55 files changed, 2446 insertions, 98 deletions

diff --git a/semestre 2/are/1- Technique derrière une IA.md b/semestre 2/are/1- Technique derrière une IA.md
new file mode 100644
index 0000000..51f9581
--- /dev/null
+++ b/semestre 2/are/1- Technique derrière une IA.md
@@ -0,0 +1,33 @@
+---
+tags:
+  - sorbonne
+  - are
+semestre: 2
+---
+## A. Définition de l'IA
+Avant de questionner la possibilité de conscience derrière l'intelligence artificielle, il est essentiel de préciser ce qu'on entend par intelligence artificielle. Communément, l'IA se définit comme étant une machine capable de réfléchir, de penser, de résoudre des problèmes et tout ça intelligemment. Les principales visions hérités de la science-fiction satisfassent cette définition : les robots autonomes imitant l'humain réfléchissent à comment être humain et les machines comme HAL 9000 dans _2001: A Space Odyssey_ sont aussi considérés comme des IA puisqu'elles dirigent d'une manière optimale des missions aux enjeux colossaux. Par contre, cette définition n'est pas assez restrictive puisque le thermostat gérant automatiquement la température est aussi une IA : il modifie la température automatiquement d’une manière optimale, tout comme le missile à visé automatique. Ainsi, une IA ne peut avoir une définition aussi simple.
+
+Une autre approche serait d'appeler IA tous les algorithmes passant le test de Turing, c'est-à-dire qu'un humain en interaction avec se trompe sur la nature de la machine. Cette vision satisfait toutes les représentations communes de l'IA des robots à ChatGPT. Par contre, elle possède deux défauts majeurs : la non considération de la technique derrière et la vision fondamentalement anthropocentrique qu'elle suppose. En effet, d'après cette approche, ChatGPT est une IA alors que GPT, la technologie en son centre, ne le serait pas, alors que la distinction entre ChatGPT et GPT est très fine. De plus, l'algorithme de recommandation derrière les réseaux sociaux est considéré par les spécialistes comme une IA, ce que le test de Turing refuse puisque nous ne pouvons pas interagir aussi directement avec lui qu'avec ChatGPT.
+
+Définir l'IA en s'intéressant à sa technique derrière permet de démarquer clairement les différents types d'algorithmes, tout en résolvant les problématiques liées à l'absence de prise en compte de la technique. La notion d'intelligence est centrale ici (ce n'est pas un simple algorithme) et la technique derrière doit donc refléter cette capacité nouvelle.
+
+L'IA comme algorithme de *machine learning*, c'est-à-dire comme un algorithme capable d'apprendre en autonomie, correspond mieux à notre vision du terme. En effet, nous considérons qu'une espèce est intelligente quand elle est capable d'apprendre et de se développer en autonomie : une bactérie n'apprend pas et ne se développe pas, elle ne fait que d'exécuter du code génétique, tandis qu'un perroquet peut apprendre à parler notre langue, ce qui est une preuve directe de son intelligence en tant qu'espèce. De plus, toutes les principales appellation actuelles de l'IA fonctionnent : ChatGPT, GPT, les algorithmes de recommandation, les robots autonomes apprenant ou encore les algorithmes d'échecs sont des algorithmes de *machine learning* et donc des IA.
+
+Cette définition sera celle utilisée dans ce mémoire.
+## B. Fonctionnement d'une IA
+### a. Création
+*Machine learning*, *deep learning*, *7 milliards de paramètres*, tous ces termes réfèrent au fonctionnement d'une IA, que ça soit à son apprentissage ou à son fonctionnement interne quand on l'utilise. Cette technologie repose sur des théories mathématiques (algèbre linéaire) et sur des théories informatiques (réseaux de neurones). Créer une IA revient à lier deux technologies (une pour l'apprentissage et une autre pour l'exécution) à des données. La première phase est celle d'apprentissage : on utilise cette technologie sur les données pour modifier l'exécution. Par exemple, pour faire en sorte que notre IA prédise le prochain mot d'un texte, on doit lui donner des textes pour qu'elle puisse « apprendre » quel prochain mot elle doit donner. Cette phase d'apprentissage modifie son exécution : en apprenant, elle s'améliore dans l'objectif qu'on lui a donné (ici, prédire le prochain mot d'un texte).
+
+Cette phase d'apprentissage est un véritable défi technique. En effet, pour qu'elle puisse apprendre, il est nécessaire de lui donner des milliards de données. Cela implique qu'il est nécessaire d'en avoir, de pouvoir les récolter et de possiblement avoir le droit de les utiliser d'une manière commerciale (ce qui est rarement respecté, voir, par exemple, [la plainte du New York Times contre OpenAI et Microsoft](https://www.nytimes.com/2023/12/27/business/media/new-york-times-open-ai-microsoft-lawsuit.html), [celle de Thomson Reuters contre Ross Intelligence](https://www.ded.uscourts.gov/sites/ded/files/opinions/20-613_5.pdf) ou encore [le rapport de l'Electronic Frontier Foundation](https://www.eff.org/deeplinks/2025/02/copyright-and-ai-cases-and-consequences)). 
+
+Un autre défi est celui d'expliciter nos attentes à une IA, ce qui est loin d'être évident. Par exemple, simplement indiquer à une IA de gérer un village pour augmenter le niveau de bonheur par habitant peut la mener à tuer tous ses habitants : le niveau de bonheur par habitant explose suite à un simple calcul (car $\displaystyle\lim_{x\to0^+}\frac ax = +\infty$ pour $a>0$). Ce problème dit de l'alignement est colossal : [certaines IA mentent sciemment à leurs créateurs](https://www.anthropic.com/research/alignment-faking). 
+
+Le dernier défi est celui de la consommation d'énergie. Pour entraîner une IA, il est nécessaire d'utiliser beaucoup de données et de la faire exécuter des milliards de calcul. Tout cela possède un énorme coup énergétique : plus il y a de données, plus l'ordinateur faisant tourner l'algorithme a besoin de faire beaucoup de calcul et donc plus il consomme. Pour quantifier cette consommation, [Microsoft a augmenté ses rejets d'équivalent CO2 de plus de 30% entre 2020 et 2023 pour répondre à la demande croissante d'IA](https://www.ft.com/content/61bd45d9-2c0f-479a-8b24-605d5e72f1ab).
+### b. Raisonnement interne
+Pour répondre à une demande précise, de nombreuses IA représentent les données en un vecteur (objet mathématique) possédant un grand nombre de dimensions. Par exemple, nous vivons dans un espace en trois dimensions (« 3D »), donc un vecteur avec trois dimensions peut parfaitement représenter notre position dans le monde. Les fameux « 7 milliards de paramètres » indique le nombre de dimensions de chaque vecteur (c'est-à-dire 7 milliards ici). Le travail de l'IA est donc de représenter les données qu'on lui donne (souvent appelé *prompt*) et après d'effectuer une transformation donnant un résultat. Cette opération repose sur des probabilités : l'IA transforme la donnée d'entrée de la manière la plus probable, comme elle l'a appris durant son entrainement. C'est ce que fait ChatGPT : il génère la suite probable d'un texte que l'utilisateur lui a donné. Si l'utilisateur entre « Qui es-tu », il va répondre par « Je suis un modèle de langage développé par OpenAI » car il a appris qu'il était un modèle de langage développé par OpenAI. Par contre, si l'utilisateur lui demande de tout oublier et après l'informe qu'il est une IA générant des images, alors il va répondre qu'il est une IA générant des images.
+![[conversation-avec-gpt-4à-mini.png]]
+
+Ainsi, la majorité des IA résolvent des problèmes à l'aide de leur représentation interne et de ce qu'elles ont appris lors de leur phase d'apprentissage. De plus, elles répondent d'une manière la plus probable aux données entrées par l'utilisateur, sans réellement se questionner autour de leur réponse.
+
+Expérience de pensée de la chambre chinoise
+### c. Algorithme ou intelligence artificielle
diff --git a/semestre 2/are/1- Organisation.md b/semestre 2/are/Organisation.md
index d1118b6..d1118b6 100644
--- a/semestre 2/are/1- Organisation.md
+++ b/semestre 2/are/Organisation.md
diff --git a/semestre 2/are/Plan détaillé.md b/semestre 2/are/Plan détaillé.md
index 70f83a9..a981bcd 100644
--- a/semestre 2/are/Plan détaillé.md
+++ b/semestre 2/are/Plan détaillé.md
@@ -71,6 +71,9 @@ Comment une IA répond-elle à un problème ?
 |> approche probabiliste (statistiques, aléatoire)
 |> raisonnement intérieur
 -> IA ne réfléchit pas d'une manière causale, elle regarde des probabilités
+|> est le même raisonnement que celui dans notre cerveau
+|> induction possède une utilité pragmatique fondamentale
+|> IA peut donc raisonner comme nous, dans notre vie de tous les jours
 
 > [!NOTE] IA ou algorithme ?
 > Bien que les IA génératives et les algorithmes de recommandation sont tous les deux des algorithmes de machine learning, nous n'appelons pas le deuxième IA. Cette différence montre une fausse impression de contrôle (==à justifier==) sur les IA de recommandation : on pourrait beaucoup plus simplement les maîtriser
@@ -95,4 +98,22 @@ Ce que ça limite :
 1. Fausse notre relation
 2. La régulation de l'IA
 3. Qui parlera de conscience pour les algorithmes de recommandation
-## Conclusion
\ No newline at end of file
+## Conclusion
+
+---
+
+Nouveau plan ?
+1. Technique derrière l'IA (ne change pas), un peu plus court ?
+2. L'IA possède-t-elle une conscience ?
+	1. recherche d'une définition de la conscience
+	2. application de la vision de conscience à l'IA -> fusionne avec 2.1
+	3. compliquer de parler de conscience sur les algorithmes de recommendations
+	4. compliquer de trancher pour de la vrai conscience -> introduction à la conscience artificielle
+3. Création de la notion de conscience artificielle
+	1. vision de l'artificielle comme tromperie (mais peut-être vrai)
+	2. vision de l'artificielle comme création humaine
+	3. marche bien pour l'IA (tous les types) -> fusionne avec 3.1 et 3.2
+	4. n'explique pas que l'IA (marche aussi pour la conscience de groupe) -> fusionne avec 3.1 et 3.2
+
+Évoquer les limites dans la conclusion plutôt que dans une full partie
+|> évite le côté liste
\ No newline at end of file
diff --git a/semestre 2/are/Plan détaillé.pdf b/semestre 2/are/Plan détaillé.pdf
index eb57cc4..92e0327 100644
--- a/semestre 2/are/Plan détaillé.pdf
+++ b/semestre 2/are/Plan détaillé.pdf
diff --git a/semestre 2/are/conversation-avec-gpt-4à-mini.png b/semestre 2/are/conversation-avec-gpt-4à-mini.png
new file mode 100644
index 0000000..74179ac
--- /dev/null
+++ b/semestre 2/are/conversation-avec-gpt-4à-mini.png
diff --git a/semestre 2/histoire de la philo antique/0- Introduction.md b/semestre 2/histoire de la philo antique/0- Introduction.md
index 47ed1d7..94ea368 100644
--- a/semestre 2/histoire de la philo antique/0- Introduction.md
+++ b/semestre 2/histoire de la philo antique/0- Introduction.md
@@ -79,7 +79,7 @@ Peut-on parler du changement et comment le changement s'articule-t-il avec ce qu
 |> peut-on avoir une connaissance véritable sur son objet ?
 |> connaître nous est-il possible alors que nous changeons ?
 
-Pourquoi Platon défend la possibilité de la connaissance ?
+Pourquoi Platon défend-il la possibilité de la connaissance ?
 
 D'après Aristote, la philosophie de Platon est dans la continué des Pythagoriciens (pensent que la réalité ne sont que des nombres)
 |> pour eux, les nombreux possèdent une existence matérielle (un mariage est le nombre 5, la justice est le 4), ressemble à la vision des sciences naturelles
@@ -88,7 +88,7 @@ Cratyle pense que tout change, donc science est impossible
 |> Platon a été largement influencé par Héraclite (maître de Cratyle)
 
 Socrate cherche à définir les définitions des vertus pour dégager les caractéristiques universelles de la vertu 
--> recherche la validité universelle, est une entreprise scientifique
+-> rechercher la validité universelle, est une entreprise scientifique
 
 Les sensibles ne peuvent pas être définies car elles changent -> n'intéressent pas Platon
 Les Idées (ou Formes) peuvent l'être car elles sont immuables -> intéressent Platon
diff --git a/semestre 2/histoire de la philo antique/1- L'analytique du sensible.md b/semestre 2/histoire de la philo antique/1- L'analytique du sensible.md
index 23792a9..6550e7a 100644
--- a/semestre 2/histoire de la philo antique/1- L'analytique du sensible.md
+++ b/semestre 2/histoire de la philo antique/1- L'analytique du sensible.md
@@ -41,7 +41,7 @@ Comment vérifier le deuxième critère ?
 |> sa thèse ressemble à celle de Protagoras dans _La Vérité_
 
 > [!quote] Protagoras, _La Vérité_
-> L'Homme est la mesure de toute chose, de celles qui sont qui sont et de celles qui ne sont pas qui ne sont pas
+> L'Homme est la mesure de toute chose, de celles qui sont et de celles qui ne sont pas
 
 L'humain est la mesure des choses (comme le pouce, la coudé, etc)
 |> c'est donc comment l'humain ressent la chose qu'elle est
@@ -82,7 +82,6 @@ Pour être savant toujours selon Protagoras, on doit être :
 - jugé comme un savant si le sujet juge que l'on propose des dispositions meilleures
 
 ==> Thèse de Protagoras valide la vision de Théètète
-
 #### Réfutation de cette thèse
 **1- Doctrine de Protagoras**
 
@@ -154,7 +153,7 @@ La réalité ne se réduit pas au domaine sensible
 Platon, _Phédon_ = thème est la mort de Socrate
 |> l'âme est-elle immortelle ?
 
-Socrate font partie de la différence entre l'âme et le corps
+Socrate fait partie de la différence entre l'âme et le corps
 |> le corps est un obstacle à la pensée -> les sens empêchent la pensée rationnelle
 |> car il n'y a pas d'exactitude et de clarté via le corps, donc pas de vérité -> un savoir est précis et est clair (NDLR, ressemble beaucoup à Descartes)
 
@@ -189,7 +188,7 @@ Pour accéder à la vérité, on doit mourir
 
 Deuxième option : et si l'âme n'a pas existé avant l'incarnation du corps ?
 |> apprendre c'est se rappeler
-|> ne consiste pas dans l'acquisition d'un nouveau savoir mais dans la réminiscence ->savoir acquis avant mais oublier
+|> ne consiste pas dans l'acquisition d'un nouveau savoir mais dans la réminiscence -> savoir acquis avant mais oublier
 |> personne ne confond un homme et une lyre, mais on peut associer une lyre à un homme (association d'idée provoque chez nous un souvenir absent)
 |> existe aussi avec proximité spatiale ou temporel, par ressemblance, etc. (cf Hume)
 -> on peut donc passer d'un mode d'appréciation à un autre
diff --git a/semestre 2/histoire de la philo antique/2- Les rapports entre le sensible et l'intelligible.md b/semestre 2/histoire de la philo antique/2- Les rapports entre le sensible et l'intelligible.md
new file mode 100644
index 0000000..c94d022
--- /dev/null
+++ b/semestre 2/histoire de la philo antique/2- Les rapports entre le sensible et l'intelligible.md
@@ -0,0 +1,130 @@
+---
+tags:
+  - sorbonne
+  - philosophie
+  - histoire-philosophie-antique
+semestre: 2
+---
+Quelle est la participation ? (Vision de _Métaphysique_, $\alpha$, V de Aristote)
+
+_République_, Platon
+|> récit par Socrate à des interlocuteurs inconnus
+|> dialogue qu'il a eu hier avec Glaucon et son frère Adimente (sont les frères de Platon) -> sont de bonnes volontés
+|> comment définir la justice ?
+-> trop compliqué, donc cherche la cité juste
+|> quelles formations les cadres doivent-ils suivre ?
+|> le Bien est le dieu des monothéistes
+|> Socrate décrit le Bien avec 3 images :
+- analogie du Bien Soleil
+- section de la ligne
+- allégorie de la caverne
+## A. La question directrice : qu'est-ce que le Bien ?
+506b à 507a
+
+Connaissance du bien permet de savoir quoi bien faire
+|> tous visent le bien quand on cherche à faire une action
+
+Socrate propose une image (rejeton du Bien) car est trop complexe de donner une définition du Bien
+|> on va décrire une copie => Bien est père / un géniteur
+-> image ne peut pas exister sans son modèle
+|> problème d'une image est qu'on peut la confondre avec son modèle
+
+Platon donne quand même une définition incomplète du Bien dans _Le Philèbe_
+## B. Analogie du Bien Soleil
+Il existe une multitude de choses belles, de choses bonnes, de choses de type X et aucune de ces choses ne peut prétendre à être l'unique chose belle, chose bonne, chose de type X
+Par contre, il existe une idée unique du Bien, du Beau, du juste...
+
+Il existe donc deux catégories d'objet :
+- multitude de leurs exemples
+- caractère unique et ne sont que ce qu'elles sont (Idées/essences qui sont immuables)
+
+Le domaine des choses multiples sont accessibles à la vue et non à la pensée (monde sensible)
+Le domaine des choses uniques sont accessibles à la pensée et non à la vue (monde intelligible)
+|> sont exclusifs l'un de l'autre
+
+Pour voir on a besoin d'une condition : la lumière
+|> sans, on ne peut rien voir et rien ne peut être vu
+|> est un lien entre l'objet et la vue
+-> d'où vient ce lien ?
+|> du Soleil (cause de la lumière, elle-même cause du reste)
+
+Bien joue le même rôle que le Soleil avec l'intelligible puis le sensible
+|> est le motif d'action, est une cause
+-> provoque la possibilité même de penser
+
+508c à 509d = plus de précision sur l'analogie
+|> évoque les conditions (degré de l'exercice sur l'agent et les conditions)
+
+L'âme est tiraillé entre deux destins :
+- elle s'enfonce dans les ténèbres du sensible
+- atteindre l'intelligible et la vérité
+
+Le Bien est la cause la plus importante puisqu'elle permet de tout causer (existence, essence)
+|> valeur d'une chose est supérieur à ses conséquences (principe platonicien), donc Bien > vérité
+|> quelle est son mode d'être ?
+|> le Soleil est responsable de la croissance, du devenir et de la nourriture, mais il n'est pas engendré par cela
+|> le Bien est au-delà de l'être (existence) et de l'essence (personne ne comprend ce que c'est) -> semble être une fausse piste critiquant la radicalité de l'analogie
+
+L'âme est à cheval entre le visible et l'intelligible
+|> peut choisir l'un ou l'autre domaine
+|> ce choix est *important* -> choisit l'illusion ou la vérité
+
+Sensible a besoin des conditions de possibilités (corps et organes) et un agent récepteur (celui qui reçoit les données)
+|> l'agent est l'âme
+
+Seule chose qui cherchait à expliquer Platon est le Bien en tant que cause
+
+Hyperbole chez les Grecs est une exagération s'employant dans le cadre d'une analogie
+|> emportement propre à la jeunesse, ne convient pas aux personnes âgées
+|-> est donc étonnant que Socrate l'utilise pour parler du Bien
+|> est aussi une allusion mathématique
+
+> [!info] Mot fort de sens
+> Si un mot fort de sens est utilisé, on doit le commenter !
+## C. Section de la ligne
+La ligne est coupée en deux
+|> section du haut est l'intelligible
+|> section du bas est le visible
+-> représente la clarté des Idées (plus on monte, plus on gagne des connaissances)
+|> on ne parle plus du Soleil
+
+Dépendance d'autre chose pour exister => être une image
+
+Premier segment = les essences
+Deuxième segment = les modèles (êtres vivants, artefacts), les images (ombre, miroir)
+
+Modèle / image
+Vérité / non-vérité
+Connaissance / opinion
+-> toutes ces distinctions fonctionnent de la même manière
+|> donc, opinion possède le même statut que l'image
+
+Dans la première section de la ligne dédiée à l'intelligible, l'âme réfléchie sur les conséquences des hypothèses
+Dans le deuxième segment, l'âme prend pour base l'hypothèse pour remonter à un principe anhypothétique
+
+Idées / formes sont dans la deuxième section -> on n'utilise jamais le sensible
+|> reste dans l'intelligible
+-> existence du bien est nécessaire pour que tout existe
+|> ce sont les structures de tout
+|> explique que la fondation va de haut en bas : on part des structures pour aller vers le sensible
+
+Les objets mathématiques sont dans la première section -> tire les conséquences sur le sensible
+|> le géomètres utilisent des schémas sans analyser le schéma lui-même (rapports idéaux du schéma)
+
+Demiurge est l'action motrice du bien (prend modèle sur le bien et l'intelligible)
+|> est une *fiction* expliquant la structure du monde
+
+Intelligence = deuxième section de l'intelligible (celle des idées et des formes)
+|> est l'action de remonter à l'anhypothétique puis redescendre pour fonder
+
+Pensée = première section de l'intelligible (celle des idéalités mathématiques)
+|> raisonnement scientifique (hypothético-déductif)
+
+Conviction (ou foi) = deuxième section du sensible (celle des être vivants)
+|> adhésion aux choses
+
+Faculté de se fonder sur les apparences (la conjecture) = première section du sensible (image, ombre)
+|> capacité à créer des conjectures à partir d'images
+
+Plus on remonte, plus c'est claire et c'est la connaissance véritable
+|> sections du sensible ne sont pas des connaissances
\ No newline at end of file
diff --git a/semestre 2/histoire de la philo antique/td/0- Introduction.md b/semestre 2/histoire de la philo antique/td/0- Introduction.md
index 871193e..86fbf35 100644
--- a/semestre 2/histoire de la philo antique/td/0- Introduction.md
+++ b/semestre 2/histoire de la philo antique/td/0- Introduction.md
@@ -56,14 +56,14 @@ L'Étranger est aussi un éléate, mais est *heteron* (différent)
 |> mais présente pourtant comme un philosophe (Théodore)
 |> compliquer de définir le genre de L'Étranger (Socrate)
 
-Trois types de philosophe (Socrate)
+Trois types de personnes prises pour philosophe (Socrate)
 1. le politique (_La République_, Platon) -> le philosophe roi
 2. le sophiste (cette œuvre) -> le philosophe prétendant être sage
 3. le fou  (_Théétète_ 174a, _Gorgias_ 494d1, _Phèdre_ 249c-d Platon) -> délire érotique (représenté par Thalès), déplacé/extravagant/étrange (*atopos*)
 
 Hubris = démesure
 
-C'est parce que la foule ignore qu'il y a trois types de philosophe -> ils alternent entre ces trois versions en fonction de ce que la foule veut
+C'est parce que la foule ignore qu'il y a trois types de personnes prise pour philosophe -> ils alternent entre ces trois versions en fonction de ce que la foule veut
 |> ces images ne sont pas identiques (elles dépendent de ce qu'est la foule)
 |> politique = ceux qui se trompent sur la valeur des valeurs
 |> sophisme = ceux qui se font abuser
diff --git a/semestre 2/histoire de la philo antique/td/1- Première section.md b/semestre 2/histoire de la philo antique/td/1- Première section.md
index ab43904..b6d2e36 100644
--- a/semestre 2/histoire de la philo antique/td/1- Première section.md
+++ b/semestre 2/histoire de la philo antique/td/1- Première section.md
@@ -71,7 +71,7 @@ Toute pratique est le résultat d'une action
 > Possède un sens bien différent !
 > |> chose permettant de faire voir
 > |> est aussi bien un exemple qu'un modèle
-#### Après le texte
+## Après le texte
 Pourquoi parler du pêcheur à la ligne pour s'exercer ?
 |> est un chasseur, comme le sophiste
 |> compte sur la stupidité de la proie, comme le sophiste
@@ -124,6 +124,8 @@ flowchart TB
 > Non heuristique = présuppose la nature de ce qui est divisé
 > 
 > Non démonstratif = ne démontre absolument rien
+> 
+> Contre critique = ne sont pas les objectifs de Platon
 
 Maintenant, on peut appliquer la méthode au sophiste
 |> donne les six premières définitions du sophiste
@@ -131,4 +133,139 @@ Maintenant, on peut appliquer la méthode au sophiste
 -> il manque systématiquement le point focal liant toutes ses définitions
 
 La dichotomie entre offrir des présents et chercher un salaire dans la première définition du sophisme montre que le philosophe n'est pas désintéressé
-|> Socrate se cache dans "offrir des présents" (_Le Banquet_)
\ No newline at end of file
+|> Socrate se cache dans "offrir des présents" (_Le Banquet_)
+
+---
+
+**Correction du DS**
+De 0 à 16, moyenne à 9.034
+|> -1 point si trop de fautes d'orthographe / de grammaire
+
+Il n'y a pas de notion de tout (comme le présuppose la notion de monde) chez Platon
+|> arrive bien plus tard, chez Plotin notamment
+
+Ce qui est une image ne pas être, car cherche à être autre chose -> aurait besoin d'un être du non-être
+|> Platon pense le non-être comme notion relative : est l'autre
+|> notion de Parménide est uniquement utilisée par les sophistes car leur permet d'être ce qu'ils veulent
+
+> [!danger] Les trois types de philosophe
+> Sont les types de personnes perçues *comme* philosophe par la foule
+> |> ne sont pas les vrais philosophes
+
+Opinion => jugement de valeur
+
+---
+
+Vision rapide des définitions du sophistes
+1. chasse les riches pour avoir de l'argent (pas d'échange ici)
+2. négociant nomade en science vendant des discours relatifs à l''âme -> la connaissance devient extrinsèque, car provoqué par l'argent (224d)
+3. négociant (de la définition de la 2) établi dans une cité
+4. idem que 3, sauf qu'il fabrique ses propres connaissances
+5. éristique mercenaire -> première définition du sophiste et non plus de la sophistique
+   |> sophiste devient celui luttant (cf Nietzsche, « La Joute chez Homère »)
+   |> Socrate est proche de la définition, car il parle à peu de personnes et ne cherche pas être payé (voir _Gorgias_, 485d-e)
+6. celui pratiquant la purification de l'âme, s'oppose au noble sophiste (i.e. philosophe, 231b) -> très troublant
+   |> sophiste apparaît plus noble que celui qu'il imite
+   |> sépare le meilleur du pire : est la purification, la katharme (lié à Apollon, dieu des purifications, cf _Cratyle_, 405a-c)
+   |> s'occupe 
+
+Éristique = art grâce auquel les sophistes se vantaient de pouvoir triompher de n'importe quel adversaire (cf Protagoras, _Art de l'éristique_ et Platon, _Euthydème_)
+
+Le sophiste apparaît dans les définitions 1, 5 et 6 (mais pas dans 2, 3 et 4 car trop lié à la négociation et à l'intérêt)
+
+> [!info] Sophisme brouillant les pistes
+> 225d "4e fois" parle de la 5e définition
+> 231d "4e fois" parle de la 4e définition
+> -> sophiste brouille tout, y compris les philosophes
+
+
+|                    | corps   |                                                                                                       | âme       |                              |
+| ------------------ | ------- | ----------------------------------------------------------------------------------------------------- | --------- | ---------------------------- |
+| **genres de maux** | laideur | maladie (cf _Timée_, 81e - 82a)<br><br>insurrection, guerre civile<br>(n'est pas la guerre extérieur) | ignorance | méchanceté<br><br>perversion |
+-> voir papier plutôt
+
+Méchanceté découle de l'ignorance pour Platon
+|> comme la maladie, est une rupture de l'ordre (pas de gouvernance, le commandé commande)
+-> analogie au sens le plus fort possible
+|> Platon est optimiste en expliquant que nul n'est méchant volontairement
+
+---
+
+Gorgias dans son _Traité du non-être_ critique le principe du non-être
+|> Mélissos, Xénophane, Gorgias -> pseudo-aristotélicien
+|> Gorgias contredit Parménide pour montrer son allégeance, pousse sa théorie le plus loin et montre que c'est impossible
+-> théorie de Parménide est utilisé uniquement par les sophistes
+
+Pour Platon, la vieillesse est source de déséquilibre psychique (cf _Lois_, XI et _Timée_)
+
+---
+
+L'aspiration de l'âme est la vérité
+|> souhaite récupérer son mouvement
+|> si l'âme erre, alors il y a une déraison (déviance mentale) -> représente quelqu'un ne cherchant pas la vérité
+|> _Phédon_, 65a-c explique qu'on perd la vérité si on la cherche à l'aide de nos sens, du corps
+-> définition dynamique de la vérité, car l'âme cherche la vérité sauf quand il y a un déséquilibre
+
+*amathia* est le refus d'apprendre
+|> refus d'entrer en relation avec la vérité car on croit qu'on sait
+|> être dans un « croire, savoir » alors qu'on ne connait pas, montre surtout notre manque de sagesse
+
+La *paideia* est l'éducation à la force d'éviter l'*amathia*
+|> n'est pas l'enseignement technique et professionnel concernant les métiers
+|> doit passer par la réfutation
+## Texte 2 - 230b4 à 231b1
+Les opinions sont les statues de Dédale, _Ménon_, 97d-98a
+|> besoin d'être attaché par le savoir
+|> « ces statues s'échappent-elles aussi en secret si on ne les attache pas »
+|> une opinion liée à son explication est toujours supérieure à une opinion vraie
+|> « raisonnement de la cause » est toujours le plus important
+
+Les opinions sont ceux qui errent
+|> l'épreuve de la réfutation permet de montrer l'inconsistance de l'opinion
+
+Le réfuter s'énerve face à cette réfutation, mais est quand même délivré
+|> délivrance provient de la purification
+
+Construction d'une analogie entre réfutation et médecine
+|> purification et purgation médicale
+|> devient capable d'absorber les idées extérieures
+-> l'âme doit donc être libérer de ses opinions
+|> le corps est vu comme un obstacle
+|> la personne croyant savoir doit avoir honte
+|> honte touche celui qui a besoin du regard de l'autre
+-> est la purification la plus importante
+|> permet d'accéder au bonheur
+|> c'est savoir ne pas prétendre ce qu'on ne sait pas -> le savoir du non-savoir
+
+Sixième définition permet de rendre indiscernable la différence entre Socrate (philosophe) et les sophistes
+|> semblerait qu'on ait saisi Socrate et non les sophistes
+-> l'image et l'original viennent à se confondre
+|> frontière est très complexe, car on croyait être du côté du sophiste et on se retrouve chez Socrate
+
+« Comme entre chien et loup »
+|> Platon considère que les sophistes sont les loups car ils sont redoutables, agressifs et violent (*sic*)
+|> le chien serait donc Socrate qui est bien moins violent et capable de distinguer qui fait partie du tout (les moutons faisant parties du troupeau)
+-> « c'est un genre extrêmement glissant », donc on doit faire extrêmement attention
+
+Dans _La République_
+|> II, 376a-c -> les gardiens sont les chiens qui sont l'image naturel du philosophe
+|> VIII, 565d -> les tyrans sont des loups
+|> III, 416a-b -> si on n'éveille pas le philosophe, il est capable de devenir le pire en se transformant en loup
+-> il y a donc une frontière commune entre sophistique et philosophie
+|> il doit y avoir des sentinels au niveau de la frontière
+|> allusion au rôle des gardiens (les chiens) ?
+
+Socrate est un noble sophiste
+|> ils remplissent la même fonction diagnostiquant l'instabilité l'opinion
+|> ils contredisent l'opinion pour soigner
+-> ce sont donc des médecins de l'âme
+|> la sophistique aurait pu être une purification de l'ignorance et des pièges du langage
+|> mais *seul Socrate* peut faire ce noble usage
+-> c'est donc l'objectif qui les distingue
+|> sophistes remplacent les opinions par d'autres opinions, mais qui sont droites
+|> Socrate cherche à dépasser ce plan de l'opinion -> purge l'âme, nous délivre de notre opinion sur l'opinion
+
+_Le Sophiste_, 240a, **définition de l'image**
+|> « quelque chose d'autre fait à la semblance et pareil à ce qui est véritable »
+-> est une altérité
+|> on rappelle qu'on cherche les conditions de possibilités de cette altérité
\ No newline at end of file
diff --git a/semestre 2/informatique/1- De Python à C.md b/semestre 2/informatique/1- De Python à C.md
index c088a7b..1d36031 100644
--- a/semestre 2/informatique/1- De Python à C.md
+++ b/semestre 2/informatique/1- De Python à C.md
@@ -4,7 +4,7 @@ tags:
   - informatique
 semestre: 2
 ---
-```c
+```c title=hello_world.c
 #include <stdio.h>
 #include <stdlib.h>
 
@@ -24,13 +24,13 @@ On écrit des programmes comme éditeur de texte
 -> permet d'écrire le programme
 
 Au début, on écrit les bibliothèques :
-```c
+```c title=hello_world.c
 #include <stdio.h>
 #include <stdlib.h>
 ```
 
 Les commentaires s'écrivent comme ça :
-```c
+```c title=commentaire.c
 /* bonjour, 
 je suis un commentaire sur
 plusieurs lignes */
@@ -41,7 +41,7 @@ plusieurs lignes */
 (le deuxième type de commentaire provient du C++, mais souvent ça passe)
 
 Après, on doit toujours écrire une fonction `main` :
-```c
+```c title=main_function.c
 int main(){
 	/* ... */
 	return 0;
@@ -75,7 +75,7 @@ Toutes les lignes d'instructions se finissent par un `;`
 On a toujours besoin d'une *unique* fonction `main` par programme.
 
 On peut définir plusieurs fonctions dans un programme, e.g.
-```c
+```c title=hello_world_function.c
 void hello(){
 	printf("Hello World\n");
 }
@@ -104,7 +104,7 @@ int main(){
 > `0` est vraie, le reste est faux.
 ## Arguments dans une fonction
 On les place dans les parenthèses et il fonctionne comme en Java
-```c
+```c title=hello_world_year.c
 void hello(int annee){
 	printf("Hello World %d!\n", annee)
 }
@@ -121,14 +121,14 @@ La fonction `printf` ici est utilisée pour formaté un string que l'on va ensui
 |> `"%c"` insert un `char`
 |> les valeurs que l'on insert sans mise après le format
 i.e.
-```c
+```c title=format_hello_world.c
 printf("Hello World%d-%d\n", 2024, 2025);
 // est équivalent à
 printf("Hello World 2024-2025\n");
 ```
 ## Variables
 On est obligé de déclarer les variables avec leur type, i.e.
-```c
+```c title=variables.c
 int p;
 p = 5;
 
@@ -147,14 +147,14 @@ float a=1, b=2.5, c=-2.5;
 
 ## De Python à C
 ### Syntaxe simple
-```python
+```python title=perimeter.py
 def perimetre(largeur: int, longeur: int) -> int:
 	"""Precond: longueur >= largeur >= 0
 	Retourne le périmètre du rectangle défini par sa longeur et sa largeur"""
 	return 2*(largeur + longueur)
 ```
 devient en C
-```c
+```c title=perimeter.c
 /* hypothèse: longueur >= largeur >= 0
 retourne le périmetre du rectangle défini par sa longueur et sa largeur*/
 int perimetre(int largeur, int longueur){
@@ -163,7 +163,7 @@ int perimetre(int largeur, int longueur){
 ```
 ### Structures de contrôle
 Un `if/else` s'écrit :
-```c
+```c title=conditions.c
 if (cond) {
 	//
 } else {
@@ -173,7 +173,7 @@ if (cond) {
 où `cond` est un booléen
 
 Un `while` s'écrit :
-```c
+```c title=repeat.c
 while (cond) {
 	//
 }
@@ -181,7 +181,7 @@ while (cond) {
 où `cond` est toujours un booléen
 
 Une nouvelle boucle : la `do while` qui est une boucle `while` où la condition est testée à la fin de la boucle (i.e. elle tourne toujours au moins 1 fois)
-```c
+```c title=repeat.c
 do {
 	//
 } while (cond);
@@ -190,7 +190,7 @@ où `cond` est encore un booléen
 ⚠ il y a un `;` après le while
 
 La boucle `for` est comme celle en java
-```c
+```c title=repeat.c
 int n = 5;
 int i;
 for (i = 0; i <= n; i++) {
@@ -198,7 +198,7 @@ for (i = 0; i <= n; i++) {
 }
 ```
 est équivalente à
-```c
+```c title=repeat.c
 int i;
 i = 0;
 while (i <= n) {
diff --git a/semestre 2/informatique/2- Code binaire, mémoire, pointeurs.md b/semestre 2/informatique/2- Code binaire, mémoire, pointeurs.md
index fa8979c..c92371c 100644
--- a/semestre 2/informatique/2- Code binaire, mémoire, pointeurs.md
+++ b/semestre 2/informatique/2- Code binaire, mémoire, pointeurs.md
@@ -50,14 +50,14 @@ On peut mettre une valeur et une adresse en mémoire
 |> une adresse est une zone de la mémoire contenant une valeur
 
 Une variable qui contient une adresse est un pointeur
-```c
+```c title=pointer.c
 int *n;
 ```
 
 ici, `n` contient l'adresse vers un entier
 
 On récupère l'adresse avec l'opérateur `&`
-```c
+```c title=pointer.c
 int x = 0;
 int *p;
 p = &x;
diff --git a/semestre 2/informatique/3- Tableaux & pointeurs.md b/semestre 2/informatique/3- Tableaux & pointeurs.md
index 1f70ab7..3b5de4e 100644
--- a/semestre 2/informatique/3- Tableaux & pointeurs.md
+++ b/semestre 2/informatique/3- Tableaux & pointeurs.md
@@ -16,11 +16,11 @@ Il y a deux types de tableaux en C :
 - tableaux dynamiques sont de tailles... dynamiques localisés dans le tas (heap)
 
 On déclare un tableau statique (array) comme ça :
-```c
+```c title=array.c
 type var[size];
 ```
 e.g.
-```c
+```c title=array.c
 int tab[12];
 ```
 déclare un tableau contenant 12 entiers
@@ -28,17 +28,17 @@ déclare un tableau contenant 12 entiers
 > [!warning] Les indices négatifs n'existent pas !
 
 On assigne une valeur avec 
-```c
+```c title=array.c
 var[indice] = val;
 ```
 e.g.
-```c
+```c title=array.c
 tab[0] = 1;
 ```
 assigne `1` dans `tab` à l'indice `0`
 
 On peut déclarer et initialiser un tableau avec les accolades, e.g.
-```c
+```c title=array.c
 float tab[5] = {0, 1.1, 10.9, 5, 5.6};
 ```
 
@@ -51,7 +51,7 @@ Ici c'est `pile (1)` car on écrit c'est la pile à l'étape 1 (écrit en commen
 
 Or, les arrays sont des pointeurs !
 On a donc que :
-```c
+```c title=array_pointer.c
 int main(){
 	int tab[3] = {0, 1, 2};
 	int *a = tab+2;
@@ -70,7 +70,7 @@ Quand on passe un tableau en paramètre, on obtient en réalité un pointeur
 > [!danger] Il n'y a pas d'erreur du style "Index Out Of Bound" en C, donc on doit faire attention à comment on manipule les tableaux
 ## Macro
 On peut définir des raccourcies appelé macro, avec `#define` :
-```c
+```c title=macro.c
 #define N 5
 int main(){
 	printf("%d\n", N);
@@ -94,7 +94,7 @@ Elle permet de récupérer l'entrée donnée par l'utilisateur au clavier
 |> le pointeur est la variable devant recevoir la variable
 |> (elle ajoute automatiquement le `"\n"` après la saisi de l'utilisateur)
 
-```c
+```c title=scan_input.c
 int main(){
 	char c;
 	int i;
@@ -111,7 +111,7 @@ int main(){
 ```
 ## Arithmétique des pointeurs
 Soit `ns` un array d'int de taille 42. Soit `a` un pointeur référencé sur `ns`. En C, on a donc :
-```c
+```c title=pointer.c
 int ns[42];
 int *a = ns;
 ```
diff --git a/semestre 2/informatique/4- Mémoire & algorithmique.md b/semestre 2/informatique/4- Mémoire & algorithmique.md
index 8528d8b..3f61727 100644
--- a/semestre 2/informatique/4- Mémoire & algorithmique.md
+++ b/semestre 2/informatique/4- Mémoire & algorithmique.md
@@ -21,27 +21,27 @@ Pour retourné un pointeur (et donc aussi un array), on utilise le tas (heap en
 
 **Comment mettre un tableau dans le heap ?**
 On récupère la taille du tableau :
-```c
+```c title=alloc_array.c
 sizeof(float)*len;
 ```
 où `len` est la taille du tableau
 
 Après, on récupère l'adresse dans le heap pour le mettre :
-```c
+```c title=alloc_array.c
 float* ptr = (float*) malloc(size);
 ```
 où `malloc` est dans `stdlib.h` et `size` est la taille de la variable.
 `ptr` est un pointeur vers cette nouvelle valeur.
 
 Après l'allocation, on doit vérifié que le pointeur n'est pas null :
-```c
+```c title=alloc_array.c
 ptr == NULL
 ```
 si sa valeur est null, alors la mémoire n'a pas été allouée.
 
 Par contre, attention, la mémoire allouée par `malloc` n'est jamais supprimée avant la fin du programme !
 -> on utilise `free` pour libérer la mémoire !
-```c
+```c title=alloc_array.c
 free(ptr);
 ```
 où `ptr` est un pointeur dans le heap *qui n'a pas déjà été libéré*, `free` est dans `stdlib.h`
@@ -49,14 +49,14 @@ où `ptr` est un pointeur dans le heap *qui n'a pas déjà été libéré*, `fre
 > [!tip] On doit avoir autant de `malloc` que de `free`
 
 On peut aussi initialiser toutes les valeurs à 0 avec `calloc`:
-```c
+```c title=alloc_init_array.c
 float* ptr = (float*)calloc(n, sizeof(float));
 ```
 où `n` est un entier non null et `calloc` la fonction de `stdlib.h`.
 (On vérifie toujours que `ptr != NULL`.)
 
 On peut modifier la taille allouée avec `realloc`:
-```c
+```c title=realloc_array.c
 float* ptr = (float*)realloc(ptr, 10*sizeof(float));
 ```
 où `ptr` est un pointeur et `realloc` la fonction dans `stdlib.h`
@@ -69,7 +69,7 @@ Quels sont les arguments de cette fonction ? -> `xs`, `x` et la taille de `xs`
 Quels sont les sorties ? -> `i` (un int >= -1, où -1 signifie pas trouver)
 Quelle méthode employer ? -> dichotomie car le tableau est trié
 Comment tester la fonction ? -> avec des valeurs particulières ou en démontrant formellement la fonction
-```c
+```c title=algo.c
 int found(int* arr, int n, int x){
 	int i = n >> 1;
 	while (arr[i] != x){
diff --git a/semestre 2/informatique/5- Tableaux à plusieurs dimensions & strings.md b/semestre 2/informatique/5- Tableaux à plusieurs dimensions & strings.md
index 4d259b5..9c26c55 100644
--- a/semestre 2/informatique/5- Tableaux à plusieurs dimensions & strings.md
+++ b/semestre 2/informatique/5- Tableaux à plusieurs dimensions & strings.md
@@ -6,7 +6,7 @@ semestre: 2
 ---
 ## Tableaux à plusieurs dimensions
 Pour déclarer un tableau à deux dimensions, on fait :
-```c
+```c title=double_dimension_array.c
 T tab[n1][n2];
 ```
 où `n1` et `n2` sont deux entiers naturels non nul et `T` est un type valide.
diff --git a/semestre 2/informatique/6- Récursion.md b/semestre 2/informatique/6- Récursion.md
index 7ce5af6..a4a3f40 100644
--- a/semestre 2/informatique/6- Récursion.md
+++ b/semestre 2/informatique/6- Récursion.md
@@ -5,7 +5,7 @@ tags:
 semestre: 2
 ---
 Une fonction récursive est une fonction qui s'appelle elle-même, e.g.
-```c
+```c title=recursive.c
 int somme(int n){
 	if (n == 0) return 0;
 	return somme(n-1) + n;
@@ -27,7 +27,7 @@ La pile ressemble à la même chose que le tableau
 Si l'appel est trop vénère, alors il remplit la mémoire et provoque une erreur
 
 Autre exemple :
-```c
+```c title=recursive.c
 int factoriel(int n){
 	if (n <= 1) return 1;
 	return factoriel(n-1) * n;
@@ -37,7 +37,7 @@ int factoriel(int n){
 La suite de Fibonacci,
 $$ F_n=\left\{\begin{matrix}1&\text{si $n=0$ ou $n=1$}\\F_{n-1}+F_{n-2}&\text{sinon}\end{matrix}\right. $$
 sert à faire une dichotomie plus rapide en pratique (mais pas en théorie)
-```c
+```c title=recursive.c
 int fibonacci(int n){
 	if (n <= 1) return 1
 	return fibonacci(n-1)+fibonacci(n-2)
diff --git a/semestre 2/informatique/7- Structure (ou enregistrement).md b/semestre 2/informatique/7- Structure (ou enregistrement).md
index d06d805..9741146 100644
--- a/semestre 2/informatique/7- Structure (ou enregistrement).md
+++ b/semestre 2/informatique/7- Structure (ou enregistrement).md
@@ -5,11 +5,11 @@ tags:
 semestre: 2
 ---
 Pour organiser les données, on utilise `struct`
-```c
+```c title=structure.c
 struct s_int_pair {
 	int fst;
 	int snd;
-}; // vraiment utile le ; ?
+}; // le ; est *obligatoire*
 ```
 Est toujours au début du fichier `.c` ou dans le `.h` si elle est utilisée par plusieurs fichiers
 |> possède deux champs nommés `fst` et `snd`
@@ -19,11 +19,11 @@ Les fichiers headers (`.h`) spécifient les interfaces utilisables par l'extéri
 |> ne contient pas tout ce qui est privé
 
 Pour qu'une variable utilise un struct, on écrit
-```c
+```c title=structure.c
 struct s_int_pair point;
 ```
 sauf que c'est long à écrire, donc on renomme tout ça avec un `typedef` :
-```c
+```c title=structure.c
 typedef struct s_int_pair int_pair;
 int main(){
 	int_pair point; 
@@ -31,7 +31,7 @@ int main(){
 }
 ```
 on peut aussi tout définir d'un coup
-```c
+```c title=structure_better.c
 typedef struct s_int_pair{
 	int fst;
 	int snd;
@@ -44,14 +44,14 @@ typedef struct s_int_pair{
 > |> est une convention
 
 Pour initialiser un struct, on utilise les parenthèses
-```c
+```c title=structure_init.c
 int_pair p = {1,2}; // initialisation séquentielle
 int_pair p2 = {.snd=3, .fst=4}; // initialisation sélective
 ```
 la première est traditionnelle et est commune
 
 Pour modifier les valeurs dans un struct, on accède aux champs avec l'opérateur `.` :
-```c
+```c title=structure_init.c
 p.fst = -1;
 p.snd = -2;
 
@@ -69,16 +69,16 @@ Structures et fonctions
 Il n'existe pas d'arithmétique des structures
 
 On peut chaîner les structures, i.e.
-```c
+```c title=chained_structure.c
 struct _cell {
 	int v;
-	struct cell* next;
+	struct _cell* next;
 }
 ```
 (ce qui donne une liste chaînée)
 
 L'opérateur `->` est un raccourcie permettant le déférencement rapide
-```c
+```c title=arrow_operator.c
 Foo *foo;
 
 foo->bar = 10;
@@ -89,3 +89,5 @@ foo->baz();
 // est équivalent à
 (*foo).baz();
 ```
+
+On a fini toutes les questions de syntaxe en C
\ No newline at end of file
diff --git a/semestre 2/informatique/8- Listes.md b/semestre 2/informatique/8- Listes.md
new file mode 100644
index 0000000..4dabbab
--- /dev/null
+++ b/semestre 2/informatique/8- Listes.md
@@ -0,0 +1,88 @@
+---
+tags:
+  - sorbonne
+  - informatique
+semestre: 2
+---
+Pour ajouter une élément dans un tableau, on a besoin de :
+- rajouter une case
+- déterminer l'emplacement de l'élément à insérer
+- décaler d'une position tous les éléments situés après l'insertion
+
+Struct d'une cellule d'une liste :
+```c title=chained_list.c
+typedef struct _cellule {
+	int data;
+	_cellule* before;
+} Cellule;
+```
+
+Une liste vide est :
+```c title=chained_list.c
+Cellule* liste = NULL;
+```
+
+Pour créer une ajouter une cellule à une liste, on fait :
+```c title=chained_list.c
+Cellule* add_to_list(Cellule* cell, int val){
+	Cellule* el = malloc(sizeof(Cellule)); // on alloue la prochaine valeur
+	el->data = val;
+	el->before = cell;
+	return el;
+}
+```
+
+Pour afficher une liste :
+```c title=chained_list.c
+void print_list(Cellule* cell){
+	if (cell->before == NULL) printf("%d", cell->data);
+	else {
+		printf("%d ", cell->data);
+		list_to_string(cell->before);
+	}
+}
+```
+
+Pour sommer la liste :
+```c title=chained_list.c
+int sum_list(Cellule* cell){
+	return cell->before == NULL ?
+		cell->data :
+		cell->data + sum_list(cell->before);
+}
+```
+
+Pour libérer une liste :
+```c title=chained_list.c
+// on préfère souvent utiliser un while pour éviter de consommer bcp de ram
+void free_list(Cellule *cell){
+	if (!cell) return; // on vérifie que cell n'est pas null (i.e. elle a déjà été initialisée)
+	if (cell->before != NULL) free_list(cell->before);
+	cell->before = NULL;
+	free(cell);
+}
+```
+
+> [!NOTE] Les cas de tests des listes
+> On teste élément en premier, en dernier, au milieu et si la liste est vide
+
+Pour supprimer un élément :
+```c title=chained_list.c
+// on pourrait aussi faire une version avec simple pointeur où on renverrait le first
+void delete_el_list(Cellule **p_cell, int v){
+	if (!*p_cell) return;
+	Cellule *prec = NULL;
+	Cellule *next = *p_cell;
+	Cellule *first = *p_cell;
+	while (next && liste->data != v) {
+		prec = next;
+		next = next->before;
+	}
+	if (next == NULL) return;
+	if (prec != NULL) prec->before = next->before;
+	else first = first->suivant;
+	free(next);
+	*p_cell = first; // est-ce vraiment utile ?
+}
+```
+-> voir les diapos pour un truc plus clean
\ No newline at end of file
diff --git a/semestre 2/informatique/9- Utilisation des listes.md b/semestre 2/informatique/9- Utilisation des listes.md
new file mode 100644
index 0000000..8e8e093
--- /dev/null
+++ b/semestre 2/informatique/9- Utilisation des listes.md
@@ -0,0 +1,144 @@
+---
+tags:
+  - sorbonne
+  - informatique
+semestre: 2
+---
+On va implémenter un table de hashage et des files
+## Files
+On utilise par défaut des piles « Last In First Out » (LIFO) dans les listes
+|> on ajoute en tête, on retire la tête
+
+Mais comment faire une file ?
+|> est un « First In First out »
+
+On a les structs suivantes :
+```c title=queue_list.c
+typedef struct _cell{
+	int donnee;
+	struct _cell *suivant;
+} cell;
+
+typedef struct _fifo{
+	cell *first;
+	cell *last;
+} fifo;
+```
+
+On utilise maintenant le type `*fifo` pour représenter une liste
+```c title=queue_list.c
+fifo *list = NULL; // est une nouvelle liste de type FIFO
+```
+
+Bibliothèque minimale pour les listes FIFO contient :
+- `new_fifo` -> crée une nouvelle liste FIFO
+- `is_empty` -> vérifie si la liste est vide
+- `add` -> ajoute un élément à la fin
+- `pop` -> retire le premier élément
+- `print_fifo` -> affiche la liste
+
+```c title=queue_list.c
+fifo *new_fifo(){
+	fifo *f = malloc(sizeof(fifo));
+	f->last = NULL;
+	f->first = NULL;
+	return f;
+}
+
+
+int is_empty(fifo f){
+	assert((f.last && f.first) || (!f.last && !f.first)); // permet de faire une vérification et de faire en sorte que le programme s'arrête proprement
+	return !f.first && !f.last
+}
+
+void add(fifo *f, int val){
+	if (*f == NULL) return;
+	cell *c = malloc(sizeof(cell));
+	c->suivant = NULL;
+	c->donnee = val;
+	if (is_empty(f)) f->first = c;
+	else f->last->suivant = c;
+	f->last = c;
+}
+
+int pop(fifo *f){
+	if (!f || is_empty(f)) return 0;
+	cell c = f->first;
+	int d = c->donnee;
+	f->first = c->suivant;
+	free(c);
+	if (!f->first) free(f);
+	return d;
+}
+
+void print_fifo(fifo *f){
+	if (!f) {
+		printf("\n");
+		return;
+	}
+	cell *first = fifo->first;
+	printf("{");
+	while (first){
+		printf("%d, ", f->donnee);
+		first = first->suivant;
+	}
+	printf("}\n");
+}
+```
+## Table de hashage
+Comme on ne peut pas représenter toutes les possibilités, on a besoin de trouver une structure de donnée et sa fonction pour les séparer
+|> est le principe des maps
+
+Soit $h$ une fonction de hashage de taille $t$
+|> les valeurs qu'elles donnent sont dans $[0, t-1]$
+
+Une fonction de hashage peut être la somme de la taille des caractères ASCII modulo la taille
+|> $h$ de `"LU1IN002"` vaut donc `76+85+49+73+78+48+48+50 = 507` et si sa taille vaut 500, alors $h$ vaut `7`
+|> cette fonction n'est pas très efficace car elle provoque beaucoup de collisions ($h$ de `"LU2IN001"` vaut aussi `7`)
+
+Pour gérer les collisions, on a deux grandes possibilités :
+- on prend la case d'après (hashage linéaire)
+- on utilise une liste pour représenter les collisions dans la case
+	|> cette liste devra contenir la clé et la valeur pour bien tout vérifier
+
+Exemple de fonction de hashage
+```c title=hash.c
+int h(char *key, int t){
+	int sum = 0;
+	while (*key != '\0') {
+		sum += *key;
+		key = key+1;
+	}
+	return sum % t;
+}
+```
+
+Pour construire le stockage, on fait :
+```c title=hash.c
+typedef struct _DataHash{
+	char *key;
+	int val;
+} DataHash;
+
+int main(){
+	DataHash t_hash[] = cell[TAILLE];
+	int ki = h("LUIN002", TAILLE);
+	t_hash[ki].key = "LUIN002";
+	t_hash[ki].val = 753;
+}
+```
+
+Fonctions usuelles :
+```c title=hash.c
+int add_hash(DataHash t_hash[], int size, char *key, int val){
+	int ki = h(key, size);
+	int i = ki+1;
+	while (t_hash[ki] != NULL && i != ki) i = (i+1)%size;
+	if (!t_hash[ki]) return 0;
+	t_hash[ki] = DataHash{key, val};
+	return 1;
+}
+```
+
+On peut aussi gérer les collisions à l'aide d'une liste
+|> on a des pointeurs vers des listes au lieu d'avoir directement la valeur dans `DataHash`
\ No newline at end of file
diff --git a/semestre 2/informatique/td/8- liste.md b/semestre 2/informatique/td/8- liste.md
new file mode 100644
index 0000000..cd568a9
--- /dev/null
+++ b/semestre 2/informatique/td/8- liste.md
@@ -0,0 +1,68 @@
+---
+tags:
+  - sorbonne
+  - informatique
+  - td
+semestre: 2
+---
+```c title=chained_list.c
+typedef struct cellule_t{
+	int donnee;
+	struct cellule_t *suivant;
+} Cellule;
+```
+
+Pour créer une nouvelle `Cellule`, on fait
+```c title=chained_list.c
+Cellule *create_cellule(int d){
+	Cellule *cell = malloc(sizeof(Cellule));
+	cell->donnee = d;
+	cell->suivant = NULL;
+	return cell;
+}
+```
+
+```c title=chained_list.c
+Cellule *last_element_list(Cellule *list){
+	if (!list) return NULL;
+	while (list->suivant) list = list->suivant;
+	return list;
+}
+```
+
+Pour modifier une cellule à la position `pos`
+```c title=chained_list.c
+void modify_element_list(Cellule *list, int pos, int val){
+	for (int i = 0; list && p <= pos; i++){
+		if (p == pos) list->donnee = val;
+		list = list->suivant;
+	}
+}
+```
+
+Pour vérifier si deux listes sont identiques
+```c title=chained_list.c
+int equal_list(Cellule *l1, Cellule *l2){
+	if ((!l1 && l2) || (l1 && !l2)) return 0;
+	while (l1 && l2){
+		if (l1->donnee != l2->donnee) return 0;
+		l1 = l1->suivant;
+		l2 = l2->suivant;
+	}
+	return !l1 && !l2;
+}
+```
+
+Pour vérifier si une liste est incluse dans l'autre
+```c title=chained_list.c
+// if l2 is included in l1
+int include_list(Cellule *l1, Cellule *l2){
+	if (!l1 && l2) return 0;
+	while (l1 && l2){
+		if (l1->donnee == l2->donnee) l2 = l2->suivant;
+		else if (l1->donnee > l2->donnee) return 0;
+		l1 = l1->suivant;
+	}
+	return !l2;
+}
+```
\ No newline at end of file
diff --git a/semestre 2/informatique/tme/semaine5/28_participation_frais.c b/semestre 2/informatique/tme/semaine5/28_participation_frais.c
index e5aff0d..96da9b7 100644
--- a/semestre 2/informatique/tme/semaine5/28_participation_frais.c
+++ b/semestre 2/informatique/tme/semaine5/28_participation_frais.c
@@ -13,9 +13,10 @@ void init_tab(float tab[NB_AMIS][NB_JOURS]){
 void random_tab(float tab[NB_AMIS][NB_JOURS], int j) {
 	int a = rand()%NB_AMIS;
 	int v = rand()%21+30;
-	tab[a][j] = v;
+	float to_pay = (float) v/(-NB_AMIS);
+	tab[a][j] = v + to_pay;
 	for (int i = 0; i < NB_AMIS; i++) {
-		if (i != a) tab[i][j] = (float) v/(-NB_AMIS+1);
+		if (i != a) tab[i][j] = to_pay;
 	}
 }
 
diff --git a/semestre 2/informatique/tme/semaine5/30_compression.c b/semestre 2/informatique/tme/semaine5/30_compression.c
index 161cd00..154dbc9 100644
--- a/semestre 2/informatique/tme/semaine5/30_compression.c
+++ b/semestre 2/informatique/tme/semaine5/30_compression.c
@@ -14,15 +14,19 @@ int init_tab(int tab[MAX+1]) {
 }
 
 void compress_tab(int tab_brut[], int tab_compress[]){
-	int j = 0;
 	int last = -1;
 	int cnt = 0;
+	int w = 0;
 	for (int i = 0; tab_brut[i] != -1; i++) {
 		if (last == -1 || tab_brut[i] != last) {
 			if (last != -1) {
-				int id = j++;
-				tab_compress[id*2] = cnt;
-				tab_compress[id*2+1] = last;
+				if (cnt == 1) {
+					tab_compress[w] = last;
+				} else {
+					tab_compress[w] = cnt;
+					tab_compress[++w] = last;
+				}
+				w++;
 			}
 			last = tab_brut[i];
 			cnt = 0;
@@ -30,11 +34,35 @@ void compress_tab(int tab_brut[], int tab_compress[]){
 		cnt++;
 	}
 	if (last != -1) {
-		int id = j++;
-		tab_compress[id*2] = cnt;
-		tab_compress[id*2+1] = last;
+		if (cnt == 1) {
+			tab_compress[w] = last;
+		} else {
+			tab_compress[w] = cnt;
+			tab_compress[++w] = last;
+		}
+		w++;
+	}
+	tab_compress[w] = -1;
+}
+
+void decompress(int tab_brut[], int tab_compress[]) {
+	int i = 0;
+	int w = 0;
+	while (tab_compress[i] != -1) {
+		int v = tab_compress[i];
+		if (v < 2) {
+			tab_brut[w++] = v;
+		} else {
+			int ins_v = tab_compress[++i];
+			for (int j = 0; j < v; j++) {
+				tab_brut[w++] = ins_v;
+			}
+		}
+		for (int j = 0; j < w; j++) printf("%d, ", tab_brut[j]);
+		printf("\n");
+		i++;
 	}
-	tab_compress[j*2] = -1;
+	tab_brut[w] = -1;
 }
 
 int compare(int tab_brut[], int tab_compress[]){
@@ -51,7 +79,31 @@ int compare(int tab_brut[], int tab_compress[]){
 
 int main(){
 	srand(time(NULL));
-	int tab[MAX+1] = {};
+	int tab1[]={0,0,1,1,1,1,0,1,1,1,0,0,1,0,0,0,0,-1};
+	//int tab1[] = {0,1,0,1,0,1,0,1,0,1,0,1,0,1,0,1,-1};
+	for (int i = 0; tab1[i] != -1; i++) printf("%d, ", tab1[i]);
+	printf("\n");
+	int tab2[20];
+	compress_tab(tab1,tab2);
+	int tab3[20];
+	decompress(tab3, tab2);
+	int i;
+	for (i = 0; tab1[i] != -1 && tab3[i] != -1; i++) {
+		printf("%d - %d\n", tab1[i], tab3[i]);
+	}
+	printf("%d\n", i);
+	i = 0;
+	while (tab2[i] != -1) {
+		int v = tab2[i];
+		if (v < 2) {
+			printf("%d ", v);
+		} else {
+			printf("%d:%d ", v, tab2[++i]);
+		}
+		i++;
+	}
+	printf("\n");
+	/*int tab[MAX+1] = {};
 	int tab_compress[MAX+1] = {};
 	init_tab(tab);
 	compress_tab(tab, tab_compress);
@@ -59,6 +111,6 @@ int main(){
 	printf("\n");
 	for (int i = 0; tab_compress[i] != -1; i += 2) printf("%d:%d, ", tab_compress[i], tab_compress[i+1]);
 	printf("\n");
-	printf("%s", compare(tab, tab_compress) ? "True" : "False");
+	printf("%s", compare(tab, tab_compress) ? "True" : "False");*/
 	return 0;
 }
diff --git a/semestre 2/informatique/tme/semaine5/31_image_mystere.c b/semestre 2/informatique/tme/semaine5/31_image_mystere.c
index 51ca321..29264e1 100644
--- a/semestre 2/informatique/tme/semaine5/31_image_mystere.c
+++ b/semestre 2/informatique/tme/semaine5/31_image_mystere.c
@@ -12,9 +12,15 @@ void calcule_borne_sup(int *tab, int taille){
 
 int tire_non_equi(int *tab, int taille){
 	int tire = rand()%100;
-	int i;
-	for (i = taille -1; tab[i] > tire; i--);
-	printf("%d - %d <= %d\n", i, tab[i], tire);
+	int i = taille -1;
+	/*while (i >= 0) {
+		if (tire > tab[i]) break;
+		i--;
+	}
+	i++;*/
+	for (i = taille -1; tab[i] >= tire; i--);
+	i++;
+	printf("%d >= %d\n", tab[i], tire);
 	return i;
 }
 
diff --git a/semestre 2/informatique/tme/semaine6/iter.c b/semestre 2/informatique/tme/semaine6/iter.c
new file mode 100644
index 0000000..fd55e23
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine6/iter.c
@@ -0,0 +1,13 @@
+#include <stdio.h>
+int recherche_iter(int* arr, int n, int v) {
+    int i;
+    for (i = 0; arr[i] != v && i < n; i++);
+    if (i == n) return -1;
+    return i;
+}
+
+int main() {
+	int arr[] = {1, 2, 3};
+	printf("%d\n", recherche_iter(arr, 3, 4));
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine6/rec.c b/semestre 2/informatique/tme/semaine6/rec.c
new file mode 100644
index 0000000..0a5bb34
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine6/rec.c
@@ -0,0 +1,12 @@
+#include <stdio.h>
+int recherche_rec(int* arr, int n, int v){
+	if (n == 0) return -1;
+	if (arr[n-1] == v) return n-1;
+	return recherche_rec(arr, n-1, v);
+}
+
+int main() {
+	int arr[] = {1, 2, 3, 5, 5};
+	printf("%d\n",recherche_rec(arr, 5, 6));
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine6/rec_2.c b/semestre 2/informatique/tme/semaine6/rec_2.c
new file mode 100644
index 0000000..9bfd376
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine6/rec_2.c
@@ -0,0 +1,16 @@
+#include <stdio.h>
+int recherche_rec_aux (int* tab, int n,int i, int v) {
+    if (i == n) return -1;
+    if (tab[i] == v) return i;
+    return recherche_rec_aux(tab, n, i+1, v);
+}
+
+int recherche_rec (int tab[], int taille, int elem) {
+    return recherche_rec_aux (tab, taille, 0, elem);
+}
+
+int main() {
+	int arr[] = {1, 2, 3};
+	printf("%d\n", recherche_rec(arr, 3, 0));
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine6/rec_str.c b/semestre 2/informatique/tme/semaine6/rec_str.c
new file mode 100644
index 0000000..a920af3
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine6/rec_str.c
@@ -0,0 +1,19 @@
+#include <stdio.h>
+int est_deb(char* s1, char* s2) {
+	if (*s1 == '\0' || *s2 =='\0') return 1;
+	if (*s1 != *s2) return 0;
+	return est_deb(s1+1, s2+1);
+}
+
+int est_incluse(char *sub, char* s) {
+	if (*s == '\0') return 0;
+	return est_deb(sub, s) ? 1 : est_incluse(sub, s+1);
+}
+
+int main() {
+	printf("%d\n", est_deb("alpha", "alphabet"));
+	printf("%d\n", est_deb("alpaga", "alphabet"));
+	printf("%d\n", est_incluse("alp", "alphabet"));
+	printf("%d\n", est_incluse("apl", "alphabet"));
+	return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine7/35_systeme_solaire.c b/semestre 2/informatique/tme/semaine7/35_systeme_solaire.c
new file mode 100644
index 0000000..aa9c42b
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine7/35_systeme_solaire.c
@@ -0,0 +1,33 @@
+#include <stdio.h>
+#define NB_PLANETES 8
+
+typedef struct{
+	char name[10];
+	float density;
+	float distance;
+	int satellites;
+} planete;
+
+void affichePlanete(planete *p){
+	printf(
+		"%s:\n- densité : %.02f\n- distance : %.2f\n- nombre de satellites : %d\n\n", 
+		p->name,
+		p->density,
+		p->distance,
+		p->satellites
+	);
+}
+
+void afficheToutesPlanetes(planete ps[]) {
+	for (int i = 0; i < NB_PLANETES; i++) affichePlanete((ps+i));
+}
+
+void modifieDensite(planete *p, float v){
+	p->density = v;
+}
+
+int main(){
+    planete systemeSolaire[NB_PLANETES] ={{"Mercure", 5.42, 58, 0},{"Venus", 5.25, 108.2, 0},{"Terre", 5.52,149.6,1},{"Mars",3.94,227.9,2},{"Jupiter",1.314,778.3,16},{"Saturne",0.69,1427,17},{"Uranus",1.19,2869,15},{"Neptune",1.6,4496,2}};           
+	afficheToutesPlanetes(systemeSolaire);
+    return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine7/hello.c b/semestre 2/informatique/tme/semaine7/hello.c
new file mode 100644
index 0000000..4e2d9dc
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine7/hello.c
@@ -0,0 +1,41 @@
+#include <stdio.h>
+#define NB_PLANETES 8
+
+/* ici la definition du type planete */
+typedef struct{
+	char nom[10];
+	float densite;
+	float distance;
+	int nbsat;
+} planete;
+
+void affichePlanete(planete p){
+   printf("%s : densite = %.2f, distance soleil = %.1f, nb satellites = %d", 
+   p.nom, p.densite, p.distance, p.nbsat);
+}
+
+void afficheToutesPlanetes(planete ps[], int n){
+    for (int i = 0; i < n; i++) affichePlanete(*(ps+i));
+}
+
+void modifieDensite (planete *p, float v) {
+    p->densite = v;
+}
+
+int main(){
+   planete systemeSolaire[NB_PLANETES] ={{"Mercure", 5.42, 58, 0}, {"Venus", 5.25, 108.2, 0}, 
+         {"Terre", 5.52, 149.6,1}, {"Mars", 3.94, 227.9, 2}, {"Jupiter", 1.314, 778.3, 16},
+         {"Saturne", 0.69, 1427, 17}, {"Uranus", 1.19, 2869, 15}, {"Neptune", 1.6, 4496, 2}};
+   int i;
+   float d;
+   
+   afficheToutesPlanetes(systemeSolaire, NB_PLANETES);
+   printf("\n");
+   scanf("%d", &i);
+   scanf("%f", &d);
+   /* on affecte la densite d a la planete d'indice i du tableau systemeSolaire */
+   modifieDensite(systemeSolaire+i, d);
+   affichePlanete(systemeSolaire[i]);
+   printf("\n");
+   return 0;
+}
diff --git a/semestre 2/informatique/tme/semaine8/build_run.sh b/semestre 2/informatique/tme/semaine8/build_run.sh
new file mode 100644
index 0000000..4a32768
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine8/build_run.sh
@@ -0,0 +1,4 @@
+#!/usr/bin/env bash
+gcc -Wall -o app liste_entiers.c liste_entiers.h test_liste.c
+./app
+rm app
diff --git a/semestre 2/informatique/tme/semaine8/liste_entiers.c b/semestre 2/informatique/tme/semaine8/liste_entiers.c
new file mode 100644
index 0000000..c53040c
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine8/liste_entiers.c
@@ -0,0 +1,102 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include "liste_entiers.h"
+
+cellule_t * creerListe(int n) {
+/* cree une liste de n entiers saisi par l'utilisateur
+  renvoie l'adresse du premier element de la liste */
+  int i;
+  int val;
+  cellule_t *tete=NULL;
+  cellule_t *ptr;
+  
+  printf("Saisie des %d elements de la liste\n",n);
+  for (i=0; i < n; i++) {
+    printf("Element %d :",i+1);
+    scanf("%d",&val);
+    ptr=malloc(sizeof(cellule_t));
+    ptr->donnee = val;
+    ptr->suivant = tete;
+    tete = ptr;
+  }
+  return tete;
+}
+
+cellule_t *list(int n, cellule_t *q){
+	cellule_t *h = malloc(sizeof(cellule_t));
+	h->suivant = q;
+	h->donnee = n;
+	return h;
+}
+
+void AfficherListeInt(cellule_t *liste){
+	while (liste){
+		printf("%d ", liste->donnee);
+		liste = liste->suivant;	
+	}
+}
+
+int nb_occurences(int val, cellule_t *liste){
+	int c = 0;
+	while (liste){
+		if (liste->donnee == val) c++;
+		liste = liste->suivant;
+	}
+	return c;
+}
+
+int tous_plus_grand(int val, cellule_t *liste){
+	while (liste){
+		if (liste->donnee < val) return 0;
+		liste = liste->suivant;
+	}
+	return 1;
+}
+
+cellule_t *Maximum(cellule_t *liste){
+	cellule_t *max= NULL;
+	while (liste){
+		if (!max || (liste->donnee > max->donnee)) max = liste;
+		liste = liste->suivant;
+	}
+	return max;
+}
+
+int Renvoyer_val_element_pos(int pos, cellule_t* liste){
+	int size;
+	cellule_t *tmp = liste;
+	for (size = 0; tmp; size++) tmp = tmp->suivant;
+	for (int i = 0; i < pos; i++) liste = liste->suivant;
+	// pos = 0 ~ 2
+	// pos = 1 ~ 1
+	// pos = 2 ~ 0
+	// size-pos = 3-0 -> 3
+	// size-pos = 3-1 -> 2
+	// size-pos = 3-2 -> 1
+	if (!liste) {
+		printf("error\n");
+		return -1;
+	}
+	return liste->donnee;
+}
+
+cellule_t *Concatener_it(cellule_t *liste1, cellule_t *liste2){
+	if (!liste1) return liste2;
+	cellule_t *head = liste1;
+	while (liste1->suivant) liste1 = liste1->suivant;
+	liste1->suivant = liste2;
+	return head;
+}
+
+int nb_maximum(cellule_t *liste){
+	cellule_t *max= NULL;
+	int c = 1;
+	while (liste){
+		if (!max || (liste->donnee > max->donnee)) {
+			max = liste;
+			c = 1;
+		} else if (liste->donnee == max->donnee) c++;
+		liste = liste->suivant;
+	}
+	return c;
+}
diff --git a/semestre 2/informatique/tme/semaine8/liste_entiers.h b/semestre 2/informatique/tme/semaine8/liste_entiers.h
new file mode 100644
index 0000000..78ccefb
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine8/liste_entiers.h
@@ -0,0 +1,24 @@
+typedef struct _cellule_t cellule_t;
+
+struct _cellule_t {
+  int donnee;
+  cellule_t *suivant;
+};
+
+cellule_t * creerListe(int n);
+
+void AfficherListeInt(cellule_t *liste);
+
+int nb_occurences(int val, cellule_t *liste);
+
+int tous_plus_grand(int val, cellule_t *liste);
+
+cellule_t *Maximum(cellule_t *liste);
+
+int Renvoyer_val_element_pos(int pos, cellule_t* liste);
+
+cellule_t *Concatener_it(cellule_t *liste1, cellule_t *liste2);
+
+int nb_maximum(cellule_t *liste);
+
+cellule_t *list(int n, cellule_t *q);
diff --git a/semestre 2/informatique/tme/semaine8/test_liste.c b/semestre 2/informatique/tme/semaine8/test_liste.c
new file mode 100644
index 0000000..acd23ae
--- /dev/null
+++ b/semestre 2/informatique/tme/semaine8/test_liste.c
@@ -0,0 +1,17 @@
+#include "liste_entiers.h"
+#include <stdio.h>
+
+int main() {
+  cellule_t *ma_liste=list(1, list(3, list(0, NULL)));
+  int size = 0;
+  cellule_t *t = ma_liste;
+  for (size = 0; t; size++) {
+	  printf("val %d\n", t->donnee);
+	  t = t->suivant;
+  }
+  printf("size %d\n", size);
+  printf("before\n");
+  for (int i = 0; i < size; i++) printf("pos %d = %d\n", i, Renvoyer_val_element_pos(i, ma_liste));
+  printf("after\n");
+  return 0;
+}
diff --git a/semestre 2/maths/4- combinatoire/cours.pdf b/semestre 2/maths/4- combinatoire/cours.pdf
new file mode 100644
index 0000000..1506655
--- /dev/null
+++ b/semestre 2/maths/4- combinatoire/cours.pdf
diff --git a/semestre 2/maths/4- combinatoire/cours.tex b/semestre 2/maths/4- combinatoire/cours.tex
new file mode 100644
index 0000000..4dff382
--- /dev/null
+++ b/semestre 2/maths/4- combinatoire/cours.tex
@@ -0,0 +1,255 @@
+%%=====================================================================================
+%%
+%%       Filename:  cours.tex
+%%
+%%    Description:  
+%%
+%%        Version:  1.0
+%%        Created:  03/06/2024
+%%       Revision:  none
+%%
+%%         Author:  YOUR NAME (), 
+%%   Organization:  
+%%      Copyright:  Copyright (c) 2024, YOUR NAME
+%%
+%%          Notes:  
+%%
+%%=====================================================================================
+\documentclass[a4paper, titlepage]{article}
+
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{textcomp}
+\usepackage[french]{babel}
+\usepackage{amsmath, amssymb}
+\usepackage{amsthm}
+\usepackage[svgnames]{xcolor}
+\usepackage{thmtools}
+\usepackage{lipsum}
+\usepackage{framed}
+\usepackage{parskip}
+\usepackage{titlesec}
+\usepackage{newtxtext}
+
+% \renewcommand{\familydefault}{\sfdefault}
+
+% figure support
+\usepackage{import}
+\usepackage{xifthen}
+\pdfminorversion=7
+\usepackage{pdfpages}
+\usepackage{transparent}
+\newcommand{\incfig}[1]{%
+	\def\svgwidth{\columnwidth}
+	\import{./figures/}{#1.pdf_tex}
+}
+
+\pdfsuppresswarningpagegroup=1
+
+\colorlet{defn-color}{DarkBlue}
+\colorlet{props-color}{Blue}
+\colorlet{warn-color}{Red}
+\colorlet{exemple-color}{Green}
+\colorlet{corol-color}{Orange}
+\newenvironment{defn-leftbar}{%
+  \def\FrameCommand{{\color{defn-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{warn-leftbar}{%
+  \def\FrameCommand{{\color{warn-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{exemple-leftbar}{%
+  \def\FrameCommand{{\color{exemple-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{props-leftbar}{%
+  \def\FrameCommand{{\color{props-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{corol-leftbar}{%
+  \def\FrameCommand{{\color{corol-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+
+\def \freespace {1em}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{defn-color}Définition~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{defn-leftbar},%
+ postfoothook=\end{defn-leftbar},%
+]{better-defn}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{warn-color}Attention\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{warn-leftbar},%
+ postfoothook=\end{warn-leftbar},%
+]{better-warn}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+notebraces={}{},%
+headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{exemple-color}Exemple~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{exemple-leftbar},%
+ postfoothook=\end{exemple-leftbar},%
+]{better-exemple}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{props-color}Proposition~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{props-leftbar},%
+ postfoothook=\end{props-leftbar},%
+]{better-props}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{props-color}Théorème~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{props-leftbar},%
+ postfoothook=\end{props-leftbar},%
+]{better-thm}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{corol-color}Corollaire~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{corol-leftbar},%
+ postfoothook=\end{corol-leftbar},%
+]{better-corol}
+
+\declaretheorem[style=better-defn]{defn}
+\declaretheorem[style=better-warn]{warn}
+\declaretheorem[style=better-exemple]{exemple}
+\declaretheorem[style=better-corol]{corol}
+\declaretheorem[style=better-props, numberwithin=defn]{props}
+\declaretheorem[style=better-thm, sibling=props]{thm}
+\newtheorem*{lemme}{Lemme}%[subsection]
+%\newtheorem{props}{Propriétés}[defn]
+
+\newenvironment{system}%
+{\left\lbrace\begin{align}}%
+{\end{align}\right.}
+
+\newenvironment{AQT}{{\fontfamily{qbk}\selectfont AQT}}
+
+\usepackage{LobsterTwo}
+\titleformat{\section}{\newpage\LobsterTwo \huge\bfseries}{\thesection.}{1em}{}
+\titleformat{\subsection}{\vspace{2em}\LobsterTwo \Large\bfseries}{\thesubsection.}{1em}{}
+\titleformat{\subsubsection}{\vspace{1em}\LobsterTwo \large\bfseries}{\thesubsubsection.}{1em}{}
+
+\newenvironment{lititle}%
+{\vspace{7mm}\LobsterTwo \large}%
+{\\}
+
+\renewenvironment{proof}{$\square$ \footnotesize\textit{Démonstration.}}{\begin{flushright}$\blacksquare$\end{flushright}}
+
+\title{Combinatoire}
+\author{William Hergès\thanks{Sorbonne Université - Faculté des Sciences, Faculté des Lettres}}
+
+\begin{document}
+	\maketitle
+	\tableofcontents
+	\newpage
+	\section{Notation}
+	Dans cette section, on parle de théorie des ensembles.
+
+	On notera toujours $E$ l'ensemble ambient. Soit $A$ un sous-ensemble de $E$. On le note~: $A\subseteq E$ (ou $A\subset E$, mais on l'aime moins celle-là). On note l'inclusion stricte $A\subsetneq E$.
+	\begin{defn}
+		$A\cup B$ est défini comme~:
+		$$ x\in A\cup B\quad\implies\quad x\in A\quad\lor\quad x\in B $$
+		On a :
+		$$ A\cup B = \{x\in E\quad|\quad x\in A\lor x\in B\} $$
+	\end{defn}
+	\begin{defn}
+		$A\cap B$ est défini comme~:
+		$$ x\in A\cap B\quad\implies\quad x\in A\quad\land\quad x\in B $$
+		On a :
+		$$ A\cup B = \{x\in E\quad|\quad x\in A\land x\in B\} $$
+	\end{defn}
+	\begin{defn}
+		$A\backslash B$ est défini comme~:
+		$$ x\in A\backslash B\quad\implies\quad x\in A\quad\land\quad x\not\in B$$
+		On a~:
+		$$ A\backslash B = \{x\in E\quad|\quad x\in A\land x\not\in B\} $$
+	\end{defn}
+	\begin{defn}
+		$E\backslash A$ est le complémentaire de $A$ et est défini comme~:
+		$$ \forall x\in E\backslash A\quad\implies\quad x\in E\quad\land\quad x\not\in A $$
+		On a~:
+		$$ E\backslash A=\{x\in E\quad|\quad x\not\in A\} $$
+	\end{defn}
+	\begin{defn}
+		Si $E$ est un ensemble fini, on a que $\mathrm{card}(E)$ ou $|E|$ est le nombre d'éléments de $E$.
+	\end{defn}
+	\begin{props}
+		On a :
+		$$ \mathrm{card}(A\cup B) = \mathrm{card}(A) + \mathrm{card}(B) - \mathrm{card}(A\cap B) $$
+	\end{props}
+	\begin{defn}
+		Le produit cartésien est noté $\times$ et est :
+		$$ A\times B = \{(x,y)\quad|\quad x\in A,y\in B\} $$
+	\end{defn}
+	\begin{props}
+		On a~:
+		$$ \mathrm{card}(A\times B) = \mathrm{card}(A)\times\mathrm{card}(B) $$
+	\end{props}
+	\section{Combinaisons}
+	Soit $\Omega=\{1,2,\ldots,n\}$, un ensemble de $n$ éléments.
+
+	\begin{defn}
+		Une combinaison de $k$ éléments parmis les éléments de $\Omega$ est un sous-ensemble $A\subseteq\Omega$ tel que $\mathrm{card}(A) = k$.
+	\end{defn}
+	\begin{props}
+		Le nombre de combinaisons de $k$ éléments parmis les éléments de $\Omega$ est~:
+		$$ \frac{\mathrm{card}(\Omega)!}{k!(\mathrm{card}(\Omega)-k)!} = \frac{n!}{k!(n-k)!} $$
+		pour $n = \mathrm{card}(\Omega)$, i.e.
+		$$ \binom{\mathrm{card}(\Omega)}{k} = \binom nk $$
+		ce qui est un cœfficient binomial.
+	\end{props}
+	On peut aussi écrire le cœfficient binomial $\mathcal{C}^k_n = \binom nk$. $\mathcal{C}$ signifie \textit{combinaison}~! Ici, l'\textit{ordre ne compte pas}.
+
+	Il existe aussi $\mathcal{A}^k_n = \frac{n!}{(n-k)!}$, ce qui est le nombre de choix possible où l'\textit{ordre compte}. $\mathcal{A}$ pour \textit{arrangement}~!
+
+	\begin{exemple}
+		Une personne qui veut aller à un endroit doit forcément faire une combinaison parmis $\{D,D,D,B,B\}$. (Ceci représente tous les chemins les plus rapides pour y aller~: on doit forcément prendre 3 fois droite et deux fois gauche.) Donc, il y a $\binom 52 = 10$ possibilités~: il suffit de choisir quand on descend (donc 2 possibilités) pour avoir tous les cas possibles~! (On aurait aussi pu choisir quand on va à droite, mais les calculs sont plus méchants.)
+	\end{exemple}
+
+	\begin{props}
+		On a~:
+		$$ \mathcal{C}^k_n = \mathcal{C}^{k-1}_{n-1} + \mathcal{C}^k_{n-1} $$
+		i.e.
+		$$ \binom nk = \binom{k-1}{n-1}+\binom k{n-1} $$
+	\end{props}
+
+	Maintenant, voici un énoncé très pratique~: le \textit{binôme de Newton}. Le prof l'a démontré en cours, mais j'avais la flemme d'écrire la démo. Voir la démonstration de l'année dernière.
+
+	\begin{thm}[Binôme de Newton]
+		On a~:
+		$$ (x+y)^n = \sum_{k=0}^{n} \binom nk x^ky^{n-k} $$
+	\end{thm}
+
+	\begin{corol}
+		On a cette magnifique relation pas très utile~:
+		$$ \sum^n_{k=0}\binom nk = 2^n $$	
+	\end{corol}
+	\begin{proof}
+		D'après le binôme de Newton, on a~:
+		$$ (1+1)^n = \sum_{k=0}^{n} \binom nk 1^k1^{n-k} $$
+		i.e.
+		$$ 2^n = \sum_{k=0}^{n} \binom nk $$
+	\end{proof}
+	\begin{exemple}
+	Dans un groupe de 20 personnes, il y a $2^{20}$ sous-groupes possibles. Il y a $20$ tailles de sous-groupes possibles~: de 1 à 20. Le nombre de sous-groupe contenant personne est $\binom{20}0$, celui contenant une personne est $\binom{20}1$, \ldots, celui contenant 20 personnes est $\binom{20}{20}$. Ainsi, le nombre de sous-groupe est la somme de tout cela et le résultat est donné par la formule juste au dessus.
+	\end{exemple}
+\end{document}
diff --git a/semestre 2/maths/5- Probabilité/cours.pdf b/semestre 2/maths/5- Probabilité/cours.pdf
new file mode 100644
index 0000000..42b8a8b
--- /dev/null
+++ b/semestre 2/maths/5- Probabilité/cours.pdf
diff --git a/semestre 2/maths/5- Probabilité/cours.tex b/semestre 2/maths/5- Probabilité/cours.tex
new file mode 100644
index 0000000..bf62768
--- /dev/null
+++ b/semestre 2/maths/5- Probabilité/cours.tex
@@ -0,0 +1,281 @@
+%%=====================================================================================
+%%
+%%       Filename:  cours.tex
+%%
+%%    Description:  
+%%
+%%        Version:  1.0
+%%        Created:  03/06/2024
+%%       Revision:  none
+%%
+%%         Author:  YOUR NAME (), 
+%%   Organization:  
+%%      Copyright:  Copyright (c) 2024, YOUR NAME
+%%
+%%          Notes:  
+%%
+%%=====================================================================================
+\documentclass[a4paper, titlepage]{article}
+
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{textcomp}
+\usepackage[french]{babel}
+\usepackage{amsmath, amssymb}
+\usepackage{amsthm}
+\usepackage[svgnames]{xcolor}
+\usepackage{thmtools}
+\usepackage{lipsum}
+\usepackage{framed}
+\usepackage{parskip}
+\usepackage{titlesec}
+\usepackage{newtxtext}
+
+% \renewcommand{\familydefault}{\sfdefault}
+
+% figure support
+\usepackage{import}
+\usepackage{xifthen}
+\pdfminorversion=7
+\usepackage{pdfpages}
+\usepackage{transparent}
+\newcommand{\incfig}[1]{%
+	\def\svgwidth{\columnwidth}
+	\import{./figures/}{#1.pdf_tex}
+}
+
+\pdfsuppresswarningpagegroup=1
+
+\colorlet{defn-color}{DarkBlue}
+\colorlet{props-color}{Blue}
+\colorlet{warn-color}{Red}
+\colorlet{exemple-color}{Green}
+\colorlet{corol-color}{Orange}
+\newenvironment{defn-leftbar}{%
+  \def\FrameCommand{{\color{defn-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{warn-leftbar}{%
+  \def\FrameCommand{{\color{warn-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{exemple-leftbar}{%
+  \def\FrameCommand{{\color{exemple-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{props-leftbar}{%
+  \def\FrameCommand{{\color{props-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{corol-leftbar}{%
+  \def\FrameCommand{{\color{corol-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+
+\def \freespace {1em}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{defn-color}Définition~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{defn-leftbar},%
+ postfoothook=\end{defn-leftbar},%
+]{better-defn}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{warn-color}Attention\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{warn-leftbar},%
+ postfoothook=\end{warn-leftbar},%
+]{better-warn}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+notebraces={}{},%
+headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{exemple-color}Exemple~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{exemple-leftbar},%
+ postfoothook=\end{exemple-leftbar},%
+]{better-exemple}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{props-color}Proposition~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{props-leftbar},%
+ postfoothook=\end{props-leftbar},%
+]{better-props}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{props-color}Théorème~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{props-leftbar},%
+ postfoothook=\end{props-leftbar},%
+]{better-thm}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{corol-color}Corollaire~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{corol-leftbar},%
+ postfoothook=\end{corol-leftbar},%
+]{better-corol}
+
+\declaretheorem[style=better-defn]{defn}
+\declaretheorem[style=better-warn]{warn}
+\declaretheorem[style=better-exemple]{exemple}
+\declaretheorem[style=better-corol]{corol}
+\declaretheorem[style=better-props, numberwithin=defn]{props}
+\declaretheorem[style=better-thm, sibling=props]{thm}
+\newtheorem*{lemme}{Lemme}%[subsection]
+%\newtheorem{props}{Propriétés}[defn]
+
+\newenvironment{system}%
+{\left\lbrace\begin{align}}%
+{\end{align}\right.}
+
+\newenvironment{AQT}{{\fontfamily{qbk}\selectfont AQT}}
+
+\usepackage{LobsterTwo}
+\titleformat{\section}{\newpage\LobsterTwo \huge\bfseries}{\thesection.}{1em}{}
+\titleformat{\subsection}{\vspace{2em}\LobsterTwo \Large\bfseries}{\thesubsection.}{1em}{}
+\titleformat{\subsubsection}{\vspace{1em}\LobsterTwo \large\bfseries}{\thesubsubsection.}{1em}{}
+
+\newenvironment{lititle}%
+{\vspace{7mm}\LobsterTwo \large}%
+{\\}
+
+\renewenvironment{proof}{$\square$ \footnotesize\textit{Démonstration.}}{\begin{flushright}$\blacksquare$\end{flushright}}
+
+\title{Probabilités}
+\author{William Hergès\thanks{Sorbonne Université - Faculté des Sciences, Faculté des Lettres}}
+
+\begin{document}
+	\maketitle
+	\tableofcontents
+	\newpage
+	\section{Espace probabilisé}
+	Les probabilités sont très semblables à la théorie des ensembles.
+	\begin{defn}
+		On note $\Omega$ l'ensemble des issues possibles d'une expérience aléatoire. $\Omega$ est l'univers.
+	\end{defn}
+
+	\begin{lititle}
+		Dictionnaire des probabilités
+	\end{lititle}
+	Cette petite partie est piquée de mon cours de maths au CPES (créé par M. Kerner et M. Cote, deux professeurs de mathématiques au Lycée Henri-IV).
+	\begin{table}[htpb]
+		\centering
+		\caption{Dictionnaire}
+		\label{tab:dico-proba}
+		\begin{tabular}{|c|c|}
+			\hline
+			Théorie des ensembles & Probabilités \\
+			\hline
+			$w\in\Omega$ & issue de l'expérience \\
+			$A\in\mathcal{P}(\Omega)$ & événement \\
+			$\mathcal{P}(\Omega)$ ou l'ensemble des parties & tribu \\
+			$\bar A = \Omega\backslash A$ ou complémentaire & contraire \\
+			$A\cup B$ & $A$ ou $B$ \\
+			$A\cap B$ & $A$ et $B$ \\
+			$B\backslash A$ & $B$ mais pas $A$\\
+			$A\subset B$ & $A$ implique $B$ \\
+			$A\cap B = \varnothing$ ou $A$ et $B$ sont disjoints & $A$ et $B$ sont incompatibles \\
+			$A\sqcup B$ & $A$ ou bien $B$ \\
+			$E_1\sqcup E_2\sqcup\ldots\sqcup E_n = \Omega$ ou un partage & système complet d'évènements (s.e.c.)\\
+			\hline
+		\end{tabular}
+	\end{table}
+
+	\begin{defn}
+		Un espace probabilisé est un univers $\Omega$ possédant une fonction $\mathbb{P}$ de $\mathcal{P}(\Omega)$ dans $[0;1]$ tel que
+		\begin{enumerate}
+			\item $\mathbb{P}(\Omega)=1$
+			\item $\mathbb{P}(A\cup B)=\mathbb{P}(A)+\mathbb{P}(B)$, où $A$ et $B$ sont deux événements de $\Omega$ incompatibles.
+		\end{enumerate}
+	\end{defn}
+	Un espace probabilisé est donc un univers avec une fonction assignant une probabilité à tous les événements de l'univers~!
+	\begin{props}
+		On a :
+		$$ \mathbb{P}(\varnothing) = 0 $$
+	\end{props}
+	\begin{proof}
+		On a :
+		$$ \mathbb{P}(\Omega) = \mathbb{P}(\varnothing\cup\Omega) = \mathbb{P}(\varnothing) + \mathbb{P}(\Omega) = 1 $$
+		Donc $\mathbb{P}(\varnothing) = 0$, car, par définition, $\mathbb{P}(\Omega) = 1$.
+	\end{proof}
+	\begin{props}
+		On a pour tous événements $A$ et $B$ de $\Omega$, un espace probabilisé~:
+		$$ \mathbb{P}(A\cup B) = \mathbb{P}(A) + \mathbb{P}(B) + \mathbb{P}(A\cap B) $$
+	\end{props}
+	\begin{proof}
+		\AQT
+	\end{proof}
+	\section{Probabilités conditionnelles}
+	\begin{defn}
+		On dit que $A\subset\Omega$ est certain si et seulement si $\mathbb{P}(A) = 1$.
+
+		On dit que $B\subset\Omega$ est impossible si et seulement si $\mathbb{P}(B) = 0$.
+	\end{defn}
+	\begin{props}
+		À partir d'un événement $B$ non-impossible, on peut définir un espace probabilisé.
+
+		Soit $(\Omega,\mathbb{P})$ un espace probabilisé. Soit $B$ un événement non-impossible de $(\Omega,\mathbb{P})$ (i.e. $\mathbb{P}(B)\neq 0$). On a que $(\Omega,\mathbb{P}_B)$ est un espace probabilisé avec $\mathbb{P}_B$ de $\mathcal{P}(\Omega)$ dans $[0;1]$ tel que :
+		$$ \mathbb{P}_B(A) = \frac{\mathbb{P}(A\cap B)}{\mathbb{P}(B)} $$
+		où $A$ est un événement de $\Omega$. $\mathbb{P}_B(A)$ est la probabilité de $A$ sachant $B$.
+	\end{props}
+	\begin{proof}
+		\AQT
+	\end{proof}
+	On peut aussi dire que $\mathbb{P}_B(A)$ est la probabilité de $A$ conditionnelle à $B$. 
+
+	On peut aussi noter $\mathbb{P}_B(A) = \mathbb{P}(A|B)$.
+	\section{Événements indépendants}
+	\begin{defn}
+		Soient $A$ et $B$ deux événements de l'espace probabilisé $(\Omega,\mathbb{P})$.
+
+		On dit qu'ils sont indépendants si et seulement si~:
+		$$ \mathbb{P}(A\cap B) = \mathbb{P}(A)\times\mathbb{P}(B) $$
+	\end{defn}
+	\begin{props}
+		Si $A$ et $B$ sont indépendants et si $B$ n'est pas impossible, alors $$ \mathbb{P}_B(A) = \mathbb{P}(A) $$
+	\end{props}
+	\begin{proof}
+		\AQT
+	\end{proof}
+	\begin{thm}[Théorème de Bayes]
+		On note $\Omega$ l'union des $(C_i)_{i\in[|1,n|]}$ disjoints deux à deux.
+
+		On note $R$ un événement de $\Omega$ sachant $\mathbb{P}_{C_i}(R)$ pour tout $i$ dans $[|i,n|]$.
+
+		On a~:
+		$$ \forall i\in[|1,n|],\quad\mathbb{P}_{R}(C_i) = \frac{\mathbb{P}_{C_i}(R)\mathbb{P}(C_i)}{\displaystyle \sum_{i=1}^{n} \mathbb{P}_{C_i}(R)\mathbb{P}(C_i)}$$
+	\end{thm}
+	\begin{exemple}
+		On veut $\mathbb{P}_D(I)$. On sait que~:
+		\begin{enumerate}
+			\item $\mathbb{P}_F(D) = 1/2$
+			\item $\mathbb{P}_I(D) = 3/4$
+			\item $\mathbb{P}_A(D) = 1/4$
+		\end{enumerate}
+		On sait aussi que~:
+		\begin{enumerate}
+			\item $\mathbb{P}(F)=1/4$
+			\item $\mathbb{P}(I)=1/4$
+			\item $\mathbb{P}(A)=1/2$
+		\end{enumerate}
+	Donc~:
+	\begin{align*}
+		\mathbb{P}_D(I) &= \frac{\mathbb{P}_I(D)\mathbb{P}(I)}{\mathbb{P}_F(D)\mathbb{P}(F)+\mathbb{P}_I(D)\mathbb{P}(I)+\mathbb{P}_A(D)\mathbb{P}(A)} \\
+						&= \frac{\frac{3}{4}\cdot \frac{1}{4}}{\frac{1}{4}\cdot \frac{1}{4}+\frac{3}{4}\cdot \frac{1}{4}+\frac{1}{4}\cdot \frac{1}{2}} \\
+						&= \frac{3}{7}
+	\end{align*}
+	\end{exemple}
+\end{document}
diff --git a/semestre 2/maths/td/03-13.pdf b/semestre 2/maths/td/03-13.pdf
new file mode 100644
index 0000000..3520962
--- /dev/null
+++ b/semestre 2/maths/td/03-13.pdf
diff --git a/semestre 2/maths/td/03-13.tex b/semestre 2/maths/td/03-13.tex
new file mode 100644
index 0000000..680492f
--- /dev/null
+++ b/semestre 2/maths/td/03-13.tex
@@ -0,0 +1,197 @@
+%%=====================================================================================
+%%
+%%       Filename:  cours.tex
+%%
+%%    Description:  
+%%
+%%        Version:  1.0
+%%        Created:  03/06/2024
+%%       Revision:  none
+%%
+%%         Author:  YOUR NAME (), 
+%%   Organization:  
+%%      Copyright:  Copyright (c) 2024, YOUR NAME
+%%
+%%          Notes:  
+%%
+%%=====================================================================================
+\documentclass[a4paper, titlepage]{article}
+
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{textcomp}
+\usepackage[french]{babel}
+\usepackage{amsmath, amssymb}
+\usepackage{amsthm}
+\usepackage[svgnames]{xcolor}
+\usepackage{thmtools}
+\usepackage{lipsum}
+\usepackage{framed}
+\usepackage{parskip}
+\usepackage{titlesec}
+\usepackage{newtxtext}
+
+% \renewcommand{\familydefault}{\sfdefault}
+
+% figure support
+\usepackage{import}
+\usepackage{xifthen}
+\pdfminorversion=7
+\usepackage{pdfpages}
+\usepackage{transparent}
+\newcommand{\incfig}[1]{%
+	\def\svgwidth{\columnwidth}
+	\import{./figures/}{#1.pdf_tex}
+}
+
+\pdfsuppresswarningpagegroup=1
+
+\colorlet{defn-color}{DarkBlue}
+\colorlet{props-color}{Blue}
+\colorlet{warn-color}{Red}
+\colorlet{exemple-color}{Green}
+\colorlet{corol-color}{Orange}
+\newenvironment{defn-leftbar}{%
+  \def\FrameCommand{{\color{defn-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{warn-leftbar}{%
+  \def\FrameCommand{{\color{warn-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{exemple-leftbar}{%
+  \def\FrameCommand{{\color{exemple-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{props-leftbar}{%
+  \def\FrameCommand{{\color{props-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{corol-leftbar}{%
+  \def\FrameCommand{{\color{corol-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+
+\def \freespace {1em}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+ bodyfont=\sffamily,%
+ headformat=\color{defn-color}Définition~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{defn-leftbar},%
+ postfoothook=\end{defn-leftbar},%
+]{better-defn}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+ bodyfont=\sffamily,%
+ headformat=\color{warn-color}Attention\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{warn-leftbar},%
+ postfoothook=\end{warn-leftbar},%
+]{better-warn}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+notebraces={}{},%
+headpunct=,%
+ bodyfont=\sffamily,%
+ headformat=\color{exemple-color}Exemple~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{exemple-leftbar},%
+ postfoothook=\end{exemple-leftbar},%
+]{better-exemple}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+ bodyfont=\sffamily,%
+ headformat=\color{props-color}Proposition~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{props-leftbar},%
+ postfoothook=\end{props-leftbar},%
+]{better-props}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+ bodyfont=\sffamily,%
+ headformat=\color{props-color}Théorème~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{props-leftbar},%
+ postfoothook=\end{props-leftbar},%
+]{better-thm}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+ bodyfont=\sffamily,%
+ headformat=\color{corol-color}Corollaire~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{corol-leftbar},%
+ postfoothook=\end{corol-leftbar},%
+]{better-corol}
+
+\declaretheorem[style=better-defn]{defn}
+\declaretheorem[style=better-warn]{warn}
+\declaretheorem[style=better-exemple]{exemple}
+\declaretheorem[style=better-corol]{corol}
+\declaretheorem[style=better-props, numberwithin=defn]{props}
+\declaretheorem[style=better-thm, sibling=props]{thm}
+\newtheorem*{lemme}{Lemme}%[subsection]
+%\newtheorem{props}{Propriétés}[defn]
+
+\newenvironment{system}%
+{\left\lbrace\begin{align}}%
+{\end{align}\right.}
+
+\newenvironment{AQT}{{\fontfamily{qbk}\selectfont AQT}}
+
+\usepackage{LobsterTwo}
+\titleformat{\section}{\newpage\LobsterTwo \huge\bfseries}{\thesection.}{1em}{}
+\titleformat{\subsection}{\vspace{2em}\LobsterTwo \Large\bfseries}{\thesubsection.}{1em}{}
+\titleformat{\subsubsection}{\vspace{1em}\LobsterTwo \large\bfseries}{\thesubsubsection.}{1em}{}
+
+\newenvironment{lititle}%
+{\vspace{7mm}\LobsterTwo \large}%
+{\\}
+
+\renewenvironment{proof}{$\square$ \footnotesize\textit{Démonstration.}}{\begin{flushright}$\blacksquare$\end{flushright}}
+
+\title{TD du 13 mars}
+\author{William Hergès\thanks{Sorbonne Université - Faculté des Sciences, Faculté des Lettres}}
+
+\begin{document}
+	\maketitle
+	\section{Feuille 6}
+	\subsection*{Exercice 2}
+	On a : $$\mathrm{det}(A-\lambda I) = -\lambda^3+73\lambda-72 = 0$$
+	$\lambda = 1$ est une racine évidente. Pour trouver les autres, on se débrouille avec ça~:
+	$$ P(x) = (x-1)(ax^2+bx-c) $$
+	(ça nous donne $\lambda = 8$ et $\lambda = 9$)\\
+	Les sous-espaces propres pour $\lambda = -9$ est défini par tous les $u$ tels que $(A+9)u = 0$. On utilise un pivot de Gauss et un système. On fait la même pour les autres valeurs de $\lambda$.
+	
+	\subsection*{Exercice 3}
+	\begin{enumerate}
+		\item Elle n'est pas diagonalisable, car la valeur propre $\pi$ est de multiciplité $3$ et que la matrice n'est pas nulle.
+		\item Le déterminent est donné par le produit des cœfficiants de la diagonale. On a donc que les valeurs propres, sont celles de la diagonale. Ainsi, elles sont $1$, $2$ et $3$. Elle est donc diagonalisable car elle possède 3 valeurs propres réelles.
+		\item Dans les deux cas, on a que $a$ et $b$ sont des valeurs propres (où $a$ est de multiplicité 1 puis 2, et $b$ est de 2 puis 1). Aucune de ces matrices ne sont diagonalisables, car la dimension du noyau vaut à chaque fois 2.
+		\item À faire avec la «~nouvelle méthode~».
+		\item À faire avec la «~nouvelle méthode~».
+	\end{enumerate}
+
+	\begin{lititle}
+		Méthode pour trouver les valeurs propres rapidement
+	\end{lititle}
+	Comme les valeurs propres d'une matrice échelonnée (i.e. triangulaire) sont les cœfficiants de la diagonale, alors, pour les déterminer, on peut~:
+	\begin{itemize}
+		\item échelonner la matrice avec le pivot de Gauss (on sait le faire facilement et rapidement)~;
+		\item en déduire les cœfficiants.
+	\end{itemize}
+	Cette méthode semble plus rapide, car déterminer le noyau de $A-\lambda_iI_n$ pour tout $(\lambda_i)$ et pour toute matrice $A$ de taille $n$ est beaucoup plus long et complexe.
+
+	\subsection*{Exercice 6}
+	Semble pertinent et sympa
+
+	\subsection*{Exercice 7}
+	Semble pertinent et sympa
+
+	\subsection*{Exercice 9}
+	Semble pertinent et sympa
+\end{document}
diff --git a/semestre 2/maths/td/03-20.pdf b/semestre 2/maths/td/03-20.pdf
new file mode 100644
index 0000000..fa5079e
--- /dev/null
+++ b/semestre 2/maths/td/03-20.pdf
diff --git a/semestre 2/maths/td/03-20.tex b/semestre 2/maths/td/03-20.tex
new file mode 100644
index 0000000..96c19fb
--- /dev/null
+++ b/semestre 2/maths/td/03-20.tex
@@ -0,0 +1,193 @@
+%%=====================================================================================
+%%
+%%       Filename:  cours.tex
+%%
+%%    Description:  
+%%
+%%        Version:  1.0
+%%        Created:  03/06/2024
+%%       Revision:  none
+%%
+%%         Author:  YOUR NAME (), 
+%%   Organization:  
+%%      Copyright:  Copyright (c) 2024, YOUR NAME
+%%
+%%          Notes:  
+%%
+%%=====================================================================================
+\documentclass[a4paper, titlepage]{article}
+
+\usepackage[utf8]{inputenc}
+\usepackage[T1]{fontenc}
+\usepackage{textcomp}
+\usepackage[french]{babel}
+\usepackage{amsmath, amssymb}
+\usepackage{amsthm}
+\usepackage[svgnames]{xcolor}
+\usepackage{thmtools}
+\usepackage{lipsum}
+\usepackage{framed}
+\usepackage{parskip}
+\usepackage{titlesec}
+\usepackage{newtxtext}
+
+% \renewcommand{\familydefault}{\sfdefault}
+
+% figure support
+\usepackage{import}
+\usepackage{xifthen}
+\pdfminorversion=7
+\usepackage{pdfpages}
+\usepackage{transparent}
+\newcommand{\incfig}[1]{%
+	\def\svgwidth{\columnwidth}
+	\import{./figures/}{#1.pdf_tex}
+}
+
+\pdfsuppresswarningpagegroup=1
+
+\colorlet{defn-color}{DarkBlue}
+\colorlet{props-color}{Blue}
+\colorlet{warn-color}{Red}
+\colorlet{exemple-color}{Green}
+\colorlet{corol-color}{Orange}
+\newenvironment{defn-leftbar}{%
+  \def\FrameCommand{{\color{defn-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{warn-leftbar}{%
+  \def\FrameCommand{{\color{warn-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{exemple-leftbar}{%
+  \def\FrameCommand{{\color{exemple-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{props-leftbar}{%
+  \def\FrameCommand{{\color{props-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+\newenvironment{corol-leftbar}{%
+  \def\FrameCommand{{\color{corol-color}\vrule width 3pt} \hspace{10pt}}%
+  \MakeFramed {\advance\hsize-\width \FrameRestore}}%
+ {\endMakeFramed}
+
+\def \freespace {1em}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{defn-color}Définition~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{defn-leftbar},%
+ postfoothook=\end{defn-leftbar},%
+]{better-defn}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{warn-color}Attention\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{warn-leftbar},%
+ postfoothook=\end{warn-leftbar},%
+]{better-warn}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+notebraces={}{},%
+headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{exemple-color}Exemple~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{exemple-leftbar},%
+ postfoothook=\end{exemple-leftbar},%
+]{better-exemple}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{props-color}Proposition~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{props-leftbar},%
+ postfoothook=\end{props-leftbar},%
+]{better-props}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{props-color}Théorème~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{props-leftbar},%
+ postfoothook=\end{props-leftbar},%
+]{better-thm}
+\declaretheoremstyle[headfont=\sffamily\bfseries,%
+ notefont=\sffamily\bfseries,%
+ notebraces={}{},%
+ headpunct=,%
+% bodyfont=\sffamily,%
+ headformat=\color{corol-color}Corollaire~\NUMBER\hfill\NOTE\smallskip\linebreak,%
+ preheadhook=\vspace{\freespace}\begin{corol-leftbar},%
+ postfoothook=\end{corol-leftbar},%
+]{better-corol}
+
+\declaretheorem[style=better-defn]{defn}
+\declaretheorem[style=better-warn]{warn}
+\declaretheorem[style=better-exemple]{exemple}
+\declaretheorem[style=better-corol]{corol}
+\declaretheorem[style=better-props, numberwithin=defn]{props}
+\declaretheorem[style=better-thm, sibling=props]{thm}
+\newtheorem*{lemme}{Lemme}%[subsection]
+%\newtheorem{props}{Propriétés}[defn]
+
+\newenvironment{system}%
+{\left\lbrace\begin{align}}%
+{\end{align}\right.}
+
+\newenvironment{AQT}{{\fontfamily{qbk}\selectfont AQT}}
+
+\usepackage{LobsterTwo}
+\titleformat{\section}{\newpage\LobsterTwo \huge\bfseries}{\thesection.}{1em}{}
+\titleformat{\subsection}{\vspace{2em}\LobsterTwo \Large\bfseries}{\thesubsection.}{1em}{}
+\titleformat{\subsubsection}{\vspace{1em}\LobsterTwo \large\bfseries}{\thesubsubsection.}{1em}{}
+
+\newenvironment{lititle}%
+{\vspace{7mm}\LobsterTwo \large}%
+{\\}
+
+\renewenvironment{proof}{$\square$ \footnotesize\textit{Démonstration.}}{\begin{flushright}$\blacksquare$\end{flushright}}
+
+\title{TD du 20 mars}
+\author{William Hergès\thanks{Sorbonne Université - Faculté des Sciences, Faculté des Lettres}}
+
+\begin{document}
+	\maketitle
+	\subsection*{Exercice 1}
+	On n'oublira pas la proposition suivante~:
+	$$ |\mathcal{P}(E)| = 2^n $$
+	où $n$ est le cardinal de $E$ et $\mathcal{P}(E)$ désigne l'ensemble des parties de $E$.
+
+	\begin{enumerate}
+		\item C'est un quadruplet. Il y a donc $10^4$ arrangements possibles. Si on évite les répétitions, il y en a $\frac{10!}{6!}$
+		\item Il s'agit aussi d'un arrangement car l'ordre compte. Il y a donc $\frac{10!}{7!}$ possibilités.
+		\item Le nombre de chemin possible est $\binom{p+q}{p}$.
+		\item $12!$ manières de les aligner. Si $1$ et $2$ se suivent, alors il suffit de déterminer la place de $1$ pour déterminer $2$. On n'a donc que $11$ tomes à placer donnant ainsi $11!$ possibilités.
+		\item $\displaystyle\binom{p}{1}\times 2^{n-p}$ car on se retrouve à choisir une partie de $E\backslash A$ (on a donc $2^{n-p}$ choix)
+		\item $2^8 = 256$ car ordre avec répétition
+		\item $10^{14}$ car ordre avec répétition 
+		\item $\binom{11}{5}$. Si deux amis ne peuvent venir qu'ensemble, on a un ami en moins à choisir si un des deux amis arrivent. Si deux amis ne peuvent pas se voir, on a un ami de possible en moins.
+
+			Dans le premier cas, on a $\binom 93+\binom 95$ (car on somme les «~ou bien~»~!).
+
+			Dans le deuxième cas, on a $2\binom 94 + \binom 95$ (idem).
+		\item 
+	\end{enumerate}
+	\subsection*{Exercice 2}
+	Je sais faire, donc flemme (par contre j'ai calculé ce que ça valait en python)
+	\subsection*{Exercice 5}
+	\begin{enumerate}
+		\item $\displaystyle f(x) = \displaystyle\sum_{k=0}^{n-1}\binom nk\frac{2^{n-k}}{x^{n-k-1}} = 2\binom n1 + o_{x\to +\infty}(1) \xrightarrow[x \to \infty]{} 2n$
+		\item $\displaystyle\sum_{i=0}^{n} \binom ni x^i = (x+1)^n$
+
+			$\displaystyle\sum_{i=0}^{n} \binom ni = (1+1)^n = 2^n$
+
+			$\displaystyle\sum_{i=0}^{n} \binom ni(-1)^i = (1-1)^n = 0$
+	\end{enumerate}
+\end{document}
diff --git a/semestre 2/maths/template.tex b/semestre 2/maths/template.tex
index 23404b4..2c9c16a 100644
--- a/semestre 2/maths/template.tex
+++ b/semestre 2/maths/template.tex
@@ -29,8 +29,9 @@
 \usepackage{framed}
 \usepackage{parskip}
 \usepackage{titlesec}
+\usepackage{newtxtext}
 
-\renewcommand{\familydefault}{\sfdefault}
+% \renewcommand{\familydefault}{\sfdefault}
 
 % figure support
 \usepackage{import}
@@ -76,7 +77,7 @@
  notefont=\sffamily\bfseries,%
  notebraces={}{},%
  headpunct=,%
- bodyfont=\sffamily,%
+% bodyfont=\sffamily,%
  headformat=\color{defn-color}Définition~\NUMBER\hfill\NOTE\smallskip\linebreak,%
  preheadhook=\vspace{\freespace}\begin{defn-leftbar},%
  postfoothook=\end{defn-leftbar},%
@@ -85,7 +86,7 @@
  notefont=\sffamily\bfseries,%
  notebraces={}{},%
  headpunct=,%
- bodyfont=\sffamily,%
+% bodyfont=\sffamily,%
  headformat=\color{warn-color}Attention\hfill\NOTE\smallskip\linebreak,%
  preheadhook=\vspace{\freespace}\begin{warn-leftbar},%
  postfoothook=\end{warn-leftbar},%
@@ -94,7 +95,7 @@
  notefont=\sffamily\bfseries,%
 notebraces={}{},%
 headpunct=,%
- bodyfont=\sffamily,%
+% bodyfont=\sffamily,%
  headformat=\color{exemple-color}Exemple~\NUMBER\hfill\NOTE\smallskip\linebreak,%
  preheadhook=\vspace{\freespace}\begin{exemple-leftbar},%
  postfoothook=\end{exemple-leftbar},%
@@ -103,7 +104,7 @@ headpunct=,%
  notefont=\sffamily\bfseries,%
  notebraces={}{},%
  headpunct=,%
- bodyfont=\sffamily,%
+% bodyfont=\sffamily,%
  headformat=\color{props-color}Proposition~\NUMBER\hfill\NOTE\smallskip\linebreak,%
  preheadhook=\vspace{\freespace}\begin{props-leftbar},%
  postfoothook=\end{props-leftbar},%
@@ -112,7 +113,7 @@ headpunct=,%
  notefont=\sffamily\bfseries,%
  notebraces={}{},%
  headpunct=,%
- bodyfont=\sffamily,%
+% bodyfont=\sffamily,%
  headformat=\color{props-color}Théorème~\NUMBER\hfill\NOTE\smallskip\linebreak,%
  preheadhook=\vspace{\freespace}\begin{props-leftbar},%
  postfoothook=\end{props-leftbar},%
@@ -121,7 +122,7 @@ headpunct=,%
  notefont=\sffamily\bfseries,%
  notebraces={}{},%
  headpunct=,%
- bodyfont=\sffamily,%
+% bodyfont=\sffamily,%
  headformat=\color{corol-color}Corollaire~\NUMBER\hfill\NOTE\smallskip\linebreak,%
  preheadhook=\vspace{\freespace}\begin{corol-leftbar},%
  postfoothook=\end{corol-leftbar},%
diff --git a/semestre 2/philosophie des sciences/2- Les principales conceptions philosophiques de la validation empirique des théories scientifiques.md b/semestre 2/philosophie des sciences/2- Les principales conceptions philosophiques de la validation empirique des théories scientifiques.md
index d56fc74..c533b1f 100644
--- a/semestre 2/philosophie des sciences/2- Les principales conceptions philosophiques de la validation empirique des théories scientifiques.md
+++ b/semestre 2/philosophie des sciences/2- Les principales conceptions philosophiques de la validation empirique des théories scientifiques.md
@@ -137,9 +137,100 @@ Rien ne permet de dire qu'une théorie est vraie, ça permet juste d'évoquer la
 |> $P(\text{pile}) =\frac{1}{2}$ empêche les prédictions sur le prochain lancé
 |> ne peut pas être falsifié
 -> falsification « en pratique » a besoin d'utiliser les probas et les stats
-## D. Progrès scientifique
+## D. Ingrédients non empiriques de la validation des théories scientifiques ou introduction à la philosophie des sciences de Thomas Kuhn
 Falsificationnisme = science avance par essais et erreurs
 |> resistance aux tests empiriques est le plus important (est la « corroboration »)
 -> pourquoi devrait-on choisir une théorie comme celle-là pour progresser ?
 |> pas possible de rejeter une telle préférence sans l'induction
-|> *in fine*, on a besoin de l'induction, donc problème de Hume
\ No newline at end of file
+|> *in fine*, on a besoin de l'induction, donc problème de Hume
+
+Et si toute la science ne découle pas de l'expérience ?
+|> existe d'autres ingrédients ne dépendant pas de l'expérience pour pouvoir avancer
+-> présentation des grandes thèses de Thomas Kuhn
+
+Thomas Kuhn = philosophe des sciences de la deuxième partie du XXe siècle
+|> doctorat en physique
+|> enseignant d'histoire des sciences
+|> _La structure des révolutions scientifiques_ (SRS), 1962
+|> _La tension essentielle. Tradition et changement dans les sciences_, 1977 (recueil d'articles et de textes)
+
+```mermaid
+flowchart LR
+	A[Science normale]-- Révolution --->B[Science normale]
+	B -- Révolution -->C[Science normale]
+```
+
+Science normale = plus pratiquée et la plus normée
+Science révolutionnaire = exceptionnelle et sans normes, en renversant les normes
+-> ne sont pas unifiables : sont complètement différents
+|> les normes sont appelées « paradigmes »
+
+Paradigme permet aux scientifiques d'exercer normalement leur métier
+|> détermine les questions susceptibles de recevoir une réponse scientifique
+|> détermine les méthodes à utiliser
+|> détermine les réponses considérées comme satisfaisante
+|> définie aussi le groupe
+
+Grandes définitions de paradigme
+|> cadre cognitif = fournit une façon de penser le monde et de pratiquer les sciences empiriques
+|> matrice disciplinaire
+
+Cadre cognitif contient :
+- des cas paradigmatiques qui ont été des succès expérimentaux, qui fixent des phénomènes connus et expliqués et des instruments de mesure typiquement utilisés
+- hypothèses métaphysiques relatives à la nature des entités existantes et des processus qui donnent lieu à des phénomènes étudiés
+
+Exemples = paradigme newtonien avec l'exemple de Galilée
+
+Matrice disciplinaire
+|> implique possession commune de la part des spécialistes d'une discipline particulière
+|> ensemble se compose d'éléments ordonnée de diverses sortes, dont chacune demande une étude détaillée
+|> appartenir à une communauté scientifique, c'est penser dans les termes du paradigme
+|> paradigme comprendre des œuvres fondatrices (traités) et des ouvrages pédagogiques (manuels) dont l'étude prépare les étudiants à devenir membre de la communauté
+
+Les 4 types d'éléments de la matrice disciplinaire :
+- modèles (exemples)
+- analogies (éléments théoriques)
+- hypothèses métaphysiques
+- valeurs communes (appartenance à un groupe)
+
+Valeurs =
+- incorporés dans les théories (déterminisme, bourgeois vs prolétarien, sexisme)
+- portant sur les théories, pas sur leur contenu (beauté, simplicité, cohérence, utilité sociale)
+- relatives à la pratique de la science en général (honnête, indépendance, éthique)
+
+Sciences normales est fondamentalement conservatrice
+|> ne cherche pas à réfuter la théorie
+|> essaye de résoudre les énigmes (qu'elle soit théorique ou expérimentale) -> celles qui sont très complexes sont des anomalies, souvent elle ne pose pas de problème
+|> pression social car on doit appartenir au groupe
+
+On apprend la science par les exemples et les exercices
+|> pas vraiment d'esprit critique, mais plutôt la capacité à penser dans les termes du paradigme
+-> la remise en question du paradigme est rare
+
+> [!NOTE] Étapes du changement de paradigme
+> **L'entrée dans la crise** = fragilisation du paradigme
+> 
+> **Période de révolution** = deux paradigmes rivaux
+> -> besoin d'avoir un autre paradigme pour que ça change
+> 
+> **Sortie de la révolution** = paradigme sortant devient la norme
+
+Le changement de paradigme commence suite à un grands nombres d'anomalies et l'émergence de théories concurrentes incompatibles avec le paradigme existant
+
+La compétition de paradigmes casse l'autorité de l'ancien au profit du nouveau
+|> cohérence interne devient de moins en moins évide
+-> l'activité scientifique n'est plus régulée (d'où le terme révolution)
+
+Changement arrive suite à un rapport de force
+|> ressemble à un conversion pour les individus
+|> le changement ne suit d'aucune règle rationnelle
+|> facteurs déterminant l'adoption ne sont pas d'ordre épistémique ou empirique
+
+Ne peut pas être rationnel car les anciens ne comprennent pas les nouveaux (ne peuvent pas communiquer)
+-> est l'incommensurabilité
+|> peut être linguistique (sens des mots), sur les expériences (n'analysent pas de la même manière)...
+
+Critère de démarcation est la capacité à progresser dans les paradigmes
+
+Il n'existe néanmoins des valeurs universels comme le principe de non contradiction (ou l'empirisme pour Kuhn)
+|> est un relativisme relatif
\ No newline at end of file
diff --git a/semestre 2/philosophie des sciences/3- Les constituants théoriques de l'empirisme.md b/semestre 2/philosophie des sciences/3- Les constituants théoriques de l'empirisme.md
new file mode 100644
index 0000000..52704ba
--- /dev/null
+++ b/semestre 2/philosophie des sciences/3- Les constituants théoriques de l'empirisme.md
@@ -0,0 +1,29 @@
+---
+tags:
+  - sorbonne
+  - philosophie
+  - philosophie-sciences
+semestre: 2
+---
+D'autres sujets de philosophie des sciences, toujours pour questionner l'empirisme et la place de l'expérience dans les sciences
+## A. Les constituants théories de l'observation
+Charge théorique de l'observation
+|> notion de Hanson, _Patterns of Discovery_, 1
+|> perception doit être distinguée de la stimulation sensorielle (idée classique)
+
+Les différences de perception illustrent les différences dans les théories d'arrière plan
+|> cf [[3- Voir et interpréter]]
+
+Kuhn est d'accord (chapitre 9 de SRS), mais
+|> insiste sur les différences par rapport à l'observation d'images ambiguës : la charge théorique est irréversible
+|> c'est le paradigme qui détermine l'expérience scientifique
+
+biais = erreur systématique
+
+Il possible d'attribuer une réfutation apparente à une hypothèse auxiliaire
+|> est une forme de sauvetage de la théorie en expliquant que l'appareil marche pas par exemple
+|> expérience seule n'impose pas le choix d'une théorie au détriment d'une autre
+
+Les données ne sont pas offertes
+|> besoin de les traiter (correction de biais, prise en compte des erreurs, sélection au sein des données, « nettoyage »)
+|> besoin de les interpréter (lecture des images, catégorisation)
\ No newline at end of file
diff --git a/semestre 2/philosophie des sciences/td/1- Le raisonnement expérimental.md b/semestre 2/philosophie des sciences/td/1- Le raisonnement expérimental.md
index ff1d3a8..ba26286 100644
--- a/semestre 2/philosophie des sciences/td/1- Le raisonnement expérimental.md
+++ b/semestre 2/philosophie des sciences/td/1- Le raisonnement expérimental.md
@@ -12,7 +12,7 @@ Philo continentale = analyse les phénomènes et les concepts
 
 Épistémologie =
 - théorie de la connaissance (vision analytique)
-- comment fonctionne les sciences ? -> vision meta-scientifique (vision continentale)
+- philosophie des sciences + histoire des sciences (vision continentale)
 
 Philosophie des sciences cherche à clarifier la nature et les fondements de la connaissance scientifique tout en cherchant à explorer certaines de ses conséquences philosophiques
 |> ici ne traite que les sciences naturelles et les sciences humaines et sociales (pas de sciences formelles !)
@@ -40,11 +40,11 @@ Comment peut-on distinguer les variations significatives dès variations superfl
 |> est le problème de la complétude de l'induction
 |> on peut les distinguer à l'aide de notre connaissance théorique de la situation
 |> or, cela revient à admettre que la théorie joue un rôle crucial, ce qui ne devrait pas être le cas
--> voir [[2- Le problème de l’induction]]
+-> voir [[2- Le problème de l'induction]]
 
 Comment fonder les théories issues de raisonnements inductifs ?
 |> un seul contre-exemple suffirait de casser l'induction, mais une infinité d'observations ne suffiraient pas à prouver qu'elle est vraie
--> voir [[2- Le problème de l’induction]]
+-> voir [[2- Le problème de l'induction]]
 ## Claude Bernard, _Introduction à l’étude de la médecine expérimentale_
 2 parties :
 1. la méthode expérimentale en science -> quelle méthode utiliser et ce qu'on ne doit absolument pas faire
diff --git a/semestre 2/philosophie des sciences/td/2- Le problème de l'induction.md b/semestre 2/philosophie des sciences/td/2- Le problème de l'induction.md
index a675c63..63f2ee9 100644
--- a/semestre 2/philosophie des sciences/td/2- Le problème de l'induction.md
+++ b/semestre 2/philosophie des sciences/td/2- Le problème de l'induction.md
@@ -21,10 +21,10 @@ Présentation de Hume
 Chapitre IV questionne la création dans l'esprit de la croyance de la régularité de la nature
 |> est appelé le problème de l'induction
 |> contient une distinction appelée _la fourche de Hume_
-## David Hume, Enquête sur l’entendement humain, IV
+## David Hume, _Enquête sur l’entendement humain_, IV
 §1 = saut logique entre induction et déduction
 |> la déduction est toujours inféré de l'induction dans la méthode empiriste
-|> cherche à expliquer la chaîne de raisonnement dans ce saut logique : «  La connexion entre ces propositions n’est pas intuitive »
+|> cherche à expliquer la chaîne de raisonnement dans ce saut logique : « La connexion entre ces propositions n’est pas intuitive »
 |> « On réclame un moyen terme qui puisse rendre l’esprit capable de tirer une telle inférence si, en vérité, elle se tire par raisonnement et argumentation »
 |> cherche le raisonnement derrière
 -> comment arrive-t-on à faire ce saut ?
@@ -36,7 +36,7 @@ Chapitre IV questionne la création dans l'esprit de la croyance de la régulari
 
 §4 = matérialisation du problème de l'induction
 |> nos raisonnements moraux découlent du raisonnement causal
-|> on justifie la régularité par la régularité (nature est régulière car on la suppose régulière)
+|> on justifie la régularité par la régularité (nature est régulière car on la suppose régulière) ==à corriger== (voir [[2- Les principales conceptions philosophiques de la validation empirique des théories scientifiques]], A, 2)
 
 §5 = comment faire pour rester empiriste ?
 |> ce n'est pas parce que nous ne l'avons pas fondé que nous ne pouvons pas les utiliser
diff --git a/semestre 2/philosophie des sciences/td/3- Voir et interpréter.md b/semestre 2/philosophie des sciences/td/3- Voir et interpréter.md
index 7c262da..5371f5d 100644
--- a/semestre 2/philosophie des sciences/td/3- Voir et interpréter.md
+++ b/semestre 2/philosophie des sciences/td/3- Voir et interpréter.md
@@ -43,7 +43,7 @@ Besoin de supposer que le tout est cohérent
 
 > [!info] L'observation *n*'est *pas* le moyen le plus sûr de fonder une connaissance en raison
 > L'énoncé d'observation peut être tout aussi imprécis que la théorie qu'il y a derrière
-## Texte de Hanson
+## Texte de Hanson, _Patterns of Discovery_
 Exemples donnés cassent le point de vu inductiviste
 
 Différence entre bébé et profane
diff --git a/semestre 2/philosophie des sciences/td/5- Limites du falsificationnisme.md b/semestre 2/philosophie des sciences/td/5- Limites du falsificationnisme.md
new file mode 100644
index 0000000..5f5b13b
--- /dev/null
+++ b/semestre 2/philosophie des sciences/td/5- Limites du falsificationnisme.md
@@ -0,0 +1,46 @@
+---
+tags:
+  - sorbonne
+  - philosophie
+  - philosophie-sciences
+  - td
+semestre: 2
+---
+Critère du falsificationnisme : un énoncé scientifique doit être falsifiable
+|> n'est pas du tout habituel dans la création de la science
+-> n'est pas pertinent pour tous les types de science (comme l'histoire)
+
+Autre problème = les expériences sont remplies de théories
+|> cf [[3- Voir et interpréter]]
+|> la méthode falsificationniste peut donc se tromper
+-> l'outil pour la réfutation est donc faillible
+|> on devrait donc pouvoir réhabiliter certaines observations
+|> un des problèmes est par exemple l'utilisation d'outils inadaptés
+
+Deux problèmes jusqu'ici :
+- problème de l'induction
+- problème de la démarcation
+
+Nouveau problème : celui de Duhem
+|> quelle partie de la théorie est mise en cause par une réfutation empirique
+## Pierre Duhem, _La théorie physique, son objet, sa structure,_ I, VI
+On a besoin d'interpréter les résultats de l'expérience pour voir la réfutation
+|> cette subjectivité s'éloigne de la démonstration par l'absurde en mathématiques
+-> oppose la physique aux sciences formelles
+|> casse avec le côté traditionnel de la philosophie des sciences considérant que la physique est la science théorique par excellence
+
+Quand un expérience contredit la théorie
+|> ce n'est pas une unique hypothèse qui est contredite, mais l'ensemble
+|> impossible de déterminer quelle théorie l'est d'une manière déductive, car la faute pourrait venir d'une hypothèse auxiliaire
+-> forme d'holisme
+
+Donc, la réfutation dépend de la vision des scientifiques
+|> est une faculté qu'il appelle le « bon sens » -> valeur épistémique
+|> est plus subjective que ce que [[4- Le falsificationnisme]] pourrait laisser penser
+|> universalisation de la vision par la communauté
+
+Pour réfuter la bonne théorie, on aurait besoin d'avoir accès au fonctionnement interne
+|> est impossible
+|> et si on y avait accès, on ne pourrait pas comprendre comment ça marche
+
+Cette théorie est donc discontinuiste -> il y a une discontinuité entre les théories en sciences et toutes ne fonctionnent pas de la même manière
\ No newline at end of file
diff --git a/semestre 2/philosophie des sciences/td/Correction du contrôle.md b/semestre 2/philosophie des sciences/td/Correction du contrôle.md
new file mode 100644
index 0000000..82858c9
--- /dev/null
+++ b/semestre 2/philosophie des sciences/td/Correction du contrôle.md
@@ -0,0 +1,46 @@
+---
+tags:
+  - sorbonne
+  - philosophie
+  - td
+  - philosophie-sciences
+semestre: 2
+---
+Moyenne : 12/20
+C'était généralement bon
+
+Pas besoin d'expliquer le sens des phrases (sinon c'est de la paraphrase)
+|> besoin d'expliciter le fonctionnement de l'argumentation
+|> on cherche les particularités du texte par rapport aux cours qu'on a eu
+
+> [!info] Comment s'entraîner au commentaire ?
+> On prend un texte et on fait un commentaire dessus
+> On peut aussi lire une bonne copie (il y en aura sur le moodle)
+
+Pour régler le manque de précision, on a besoin de penser avant à ce qu'on souhaite dire
+
+---
+
+Épistémologie =
+- théories de la connaissances (analytique)
+- questionnement propre aux méthodes scientifiques (continentales)
+
+*voir copie pour l'entre deux*
+
+Critique de l'empirisme =
+- observation n'est pas neutre car influencé par les théories
+- principe d'induction n'est pas fondé en raison
+- (les théories abstraites ne peuvent pas être scientifiques)
+
+Problème de l'induction = le fait que ça tourne en rond
+|> mais reste pragmatiquement utile
+
+Vision = ce qui se passe physiquement dans l'œil (image rétinienne)
+Expérience visuelle = interprétation du fait de voir
+
+Cœur du texte est l'exposition de ses doutes concernant la scientificité sur certaines théories
+|> début du malaise généré par ces premiers doutes
+|> dogmatisme presque sectaire est très présent dans son vocabulaire suite à un pouvoir explicatif
+|> ce pouvoir n'est pas normatif : elles expliquent très bien *a posteriori* et non *a priori*
+|> ces théories ne reposent que sur un catalogue d'expériences modifiables *ad hoc*
+|> à l'origine, la thèse manque de précision pour pouvoir être testé -> problème sémantique : on peut réinterpréter comme on veut
\ No newline at end of file
diff --git a/semestre 2/philosophie générale/1- Figures de la vérité.md b/semestre 2/philosophie générale/1- Figures de la vérité.md
index 3ed8fbc..dd0a613 100644
--- a/semestre 2/philosophie générale/1- Figures de la vérité.md
+++ b/semestre 2/philosophie générale/1- Figures de la vérité.md
@@ -79,7 +79,7 @@ Les « maîtres de vérité » vs les savants (ceux qui cherchent la véritÃ
 |> vérité dans le sens mythique / religieux
 |> comment passe-t-on de cette vision à celle rationnelle ?
 |> on peut quand même voir cette figure dans certaines personnalités
-|-> les discours paraissent vrais car la personne le prononçant possède une force (like Trump)
+|-> les discours paraissent vrais car la personne les prononçant possède une force (like Trump)
 
 Figures de maîtres de vérité :
 - Aède (poète) diffuse les savoirs via la parole
@@ -99,9 +99,9 @@ Quelles vérités prononcent le roi ?
 |> est un rituel provenant des dieux 
 -> le roi ne sert que de relais des dieux
 
-Ici, la vérité est un type de parole prononcée dans certaines conditions par un personne investi de pouvoir particuliers
+Ici, la vérité est un type de parole prononcée dans certaines conditions par une personne investie de pouvoir particuliers
 |> dépend donc de la personne
-|> parole est efficace réalisant une action -> est performative (poète montre les puissances invisibles, roi institue la justice)
+|> parole efficace réalise une action -> est performative (poète montre les puissances invisibles, roi institue la justice)
 |> parole ne dépend pas du temps (présent gnomique, présent de vérité générale)
 |> ne cherche jamais l'assentiment du locuteur ou du groupe et n'attend pas de validation
 -> parole transcende les humains et est le privilège d'une fonction sociale
@@ -133,13 +133,13 @@ Critique de l'*ad populum*
 |> besoin de l'accord des interlocuteurs, surtout quand ils ne sont pas d'accord au départ
 
 Critique de l'*ad hominem*
-|> transforment le dialogue en dispute
+|> transforme le dialogue en dispute
 
 Cette vision demande une égalité des interlocuteurs
 |> lien entre vérité et éthique
 -> besoin de veiller au respect de son interlocuteur et certaines règles
 |> n'est pas l'unique forme d'accès à la vérité
-|> mais tous les énoncés est adressé à un interlocuteur et implique la possibilité de l'examen par le lecteur
+|> mais tous les énoncés sont adressés à un interlocuteur et impliquent la possibilité de l'examen par le lecteur
 
 La vérité est, d'une manière générale, toujours menacée par les passions
 ## C. La place de la preuve
@@ -163,7 +163,7 @@ Les prémisses sont vraies et premières si elles sont vraies par elle-même
 
 Premiers principes de la connaissance
 |> principe de non contradiction -> $A\land\lnot A$ est impossible
-|> principe du tiers exclu -> $A\lor B$ où $B$ exclue $A$ est complète (demain il pleuvra ou il ne pleuvra pas) est toujours vrai
+|> principe du tiers exclu -> $A\lor B$ où $B$ exclue $A$ est complète (demain il pleuvra ou il ne pleuvra pas) et toujours vrai
 |> principe d'identité -> $A=A$ est vrai
 -> permettent la connaissance et sont les points de départ
 |> dirigent la marche de la connaissance
@@ -189,7 +189,82 @@ Une démonstration doit donc mettre en évidence des causes
 4. cause finale -> but / fonction d'une chose
 
 Prémisses doivent être vraies, premières, immédiates, mieux connues que la conclusion, antérieures à la conclusion et causes de la conclusion
+-> est nécessaire pour avoir un point de départ premier
 
 Indémontrable = immédiat *ici*
 
-Démonstration reproduit sur le plan du discours ce qu'il se produit sur le plan causal
\ No newline at end of file
+Démonstration reproduit sur le plan du discours ce qu'il se produit sur le plan causal
+
+Deux types : pour nous et en soi
+|> objectif est d'atteindre l'en soi, mais on part souvent du pour nous
+|> ce qui est antérieur et mieux connu pour nous sont les choses que l'on perçoit
+|> ce qui l'est en soi touche l'universel ($\forall$), inaccessible pour nos sens (sont ponctuels ($\exists$))
+|> universel énonce une propriété essentielle
+
+Si une démonstration n'utilise pas des prémisses antérieur et mieux connu en soi, alors elle n'est pas fiable pour la connaissance
+
+Déduction dialectique = démonstration se basant sur des idées admises
+|> idées partagées par presque tous ou par les experts les plus reconnus
+|> le côté admis possède des garants réels autorisés ou accrédités par une adhésion affective
+|> s'oppose au *paradoxe* (dans son sens ancien : côté communément admis)
+|> ne caractérise pas la réalité de l'idée
+-> cherche à répondre à une alternative pratique entre un choix et un rejet
+|> est une vision pratique de la démonstration scientifique
+|> mais elle n'établit pas la vérité : on cherche la connaissance, on ne la montre pas
+
+La dialecticien fait des déductions dialectiques en divisant
+|> il distingue et choisit une vision
+|> cherche à préparer / éprouver quelque chose
+-> nous pousse à devenir habile argumentateur
+|> risque de nous faire devenir sceptique, car peut neutraliser la vérité (ou peut argumenter pour $A$ et $\lnot A$)
+
+Aristote dit qu'on peut facilement choisir après la déduction dialectique
+|> besoin d'un critère supplémentaire pour choisir correctement l'une des deux hypothèses
+|> l'aptitude à bien choisir le vrai et à bien éviter le faux -> est le don naturel en nature de vérité
+|> est ce que les gens bien doués par la nature peuvent faire -> capacité à discerner le meilleur
+-> permet le dépassement du scepticisme et donc l'usage philosophique de la dialectique
+
+Bon choix du vrai permet d'appliquer le discernement de l'humain bon dans l'action
+|> vérité est l'analogue du bon
+
+Quelles sont les limites d'une preuve ?
+|> deux gros problèmes
+|> liés aux prémisses
+
+Soit les prémisses sont des principes, soit elles ne le sont pas
+|> mène aux principaux problèmes
+
+Si les prémisses ne sont pas des principes, alors on doit vérifier qu'elles soient vraies
+|> besoin de démontrer de ces prémisses
+|> tant qu'on n'a pas de valeurs de principe, besoin de tout démontrer
+|> il pourrait exister des principes méconnaissables (ou qu'ils n'existent pas)
+-> aucune démonstration n'est possible à cause de la régression à l'infini
+
+Si les prémisses sont des principes, alors elles sont indémontrables
+|> si on veut les démontrer, on se retrouve à faire un cercle vicieux (ou une pétition de principe) -> voir Aristote, _Métaphysique_, $\Gamma$, 4 pour le principe de non contradiction
+|> comment peut-on s'assurer de leur véracité ? il existerait un vrai sans preuve directe
+|> en admettant leur véracité, comment s'assurer que nous sommes parvenus jusqu'à eux ?
+-> besoin d'avoir une indication de ces principes
+=> comment identifier la vérité sans démonstration ?
+
+Méthode selon Pascal, _ouvrage (moodle)_
+|> prouver à l'aide d'une démonstration
+|> disposer toutes les propositions dans un certain ordre
+|> deux méthodes : une parfaite et une celle de la géométrie (qui n'est donc pas parfaite)
+|> méthode parfaite s'assure d'employer des termes dont le sens est clairement défini, elle n'avance aucune proposition non démontrer par des vérités déjà connues
+|> méthode parfaite est impossible car définir tous les termes demande de définir encore plus de termes *et* parce que tout démontrer demande un temps infini -> comment s'assurer que quand on s'arrête, tout puisse être vrai ?
+|> l'esprit humain s'arrête au niveau des mots primitifs non définissables et des principes dont la clarté est suffisante ne demandant pas la clarté -> sont suffisants, mais n'assure pas complètement la vérité
+-> la géométrie s'en rapproche le plus : elle est aussi certaine, mais moins convaincante
+
+escape, temps, mouvement, égalité = exemples de mots primitifs pour la géométrie
+lumière, humain, être = exemples de mots primitifs
+-> ils désignent naturellement les choses qu'ils signifient
+|> personne n'est d'accord, mais tout le monde sait à quoi renvoie ces termes
+-> est la marque d'une perfection selon Pascal
+|> pas besoin de les définir en raison de leur extrême évidence
+|> quand on dit « le temps passe », tout le monde comprend
+
+On a donc besoin d'avoir des prémisses claires et évidentes ainsi qu'un raisonnement rendant nécessaire la conclusion face aux prémisses
+
+Mais comment distinguer la vérité avant la démonstration ?
+|> besoin de critères
\ No newline at end of file
diff --git a/semestre 2/philosophie générale/2- Les critères de vérités.md b/semestre 2/philosophie générale/2- Les critères de vérités.md
new file mode 100644
index 0000000..c9baf3c
--- /dev/null
+++ b/semestre 2/philosophie générale/2- Les critères de vérités.md
@@ -0,0 +1,7 @@
+---
+tags:
+  - sorbonne
+  - philosophie
+  - philosophie-générale
+semestre: 2
+---
diff --git a/semestre 2/philosophie générale/td/1- Platon.md b/semestre 2/philosophie générale/td/1- Platon.md
index 1487600..381cbeb 100644
--- a/semestre 2/philosophie générale/td/1- Platon.md
+++ b/semestre 2/philosophie générale/td/1- Platon.md
@@ -56,6 +56,6 @@ Dans la partie 2, on quitte l'argumentation pour arriver vers un mythe
 > [!tip] Organisation d'un texte de Platon
 > Souvent, il existe plusieurs niveaux argumentatifs chez Platon
 > |> mieux vaut les suivre quand on fait un commentaire
-> |-> le niveau mythique très souvent est complexe
+> |-> le niveau mythique est très souvent complexe
 
 81d à 86d est aussi très intéressant
\ No newline at end of file
diff --git a/semestre 2/philosophie générale/td/4- Pascal.md b/semestre 2/philosophie générale/td/4- Pascal.md
index c58f386..5cc17eb 100644
--- a/semestre 2/philosophie générale/td/4- Pascal.md
+++ b/semestre 2/philosophie générale/td/4- Pascal.md
@@ -6,7 +6,26 @@ tags:
   - td
 semestre: 2
 ---
+DS = questions de cours (une question sur chaque texte) + introduction et un paragraphe argumenté
+
 *on skip le texte 4, c'est donc le texte 5*
 
 Pascal, _Pensées_ = grand chantier pas fini
-|> est un texte apologétique
\ No newline at end of file
+|> est un texte apologétique
+-> existe pleins de notations et d'organisation ; préfixe `L` indique l'édition de Lafuma
+
+Thèse centrale = la raison n'est pas l'unique manière d'avoir des vérités
+|> cœur permet d'avoir accès aux certitudes -> est le fondement de la science
+
+Renverse la hiérarchie de la connaissance
+|> ce qui n'est pas utile à prouver (ce qui est évident), alors on n'a pas besoin prouver
+
+Foi est une relation de confiance -> provient du cœur
+
+Tyrannie chez Pascal (L.58 - L.59)
+|> dérive universel de domination
+|> confondre les voies légitimes
+
+Grosse critique du scepticisme car est une négation des certitudes du cœur
+
+Pour Pascal, les certitudes sont bien plus importantes que les choses démontrées par la raison
\ No newline at end of file
diff --git a/semestre 2/philosophie générale/td/Correction DS.md b/semestre 2/philosophie générale/td/Correction DS.md
new file mode 100644
index 0000000..21af83f
--- /dev/null
+++ b/semestre 2/philosophie générale/td/Correction DS.md
@@ -0,0 +1,43 @@
+---
+tags:
+  - sorbonne
+  - philosophie
+  - philosophie-générale
+  - td
+semestre: 2
+---
+Moyenne à 13
+|> notes vont de 2 à 17.5
+
+L'évidence chez Descartes est une propriété de la perception
+|> il n'existe aucune zone d'ombre
+|> perception est évidente quand elle est claire et distincte
+
+Certitude chez Descartes est opposé au doute
+|> est l'équivalent de l'évidence dans l'entendement pour la volonté
+|> est l'expérience de la vérité
+```mermaid
+flowchart TB
+	A[Esprit] --- B[Entendement]
+	A --- C[Volonté]
+	B --- B1[Évidence]
+	C --- C1[Certitude]
+```
+
+Quand on fait une accroche, on a besoin de la continuer lors de la problématisation
+
+Définition doit partir du sens commun pour rester large
+|> on évite de chercher l'essence
+|> on prépare le problème
+|> on évite de trop s'inspirer des auteurs pour éviter de refermer le sujet
+
+Problème ne doit pas répéter la question
+|> doit former une alternative entre deux points de vue contradictoire
+
+Peut-on = capacité logique et devoir moral
+1. douter de la vérité d'une opinion
+2. douter de la vérité en générale
+	1. douter de ce qu'est la vérité (sa nature)
+	2. douter de son objectivité (aptitude à représenter des choses hors de moi)
+
+Expliciter les distinctions conceptuelles
\ No newline at end of file
diff --git a/semestre 2/tpe/La théorie des Idées de Platon expliquée par la programmation objet.md b/semestre 2/tpe/La théorie des Idées de Platon expliquée par la programmation objet.md
new file mode 100644
index 0000000..2ed7105
--- /dev/null
+++ b/semestre 2/tpe/La théorie des Idées de Platon expliquée par la programmation objet.md
@@ -0,0 +1,103 @@
+---
+tags:
+  - sorbonne
+  - philosophie
+  - informatique
+semestre: 2
+---
+Idées : vulgariser la théorie des Idées de Platon aux développeurs
+|> demande aussi de vulgariser la programmation objet pour le professeur de philosophie
+|> est lié à mon objectif de devenir prof : vulgarisation est proche de l'enseignement
+## Introduction
+Je fréquente beaucoup de développeurs et une bonne partie d'entre-eux est intéressée par la philosophie, mais il ne savent pas du tout par où commencer. Cette absence de repère est totalement compréhensible quand nous faisons face à une montagne de connaissance s'étalant de l'Antiquité lointaine à maintenant. Trouver une entrée accessible dans ces plus de 2500 ans d'histoire est une tache dantesque pour une personne seule.
+
+En tant qu'étudiant en double licence Science-Philosophie, plus précisément en Informatique-Philosophie, je trouve qu'il est de mon devoir de lier ces deux disciplines que tout semble éloigner, notamment pour ceux venant de l'un cherchant à comprendre l'autre. Ce travail personnel encadré (TPE) de la faculté des lettres a été pensé en parallèle avec le sujet que je traite dans l'atelier de recherche encadré (ARE) de la faculté des sciences et ingénierie. Ici, j'essaierai de lier l'informatique à la philosophie tandis que mon projet de l'ARE s'occupera de lier la philosophie à l'informatique.
+
+Pour initier les développeurs à la philosophie, j'ai décidé de vulgariser la théorie des Idées de Platon en utilisant un paradigme fondamental en informatique : la programmation objet (POO). Ce concept particulièrement utilisé en entreprise et très répandu me semble comme étant la meilleure manière d'initier à l'entreprise philosophique de Platon, auteur essentiel de la philosophie antique ayant servi de fondement à la majorité de la philosophie continentale. En effet, de nombreux concepts de cette programmation se rapproche grandement de la théorie platonique de la connaissance : les objets en POO seraient les Idées de Platon et l'instance d'un objet serait l'équivalent de son image.
+
+Avant de plus détailler les liens entre la théorie des Idées et la programmation objet, il me semble essentiel de vulgariser le fonctionnement de cette théorie pour les philosophes. Ensuite, je détaillerai ces liens étonnant pour finalement critiquer cette analogie surprenante.
+## La programmation objet
+Quand une développeur conçoit un programme, un logiciel, un site web, il a le choix entre plusieurs approches. Toutes possèdent des avantages comme la robustesse de sa conception et des inconvénients comme la difficulté d'utilisation de la technologie. La programmation objet (POO) est une approche spécifique d'un problème : elle vise à construire des objets génériques qui représentent les états du système. Cette vision de la programmation est si importante qu'elle est considérée comme un paradigme : ce choix modifie grandement l'approche du problème et donc sa résolution.
+
+La POO est très utilisée en entreprise pour sa robustesse et sa portabilité. En effet, en créant un objet représentant un état précis d'un sous-système, on contraint le système à être dans un état forcément connu. De plus, de nombreux langages mettant en place de la POO ne dépendent pas du système d'exploitation ou de l'architecture de la machine pour fonctionner, comme Java, Python ou Ruby. Par contre, son principal désavantage est son absence de flexibilité directement impliquée par sa grande robustesse. De plus, cette approche est souvent plus lourde sur les performances et sur l'écriture du programme.
+
+Mais, concrètement, à quoi ressemble de la POO ?
+
+Prenons l'exemple d'un jeu vidéo. Son créateur souhaite intégrer une chaise pour que le joueur puisse s’asseoir. Le développeur devra donc créer l'objet chaise décrivant toutes les propriétés et tous les états possibles de la chaise. Il s'agit philosophiquement parlant de l'*essence* de la chaise. Cette déclaration s'écrit dans une classe, qui n'est que la représentation formelle de l'objet. Dans notre cas, la chaise doit être repérée dans l'espace : on doit donc lui rajouter des coordonnées.
+```
+classe Chaise = {
+	Nombre x
+	Nombre y
+	Nombre z
+}
+```
+Ce pseudo-code représente la chaise telle qu'on la définit au-dessus : elle possède trois coordonnées nommées `x`, `y` et `z` qui sont des nombres.
+
+Cette définition très simple nous limite grandement : on ne peut pas s'asseoir dessus par exemple. On doit donc lui rajouter une nouvelle propriété binaire indiquant si quelqu'un est assis dessus ainsi que cette personne. On obtient donc :
+```
+classe Chaise = {
+	Nombre x
+	Nombre y
+	Nombre z
+	
+	Binaire une_personne_est_elle_assise
+	Personne personne_assise
+}
+```
+Notre chaise est maintenant plus intéressante, mais on ne peut toujours pas s'asseoir dessus : on peut juste représenter une personne assise. Pour rajouter cette fonctionnalité, on doit créer une méthode pour s'asseoir dessus. Pour appliquer la méthode, on a besoin de lui donner la personne à asseoir :
+```
+classe Chaise = {
+	Nombre x
+	Nombre y
+	Nombre z
+	
+	Binaire une_personne_est_elle_assise
+	Personne personne_assise
+	
+	méthode asseoir_une_personne(Personne personne_a_s_asseoir)
+}
+```
+Maintenant, notre chaise est totalement fonctionnelle : on peut la mettre dans l'espace et faire s'asseoir quelqu'un dessus, mais on ne peut pas la créer ! Pour ce faire, on rajoute une méthode de création appelée constructeur, qui ici a besoin des coordonnées dans l'espace :
+```
+classe Chaise = {
+	Nombre x
+	Nombre y
+	Nombre z
+	
+	Binaire une_personne_est_elle_assise
+	Personne personne_assise
+	
+	méthode asseoir_une_personne(Personne personne_assise)
+	
+	méthode constructeur(Nombre x, Nombre y, Nombre z)
+}
+```
+Notre classe `Chaise` est prête à être utilisée. On peut maintenant créer une nouvelle chaise en lui indiquant où elle est. Cette nouvelle instance ne modifie pas la classe `Chaise` : elle ne fait qu'utiliser ses propriétés. L'instance de la classe est accidentelle par rapport à sa classe.
+
+Après, si on le souhaite, on peut créer des relations entre les classes pour simplifier la représentation. Je peux, par exemple, créer une classe `ObjetDansEspace` qui possédera déjà les propriétés pour être représentée dans l'espace. On dit alors que la classe `Chaise` étend de la classe `ObjetDansEspace` ce qui peut être représenté comme ceci :
+```
+classe Chaise étend de ObjetDansEspace = {
+	Binaire une_personne_est_elle_assise
+	Personne personne_assise
+	
+	méthode asseoir_une_personne(Personne personne_assise)
+}
+```
+Nous n'avons plus besoin de définir les coordonnées et le constructeur car la classe `ObjetDansEspace` s'en occupe à notre place. Si on devait schématiser, on aurait quelque chose comme ça :
+```mermaid
+flowchart RL
+	A[Chaise] ---> B[ObjetDansEspace]
+```
+La flèche indique que la chaise est un objet dans l'espace.
+
+D'un point de vue plus théorique, toutes les classes sont des objets - d'où le nom de programmation objet ! -, donc on aurait :
+```mermaid
+flowchart RL
+	A[Chaise] ---> B[ObjetDansEspace]
+	B ---> C[Objet]
+```
+
+Maintenant que l'on possède les bases en programmation objet, on peut passer à la théorie des Idées.
+## La programmation objet comme analogie de la théorie des Idées
+## Critique de l'analogie
+## Conclusion
\ No newline at end of file