En théorie des automates (automates finis, automates pushdown, ...) et en complexité, il existe une notion d '"ambiguïté". Un automate est ambigu s'il existe un mot avec au moins deux cycles d'acceptation distincts. Une machine est k- ambiguë si pour chaque mot w accepté par la machine il y a au plus k exécutions distinctes pour accepter w .
Cette notion est également définie sur des grammaires hors contexte: une grammaire est ambiguë s'il existe un mot qui peut être dérivé de deux manières différentes.
Il est également connu que de nombreux langages ont une belle caractérisation logique sur des modèles finis. (Si un langage est régulier, il existe une formule monadique de second ordre ϕ sur les mots de telle sorte que chaque mot w de L est un modèle de ϕ , de la même manière NP s'il est équivalent aux formules du deuxième ordre où tous les quantificateurs du deuxième ordre sont existentiels.)
Ma question se situe donc aux confins des deux domaines: y a-t-il un résultat, voire une définition canonique, de «l'ambiguïté» des formules d'une logique donnée?
Je peux imaginer quelques définitions:
- est non ambigu s'il existe au plus un x tel que ϕ ( x ) estvraiet que ϕ ( x ) soit non ambigu.
- serait ambigu s'il existe un modèle à la fois ϕ 0 et ϕ 1 , ou si ϕ i est ambigu.
- Une formule SAT serait non ambiguë s'il y a au plus une affectation correcte.
Par conséquent, je me demande si c'est une notion bien connue, sinon il peut être intéressant d'essayer de faire des recherches sur ce sujet. Si la notion est connue, quelqu'un pourrait-il me donner des mots-clés que je pourrais utiliser pour rechercher des informations sur le sujet (parce que "l'ambiguïté logique" donne beaucoup de résultats sans rapport), ou un livre / pdf / références d'article?
la source
Juste deux remarques. J'espère qu'ils vous aideront.
Les définitions standard de la sémantique d'une logique et de la vérité suivent la présentation de Tarski, procédant par induction sur la structure des formules. Une autre possibilité est de donner une sémantique basée sur le jeu comme suggéré par Hintikka. La vérité et la satisfiabilité sont toutes définies en termes de stratégies dans un jeu. Pour les formules de premier ordre, on peut prouver qu'une formule est vraie selon la notion de Tarski si et seulement s'il existe une stratégie gagnante dans le jeu Hintikka.
Pour formaliser votre question, on peut se demander si le jeu admet plusieurs stratégies. Il y a aussi la question intéressante de savoir si les stratégies doivent être déterministes. Hintikka les obligeait à être déterministes. La preuve que l'original de Hintikka et la sémantique de Tarski sont équivalents nécessite l'Axiom of Choice. On peut aussi formaliser la vérité en termes de jeux avec des stratégies non déterministes avec moins de complications.
Votre exemple de théorie du langage a évoqué le déterminisme, les relations de simulation et l'acceptation du langage. Une relation de simulation entre automates implique l'inclusion d'une langue entre leurs langues bien que l'inverse ne soit pas vrai. Pour les automates déterministes, les deux notions coïncident. On peut se demander s'il est possible d'étendre les relations de simulation d'une manière «fluide» pour capturer l'équivalence du langage pour les automates non déterministes. Kousha Etessami a un très bon article montrant comment faire cela en utilisant des k-simulations ( Une hiérarchie de simulations calculables en temps polynomial pour les automates). Intuitivement, le «k» reflète le degré de non-déterminisme que la relation de simulation peut capturer. Lorsque «k» est égal au niveau de non-déterminisme dans l'automate, la simulation et l'équivalence du langage coïncident. Cet article donne également une caractérisation logique des k-simulations en termes de logique modale polyadique et un fragment variable borné de logique de premier ordre. Vous obtenez l'inclusion de la langue, le déterminisme, les jeux, la logique modale et la logique du premier ordre, le tout dans un package pare-chocs.
la source
Cela a commencé comme un commentaire sous la réponse d'Andrej Bauer, mais c'est devenu trop gros.
Je pense qu'une définition évidente de l'ambiguïté du point de vue de la théorie des modèles finis serait:a m b i gu o u s ( ϕ )⟹∃ M1, M2| M1⊨ ϕ ∧ M2⊨ ϕ ∧ M1⊨ ψ ∧ M2⊭ ψ
En d'autres termes, il existe des modèles distincts de votre grammaire codés comme une formule qui peuvent être distingués par une formule ψ , peut-être une sous-formule de ϕ .ϕ ψ ϕ
Vous pouvez connecter cela à la réponse d'Andrej sur les preuves via la complexité descriptive. La combinaison de l'existence d'un codage d'un modèle particulier et de son acceptation par une MT appropriée comme modèle d'une formule donnée EST une preuve que les axiomes et les inférences (et donc une grammaire équivalente) codés dans cette formule sont cohérents.
Pour rendre cela entièrement compatible avec la réponse d'Andrej, vous devez dire que le modèle est "généré" par la formule agissant comme un filtre sur l'espace de tous les modèles finis possibles (ou quelque chose comme ça), avec l'encodage et l'action du filtrage sur le modèle d'entrée comme "preuve". Les preuves distinctes témoignent alors de l'ambiguïté.
Ce n'est peut-être pas un sentiment populaire, mais j'ai tendance à penser que la théorie des modèles finis et la théorie des preuves sont la même chose vue sous des angles différents. ;-)
la source
Pas sûr de la question appliquée à CS, mais essayez de rechercher le terme d'imprécision et de logique. En philosophie de la logique, l'ambiguïté est généralement distinguée du flou (voir ici par exemple), et je pense que ce que vous recherchez est le flou (car le flou est défini comme des termes où il y a des cas limites). Le livre majeur dans ce domaine est Vagueness de Timothy Williamson (mais aussi voir la bibliographie sur le site de Stanford ci-dessus).
la source
Je suis (également) d'accord avec Anrej.
Je pense que la complexité descriptive est une caractérisation sans calcul (ce qui la rend intéressante à sa manière) et donc les exemples d'ambiguïté computationnelle de la théorie des langages formels (automates / grammaires / ...) que vous avez donnés semblent être dans un domaine assez différent . Dans la complexité descriptive, les langages correspondent à des classes de complexité et les requêtes (dans un langage) correspondent à des problèmes de calcul (pas d'algorithmes). Il n'y a aucun moyen prévu de vérifier / calculer une requête AFAIK, donc si vous ne recherchez pas une ambiguïté de calcul à mon humble avis, ces exemples sont trompeurs.
la source