Das deutsche Python-Forum

Gibt es eigentlich ein Python modul mit dem man boolesche Terme auflösen kann? Also ich meine die mit + und * als operandenund idempotenzgesetz distributiv assioziativ und de morgan und sowas. Ich hab bis jetzt nur Losungen zu Gleichungen gesehen bei denen nur eine Zahl raus kam

@INFACT: Was meinst Du mit "auflösen"? Kannst Du Beispiele geben? Was soll das Modul können?

Wenn man jetzt so einen Term hat ( ich nehm jetzt einfach - für nich bzw quer ) a*(a+b) gespr a geschniiten mit ( à vereinigt b) da kommt ja à raus , wegen diesem abspOrptionsgesetz. Ich mochte jetzt dass ein Programm aus einem langen Term einen kurzen macht

tut mir leid wegen der rechtschreibgehler ich bin am ipod

Man kann natürlich programmatisch logische Umformungen vornehmen, bei entsprechenden Datenstrukturen sind das schöne Übungen für Pattern Matching.

Nur führen solche Umformungen eben nicht zwangsläufig zu einer Reduktion des Terms.

lunar hat geschrieben:Man kann natürlich programmatisch logische Umformungen vornehmen, bei entsprechenden Datenstrukturen sind das schöne Übungen für Pattern Matching.

Gibt es denn schon sowas?

Aber eigentlich verkürzen alle gesetze den term ausser das distributivgesetz oder?

@INFACT: Natürlich reduzieren manche Gesetze den Term, nur ist das Resultat deswegen nicht zwangsläufig minimal, oder auch nur kurz.

Vielleicht ist das ja was für dich:
http://docs.sympy.org/tutorial.html#introduction

Damit kann ich Terme nach x oder y auflösen und bekomme dann ein ergebnis. Ich meinte eher vereinfachen. http://de.wikipedia.org/wiki/Boolesche_Algebra Beil Solchen Termen kommen keine Zahlen als ergebnis raus. Das ergebnis ist immer True oder False .

Ich denke SymPy ist hier schon der richtige Ansatz, da es sich dabei um ein Computer Algebra System handelt. Ob du nun "normale" Algebra mit reellen Zahlen oder boolesche Algebra mit {0,1} machst, ist nicht wirklich ein großer Unterschied. Wie einfach sich boolesche Algebra aus SymPy ableiten lässt kann ich dir aber nicht sagen. Dafür kenne ich mich mit SymPy zu wenig aus.

Grüße
Gerrit

Es scheint sich übrigens um Mengenalgebra zu handeln, denn bei Boolescher Algebra dachte ich zunächst nur an Wahr und Falsch, da machen Schnittmengen wenig Sinn.

@mkesper: Wer hat denn von Schnittmengen gesprochen?

Möglich (ich habe die Frage auch nicht verstanden

), aber in dem Fall wäre sympy u. U. auch eine Alternative.

lunar hat geschrieben:@mkesper: Wer hat denn von Schnittmengen gesprochen?

Der OP: a geschniiten mit ( à vereinigt b)
Vereinigungs- und Schnittmenge

Hier genau sowas will ich programmieren, leider braucht man dafür internet und der zeigt den source code nicht http://www.elektroniker-bu.de/boolesche.htm#ergebnis

Boolsche Algebra simplifizieren schreit nach Pattern Mattching. Hier ein Lösungsansatz in Scala -> http://paste.pocoo.org/show/207030/

Distributivgesetzt und Assoziativgesetz fehlen, denn da ist es kniffelig, nicht in eine Endlosrekursion zu fallen. Das Kommutativgesetz habe ich hingegen einfach in alle anderen Gesetze eingearbeitet.

Ich glaube, statt 0 und 1 hätte ich lieber true und false benutzen sollen. Es wäre in Scala auch möglich gewesen, & und | für `Node` überzudefinieren, aber so fand ich's einfacher.

Eine Python-Lösung wäre so ähnlich, allerdings kann man (ohne Zusatzbibliothek) das Pattern Matching nicht so elegant hinschreiben.

Was mich wunderte ist, dass Scala kein `And(x, x)` so verstand, wie es gemeint sein sollte. Ich musste mit einem `if` nachbessern.

Stefan

Wenn es sich um "wenige" Indexe handelt bietet sich ein Minimierungsverfahren an.

Aus einer Vorlesung, die ich besucht hatte. Siehe Minimierungsverfahren.

http://www-ihs.theoinf.tu-ilmenau.de/~s ... index.html

Oder man nimmt einfach sympy...

Code: Alles auswählen

>>> from sympy import *
>>> A = Symbol("A")
>>> B = Symbol("B")
>>> A & B
0: And(A, B)
>>> (A|B)&(A|B)
1: Or(A, B)

@HerrHagen: Wieso sollte man das geeignete Werkzeug benutzen? Ich bin sicher, es geht auch mit einem Hammer, äh regex!

HerrHagen hat geschrieben:Oder man nimmt einfach sympy...
Code: Alles auswählen
>>> from sympy import *
>>> A = Symbol("A")
>>> B = Symbol("B")
>>> A & B
0: And(A, B)
>>> (A|B)&(A|B)
1: Or(A, B)

Das vereinfacht die Terme aber nicht:

Code: Alles auswählen

>>> And(B, Or(A, B))
And(B, Or(A, B))
# Hier sollte jetzt B stehen (Absorptionsgesetz)

Oder gibt es da auch eine Funktion für?

Ich dachte, genau das wolltest Du selbst implementieren, oder?