ajout de tous les cours et TP préparés cet été
This commit is contained in:
177
Calculabilité/Exercices.md
Normal file
177
Calculabilité/Exercices.md
Normal file
@@ -0,0 +1,177 @@
|
||||
# Exercices : Calculabilité et Décidabilité
|
||||
|
||||
---
|
||||
|
||||
## Exercice 1 : Problèmes décidables ou non ?
|
||||
|
||||
Pour chaque problème ci-dessous, indiquez s'il est **décidable** ou **indécidable**. Justifiez votre réponse.
|
||||
|
||||
1. Déterminer si un nombre entier est premier.
|
||||
|
||||
2. Déterminer si une chaîne de caractères est un palindrome.
|
||||
|
||||
3. Déterminer si un programme Python quelconque va s'arrêter.
|
||||
|
||||
4. Déterminer si un nombre est divisible par 7.
|
||||
|
||||
5. Déterminer si deux programmes Python produisent toujours le même résultat pour toutes les entrées possibles.
|
||||
|
||||
---
|
||||
|
||||
## Exercice 2 : Écrire des prédicats
|
||||
|
||||
Un **prédicat** est une fonction qui renvoie un booléen. Écrivez en Python les prédicats suivants :
|
||||
|
||||
### 2.1 Prédicat `est_puissance_de_2`
|
||||
|
||||
```python
|
||||
def est_puissance_de_2(n):
|
||||
"""
|
||||
Renvoie True si n est une puissance de 2, False sinon.
|
||||
Exemples : 1, 2, 4, 8, 16, 32... sont des puissances de 2.
|
||||
"""
|
||||
# À compléter
|
||||
pass
|
||||
```
|
||||
|
||||
### 2.2 Prédicat `est_parfait`
|
||||
|
||||
Un nombre parfait est un entier positif égal à la somme de ses diviseurs propres (diviseurs stricts, c'est-à-dire sans compter le nombre lui-même).
|
||||
|
||||
Exemple : 6 = 1 + 2 + 3 est parfait.
|
||||
|
||||
```python
|
||||
def est_parfait(n):
|
||||
"""
|
||||
Renvoie True si n est un nombre parfait, False sinon.
|
||||
"""
|
||||
# À compléter
|
||||
pass
|
||||
```
|
||||
|
||||
### 2.3 Prédicat `contient_doublon`
|
||||
|
||||
```python
|
||||
def contient_doublon(liste):
|
||||
"""
|
||||
Renvoie True si la liste contient au moins un élément en double.
|
||||
"""
|
||||
# À compléter
|
||||
pass
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Exercice 3 : Thèse de Church-Turing
|
||||
|
||||
### 3.1 Questions de cours
|
||||
|
||||
1. Qui est Alonzo Church et quelle est sa contribution à l'informatique théorique ?
|
||||
|
||||
2. Qu'affirme la thèse de Church-Turing ?
|
||||
|
||||
3. Pourquoi parle-t-on de "thèse" et non de "théorème" ?
|
||||
|
||||
### 3.2 Réflexion
|
||||
|
||||
Si un algorithme fonctionne en Python, peut-il être traduit dans n'importe quel autre langage de programmation ? Justifiez en vous appuyant sur la thèse de Church-Turing.
|
||||
|
||||
---
|
||||
|
||||
## Exercice 4 : Le problème de l'arrêt
|
||||
|
||||
### 4.1 Compréhension
|
||||
|
||||
Considérez le programme suivant :
|
||||
|
||||
```python
|
||||
def mystere(n):
|
||||
while n != 1:
|
||||
if n % 2 == 0:
|
||||
n = n // 2
|
||||
else:
|
||||
n = 3 * n + 1
|
||||
return n
|
||||
```
|
||||
|
||||
1. Testez ce programme avec les valeurs 6, 11, 27. Que constatez-vous ?
|
||||
|
||||
2. Ce programme s'arrête-t-il toujours ? (Indice : c'est la conjecture de Syracuse, non résolue à ce jour !)
|
||||
|
||||
3. En quoi cet exemple illustre-t-il le problème de l'arrêt ?
|
||||
|
||||
### 4.2 Démonstration par l'absurde
|
||||
|
||||
Expliquez avec vos propres mots pourquoi le problème de l'arrêt est indécidable. Utilisez le raisonnement par l'absurde vu en cours.
|
||||
|
||||
---
|
||||
|
||||
## Exercice 5 : Machine de Turing
|
||||
|
||||
### 5.1 Addition binaire
|
||||
|
||||
Utilisez l'algorithme de la machine de Turing (activité TURING.md) pour calculer :
|
||||
|
||||
1. 11₂ + 1 = ?
|
||||
2. 111₂ + 1 = ?
|
||||
3. 1111₂ + 1 = ?
|
||||
|
||||
### 5.2 Réflexion
|
||||
|
||||
Que remarquez-vous sur le nombre d'étapes nécessaires quand tous les bits sont à 1 ?
|
||||
|
||||
---
|
||||
|
||||
## Exercice 6 : QCM de révision
|
||||
|
||||
### Question 1
|
||||
Un prédicat est une fonction qui :
|
||||
- [ ] A. Prend un booléen en paramètre
|
||||
- [ ] B. Renvoie un booléen
|
||||
- [ ] C. Ne s'arrête jamais
|
||||
- [ ] D. Est toujours récursive
|
||||
|
||||
### Question 2
|
||||
Le problème de l'arrêt est :
|
||||
- [ ] A. Décidable et calculable
|
||||
- [ ] B. Indécidable
|
||||
- [ ] C. Résolu par Alan Turing en 1936
|
||||
- [ ] D. Un problème simple à résoudre
|
||||
|
||||
### Question 3
|
||||
Selon la thèse de Church-Turing :
|
||||
- [ ] A. Python est le meilleur langage de programmation
|
||||
- [ ] B. Tout ce qui est calculable peut l'être par une machine de Turing
|
||||
- [ ] C. Certains langages sont plus puissants que d'autres
|
||||
- [ ] D. Les ordinateurs quantiques peuvent tout calculer
|
||||
|
||||
### Question 4
|
||||
Un problème est dit décidable si :
|
||||
- [ ] A. On peut toujours trouver une solution
|
||||
- [ ] B. Il existe un algorithme qui répond oui ou non en temps fini
|
||||
- [ ] C. Il n'a pas de solution
|
||||
- [ ] D. Il nécessite un supercalculateur
|
||||
|
||||
---
|
||||
|
||||
## Exercice 7 : Pour aller plus loin
|
||||
|
||||
### Le paradoxe de Russell
|
||||
|
||||
Bertrand Russell a proposé le paradoxe suivant en 1901 :
|
||||
|
||||
> « Dans un village, le barbier rase tous ceux qui ne se rasent pas eux-mêmes, et seulement ceux-là. Qui rase le barbier ? »
|
||||
|
||||
1. Expliquez pourquoi ce paradoxe n'a pas de solution logique.
|
||||
|
||||
2. En quoi ce paradoxe est-il similaire au problème de l'arrêt ?
|
||||
|
||||
3. (Bonus) Recherchez le "paradoxe du menteur" et expliquez son lien avec l'indécidabilité.
|
||||
|
||||
---
|
||||
|
||||
Auteur : Florian Mathieu
|
||||
|
||||
Licence CC BY NC
|
||||
|
||||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.
|
||||
@@ -1,4 +1,4 @@
|
||||
## Calculabilité et décidabilité en informatique ##
|
||||
# Calculabilité et décidabilité en informatique
|
||||
|
||||
> À chaque problème sa non solution !
|
||||
|
||||
@@ -12,7 +12,7 @@
|
||||
|
||||
#### Introduction à la décidabilité
|
||||
|
||||
Il vous est deja arrivé de prendre des décisions en suivant une logique. Dans la vie vous suivez la votre, en prenant des conseils, ou de par ce que vous avez appris à l'école. C'est donc quelque chose général.
|
||||
Il vous est déjà arrivé de prendre des décisions en suivant une logique. Dans la vie vous suivez la votre, en prenant des conseils, ou de par ce que vous avez appris à l'école. C'est donc quelque chose général.
|
||||
|
||||
Cela vous semble simple de définir la logique, mais en réalité, mise en pratique, cela devient plus complexe à commenter :
|
||||
mathématiquement, la logique n'a pas grand chose à voir avec celle dont on use au quotidien.
|
||||
@@ -33,22 +33,19 @@ On peut par exemple prendre des problèmes assez élémentaires :
|
||||
|
||||
Dans notre premier cas, nous avons en **instance de départ :** un entier naturel, qui, après être traité via le **paramètre** choisi (Si reste = 0 après une division par 2, alors nombre est pair) dans **l'algorithme**, ressortira en une réponse simple : *Oui* ou *Non* selon la **décision** prise.
|
||||
|
||||
### Définition
|
||||
### Définition : Prédicat
|
||||
|
||||
En informatique ou mathématiques, on peut parler d'une **fonction algorithmique**. Quand le résultat de celle ci, c'est à dire ce qu'elle *renvoit*, est un boléen, on parle de ***prédicat***.
|
||||
En informatique ou mathématiques, on peut parler d'une **fonction algorithmique**. Quand le résultat de celle-ci, c'est-à-dire ce qu'elle *renvoie*, est un booléen, on parle de ***prédicat***.
|
||||
|
||||
Un ***prédicat*** est une fonction qui ne prendra que des valeurs booléennes:
|
||||
Un ***prédicat*** est une fonction qui ne prendra que des valeurs booléennes.
|
||||
|
||||
<p>
|
||||
> La réponse à un problème de décision est donc soit un booléen, soit une valeur qui permet de répondre à un prédicat.
|
||||
>
|
||||
> **Exemple** : Dans un graphe, connaître le nombre de sommets permet de répondre à la question : « Le chemin que j'ai choisi est-il le plus court passant par tous les sommets de ce graphe ? »
|
||||
>
|
||||
> Question dont la réponse est bel et bien un prédicat.
|
||||
|
||||
La réponse à un problème de décision est donc soit un booléen ou alors une valeur qui permet de répondre à un prédicat
|
||||
|
||||
|
||||
Exemple : Dans un graphe, connaitre le nombre de sommets permet de répondre à la question : le chemin que j'ai choisi est il le plus court passant par tous les sommets de ce graphe ?
|
||||
|
||||
Question dont la réponse est bel et bien un prédicat.
|
||||
|
||||
### Définition
|
||||
### Définition : Décidabilité
|
||||
|
||||
Si, pour réponse à un problème, on peut en écrire un algorithme permettant la prise de décision et donc amenant à la résolution du dit problème, on parlera de problème ***décidable*** ou de <u>**décidabilité**</u>
|
||||
|
||||
@@ -58,7 +55,7 @@ Et donc, par extension, si un problème n'est pas soluble, on utilisera le terme
|
||||
|
||||
## ~~La calcul habilité~~ La calculabilité
|
||||
|
||||
En informatique, plus précisemment dans la branche dite de programmation, nous utilisons un langage qui nous est propre afin de mettre en place nos idées dans un algorithme.
|
||||
En informatique, plus précisément dans la branche dite de programmation, nous utilisons un langage qui nous est propre afin de mettre en place nos idées dans un algorithme.
|
||||
|
||||
### Vocabulaire
|
||||
|
||||
@@ -100,7 +97,7 @@ Ici, en NSI, nous utilisons le langage Python, mais nous pourrions parfaitement
|
||||
|
||||
Revenons au prédicat : si une fonction renvoie un prédicat, et que celui là est dit calculable, alors la prise de décision est possible. Une fonction calculable permet donc l'emergence de décisions décidables.
|
||||
|
||||
Ce qui signifie qu'il existe un algorithme permettant la résolution de cette fonction, ou d'un problème ammené par la fonction, et si un algorithme existe, alors nous sommes en mesure de programmer la fonction dans n'importe quel langage.
|
||||
Ce qui signifie qu'il existe un algorithme permettant la résolution de cette fonction, ou d'un problème amené par la fonction, et si un algorithme existe, alors nous sommes en mesure de programmer la fonction dans n'importe quel langage.
|
||||
|
||||
--------
|
||||
|
||||
@@ -116,7 +113,9 @@ Pour un problème, c'est la même chose : si l'on peut écrire un programme qui
|
||||
|
||||
### Pourquoi est ce important ?
|
||||
|
||||
Imaginez, si votre programme, logiciel ou jeu vidéo favori rencontrait un problème d'execution et tournait en boucle quand vous l'utilisez. <br> Frustrant n'est ce pas ? Une personne qui souhaite développer des programmes doit s'assurer de la décidabilité de son travail.
|
||||
Imaginez, si votre programme, logiciel ou jeu vidéo favori rencontrait un problème d'execution et tournait en boucle quand vous l'utilisez.
|
||||
|
||||
Frustrant n'est ce pas ? Une personne qui souhaite développer des programmes doit s'assurer de la décidabilité de son travail.
|
||||
|
||||
### Et maintenant, des exemples !
|
||||
|
||||
@@ -177,7 +176,7 @@ Nous avons bien la preuve que le problème " Peut-on prouver qu'un nombre est pa
|
||||
|
||||
### Tous les problèmes sont ils décidables?
|
||||
|
||||
Et bien non ! Disons le tout de suite, il existe un nombre de problèmes que l'ont ne peut résoudre par un simple algorithme. On parlera de ***Problèmes Indécidables*** !
|
||||
Et bien non ! Disons le tout de suite, il existe un nombre de problèmes que l'on ne peut résoudre par un simple algorithme. On parlera de ***Problèmes Indécidables*** !
|
||||
|
||||
La question qui se pose à nous est de savoir comment reconnaitre un problème indécidable.
|
||||
|
||||
@@ -203,9 +202,9 @@ C'est à dire qu'on va partir d'une hypothèse qu'on supposera vraie, pour essay
|
||||
|
||||
Cela nous ramènera donc à des décisions logiques qui en découleront.
|
||||
|
||||
### Mais si le postulat de base est éronné ?
|
||||
### Mais si le postulat de base est erroné ?
|
||||
|
||||
C'est tout le principe : s'il est éronné, alors il faut tester son exact opposé : celà prend du temps.
|
||||
C'est tout le principe : s'il est erroné, alors il faut tester son exact opposé : cela prend du temps.
|
||||
|
||||
Et enfin, en testant l'opposé, on pourra savoir si notre problème est décidable ou pas !
|
||||
|
||||
@@ -215,7 +214,7 @@ Oui mais :En 1936, Alan Turing démontre son indécidabilité.
|
||||
|
||||
#### Attendez, le programme qui determine l'indécidabilité est lui même indécidable ??
|
||||
|
||||
Eeh oui, c'est incroyable mais juste : ironique n'est ce pas ? On peut même dire *absurde*
|
||||
Eh oui, c'est incroyable mais juste : ironique n'est ce pas ? On peut même dire *absurde*
|
||||
|
||||
En effet, on va user d'un raisonnement par l'absurde pour montrer que ce qu'on pense vrai est en réalité faux.
|
||||
|
||||
@@ -227,7 +226,7 @@ Supposons que l'on puisse écrire une fonction arret, capable de dire si une fon
|
||||
|
||||
Il n'est, dans notre exemple, absolument pas certain qu'une telle fonction existe.
|
||||
|
||||
Nous allons dans un premier temps, créer une fonction qui nous servira de cobaye dans notre fonction absurbe de programme d'arrêt.
|
||||
Nous allons dans un premier temps, créer une fonction qui nous servira de cobaye dans notre fonction absurde de programme d'arrêt.
|
||||
|
||||
|
||||
```python
|
||||
@@ -253,16 +252,23 @@ Maintenant, définissons notre fonction absurde
|
||||
|
||||
```python
|
||||
def absurde(programme):
|
||||
if arret_programme(programme,x):
|
||||
if arret_programme(programme, programme):
|
||||
# Si le programme s'arrête, on boucle à l'infini
|
||||
while True:
|
||||
continue
|
||||
else:
|
||||
return True
|
||||
pass
|
||||
else:
|
||||
# Si le programme boucle, on s'arrête
|
||||
return True
|
||||
```
|
||||
|
||||
Si on analyse ce que l'on vient d'écrire : Quand la fonction arret_programme peut s'arrêter, la fonction absurde va lui permettre de boucler à l'infini !
|
||||
Analysons ce que l'on vient d'écrire :
|
||||
- Si `arret_programme(programme, programme)` renvoie `True` (le programme s'arrête), alors `absurde` **boucle à l'infini**
|
||||
- Si `arret_programme(programme, programme)` renvoie `False` (le programme boucle), alors `absurde` **s'arrête** et renvoie `True`
|
||||
|
||||
Mais si le test se révèle négatif, on renvoit True et arretons donc la fonction!
|
||||
**Le paradoxe** : Que se passe-t-il si on appelle `absurde(absurde)` ?
|
||||
|
||||
- Si `arret_programme(absurde, absurde)` dit que `absurde(absurde)` s'arrête → alors `absurde(absurde)` boucle (contradiction !)
|
||||
- Si `arret_programme(absurde, absurde)` dit que `absurde(absurde)` boucle → alors `absurde(absurde)` s'arrête (contradiction !)
|
||||
|
||||
Nous venons donc de prouver l'impossible. Pas mal non ?
|
||||
|
||||
@@ -277,7 +283,7 @@ Si la machine ne peut nous aider, il vous faudra donc, en tant qu'humain, toujou
|
||||
|
||||
On peut retenir deux choses de notre exemple : Le fameux théorème de Kurt Gödel, qui traite de l'indécidabilité, n'est pas vérifiable puisque qu'on ne peut vérifier la décidabilité de tous les sytèmes, dès lors que la fonction qui doit nous y aider n'est elle même pas décidable !
|
||||
|
||||
Pour comprendre la démonstration de tout cela, il nous aura fallu analyser la démonstration en elle même, et non pas essayer de démontrer ce qu'elle prouve. Ce qui laisse perplexe quant à la veracité de certaines affirmations.
|
||||
Pour comprendre la démonstration de tout cela, il nous aura fallu analyser la démonstration en elle même, et non pas essayer de démontrer ce qu'elle prouve. Ce qui laisse perplexe quant à la véracité de certaines affirmations.
|
||||
|
||||
Enfin, on peut se demander une chose. Puisque nous avons une donnée en entrée d'une fonction, et une donnée en sortie...Une fonction ne serait-elle pas uniquement que données ?
|
||||
|
||||
|
||||
289
Calculabilité/TP_Paradoxes.md
Normal file
289
Calculabilité/TP_Paradoxes.md
Normal file
@@ -0,0 +1,289 @@
|
||||
# TP : Le Barbier, le Menteur et la Machine — Paradoxes et Indécidabilité
|
||||
|
||||
> **Thème** : Comprendre l'indécidabilité à travers les paradoxes logiques
|
||||
|
||||
---
|
||||
|
||||
## Contexte
|
||||
|
||||
En 2026, les intelligences artificielles comme ChatGPT, Claude ou Gemini impressionnent par leurs capacités. Mais peuvent-elles *tout* calculer ? Peuvent-elles répondre à *toutes* les questions ?
|
||||
|
||||
Dans ce TP, vous allez découvrir que certaines questions n'ont **pas de réponse calculable**, et ce depuis bien avant l'invention des ordinateurs. Des mathématiciens comme Bertrand Russell, Kurt Gödel et Alan Turing ont prouvé qu'il existe des **limites fondamentales** à ce que les machines peuvent faire.
|
||||
|
||||
---
|
||||
|
||||
## Partie 1 : Le Paradoxe du Menteur
|
||||
|
||||
### L'énoncé
|
||||
|
||||
Considérez la phrase suivante :
|
||||
|
||||
> « Cette phrase est fausse. »
|
||||
|
||||
### Questions
|
||||
|
||||
1. Si cette phrase est **vraie**, que peut-on en déduire ?
|
||||
|
||||
2. Si cette phrase est **fausse**, que peut-on en déduire ?
|
||||
|
||||
3. Pourquoi dit-on que c'est un paradoxe ?
|
||||
|
||||
### Variante moderne : le tweet impossible
|
||||
|
||||
Imaginez un bot Twitter/X programmé ainsi :
|
||||
|
||||
```
|
||||
SI le tweet dit "Ce tweet est faux" ALORS :
|
||||
SI le tweet est vrai → marquer comme faux
|
||||
SI le tweet est faux → marquer comme vrai
|
||||
```
|
||||
|
||||
Que se passe-t-il quand le bot analyse le tweet « Ce tweet est faux » ?
|
||||
|
||||
---
|
||||
|
||||
## Partie 2 : Le Paradoxe du Barbier
|
||||
|
||||
### L'énoncé (Bertrand Russell, 1901)
|
||||
|
||||
> Dans un village, il y a un barbier qui rase **tous** les hommes qui ne se rasent pas eux-mêmes, et **seulement** ceux-là.
|
||||
>
|
||||
> **Question : Le barbier se rase-t-il lui-même ?**
|
||||
|
||||
### Analyse
|
||||
|
||||
1. **Hypothèse 1** : Le barbier se rase lui-même.
|
||||
- Que peut-on en déduire d'après la règle ?
|
||||
|
||||
2. **Hypothèse 2** : Le barbier ne se rase pas lui-même.
|
||||
- Que peut-on en déduire d'après la règle ?
|
||||
|
||||
3. Conclusion : pourquoi ce paradoxe n'a-t-il pas de solution ?
|
||||
|
||||
### Application en informatique
|
||||
|
||||
Imaginez une fonction Python `barbier(personne)` qui renvoie `True` si le barbier rase cette personne :
|
||||
|
||||
```python
|
||||
def barbier(personne):
|
||||
"""
|
||||
Renvoie True si le barbier rase cette personne.
|
||||
Règle : le barbier rase ceux qui ne se rasent pas eux-mêmes.
|
||||
"""
|
||||
return not se_rase_soi_meme(personne)
|
||||
```
|
||||
|
||||
Que renvoie `barbier("barbier")` si le barbier est une personne du village ?
|
||||
|
||||
---
|
||||
|
||||
## Partie 3 : L'Ensemble de tous les ensembles
|
||||
|
||||
### Le paradoxe de Russell (version mathématique)
|
||||
|
||||
Considérons l'ensemble R défini ainsi :
|
||||
|
||||
> R = { tous les ensembles qui ne se contiennent pas eux-mêmes }
|
||||
|
||||
**Question** : R se contient-il lui-même ?
|
||||
|
||||
### Analyse
|
||||
|
||||
1. Si R ∈ R (R se contient), alors par définition de R, R ne devrait pas se contenir. **Contradiction.**
|
||||
|
||||
2. Si R ∉ R (R ne se contient pas), alors par définition de R, R devrait se contenir. **Contradiction.**
|
||||
|
||||
### Impact historique
|
||||
|
||||
Ce paradoxe a provoqué une **crise des fondements des mathématiques** au début du XXe siècle. Les mathématiciens ont dû repenser la notion même d'ensemble pour éviter ces contradictions.
|
||||
|
||||
---
|
||||
|
||||
## Partie 4 : Du Paradoxe au Problème de l'Arrêt
|
||||
|
||||
### Le lien avec l'informatique
|
||||
|
||||
Alan Turing a utilisé une structure similaire pour prouver que le **problème de l'arrêt** est indécidable.
|
||||
|
||||
### Rappel du problème de l'arrêt
|
||||
|
||||
> Existe-t-il un programme `arret(P, x)` qui, pour tout programme P et toute entrée x, répond :
|
||||
> - `True` si P(x) s'arrête
|
||||
> - `False` si P(x) boucle indéfiniment ?
|
||||
|
||||
### La démonstration de Turing (simplifiée)
|
||||
|
||||
**Étape 1** : Supposons qu'un tel programme `arret` existe.
|
||||
|
||||
**Étape 2** : Construisons le programme `paradoxe` suivant :
|
||||
|
||||
```python
|
||||
def paradoxe(programme):
|
||||
if arret(programme, programme):
|
||||
# Si le programme s'arrête sur lui-même, on boucle
|
||||
while True:
|
||||
pass
|
||||
else:
|
||||
# Si le programme boucle sur lui-même, on s'arrête
|
||||
return True
|
||||
```
|
||||
|
||||
**Étape 3** : Que se passe-t-il si on appelle `paradoxe(paradoxe)` ?
|
||||
|
||||
Complétez le raisonnement :
|
||||
|
||||
- Si `arret(paradoxe, paradoxe)` renvoie `True` → ...
|
||||
- Si `arret(paradoxe, paradoxe)` renvoie `False` → ...
|
||||
|
||||
**Étape 4** : Conclusion
|
||||
|
||||
Quelle conclusion peut-on tirer sur l'existence de la fonction `arret` ?
|
||||
|
||||
---
|
||||
|
||||
## Partie 5 : Simulation d'une Machine de Turing en Python
|
||||
|
||||
### Objectif
|
||||
|
||||
Implémenter une machine de Turing simplifiée qui effectue l'addition de 1 à un nombre binaire.
|
||||
|
||||
### Structure de la machine
|
||||
|
||||
```python
|
||||
class MachineDeTuring:
|
||||
def __init__(self, ruban_initial):
|
||||
"""
|
||||
Initialise la machine avec un ruban.
|
||||
Le ruban est une liste de caractères ('0', '1', ou ' ' pour vide).
|
||||
"""
|
||||
self.ruban = list(ruban_initial)
|
||||
self.position = 0 # Position de la tête de lecture
|
||||
self.etat = "chercher_fin" # État initial
|
||||
|
||||
def lire(self):
|
||||
"""Lit le symbole sous la tête de lecture."""
|
||||
if 0 <= self.position < len(self.ruban):
|
||||
return self.ruban[self.position]
|
||||
return ' ' # Case vide
|
||||
|
||||
def ecrire(self, symbole):
|
||||
"""Écrit un symbole sous la tête de lecture."""
|
||||
# Étendre le ruban si nécessaire
|
||||
while self.position >= len(self.ruban):
|
||||
self.ruban.append(' ')
|
||||
while self.position < 0:
|
||||
self.ruban.insert(0, ' ')
|
||||
self.position += 1
|
||||
self.ruban[self.position] = symbole
|
||||
|
||||
def gauche(self):
|
||||
"""Déplace la tête vers la gauche."""
|
||||
self.position -= 1
|
||||
|
||||
def droite(self):
|
||||
"""Déplace la tête vers la droite."""
|
||||
self.position += 1
|
||||
|
||||
def afficher(self):
|
||||
"""Affiche l'état actuel du ruban."""
|
||||
ruban_str = ''.join(self.ruban)
|
||||
curseur = ' ' * self.position + 'V'
|
||||
print(f"État: {self.etat}")
|
||||
print(curseur)
|
||||
print(ruban_str)
|
||||
print()
|
||||
```
|
||||
|
||||
### Exercice : Implémenter l'algorithme d'addition
|
||||
|
||||
Complétez la méthode `ajouter_un` qui implémente l'algorithme d'addition de 1 :
|
||||
|
||||
```python
|
||||
def ajouter_un(self):
|
||||
"""
|
||||
Ajoute 1 au nombre binaire sur le ruban.
|
||||
Algorithme :
|
||||
1. Aller à droite jusqu'à une case vide
|
||||
2. Revenir à gauche et appliquer la règle d'addition avec retenue
|
||||
"""
|
||||
# Étape 1 : Aller à droite jusqu'à une case vide
|
||||
while self.lire() != ' ':
|
||||
self.droite()
|
||||
|
||||
# Étape 2 : Revenir à gauche et ajouter 1
|
||||
self.gauche()
|
||||
|
||||
# À compléter : implémenter la logique d'addition avec retenue
|
||||
# Tant qu'on a une retenue à propager...
|
||||
|
||||
pass # Remplacez par votre code
|
||||
```
|
||||
|
||||
### Test
|
||||
|
||||
```python
|
||||
# Créer une machine avec le nombre binaire 101 (= 5)
|
||||
machine = MachineDeTuring("101")
|
||||
machine.afficher()
|
||||
|
||||
# Ajouter 1
|
||||
machine.ajouter_un()
|
||||
machine.afficher()
|
||||
|
||||
# Résultat attendu : 110 (= 6)
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Partie 6 : Réflexion finale
|
||||
|
||||
### Questions de synthèse
|
||||
|
||||
1. **Lien entre les paradoxes** : Quel point commun voyez-vous entre le paradoxe du menteur, le paradoxe du barbier et le problème de l'arrêt ?
|
||||
|
||||
2. **Auto-référence** : Qu'est-ce que l'auto-référence ? Pourquoi pose-t-elle problème ?
|
||||
|
||||
3. **Limites des machines** : Si le problème de l'arrêt est indécidable, cela signifie-t-il que les ordinateurs sont "stupides" ? Justifiez.
|
||||
|
||||
4. **IA et indécidabilité** : Une intelligence artificielle, aussi avancée soit-elle, peut-elle résoudre le problème de l'arrêt ? Pourquoi ?
|
||||
|
||||
### Débat : Les limites de l'IA
|
||||
|
||||
En 2026, les IA génératives sont partout. Mais elles sont soumises aux mêmes limites fondamentales que n'importe quel programme.
|
||||
|
||||
Discutez en groupe :
|
||||
- Une IA peut-elle savoir si elle va boucler indéfiniment sur une tâche ?
|
||||
- Une IA peut-elle vérifier qu'elle n'a pas de bugs ?
|
||||
- Quelles sont les implications pour la sécurité des systèmes autonomes ?
|
||||
|
||||
---
|
||||
|
||||
## Résumé des notions
|
||||
|
||||
| Concept | Description |
|
||||
|---------|-------------|
|
||||
| **Paradoxe** | Situation logique contradictoire, sans solution |
|
||||
| **Auto-référence** | Quand un énoncé parle de lui-même |
|
||||
| **Problème de l'arrêt** | Peut-on décider si un programme s'arrête ? (Non !) |
|
||||
| **Indécidabilité** | Existence de problèmes sans algorithme de résolution |
|
||||
| **Machine de Turing** | Modèle théorique de calcul universel |
|
||||
|
||||
---
|
||||
|
||||
## Bonus : Le théorème d'incomplétude de Gödel
|
||||
|
||||
En 1931, Kurt Gödel a prouvé qu'en mathématiques, il existe des énoncés **vrais mais indémontrables**.
|
||||
|
||||
Plus précisément : dans tout système logique assez puissant pour exprimer l'arithmétique, il existe des propositions qui ne peuvent être ni prouvées, ni réfutées.
|
||||
|
||||
C'est une autre facette de l'indécidabilité : même les mathématiques ont leurs limites !
|
||||
|
||||
Recherchez et expliquez avec vos mots ce que signifie ce théorème.
|
||||
|
||||
---
|
||||
|
||||
Auteur : Florian Mathieu
|
||||
|
||||
Licence CC BY NC
|
||||
|
||||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.
|
||||
@@ -1,4 +1,4 @@
|
||||
## Machine de Turing
|
||||
# Activité : Machine de Turing
|
||||
|
||||
Cette machine est constituée :
|
||||
|
||||
@@ -34,24 +34,40 @@ Réalisez pas à pas l'algorithme ci-dessous :
|
||||
| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
|
||||
| | | | | | | | | | | | 1 | 0 | 1 | | | | | | |
|
||||
|
||||
*Etape 2* : la dernière case lue est ... donc ...
|
||||
*Étape 2* : La dernière case lue est **1**. On se décale à gauche et on écrit **0** (retenue). On doit continuer car on avait un 1.
|
||||
|
||||
| | | | | | | | | | | | | | V | | | | | | |
|
||||
| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
|
||||
| | | | | | | | | | | | 1 | 0 | 0 | | | | | | |
|
||||
|
||||
*Etape 4* : ...
|
||||
*Étape 3* : La case courante est **0**. On écrit **1** et on arrête la propagation de la retenue.
|
||||
|
||||
| | | | | | | | | | | | | V | | | | | | | |
|
||||
| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
|
||||
| | | | | | | | | | | | 1 | 1 | 0 | | | | | | |
|
||||
|
||||
*Etape 5* : ...
|
||||
*Étape 4* : On retourne à la position initiale. Le calcul est terminé.
|
||||
|
||||
| | | | | | | | | | | V | | | | | | | | | |
|
||||
| ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- | ---- |
|
||||
| | | | | | | | | | | | 1 | 1 | 0 | | | | | | |
|
||||
|
||||
Vous trouverez [sur ce site](http://zanotti.univ-tln.fr/turing/turing.php) un simulateur d'une machin de de Turing si vous souhaitez aller plus loin.
|
||||
**Résultat** : 101₂ + 1 = 110₂ (soit 5 + 1 = 6 en décimal)
|
||||
|
||||
ll faut garder à l'esprit que la machine de Turing est un modèle universel de calcul et qu'elle peut calculer tout ce que n'importe quel ordinateur physique peut calculer (aussi puissant soit-il). Inversement, ce qu'elle ne peut pas calculer ne peut l'être non plus par un ordinateur. Elle résume donc de manière saisissante le concept d'*ordinateur* et constitue un support idéal pour raisonner autour de la notion d'*algorithme* de *calcul* ou de *démonstration*. En terminale, nous étudierons plus en détail le concept de calculabilité.
|
||||
Vous trouverez [sur ce site](http://zanotti.univ-tln.fr/turing/turing.php) un simulateur d'une machine de Turing si vous souhaitez aller plus loin.
|
||||
|
||||
Il faut garder à l'esprit que la machine de Turing est un modèle universel de calcul et qu'elle peut calculer tout ce que n'importe quel ordinateur physique peut calculer (aussi puissant soit-il). Inversement, ce qu'elle ne peut pas calculer ne peut l'être non plus par un ordinateur. Elle résume donc de manière saisissante le concept d'*ordinateur* et constitue un support idéal pour raisonner autour de la notion d'*algorithme*, de *calcul* ou de *démonstration*.
|
||||
|
||||
---
|
||||
|
||||
## Exercice supplémentaire
|
||||
|
||||
Appliquez le même algorithme pour calculer **111₂ + 1**. Combien d'étapes sont nécessaires ?
|
||||
|
||||
---
|
||||
|
||||
Auteur : Florian Mathieu
|
||||
|
||||
Licence CC BY NC
|
||||
|
||||
<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.
|
||||
Reference in New Issue
Block a user