Tablas de verdad

boolean p = true;
System.out.println("p = " + p);          // p = true
System.out.println("NOT p = " + !p);     // NOT p = false

boolean q = false;
System.out.println("q = " + q);          // q = false
System.out.println("NOT q = " + !q);     // NOT q = true

// Un usuario accede solo si tiene credenciales válidas Y cuenta activa
boolean credencialesValidas = true;
boolean cuentaActiva = false;

boolean acceso = credencialesValidas && cuentaActiva;
System.out.println("Acceso permitido: " + acceso);  // false

// Tabla de verdad completa generada por código
boolean[] valores = {true, false};
System.out.println("\n  p\t  q\t  p AND q");
System.out.println("-----------------------------");
for (boolean p : valores) {
    for (boolean q : valores) {
        System.out.printf("  %s\t  %s\t  %s%n", p, q, (p && q));
    }
}

// Se activa la alarma si hay humo O si la temperatura supera 60°C
boolean hayHumo = false;
boolean temperaturaAlta = true;

boolean activarAlarma = hayHumo || temperaturaAlta;
System.out.println("Alarma activada: " + activarAlarma);  // true

// Tabla de verdad completa
boolean[] v = {true, false};
System.out.println("\n  p\t  q\t  p OR q");
System.out.println("-----------------------------");
for (boolean p : v) {
    for (boolean q : v) {
        System.out.printf("  %s\t  %s\t  %s%n", p, q, (p || q));
    }
}

// En un turno rotativo, exactamente uno de los dos empleados trabaja
boolean trabajaAna = true;
boolean trabajaCarlos = true;

boolean turnoValido = trabajaAna ^ trabajaCarlos;
System.out.println("Turno válido: " + turnoValido);  // false (ambos a la vez)

trabajaCarlos = false;
turnoValido = trabajaAna ^ trabajaCarlos;
System.out.println("Turno válido: " + turnoValido);  // true (solo uno)

// Implicación: "Si estudias, entonces apruebas"
// En Java: !p || q  (equivalente lógico de p → q)
boolean estudia = true;
boolean aprueba = false;

boolean implicacion = !estudia || aprueba;
System.out.println("Si estudia → aprueba: " + implicacion);  // false

// La única combinación falsa: estudia=true, aprueba=false
// Todas las demás devuelven true

// Demostración de las leyes de De Morgan en Java
boolean[] valores = {true, false};

System.out.println("=== Primera Ley de De Morgan ===");
System.out.println("  p\t  q\t  !(p&&q)\t  !p||!q");
for (boolean p : valores) {
    for (boolean q : valores) {
        boolean izq = !(p && q);
        boolean der = !p || !q;
        System.out.printf("  %s\t  %s\t  %s\t\t  %s\t  %s%n",
            p, q, izq, der, izq == der ? "✓" : "✗");
    }
}

System.out.println("\n=== Segunda Ley de De Morgan ===");
System.out.println("  p\t  q\t  !(p||q)\t  !p&&!q");
for (boolean p : valores) {
    for (boolean q : valores) {
        boolean izq = !(p || q);
        boolean der = !p && !q;
        System.out.printf("  %s\t  %s\t  %s\t\t  %s\t  %s%n",
            p, q, izq, der, izq == der ? "✓" : "✗");
    }
}

public class TablasDeVerdad {
    public static void main(String[] args) {
        boolean[] valores = {true, false};

        System.out.println("╔═══════╦═══════╦══════╦══════╦══════╦══════╦════════╦═════════╗");
        System.out.println("║   p   ║   q   ║  NOT ║  AND ║  OR  ║  XOR ║  p→q   ║  p↔q   ║");
        System.out.println("╠═══════╬═══════╬══════╬══════╬══════╬══════╬════════╬═════════╣");

        for (boolean p : valores) {
            for (boolean q : valores) {
                System.out.printf("║ %-5s ║ %-5s ║ %-4s ║ %-4s ║ %-4s ║ %-4s ║ %-6s ║ %-7s ║%n",
                    p, q,
                    !p,              // NOT p
                    p && q,          // AND
                    p || q,          // OR
                    p ^ q,           // XOR
                    !p || q,         // Condicional (p → q)
                    p == q           // Bicondicional (p ↔ q)
                );
            }
        }

        System.out.println("╚═══════╩═══════╩══════╩══════╩══════╩══════╩════════╩═════════╝");
    }
}

public class ValidadorProposiciones {

    // Verificar si una fórmula es tautología (siempre verdadera)
    public static boolean esTautologia(boolean[] resultados) {
        for (boolean r : resultados) {
            if (!r) return false;
        }
        return true;
    }

    // Verificar si es contradicción (siempre falsa)
    public static boolean esContradiccion(boolean[] resultados) {
        for (boolean r : resultados) {
            if (r) return false;
        }
        return true;
    }

    // Verificar si dos fórmulas son equivalentes
    public static boolean sonEquivalentes(boolean[] f1, boolean[] f2) {
        if (f1.length != f2.length) return false;
        for (int i = 0; i < f1.length; i++) {
            if (f1[i] != f2[i]) return false;
        }
        return true;
    }

    public static void main(String[] args) {
        boolean[] valores = {true, false};

        // === Verificar: p OR NOT p (tautología esperada) ===
        System.out.println("=== Fórmula: p ∨ ¬p ===");
        boolean[] resultadosORNot = new boolean[2];
        int idx = 0;
        for (boolean p : valores) {
            boolean resultado = p || !p;
            resultadosORNot[idx++] = resultado;
            System.out.printf("  p=%s → %s%n", p, resultado);
        }
        System.out.println("¿Tautología? " + esTautologia(resultadosORNot));

        // === Verificar: p AND NOT p (contradicción esperada) ===
        System.out.println("\n=== Fórmula: p ∧ ¬p ===");
        boolean[] resultadosANDNot = new boolean[2];
        idx = 0;
        for (boolean p : valores) {
            boolean resultado = p && !p;
            resultadosANDNot[idx++] = resultado;
            System.out.printf("  p=%s → %s%n", p, resultado);
        }
        System.out.println("¿Contradicción? " + esContradiccion(resultadosANDNot));

        // === Verificar ley de De Morgan ===
        System.out.println("\n=== Ley de De Morgan: ¬(p∧q) ≡ ¬p∨¬q ===");
        boolean[] formula1 = new boolean[4];
        boolean[] formula2 = new boolean[4];
        idx = 0;
        for (boolean p : valores) {
            for (boolean q : valores) {
                formula1[idx] = !(p && q);
                formula2[idx] = !p || !q;
                System.out.printf("  p=%s, q=%s → ¬(p∧q)=%s, ¬p∨¬q=%s%n",
                    p, q, formula1[idx], formula2[idx]);
                idx++;
            }
        }
        System.out.println("¿Equivalentes? " + sonEquivalentes(formula1, formula2));

        // === Clasificar: (p → q) ∧ (q → p) ↔ (p ↔ q) ===
        System.out.println("\n=== (p→q)∧(q→p) vs (p↔q) ===");
        boolean[] f1 = new boolean[4];
        boolean[] f2 = new boolean[4];
        idx = 0;
        for (boolean p : valores) {
            for (boolean q : valores) {
                f1[idx] = (!p || q) && (!q || p);  // (p→q) ∧ (q→p)
                f2[idx] = (p == q);                   // p ↔ q
                System.out.printf("  p=%s, q=%s → F1=%s, F2=%s%n",
                    p, q, f1[idx], f2[idx]);
                idx++;
            }
        }
        System.out.println("¿Equivalentes? " + sonEquivalentes(f1, f2));
    }
}

// ❌ Error: asumir que || es exclusivo
boolean a = true, b = true;
System.out.println(a || b);  // true (no false)

// ✅ Si necesitas exclusividad, usa XOR (^)
System.out.println(a ^ b);   // false

// ❌ Error: negar sin cambiar el operador
// !(a && b) NO es igual a (!a && !b)
boolean a = true, b = false;
System.out.println(!(a && b));      // true
System.out.println(!a && !b);       // false  ← ¡DIFERENTE!

// ✅ Correcto: negar Y cambiar el operador
System.out.println(!a || !b);       // true  ← Igual que !(a && b)

// p → q equivale a !p || q
boolean llueve = false;
boolean llevoParaguas = false;

// ❌ Error: pensar que esto es false
boolean implicacion = !llueve || llevoParaguas;
System.out.println(implicacion);  // true (verdad vacía)