boofun.core.representations.circuit

Circuit representation for Boolean functions.

This module implements Boolean circuits using basic gates (AND, OR, NOT) for representing and evaluating Boolean functions efficiently.

Functions

build_majority_circuit(n_vars)	Build optimized majority circuit.
build_parity_circuit(n_vars)	Build parity circuit using XOR gates.

Classes

BooleanCircuit(n_inputs)	Boolean circuit representation using gates and wires.
CircuitRepresentation()	Circuit representation for Boolean functions.
Gate(gate_id, gate_type, inputs[, output_wire])	Represents a single gate in a Boolean circuit.
GateType(value)	Types of Boolean gates.

class boofun.core.representations.circuit.GateType(value)

Types of Boolean gates.

INPUT = 'INPUT'

AND = 'AND'

OR = 'OR'

NOT = 'NOT'

XOR = 'XOR'

NAND = 'NAND'

NOR = 'NOR'

class boofun.core.representations.circuit.Gate(gate_id: int, gate_type: GateType, inputs: List[int], output_wire: int | None = None)

Represents a single gate in a Boolean circuit.

gate_id

Unique identifier for the gate

Type:

int

gate_type

Type of gate (AND, OR, NOT, etc.)

Type:

boofun.core.representations.circuit.GateType

inputs

List of input gate IDs

Type:

List[int]

output_wire

Wire ID for output (optional)

Type:

int | None

gate_id: int

gate_type: GateType

inputs: List[int]

output_wire: int | None = None

evaluate(input_values: Dict[int, bool]) → bool

Evaluate gate with given input values.

Parameters:

input_values – Mapping from gate/wire IDs to boolean values

Returns:

Gate output value

__init__(gate_id: int, gate_type: GateType, inputs: List[int], output_wire: int | None = None) → None

class boofun.core.representations.circuit.BooleanCircuit(n_inputs: int)

Boolean circuit representation using gates and wires.

Supports construction, evaluation, and optimization of Boolean circuits with standard gates (AND, OR, NOT, XOR, NAND, NOR).

__init__(n_inputs: int)

Initialize Boolean circuit.

Parameters:

n_inputs – Number of input variables

gates: Dict[int, Gate]

input_gates: List[int]

output_gate: int | None

add_gate(gate_type: GateType, inputs: List[int]) → int

Add gate to circuit.

Parameters:

• gate_type – Type of gate to add

• inputs – List of input gate IDs

Returns:

ID of newly created gate

set_output(gate_id: int) → None

Set output gate of the circuit.

evaluate(inputs: List[bool] | ndarray) → bool

Evaluate circuit with given inputs.

Parameters:

inputs – Boolean input values

Returns:

Circuit output value

get_depth() → int

Calculate circuit depth (longest path from input to output).

Returns:

Circuit depth

get_size() → int

Get total number of gates (excluding inputs).

to_dict() → Dict[str, Any]

Export circuit to dictionary format.

Returns:

Dictionary representation of circuit

classmethod from_dict(data: Dict[str, Any]) → BooleanCircuit

Create circuit from dictionary representation.

Parameters:

data – Dictionary representation

Returns:

BooleanCircuit instance

class boofun.core.representations.circuit.CircuitRepresentation

Circuit representation for Boolean functions.

evaluate(inputs: ndarray, data: BooleanCircuit, space: Space, n_vars: int) → bool | ndarray

Evaluate circuit representation.

Parameters:

• inputs – Input values (integer indices or binary vectors)

• data – Boolean circuit

• space – Evaluation space

• n_vars – Number of variables

Returns:

Boolean result(s)

dump(data: BooleanCircuit, space=None, **kwargs) → Dict[str, Any]

Export circuit representation.

convert_from(source_repr: BooleanFunctionRepresentation, source_data: Any, space: Space, n_vars: int, **kwargs) → BooleanCircuit

Convert from another representation to circuit.

Uses a simple DNF (Disjunctive Normal Form) construction approach.

convert_to(target_repr: BooleanFunctionRepresentation, source_data: Any, space: Space, n_vars: int, **kwargs) → ndarray

Convert circuit to another representation.

create_empty(n_vars: int, **kwargs) → BooleanCircuit

Create empty circuit (constant False).

is_complete(data: BooleanCircuit) → bool

Check if circuit is complete (has output gate).

time_complexity_rank(n_vars: int) → Dict[str, int]

Return time complexity for circuit operations.

get_storage_requirements(n_vars: int) → Dict[str, int]

Return storage requirements for circuit representation.

optimize_circuit(circuit: BooleanCircuit) → BooleanCircuit

Apply basic circuit optimizations.

Parameters:

circuit – Circuit to optimize

Returns:

Optimized circuit

boofun.core.representations.circuit.build_majority_circuit(n_vars: int) → BooleanCircuit

Build optimized majority circuit.

Parameters:

n_vars – Number of variables

Returns:

Circuit implementing majority function

boofun.core.representations.circuit.build_parity_circuit(n_vars: int) → BooleanCircuit

Build parity circuit using XOR gates.

Parameters:

n_vars – Number of variables

Returns:

Circuit implementing parity function