Wahrheiswerttabellen per "Knopfdruck" • Tableaux de vérité "en pressant le bouton"

mit • avec   Mathematica

Generierung von Wahrheitswerttabellen für die Variablen 
• Générer des tableaux de vérité pour les variables

Säubern • Nettoyer

Remove["Global`@*"];
Remove["Global`*"]

Programm • Programme

tabb[1] = {{0}, {1}};
tabb[n_] := 
        Flatten[Table[
            Append[tabb[n - 1][[k]], w], {k, 1, 
              Length[tabb[n - 1]]}, {w, 0, 1}], 
          1];
tabZ[n_] :=  tabb[n] /. {0 -> False, 1 -> True}

Testen • Tester

{tabb[2] // MatrixForm, tabZ[2] // MatrixForm}

{tabb[3] // MatrixForm, tabZ[3] // MatrixForm}

Wahrheitsfunktionen definieren 
• Définir des fonctions de vérité

Darstellung des Outputs • Représentation de l'output

asUsual[f_] := 
      StringReplace[
        ToString[
          TraditionalForm[f]], {"!" -> "¬"}]

Eine Funktion • Une fonction

Ein erster Versuch • Premier essai

Definieren • Définir

f[x_, y_, z_] :=  ¬ Or[And[Not[x], y], z];

Output • Output

f[a, b, c] // asUsual

Subjunktion neu • Encore la subjonction

Definieren • Définir

sub[x_, y_] := Or[Not[x], y]; Attributes[sub] = {Listable};

Testen, Vergleich • Tester, comparer

sub[! a || ! b, ! (x1 || x2)]

sub[! a || ! b, ! (x1 || x2)] // LogicalExpand

Implies[ Or[Not[a], Not[b]], Not[Or[x1, x2]]]

Implies[ Or[Not[a], Not[b]], Not[Or[x1, x2]]] // 
      LogicalExpand

f00[a_, b_] := 
        And[sub[Not[Or[a, b]],   Or[Not[a], 
              Not[b]]], 
sub[ Or[Not[a], Not[b]], 
            Not[Or[a, b]]]];

f00[x, y] // asUsual

Bijunktion  • Bijonction

Definieren • Définir

bij[x_, y_] := And[sub[x, y], sub[y, x]]; 
    Attributes[bij] = {Listable};

Testen • Tester

bij[x, y] // asUsual

exOr • exOr

exOr[x_, y_] := ! bij[x, y];
Attributes[exOr] = {Listable};
exOr[x, y] // asUsual

Programms für beliebig Wahrheitsfunktionen 
• Programme pour des fonctions de vérité quelconques

Programm • Programme

Entwicklungsphase  • Phase de développement

Programm als Test-Module • Programme comme Module pour tester

\(WtabTest[f_, tabX_] := 
      Module[{res, newtabX, u, exttabX, output1, 
          output2}, \ 
Attributes[f] = {Listable}; 
        res = Table[
            Apply[f, tabX[\([n]\)]], {n, 1, 
              Length[tabX]}]; 
Print["res = ", 
          res]; 
newtabX = 
          Transpose[tabX]; 
Print["newtabX = ", 
          newtabX]; 
u = 
          Length[newtabX]; 
Print["u = ", 
          u]; 
\ \ \ \ exttabX = 
          Transpose[
            Append[newtabX, 
              res]]; 
Print[" exttabX = ", \ 
          exttabX]; 
\ \ \ \ output1 = 
          Prepend[exttabX, Append[Range[u], {expr}]] // 
            MatrixForm; 
Print["  output1 = ", \ 
          output1]; 
output2 = 
          Prepend[exttabX, Append[Range[u], {expr}]] /. {True -> 1, 
                False -> 0} // MatrixForm]\)

Test mit einer Funktion  • Test avec une fonction

Eine Funktion • Une fonction

f[x_, y_, z_] :=  ¬ Or[And[Not[x], y], z];
f[a, b, c] // asUsual

Test • Tester

WtabTest[f, tabZ[3]]

Fertiges Programm • Programme complet

Programm • Programme

\(Wtab[f_, m_] := 
      Module[{tabb, tabZ, res, newtabX, u, exttabX, output, 
          output1}, \ 
Attributes[
            f] = {Listable}; 
tabb[
            1] = {{0}, {1}}; 
tabb[u_] := 
          Flatten[Table[
              Append[\(tabb[u - 1]\)[\([k]\)], w], {k, 1, 
                Length[tabb[u - 1]]}, {w, 0, 1}], 1]; 
        tabZ[u_] := \ tabb[u] /. {0 -> False, 1 -> True}; 
        res = Table[Apply[f, \(tabZ[m]\)[\([n]\)]], {n, 1, Length[tabZ[m]]}]; 
        newtabX = Transpose[tabZ[m]]; 
u = 
          Length[newtabX]; 
\ \ \ \ \ exttabX = 
          Transpose[
            Append[newtabX, res]]; 
\ \ \ \ \ Prepend[exttabX, 
              Append[Range[u], {expr}]] /. {True -> 1, False -> 0} // 
          MatrixForm]\)

Test • Tester

Wtab[f, 3]

Programm anwenden • Appliquer le programme

Ueb. • Ex. 1

Funktionen • Fonctions

f1a[x1_, x2_] := Not[Or[x1, x2]];
f1b[x1_, x2_] := Or[Not[x1], Not[x2]];

Exkluxiv oder
• ou exclusive

f[x_, y_] := exOr[x, y];
Wtab[f, 2]

Anwenden:Vergleich von Wahrheitstabellen
• Appliquer:Comparaison de tableaux de vétité

Ueb. • Ex. 2

a

Funktion • Fonction

f2a[a_, b_] := 
        bij[Not[Or[a, b]], And[Not[a], Not[b]]];
f2a[a, b]  // asUsual

Anwenden • Appliquer

Wtab[f2a, 2]

b

Funktion • Fonction

f2b[a_, b_, c_] := 
        bij[Not[Or[sub[a, b], c]], 
          And[Not[sub[a, c]], Not[b]]];
f2b[a, b, c]  // asUsual

Anwenden • Appliquer

Wtab[f2b, 3]

c

Funktion • Fonction

f2c[a_, b_] := sub[And[a, b], a];
f2c[a, b]  // asUsual

Anwenden • Appliquer

Wtab[f2c, 2]

d

Funktion • Fonction

f2d[a_, b_] := 
        sub[sub[sub[a, b], a], a];
Wtab[f2d, 2]

Ueb. • Ex. 3

Kurz • Bref

a

Clear[s];
s[a_, b_] := sub[And[sub[a, Not[b]], b], Not[a]];
Wtab[s,     2    ]

{s[a, b]  //  asUsual ,  s[a, b]  //  LogicalExpand}

b

Clear[s];
s[a_, b_] := sub[Or[bij[a, Not[b]], b], Not[a]];
Wtab[s,     2    ]

s[a, b]  //  asUsual

s[a, b]  //  LogicalExpand  //  asUsual

Ueb. • Ex. 4

Ein grösserer Ausdruck • Une expression plus grande

Clear[s]; 
s[a_, b_, c_, 
          d_] := 
! (sub[
bij[
                sub[a  &&  b  ||  c, 
                  a], 
! (a  ||  
                          c  &&  b  ||  ! c  ||  d)  &&  
                    b  &&  ! c  ||  b], 
b  &&  
                sub[a  &&  b  &&  c,  
                  a  ||  ! b  &&  
                      sub[c  &&  d, a]]]);
Wtab[s,    4     ]

s[a, b, c, d]  // LogicalExpand  //  
      asUsual