Lógica proposicional aplicada a la programación

🧠 ¿Qué es la lógica?

La lógica proposicional es una rama de la lógica matemática que estudia los principios formales del razonamiento válido. A diferencia de la lógica informal que empleamos en el día a día, la lógica proposicional elimina toda ambigüedad y trabaja exclusivamente con dos valores: verdadero y falso. Para cualquier persona que desee aprender a programar, comprender estos fundamentos resulta imprescindible, ya que toda estructura de decisión en un lenguaje de programación —desde un simple if hasta un complejo sistema de reglas de negocio— se apoya en la evaluación de expresiones lógicas.

El término lógica proviene del griego logikḗ, que significa «dotado de razón». Aristóteles fue el primero en sistematizar las reglas del razonamiento formal en el siglo IV a.C., pero la lógica proposicional moderna tal como la conocemos fue desarrollada por George Boole en el siglo XIX. De hecho, el álgebra de Boole (Boolean algebra) es la base teórica sobre la que se construyen los circuitos digitales y, por extensión, toda la informática contemporánea.

📖 Lenguaje natural vs. lenguaje formal

Antes de adentrarse en la lógica proposicional conviene distinguir entre dos tipos de lenguaje que los seres humanos utilizan para comunicarse y razonar:

Los lenguajes de programación son, en esencia, lenguajes formales. Cuando se escribe una condición como edad >= 18 && tieneDNI, no existe margen de interpretación: el compilador evalúa la expresión de forma determinista y produce un resultado exacto. Esta precisión es posible gracias a que los lenguajes de programación heredan las reglas de la lógica proposicional.

La gramática y las reglas de los lenguajes naturales surgieron después de que estos ya existieran, como un intento de describir y normalizar la comunicación. Las matemáticas y la lógica, en cambio, nacieron precisamente para formalizar los razonamientos humanos y permitir inferencias complejas basadas en axiomas, teoremas y demostraciones rigurosas.

🔍 Proposiciones y valores de verdad

Una proposición (también llamada sentencia o fórmula atómica) es un enunciado declarativo que puede ser verdadero (V) o falso (F), pero nunca ambos a la vez. Veamos algunos ejemplos:

El último ejemplo merece atención especial: «x es mayor que 10» no es una proposición porque su valor de verdad depende del valor concreto de x. Se denomina predicado o función proposicional, y solo se convierte en proposición cuando se asigna un valor concreto a la variable.

🔹 Variables proposicionales

En lógica proposicional se utilizan letras minúsculas (p, q, r, s…) como variables proposicionales, es decir, símbolos que representan proposiciones cuyo valor de verdad puede variar. Esto permite escribir fórmulas genéricas como p AND q sin referirse a proposiciones concretas.

En programación, las variables booleanas cumplen exactamente el mismo papel. En Java, una variable de tipo boolean solo puede almacenar true o false, lo que la convierte en el equivalente directo de una variable proposicional:

// Variables proposicionales en Java
boolean haceFrio = true;          // p = "hace frío"
boolean llevoAbrigo = false;      // q = "llevo abrigo"
boolean tengoFrio = haceFrio && !llevoAbrigo;  // p AND NOT q

System.out.println(tengoFrio);    // Salida: true

⚙️ Operadores lógicos fundamentales

Los operadores lógicos (también llamados conectivas lógicas) son símbolos que permiten combinar proposiciones para formar fórmulas más complejas. Se clasifican en dos categorías:

Operadores unarios: actúan sobre una sola proposición. El único operador unario fundamental es la negación (NOT).

Operadores binarios: actúan sobre dos proposiciones. Los principales son la conjunción (AND), la disyunción (OR), la disyunción exclusiva (XOR), la implicación (→) y la bicondicional (↔).

🔹 Negación (NOT) — Operador unario

La negación invierte el valor de verdad de una proposición. Si p es verdadero, ¬p (NOT p) es falso, y viceversa. Es el único operador unario de la lógica proposicional y se evalúa de derecha a izquierda.

Ejemplo: si p representa «hace frío» y p es verdadero, entonces ¬p (NOT p) equivale a «no hace frío» y es falso.

🔹 Conjunción (AND) — Ambos verdaderos

La conjunción produce un resultado verdadero únicamente cuando ambos operandos son verdaderos. Si alguno de los dos es falso, el resultado es falso. Se evalúa de izquierda a derecha.

Ejemplo: «Tengo hambre Y hay comida en la nevera». Solo podemos comer si ambas condiciones se cumplen simultáneamente.

🔹 Disyunción (OR) — Al menos uno verdadero

La disyunción inclusiva produce un resultado verdadero cuando al menos uno de los operandos es verdadero. Solo es falsa cuando ambos operandos son falsos.

Ejemplo: «Puedo pagar con tarjeta O en efectivo». Basta con disponer de uno de los dos medios de pago (aunque tener ambos también es válido).

🔹 Disyunción exclusiva (XOR) — Exactamente uno verdadero

El XOR produce verdadero cuando exactamente uno de los operandos es verdadero, pero no ambos. A diferencia del OR inclusivo, el caso en que los dos operandos son verdaderos produce falso.

Ejemplo: «El semáforo está en verde O exclusivamente en rojo». No puede estar en ambos colores simultáneamente.

📊 Tablas de verdad completas

Una tabla de verdad es una representación tabular que muestra el resultado de un operador lógico para todas las combinaciones posibles de valores de sus operandos. Con n variables proposicionales se generan 2ⁿ filas (combinaciones).

🔹 NOT (negación)

🔹 AND (conjunción)

🔹 OR (disyunción inclusiva)

🔹 XOR (disyunción exclusiva)

🔹 Implicación (→) y bicondicional (↔)

📐 Precedencia y asociatividad de operadores

Cuando una fórmula lógica contiene varios operadores, es necesario establecer un orden de evaluación. La precedencia determina qué operador se evalúa primero y la asociatividad indica en qué dirección se agrupan los operandos cuando hay operadores de igual precedencia.

La asociatividad indica cómo se agrupan operadores de igual prioridad. Por ejemplo, el operador NOT se evalúa de derecha a izquierda: en la expresión ¬¬p, primero se niega p y después se niega el resultado. El operador AND se evalúa de izquierda a derecha: en p ∧ q ∧ r, primero se evalúa p ∧ q y después el resultado se combina con r.

🧮 Evaluación de fórmulas paso a paso

Veamos cómo evaluar una fórmula lógica compleja aplicando las reglas de precedencia. Consideremos la fórmula:

¬p ∧ q ∨ r

Con los valores: p = V, q = F, r = V.

El resultado final es V (verdadero). Si quisiéramos que el OR se evaluara antes que el AND, deberíamos usar paréntesis: ¬p ∧ (q ∨ r), lo que produciría un resultado diferente:

El resultado cambia a F (falso). Este ejemplo demuestra la importancia de conocer la precedencia y de usar paréntesis cuando se desea forzar un orden de evaluación específico.

☕ Lógica proposicional en Java

Java implementa los operadores de la lógica proposicional mediante operadores específicos del lenguaje. La siguiente tabla muestra la correspondencia directa entre la notación lógica y la sintaxis de Java:

Veamos un ejemplo completo que aplica los operadores lógicos a un problema real de control de acceso:

public class LogicaAcceso {
    public static void main(String[] args) {
        boolean esEmpleado = true;
        boolean tieneCredencial = false;
        boolean esVisitante = true;
        boolean tieneAutorizacion = true;

        // p ∧ q: el empleado debe tener credencial
        boolean accesoEmpleado = esEmpleado && tieneCredencial;

        // r ∧ s: el visitante debe tener autorización
        boolean accesoVisitante = esVisitante && tieneAutorizacion;

        // (p ∧ q) ∨ (r ∧ s): acceso si cumple alguna vía
        boolean accesoPermitido = accesoEmpleado || accesoVisitante;

        System.out.println("Acceso empleado: " + accesoEmpleado);     // false
        System.out.println("Acceso visitante: " + accesoVisitante);   // true
        System.out.println("Acceso permitido: " + accesoPermitido);   // true
    }
}

🔹 Precedencia de operadores lógicos en Java

Java respeta una precedencia coherente con la lógica proposicional. De mayor a menor prioridad:

⚡ Evaluación en cortocircuito (short-circuit evaluation)

Una de las características más importantes de los operadores lógicos en Java es la evaluación en cortocircuito (short-circuit evaluation). Este mecanismo hace que Java deje de evaluar una expresión lógica en cuanto el resultado queda determinado:

Con && (AND): si el primer operando es false, el resultado es false sin evaluar el segundo operando. Esto es lógicamente correcto: si uno de los dos es falso, la conjunción es falsa independientemente del otro.

Con || (OR): si el primer operando es true, el resultado es true sin evaluar el segundo operando. Si uno es verdadero, la disyunción es verdadera independientemente del otro.

public class Cortocircuito {
    public static void main(String[] args) {
        String nombre = null;

        // ✅ Seguro: si nombre es null, no se ejecuta .length()
        if (nombre != null && nombre.length() > 0) {
            System.out.println("Nombre válido: " + nombre);
        } else {
            System.out.println("Nombre vacío o nulo");
        }
        // Salida: Nombre vacío o nulo

        // ❌ Peligroso: sin cortocircuito, & evalúa ambos lados
        // if (nombre != null & nombre.length() > 0) {
        //     // ¡NullPointerException! Se evalúa nombre.length()
        //     // aunque nombre sea null
        // }

        // Cortocircuito con OR: valor por defecto
        int puerto = 0;
        int puertoFinal = (puerto > 0) ? puerto : 8080;
        System.out.println("Puerto: " + puertoFinal);  // Puerto: 8080
    }
}

🏗️ Ejemplo integrador: sistema de validación de pedidos

El siguiente ejemplo reúne todos los conceptos de lógica proposicional aplicados a un caso práctico: un sistema de validación de pedidos en una tienda online. Cada condición del negocio se modela como una proposición lógica, y las reglas de validación se expresan como fórmulas compuestas.

public class ValidadorPedido {

    public static void main(String[] args) {
        // --- Proposiciones (datos del pedido) ---
        double totalCompra = 85.50;
        boolean clienteRegistrado = true;
        boolean direccionVerificada = true;
        boolean metodoPagoValido = true;
        boolean productoEnStock = true;
        boolean esEnvioInternacional = false;
        boolean tienePermisoExportacion = false;

        // --- Fórmula 1: ¿El cliente puede comprar? ---
        // p ∧ q: debe estar registrado Y tener dirección verificada
        boolean clienteValido = clienteRegistrado && direccionVerificada;

        // --- Fórmula 2: ¿El pago es aceptable? ---
        // r ∧ (s > 0): método válido Y total positivo
        boolean pagoAceptable = metodoPagoValido && totalCompra > 0;

        // --- Fórmula 3: ¿El envío es posible? ---
        // ¬e ∨ (e ∧ x): no es internacional, O si lo es, tiene permiso
        boolean envioPosible = !esEnvioInternacional
                || (esEnvioInternacional && tienePermisoExportacion);

        // --- Fórmula final: todas las condiciones ---
        // f1 ∧ f2 ∧ f3 ∧ stock
        boolean pedidoValido = clienteValido
                && pagoAceptable
                && envioPosible
                && productoEnStock;

        // --- Resultado ---
        System.out.println("=== Validación del Pedido ===");
        System.out.println("Cliente válido:    " + clienteValido);
        System.out.println("Pago aceptable:    " + pagoAceptable);
        System.out.println("Envío posible:     " + envioPosible);
        System.out.println("Producto en stock: " + productoEnStock);
        System.out.println("-----------------------------");
        System.out.println("PEDIDO VÁLIDO:     " + pedidoValido);

        // Demostración de XOR
        boolean pagoTarjeta = true;
        boolean pagoTransferencia = false;
        // Solo se permite un método de pago (XOR)
        boolean metodoUnico = pagoTarjeta ^ pagoTransferencia;
        System.out.println("\nMétodo de pago único: " + metodoUnico);
    }
}
// Salida:
// === Validación del Pedido ===
// Cliente válido:    true
// Pago aceptable:    true
// Envío posible:     true
// Producto en stock: true
// -----------------------------
// PEDIDO VÁLIDO:     true
//
// Método de pago único: true

✏️ Ejercicios resueltos

public class SistemaDescuentos {
    public static void main(String[] args) {
        boolean esSocio = true;
        boolean esPremium = false;
        double totalCompra = 120.0;
        boolean tieneCupon = true;

        // Regla 1: descuento 10% si es socio Y compra > 100
        boolean descuentoSocio = esSocio && totalCompra > 100;

        // Regla 2: envío gratis si compra > 50 O es premium
        boolean envioGratis = totalCompra > 50 || esPremium;

        // Regla 3: NO puede usar cupón si ya tiene descuento
        boolean puedUsarCupon = tieneCupon && !descuentoSocio;

        System.out.println("Descuento socio: " + descuentoSocio);  // true
        System.out.println("Envío gratis: " + envioGratis);        // true
        System.out.println("Puede usar cupón: " + puedUsarCupon);  // false
    }
}

String[] nombres = {"Ana", "Luis", null, "Carlos"};
for (int i = 0; i < nombres.length; i++) {
    if (nombres[i] != null && nombres[i].length() > 3) {
        System.out.println(nombres[i] + " tiene más de 3 letras");
    }
}