________________________________________________________________________________
Inhalt....: Elementare Logik mit MuPAD
Kategorie.: Handwerkskasten
Mathematik: Logik
MuPAD.....: 3.1.0
Datum.....: 2002-08-15
Autoren...: Kai Gehrs <acrowley@mupad.de>
Funktionen: |, not, and, or, simplify, logic, TRUE, FALSE, for, print
________________________________________________________________________________
Elementare MuPAD-Funktionen:
Elementare Logik mit MuPAD
In diesem Notebook stellen wir vor, wie man mit MuPAD elementare aussagenlogische Formeln
darstellen und auswerten bzw. vereinfachen kann.
Die aussagenlogischen Verknüpfungen wie 'und', 'oder', 'ausschließendes oder',
'nicht' sowie 'Implikation' und 'Äquivalenz' sind auch in MuPAD vorhanden.
Folgende Tabelle gibt einen kurzen Überblick über diese Verknüpfungen und
erklärt gleichzeitig, wie sie in MuPAD benutzt werden sollten. Es seien a und b
stets freie (d.h. nicht mit boolschen Werten belegte) Variablen.
---------------------------------------------------------------------------------------------------------------
logische Verknüpfung Bedeutung
---------------------------------------------------------------------------------------------------------------
a and b a und b (Konjunktion)
a or b a oder b (Disjunktion)
not a nicht a (Negation)
a ==> b aus a folgt b (Implikation)
a <=> b a ist äquivalent zu b (Äquivalenz)
a xor b entweder a oder b (Kontrajunktion)
----------------------------------------------------------------------------------------------------------------
Zu jeder der obigen logischen Operationen gibt es auch eine sogenannte
"funktionale Variante", d.h. statt a and b können wir auch _and( a, b ) schreiben.
Da diese Variante nicht unbedingt die intuitivere ist, verzichten wir hier auf eine
zusätzliche Beschreibung der funktionalen Varianten der logischen Operationen
und verweisen stattdessen auf die entsprechenden Hilfeseiten von and, or, xor,
not, ==> und <=>.
Wir definieren uns einige logische Ausdrücke:
A1:= a and b
A2:= a or b
A3:= a and (not b)
A4:= ((not a) or b) and (not b)
A5:= a ==> ((not a) or b)
A6:= a <=> ((not b) or c)
A7:= a xor (not b)
Jetzt können wir diese untereinander wieder beliebig miteinander verknüpfen:
((not A1) and A2) or (A3 xor A6) ==> (not A7)
Eine wichtige Funktion zur Vereinfachung von logischen Ausdrücken ist die
Funktion simplify mit der Zusatzoption logic. Möchte man mit simplify logische
Ausdrücke vereinfachen, so erhält die Funktion stets zwei Argumente:
1. Argument: A, ein logischer Ausdruck, der vereinfacht werden soll
2. Argument: logic, eine Zusatzoption für simplify zur Vereinfachung von A
Ein Aufruf der Funktion ist also in unserem Kontext immer von der Form
simplify( A, logic).
Rückgabewert ist eine vereinfachte Version des logischen Ausdruck A, falls
dieser vereinfacht werden kann, und A selbst, falls A nicht vereinfacht werden
konnte.
Wir betrachten einige Beispiele
A:= (not b) and ((not a) or b)
simplify(A4, logic)
A:= (a and (not b)) or (c or (not(a and b)))
simplify(A, logic)
A:= (a and (not b)) or (c or (not(a and b)) or
(not (a or (not b))))
simplify(A, logic)
Formeln, die von vorneherein wahr oder falsch sind, müssen unter
Umständen, wenn sie nicht zu kompliziert sind, erst gar nicht vereinfacht
werden. MuPAD tut dies von selbst:
A:= (a or b) or ((not a) or b)
A:= (a and (not b)) and (a and b)
Mit Hilfe des Operators | können wir die Werte TRUE (wahr) oder
FALSE (falsch) für freie Variablen in eine boolsche Formel einsetzen. Dabei
ist die Verwendung in diesem Kontext ganz analog zur Verwendung
von | in anderen Zusammenhängen.
Der Aufruf erfolgt in der Form A | a = TRUE bzw. A | (a = TRUE, b = FALSE)
bei mehreren zu ersetzenden Variablen. A ist hierbei ein logischer Ausdruck,
a und b sind boolsche Variablen.
Mit dem Aufruf logischer Ausdruck | boolsche Variable = Wert erreichen
wir also, dass in dem logischen Ausdruck die boolsche Variable durch den
entsprechenden Wert ersetzt wird.
Auch hierzu einige kleine Beispiele:
A:= (a and (not b)) or (c or (not(a and b)) or
(not (a or (not b))))
A | a = TRUE
A | (a = TRUE, b = TRUE)
A | (a = TRUE, b = TRUE, c = TRUE)
A | (a = TRUE, b = TRUE, c = FALSE)
A | (a = TRUE, b = FALSE)
A | a = FALSE
Wir können mit Hilfe von MuPAD auch die Werte von Wahrheitstabellen für
logische Formeln bestimmen. Wir setzen einfach alle möglichen Werte
für alle vorkommenden Variablen ein und bestimmen, ob das Ergebnis
wahr oder falsch ist.
Wir betrachten die logische Formel
A:= (a and (not b)) or (c or (not(a and b)) or
(not (a or (not b))))
Alle möglichen Belegungen der Variablen mit den entsprechenden Werten
für die logische Formel A erhalten wir wie folgt:
for k in {TRUE, FALSE} do
for l in {TRUE, FALSE} do
for m in {TRUE, FALSE} do
print(k, l, m, (A | (a = k, b = l, c = m)));
end_for:
end_for:
end_for:
TRUE, TRUE, TRUE, TRUE
TRUE, TRUE, FALSE, FALSE
TRUE, FALSE, TRUE, TRUE
TRUE, FALSE, FALSE, TRUE
FALSE, TRUE, TRUE, TRUE
FALSE, TRUE, FALSE, TRUE
FALSE, FALSE, TRUE, TRUE
FALSE, FALSE, FALSE, TRUE
In jeder Zeile sind die ersten drei logischen Werte die Werte, die für a, b
und c in die Formel A eingesetzt werden. Der vierte Wert ist immer genau
der Wert, den A bei den entsprechenden Werten für a, b und c annimmt.
_______________________________________________________________________________
Anmerkungen:
1. Weitere Anregungen finden Sie unter: http://schule.mupad.de bzw. http://studium.mupad.de
_______________________________________________________________________________