boologic 0.3.5

This is a basic library for implementing boolean propositional logic.

Boologic

A lightweight Python library for working with boolean propositional logic expressions.

Boologic allows you to construct logical expressions either:

• explicitly with classes
• implicitly using Python operators

Expressions are rendered using proper logical symbols:

¬  ∧  ∨  →  ↔

---

Features

• Clean symbolic boolean logic expressions
• Python operator overloading
• Explicit class-based API
• Unicode pretty-printing
• Mix-and-match syntax support
• Built-in logical constants

---

Installation

pip install boologic

uv add boologic

---

Quick Start

Create Variables

Use the Var class to create propositional variables:

from boologic import Var

A = Var("A")
B = Var("B")

---

Building Expressions

Operator Syntax (Recommended)

expr = (A & B) >> ~A
print(expr)

Output:

(A ∧ B) → ¬A

Explicit Class Syntax

from boologic import And, Implies, Not

expr = Implies(And(A, B), Not(A))
print(expr)

Output:

(A ∧ B) → ¬A

Mixed Syntax

Both styles can be combined safely:

from boologic import Implies

expr = Implies(A & B, ~A)

---

Supported Operators

Logic	Python Operator	Symbol
NOT	~A	¬A
AND	A & B	A ∧ B
OR	A | B	A ∨ B
IMPLIES	A >> B	A → B
BICONDITIONAL	A ^ B	A ↔ B

---

Constants

Boologic uses its own Const class instead of Python's built-in True and False.

Example

from boologic import Const

expr = Const(True) | A

This is interpreted internally as:

Or(Const(True), A)

---

Important: Operator Precedence

Python's operator precedence rules do not match standard logical precedence.

Always use parentheses () to ensure expressions are evaluated correctly.

Recommended

expr = (A & B) >> C

Avoid

expr = A & B >> C

The second example may not behave as expected.

---

Binary Operator Design

All binary operators are primarily designed around handling two operands at a time.

For clarity and correctness, always prefer explicit grouping:

(A & B) & C

instead of:

A & B & C

---

Example Expressions

Negation

~A

Output:

¬A

Conjunction

A & B

Output:

A ∧ B

Disjunction

A | B

Output:

A ∨ B

Implication

A >> B

Output:

A → B

Biconditional

A ^ B

Output:

A ↔ B

---

Recommended Style

For best readability:

• use parentheses generously
• prefer operator syntax for concise expressions
• use explicit classes for complex/generated expressions

---

Full Example

from boologic import Const, Var

A = Var("A")
B = Var("B")
C = Var("C")

expr = ((A & B) >> C) | ~Const(False)

print(expr)

Output:

((A ∧ B) → C) ∨ ¬False

---

License

MIT License