6. Lógica proposicional: Tautologías, contradicciones, formas normales, equivalencias e implicaciones lógicas y argumentaciones

Ejemplos con Mathematica

1. Tautología y contradicción

Ejemplo 6.1.

Comprobar si la forma enunciativa: A: ((Subscript[p, 1])⋁(Subscript[p, 2])) ⋀ ((Subscript[p, 3])⋁(Subscript[p, 4])) es tautología o contradicción.

n = 4;
tautologia = True;
p = Table[False, {t, n}];
expresion := (p[[1]] || p[[2]]) && (p[[3]] || 
              p[[4]]);
For[i = 0, 
        i < 2^n, i++, 
j = i; 
For[
          f = n, f > 0, f--, 
resto = 
            Mod[j, 2]; 
j = 
            Floor[j/2]; 
If[resto == 0, 
            p[[f]] = True, 
            p[[f]] = False];
]; 
If[
          TrueQ[expresion], Null, 
          tautologia = False];
];
If[tautologia, 
      Print["La forma enunciativa es una tautología"], 
      Print["La forma enunciativa no es una tautología"]]

n = 4;
contradiccion = True;
p = Table[False, {t, n}];
expresion := (p[[1]] || p[[2]]) && (p[[3]] || 
              p[[4]]);
\(\(For[i = 0, 
        i < 2^n, \(i++\), 
j = i; 
For[
          f = n, f > 0, \(f--\), 
resto = 
            Mod[j, 2]; 
j = 
            Floor[j/2]; 
If[resto == 0, 
            p[\([f]\)] = True, 
            p[\([f]\)] = False];
]; 
If[
          TrueQ[expresion], contradiccion = False];
];\)\)
If[contradiccion, 
      Print["La forma enunciativa es una contradicción"], 
      Print["La forma enunciativa no es una contradicción"]]

2. Formas normales

Ejemplo 6.2.

Calcular las formas normales de la forma enunciativa A: ((Subscript[p, 1])⋁(Subscript[p, 2])) → (Subscript[p, 3]).

n = 3;
cadena = "";
cadena2 = "";
cad = "";
cad2 = "";
contradiccion = True;
tautologia = True;
p = Table[False, {t, n}];
expresion := 
        Implies[(p[[1]] || p[[2]]), p[[3]]];
For[i = 0, i < 2^n, i++, 
        j = i; 
cad = ""; 
cad2 = "\
"; 
For[f = n, f > 0, f--, 
          resto = Mod[j, 2]; 
j = 
            Floor[j/2]; 
If[resto == 0, 
            p[[f]] = True; 
If[f == n, 
              cad = StringJoin["p", ToString[f], cad], 
              cad = StringJoin["p", ToString[f], " ∧ ", 
                  cad]]; If[f == n, 
                cad2 = StringJoin["(~p", ToString[f], ")", cad2], 
                cad2 = StringJoin["(~p", 
                    ToString[f], ")", " ∨ ", cad2]];, 
            p[[f]] = False; 
If[f == n, 
              cad = StringJoin["(~p", ToString[f], ")", cad], 
              cad = StringJoin["(~p", 
                  ToString[f], ")", " ∧ ", 
                  cad]]; 
If[f == n, 
              cad2 = StringJoin["p", ToString[f], cad2], 
              cad2 = StringJoin["p", ToString[f], " ∨ ", 
                  cad2]];];]; 
If[TrueQ[expresion], 
          If[cadena == "", 
            cadena = StringJoin[cadena, "(", cad, ")"], 
            cadena = 
              StringJoin[cadena, " ∨ (", 
                cad, ")"]]; 
contradiccion = 
              False;, 
          If[cadena2 == "", 
            cadena2 = StringJoin[cadena2, "(", cad2, ")"], 
            cadena2 = 
              StringJoin[cadena2, " ∧ (", 
                cad2, ")"]]; 
tautologia = 
            False;];];
If[contradiccion, Print["Es una contradicción."], 
        Print["No es contradicción y la forma normal disyuntiva es: \
", cadena]];
If[tautologia, Print["Es una tautología."], 
        Print["No es tautología y la forma normal conmutativa es: \
", cadena2]];

Ejemplo 6.3.

Calcular una forma enunciativa restringida equivalente a la forma enunciativa A: (Subscript[p, 1])→(Subscript[p, 2]).

Bastará con dar la forma normal disyuntiva o la forma normal conjuntiva de A para tener tal forma enunciativa restringida.

n = 2;
cadena = "";
cadena2 = "";
cad = "";
cad2 = "";
contradiccion = True;
tautologia = True;
p = Table[False, {t, n}];
expresion := Implies[p[[1]], p[[2]]];
For[i = 0, i < 2^n, i++, 
        j = i; 
cad = ""; 
cad2 = "\
"; 
For[f = n, f > 0, f--, 
          resto = Mod[j, 2]; 
j = 
            Floor[j/2]; 
If[resto == 0, 
            p[[f]] = True; 
If[f == n, 
              cad = StringJoin["p", ToString[f], cad], 
              cad = StringJoin["p", ToString[f], " ∧ ", 
                  cad]]; If[f == n, 
                cad2 = StringJoin["(~p", ToString[f], ")", cad2], 
                cad2 = StringJoin["(~p", 
                    ToString[f], ")", " ∨ ", cad2]];, 
            p[[f]] = False; 
If[f == n, 
              cad = StringJoin["(~p", ToString[f], ")", cad], 
              cad = StringJoin["(~p", 
                  ToString[f], ")", " ∧ ", 
                  cad]]; 
If[f == n, 
              cad2 = StringJoin["p", ToString[f], cad2], 
              cad2 = StringJoin["p", ToString[f], " ∨ ", 
                  cad2]];];]; 
If[TrueQ[expresion], 
          If[cadena == "", 
            cadena = StringJoin[cadena, "(", cad, ")"], 
            cadena = 
              StringJoin[cadena, " ∨ (", 
                cad, ")"]]; 
contradiccion = 
              False;, 
          If[cadena2 == "", 
            cadena2 = StringJoin[cadena2, "(", cad2, ")"], 
            cadena2 = 
              StringJoin[cadena2, " ∧ (", 
                cad2, ")"]]; 
tautologia = 
            False;];];
If[contradiccion, Print["Es una contradicción."], 
        Print["No es contradicción y la forma normal disyuntiva es: \
", cadena]];
If[tautologia, Print["Es una tautología."], 
        Print["No es tautología y la forma normal conmutativa es: \
", cadena2]];

Por tanto, una solución para este problema sería la forma enunciativa restringida ((Subscript[p, 1])⋁ (~(Subscript[p, 2]))).

Ejemplo 6.4.

Aplicamos el procedimiento logica a la forma enunciativa ((p→q)→(~r))

\(logica := 
      Module[{tabla, cadena, cadena2, cad, cad2, contradiccion, tautologia}, 
        tabla = Table["F", {x, \((2^n + 1)\)}, {y, 
              n + 1}]; 
For[k = 1, k < n + 1, \(k++\), 
          tabla[\([1, 
                k]\)] = \!\("p" \_ 
                  k\)]; 
tabla[\([1, 
              n + 1]\)] = "Exp"; 
For[i = 0, 
          i < 2^n, \(i++\), 
          j = i; 
For[f = n, f > 0, \(f--\), 
            resto = Mod[j, 2]; 
j = 
              Floor[j/2]; 
If[resto == 0, 
              p[\([f]\)] = True; tabla[\([i + 2, f]\)] = "V", 
              p[\([f]\)] = False];]; 
If[TrueQ[expresion], 
            tabla[\([i + 2, 
                  n + 1]\)] = "V"];]; 
Print["La tabla de verdad es: "]; 
Print[
          TableForm[
            tabla]]; 
cadena = ""; 
cadena2 = ""; 
cad = ""; 
cad2 = ""; 
contradiccion = 
          True; 
tautologia = True; 
For[
          i = 0, i < 2^n, \(i++\), 
          j = i; 
cad = ""; 
cad2 = ""; 
For[f = n, f > 0, \(f--\), 
            resto = Mod[j, 2]; 
j = 
              Floor[j/2]; 
If[resto == 0, 
              p[\([f]\)] = True; 
If[f == n, 
                cad = StringJoin["p", ToString[f], cad], 
                cad = StringJoin["p", ToString[f], " ∧ ", 
                    cad]]; 
If[f == n, 
                cad2 = StringJoin["(~p", ToString[f], ")", cad2], 
                cad2 = StringJoin["(~p", 
                    ToString[f], ")", " ∨ ", cad2]];, 
              p[\([f]\)] = False; 
If[f == n, 
                cad = StringJoin["(~p", ToString[f], ")", cad], 
                cad = StringJoin["(~p", 
                    ToString[f], ")", " ∧ ", 
                    cad]]; 
If[f == n, 
                cad2 = StringJoin["p", ToString[f], cad2], 
                cad2 = StringJoin["p", ToString[f], " ∨ ", 
                    cad2]];];]; 
If[TrueQ[expresion], 
            If[cadena == "", 
              cadena = StringJoin[cadena, "(", cad, ")"], 
              cadena = 
                StringJoin[cadena, " ∨ (", 
                  cad, ")"]]; 
contradiccion = False;, 
            If[cadena2 == "", 
              cadena2 = StringJoin[cadena2, "(", cad2, ")"], 
              cadena2 = 
                StringJoin[cadena2, " ∧ (", 
                  cad2, ")"]]; 
tautologia = 
              False;];]; 
If[contradiccion, 
          Print["Es una contradicción."], 
          Print["No es contradicción y la forma normal disyuntiva es: ", cadena]]; 
If[tautologia, 
          Print["Es una tautología."], 
          Print["No es tautología y la forma normal conjuntiva es: ", cadena2]]]\)

n = 3;
p = Table[False, {t, n}];
expresion := 
      Implies[Implies[p[[1]], p[[2]]], ! p[[3]]]
logica

3. Equivalencias lógicas e implicaciones lógicas

Ejemplo 6.5.

Comprobar que las siguientes formas enunciativas son equivalentes:
	a) (p → q)
	b) ((~q) → (~p))

Sii[a_, b_] := Implies[a, b] && Implies[b, a];
n = 2;
tautologia = True;
p = Table[False, {t, n}];
expresion := 
        Sii[Implies[p[[1]], p[[2]]], 
          Implies[! p[[2]], ! p[[1]]]];
For[i = 0, i < 2^n, i++, 
        j = i; 
For[f = n, f > 0, f--, 
          resto = Mod[j, 2]; 
j = 
            Floor[j/2]; 
If[resto == 0, 
            p[[f]] = True, p[[f]] = False];]; 
If[
          TrueQ[expresion], Null, tautologia = False];];
If[tautologia, 
      Print["La forma enunciativa es una tautología"], 
      Print["La forma enunciativa no es una tautología"]]

Por tanto, la forma enunciativa ((p → q) ↔ ((~ q) → (~ p))) es una tautología de lo que deducimos que (p → q) es lógicamente equivalente a ((~ q) → (~ p)).

4. Argumentaciones válidas

Ejemplo 6.6.

Estudiar la validez o invalidez de la siguiente argumentación:
((p ⋀ q) → r), q ; ∴ (p → r)

Sólo tenemos que ver si la forma enunciativa (((p⋀q)→r)⋀q)->(p→r) es una tautología

n = 3;
tautologia = True;
p = Table[False, {t, n}];
expresion := 
        Implies[Implies[p[[1]] && p[[2]], p[[3]]] && p[[2]], 
          Implies[p[[1]], p[[3]]]];
For[i = 0, 
        i < 2^n, i++, 
j = i; 
For[
          f = n, f > 0, f--, 
resto = 
            Mod[j, 2]; 
j = 
            Floor[j/2]; 
If[resto == 0, 
            p[[f]] = True, 
            p[[f]] = False];
]; 
If[
          TrueQ[expresion], Null, 
          tautologia = False];
];
If[tautologia, 
      Print["La forma enunciativa es una tautología"], 
      Print["La forma enunciativa no es una tautología"]]

Por tanto, la forma argumentativa es válida.

Ejemplo 6.7.

Cierta empresa necesita incrementar su plantilla con un nuevo miembro que pueda programar en Mathematica o que sepa programación. Además si sabe programación entonces puede programar en Mathematica. ¿Podemos deducir de lo anterior que dicha empresa necesita una persona que sepa utilizar el programa Mathematica?

En realidad, este enunciado se puede estudiar a través de una argumentación con premisas (Subscript[A, 1]): p ⋁ q, (Subscript[A, 2]): q → p y conclusión A: p. La respuesta a la pregunta planteada será afirmativa si la argumentación es valida y en otro caso será negativa.

n = 2;
tautologia = True;
p = Table[False, {t, n}];
expresion := 
        Implies[(p[[1]] || p[[2]]) && 
            Implies[p[[2]], p[[1]]], p[[1]]];
For[i = 0, i < 2^n, i++, 
        j = i; 
For[f = n, f > 0, f--, 
          resto = Mod[j, 2]; 
j = 
            Floor[j/2]; 
If[resto == 0, 
            p[[f]] = True, p[[f]] = False];]; 
If[
          TrueQ[expresion], Null, tautologia = False];];
If[tautologia, 
      Print["La forma enunciativa es una tautología"], 
      Print["La forma enunciativa no es una tautología"]]

Por tanto, la forma argumentativa es válida y efectivamente la empresa necesita una persona que sepa utilizar el programa Mathematica.