Tabela verdade: o que é e como montar

Neste artigo

1. O que é uma tabela verdade?
2. Quais são as tabelas do E, do OU e do NÃO?
3. Quantas linhas tem uma tabela verdade?
4. Como montar uma tabela verdade passo a passo?
5. Como gerar uma tabela verdade em Python, PHP e C?
6. Aí você pergunta: preciso mesmo dos parênteses?
7. O computador testa sempre as duas condições?
8. Quais são os erros mais comuns com a tabela verdade?
9. Agora é com você!

Tabela verdade é a tabela que mostra o resultado de uma expressão lógica para todas as combinações possíveis de verdadeiro e falso das suas partes.

Nos artigos sobre o if e o else e sobre o switch case, o programa tomava decisões testando condições. Toda condição dá verdadeiro ou falso. Quando você junta duas ou mais condições com E, OU e NÃO, a tabela verdade é o mapa que mostra o que sai de cada combinação. Essa parte pode parecer confusa, mas respira fundo! Leia e releia, que você vai aprender!!!

Imagine que você quer MUITO uma pizza de queijo, e tem que ser de queijo. O pedido só acontece se a pizzaria atender a ligação E tiver pizza de queijo. São duas condições, e cada uma pode ser verdadeira ou falsa. Quantas situações existem? Quatro: atende e tem, atende e não tem, não atende e tem, não atende e não tem. Só na primeira você come pizza. Pronto: você acabou de montar uma tabela verdade de cabeça.

O que é uma tabela verdade?

É uma tabela com duas partes. As primeiras colunas trazem as condições simples, uma por coluna. A última coluna traz o resultado da expressão. Cada linha é uma combinação possível de verdadeiro (V) e falso (F). Como nenhuma combinação fica de fora, a tabela responde qualquer pergunta sobre a expressão: quando ela é verdadeira, quando é falsa e se duas expressões diferentes dão sempre o mesmo resultado.

Quais são as tabelas do E, do OU e do NÃO?

• E: o resultado só é verdadeiro quando as duas condições são verdadeiras. É a pizza de queijo: a pizzaria tem de atender E ter o sabor.
• OU: o resultado só é falso quando as duas condições são falsas. Se você aceita queijo OU calabresa, basta a pizzaria ter um dos dois sabores.
• NÃO: inverte o valor. Verdadeiro vira falso, e falso vira verdadeiro.

Nas linguagens, só muda a escrita. No Python, as palavras são and, or e not. No PHP e no C, os sinais são && para o E, || para o OU e ! para o NÃO.

Quantas linhas tem uma tabela verdade?

Depende de quantas condições simples a expressão tem. Com n condições, a tabela tem 2 elevado a n linhas. Cada condição nova dobra o tamanho da tabela: 2 linhas com uma condição, 4 com duas, 8 com três e 16 com quatro. É o último bloco da saída do programa deste artigo.

Como montar uma tabela verdade passo a passo?

Vamos usar a regra de entrada de uma casa de show: a pessoa entra se tem ingresso E (é maior de idade OU está acompanhada de um responsável).

• Passo 1: conte as condições simples. São três: ingresso, maior e acompanhado.
• Passo 2: calcule as linhas. Com três condições, 2 × 2 × 2 = 8.
• Passo 3: preencha as combinações. Na primeira coluna, metade V e metade F. Na segunda, de 2 em 2. Na terceira, de 1 em 1. Assim nenhuma combinação se repete nem fica de fora.
• Passo 4: resolva primeiro o que está entre parênteses, em uma coluna própria.
• Passo 5: resolva o resto e preencha a coluna do resultado.

Ver a animação resolvendo duas linhas da tabela

A tabela mostra uma coisa que a frase escondia: sem ingresso, não adianta ser maior de idade nem estar acompanhado. As quatro linhas com F no ingresso terminam em F.

Como gerar uma tabela verdade em Python, PHP e C?

Para gerar todas as combinações, o programa usa um laço for dentro do outro: um laço para cada condição, passando por verdadeiro e por falso.

Python:

# Tabela verdade: o resultado de uma expressão lógica para todas as combinações

def vf(valor):
    if valor:
        return "V"
    return "F"

valores = [True, False]

print("Tabela do E:")
print("A B   A e B")
for a in valores:
    for b in valores:
        print("%s %s   %s" % (vf(a), vf(b), vf(a and b)))

print("Tabela do OU:")
print("A B   A ou B")
for a in valores:
    for b in valores:
        print("%s %s   %s" % (vf(a), vf(b), vf(a or b)))

print("Tabela do NÃO:")
print("A   não A")
for a in valores:
    print("%s   %s" % (vf(a), vf(not a)))

print("Casa de show: tem ingresso E (é maior de idade OU está acompanhado)")
print("%-8s %-5s %-11s %s" % ("ingresso", "maior", "acompanhado", "entra"))
entram = 0
for ingresso in valores:
    for maior in valores:
        for acompanhado in valores:
            entra = ingresso and (maior or acompanhado)
            if entra:
                entram = entram + 1
            print("%-8s %-5s %-11s %s" % (vf(ingresso), vf(maior), vf(acompanhado), vf(entra)))
print("Linhas em que a pessoa entra: %d de 8" % entram)

print("Negando o E: não (A e B) ao lado de (não A) ou (não B)")
iguais = 0
for a in valores:
    for b in valores:
        esquerda = not (a and b)
        direita = (not a) or (not b)
        if esquerda == direita:
            iguais = iguais + 1
        print("%s %s   %s %s" % (vf(a), vf(b), vf(esquerda), vf(direita)))
print("Linhas com o mesmo resultado: %d de 4" % iguais)

print("Tamanho da tabela:")
linhas = 1
for n in range(1, 5):
    linhas = linhas * 2
    print("n = %d: %d linhas" % (n, linhas))

PHP:

<?php
// Tabela verdade: o resultado de uma expressão lógica para todas as combinações

function vf(bool $valor): string {
    if ($valor) {
        return "V";
    }
    return "F";
}

$valores = [true, false];

echo "Tabela do E:\n";
echo "A B   A e B\n";
foreach ($valores as $a) {
    foreach ($valores as $b) {
        printf("%s %s   %s\n", vf($a), vf($b), vf($a && $b));
    }
}

echo "Tabela do OU:\n";
echo "A B   A ou B\n";
foreach ($valores as $a) {
    foreach ($valores as $b) {
        printf("%s %s   %s\n", vf($a), vf($b), vf($a || $b));
    }
}

echo "Tabela do NÃO:\n";
echo "A   não A\n";
foreach ($valores as $a) {
    printf("%s   %s\n", vf($a), vf(!$a));
}

echo "Casa de show: tem ingresso E (é maior de idade OU está acompanhado)\n";
printf("%-8s %-5s %-11s %s\n", "ingresso", "maior", "acompanhado", "entra");
$entram = 0;
foreach ($valores as $ingresso) {
    foreach ($valores as $maior) {
        foreach ($valores as $acompanhado) {
            $entra = $ingresso && ($maior || $acompanhado);
            if ($entra) {
                $entram = $entram + 1;
            }
            printf("%-8s %-5s %-11s %s\n", vf($ingresso), vf($maior), vf($acompanhado), vf($entra));
        }
    }
}
printf("Linhas em que a pessoa entra: %d de 8\n", $entram);

echo "Negando o E: não (A e B) ao lado de (não A) ou (não B)\n";
$iguais = 0;
foreach ($valores as $a) {
    foreach ($valores as $b) {
        $esquerda = !($a && $b);
        $direita = (!$a) || (!$b);
        if ($esquerda == $direita) {
            $iguais = $iguais + 1;
        }
        printf("%s %s   %s %s\n", vf($a), vf($b), vf($esquerda), vf($direita));
    }
}
printf("Linhas com o mesmo resultado: %d de 4\n", $iguais);

echo "Tamanho da tabela:\n";
$linhas = 1;
for ($n = 1; $n <= 4; $n++) {
    $linhas = $linhas * 2;
    printf("n = %d: %d linhas\n", $n, $linhas);
}

C:

/* Tabela verdade: o resultado de uma expressão lógica para todas as combinações */
#include <stdio.h>
#include <stdbool.h>

const char *vf(bool valor) {
    if (valor) {
        return "V";
    }
    return "F";
}

int main(void) {
    bool valores[] = {true, false};

    printf("Tabela do E:\n");
    printf("A B   A e B\n");
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            bool a = valores[i], b = valores[j];
            printf("%s %s   %s\n", vf(a), vf(b), vf(a && b));
        }
    }

    printf("Tabela do OU:\n");
    printf("A B   A ou B\n");
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            bool a = valores[i], b = valores[j];
            printf("%s %s   %s\n", vf(a), vf(b), vf(a || b));
        }
    }

    printf("Tabela do NÃO:\n");
    printf("A   não A\n");
    for (int i = 0; i < 2; i++) {
        bool a = valores[i];
        printf("%s   %s\n", vf(a), vf(!a));
    }

    printf("Casa de show: tem ingresso E (é maior de idade OU está acompanhado)\n");
    printf("%-8s %-5s %-11s %s\n", "ingresso", "maior", "acompanhado", "entra");
    int entram = 0;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            for (int k = 0; k < 2; k++) {
                bool ingresso = valores[i], maior = valores[j], acompanhado = valores[k];
                bool entra = ingresso && (maior || acompanhado);
                if (entra) {
                    entram = entram + 1;
                }
                printf("%-8s %-5s %-11s %s\n", vf(ingresso), vf(maior), vf(acompanhado), vf(entra));
            }
        }
    }
    printf("Linhas em que a pessoa entra: %d de 8\n", entram);

    printf("Negando o E: não (A e B) ao lado de (não A) ou (não B)\n");
    int iguais = 0;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            bool a = valores[i], b = valores[j];
            bool esquerda = !(a && b);
            bool direita = (!a) || (!b);
            if (esquerda == direita) {
                iguais = iguais + 1;
            }
            printf("%s %s   %s %s\n", vf(a), vf(b), vf(esquerda), vf(direita));
        }
    }
    printf("Linhas com o mesmo resultado: %d de 4\n", iguais);

    printf("Tamanho da tabela:\n");
    int linhas = 1;
    for (int n = 1; n <= 4; n++) {
        linhas = linhas * 2;
        printf("n = %d: %d linhas\n", n, linhas);
    }
    return 0;
}

Saída:

Tabela do E:
A B   A e B
V V   V
V F   F
F V   F
F F   F
Tabela do OU:
A B   A ou B
V V   V
V F   V
F V   V
F F   F
Tabela do NÃO:
A   não A
V   F
F   V
Casa de show: tem ingresso E (é maior de idade OU está acompanhado)
ingresso maior acompanhado entra
V        V     V           V
V        V     F           V
V        F     V           V
V        F     F           F
F        V     V           F
F        V     F           F
F        F     V           F
F        F     F           F
Linhas em que a pessoa entra: 3 de 8
Negando o E: não (A e B) ao lado de (não A) ou (não B)
V V   F F
V F   V V
F V   V V
F F   V V
Linhas com o mesmo resultado: 4 de 4
Tamanho da tabela:
n = 1: 2 linhas
n = 2: 4 linhas
n = 3: 8 linhas
n = 4: 16 linhas

Foque no conceito, e não na linguagem! As três geram as mesmas tabelas. Repare no penúltimo bloco: negar um E dá o mesmo resultado que trocar o E por OU e negar cada parte. As duas colunas ficaram iguais nas 4 linhas. Em português: dizer “não é verdade que a pizzaria atendeu E tinha queijo” é o mesmo que dizer “a pizzaria não atendeu OU não tinha queijo”.

Aí você pergunta: preciso mesmo dos parênteses?

Precisa, quando a expressão mistura E com OU. Testei duas versões da mesma expressão, com os mesmos valores:

True or False and False       resultado: True
(True or False) and False     resultado: False

Sem parênteses, o E foi resolvido antes do OU. O teste deu o mesmo resultado no Python e no PHP. Na dúvida, coloque os parênteses: eles deixam claro o que você quis dizer.

O computador testa sempre as duas condições?

Nem sempre. No Python, o and só avalia a segunda parte se a primeira for verdadeira, e o or só avalia a segunda se a primeira for falsa. No teste, coloquei como segunda parte uma função que avisa quando é chamada. Em False and ligou(), a função não foi chamada: com a primeira parte falsa, o E já está decidido. Em True or ligou(), também não: com a primeira parte verdadeira, o OU já está decidido. É a própria tabela verdade sendo usada para economizar trabalho.

Quais são os erros mais comuns com a tabela verdade?

• Esquecer combinações. Com três condições são 8 linhas, e não 6.
• Confundir o E com o OU. O E exige tudo verdadeiro. O OU se contenta com uma parte verdadeira.
• Ler o OU como “um ou outro, mas não os dois”. Na tabela do OU, V com V dá V.
• Esquecer os parênteses. A mesma expressão deu True sem eles e False com eles.
• Negar pela metade. O contrário de “A e B” não é “não A e não B”. Com A verdadeiro e B falso, a primeira negação dá V e a segunda dá F.

Agora é com você!

No papel:

• Monte a tabela verdade de “A ou (não B)”.
• Quantas linhas tem a tabela de uma expressão com 5 condições simples?
• Uma loja dá frete grátis se a compra passa de 100 reais OU (o cliente é assinante E mora na cidade). Monte as 8 linhas e conte em quantas o frete é grátis.

No computador:

• Acrescente ao programa a tabela de “A ou (não B)”.
• Gere a tabela da regra do frete grátis.
• Compare, linha por linha, “não (A ou B)” com “(não A) e (não B)”.

Tente sozinho, sem pedir a resposta pronta para ninguém, nem para a IA!

No próximo artigo, o assunto são as contas e a atribuição de valores. Até lá!

Confiança Sempre!!!

Fontes:

• Universidade Federal do Vale do São Francisco, Matemática Discreta, parte 1, Introdução à Lógica Formal, com as tabelas verdade, o número de linhas igual ao número de combinações de V e F e a regra de resolver primeiro os conectivos dentro dos parênteses (PDF, slides de aula).
• PUCPR, Ciência da Computação, Lógica Matemática, semana 2, com o número de linhas calculado como 2 elevado a n e as tabelas verdade da conjunção, da disjunção e da negação (documento de aula).
• Universidade Federal de Sergipe, CESAD, Fundamentos de Matemática, aula 3, Valorações e Tabelas de Verdade, com os passos para montar a tabela: contar os símbolos e montar 2 elevado a n linhas, com uma coluna para cada parte da fórmula (PDF).
• Universidade Federal de Sergipe, CESAD, Fundamentos de Matemática, aula 2, com as quatro entradas possíveis dos conectivos que ligam duas proposições (PDF).
• IFPR, Câmpus Foz do Iguaçu, Lógica, material de Matemática, com a observação de que uma fórmula com n átomos tem 2 elevado a n valorações possíveis (PDF).
• Universidade Federal de Rondonópolis, PROFMAT, dissertação sobre raciocínio lógico, com a construção da tabela verdade com uma, duas e três proposições e os valores lógicos da negação, da conjunção e da disjunção inclusiva (PDF).
• eduCAPES, Guia de Raciocínio Lógico com Questões Resolvidas, com as tabelas verdade da negação da conjunção e da negação da disjunção (PDF).
• PHP, manual oficial, operadores lógicos, com o resultado de cada operador: E, OU, XOR e Não.
• Python, documentação oficial, Boolean Operations, com as operações and, or e not em ordem de prioridade e a avaliação da segunda parte só quando ela é necessária (em inglês).
• Os exemplos foram executados em Python 3.13, PHP 8.3 e GCC 13.