compiled-knowledge 4.0.0a21__cp313-cp313-win_amd64.whl → 4.0.0a23__cp313-cp313-win_amd64.whl

ck/circuit_compiler/cython_vm_compiler/_compiler.pyx

@@ -38,7 +38,7 @@ DTYPE_TO_CVM_TYPE: Dict[DTypeNumeric, str] = {
 }
 
 
-def make_function(analysis: CircuitAnalysis, dtype: DTypeNumeric) -> Tuple[RawProgramFunction, int]:
+def make_function(analysis: CircuitAnalysis, dtype: DTypeNumeric) -> Tuple[RawProgramFunction, int, int]:
     """
     Make a RawProgram function that interprets the circuit.
 
@@ -47,7 +47,7 @@ def make_function(analysis: CircuitAnalysis, dtype: DTypeNumeric) -> Tuple[RawPr
         dtype: a numpy data type that must be a key in the dictionary, DTYPE_TO_CVM_TYPE.
 
     Returns:
-        (function, number_of_tmps)
+        (function, number_of_tmps, number_of_instructions)
     """
 
     cdef Instructions instructions
@@ -128,7 +128,7 @@ def make_function(analysis: CircuitAnalysis, dtype: DTypeNumeric) -> Tuple[RawPr
     else:
         raise ValueError(f'cvm_type_name unexpected: {cvm_type_name!r}')
 
-    return function, len(analysis.op_to_tmp)
+    return function, len(analysis.op_to_tmp), len(analysis.op_nodes)
 
 # VM instructions
 cdef int ADD = circuit.ADD

ck/circuit_compiler/cython_vm_compiler/cython_vm_compiler.py

@@ -48,15 +48,16 @@ class CythonRawProgram(RawProgram):
             result: Sequence[CircuitNode],
             dtype: DTypeNumeric,
     ):
-        self.in_vars = in_vars
-        self.result = result
-
-        function, number_of_tmps = _make_function(
+        function, number_of_tmps, number_of_instructions = _make_function(
             var_nodes=in_vars,
             result_nodes=result,
             dtype=dtype,
         )
 
+        self.in_vars = in_vars
+        self.result = result
+        self.number_of_instructions = number_of_instructions
+
         super().__init__(
             function=function,
             dtype=dtype,
@@ -66,6 +67,10 @@ class CythonRawProgram(RawProgram):
             var_indices=tuple(var.idx for var in in_vars),
         )
 
+    def dump(self, *, prefix: str = '', indent: str = '  ') -> None:
+        super().dump(prefix=prefix, indent=indent)
+        print(f'{prefix}number of instructions = {self.number_of_instructions}')
+
     def __getstate__(self):
         """
         Support for pickle.
@@ -94,7 +99,7 @@ class CythonRawProgram(RawProgram):
         self.in_vars = state['in_vars']
         self.result = state['result']
 
-        self.function, _ = _make_function(
+        self.function, _, self.number_of_instructions = _make_function(
             var_nodes=self.in_vars,
             result_nodes=self.result,
             dtype=self.dtype,
@@ -105,7 +110,7 @@ def _make_function(
         var_nodes: Sequence[VarNode],
         result_nodes: Sequence[CircuitNode],
         dtype: DTypeNumeric,
-) -> Tuple[RawProgramFunction, int]:
+) -> Tuple[RawProgramFunction, int, int]:
     """
     Make a RawProgram function that interprets the circuit.
 
@@ -115,7 +120,9 @@ def _make_function(
         dtype: a numpy data type that must be a key in the dictionary, DTYPE_TO_CVM_TYPE.
 
     Returns:
-        (function, number_of_tmps)
+        (function, number_of_tmps, number_of_instructions)
     """
     analysis: CircuitAnalysis = analyze_circuit(var_nodes, result_nodes)
+    DEBUG =  _compiler.make_function(analysis, dtype)
+
     return _compiler.make_function(analysis, dtype)

ck/circuit_compiler/interpret_compiler.py

@@ -1,17 +1,17 @@
 from __future__ import annotations
 
+import ctypes as ct
 from dataclasses import dataclass
 from typing import Sequence, Optional, Dict, List, Tuple, Callable
 
 import numpy as np
-import ctypes as ct
 
+from .support.circuit_analyser import CircuitAnalysis, analyze_circuit
+from .support.input_vars import InputVars, InferVars, infer_input_vars
 from ..circuit import Circuit, CircuitNode, VarNode, OpNode, ADD, MUL
 from ..program.raw_program import RawProgram, RawProgramFunction
 from ..utils.iter_extras import multiply, first
 from ..utils.np_extras import NDArrayNumeric, DTypeNumeric
-from .support.circuit_analyser import CircuitAnalysis, analyze_circuit
-from .support.input_vars import InputVars, InferVars, infer_input_vars
 
 # index to a value array
 _VARS = 0
@@ -85,6 +85,15 @@ class InterpreterRawProgram(RawProgram):
             var_indices=tuple(var.idx for var in in_vars),
         )
 
+    def dump(self, *, prefix: str = '', indent: str = '  ', show_instructions: bool = True) -> None:
+        super().dump(prefix=prefix, indent=indent)
+        print(f'{prefix}number of instructions = {len(self.instructions)}')
+        if show_instructions:
+            print(f'{prefix}instructions:')
+            next_prefix: str = prefix + indent
+            for instruction in self.instructions:
+                print(f'{next_prefix}{instruction.to_str(self.var_indices, self.np_consts)}')
+
     def __getstate__(self):
         """
         Support for pickle.
@@ -123,7 +132,6 @@ def _make_instructions(
         analysis: CircuitAnalysis,
         dtype: DTypeNumeric,
 ) -> Tuple[Sequence[_Instruction], NDArrayNumeric]:
-
     # Store const values in a numpy array
     node_to_const_idx: Dict[int, int] = {
         id(node): i
@@ -139,6 +147,7 @@ def _make_instructions(
     for node_id, const_idx in node_to_const_idx.items():
         node_to_element[node_id] = _ElementID(_CONSTS, const_idx)
     # var nodes
+    var_node: VarNode
     for i, var_node in enumerate(analysis.var_nodes):
         if var_node.is_const():
             node_to_element[id(var_node)] = node_to_element[id(var_node.const)]
@@ -215,9 +224,32 @@ class _ElementID:
     array: int  # VARS, TMPS, CONSTS, RESULT
     index: int  # index into the array
 
+    def to_str(self, var_indices: Sequence[int], consts: NDArrayNumeric) -> str:
+        if self.array == _VARS:
+            return f'var[{var_indices[self.index]}]'
+        elif self.array == _TMPS:
+            return f'tmp[{self.index}]'
+        elif self.array == _CONSTS:
+            return str(consts.item(self.index))
+        elif self.array == _RESULT:
+            return f'result[{self.index}]'
+        else:
+            return f'?[{self.index}]'
+
 
 @dataclass
 class _Instruction:
     operation: Callable
     args: Sequence[_ElementID]
     dest: _ElementID
+
+    def to_str(self, var_indices: Sequence[int], consts: NDArrayNumeric) -> str:
+        symbol: str
+        if self.operation is multiply:
+            symbol = 'mul'
+        elif self.operation == sum:
+            symbol = 'sum'
+        else:
+            symbol = '<?>'
+        args: str = ' '.join(elem.to_str(var_indices, consts) for elem in self.args)
+        return f'{self.dest.to_str(var_indices, consts)} = {symbol} {args}'

ck/circuit_compiler/llvm_compiler.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from enum import Enum
-from typing import Sequence, Optional, Tuple, Dict, Protocol
+from typing import Sequence, Optional, Tuple, Dict, Protocol, assert_never
 
 import llvmlite.binding as llvm
 import llvmlite.ir as ir
@@ -238,7 +238,7 @@ class _FunctionBuilderTmps(_FunctionBuilder):
         if idx is not None:
             return builder.load(builder.gep(self.out_args, [ir.Constant(self.llvm_idx_type, idx)]))
 
-        assert False, 'not reached'
+        assert_never('not reached')
 
     def store_calculation(self, value: ir.Value, op_node: OpNode) -> None:
         """
@@ -262,7 +262,7 @@ class _FunctionBuilderTmps(_FunctionBuilder):
             builder.store(value, ptr)
             return
 
-        assert False, 'not reached'
+        assert_never('not reached')
 
     def store_result(self, value: ir.Value, idx: int) -> None:
         """
@@ -359,7 +359,7 @@ class _FunctionBuilderStack(_FunctionBuilder):
         if idx is not None:
             return builder.load(builder.gep(self.out_args, [ir.Constant(self.llvm_idx_type, idx)]))
 
-        assert False, 'not reached'
+        assert_never('not reached')
 
     def store_calculation(self, value: ir.Value, op_node: OpNode) -> None:
         """

ck/circuit_compiler/llvm_vm_compiler.py

@@ -1,12 +1,12 @@
 from __future__ import annotations
 
+import ctypes as ct
 from dataclasses import dataclass
 from typing import Sequence, Optional, Tuple, List, Dict
 
 import llvmlite.binding as llvm
 import llvmlite.ir as ir
 import numpy as np
-import ctypes as ct
 
 from .support.circuit_analyser import CircuitAnalysis, analyze_circuit
 from .support.input_vars import InputVars, InferVars, infer_input_vars
@@ -126,6 +126,12 @@ class LLVMRawProgramWithArrays(LLVMRawProgram):
     instructions: np.ndarray
     consts: np.ndarray
 
+    def dump(self, *, prefix: str = '', indent: str = '  ', show_instructions: bool = True) -> None:
+        super().dump(prefix=prefix, indent=indent)
+        print(f'{prefix}LLVM byte code size = {len(self.instructions)}')
+        if show_instructions:
+            self.dump_llvm_program(prefix=prefix, indent=indent)
+
     def __post_init__(self):
         self._set_globals(self.instructions, _SET_INSTRUCTIONS_FUNCTION_NAME)
         self._set_globals(self.consts, _SET_CONSTS_FUNCTION_NAME)
@@ -200,7 +206,7 @@ def _make_llvm_program(
         consts_global.global_constant = True
         consts_global.initializer = ir.Constant(consts_array_type, const_values)
         data_idx_0 = ir.Constant(data_idx_type, 0)
-        consts: ir.Value = builder.gep(consts_global, [data_idx_0,  data_idx_0])
+        consts: ir.Value = builder.gep(consts_global, [data_idx_0, data_idx_0])
 
         # Put bytecode into the LLVM module
         instructions_array_type = ir.ArrayType(byte_type, len(byte_code))
@@ -218,7 +224,7 @@ def _make_llvm_program(
 
         instructions_ptr_type = byte_type.as_pointer()
         instructions_global = ir.GlobalVariable(module, instructions_ptr_type, name='instructions')
-        instructions_global.initializer =ir.Constant(instructions_ptr_type, None)
+        instructions_global.initializer = ir.Constant(instructions_ptr_type, None)
         instructions: ir.Value = builder.load(instructions_global)
 
     interp = _InterpBuilder(builder, type_info, inst_idx_type, data_idx_bytes, num_args_bytes, consts, instructions)

ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.c

@@ -13,7 +13,7 @@
             "/O2"
         ],
         "include_dirs": [
-            "C:\\Users\\runneradmin\\AppData\\Local\\Temp\\build-env-j2senjg7\\Lib\\site-packages\\numpy\\_core\\include"
+            "C:\\Users\\runneradmin\\AppData\\Local\\Temp\\build-env-ca0w3uvm\\Lib\\site-packages\\numpy\\_core\\include"
         ],
         "name": "ck.circuit_compiler.support.circuit_analyser._circuit_analyser_cy",
         "sources": [

ck/circuit_compiler/support/llvm_ir_function.py

@@ -1,7 +1,7 @@
 import ctypes as ct
 from dataclasses import dataclass
 from enum import Enum
-from typing import Callable, Tuple, Optional
+from typing import Callable, Tuple, Optional, List
 
 import llvmlite.binding as llvm
 import llvmlite.ir as ir
@@ -172,6 +172,23 @@ class LLVMRawProgram(RawProgram):
             'opt': self.opt,
         }
 
+    def dump(self, *, prefix: str = '', indent: str = '  ', show_instructions: bool = True) -> None:
+        super().dump(prefix=prefix, indent=indent)
+        print(f'{prefix}optimisation level = {self.opt}')
+        if show_instructions:
+            self.dump_llvm_program(prefix=prefix, indent=indent)
+
+    def dump_llvm_program(self, *, prefix: str = '', indent: str = '  ') -> None:
+        if self.llvm_program is None:
+            print(f'{prefix}LLVM program: unavailable')
+        else:
+            llvm_program: List[str] = self.llvm_program.split('\n')
+            print(f'{prefix}LLVM program size = {len(llvm_program)}')
+            print(f'{prefix}LLVM program:')
+            next_prefix: str = prefix + indent
+            for line in llvm_program:
+                print(f'{next_prefix}{line}')
+
     def __setstate__(self, state):
         """
         Support for pickle.

ck/pgm.py

@@ -2935,7 +2935,7 @@ class CPTPotentialFunction(PotentialFunction):
             return True
         else:
             # The requested tolerance is tighter than ensured.
-            # Need to use the default method
+            # Need to use the default method.
             return super().is_cpt(tolerance)
 
     @property

ck/pgm_circuit/mpe_program.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from dataclasses import dataclass
 from functools import partial
-from typing import Sequence, Optional, Tuple, List, Dict, Set
+from typing import Sequence, Optional, Tuple, List, Dict, Set, assert_never
 
 from ck.circuit import CircuitNode, Circuit, VarNode, OpNode, ADD, MUL
 from ck.circuit_compiler import llvm_vm_compiler, CircuitCompiler
@@ -207,7 +207,7 @@ class MPEProgram(ProgramWithSlotmap):
                             self._trace_var(child, states)
                             return
                 # No child value equaled the value for node! We should never get here
-                assert False, 'not reached'
+                assert_never('not reached')
             elif node.symbol == MUL:
                 # Recurse though each child node
                 for child in node.args:

ck/pgm_circuit/support/compile_circuit.py

@@ -2,7 +2,6 @@ from typing import Optional, Sequence
 
 from ck.circuit import CircuitNode, TmpConst, Circuit
 from ck.circuit_compiler import CircuitCompiler
-from ck.circuit_compiler.llvm_compiler import DataType, DEFAULT_TYPE_INFO, compile_circuit
 from ck.circuit_compiler import DEFAULT_CIRCUIT_COMPILER
 from ck.pgm_circuit import PGMCircuit
 from ck.program import RawProgram
@@ -48,7 +47,7 @@ def compile_param_derivatives(
         pgm_circuit: PGMCircuit,
         self_multiply: bool = False,
         params_value: Optional[float | int] = 1,
-        data_type: DataType = DEFAULT_TYPE_INFO,
+        compiler: CircuitCompiler = DEFAULT_CIRCUIT_COMPILER,
 ) -> RawProgram:
     """
     Compile the circuit to a program for computing the partial derivatives of the parameters.
@@ -56,14 +55,12 @@ def compile_param_derivatives(
 
     Typically, this will grow the circuit by the addition of circuit nodes to compute the derivatives.
 
-    This uses the LLVM circuit compiler.
-
     Args:
         pgm_circuit: The circuit (and PGM) that will be compiled to a program.
         self_multiply: if true then each partial derivative df/dx will be multiplied by x.
         params_value: if not None, then circuit vars representing parameters will be temporarily
             set to this value for compiling the program. Default is 1.
-        data_type: What data type to use for arithmetic calculations. Either a DataType member or TypeInfo.
+        compiler: function from circuit nodes to raw program.
     """
     top: CircuitNode = pgm_circuit.circuit_top
     circuit: Circuit = top.circuit
@@ -76,8 +73,8 @@ def compile_param_derivatives(
     if params_value is not None:
         with TmpConst(circuit) as tmp:
             tmp.set_const(param_vars, params_value)
-            raw_program: RawProgram = compile_circuit(*derivatives, circuit=circuit, data_type=data_type)
+            raw_program: RawProgram = compiler(*derivatives, circuit=circuit)
     else:
-        raw_program: RawProgram = compile_circuit(*derivatives, circuit=circuit, data_type=data_type)
+        raw_program: RawProgram = compiler(*derivatives, circuit=circuit)
 
     return raw_program

ck/pgm_compiler/named_pgm_compilers.py

@@ -16,7 +16,6 @@ class NamedPGMCompiler(Enum):
     Wrapping in a tuple is needed otherwise Python erases the type of the member, which can cause problems.
     Each member itself is callable, confirming to the PGMCompiler protocol, delegating to the compiler function.
     """
-    # @formatter:off
 
     VE_MIN_DEGREE = _get_compiler_algorithm(variable_elimination, 'MIN_DEGREE')
     VE_MIN_DEGREE_THEN_FILL = _get_compiler_algorithm(variable_elimination, 'MIN_DEGREE_THEN_FILL')
@@ -45,8 +44,6 @@ class NamedPGMCompiler(Enum):
 
     ACE = _get_compiler(ace)
 
-    # @formatter:on
-
     def __call__(self, pgm: PGM, const_parameters: bool = True) -> PGMCircuit:
         """
         Each member of the enum is a PGMCompiler function.

ck/pgm_compiler/support/circuit_table/_circuit_table_cy.c

@@ -13,7 +13,7 @@
             "/O2"
         ],
         "include_dirs": [
-            "C:\\Users\\runneradmin\\AppData\\Local\\Temp\\build-env-j2senjg7\\Lib\\site-packages\\numpy\\_core\\include"
+            "C:\\Users\\runneradmin\\AppData\\Local\\Temp\\build-env-ca0w3uvm\\Lib\\site-packages\\numpy\\_core\\include"
         ],
         "name": "ck.pgm_compiler.support.circuit_table._circuit_table_cy",
         "sources": [

ck/pgm_compiler/support/clusters.py

@@ -295,7 +295,7 @@ class Clusters:
         Returns:
             the maximum `len(cluster)` over all clusters.
         """
-        return max(len(cluster) for cluster in self.clusters)
+        return max((len(cluster) for cluster in self.clusters), default=0)
 
     def max_cluster_weighted_size(self, rv_log_sizes: Sequence[float]) -> float:
         """
@@ -303,13 +303,17 @@ class Clusters:
 
         Args:
             rv_log_sizes: is an array of random variable sizes, such that
-                for a random variable `rv`, `rv_log_sizes[rv.idx] = log2(len(rv))`.
+                for a random variable `rv`, `rv_log_sizes[rv.idx] = log2(len(rv))`,
+                e.g., `self.pgm.rv_log_sizes`.
         Returns:
             the maximum `sum(rv_log_sizes[rv_idx] for rv_idx in cluster)` over all clusters.
         """
         return max(
-            sum(rv_log_sizes[rv_idx] for rv_idx in cluster)
-            for cluster in self.clusters
+            (
+                sum(rv_log_sizes[rv_idx] for rv_idx in cluster)
+                for cluster in self.clusters
+            ),
+            default=0
         )
 
     def eliminate(self, rv_index: int) -> None:

ck/program/raw_program.py

@@ -21,8 +21,11 @@ class RawProgram:
     A raw program is returned by a circuit compiler to provide execution of
     the function defined by a compiled circuit.
 
-    A `RawProgram` is a `Callable` with the signature:
-
+    A `RawProgram` is a `Callable`; given an array of input variable values,
+    return a numpy array of result values. Calling a RawProgram is not necessarily
+    an efficient method for executing a program as buffers are reallocated for
+    each call. Alternatively, a `RawProgram` can be wrapped in a `ProgramBuffer`
+    for computationally efficient memory buffer reuse.
 
     Fields:
         function: is a function of three ctypes arrays, returning nothing.
@@ -30,7 +33,7 @@ class RawProgram:
         number_of_vars: the number of input values (first function argument).
         number_of_tmps: the number of working memory values (second function argument).
         number_of_results: the number of result values (third function argument).
-        var_indices:  maps the index of inputs (from 0 to self.number_of_vars - 1) to the index
+        var_indices: maps the index of inputs (from 0 to self.number_of_vars - 1) to the index
             of the corresponding circuit var.
     """
 
@@ -41,19 +44,33 @@ class RawProgram:
     number_of_results: int
     var_indices: Sequence[int]
 
-    def __call__(self, in_vars: NDArrayNumeric | Sequence[int | float]) -> NDArrayNumeric:
+    def __call__(self, var_values: NDArrayNumeric | Sequence[int | float] | int | float) -> NDArrayNumeric:
         """
-        Call the raw program as a function from an array to an array.
+        Call the raw program as a function. This method will allocate numpy arrays of type `self.dtype`
+        for input, temporary, and output values. If `var_values` is a numpy array of the needed
+        dtype then it will be used directly.
+
+        Args:
+            var_values: the input variable values. This can be a numpy array, a Python sequence of
+                floats or int, or a single float or int. The number of input values must equal
+                `self.number_of_vars`.
+
+        Returns:
+            a numpy array of result values with shape `(self.number_of_results,)`.
         """
         array_vars: NDArrayNumeric
         if isinstance(vars, np.ndarray):
-            array_vars = in_vars
+            if var_values.dtype != self.dtype:
+                array_vars = var_values.astype(self.dtype)
+            else:
+                array_vars = self.dtype
+        elif isinstance(vars, (int, float)):
+            array_vars = np.array([var_values], dtype=self.dtype)
         else:
-            array_vars = np.array(in_vars, dtype=self.dtype)
+            array_vars = np.array(var_values, dtype=self.dtype)
+
         if array_vars.shape != (self.number_of_vars,):
             raise ValueError(f'input array incorrect shape: got {array_vars.shape} expected ({self.number_of_vars},)')
-        if array_vars.dtype != self.dtype:
-            raise ValueError(f'input array incorrect dtype: got {array_vars.dtype} expected {self.dtype}')
 
         array_tmps: NDArrayNumeric = np.zeros(self.number_of_tmps, dtype=self.dtype)
         array_outs: NDArrayNumeric = np.zeros(self.number_of_results, dtype=self.dtype)
@@ -65,3 +82,18 @@ class RawProgram:
 
         self.function(c_array_vars, c_array_tmps, c_array_outs)
         return array_outs
+
+    def dump(self, *, prefix: str = '', indent: str = '  ') -> None:
+        """
+        Print a dump of the PGM.
+        This is intended for demonstration and debugging purposes.
+
+        Args:
+            prefix: optional prefix for indenting all lines.
+            indent: additional prefix to use for extra indentation.
+        """
+        print(f'{prefix}{self.__class__.__name__}')
+        print(f'{prefix}signature = [{self.number_of_vars}] -> [{self.number_of_results}]')
+        print(f'{prefix}temps = {self.number_of_tmps}')
+        print(f'{prefix}dtype = {self.dtype}')
+        print(f'{prefix}var_indices = {self.var_indices}')

ck/utils/np_extras.py

@@ -29,17 +29,17 @@ NDArrayNumeric = NDArray[DTypeNumeric]
 
 
 # Constants for maximum number of states.
-_MAX_STATES_8: int = 2 ** 8 - 1
-_MAX_STATES_16: int = 2 ** 16 - 1
-_MAX_STATES_32: int = 2 ** 32 - 1
-_MAX_STATES_64: int = 2 ** 64 - 1
+_MAX_STATES_8: int = 2 ** 8
+_MAX_STATES_16: int = 2 ** 16
+_MAX_STATES_32: int = 2 ** 32
+_MAX_STATES_64: int = 2 ** 64
 
 
 def dtype_for_number_of_states(number_of_states: int) -> DTypeStates:
     """
     Infer the numpy dtype required to store any state index of the given PGM.
     """
-    # Infer the needed size of
+    # Infer the needed dtype required to hold a number of states
     if number_of_states <= _MAX_STATES_8:
         return np.uint8
     if number_of_states <= _MAX_STATES_16:

ck_demos/ace/simple_ace_demo.py

@@ -0,0 +1,18 @@
+from ck import example
+from ck.pgm import RVMap
+from ck.pgm_circuit.wmc_program import WMCProgram
+from ck.pgm_compiler import NamedPGMCompiler
+
+# create the example "Cancer" Bayesian network
+pgm = example.Cancer()
+
+# compile the PGM and construct an object for probabilistic queries
+wmc = WMCProgram(NamedPGMCompiler.ACE(pgm))
+
+# provide easy access to the random variables - not needed but simplifies this demo
+rvs = RVMap(pgm)
+
+# get the probability of having cancer given that pollution is high
+pr = wmc.probability(rvs.cancer('True'), condition=rvs.pollution('high'))
+
+print('probability of having cancer given that pollution is high =', pr)

ck_demos/getting_started/simple_demo.py

@@ -0,0 +1,18 @@
+from ck import example
+from ck.pgm import RVMap
+from ck.pgm_circuit.wmc_program import WMCProgram
+from ck.pgm_compiler import DEFAULT_PGM_COMPILER
+
+# create the example "Cancer" Bayesian network
+pgm = example.Cancer()
+
+# compile the PGM and construct an object for probabilistic queries
+wmc = WMCProgram(DEFAULT_PGM_COMPILER(pgm))
+
+# provide easy access to the random variables - not needed but simplifies this demo
+rvs = RVMap(pgm)
+
+# get the probability of having cancer given that pollution is high
+pr = wmc.probability(rvs.cancer('True'), condition=rvs.pollution('high'))
+
+print('probability of having cancer given that pollution is high =', pr)

ck_demos/programs/demo_raw_program_dump.py

@@ -0,0 +1,17 @@
+from ck.circuit import Circuit
+from ck.circuit_compiler import NamedCircuitCompiler
+
+
+def main() -> None:
+    cct = Circuit()
+    a, b, c, d = cct.new_vars(4)
+    top = a * b + c * d + 56.23
+
+    for compiler in NamedCircuitCompiler:
+        raw_program = compiler(top)
+        raw_program.dump()
+        print()
+
+
+if __name__ == '__main__':
+    main()

{compiled_knowledge-4.0.0a21.dist-info → compiled_knowledge-4.0.0a23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compiled-knowledge
-Version: 4.0.0a21
+Version: 4.0.0a23
 Summary: A Python package for compiling and querying discrete probabilistic graphical models.
 Author-email: Barry Drake <barry@compiledknowledge.org>
 License-Expression: MIT