( MISE À JOUR : une question mieux formulée est posée ici car les commentaires pour la réponse acceptée ci-dessous montrent que cette question n'est pas bien définie)
La preuve classique de l'impossibilité du problème d'arrêt dépend de la démonstration d'une contradiction lors de la tentative d'application de l'algorithme de détection d'arrêt à lui-même en entrée. Voir le contexte ci-dessous pour plus d'informations.
La contradiction démontrée s'applique en raison d'un paradoxe autoréférentiel (comme la phrase "Cette phrase n'est pas vraie"). Mais si nous interdisons strictement de telles références (c'est-à-dire acceptons le fait que de telles références ne peuvent pas être arrêtées), quel résultat nous reste-t-il? Le problème d'arrêt pour l'ensemble restant de machines non auto-référencées peut-il être arrêté ou non?
Les questions sont:
Si nous considérons un sous-ensemble de toutes les machines de Turing possibles, qui ne sont pas auto-référencées (c'est-à-dire ne se prennent pas elles-mêmes en entrée), que savons-nous du problème d'arrêt de ce sous-ensemble?
MISE À JOUR
Peut-être qu'une meilleure reformulation de ce que je recherche est une meilleure compréhension de ce qui définit un ensemble décidable. J'essayais d'isoler la preuve d'indécidabilité classique car elle n'ajoute aucune information sur l'indécidabilité, sauf dans les cas où vous exécutez HALT sur lui-même.
Contexte: En supposant vers une contradiction qu'il existe une machine de Turing qui peut décider de l'entrée M qui est un codage pour une machine de Turing et X , que M ( X ) s'arrête ou non . Considérons alors une machine de Turing K qui prend M et X et utilise Q pour décider si M ( X ) s'arrête ou non, puis fait le contraire, c'est-à-dire K s'arrête si M ( X ) ne s'arrête pas, et ne s'arrête pas si M ( X )s'arrête. Alors démontre une contradiction, car K devrait s'arrêter s'il ne s'arrête pas, et ne s'arrête pas quand il s'arrête.
Motivation: un collègue travaille sur la vérification formelle des systèmes logiciels (en particulier lorsque le système est déjà éprouvé au niveau du code source et que nous voulons le reprendre pour sa version compilée, pour neutraliser les problèmes du compilateur), et dans son cas, il se soucie d'un ensemble spécial de programmes de contrôle intégrés pour lesquels nous savons avec certitude qu'ils ne seraient pas auto-référencés. Un aspect de la vérification qu'il souhaite effectuer est de savoir s'il est garanti que le programme compilé s'arrêtera s'il est prouvé que le code source d'entrée se termine.
MISE À JOUR
Sur la base des commentaires ci-dessous, je clarifie la signification des machines de Turing non auto-référencées.
Le but est de le définir comme l'ensemble qui ne conduit pas à la contradiction posée dans la preuve (cf. "Contexte" ci-dessus). Il pourrait être défini comme suit:
En supposant qu'il existe une machine de Turing qui décide du problème d'arrêt pour un ensemble de machines de Turing S , alors S n'est pas auto-référencé par rapport à Q s'il exclut toutes les machines qui invoquent Q sur S (directement ou indirectement). (Cela signifie clairement que Q ne peut pas être membre de S. )
Pour clarifier ce que l'on entend par invocation indirecte de sur S :
L'invocation de sur S est désignée par une machine de Turing Q avec un ensemble d'états et certaines entrées initiales possibles sur la bande (correspondant à n'importe quel membre de S ), avec la tête initialement au début de cette entrée. Une machine W invoque Q sur S "indirectement" s'il existe une séquence (finie) d'étapes que W prendrait pour rendre sa configuration "homomorphe" à la configuration initiale de Q ( S ) .
MISE À JOUR 2
D'après une réponse ci-dessous faisant valoir qu'il existe une infinité de machines Turing faisant la même tâche, et donc n'est pas unique, nous changeons la définition ci-dessus en disant que Q n'est pas une seule machine Turing, mais l'ensemble (infini) de toutes les machines informatiques la même fonction (HALT), où HALT est la fonction qui décide ce qu'une machine de Turing arrête sur une entrée particulière.
MISE À JOUR 3
La définition de l'homomorphisme de la machine de Turing:
A TM A est homomorphe à TM B si le graphe de transition de A est homomorphe à celui de B, au sens standard des homomorphismes des graphes à nœuds ET bords étiquetés. Un graphe de transition (V, E) d'une MT est tel que V = états, E = arcs de transition entre états. Chaque arc est étiqueté avec (S, W, D), S = symbole lu sur la bande et W = le symbole à y écrire, et D = la direction vers laquelle le head show se déplace.
la source
Réponses:
Je pense qu'il faudra un peu plus de travail pour arriver à une question "bien définie". En particulier, cela pose problème:
Un problème est qu'il existe une infinité de machines Turing qui calculent la même fonction. Dans l'argument de diagonalisation standard, je peux simplement remplacer le sous-programme Q par un autre décideur pour HALT, car ils sont infiniment nombreux. Ou une fonction équivalente à HALT. Il n'est donc pas tout à fait clair pour moi de définir votre notion d '"invocation indirecte".
Une autre question pourrait être: pour quels ensembles de machines Turing le problème d'arrêt est-il décidable? Ici, il y a une abondance de réponses: les MT restreintes aux ressources (par exemple, utiliser uniquement l'espace f (n), où f est une fonction calculable spécifique), les MT qui sont opérationnellement restreintes d'une manière particulière (par exemple, la tête de lecture se déplace uniquement dans un sens), etc. Mais, une autre question intéressante est de savoir si l'appartenance à cet ensemble restreint est décidable, ou si vous devez vous limiter aux "problèmes de promesse", où vous ne garantissez une réponse correcte que sur un sous-ensemble d'entrées "promises", mais ne vérifiez pas adhésion.
la source
Si je comprends bien votre motivation, il semble que ce soit plus un problème de "correction du compilateur" qu'un problème de "problème d'arrêt restreint". Vous avez une propriété (terminaison) que vous avez prouvée pour un programme de niveau source Prog que vous souhaitez ensuite étendre au code compilé pour obtenir la même propriété de compiled (Prog) . Mais le compilateur peut (en général) faire des choses arbitrairement loufoques comme implémenter un runtime complet (par exemple la JVM), compiler votre programme de terminaison dans un bytecode JVM puis vider un exécutable qui démarre la JVM et l'alimente votre bytecode compilé.
En pratique, il est probablement tout à fait possible d'utiliser les connaissances implicites que vous avez sur le fonctionnement de votre compilateur pour implémenter une procédure de vérification qui prouve à peu près que les programmes compilés sont corrects compte tenu des programmes source corrects (en effet, de nombreux outils de vérification automatique pour les programmes utilisent des connaissances implicites du "compilateur" algorithme-à-code dans le cerveau des programmeurs). Cependant, en général, vous examinez probablement un problème de correction du compilateur. Si je comprends bien, il existe deux façons classiques de le faire.
Une option est d'avoir un compilateur qui prend en entrée le programme Prog et la preuve se termine (Prog) et sort compilé (Prog) et se termine (compilé (Prog)) - ce dernier est une preuve qui peut ensuite être revérifiée indépendamment de le compilateur. Le papier classique à ce sujet est Necula et Lee's The design and implementation of a certificating compiler , je crois.
Alternativement, vous pouvez prouver un fait sur la fonction compiles () - que chaque fois que compiles () donne une entrée de terminaison, elle produit une sortie de terminaison. Une introduction accessible à cette façon de penser sur l'exactitude du compilateur est l'article CACM de Xavier Leroy, Vérification formelle d'un compilateur réaliste .
(PS J'espère que cette réponse est utile - je reconnais que c'est un peu différent de la question que vous avez posée, alors faites-moi savoir si je suis loin de la base et / ou répétez quelque chose que vous savez déjà.)
la source