Distribute boolean logic expression

Question

What I have :

(A.B.C) + (D.E) + (F.G.H.I)

What I want using distributive law :

(A + D + F).(A + D + G).(A + D + H).(A + D + I).
(A + E + F).(A + E + G).(A + E + H).(A + E + I).
(B + D + F).(B + D + G).(B + D + H).(B + D + I).
(B + E + F).(B + E + G).(B + E + H).(B + E + I).
(C + D + F).(C + D + G).(C + D + H).(C + D + I).
(C + E + F).(C + E + G).(C + E + H).(C + E + I)

Both expressions are equivalent. I used distributive law to get the second one : A + (B . C) ⇔ (A + B) . (A + C)

The expression can be bigger but is always compose of groups of AND separated by OR. What I'm looking for is a library that would be able to distribute logical expressions. A library like Sympy but applied to logic instead of algebra.

Answer 1

Sympy is the perfect choice for this, just take a look to the logic module, in particular, Equivalent and to_cnf functions, example below:

from sympy import *

A, B, C, D, E, F, G, H, I = symbols('A,B,C,D,E,F,G,H,I')

formula = (
    (A & B & C) | (D & E) | (F & G & H & I)
)
formula2 = (
    (A | D | F) & (A | D | G) & (A | D | H) & (A | D | I) &
    (A | E | F) & (A | E | G) & (A | E | H) & (A | E | I) &
    (B | D | F) & (B | D | G) & (B | D | H) & (B | D | I) &
    (B | E | F) & (B | E | G) & (B | E | H) & (B | E | I) &
    (C | D | F) & (C | D | G) & (C | D | H) & (C | D | I) &
    (C | E | F) & (C | E | G) & (C | E | H) & (C | E | I)
)

print(to_cnf(formula))
print(Equivalent(to_cnf(formula), formula2))

Result:

(A | D | F) & (A | D | G) & (A | D | H) & (A | D | I) & (A | E | F) & (A | E | G) & (A | E | H) & (A | E | I) & (B | D | F) & (B | D | G) & (B | D | H) & (B | D | I) & (B | E | F) & (B | E | G) & (B | E | H) & (B | E | I) & (C | D | F) & (C | D | G) & (C | D | H) & (C | D | I) & (C | E | F) & (C | E | G) & (C | E | H) & (C | E | I)
True

Answer 2

Looks like you can do that with the package boolean.py (install it from Pip with pip install boolean.py):

from boolean import BooleanAlgebra

exp1 = algebra.parse("(A*B*C) + (D*E) + (F*G*H*I)")
# Convert to conjunctive normal form (CNF)
exp2 = algebra.cnf(exp1)
print(exp2.pretty())

Output:

AND(
  OR(
    Symbol('A'),
    Symbol('D'),
    Symbol('F')
  ),
  OR(
    Symbol('A'),
    Symbol('D'),
    Symbol('G')
  ),
  OR(
    Symbol('A'),
    Symbol('D'),
    Symbol('H')
  ),
  OR(
    Symbol('A'),
    Symbol('D'),
    Symbol('I')
  ),
  OR(
    Symbol('A'),
    Symbol('E'),
    Symbol('F')
  ),
  OR(
    Symbol('A'),
    Symbol('E'),
    Symbol('G')
  ),
  OR(
    Symbol('A'),
    Symbol('E'),
    Symbol('H')
  ),
  OR(
    Symbol('A'),
    Symbol('E'),
    Symbol('I')
  ),
  OR(
    Symbol('B'),
    Symbol('D'),
    Symbol('F')
  ),
  OR(
    Symbol('B'),
    Symbol('D'),
    Symbol('G')
  ),
  OR(
    Symbol('B'),
    Symbol('D'),
    Symbol('H')
  ),
  OR(
    Symbol('B'),
    Symbol('D'),
    Symbol('I')
  ),
  OR(
    Symbol('B'),
    Symbol('E'),
    Symbol('F')
  ),
  OR(
    Symbol('B'),
    Symbol('E'),
    Symbol('G')
  ),
  OR(
    Symbol('B'),
    Symbol('E'),
    Symbol('H')
  ),
  OR(
    Symbol('B'),
    Symbol('E'),
    Symbol('I')
  ),
  OR(
    Symbol('C'),
    Symbol('D'),
    Symbol('F')
  ),
  OR(
    Symbol('C'),
    Symbol('D'),
    Symbol('G')
  ),
  OR(
    Symbol('C'),
    Symbol('D'),
    Symbol('H')
  ),
  OR(
    Symbol('C'),
    Symbol('D'),
    Symbol('I')
  ),
  OR(
    Symbol('C'),
    Symbol('E'),
    Symbol('F')
  ),
  OR(
    Symbol('C'),
    Symbol('E'),
    Symbol('G')
  ),
  OR(
    Symbol('C'),
    Symbol('E'),
    Symbol('H')
  ),
  OR(
    Symbol('C'),
    Symbol('E'),
    Symbol('I')
  )
)