Boolesche Algebra - Motivation

Boolesche Algebra mit SetlX

Dieser Code prüft, ob eine Operation auf einer Menge kommutativ ist:

istKommutativ := procedure(set,operation) {
   if (forall(x in set, y in set | operation(x,y) == operation(y,x))) {
      return true;
   } else {
      print ("nicht kommutativ");
      return false;
   }
};

Man kann folgendermaßen Operationen definieren:

und := procedure(a,b) { return a && b; };
oder := procedure(a,b) { return a || b; };
nicht := procedure(a) { return ! a; };
ifThen := procedure(a,b) { return !a || b; };

und dann testen, ob diese bezüglich einer Menge kommutativ sind, z.B.:

istKommutativ({false,true},und);
istKommutativ({false,true},oder);

Vervollständigen Sie den folgenden Code, so dass auch Assoziativität, Distributivität und Absorption überprüft werden. Testen Sie, ob Ihr Code die Rechenregeln für und und oder richtig erkennt und für ifThen ausgibt, dass es nicht assoziativ, nicht absorptiv und nicht distributiv ist.

istKommutativ := procedure(set,operation) {
   if (forall(x in set, y in set | operation(x,y) == operation(y,x))) {
      return true;
   } else {
      print ("nicht kommutativ");
      return false;
   }
};

istAssoziativ := procedure(set,operation) {
};

istDistributiv := procedure(set,operation1,operation2) {
};

istAbsorptiv := procedure(set,operation1,operation2) {
};

Dieser Code prüft, ob eine Operation bezüglich einer Menge ein neutrales Element (oder Identität) enthält. (Ein neutrales Element verändert den Wert des anderen Operanden nicht. Zum Beispiel ist 0 das neutrale Element der Addition, da x + 0 = x gilt.)

hatIdentitaet := procedure(set,operation,element) {
   if (forall(x in set | operation(x,element) == x)) {
      return true;
   } else {
      print ("keine Identitaet",set,operation,element);
      return false;
   }
};

Man kann den Code so einsetzen:

hatIdentitaet({false,true},oder,false);
hatIdentitaet({false,true},und,true);

Vervollständigen Sie den Code um einen Test für komplementäre (oder negierte) Elemente, der überprüft, dass x + ¬ x = 1 und x · ¬ x = 0. Testen Sie, ob Ihr Code die Komplemente für und und oder richtig erkennt und für ifThen mit nicht ausgibt, dass es keine Komplemente sind.

hatIdentitaet := procedure(set,operation,element) {
   if (forall(x in set | operation(x,element) == x)) {
      return true;
   } else {
      print ("keine Identitaet",set,operation,element);
      return false;
   }
};

hatKomplement := procedure(set,operation,unary_operation,element) {
};

Eine Boolesche Algebra kann jetzt so definiert werden:

istBooleanAlgebra:= procedure(set,eins,null,operat1,operat2,unary_operat){
    return eins in set && null in set &&
     istKommutativ(set,operat1) &&
     istKommutativ(set,operat2) &&
     istAssoziativ(set,operat1) &&
     istAssoziativ(set,operat2) &&
     istDistributiv(set,operat2,operat1) &&
     istDistributiv(set,operat1,operat2) &&
     istAbsorptiv(set,operat2,operat1) &&
     istAbsorptiv(set,operat1,operat2) &&
     hatIdentitaet(set,operat1,null) &&
     hatIdentitaet(set,operat2,eins) &&
     hatKomplement(set,operat1,unary_operat,eins) &&
     hatKomplement(set,operat2,unary_operat,null);
};

Überprüfen Sie, dass die Menge {true,false} mit den Operationen und, oder, nicht tatsächlich eine Boolesche Algebra ist.