Sont || et ! opérateurs suffisants pour rendre toutes les expressions logiques possibles?

294

L'expression logique ( a && b ) (les deux aet bont des valeurs booléennes) peut être écrite comme !(!a || !b), par exemple. Cela ne veut-il pas dire que &&c'est "inutile"? Est-ce à dire que toutes les expressions logiques ne peuvent être faites qu'en utilisant ||et !?

logic logical-operators

— JakeTheSnake
source

83

Il s'agit plus d'une question de logique symbolique de base que d'un problème Java, mais oui. OU et NON en combinaison peut être utilisé pour construire tout le reste. La même chose avec ET et NON. Par exemple, quand j'étais à l'école, on nous a appris à tout construire en utilisant uniquement des grilles NAND car elles prenaient moins de transistors.

— azurefrog

79

Ne confondez pas la possibilité d'écrire une déclaration de cette façon avec l'opportunité de le faire. Le sucre syntaxique est une bonne chose.

— azurefrog

20

De nombreuses puces de porte logique ne fournissent que des portes NAND ou NOR car il est possible de mettre en œuvre toutes les opérations avec elles et cela les rend bon marché à produire - A and B == !A nor !B == !(!A or !B). De même A or B == !A nand !B == !(!A and !B). Évidemment, passer la même valeur aux deux entrées d'un NAND ou d'un NOR donnera le même résultat qu'un simple NOT. XOR et XNOR sont également possibles mais plus complexes. Voir le théorème de De Morgan

— Basic

16

N'est-ce pas une question d'informatique? Je ne vois aucun code ici. En particulier, si cela est vrai dans la pratique, cela variera selon l'implémentation, par exemple en C ++ avec une surcharge de fonctionnement, ce n'est pas en général.

— Courses de légèreté en orbite

6

@SnakeDoc Je pense que personne ici ne préconise de faire une telle chose. Je crois que cette question était plus une question de logique théorique, qu'une question de programmation, vraiment.

— ryuu9187 du

425

Oui, comme l'ont souligné les autres réponses, l'ensemble des opérateurs comprenant ||et !est fonctionnellement complet . Voici une preuve constructive de cela, montrant comment les utiliser pour exprimer les seize connecteurs logiques possibles entre les variables booléennes Aet B:

Vrai :A || !A
A NAND B :!A || !B
B implique A :!B || A
A implique B :!A || B
A OU B :A || B
Pas B :!B
Pas A :!A
A XOR B :!(!A || B) || !(A || !B)
A XNOR B :!(!A || !B) || !(A || B)
Un :A
B :B
A NI B :!(A || B)
A n'implique pas B :!(!A || B)
B n'implique pas A :!(!B || A)
A ET B :!(!A || !B)
Faux :!(A || !A)

Notez que NAND et NOR sont en eux-mêmes fonctionnellement complets (ce qui peut être prouvé en utilisant la même méthode ci-dessus), donc si vous voulez vérifier qu'un ensemble d'opérateurs est fonctionnellement complet, il suffit de montrer que vous pouvez exprimer NAND ou NOR avec ça.

Voici un graphique montrant les diagrammes de Venn pour chacun des connecteurs répertoriés ci-dessus:

[ source ]

— Peter Olson
source

20

Il est difficile de dire si la question a l'intention de le faire, mais cette réponse ne traite pas du comportement en court-circuit (pertinent, car la question demande ||plutôt que |) ni des effets secondaires (pertinents car l'expansion de true, false, XOR et XNOR évalue leurs arguments plus de fois que la constante ou l'opérateur d'origine).

— David Richerby

5

Les cercles contenant les cercles et les transitions forment un diagramme de Hasse ( en.wikipedia.org/wiki/Hasse_diagram ). (Ouais, j'ai appris quelque chose de nouveau aujourd'hui!)

— Kasper van den Berg

5

@DavidRicherby C'est vrai. À part les XOR, XNOR, true et false, pour autant que je sache, les effets secondaires et le nombre d'évaluations devraient être les mêmes que les équivalents intégrés (par exemple, !(!A || !B)ont le même nombre de court-circuits et d'évaluations que A && B). Je ne pense pas que vous puissiez le faire pour XOR et XNOR sans constructions supplémentaires (par exemple a ? !b : b), et true ou false n'est pas un problème si vous pouvez enregistrer des valeurs, car vous pouvez démarrer votre programme en définissant trueet en falseutilisant une variable booléenne factice.

— Peter Olson

Il est intéressant de noter que la liste ci-dessus comprend 16 opérations. Cela est cohérent avec le fait qu'il existe 16 tables de vérité possibles dans le cas où vous avez 2 entrées et 1 sortie.

— Paul R

1

Je voulais juste ajouter une autre visualisation en tant que tableau pour référence. Même source que ci-dessus.

— août

125

Ce que vous décrivez est l'exhaustivité fonctionnelle .

Ceci décrit un ensemble d'opérateurs logiques qui sont suffisants pour "exprimer toutes les tables de vérité possibles". Votre ensemble d'opérateurs Java, { ||, !}, est suffisant; il correspond à l'ensemble {∨, ¬}, qui est répertorié dans la section "Ensembles d'opérateurs fonctionnellement minimaux".

L'ensemble de toutes les tables de vérité signifie tous les ensembles possibles de 4 valeurs booléennes qui peuvent être le résultat d'une opération entre 2 valeurs booléennes. Puisqu'il y a 2 valeurs possibles pour un booléen, il y a 2 ⁴ ou 16 tables de vérité possibles.

A B | 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14 15
----+------------------------------------------------
T T | T  T  T  T  T  T  T  T  F  F  F  F  F  F  F  F
T F | T  T  T  T  F  F  F  F  T  T  T  T  F  F  F  F
F T | T  T  F  F  T  T  F  F  T  T  F  F  T  T  F  F 
F F | T  F  T  F  T  F  T  F  T  F  T  F  T  F  T  F

Voici un tableau des numéros de table de vérité (0-15), les combinaisons ||et !qui le produisent, et une description.

Table  |  Operation(s)                    | Description
-------+----------------------------------+-------------
  0    | A || !A                          | TRUE
  1    | A || B                           | OR
  2    | A || !B                          | B IMPLIES A
  3    | A                                | A
  4    | !A || B                          | A IMPLIES B
  5    | B                                | B
  6    | !(!A || !B) || !(A || B)         | XNOR (equals)
  7    | !(!A || !B)                      | AND
  8    | !A || !B                         | NAND
  9    | !(A || !B) || !(!A || B)         | XOR
 10    | !B                               | NOT B
 11    | !(!A || B)                       | NOT A IMPLIES B
 12    | !A                               | NOT A
 13    | !(A || !B)                       | NOT B IMPLIES A
 14    | !(A || B)                        | NOR
 15    | !(A || !A)                       | FALSE

Il existe de nombreux autres ensembles fonctionnellement complets, y compris les ensembles d'éléments {NAND} et {NOR}, qui n'ont pas d'opérateurs uniques correspondants en Java.

— rgettman
source

4

+1 pour l'édition. Malgré la différence dans le décompte des voix, je pense que votre réponse est en fait plus détaillée que la mienne actuellement.

— Peter Olson

Tables de vérité, je pensais les avoir laissées derrière

— moi

80

Oui.

Toutes les portes logiques peuvent être réalisées à partir de portes NOR.

Puisqu'une porte NOR peut être faite à partir d'un NON et d'un OU, le résultat suit.

— Paul Boddington
source

64

@PaulDraper ou portes NAND

— slebetman

25

Il a fallu 4100 portes NOR pour faire atterrir deux personnes sur la lune.

— Hans Passant

4

@HansPassant Et une chaîne. Beaucoup de ficelle. (Mémoire de corde de base, pas la variété de boîtes de conserve.)

— un CVn

3

@HansPassant Parfois, je souhaite que Stack Exchange soit Wikipedia, alors j'insère une [citation-needed]marque juste là.

— Simon Forsberg

11

Oui, désolé, ordinateur de guidage Apollo .

— Hans Passant

64

Prenez le temps de lire sur les lois de DeMorgan si vous le pouvez.

Vous y trouverez la réponse dans la lecture, ainsi que des références aux preuves logiques.

Mais essentiellement, la réponse est oui.

EDIT : Pour explicitation, mon point est que l'on peut logiquement déduire une expression OR d'une expression AND, et vice-versa. Il existe également d'autres lois pour l'équivalence et l'inférence logiques, mais je pense que celle-ci est tout à fait appropriée.

EDIT 2 : Voici une preuve via la table de vérité montrant l'équivalence logique de l'expression suivante.

Loi de DeMorgan: !(!A || !B) -> A && B

 _____________________________________________________
| A | B | ! A | ! B | ! A || ! B | ! (! A ||! B) | A && B |
-------------------------------------------------- -----
| 0 | 0 | 1 | 1 | 1 | 0 | 0 |
-------------------------------------------------- -----
| 0 | 1 | 1 | 0 | 1 | 0 | 0 |
-------------------------------------------------- -----
| 1 | 0 | 0 | 1 | 1 | 0 | 0 |
-------------------------------------------------- -----
| 1 | 1 | 0 | 0 | 0 | 1 | 1 |
_______________________________________________________

— ryuu9187
source

19

Certaines personnes doivent voter contre dans le cadre de leur "complétude fonctionnelle"

— Jesse

3

À + 27 / -2, je ne m'inquiéterais pas beaucoup d'un downvote errant.

— un CVn du

2

@ MichaelKjörling Je suis simplement curieux de savoir pourquoi certaines personnes ont pensé que ma réponse n'était pas utile / nuisible.

— ryuu9187

3

Généralement, les réponses qui reposent sur des liens ne sont pas trop appréciées (car les liens meurent), mais dans ce cas, il y a tellement d'explications alternatives aux lois de DeMorgan, que je ne vois pas de problème - encore, c'est ma supposition quant à la DV

— user2813274

@ user2813274 Merci pour l'explication. J'espère que mes modifications aideront à combler le fossé entre la recherche personnelle et la réponse.

— ryuu9187

11

NAND et NOR sont universels, ils peuvent être utilisés pour créer n'importe quelle opération logique que vous voulez n'importe où; d'autres opérateurs sont disponibles dans les langages de programmation pour faciliter l'écriture et la lisibilité des codes.

Toutes les opérations logiques qui doivent être câblées en circuit sont également développées en utilisant des circuits intégrés NAND ou NOR uniquement.

— anand
source

10

Oui, selon l'algèbre booléenne, toute fonction booléenne peut être exprimée comme une somme de minterms ou un produit de maxterms, qui est appelé forme normale canonique . Il n'y a aucune raison pour laquelle une telle logique ne pourrait pas être appliquée aux mêmes opérateurs utilisés en informatique.

https://en.wikipedia.org/wiki/Canonical_normal_form

— Michał Szydłowski
source