compiled-knowledge 4.0.0a22__cp312-cp312-win_amd64.whl → 4.0.0a23__cp312-cp312-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
@@ -216,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_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-0p_rjbh1\\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_compiler/support/circuit_table/_circuit_table_cy.c

@@ -13,7 +13,7 @@
             "/O2"
         ],
         "include_dirs": [
-            "C:\\Users\\runneradmin\\AppData\\Local\\Temp\\build-env-0p_rjbh1\\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/program/raw_program.py

@@ -21,7 +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.
@@ -40,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)
@@ -64,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_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.0a22.dist-info → compiled_knowledge-4.0.0a23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compiled-knowledge
-Version: 4.0.0a22
+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

{compiled_knowledge-4.0.0a22.dist-info → compiled_knowledge-4.0.0a23.dist-info}/RECORD

@@ -1,29 +1,29 @@
 ck/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/pgm.py,sha256=Uwo2A4qEtgwmKkma1HOsozn837435zEN9JUByYlfe-w,120701
 ck/circuit/__init__.py,sha256=klUR7OVESf53-8Ho4f32clHFsR2SOz4XgwZzfDlms88,418
-ck/circuit/_circuit_cy.c,sha256=zBsA_-1MY4IpO1kF4xOPtIjp8AkCCmbYSw7hm9NQxC4,1742373
-ck/circuit/_circuit_cy.cp312-win_amd64.pyd,sha256=Te7ZttUIpLYmP7ihkRWnwQxnXOgT41RxmoOctV9x-8Q,242688
+ck/circuit/_circuit_cy.c,sha256=TU_8mS7m-QLkAok8SHoYza7v4HINNxmi-MqPwEFwD2g,1741715
+ck/circuit/_circuit_cy.cp312-win_amd64.pyd,sha256=bHkoHY0xhttReKysRJ9q12EBGYYj_4rhSfdlkepNWjg,242688
 ck/circuit/_circuit_cy.pxd,sha256=F1WU4KuX_knXQX-hwNKoHsoUK3fJLbLOxEnomWMJFpI,1057
-ck/circuit/_circuit_cy.pyx,sha256=RGfHGBj3XibLw4S5CC6FVnXOHjpzU0_aoVowqIY2qzA,27773
-ck/circuit/_circuit_py.py,sha256=vN8lg01RyjA_YUphjx1dr0Uj4ql4seczRcoCaH7ylAw,28341
+ck/circuit/_circuit_cy.pyx,sha256=TIjqsdyN_IzOm9XQw26kEURpL6GSL1kJO3K-UUlkbQc,27763
+ck/circuit/_circuit_py.py,sha256=gQZoEphxut2UyBL0ZqmNc8KlNBSMST_VOCqOpDMIRSM,28331
 ck/circuit/tmp_const.py,sha256=dG9FuGfoAG5qjYG1rNwekqKiea_KmVfxHMTOgCPbBiQ,2372
 ck/circuit_compiler/__init__.py,sha256=T0Igyp5jPgnIXv4oRcIYhmsOdcNOb3L4Za6dK6eYk7g,132
 ck/circuit_compiler/circuit_compiler.py,sha256=8BLB8DUnPbpl5PXZsIopydPbItytdn2rzRfM2U1EC84,1018
-ck/circuit_compiler/interpret_compiler.py,sha256=7PjtEFNR0JMw56XaYP9IZ5ZNZTTLYCUUDiMDj7cN5f8,7373
+ck/circuit_compiler/interpret_compiler.py,sha256=KMzLzIV-BU5l8GQ2833kjios4sbGSVUm4ero7MEYvVk,8786
 ck/circuit_compiler/llvm_compiler.py,sha256=6RHUCVWCOgt3ZNyjRTl2Z2npYJMWyAFJVAIc5SAx2mY,14023
-ck/circuit_compiler/llvm_vm_compiler.py,sha256=I46_XV5FrClDKO06zIjn8T3ME5XQ9RYJ_1aAE8e_YzM,21873
+ck/circuit_compiler/llvm_vm_compiler.py,sha256=XJhiAZmGMRRz49XUfng9lgETxVw6NgD6XCI0H3fX-1E,22200
 ck/circuit_compiler/named_circuit_compilers.py,sha256=snlD3JnhAZC-atKpf5GD0v4CGdvj2_ZhCZ3O-tsxzxc,2284
 ck/circuit_compiler/cython_vm_compiler/__init__.py,sha256=pEAwTleuZgdYhTAQMea2f9YsFK54eoNbZSbrWkW8aeE,49
-ck/circuit_compiler/cython_vm_compiler/_compiler.c,sha256=ly19gSYNgnEmyrrAjQooVL1BMULN5_IoyHNYZlEEJWQ,870540
-ck/circuit_compiler/cython_vm_compiler/_compiler.cp312-win_amd64.pyd,sha256=q95-GArE8rbjvDGoXSHHPga0vYtXopGoPgqRwW01k48,103424
-ck/circuit_compiler/cython_vm_compiler/_compiler.pyx,sha256=QS6FG5z-ay9fnUTCMwtJm89I3QpfY6RqS874zHvZrBA,13225
-ck/circuit_compiler/cython_vm_compiler/cython_vm_compiler.py,sha256=WywW6uhoyP-U5hWdF1amsE8fhbP9LbDtWTu2wVFkR2k,4066
+ck/circuit_compiler/cython_vm_compiler/_compiler.c,sha256=RKSqL9x1DlfNR2NPzDJJhnknwei_enKaZxtcXZgzdRw,871325
+ck/circuit_compiler/cython_vm_compiler/_compiler.cp312-win_amd64.pyd,sha256=2J4f7I48NyDQHXd51A9YoSsbe4mECV9xvpFzHMiLJZc,103936
+ck/circuit_compiler/cython_vm_compiler/_compiler.pyx,sha256=550r0AkOh8ZuuTRy3e6Aq-YqBQ82EKcap8e6f3zlEuM,13278
+ck/circuit_compiler/cython_vm_compiler/cython_vm_compiler.py,sha256=3Q-HCyA7VWFoXS9gn-k4LXedzqHPvdFNvWHfDcKYv6s,4473
 ck/circuit_compiler/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/circuit_compiler/support/input_vars.py,sha256=x6krN6sW9A-vZTteY4M4on_0vS4ChaaCcmnXcnQ4y0s,4812
-ck/circuit_compiler/support/llvm_ir_function.py,sha256=7SoYEQiBS2GHFknw0raH0ouJyBQmYp-ZydJVEXVo0Uw,7779
+ck/circuit_compiler/support/llvm_ir_function.py,sha256=f4gD591d8cytln4vY9Lxw_cJrSyQJ3iHES49eN44eec,8612
 ck/circuit_compiler/support/circuit_analyser/__init__.py,sha256=RbyIObAAb-w0Ky4fB198xAfxTh2doquN9ez68SZSZgo,536
-ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.c,sha256=uVBuaWzBVkkYIIkVGikKWR839DGW9ytriP6a2yEPEFQ,448751
-ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.cp312-win_amd64.pyd,sha256=kdIx89qPFfdUa15ADpVAFoc-3OHjdbXU7S9U1Dna6Ds,54272
+ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.c,sha256=FN43CmGEBQv72l7rqE6qnjb_8MzYLZRwudYkRrxRSD0,448751
+ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.cp312-win_amd64.pyd,sha256=bIr-0khzKefEnY8ff_dbzWrlg1ICcrSIwHSaQhCYrU8,54272
 ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.pyx,sha256=ctDOHOjnUhdsR_XHBrgchFVTImLhsEUjU3cqkP-GdF8,3331
 ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_py.py,sha256=eWjc2B946LeSzcGa9PyI4XQvlx_B1KPEiQuM6OOFjjQ,3086
 ck/example/__init__.py,sha256=BXVxvTcl3tqgai-xJiGQIaG_ChlpPRdfWg985MQ7dwM,1744
@@ -91,8 +91,8 @@ ck/pgm_compiler/support/factor_tables.py,sha256=tV9qE2zC8iwEQxTuXE6qiE6lmMpz4-Vc
 ck/pgm_compiler/support/join_tree.py,sha256=OGAuZVHzT0i4e6TJ03dOM7e3gbpuW9AyjZKvSBvKvJA,12894
 ck/pgm_compiler/support/named_compiler_maker.py,sha256=g2MLnlkWXkISHL6dh23EY53SptTo7-itfuZogSpMdB8,1420
 ck/pgm_compiler/support/circuit_table/__init__.py,sha256=yJ05NvuNE9j0E_QnjDzHYfLqcHn5TdOleEpG3wSRgXQ,579
-ck/pgm_compiler/support/circuit_table/_circuit_table_cy.c,sha256=4wnwUtsxyHGV0YSTzWOZn6bux4RhaK_zPdZxBY8C9io,730350
-ck/pgm_compiler/support/circuit_table/_circuit_table_cy.cp312-win_amd64.pyd,sha256=tWzEiXDAOYHg5Cr6ViUHj6rEni89PNa148w1pJpTJSk,97280
+ck/pgm_compiler/support/circuit_table/_circuit_table_cy.c,sha256=8m9UlrszjsKjINoU0lDBmNyeNhJ13ApY4OaPnY8riI4,730350
+ck/pgm_compiler/support/circuit_table/_circuit_table_cy.cp312-win_amd64.pyd,sha256=UV3db7bYnOD-5iqn_pZf3eYfjQy6FqFgcsDGL--mMvc,97280
 ck/pgm_compiler/support/circuit_table/_circuit_table_cy.pyx,sha256=rVO1yxjZmZ6yv5s0zKq4Ji9WYrDuYTZsRG_zeF1_1xE,12015
 ck/pgm_compiler/support/circuit_table/_circuit_table_py.py,sha256=h6xPYGBSy6XHQBFLPD2D1-V7Kiw9utY68nWrcGRMEg4,11287
 ck/probability/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -102,7 +102,7 @@ ck/probability/probability_space.py,sha256=itv3dNEpSTLhKg6JCNhe7Iy6n9MKWqeKO4RxK
 ck/program/__init__.py,sha256=Ss9-0eqsGxCGloD6liH-0iqBG5Q3vPRF4XCw2hkDJ0M,110
 ck/program/program.py,sha256=gDJ5Q2kXZuaoHboa9yNTg0tQH9S-Gmw0BRx6PPV28pU,4184
 ck/program/program_buffer.py,sha256=1fiUcT7sqyr4vu8jXzK3ZsrgURFhWMdm6hr2BeS9ONA,5665
-ck/program/raw_program.py,sha256=94D74Vz5Hu8p3JYNKT9kflXHuj0jscNBoX4O5Ug7G8A,2623
+ck/program/raw_program.py,sha256=J8jbyhc1X9PxX5DFMFeIIRHbh65JTkAxFRbjVjzxz7s,4257
 ck/sampling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/sampling/forward_sampler.py,sha256=pTtpaH_ONH67G4P-aJ1p8YZSaXr4TTD6pj3ZEI2y7KM,8348
 ck/sampling/marginals_direct_sampler.py,sha256=p1jDr1stG2Hjay3D8hILezW-5YZTX1p3odUcJDAI-OQ,4466
@@ -126,12 +126,15 @@ ck_demos/all_demos.py,sha256=E1SZDvG0l_j1PfHZLemHocezw10uY5uGl3yE3BX87DE,2556
 ck_demos/ace/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck_demos/ace/copy_ace_to_ck.py,sha256=TJHPGcUbd1a6OjH3Fw7c3fno8ULPbf5p3V_lBmiNR-k,303
 ck_demos/ace/demo_ace.py,sha256=Ve_0Ho-jeOrfpFAV-XBSW_jxcWqFYeCQyo_VQd3Aik4,1458
+ck_demos/ace/simple_ace_demo.py,sha256=cC1ZHiq5VbF1LmIjyYaHlUnku_3wP5FJ3sa537x-0xU,664
 ck_demos/circuit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck_demos/circuit/demo_circuit_dump.py,sha256=CQC5cxXaaRuVZ3d8h-SqXs8EJo0Tm5H5l7T9ad6pyEk,458
 ck_demos/circuit/demo_derivatives.py,sha256=3JoWVAEKLEoLjq6QzWkq4Z-qVq1l0tHvGDn5erVuozc,1186
 ck_demos/circuit_compiler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck_demos/circuit_compiler/compare_circuit_compilers.py,sha256=IEzwvKt6c8wrmAyd6F0sUaNaWYEx1BBFQhRyDt7cibI,756
 ck_demos/circuit_compiler/show_llvm_program.py,sha256=HKUuyLfBjH6ZgD8l4gQWVSBPUh55ZCXjPa7ZEdm5OyU,712
+ck_demos/getting_started/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ck_demos/getting_started/simple_demo.py,sha256=AR40OtUVd-CJOxFlsu8_RtGLL2LLnZg506SzrIx7OQA,668
 ck_demos/pgm/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck_demos/pgm/demo_pgm_dump.py,sha256=egcjSjMDJdyzxWGvHrgdF_g3CFYozLKv4XSXzvSfWbg,248
 ck_demos/pgm/demo_pgm_dump_stress.py,sha256=L9S3yp0EQM56kWztV4A6XzEqITOGbThImZIU0JofCDg,285
@@ -159,6 +162,7 @@ ck_demos/programs/demo_program_buffer.py,sha256=2XuBE15PmJOtdsyzqlq_LgHrYPj59_Ej
 ck_demos/programs/demo_program_multi.py,sha256=8mTZycb5onaDKThLOvoR9oeCdWD8k8K0hVIKxCxMkq0,624
 ck_demos/programs/demo_program_none.py,sha256=PDo3Ua0j-g8GXrAfLt3oWa2H-_cTMvo_7GwNimCRaNc,480
 ck_demos/programs/demo_program_single.py,sha256=CVbipru3BxUGol565MY3Q_G0z4GLNnSrgFMw58ilU0Q,598
+ck_demos/programs/demo_raw_program_dump.py,sha256=A8eNKxK618FxAVnMMMOdvSz_nwZEaDUvuQKoey6w9dA,370
 ck_demos/programs/demo_raw_program_interpreted.py,sha256=iPbGXsj8ZQl4RMIZZBF7oDHEEnAl31kIilQFPcqSA98,528
 ck_demos/programs/demo_raw_program_llvm.py,sha256=a3V85jgyqrCBJpBmfVWpY9Nx5l0WhfvzgIXEdCcxRXA,523
 ck_demos/sampling/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -171,8 +175,8 @@ ck_demos/utils/compare.py,sha256=Bwjpflevl4nusfA0zp96rInaVKFGuhC5Xv7HzA1Fobk,508
 ck_demos/utils/convert_network.py,sha256=TSKj8q7L7J5rhrvwjaDkdYZ0Sg8vV5FRL_vCanX1CQw,1363
 ck_demos/utils/sample_model.py,sha256=in-Nlv-iuNIu6y9fDuMyo7nzgimBuTAnCWcpnVqvqDQ,8839
 ck_demos/utils/stop_watch.py,sha256=VzXHRWx0V8vPSD-bLgLlEYkCkR2FA0-KmM_pfKx-Pxo,13205
-compiled_knowledge-4.0.0a22.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
-compiled_knowledge-4.0.0a22.dist-info/METADATA,sha256=eJdp11Ps62kBb4jFBn6-ROz4TIXeWGBJFDoq49vzO7g,1838
-compiled_knowledge-4.0.0a22.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
-compiled_knowledge-4.0.0a22.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
-compiled_knowledge-4.0.0a22.dist-info/RECORD,,
+compiled_knowledge-4.0.0a23.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
+compiled_knowledge-4.0.0a23.dist-info/METADATA,sha256=OR-iFkTIH02rufAdmjgY7BW_Q5ECJ6ZveWe-jFjK8qI,1838
+compiled_knowledge-4.0.0a23.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
+compiled_knowledge-4.0.0a23.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
+compiled_knowledge-4.0.0a23.dist-info/RECORD,,