LogicalExpand

[<Charivari@XXXXXXX.de>]

Hallo Zusammen,

eigentlich wollte ich nur eine simple logische Umformung machen, 
dabei sind bei mir folgende Probleme aufgetaucht:

(* i) Logik & Mathematica 2.2 *)

(* Definitionen von Wahrheitswerten *)
p1 = True;
p2 = False;
p3 = True;
p4 = False;
p5 = True;
p6 = False;

(* Definitionen von Kombinatorischen Regeln *)
logexp1 = p1 && p2 && p3;
logexp2 = p1 && p3 && p5;
logexp3 = (p1 && p3) ¦¦ (p2 && p4);
logexp4 = (p1 ¦¦ p2) && (p3 ¦¦ p4);

(* Ok fokusiert ... auf Teile ...*)
logexp13and = (p1 && p3); 
logexp24and =  (p2 && p4);
logexp12or = (p1 ¦¦ p2); 
logexp34or = (p3 ¦¦ p4);

(* Logische Verarbeitung & Erwartungen *)
{{LogicalExpand[logexp1], False (* Erwartung: T && F => F *)},
{LogicalExpand[logexp2], True (* Erwartung: T && T && T => T *)},
{LogicalExpand[logexp3], True (* Erwartung: T || irgendwas => T *)},
{LogicalExpand[logexp4], True (* Erwartung: T && T  => T *)},
{LogicalExpand[logexp13and], True (* Erwartung: T && T  => T *)},
{LogicalExpand[logexp24and], False (* Erwartung: F && F => F *)},
{LogicalExpand[logexp12or], True (* Erwartung: T && T => T*)},   (* Or-BUG *)
{LogicalExpand[logexp34or], False (* Erwartung: F || F => F *)} }  //TableForm

False           False

True            True

¦¦ False True   True

¦¦ False True   True

True            True

False           False

¦¦ False True   True

¦¦ False True   False


Warum liefert LogicalExpand so komische Ergebnisse beim "nicht-symbolsichen" Rechnen? 

(* ii) Logik & Mathematica 2.2 symbolische Manipulation *)

(* Definitionen von Wahrheitswerten *)

ClearAll[p1,p2,p3,p4,p5,p6]

sub1 = {p1->True,p2->False,p3->True,p4->False,p5->True,p6->False}

(* Definitionen von Kombinatorischen Regeln *)

ClearAll[logexp1,logexp2,logexp3,logexp4,logexp13and, logexp24and, logexp12or, logexp34or]

logexp1 = p1 && p2 && p3;
logexp2 = p1 && p3 && p5;
logexp3 = (p1 && p3) ¦¦ (p2 && p4);
logexp4 = (p1 ¦¦ p2) && (p3 ¦¦ p4);
(* Ok fokusieren wir uns auf kleinere Einheiten...*)
logexp13and = (p1 && p3); 
logexp24and =  (p2 && p4);
logexp12or = (p1 ¦¦ p2); 
logexp34or = (p3 ¦¦ p4);

{p1 -> True, p2 -> False, p3 -> True, p4 -> False, 
  p5 -> True, p6 -> False}

{{LogicalExpand[logexp1], False (* Erwartung: T && F => F *)},
{LogicalExpand[logexp2], True (* Erwartung: T && T && T => T *)},
{LogicalExpand[logexp3], True (* Erwartung: T || irgendwas => T *)},
{LogicalExpand[logexp4], True (* Erwartung: T && T  => T *)},
{LogicalExpand[logexp13and], True (* Erwartung: T && T  => T *)},
{LogicalExpand[logexp24and], False (* Erwartung: F && F => F *)},
{LogicalExpand[logexp12or], True (* Erwartung: T && T => T*)},   (* Or-BUG *)
{LogicalExpand[logexp34or], False (* Erwartung: F || F => F *)} } //TableForm 

p1 && p2 && p3             False

p1 && p3 && p5             True

¦¦ (p1 && p3) (p2 && p4)   True

¦¦ p1 p2 && ¦¦ p3 p4       True

p1 && p3                   True

p2 && p4                   False

¦¦ p1 p2                   True

¦¦ p3 p4                   False

% /.sub1 //TableForm

False                            False

True                             True

¦¦ False True                    True

¦¦ False True && ¦¦ False True   True

True                             True

False                            False

¦¦ False True                    True

¦¦ False True                    False

Warum?
 
Gibt es irgendwo eine Quelle, wie man sich stabile do-it-yourself Logik-Operatoren baut?
So eine Art Vorgehensmodell?

Merci für eure Hilfe,

Chari
______________________________________________________________________________
Wo gibt es den besten Spam-Schutz? Computerbild 15-03 sagt bei
WEB.DE FreeMail - Deutschlands beste E-Mail - http://s.web.de/?mc=021123