compiled-knowledge 4.0.0a10__cp312-cp312-win_amd64.whl → 4.0.0a11__cp312-cp312-win_amd64.whl

ck/circuit/circuit.pyx

@@ -1,3 +1,6 @@
+"""
+For more documentation on this module, refer to the Jupyter notebook docs/6_circuits_and_programs.ipynb.
+"""
 from __future__ import annotations
 
 from itertools import chain
@@ -15,12 +18,15 @@ MUL: int = 1
 
 cdef class Circuit:
     """
-    An arithmetic circuit defining computation based on input variables (VarNode objects)
-    and constant values (ConstNode objects). Computation is defined over a mathematical
-    ring, with two operations: addition (AddNode objects) and multiplication (MulNode objects).
+    An arithmetic circuit defines an arithmetic function from input variables (`VarNode` objects)
+    and constant values (`ConstNode` objects) to one or more result values. Computation is defined
+    over a mathematical ring, with two operations: addition and multiplication (represented
+    by `OpNode` objects).
 
-    An arithmetic circuit cam be directly interpreted, using `ck.circuit_compiler.circuit_interpreter`,
-     or may be compiled to an LLVM JIT, using `ck.circuit_compiler.llvm_compiler`.
+    An arithmetic circuit needs to be compiled to a program to execute the function.
+
+    All nodes belong to a circuit. All nodes are immutable, with the exception that a
+    `VarNode` may be temporarily be set to a constant value.
     """
 
     cdef public list[VarNode] vars

ck/circuit/circuit_py.py

@@ -1,3 +1,9 @@
+"""
+This is a pure Python implementation of Circuits (for testing and development)
+
+For more documentation on this module, refer to the Jupyter notebook docs/6_circuits_and_programs.ipynb.
+"""
+
 from __future__ import annotations
 
 from dataclasses import dataclass, field
@@ -14,12 +20,15 @@ MUL: int = 1
 
 class Circuit:
     """
-    An arithmetic circuit defining computation based on input variables (VarNode objects)
-    and constant values (ConstNode objects). Computation is defined over a mathematical
-    ring, with two operations: addition (AddNode objects) and multiplication (MulNode objects).
+    An arithmetic circuit defines an arithmetic function from input variables (`VarNode` objects)
+    and constant values (`ConstNode` objects) to one or more result values. Computation is defined
+    over a mathematical ring, with two operations: addition and multiplication (represented
+    by `OpNode` objects).
 
-    An arithmetic circuit cam be directly interpreted, using `ck.circuit_compiler.circuit_interpreter`,
-     or may be compiled to an LLVM JIT, using `ck.circuit_compiler.llvm_compiler`.
+    An arithmetic circuit needs to be compiled to a program to execute the function.
+
+    All nodes belong to a circuit. All nodes are immutable, with the exception that a
+    `VarNode` may be temporarily be set to a constant value.
     """
 
     def __init__(self, zero: ConstValue = 0, one: ConstValue = 1):
@@ -352,6 +361,7 @@ class Circuit:
             prefix: str = '',
             indent: str = '  ',
             var_names: Optional[List[str]] = None,
+            include_consts: bool = False,
     ) -> None:
         """
         Print a dump of the Circuit.
@@ -361,6 +371,7 @@ class Circuit:
             prefix: optional prefix for indenting all lines.
             indent: additional prefix to use for extra indentation.
             var_names: optional variable names to show.
+            include_consts: if true, then constant values are dumped.
         """
 
         next_prefix: str = prefix + indent
@@ -374,34 +385,38 @@ class Circuit:
         print(f'{prefix}number of arcs: {self.number_of_arcs:,}')
 
         print(f'{prefix}var nodes: {self.number_of_vars}')
-        for var in self._vars:
+        for var in self.vars:
             node_name[id(var)] = f'var[{var.idx}]'
             var_name: str = '' if var_names is None or var.idx >= len(var_names) else var_names[var.idx]
             if var_name != '':
                 if var.is_const():
-                    print(f'{next_prefix}var[{var.idx}]: {var_name}, const({var.const.value})')
+                    print(f'{next_prefix}var[{var.idx}]: {var_name}, {var.const.value}')
                 else:
                     print(f'{next_prefix}var[{var.idx}]: {var_name}')
             elif var.is_const():
-                print(f'{next_prefix}var[{var.idx}]: const({var.const.value})')
+                print(f'{next_prefix}var[{var.idx}]: {var.const.value}')
+
+        if include_consts:
+            print(f'{prefix}const nodes: {self.number_of_consts}')
+            for const in self._const_map.values():
+                print(f'{next_prefix}{const.value!r}')
 
-        print(f'{prefix}const nodes: {self.number_of_consts}')
+        # Add const nodes to the node_name dict
         for const in self._const_map.values():
-            node_name[id(const)] = str(const.value)
-            print(f'{next_prefix}const({const.value})')
+            node_name[id(const)] = repr(const.value)
 
         # Add op nodes to the node_name dict
-        for i, op in enumerate(self._ops):
-            node_name[id(op)] = f'{op.symbol}<{i}>'
+        for i, op in enumerate(self.ops):
+            node_name[id(op)] = f'{op.op_str()}<{i}>'
 
         print(
             f'{prefix}op nodes: {self.number_of_op_nodes} '
             f'(arcs: {self.number_of_arcs}, ops: {self.number_of_operations})'
         )
-        for op in reversed(self._ops):
+        for op in reversed(self.ops):
             op_name = node_name[id(op)]
             args_str = ' '.join(node_name[id(arg)] for arg in op.args)
-            print(f'{next_prefix}{op_name}\\{len(op.args)}: {args_str}')
+            print(f'{next_prefix}{op_name}: {args_str}')
 
     def _check_nodes(self, nodes: Iterable[Args]) -> Tuple[CircuitNode, ...]:
         """
@@ -585,12 +600,18 @@ class OpNode(CircuitNode):
         self.symbol: int = symbol
 
     def __str__(self) -> str:
+        return f'{self.op_str()}\\{len(self.args)}'
+
+    def op_str(self) -> str:
+        """
+        Returns the op node operation as a string.
+        """
         if self.symbol == MUL:
-            return f'mul\\{len(self.args)}'
+            return 'mul'
         elif self.symbol == ADD:
-            return f'add\\{len(self.args)}'
+            return 'add'
         else:
-            return f'?{self.symbol}\\{len(self.args)}'
+            return '?' + str(self.symbol)
 
 
 @dataclass
@@ -688,7 +709,7 @@ class _DerivativeHelper:
             for value in (self._derivative_prod(prods) for prods in d_node.sum_prod)
             if not value.is_zero()
         )
-        # we can release the temporary memory at this DNode now
+        # We can release the temporary memory at this DNode now
         d_node.sum_prod = None
 
         # Construct the addition operation

ck/pgm.py

@@ -1,80 +1,5 @@
 """
-This module support the in-memory creation of probabilistic graphical models.
-
-A probabilistic graphical model (PGM) represents a joint probability distribution over
-a set of random variables. Specifically, a PGM is a factor graph with discrete random variables.
-
-A random variable is represented by a RandomVariable object. Each random variable has a
-fixed, finite number of states. Many algorithms will assume at least two states.
-Every RandomVariable object belongs to exactly one PGM object. A RandomVariable
-has a name (for human convenience) and its states are indexed by integers, counting
-from zero.
-
-A PGM also has factors. Each Factor of a PGM connects a set of RandomVariable objects
-of the PGM. In general, the order of the random variables of a factor is functionally
-irrelevant, but is practically relevant for operating with Factor objects. The "shape"
-of a factor is the list of the numbers of states of the factor's random variables (co-indexed
-with the list of random variables of the factor).
-
-If a PGM is representing a Bayesian network, then each factor represents a conditional
-probability table (CPT) and the first random variable of the factor is taken to be the child
-random variable, with the remaining random variables being the parents.
-
-Every factor has associated with it a potential function. A potential function maps
-each combination of states of the factor's random variables to a value (of type float).
-A combination of states of random variables is represented as a Key. A Key is essentially
-a list of state indexes, co-indexed with the factor's random variables.
-
-A potential function is a map from all possible keys (according to the potential function's
-shape) to a float value. Each potential function has zero or more "parameters" which may be
-adjusted to change the potential function's mapping. The parameters of a potential function
-are indexed sequentially from zero.
-
-Each parameter of a potential function is associated with one or more keys. The value of the
-parameter is the value of the potential function for it's associated keys. Conversely, each
-key of a potential function is associate with zero or one parameters. That is, it is possible
-that a potential function maps multiple keys to the same parameter, in which case keys that map
-to the same parameter will have the same value.
-
-If a key of a potential function is associated with a parameter, then the value of
-the potential function for that key is the value of the parameter.
-
-If a key of a potential function is associated with zero parameters then the value of
-the potential function for that key is zero. Furthermore, the key is referred to as
-"guaranteed-zero", meaning that no change in the parameter values of the potential function
-will change the value for that key away from zero.
-
-RandomVariable objects are immutable and hashable, including their states.
-
-Factor objects cannot change the random variables they are a factor of. However,
-the PotentialFunction associated with a Factor may be updated.
-
-Factors may share a potential function, so long as they have the same shape.
-
-PotentialFunction objects cannot change their shape, but may be otherwise mutable and
-are generally not hashable. A particular class of potential function may allow its mapping
-to change and even its available parameters to change.
-
-There are many kinds of potential function. A DensePotentialFunction has exactly
-one parameter for each possible key (no 'guaranteed-zero' keys) and there are no
-shared parameters. A SparsePotentialFunction only has parameters for explicitly
-mentioned keys.
-
-There is a special class of potential function called a ZeroPotentialFunction which
-(like DensePotentialFunction) has a parameter for each possible key (and thus no
-key is guaranteed-zero). However, the value of each parameter is zero and there
-is no mechanism to update these values.
-
-A ZeroPotentialFunction is the default PotentialFunction for a Factor. It may be seen
-as a light-weight placeholder until replaced by some other potential function.
-It may also be used as a light-weight surrogate for a DensePotentialFunction when
-performing PGM parameter learning.
-
-Each RandomVariable has an index (`idx`) which is a sequence number, starting from zero,
-indicating when that RandomVariable was added to its PGM.
-
-Each Factor has an  index (`idx`) which is a sequence number, starting from zero,
-indicating when that Factor was added to its PGM.
+For more documentation on this module, refer to the Jupyter notebook docs/4_PGM_advanced.ipynb.
 """
 from __future__ import annotations
 
@@ -2148,6 +2073,8 @@ class DensePotentialFunction(PotentialFunction):
 
     @property
     def params(self) -> Iterable[Tuple[int, float]]:
+        # Type warning due to numpy type erasure
+        # noinspection PyTypeChecker
         return enumerate(self._values)
 
     @property
@@ -2324,9 +2251,12 @@ class DensePotentialFunction(PotentialFunction):
 class SparsePotentialFunction(PotentialFunction):
     """
     A sparse potential function.
-    The default value for each parameter is zero.
-    The user may set the value of any key.
-    Setting the value of a key back to zero does not remove its parameter.
+
+    There is one parameter for each non-zero key value.
+    The user may set the value for any key and parameters will
+    be automatically reconfigured as needed. Setting the value for
+    a key to zero disassociates the key from its parameter and
+    thus makes that key "guaranteed zero".
     """
 
     def __init__(self, factor: Factor):
@@ -2381,7 +2311,7 @@ class SparsePotentialFunction(PotentialFunction):
         """
         Set the potential function value, for a given key.
         
-       If value is zero, then the key will become "guaranteed zero".
+        If value is zero, then the key will become "guaranteed zero".
 
         Arg:
             key: defines an instance in the state space of the potential function.
@@ -2395,7 +2325,7 @@ class SparsePotentialFunction(PotentialFunction):
 
         if param_idx is None:
             if value == 0:
-                # nothing to do
+                # Nothing to do
                 return
             param_idx = len(self._values)
             self._values.append(value)
@@ -2403,11 +2333,16 @@ class SparsePotentialFunction(PotentialFunction):
             return
 
         if value != 0:
-            # simple case
+            # Simple case
             self._values[param_idx] = value
             return
 
-        # Need to clear an existing non-zero parameter.
+        # This is the case where the key was associated with a parameter
+        # but the value is being set to zero, so we
+        # need to clear an existing non-zero parameter.
+        # This code operates by first ensuring the parameter is the last one,
+        # then popping the last parameter.
+
         end: int = len(self._values) - 1
         if param_idx != end:
             # need to swap the parameter with the end.
@@ -2419,7 +2354,7 @@ class SparsePotentialFunction(PotentialFunction):
                     # There will only be one, so we can break now
                     break
 
-        # remove the parameter
+        # Remove the parameter
         self._values.pop()
         self._params.pop(instance)
 
@@ -2568,10 +2503,14 @@ class SparsePotentialFunction(PotentialFunction):
 
 class CompactPotentialFunction(PotentialFunction):
     """
-    A sparse potential function.
-    There is one parameter for each unique, non-zero parameter value.
-    The default value for each parameter is zero.
-    The user may set the value of any key.
+    A compact potential function is sparse, where values for keys of
+    the same value are represented by a single parameter.
+
+    There is one parameter for each unique, non-zero key value.
+    The user may set the value for any key and parameters will
+    be automatically reconfigured as needed. Setting the value for
+    a key to zero disassociates the key from its parameter and
+    thus makes that key "guaranteed zero".
     """
 
     def __init__(self, factor: Factor):
@@ -2799,9 +2738,9 @@ class CompactPotentialFunction(PotentialFunction):
 
     def _remove_param(self, param_idx: int) -> None:
         """
-        Remove the index parameter from self._params and self._counts.
+        Remove the indexed parameter from self._params and self._counts.
         If the parameter is not at the end of the list of parameters
-        then it will be swapped with the end parameter.
+        then it will be swapped with the last parameter in the list.
         """
 
         # ensure the parameter is at the end of the list
@@ -2823,10 +2762,10 @@ class CompactPotentialFunction(PotentialFunction):
 
 class ClausePotentialFunction(PotentialFunction):
     """
-    A clause potential function represents a clause (from a CNF formula) i.e. a disjunction.
-    A clause over variables X, Y, Z, is of the form: 'X=x or Y=y or Z=z'.
+    A clause potential function represents a clause From a CNF formula.
+    I.e. a clause over variables X, Y, Z, is a disjunction of the form: 'X=x or Y=y or Z=z'.
 
-    A clause potential function guaranteed zero for the key where the clause is false,
+    A clause potential function is guaranteed zero for a key where the clause is false,
     i.e., when 'X != x and Y != y and Z != z'.
 
     For keys where the clause is true, the value of the potential function
@@ -3527,6 +3466,7 @@ _CLEAN_CHARS: Set[str] = set('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWX
 def _clean_str(s) -> str:
     """
     Quote a string if empty or not all characters are in _CLEAN_CHARS.
+    This is used when rendering indicators.
     """
     s = str(s)
     if len(s) == 0 or not all(c in _CLEAN_CHARS for c in s):

ck/program/program.py

@@ -1,3 +1,6 @@
+"""
+For more documentation on this module, refer to the Jupyter notebook docs/6_circuits_and_programs.ipynb.
+"""
 from typing import Callable, Sequence
 
 import numpy as np
@@ -8,7 +11,12 @@ from ck.utils.np_extras import DTypeNumeric, NDArrayNumeric
 
 class Program:
     """
-    A Program wraps a RawProgram to make a convenient callable.
+    A program represents an arithmetic a function from input values to output values.
+
+    Internally a `Program` wraps a `RawProgram` which is the object returned by a circuit compiler.
+
+    Every `Program` has a numpy `dtype` which defines the numeric data type for input and output values.
+    Typically, the `dtype` of a program is a C style double.
     """
 
     def __init__(self, raw_program: RawProgram):

ck/program/raw_program.py

@@ -9,8 +9,8 @@ from ck.utils.np_extras import NDArrayNumeric, DTypeNumeric
 
 # RawProgramFunction is a function of three ctypes arrays, returning nothing.
 # Args:
-#     [0]: input parameter values,
-#     [1]: working memory,
+#     [0]: input  values,
+#     [1]: temporary working memory,
 #     [2]: output values.
 RawProgramFunction = Callable[[ct.POINTER, ct.POINTER, ct.POINTER], None]
 
@@ -18,10 +18,16 @@ RawProgramFunction = Callable[[ct.POINTER, ct.POINTER, ct.POINTER], None]
 @dataclass
 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:
+
+
     Fields:
         function: is a function of three ctypes arrays, returning nothing.
         dtype: the numpy data type of  the array values.
-        number_of_vars: the number of input parameter values (first function argument).
+        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

{compiled_knowledge-4.0.0a10.dist-info → compiled_knowledge-4.0.0a11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compiled-knowledge
-Version: 4.0.0a10
+Version: 4.0.0a11
 Summary: A Python package for compiling and querying discrete probabilistic graphical models.
 Author-email: Barry Drake <barry@compiledknowledge.org>
 License-Expression: MIT
@@ -15,17 +15,17 @@ Requires-Dist: llvmlite
 Requires-Dist: numpy
 Dynamic: license-file
 
-CompiledKnowledge
-=================
+Compiled Knowledge
+==================
 
-CompiledKnowledge is a Python package for compiling and querying discrete probabilistic graphical models.
-
-The aim of this repository is:
+Compiled Knowledge is a Python package for compiling and querying discrete probabilistic graphical models.
+The aim of the project is:
   - to provide a Python library for compiling and querying
-    probabilistic graphical models, specifically discrete factor graphs
+    probabilistic graphical models, specifically discrete factor graphs,
+    which includes Bayesian networks
   - to be extremely efficient, flexible, and easy to use
   - to exhibit excellent design, code, and documentation
-  - support researchers and businesses wanting to explore and use 
+  - to support researchers and businesses wanting to explore and use 
     probabilistic artificial intelligence.
 
 License
@@ -37,10 +37,14 @@ MIT license (see the file `LICENSE.txt`).
 More Information
 ================
 
-Refer to the project [online documentation](https://compiled-knowledge.readthedocs.io/).
+Refer to the project online documentation at
+[compiled-knowledge.readthedocs.io](https://compiled-knowledge.readthedocs.io/).
 
-The primary project repository for Compiled Knowledge is https://github.com/ropeless/compiled_knowledge. 
+The primary repository for the project is 
+[github.com/ropeless/compiled_knowledge](https://github.com/ropeless/compiled_knowledge). 
 
-The Python package is available on [PyPi](https://pypi.org/project/compiled-knowledge/).
+The Python package is available on PyPi, see
+[pypi.org/project/compiled-knowledge](https://pypi.org/project/compiled-knowledge/).
 
-For more information email [info@compiledknowledge.org](mailto:info@compiledknowledge.org).
+For more information email
+[info@compiledknowledge.org](mailto:info@compiledknowledge.org).

{compiled_knowledge-4.0.0a10.dist-info → compiled_knowledge-4.0.0a11.dist-info}/RECORD

@@ -1,11 +1,10 @@
 ck/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ck/pgm.py,sha256=PcuoqQyymMvbmUWb62hIe4cly2k28EuF0R4yM-KYBvI,124358
+ck/pgm.py,sha256=rbqgP-clfSvgpzUXxVjk_6SdM9neHmpChku6qpyeidk,120700
 ck/circuit/__init__.py,sha256=tozFNNVzsgQDwFrtGzrgcFS4XTszhgyFmbMGfV5pimc,212
-ck/circuit/circuit.c,sha256=nPXdIXZHyMC25nQ58iPtIpBnUNRwtOtrCxjp8-fv4Yw,1772565
-ck/circuit/circuit.cp312-win_amd64.pyd,sha256=ni89eTKbJVWmXEcMY_YkLDSuIJr3zw53DIq6bwZCfdk,252416
-ck/circuit/circuit.pyx,sha256=H5OIVZS7Ft5K3b-1KPna815JHfwhvoQPQBcvJq3IZCY,27854
+ck/circuit/circuit.cp312-win_amd64.pyd,sha256=InSRSXXMYNc_7RyWOZx_EeRDwboCCyMPLhd8O1vslJ4,252416
+ck/circuit/circuit.pyx,sha256=Y35CZMalySX8_uhNH6wIaZzS6ACn3rh3L99bog1lQx8,28060
 ck/circuit/circuit_node.pyx,sha256=8RuEC1ngYxnsGryzQ1lOEPc4ewTxvKwc56sOxWLB9zs,4103
-ck/circuit/circuit_py.py,sha256=Y4g3vf3l1_3zS1g52b5Fi9F-4DupiZTeF8yiYiKz6Vc,27507
+ck/circuit/circuit_py.py,sha256=_k8H1yZsfp2vERkX_CIo8VxxOf1ICw2zL8i2ckoaSlE,28127
 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
@@ -14,8 +13,7 @@ ck/circuit_compiler/llvm_compiler.py,sha256=ejeNPkO5Og2FyjjyA5JAexxUl1f8IJ6mwU5N
 ck/circuit_compiler/llvm_vm_compiler.py,sha256=I46_XV5FrClDKO06zIjn8T3ME5XQ9RYJ_1aAE8e_YzM,21873
 ck/circuit_compiler/named_circuit_compilers.py,sha256=Fsk2HANYhw25uxAdOo5-7aSnVZxlPgsaPz9wO_1YdRg,2400
 ck/circuit_compiler/cython_vm_compiler/__init__.py,sha256=pEAwTleuZgdYhTAQMea2f9YsFK54eoNbZSbrWkW8aeE,49
-ck/circuit_compiler/cython_vm_compiler/_compiler.c,sha256=xpYybtj-aRcMJV1oKkB-p0kciZVW3gLRd0OJBfDg3sc,757006
-ck/circuit_compiler/cython_vm_compiler/_compiler.cp312-win_amd64.pyd,sha256=S3nPwu09dARS8GrKmr_KtA-EHH5MD0ioAnyZ-cqf0q4,92160
+ck/circuit_compiler/cython_vm_compiler/_compiler.cp312-win_amd64.pyd,sha256=nsx6Nz3p2P83RAvHORCxvdGHC8RaSRGbQhzg1bb6Dug,92160
 ck/circuit_compiler/cython_vm_compiler/_compiler.pyx,sha256=hHuNo99TbodNpWgQwQ8qzW1cTwGXZj5SW0tKAo9u6cw,7718
 ck/circuit_compiler/cython_vm_compiler/cython_vm_compiler.py,sha256=yUkBNr5HnoVXyWjJdXHp8lyAXFiIDYapvMvHtzKuhI8,3140
 ck/circuit_compiler/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -87,8 +85,7 @@ ck/pgm_compiler/support/factor_tables.py,sha256=LAZbWtDVyTpxps7C4d3q38uUVkNnzRBO
 ck/pgm_compiler/support/join_tree.py,sha256=tRHev655cwRsOSyLK9HYwfX8EEkubmlg1fw748Kztb4,10418
 ck/pgm_compiler/support/named_compiler_maker.py,sha256=tQ79JOI8MknAziUiFhFGV9n4y6PPKrnbq3-quMmnrwY,974
 ck/pgm_compiler/support/circuit_table/__init__.py,sha256=eWMP5ywgd51RJexKkhcpKJb_8iEluL0C4_hyOpzlAvQ,167
-ck/pgm_compiler/support/circuit_table/circuit_table.c,sha256=aO3bq3V-FwbmJDzWVYwigOFeQUC6gFz-nAq091XQp2E,702527
-ck/pgm_compiler/support/circuit_table/circuit_table.cp312-win_amd64.pyd,sha256=TPzAAETE8QIjRp6yReo9YlNczibIBFQ6mu7KlTzUeXE,94720
+ck/pgm_compiler/support/circuit_table/circuit_table.cp312-win_amd64.pyd,sha256=7Yc_Iqes51f7Q6lPyc2M1ysXeES0T8TkZaOf2ZbQoEc,94720
 ck/pgm_compiler/support/circuit_table/circuit_table.pyx,sha256=jhzstay-3EUgu0CIbWKd0eNDNToX1tmm9IQxk0ZgpYM,11904
 ck/pgm_compiler/support/circuit_table/circuit_table_py.py,sha256=1WFCxgBFu4oaYRCdk_1uXeufFQu6PqMOsYIQ_SkXDS4,10156
 ck/probability/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -96,9 +93,9 @@ ck/probability/empirical_probability_space.py,sha256=HoLxmigzlWFWQlcZQwDOYk-mjgf
 ck/probability/pgm_probability_space.py,sha256=vK-drx145PWW2aYB8HttQcvhvqPfxVl72bPcFO8jw8M,1034
 ck/probability/probability_space.py,sha256=itv3dNEpSTLhKg6JCNhe7Iy6n9MKWqeKO4RxKR9kKF0,25882
 ck/program/__init__.py,sha256=Ss9-0eqsGxCGloD6liH-0iqBG5Q3vPRF4XCw2hkDJ0M,110
-ck/program/program.py,sha256=ONeKhhMtgkaMtcgC-DDRUqId9ATgqnFD0ovt1t2nqrM,3773
+ck/program/program.py,sha256=gDJ5Q2kXZuaoHboa9yNTg0tQH9S-Gmw0BRx6PPV28pU,4184
 ck/program/program_buffer.py,sha256=1fiUcT7sqyr4vu8jXzK3ZsrgURFhWMdm6hr2BeS9ONA,5665
-ck/program/raw_program.py,sha256=7LbGGd-CtGxc-HTWnk1_-D4UBlTErax7MSYVfRQz8V0,2447
+ck/program/raw_program.py,sha256=1HA7k4V34LQg_KgYWs6XewHrtNiTRuL-ejNnki7oTho,2626
 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
@@ -165,8 +162,8 @@ ck_demos/utils/compare.py,sha256=eC1rJXuWQhEfq4yQlXggn2O_sk-xAVEn6PpVuIaZJoo,344
 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.0a10.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
-compiled_knowledge-4.0.0a10.dist-info/METADATA,sha256=olz_v2tXOkTcuQGPYBnSiaDyGS_N7sja-guy1p2onDE,1689
-compiled_knowledge-4.0.0a10.dist-info/WHEEL,sha256=b7PoVIxzH_MOHKjftqMzQiGKfdHRlRFepVBVPg0y3vc,101
-compiled_knowledge-4.0.0a10.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
-compiled_knowledge-4.0.0a10.dist-info/RECORD,,
+compiled_knowledge-4.0.0a11.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
+compiled_knowledge-4.0.0a11.dist-info/METADATA,sha256=BwJQwg7IB8iA7mXWDo2aPDyWXz7jbfyZoUNJ2vNaXUM,1838
+compiled_knowledge-4.0.0a11.dist-info/WHEEL,sha256=b7PoVIxzH_MOHKjftqMzQiGKfdHRlRFepVBVPg0y3vc,101
+compiled_knowledge-4.0.0a11.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
+compiled_knowledge-4.0.0a11.dist-info/RECORD,,