Lógica Proposicional e Operadores Relacionais

1. O Que É Lógica Proposicional? A Raiz da Decisão Computacional

Até agora, nossos algoritmos comportavam-se como esteiras industriais lineares: liam uma entrada, calculavam uma fórmula e exibiam a resposta no monitor. No entanto, um software inteligente só existe quando ele é capaz de fazer perguntas e escolher caminhos diferentes dependendo das respostas.

Para que uma máquina tome decisões, ela se apoia em um ramo secular da matemática e da filosofia chamado Lógica Proposicional (ou Lógica Sentencial), cujas bases remontam a Aristóteles e foram formalizadas por George Boole.

Na computação, uma proposição é uma afirmação que só pode admitir dois estados absolutos:

• Verdadeiro (True / 1)
• Falso (False / 0)

Esse princípio é conhecido na matemática clássica como o Princípio do Terceiro Excluído: uma afirmação é verdadeira ou é falsa; não existe "mais ou menos", "quase" ou "depende". Ou o saldo é suficiente para pagar o boleto, ou não é.

2. Os 6 Operadores Relacionais Fundamentais

Como formulamos essas perguntas dentro do código? Utilizando os operadores relacionais: operadores binários que colocam dois valores lado a lado na CPU e devolvem um resultado estritamente do tipo logico.

1. Igual a (==)

Verifica se o valor do lado esquerdo é idêntico em magnitude ao valor do lado direito.

• 5 == 5 → Retorna verdadeiro.
• 10 == 20 → Retorna falso.

2. Diferente de (!=)

É o inverso exato da igualdade. Na maioria das linguagens de programação, o ponto de exclamação (!) representa negação lógica. Logo, != lê-se "NÃO é igual a".

• 10 != 5 → Retorna verdadeiro (porque 10 realmente é diferente de 5).
• 8 != 8 → Retorna falso (porque eles são idênticos).

3. Maior que (>)

Avalia se o operando da esquerda é estritamente superior ao operando da direita.

• 25 > 18 → Retorna verdadeiro.
• 18 > 18 → Retorna falso (pois 18 é igual a 18, e não maior!).

4. Menor que (<)

Avalia se o operando da esquerda é estritamente inferior ao da direita.

• 15 < 30 → Retorna verdadeiro.
• 50 < 10 → Retorna falso.

5. Maior ou igual a (>=)

Combina duas verificações: o valor da esquerda é maior OU é igual ao da direita? Basta que uma dessas condições seja satisfeita para que o resultado seja verdadeiro.

• 20 >= 18 → Retorna verdadeiro (pois 20 é maior).
• 18 >= 18 → Retorna verdadeiro (pois empatou no valor exato de corte).
• 17 >= 18 → Retorna falso.

6. Menor ou igual a (<=)

Verifica se o valor da esquerda é inferior ou empata no limite máximo permitido.

• 60 <= 80 → Retorna verdadeiro (dentro do limite de velocidade).
• 80 <= 80 → Retorna verdadeiro (atingiu o limite exato sem ultrapassar).
• 81 <= 80 → Retorna falso (excedeu o limite).

3. O Erro Mais Letal da Programação: '=' vs '=='

Se perguntarmos a engenheiros de software seniores qual foi o erro de digitação que mais lhes causou noites em claro no início de suas carreiras, a resposta unânime será a confusão entre o sinal de atribuição simples (=) e o operador de comparação de igualdade (==).

Observe a diferença conceitual na tabela a seguir:

4. Condições de Borda: O Ponto Cego entre '>' e '>='

Na engenharia de software profissional, os bugs mais difíceis de rastrear não ocorrem nos números centrais, mas sim nas condições de borda (Boundary Conditions): o valor exato que separa o sucesso da falha.

Considere uma regra escolar onde a média de aprovação é 7.0:

• Se o programador escrever: nota > 7.0 (Estrito / Exclusivo)
• O aluno que tirou 7.0 cravado é considerado REPROVADO, porque 7.0 não é maior que 7.0! O sistema exigirá 7.1 para aprová-lo, gerando reclamações legítimas de pais e alunos.
• A forma correta: nota >= 7.0 (Inclusivo). O aluno com 7.0 atinge a igualdade e é aprovado com justiça.

5. Comparando Textos e Números Decimais

Operadores relacionais não se limitam a comparar números inteiros. No entanto, comparar textos e números decimais exige cuidados técnicos especiais:

1. Comparação de Textos (Cadeias de Caracteres)

Ao comparar se dois textos são iguais (nome == "Carlos"), o computador compara byte por byte na tabela Unicode. Isso traz duas consequências imediatas:

• Sensibilidade a Maiúsculas (Case Sensitivity): "Brasil" == "brasil" resultará em falso! Para o computador, a letra 'B' maiúscula possui o código ASCII 66, enquanto 'b' minúsculo possui código 98.
• Ordem Lexicográfica (Ordem de Dicionário): Operadores como < e > funcionam com textos ordenando-os alfabeticamente: "Ana" < "Beatriz" é verdadeiro porque "A" vem antes de "B".

2. O Dilema do Ponto Flutuante (Epsilon)

Como vimos na Aula 04, computadores armazenam números decimais com uma margem infinitesimal de imprecisão binária. Por isso, nunca compare números decimais com igualdade estrita:

// Na matemática do papel: 0.1 + 0.2 é exatamente 0.3
// No computador: 0.1 + 0.2 resulta em 0.30000000000000004!

numero soma = 0.1 + 0.2;
saida(soma == 0.3);  // Retornará falso na maioria das linguagens!

6. Os 5 Erros Clássicos de Comparações em Iniciantes

Evite perder tempo depurando seu código prestando atenção nestas cinco armadilhas recorrentes:

7. Exercício Prático Resolvido: Radar de Velocidade Inteligente

Para consolidar o uso dos operadores relacionais, vamos implementar um algoritmo de radar eletrônico inteligente para rodovias. O programa lê a velocidade máxima permitida na via e a velocidade registrada pelo veículo, gerando um relatório com três diagnósticos booleanos independentes:

1. O veículo está Dentro do Limite? (Velocidade menor ou igual à permitida).
2. O veículo cometeu Excesso de Velocidade? (Velocidade estritamente maior que a permitida).
3. O veículo cometeu infração com Suspensão Imediata da CNH? (Velocidade superior a 50% acima do limite da via).

// 1. Coleta de dados do radar com mensagens interativas
saida("=== SISTEMA DE FISCALIZAÇÃO ELETRÔNICA ===");
numero limiteVia = entrada("Informe a velocidade máxima da via (km/h):");
numero velocidadeCarro = entrada("Informe a velocidade registrada pelo radar (km/h):");

// 2. Processamento com Operadores Relacionais
// Limite com 50% de tolerância para suspensão: limite * 1.50
numero limiteSuspensao = limiteVia * 1.50;

// Comparações relacionais puras gerando resultados booleanos
logico dentroDoLimite = velocidadeCarro <= limiteVia;
logico excessoVelocidade = velocidadeCarro > limiteVia;
logico suspensaoCnh = velocidadeCarro > limiteSuspensao;

// 3. Emissão do Relatório Fiscal
saida("------------------------------------------");
saida("Velocidade da Via: " + limiteVia + " km/h");
saida("Velocidade do Veículo: " + velocidadeCarro + " km/h");
saida("Veículo dentro do limite permitido: " + dentroDoLimite);
saida("Cometeu infração por excesso: " + excessoVelocidade);
saida("Infração gravíssima com suspensão: " + suspensaoCnh);
saida("==========================================");

Acompanhamento pelo Teste de Mesa (Trace Table)

Vamos simular três veículos passando por uma rodovia cujo limite é 80.0 km/h (limite de suspensão: \(80 \times 1.50 = 120.0\) km/h):

Observe como as variáveis booleanas capturaram com exatidão a condição jurídica de cada motorista, servindo de base perfeita para as estruturas condicionais (Se/Senão) que aprenderemos nas próximas aulas.

8. Perguntas Frequentes sobre Operadores Relacionais (FAQ)