Sont || et ! opérateurs suffisants pour rendre chaque expression logique possible?
L'expression logique ( a && b )(a et b ont tous deux des valeurs booléennes) peut être écrit comme !(!a || !b), par exemple. Cela ne signifie-t-il pas que && est "inutile"? Cela signifie-t-il que les expressions logiques toutes ne peuvent être créées qu'avec || et !?
Oui, comme l'ont souligné les autres réponses, l'ensemble des opérateurs comprenant || et ! est fonctionnellement complet . En voici une preuve constructive, montrant comment les utiliser pour exprimer les seize connecteurs possibles entre les variables booléennes A et B:
- True :
A || !A - A NAND B :
!A || !B - B implique A :
!B || A - A implique B :
!A || B - A OR B :
A || B - Not B :
!B - pas A :
!A - A XOR B :
!(!A || B) || !(A || !B) - A XNOR B :
!(!A || !B) || !(A || B) - A :
A - B :
B - A NOR B :
!(A || B) - A n'implique pas B :
!(!A || B) - B n'implique pas A :
!(!B || A) - A AND B :
!(!A || !B) - False :
!(A || !A)
Notez que NAND et NOR sont eux-mêmes fonctionnellement complets (ce qui peut être prouvé à l'aide de la même méthode ci-dessus), donc si vous voulez vérifier qu'un ensemble d'opérateurs est fonctionnellement complet, il vous suffit de peut exprimer NAND ou NOR avec elle.
Voici un graphique montrant le diagrammes de Venn pour chacun des connecteurs décrits ci-dessus:
[ source ]
Ce que vous décrivez est complétude fonctionnelle .
Ceci décrit un ensemble d'opérateurs logiques suffisant pour "exprimer toutes les tables de vérité possibles". Votre groupe d'opérateurs Java, {||, !}, est suffisant. il correspond à l'ensemble {∨, ¬}, répertorié dans la section "Ensembles d'opérateurs minimalement complets du point de vue fonctionnel".
L'ensemble de toutes les tables de vérité désigne tous les ensembles possibles de 4 valeurs booléennes pouvant être le résultat d'une opération entre 2 valeurs booléennes. Comme il existe 2 valeurs possibles pour un booléen, il y a 24, 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 renvoient, ainsi qu'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, notamment les ensembles d'élément {NAND} et {NOR}, qui ne possèdent pas d'opérateur unique correspondant en Java.
Oui.
Toutes les portes logiques peuvent être faites à partir de NOR portes.
Puisqu'un NOR porte peut être faite à partir d'un NON et un OU, le résultat suit.
Prenez le temps de lire lois de DeMorgan si vous le pouvez.
Vous 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 des raisons de clarté, je veux dire que l'on peut déduire logiquement une expression OR à partir d'une expression AND, et vice-versa. vice versa. Il existe également davantage de lois sur l'équivalence logique et l'inférence, mais je pense que celle-ci est à peu près à propos.
EDIT 2 : Voici une preuve via vérité-table 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 | _______________________________________________________
NAND et NI sont universels, ils peuvent être utilisés pour créer n'importe quelle opération logique de votre choix. d'autres opérateurs sont disponibles dans les langages de programmation pour faciliter l'écriture et la lisibilité des codes.
De plus, toutes les opérations logiques devant être câblées dans le circuit sont également développées à l’aide de circuits intégrés NAND ou NOR uniquement.
Oui, selon l'algèbre booléenne, toute fonction booléenne peut être exprimée sous la forme d'une somme de minterms ou d'un produit de maxterms, appelée forme normale canonique . Il n'y a aucune raison pour qu'une telle logique ne puisse pas être appliquée aux mêmes opérateurs que ceux utilisés en informatique.