São || e! operadores suficientes para criar todas as expressões lógicas possíveis?

A expressão lógica ( a && b ) (ambos ae bcom valores booleanos) pode ser escrita como !(!a || !b), por exemplo. Isso não significa que &&é "desnecessário"? Isso significa que todas as expressões lógicas podem ser feitas apenas usando ||e !?

Sim, como as outras respostas apontaram, o conjunto de operadores que compreende ||e !é funcionalmente completo . Aqui está uma prova construtiva disso, mostrando como usá-los para expressar todos os dezesseis possíveis conectores lógicos possíveis entre as variáveis ​​booleanas Ae B:

• Verdadeiro :A || !A
• A NAND B :!A || !B
• B implica A :!B || A
• A implica B :!A || B
• A OU B :A || B
• Não B :!B
• Não 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ão implica B :!(!A || B)
• B não implica A :!(!B || A)
• A e B :!(!A || !B)
• Falso :!(A || !A)

Observe que NAND e NOR são eles próprios funcionalmente completos (o que pode ser comprovado usando o mesmo método acima); portanto, se você deseja verificar se um conjunto de operadores está funcionalmente completo, basta mostrar que você pode expressar NAND ou NOR com isso.

Aqui está um gráfico mostrando os diagramas de Venn para cada um dos conectivos listados acima:

[ fonte ]

O que você está descrevendo é integridade funcional .

Isso descreve um conjunto de operadores lógicos que é suficiente para "expressar todas as tabelas verdadeiras possíveis". O seu Java do operador, { ||, !}, é suficiente; corresponde ao conjunto {∨, ¬}, listado na seção "Conjuntos mínimos de operadores funcionalmente completos".

O conjunto de todas as tabelas verdadeiras significa todos os conjuntos possíveis de 4 valores booleanos que podem ser o resultado de uma operação entre 2 valores booleanos. Como existem 2 valores possíveis para um booleano, existem 2 ⁴ ou 16 tabelas de verdade possíveis.

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

Aqui está uma tabela dos números da tabela verdade (0-15), as combinações ||e !que a produzem e uma descrição.

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

Existem muitos outros conjuntos funcionalmente completos, incluindo os conjuntos de um elemento {NAND} e {NOR}, que não possuem operadores únicos correspondentes em Java.

Sim.

Todas as portas lógicas podem ser feitas a partir de portas NOR.

Como uma porta NOR pode ser feita a partir de um NOT e um OR, o resultado segue.

Reserve um tempo para ler as leis de DeMorgan, se puder.

Você encontrará a resposta na leitura, assim como referências às provas lógicas.

Mas essencialmente, a resposta é sim.

EDIT : Para explicitação, o que quero dizer é que é possível inferir logicamente uma expressão OR a partir de uma expressão AND e vice-versa. Também existem mais leis para equivalência lógica e inferência, mas acho que essa é mais apropriada.

EDIT 2 : Aqui está uma prova via tabela de verdade mostrando a equivalência lógica da expressão a seguir.

Lei 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 e NOR são universais, podem ser usados ​​para criar qualquer operação lógica que você deseja em qualquer lugar; outro operador está disponível nas linguagens de programação para facilitar a gravação e a criação de códigos legíveis.

Além disso, todas as operações lógicas que precisam ser conectadas no circuito também são desenvolvidas usando ICs NAND ou NOR apenas.

Sim, de acordo com a álgebra booleana, qualquer função booleana pode ser expressa como uma soma de mintermos ou um produto de maxtermos, chamado forma normal canônica . Não há razão para que essa lógica não possa ser aplicada aos mesmos operadores usados ​​na ciência da computação.

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