compiled-knowledge 4.0.0a20__cp312-cp312-musllinux_1_2_x86_64.whl

ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.pyx

@@ -0,0 +1,98 @@
+from dataclasses import dataclass
+from typing import List, Dict, Sequence, Set
+
+from ck.circuit._circuit_cy cimport Circuit, OpNode, VarNode, CircuitNode, ConstNode
+from cython.operator cimport postincrement
+
+
+@dataclass
+class CircuitAnalysis:
+    """
+    A data structure representing the analysis of a function defined by
+    a circuit which chosen input variables and output result nodes.
+    """
+
+    var_nodes: Sequence[VarNode]  # specified input var nodes
+    result_nodes: Sequence[CircuitNode]  # specified result nodes
+    op_nodes: Sequence[OpNode]  # in-use op nodes, in computation order
+    const_nodes: Sequence[ConstNode]  # in_use const nodes, in arbitrary order
+    op_to_result: Dict[int, int]  # op nodes in the result, op_node = result[idx]: id(op_node) -> idx
+    op_to_tmp: Dict[int, int]  # op nodes needing tmp memory, using tmp[idx]: id(op_node) -> idx
+
+
+def analyze_circuit(
+        var_nodes: Sequence[VarNode],
+        result_nodes: Sequence[CircuitNode],
+) -> CircuitAnalysis:
+    """
+    Analyzes a circuit as a function from var_nodes to result_nodes,
+    returning a CircuitAnalysis object.
+
+    Args:
+        var_nodes: The chosen input variable nodes of the circuit.
+        result_nodes: The chosen output result nodes of the circuit.
+
+    Returns:
+        A CircuitAnalysis object.
+    """
+    cdef list[CircuitNode] results_list = list(result_nodes)
+
+    # What op nodes are in use
+    cdef list[OpNode] op_nodes = _reachable_op_nodes(results_list)
+
+    # What constant values are in use
+    cdef set[int] seen_const_nodes = set()
+    cdef list[ConstNode] const_nodes  = []
+
+    def _register_const(_node: ConstNode) -> None:
+        nonlocal seen_const_nodes
+        nonlocal const_nodes
+        _node_id: int = id(_node)
+        if _node_id not in seen_const_nodes:
+            const_nodes.append(_node)
+            seen_const_nodes.add(_node_id)
+
+    # Register all the used constants
+    for op_node in op_nodes:
+        for node in op_node.args:
+            if isinstance(node, ConstNode):
+                _register_const(node)
+    for node in results_list:
+        if isinstance(node, ConstNode):
+            _register_const(node)
+    for node in var_nodes:
+        if node.is_const():
+            _register_const(node.const)
+
+    # What op nodes are in the result.
+    # Dict op_to_result maps id(OpNode) to result index.
+    cdef dict[int, int] op_to_result = {
+        id(node): i
+        for i, node in enumerate(result_nodes)
+        if isinstance(node, OpNode)
+    }
+
+    # Assign all other op nodes to a tmp slot.
+    # Dict op_to_tmp maps id(OpNode) to tmp index.
+    cdef int tmp_idx = 0
+    op_to_tmp: Dict[int, int] = {
+        id(op_node): postincrement(tmp_idx)
+        for op_node in op_nodes
+        if id(op_node) not in op_to_result
+    }
+
+    return CircuitAnalysis(
+        var_nodes=var_nodes,
+        result_nodes=result_nodes,
+        op_nodes=op_nodes,
+        const_nodes=const_nodes,
+        op_to_result=op_to_result,
+        op_to_tmp=op_to_tmp,
+    )
+
+
+cdef list[OpNode] _reachable_op_nodes(list[CircuitNode] results):
+    if len(results) == 0:
+        return []
+    cdef Circuit circuit = results[0].circuit
+    return circuit.find_reachable_op_nodes(results)

ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_py.py

@@ -0,0 +1,93 @@
+from dataclasses import dataclass
+from itertools import count
+from typing import List, Dict, Sequence, Set
+
+from ck.circuit import OpNode, VarNode, CircuitNode, ConstNode
+
+
+@dataclass
+class CircuitAnalysis:
+    """
+    A data structure representing the analysis of a function defined by
+    a circuit which chosen input variables and output result nodes.
+    """
+
+    var_nodes: Sequence[VarNode]  # specified input var nodes
+    result_nodes: Sequence[CircuitNode]  # specified result nodes
+    op_nodes: Sequence[OpNode]  # in-use op nodes, in computation order
+    const_nodes: Sequence[ConstNode]  # in_use const nodes, in arbitrary order
+    op_to_result: Dict[int, int]  # op nodes in the result, op_node = result[idx]: id(op_node) -> idx
+    op_to_tmp: Dict[int, int]  # op nodes needing tmp memory, using tmp[idx]: id(op_node) -> idx
+
+
+def analyze_circuit(
+        var_nodes: Sequence[VarNode],
+        result_nodes: Sequence[CircuitNode],
+) -> CircuitAnalysis:
+    """
+    Analyzes a circuit as a function from var_nodes to result_nodes,
+    returning a CircuitAnalysis object.
+
+    Args:
+        var_nodes: The chosen input variable nodes of the circuit.
+        result_nodes: The chosen output result nodes of the circuit.
+
+    Returns:
+        A CircuitAnalysis object.
+    """
+    # What op nodes are in use
+    op_nodes: List[OpNode] = (
+        [] if len(result_nodes) == 0
+        else result_nodes[0].circuit.reachable_op_nodes(*result_nodes)
+    )
+
+    # What constant values are in use
+    seen_const_nodes: Set[int] = set()
+    const_nodes: List[ConstNode] = []
+
+    def _register_const(_node: ConstNode) -> None:
+        nonlocal seen_const_nodes
+        nonlocal const_nodes
+        _node_id: int = id(_node)
+        if _node_id not in seen_const_nodes:
+            const_nodes.append(_node)
+            seen_const_nodes.add(_node_id)
+
+    # Register all the used constants
+    for op_node in op_nodes:
+        for node in op_node.args:
+            if isinstance(node, ConstNode):
+                _register_const(node)
+    for node in result_nodes:
+        if isinstance(node, ConstNode):
+            _register_const(node)
+    for node in var_nodes:
+        if node.is_const():
+            _register_const(node.const)
+
+    # What op nodes are in the result.
+    # Dict op_to_result maps id(OpNode) to result index.
+    op_to_result: Dict[int, int] = {
+        id(node): i
+        for i, node in enumerate(result_nodes)
+        if isinstance(node, OpNode)
+    }
+
+    # Assign all other op nodes to a tmp slot.
+    # Dict op_to_tmp maps id(OpNode) to tmp index.
+    tmp_idx = count()
+    op_to_tmp: Dict[int, int] = {
+        id(op_node): next(tmp_idx)
+        for op_node in op_nodes
+        if id(op_node) not in op_to_result
+    }
+    del tmp_idx
+
+    return CircuitAnalysis(
+        var_nodes=var_nodes,
+        result_nodes=result_nodes,
+        op_nodes=op_nodes,
+        const_nodes=const_nodes,
+        op_to_result=op_to_result,
+        op_to_tmp=op_to_tmp,
+    )

ck/circuit_compiler/support/input_vars.py

@@ -0,0 +1,148 @@
+"""
+This module supports circuit compilers and interpreters by inferring and checking input variables
+that are explicitly or implicitly referred to by a client.
+"""
+
+from enum import Enum
+from itertools import chain
+from typing import Sequence, Optional, Set, Iterable, List
+
+from ck.circuit import VarNode, Circuit, CircuitNode, OpNode
+
+
+class InferVars(Enum):
+    """
+    An enum specifying how to automatically infer a program's input variables.
+    """
+
+    ALL = 'all'  # all circuit vars are input vars
+    REF = 'ref'  # only referenced vars are input vars
+    LOW = 'low'  # input vars are circuit vars[0 : max_referenced + 1]
+
+
+# Type for specifying input circuit vars
+InputVars = InferVars | Sequence[VarNode] | VarNode
+
+
+def infer_input_vars(
+        circuit: Optional[Circuit],
+        results: Sequence[CircuitNode],
+        input_vars: InputVars,
+) -> Sequence[VarNode]:
+    """
+    Infer what circuit is being referred to, based on Program constructor arguments.
+    Infer what input variable are being referred to, based on Program constructor arguments.
+    Check that all input vars and results nodes are in the circuit.
+
+    Returns:
+        The inferred input circuit vars.
+
+    Raises:
+        ValueError: if the circuit is unknown, but it is needed.
+        ValueError: if not all nodes are from the same circuit.
+
+    Ensures:
+        circuit is None implies len(input_vars) == 0
+    """
+    cct: Optional[Circuit] = _infer_circuit(circuit, results, input_vars)
+    input_vars: Sequence[VarNode] = _infer_input(cct, results, input_vars)
+
+    # Check that all results nodes and input vars are in the circuit.
+    if cct is not None:
+        for n in chain(results, input_vars):
+            if n.circuit is not cct:
+                raise ValueError('a var node or result node is not in the inferred circuit')
+
+    return input_vars
+
+
+def _infer_circuit(
+        cct: Optional[Circuit],
+        results: Sequence[CircuitNode],
+        input_vars: InputVars,
+) -> Optional[Circuit]:
+    """
+    Infer what circuit is being referred to, based on Program constructor arguments.
+    """
+    if cct is not None:
+        return cct
+    if len(results) > 0:
+        return results[0].circuit
+    if isinstance(input_vars, CircuitNode):
+        return input_vars.circuit
+    if not isinstance(input_vars, InferVars):
+        # input vars is a sequence of CircuitNode
+        for input_var in input_vars:
+            return input_var.circuit
+
+    return None
+
+
+def _infer_input(
+        cct: Optional[Circuit],
+        results: Sequence[CircuitNode],
+        input_vars: InputVars,
+) -> Sequence[VarNode]:
+    """
+    Infer what input variable are being referred to, based on Program constructor arguments.
+    """
+
+    have_results: bool = len(results) > 0
+
+    if input_vars == InferVars.ALL:
+        if have_results:
+            return cct.vars
+        else:
+            return ()
+
+    elif input_vars == InferVars.LOW:
+        if have_results:
+            to_index: int = max((var.idx for var in _find_vars(results)), default=-1) + 1
+            return cct.vars[:to_index]
+        else:
+            return ()
+
+    elif input_vars == InferVars.REF:
+        return tuple(sorted(_find_vars(results)))
+
+    elif isinstance(input_vars, VarNode):
+        input_vars = (input_vars,)
+
+    # Assume input_vars is a Sequence[VarNode]
+
+    in_vars: Sequence[VarNode] = tuple(input_vars)
+
+    # check no duplicate in_vars
+    input_var_indices: Set[int] = {var.idx for var in in_vars}
+    if len(input_var_indices) != len(in_vars):
+        raise ValueError('cannot have duplicate circuit variables as inputs')
+
+    # ensure that the input vars cover what is needed.
+    needed_var_indices: Set[int] = {var.idx for var in _find_vars(results)}
+    if not input_var_indices.issuperset(needed_var_indices):
+        raise ValueError('input var nodes does not cover all need var nodes for result')
+
+    return in_vars
+
+
+def _find_vars(nodes: Iterable[CircuitNode]) -> List[VarNode]:
+    """
+    Get the set of all VarNode nodes that are not set constant, reachable from the given nodes.
+    """
+    seen: Set[int] = set()
+    var_nodes: List[VarNode] = []
+    __find_vars_r(nodes, seen, var_nodes)
+    return var_nodes
+
+
+def __find_vars_r(nodes: Iterable[CircuitNode], seen: Set[int], var_nodes: List[VarNode]) -> None:
+    """
+    Recursive support for _find_vars.
+    """
+    for node in nodes:
+        if id(node) not in seen:
+            seen.add(id(node))
+            if isinstance(node, VarNode) and not node.is_const():
+                var_nodes.append(node)
+            elif isinstance(node, OpNode):
+                __find_vars_r(node.args, seen, var_nodes)

ck/circuit_compiler/support/llvm_ir_function.py

@@ -0,0 +1,234 @@
+import ctypes as ct
+from dataclasses import dataclass
+from enum import Enum
+from typing import Callable, Tuple, Optional
+
+import llvmlite.binding as llvm
+import llvmlite.ir as ir
+
+from ck.program import RawProgram
+from ck.program.raw_program import RawProgramFunction
+from ck.utils.np_extras import DType, DTypeNumeric
+
+__LLVM_INITIALISED: bool = False
+
+_LVM_FUNCTION_NAME: str = 'main'
+
+# Type for an LLVM builder binary Operation
+IrBOp = Callable[[ir.IRBuilder, ir.Value, ir.Value], ir.Value]
+
+IrBoolType = ir.IntType(1)  # Type for an LLVM Boolean.
+
+
+@dataclass(frozen=True)
+class TypeInfo:
+    """
+    Record compiler related information contingent on a given numpy/ctypes `dtype`
+
+    An instance of this data type defines a mathematical ring, i.e., an atomic machine
+    data type and arithmetic operations over them.
+    """
+
+    dtype: DTypeNumeric  # This is the same as numpy `dtype`.
+    llvm_type: ir.Type  # Corresponding LLVM IR type.
+    add: IrBOp  # LLVM IR binary operation for addition.
+    mul: IrBOp  # LLVM IR binary operation for multiplication.
+
+
+# The Boolean constant "One", i.e., "True".
+_IrBoolOne: ir.Value = ir.Constant(IrBoolType, 1)
+
+
+def _bool_and(builder: ir.IRBuilder, x: ir.Value, y: ir.Value) -> ir.Value:
+    """
+    LLVM IR Boolean "and"
+    """
+    tmp: ir.Value = ir.IRBuilder.and_(builder, x, y)
+    return ir.IRBuilder.and_(builder, tmp, _IrBoolOne)
+
+
+def _bool_or(builder: ir.IRBuilder, x: ir.Value, y: ir.Value) -> ir.Value:
+    """
+    LLVM IR Boolean "or"
+    """
+    tmp: ir.Value = ir.IRBuilder.or_(builder, x, y)
+    return ir.IRBuilder.and_(builder, tmp, _IrBoolOne)
+
+
+def _bool_xor(builder: ir.IRBuilder, x: ir.Value, y: ir.Value) -> ir.Value:
+    """
+    LLVM IR Boolean "xor"
+    """
+    tmp: ir.Value = ir.IRBuilder.xor(builder, x, y)
+    return ir.IRBuilder.and_(builder, tmp, _IrBoolOne)
+
+
+def _float_max(builder: ir.IRBuilder, x: ir.Value, y: ir.Value) -> ir.Value:
+    """
+    LLVM IR floating point "max"
+    """
+    cond = builder.fcmp_ordered('>', x, y)
+    return builder.select(cond, x, y)
+
+
+def _float_min(builder: ir.IRBuilder, x: ir.Value, y: ir.Value) -> ir.Value:
+    """
+    LLVM IR floating point "min"
+    """
+    cond = builder.fcmp_ordered('<', x, y)
+    return builder.select(cond, x, y)
+
+
+# IR operations for TypeInfo: (add, mul)
+_float_add: IrBOp = ir.IRBuilder.fadd
+_float_mul: IrBOp = ir.IRBuilder.fmul
+_int_add: IrBOp = ir.IRBuilder.add
+_ind_mul: IrBOp = ir.IRBuilder.mul
+
+
+class DataType(Enum):
+    """
+    Predefined TypeInfo objects.
+
+    Each member defines a mathematical ring, i.e., a machine data
+    type and the "add" and "mul" arithmetic operations over them.
+    """
+
+    FLOAT_32 = TypeInfo(ct.c_float, ir.FloatType(), _float_add, _float_mul)
+    FLOAT_64 = TypeInfo(ct.c_double, ir.DoubleType(), _float_add, _float_mul)
+    INT_8 = TypeInfo(ct.c_int8, ir.IntType(8), _int_add, _ind_mul)
+    INT_16 = TypeInfo(ct.c_int16, ir.IntType(16), _int_add, _ind_mul)
+    INT_32 = TypeInfo(ct.c_int32, ir.IntType(32), _int_add, _ind_mul)
+    INT_64 = TypeInfo(ct.c_int64, ir.IntType(64), _int_add, _ind_mul)
+    BOOL = TypeInfo(ct.c_bool, IrBoolType, _bool_or, _bool_and)
+    XBOOL = TypeInfo(ct.c_bool, IrBoolType, _bool_xor, _bool_and)
+    MAX_MIN = TypeInfo(ct.c_double, ir.DoubleType(), _float_max, _float_min)
+    MAX_MUL = TypeInfo(ct.c_double, ir.DoubleType(), _float_max, _float_mul)
+    MAX_SUM = TypeInfo(ct.c_double, ir.DoubleType(), _float_max, _float_add)
+
+
+class IRFunction:
+    """
+    Data structure to hold information while building an LLVM IR program function.
+    """
+
+    def __init__(self, type_info: TypeInfo):
+        """
+        Create an LLVM IR program function.
+
+        Actions performed:
+        1. LLVM will be initialized.
+        2. A IRBuilder will be constructed (field `builder`).
+        3. A module will be created (field `module`).
+        4. A function will be added to the module (field `function`), the function will
+            have the signature (T* in, T* tmp, T* out) -> Void, where T is `type_info.llvm_type`.
+        5. A basic block will be added to the function (named "entry").
+        """
+        _init_llvm()
+
+        # Get important IR types
+        self.type_info: TypeInfo = type_info
+        self.ret_type: ir.Type = ir.VoidType()
+        self.ptr_type: ir.Type = self.type_info.llvm_type.as_pointer()
+        function_type = ir.FunctionType(self.ret_type, (self.ptr_type, self.ptr_type, self.ptr_type))
+
+        self.module = ir.Module()
+        self.function = ir.Function(self.module, function_type, name=_LVM_FUNCTION_NAME)
+        self.builder = ir.IRBuilder()
+
+        # Create a block of code in the function
+        bb_entry = self.function.append_basic_block('entry')
+        self.builder.position_at_end(bb_entry)
+
+    def llvm_program(self) -> str:
+        """
+        Get the LLVM source code (i.e., the module as an LLVM string).
+
+        Returns:
+            an LLVM program string that can be passed to `compile_llvm_program`.
+        """
+        return str(self.module)
+
+
+@dataclass
+class LLVMRawProgram(RawProgram):
+    llvm_program: Optional[str]
+    engine: llvm.ExecutionEngine
+    opt: int
+
+    def __getstate__(self):
+        """
+        Support for pickle.
+        """
+        if self.llvm_program is None:
+            raise ValueError('need to have the LLVM program to pickle a Program object')
+
+        return {
+            'dtype': self.dtype,
+            'number_of_vars': self.number_of_vars,
+            'number_of_tmps': self.number_of_tmps,
+            'number_of_results': self.number_of_results,
+            'llvm_program': self.llvm_program,
+            'opt': self.opt,
+        }
+
+    def __setstate__(self, state):
+        """
+        Support for pickle.
+        """
+        self.dtype = state['dtype']
+        self.number_of_vars = state['number_of_vars']
+        self.number_of_tmps = state['number_of_tmps']
+        self.number_of_results = state['number_of_results']
+        self.llvm_program = state['llvm_program']
+        self.opt = state['opt']
+
+        # Compile the LLVM program
+        self.engine, self.function = compile_llvm_program(self.llvm_program, self.dtype, self.opt)
+
+
+def compile_llvm_program(
+        llvm_program: str,
+        dtype: DType,
+        opt: int,
+) -> Tuple[llvm.ExecutionEngine, RawProgramFunction]:
+    """
+    Compile the given LLVM program.
+
+    Returns:
+        (engine, function) where
+        engine: is an LLVM execution engine, which must remain
+            in memory for the returned function to be valid.
+        function: is the raw Python callable for the compiled function.
+    """
+    _init_llvm()
+
+    llvm_module = llvm.parse_assembly(llvm_program)
+    llvm_module.verify()
+
+    target = llvm.Target.from_default_triple().create_target_machine(opt=opt)
+    engine = llvm.create_mcjit_compiler(llvm_module, target)
+
+    # Calling finalize_object will create native code and make it executable.
+    engine.finalize_object()
+
+    engine.run_static_constructors()
+
+    # Get the function entry point
+    function_ptr = engine.get_function_address(_LVM_FUNCTION_NAME)
+    ctypes_ptr_type = ct.POINTER(dtype)
+    function = ct.CFUNCTYPE(None, ctypes_ptr_type, ctypes_ptr_type, ctypes_ptr_type)(function_ptr)
+
+    return engine, function
+
+
+def _init_llvm() -> None:
+    """
+    Ensure that LLVM is initialised.
+    """
+    global __LLVM_INITIALISED
+    if not __LLVM_INITIALISED:
+        llvm.initialize()
+        llvm.initialize_native_target()
+        llvm.initialize_native_asmprinter()
+        __LLVM_INITIALISED = True

ck/example/__init__.py

@@ -0,0 +1,53 @@
+"""
+A package of standard probabilistic graphical models.
+"""
+from ck.pgm import PGM
+from ck.example.alarm import Alarm
+from ck.example.binary_clique import BinaryClique
+from ck.example.bow_tie import BowTie
+from ck.example.cancer import Cancer
+from ck.example.asia import Asia
+from ck.example.chain import Chain
+from ck.example.child import Child
+from ck.example.clique import Clique
+from ck.example.cnf_pgm import CNF_PGM
+from ck.example.diamond_square import DiamondSquare
+from ck.example.earthquake import Earthquake
+from ck.example.empty import Empty
+from ck.example.hailfinder import Hailfinder
+from ck.example.hepar2 import Hepar2
+from ck.example.insurance import Insurance
+from ck.example.loop import Loop
+from ck.example.mildew import Mildew
+from ck.example.munin import Munin
+from ck.example.pathfinder import Pathfinder
+from ck.example.rectangle import Rectangle
+from ck.example.rain import Rain
+from ck.example.run import Run
+from ck.example.sachs import Sachs
+from ck.example.sprinkler import Sprinkler
+from ck.example.survey import Survey
+from ck.example.star import Star
+from ck.example.stress import Stress
+from ck.example.student import Student
+from ck.example.triangle_square import TriangleSquare
+from ck.example.truss import Truss
+
+
+# A dictionary with entries, `name: class`, for all example PGM classes.
+#
+# Example usage:
+#     from ck.example import ALL_EXAMPLES
+#
+#     my_pgm: PGM = ALL_EXAMPLES['Alarm']()
+#
+ALL_EXAMPLES = {
+    name: pgm_class
+    for name, pgm_class in globals().items()
+    if (
+           not name.startswith('_')
+           and name != PGM.__name__
+           and isinstance(pgm_class, type)
+           and issubclass(pgm_class, PGM)
+    )
+}