compiled-knowledge 4.0.0a17__cp312-cp312-win_amd64.whl → 4.0.0a19__cp312-cp312-win_amd64.whl

ck/pgm_compiler/support/circuit_table/_circuit_table_cy.pyx

@@ -1,8 +1,14 @@
 from __future__ import annotations
 
-from typing import Sequence, Tuple, Iterable, Iterator
+from typing import Sequence, Tuple, Iterable
+
+from ck.circuit import MUL, ADD
+
+from ck.circuit._circuit_cy cimport Circuit, CircuitNode
+
+cdef int c_ADD = ADD
+cdef int c_MUL = MUL
 
-from ck.circuit import CircuitNode, Circuit, OpNode, MUL
 
 TableInstance = Tuple[int, ...]
 
@@ -22,14 +28,14 @@ cdef class CircuitTable:
     zero node. These are assumed to be optimised out already.
     """
 
-    cdef public object circuit
+    cdef public Circuit circuit
     cdef public tuple[int, ...] rv_idxs
-    cdef public dict[tuple[int, ...], CircuitNode] rows
+    cdef dict[tuple[int, ...], CircuitNode] rows
 
     def __init__(
             self,
             circuit: Circuit,
-            rv_idxs: Sequence[int, ...],
+            rv_idxs: Sequence[int],
             rows: Iterable[Tuple[TableInstance, CircuitNode]] = (),
     ):
         """
@@ -53,13 +59,19 @@ cdef class CircuitTable:
     def get(self, key, default=None):
         return self.rows.get(key, default)
 
+    def keys(self) -> Iterable[CircuitNode]:
+        return self.rows.keys()
+
+    def values(self) -> Iterable[tuple[int, ...]]:
+        return self.rows.values()
+
     def __getitem__(self, key):
         return self.rows[key]
 
     def __setitem__(self, key, value):
         self.rows[key] = value
 
-    cpdef object top(self):  # -> CircuitNode:
+    cpdef CircuitNode top(self):
         # Get the circuit top value.
         #
         # Raises:
@@ -80,7 +92,7 @@ cdef class CircuitTable:
 #  Circuit Table Operations
 # ==================================================================================
 
-cpdef object sum_out(object table: CircuitTable, object rv_idxs: Iterable[int]):  # -> CircuitTable:
+cpdef CircuitTable sum_out(CircuitTable table, object rv_idxs: Iterable[int]):
     # Return a circuit table that results from summing out
     # the given random variables of this circuit table.
     #
@@ -118,12 +130,12 @@ cpdef object sum_out(object table: CircuitTable, object rv_idxs: Iterable[int]):
     for rv_index in remaining_rv_idxs:
         index_map.append(_find(table.rv_idxs, rv_index))
 
-    cdef dict[tuple[int, ...], list[object]] groups = {}
+    cdef dict[tuple[int, ...], list[CircuitNode]] groups = {}
     cdef object got
     cdef list[int] group_instance
     cdef tuple[int, ...] group_instance_tuple
     cdef int i
-    cdef object node
+    cdef CircuitNode node
     cdef tuple[int, ...] instance
     for instance, node in table.rows.items():
         group_instance = []
@@ -136,19 +148,19 @@ cpdef object sum_out(object table: CircuitTable, object rv_idxs: Iterable[int]):
         else:
             got.append(node)
 
-    cdef object circuit = table.circuit
-    cdef object new_table = CircuitTable(circuit, remaining_rv_idxs)
-    cdef dict[tuple[int, ...], object] rows = new_table.rows
+    cdef Circuit circuit = table.circuit
+    cdef CircuitTable new_table = CircuitTable(circuit, remaining_rv_idxs)
+    cdef dict[tuple[int, ...], CircuitNode] rows = new_table.rows
 
     for group_instance_tuple, to_add in groups.items():
-        node = circuit.optimised_add(to_add)
+        node = circuit.op(c_ADD, tuple(to_add))
         if not node.is_zero:
             rows[group_instance_tuple] = node
 
     return new_table
 
 
-cpdef object sum_out_all(object table: CircuitTable):  # -> CircuitTable:
+cpdef CircuitTable sum_out_all(CircuitTable table):
     # Return a circuit table that results from summing out
     # all random variables of this circuit table.
     circuit: Circuit = table.circuit
@@ -158,14 +170,14 @@ cpdef object sum_out_all(object table: CircuitTable):  # -> CircuitTable:
     elif num_rows == 1:
         node = next(iter(table.rows.values()))
     else:
-        node: CircuitNode = circuit.optimised_add(table.rows.values())
+        node: CircuitNode = circuit.op(c_ADD, tuple(table.rows.values()))
         if node.is_zero:
             return CircuitTable(circuit, ())
 
     return CircuitTable(circuit, (), [((), node)])
 
 
-cpdef object project(object table: CircuitTable, object rv_idxs: Iterable[int]):  # -> CircuitTable:
+cpdef CircuitTable project(CircuitTable table: CircuitTable, object rv_idxs: Iterable[int]):
     # Call `sum_out(table, to_sum_out)`, where
     # `to_sum_out = table.rv_idxs - rv_idxs`.
     cdef set[int] to_sum_out = set(table.rv_idxs)
@@ -173,13 +185,13 @@ cpdef object project(object table: CircuitTable, object rv_idxs: Iterable[int]):
     return sum_out(table, to_sum_out)
 
 
-cpdef object product(x: CircuitTable, y: CircuitTable):  # -> CircuitTable:
+cpdef CircuitTable product(CircuitTable x, CircuitTable y):
     # Return a circuit table that results from the product of the two given tables.
     #
     # If x or y equals `one_table`, then the other table is returned. Otherwise,
     # a new circuit table will be constructed and returned.
     cdef int i
-    cdef object circuit = x.circuit
+    cdef Circuit circuit = x.circuit
     if y.circuit is not circuit:
         raise ValueError('circuit tables must refer to the same circuit')
 
@@ -229,12 +241,12 @@ cpdef object product(x: CircuitTable, y: CircuitTable):  # -> CircuitTable:
     cdef tuple[int, ...] co_tuple
     cdef tuple[int, ...] yo_tuple
 
-    cdef object table = CircuitTable(circuit, x.rv_idxs + yo_rv_idxs)
-    cdef dict[tuple[int, ...], object] rows = table.rows
+    cdef CircuitTable table = CircuitTable(circuit, x.rv_idxs + yo_rv_idxs)
+    cdef dict[tuple[int, ...], CircuitNode] rows = table.rows
 
 
     # Index the y rows by common-only key (y is the smaller of the two tables).
-    cdef dict[tuple[int, ...], list[tuple[tuple[int, ...], object]]] y_index = {}
+    cdef dict[tuple[int, ...], list[tuple[tuple[int, ...], CircuitNode]]] y_index = {}
     for y_instance, y_node in y.rows.items():
         co = []
         yo = []
@@ -271,7 +283,10 @@ cpdef object product(x: CircuitTable, y: CircuitTable):  # -> CircuitTable:
             got = y_index.get(co_tuple)
             if got is not None:
                 for yo_tuple, y_node in got:
-                    rows[x_instance + yo_tuple] = _optimised_mul(circuit, x_node, y_node)
+                    if y_node.is_one:
+                        rows[x_instance + yo_tuple] = x_node
+                    else:
+                        rows[x_instance + yo_tuple] = circuit.op(c_MUL, (x_node, y_node))
 
     return table
 
@@ -285,7 +300,7 @@ cdef int _find(tuple[int, ...] xs, int x):
     raise RuntimeError('not found')
 
 
-cdef object _product_no_common_rvs(x: CircuitTable, y: CircuitTable):  # -> CircuitTable:
+cdef CircuitTable _product_no_common_rvs(CircuitTable x, CircuitTable y):
     # Return the product of x and y, where x and y have no common random variables.
     #
     # This is an optimisation of more general product algorithm as no index needs
@@ -296,8 +311,8 @@ cdef object _product_no_common_rvs(x: CircuitTable, y: CircuitTable):  # -> Circ
     # Assumes:
     #     * There are no common random variables between x and y.
     #     * x and y are for the same circuit.
-    cdef object circuit = x.circuit
-    cdef object table = CircuitTable(circuit, x.rv_idxs + y.rv_idxs)
+    cdef Circuit circuit = x.circuit
+    cdef CircuitTable table = CircuitTable(circuit, x.rv_idxs + y.rv_idxs)
     cdef tuple[int, ...] instance
 
     for x_instance, x_node in x.rows.items():
@@ -308,18 +323,10 @@ cdef object _product_no_common_rvs(x: CircuitTable, y: CircuitTable):  # -> Circ
         else:
             for y_instance, y_node in y.rows.items():
                 instance = x_instance + y_instance
-                table.rows[instance] = _optimised_mul(circuit, x_node, y_node)
+                if y_node.is_one:
+                    table.rows[instance] = x_node
+                else:
+                    table.rows[instance] = circuit.op(c_MUL, (x_node, y_node))
 
     return table
 
-
-cdef object _optimised_mul(object circuit: Circuit, object x: CircuitNode, object y: CircuitNode):  # -> CircuitNode
-    if x.is_zero:
-        return x
-    if y.is_zero:
-        return y
-    if x.is_one:
-        return y
-    if y.is_one:
-        return x
-    return circuit.mul(x, y)

ck/pgm_compiler/support/circuit_table/_circuit_table_py.py

@@ -40,21 +40,38 @@ class CircuitTable:
             * all row instances conform to the indexed random variables.
             * all row circuit nodes belong to the given circuit.
         """
-        self.circuit: Circuit = circuit
-        self.rv_idxs: Tuple[int, ...] = tuple(rv_idxs)
-        self.rows: Dict[TableInstance, CircuitNode] = dict(rows)
+        self._circuit: Circuit = circuit
+        self._rv_idxs: Tuple[int, ...] = tuple(rv_idxs)
+        self._rows: Dict[TableInstance, CircuitNode] = dict(rows)
+
+    @property
+    def circuit(self) -> Circuit:
+        return self._circuit
+
+    @property
+    def rv_idxs(self) -> Tuple[int, ...]:
+        return self._rv_idxs
 
     def __len__(self) -> int:
-        return len(self.rows)
+        return len(self._rows)
 
     def get(self, key, default=None):
-        return self.rows.get(key, default)
+        return self._rows.get(key, default)
+
+    def keys(self) -> Iterable[TableInstance]:
+        return self._rows.keys()
+
+    def values(self) -> Iterable[CircuitNode]:
+        return self._rows.values()
+
+    def items(self) -> Iterable[Tuple[TableInstance, CircuitNode]]:
+        return self._rows.items()
 
     def __getitem__(self, key):
-        return self.rows[key]
+        return self._rows[key]
 
     def __setitem__(self, key, value):
-        self.rows[key] = value
+        self._rows[key] = value
 
     def top(self) -> CircuitNode:
         """
@@ -66,10 +83,10 @@ class CircuitTable:
         Returns:
             A single circuit node.
         """
-        if len(self.rows) == 0:
-            return self.circuit.zero
-        elif len(self.rows) == 1:
-            return next(iter(self.rows.values()))
+        if len(self._rows) == 0:
+            return self._circuit.zero
+        elif len(self._rows) == 1:
+            return next(iter(self._rows.values()))
         else:
             raise RuntimeError('cannot get top node from a table with more that 1 row')
 
@@ -119,20 +136,34 @@ def sum_out(table: CircuitTable, rv_idxs: Iterable[int]) -> CircuitTable:
         for remaining_rv_index in remaining_rv_idxs
     )
 
+    # This is a one-pass version to sum the groups. The
+    # two-pass version (below) seems to have better performance.
+    #
+    # circuit: Circuit = table.circuit
+    # result = CircuitTable(circuit, remaining_rv_idxs)
+    # result_rows: Dict[TableInstance, CircuitNode] = result._rows
+    # for instance, node in table.items():
+    #     group_instance = tuple(instance[i] for i in index_map)
+    #     prev_sum = result_rows.get(group_instance)
+    #     if prev_sum is None:
+    #         result_rows[group_instance] = node
+    #     else:
+    #         result_rows[group_instance] = circuit.add(prev_sum, node)
+    # return result
+
     groups: MapList[TableInstance, CircuitNode] = MapList()
-    for instance, node in table.rows.items():
+    for instance, node in table.items():
         group_instance = tuple(instance[i] for i in index_map)
         groups.append(group_instance, node)
-
     circuit: Circuit = table.circuit
-
-    def _result_rows() -> Iterator[Tuple[TableInstance, CircuitNode]]:
-        for group, to_add in groups.items():
-            _node: CircuitNode = circuit.optimised_add(to_add)
-            if not _node.is_zero:
-                yield group, _node
-
-    return CircuitTable(circuit, remaining_rv_idxs, _result_rows())
+    return CircuitTable(
+        circuit,
+        remaining_rv_idxs,
+        (
+            (group, circuit.add(to_add))
+            for group, to_add in groups.items()
+        )
+    )
 
 
 def sum_out_all(table: CircuitTable) -> CircuitTable:
@@ -145,9 +176,9 @@ def sum_out_all(table: CircuitTable) -> CircuitTable:
     if num_rows == 0:
         return CircuitTable(circuit, ())
     elif num_rows == 1:
-        node = next(iter(table.rows.values()))
+        node = next(iter(table.values()))
     else:
-        node: CircuitNode = circuit.optimised_add(table.rows.values())
+        node: CircuitNode = circuit.optimised_add(table.values())
         if node.is_zero:
             return CircuitTable(circuit, ())
 
@@ -168,7 +199,7 @@ def product(x: CircuitTable, y: CircuitTable) -> CircuitTable:
     """
     Return a circuit table that results from the product of the two given tables.
 
-    If x or y equals `one_table`, then the other table is returned. Otherwise,
+    If x or y have a single row with value 1, then the other table is returned. Otherwise,
     a new circuit table will be constructed and returned.
     """
     circuit: Circuit = x.circuit
@@ -193,18 +224,18 @@ def product(x: CircuitTable, y: CircuitTable) -> CircuitTable:
     # Set operations on rv indexes. After these operations:
     # * co_rv_idxs is the set of rv indexes common (co) to x and y,
     # * yo_rv_idxs is the set of rv indexes in y only (yo), and not in x.
-    yo_rv_idxs: Set[int] = set(y_rv_idxs)
-    co_rv_idxs: Set[int] = set(x_rv_idxs)
-    co_rv_idxs.intersection_update(yo_rv_idxs)
-    yo_rv_idxs.difference_update(co_rv_idxs)
+    yo_rv_idxs_set: Set[int] = set(y_rv_idxs)
+    co_rv_idxs_set: Set[int] = set(x_rv_idxs)
+    co_rv_idxs_set.intersection_update(yo_rv_idxs_set)
+    yo_rv_idxs_set.difference_update(co_rv_idxs_set)
 
-    if len(co_rv_idxs) == 0:
+    if len(co_rv_idxs_set) == 0:
         # Special case: no common random variables.
         return _product_no_common_rvs(x, y)
 
     # Convert random variable index sets to sequences
-    yo_rv_idxs: Tuple[int, ...] = tuple(yo_rv_idxs)  # y only random variables
-    co_rv_idxs: Tuple[int, ...] = tuple(co_rv_idxs)  # common random variables
+    yo_rv_idxs: Tuple[int, ...] = tuple(yo_rv_idxs_set)  # y only random variables
+    co_rv_idxs: Tuple[int, ...] = tuple(co_rv_idxs_set)  # common random variables
 
     # Cache mappings from result Instance to index into source Instance (x or y).
     # This will be used in indexing and product loops to pull our needed values
@@ -215,7 +246,7 @@ def product(x: CircuitTable, y: CircuitTable) -> CircuitTable:
 
     # Index the y rows by common-only key (y is the smaller of the two tables).
     y_index: MapList[TableInstance, Tuple[TableInstance, CircuitNode]] = MapList()
-    for y_instance, y_node in y.rows.items():
+    for y_instance, y_node in y.items():
         co = tuple(y_instance[i] for i in co_from_y_map)
         yo = tuple(y_instance[i] for i in yo_from_y_map)
         y_index.append(co, (yo, y_node))
@@ -223,7 +254,7 @@ def product(x: CircuitTable, y: CircuitTable) -> CircuitTable:
     def _result_rows() -> Iterator[Tuple[TableInstance, CircuitNode]]:
         # Iterate over x rows, yielding (instance, value).
         # Rows with constant node values of one are optimised out.
-        for _x_instance, _x_node in x.rows.items():
+        for _x_instance, _x_node in x.items():
             _co = tuple(_x_instance[i] for i in co_from_x_map)
             if _x_node.is_one:
                 # Multiplying by one.
@@ -233,7 +264,10 @@ def product(x: CircuitTable, y: CircuitTable) -> CircuitTable:
             else:
                 # Iterate over matching y rows.
                 for _yo, _y_node in y_index.get(_co, ()):
-                    yield _x_instance + _yo, circuit.optimised_mul((_x_node, _y_node))
+                    if _y_node.is_one:
+                        yield _x_instance + _yo, _x_node
+                    else:
+                        yield _x_instance + _yo, circuit.mul(_x_node, _y_node)
 
     return CircuitTable(circuit, x_rv_idxs + yo_rv_idxs, _result_rows())
 
@@ -256,14 +290,15 @@ def _product_no_common_rvs(x: CircuitTable, y: CircuitTable) -> CircuitTable:
     result_rv_idxs: Tuple[int, ...] = x.rv_idxs + y.rv_idxs
 
     def _result_rows() -> Iterator[Tuple[TableInstance, CircuitNode]]:
-        for x_instance, x_node in x.rows.items():
+        for x_instance, x_node in x.items():
             if x_node.is_one:
-                for y_instance, y_node in y.rows.items():
-                    instance = x_instance + y_instance
-                    yield instance, y_node
+                for y_instance, y_node in y.items():
+                    yield x_instance + y_instance, y_node
             else:
-                for y_instance, y_node in y.rows.items():
-                    instance = x_instance + y_instance
-                    yield instance, circuit.optimised_mul((x_node, y_node))
+                for y_instance, y_node in y.items():
+                    if y_node.is_one:
+                        yield x_instance + y_instance, y_node
+                    else:
+                        yield x_instance + y_instance, circuit.mul(x_node, y_node)
 
     return CircuitTable(circuit, result_rv_idxs, _result_rows())

ck/pgm_compiler/support/named_compiler_maker.py

@@ -12,6 +12,7 @@ def get_compiler(module: ModuleType, **kwargs) -> Tuple[PGMCompiler]:
 
     Args:
         module: module containing `compile_pgm` function.
+        kwargs: are additional keyword arguments to `compile_pgm`.
 
     Returns:
         a singleton tuple containing PGMCompiler function.
@@ -24,10 +25,19 @@ def get_compiler(module: ModuleType, **kwargs) -> Tuple[PGMCompiler]:
     return compiler,
 
 
-def get_compiler_algorithm(module, algorithm: str, **kwargs) -> Tuple[PGMCompiler]:
+def get_compiler_algorithm(module: ModuleType, algorithm: str, **kwargs) -> Tuple[PGMCompiler]:
     """
     Helper function to create a named PGM compiler, with a named algorithm argument.
+
+    Args:
+        module: module containing `compile_pgm` function.
+        algorithm: name of the algorithm, to pass as keyword argument to `compile_pgm`.
+            The algorithm should be declared in the module.
+        kwargs: are additional keyword arguments to `compile_pgm`.
+
+    Returns:
+        a singleton tuple containing PGMCompiler function.
     """
-    return get_compiler(module, algorithm=getattr(module, algorithm, **kwargs))
+    return get_compiler(module, algorithm=getattr(module, algorithm), **kwargs)
 
 

ck/utils/iter_extras.py

@@ -2,7 +2,7 @@
 A module with extra iteration functions.
 """
 from functools import reduce as _reduce
-from itertools import combinations, chain
+from itertools import combinations, chain, islice
 from operator import mul as _mul
 from typing import Iterable, Tuple, Sequence, TypeVar
 
@@ -154,3 +154,10 @@ def first(items: Iterable[_T]) -> _T:
     Return the first element of the iterable.
     """
     return next(iter(items))
+
+
+def take(iterable: Iterable[_T], n: int) -> Iterable[_T]:
+    """
+    Take the first n elements of the iterable.
+    """
+    return islice(iterable, n)

ck_demos/ace/demo_ace.py

@@ -6,6 +6,11 @@ from ck.pgm_circuit.wmc_program import WMCProgram
 
 
 def main() -> None:
+
+    if not ace.ace_available():
+        print("ACE is not available")
+        exit(1)
+
     pgm: PGM = example.Rain()
 
     # `ace.compile_pgm` will look for an Ace installation in

ck_demos/utils/compare.py

@@ -1,3 +1,4 @@
+import gc
 from typing import Sequence
 
 from ck.circuit_compiler import NamedCircuitCompiler
@@ -88,6 +89,7 @@ def compare(
                         print(f'{"":{col_cct_ops}}', end=sep)
                         print(f'{"":{col_pgm_compile_time}}', end=sep)
                     else:
+                        gc.collect()
                         time.start()
                         pgm_cct: PGMCircuit = pgm_compiler(pgm)
                         time.stop()
@@ -97,6 +99,7 @@ def compare(
                         prev_pgm = pgm
                         prev_pgm_compiler = pgm_compiler
 
+                    gc.collect()
                     time.start()
                     # `pgm_cct` will always be set but the IDE can't work that out.
                     # noinspection PyUnboundLocalVariable
@@ -104,11 +107,12 @@ def compare(
                     time.stop()
                     print(f'{time.seconds():{col_cct_compile_time}{comma}.3f}', end=sep)
 
+                    gc.collect()
                     time.start()
                     for _ in range(1000):
                         wmc.compute()
                     time.stop()
-                    print(f'{time.seconds() * 1000:{col_execute_time}{comma}.3f}', end=sep)
+                    print(f'{time.seconds() * 1000:{col_execute_time}{comma}.3f}', end='')
                 except Exception as err:
                     print(repr(err), end='')
                 print()

{compiled_knowledge-4.0.0a17.dist-info → compiled_knowledge-4.0.0a19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compiled-knowledge
-Version: 4.0.0a17
+Version: 4.0.0a19
 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.0a17.dist-info → compiled_knowledge-4.0.0a19.dist-info}/RECORD

@@ -1,9 +1,10 @@
 ck/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/pgm.py,sha256=rbqgP-clfSvgpzUXxVjk_6SdM9neHmpChku6qpyeidk,120700
-ck/circuit/__init__.py,sha256=pMe0M2WI0A1Kr8TCty82oRKrHnDeTjL1rr0Wy03shY0,217
-ck/circuit/_circuit_cy.cp312-win_amd64.pyd,sha256=Pyd-NonuBw-XvnguxnsZBqf3P4O1W9Tdlt3T4p4OWG4,248320
-ck/circuit/_circuit_cy.pyx,sha256=wFu81taNG3M-SLJivhVoJwZVX_50eHyBVduIx5vtHFw,28453
-ck/circuit/_circuit_py.py,sha256=9C-5PuKEnU8eTgdCZysTAsbvHDOLTcsSjzcXdIHH-Ow,28339
+ck/circuit/__init__.py,sha256=klUR7OVESf53-8Ho4f32clHFsR2SOz4XgwZzfDlms88,418
+ck/circuit/_circuit_cy.cp312-win_amd64.pyd,sha256=i4-iiLDcHW_9qU6aXtmYLF-eLd48LKP2XY4EUkLqa0Q,240640
+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/tmp_const.py,sha256=dG9FuGfoAG5qjYG1rNwekqKiea_KmVfxHMTOgCPbBiQ,2372
 ck/circuit_compiler/__init__.py,sha256=T0Igyp5jPgnIXv4oRcIYhmsOdcNOb3L4Za6dK6eYk7g,132
 ck/circuit_compiler/circuit_compiler.py,sha256=8BLB8DUnPbpl5PXZsIopydPbItytdn2rzRfM2U1EC84,1018
@@ -12,14 +13,16 @@ 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=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=nL6nPNrlx6RfmGeK7ZFgw38PMrs7n4w0KFBV9ba_zcU,722307
-ck/circuit_compiler/cython_vm_compiler/_compiler.cp312-win_amd64.pyd,sha256=JK43LQ7GVu7P_Lx5xO7-qdKi0z9baTTSthYg0Ra8XEQ,81920
-ck/circuit_compiler/cython_vm_compiler/_compiler.pyx,sha256=c9NVKWtL2ctY_ja5MZg74hgw8hKKztLi7FB6S1kLTe4,8542
-ck/circuit_compiler/cython_vm_compiler/cython_vm_compiler.py,sha256=yUkBNr5HnoVXyWjJdXHp8lyAXFiIDYapvMvHtzKuhI8,3140
+ck/circuit_compiler/cython_vm_compiler/_compiler.cp312-win_amd64.pyd,sha256=WWvN7NHOri3UnBebI5Qq-lkYZyY_ZUH2lyOWzhlz3Yc,101376
+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/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ck/circuit_compiler/support/circuit_analyser.py,sha256=jM0QW2flucvpc6fqcT8mL00ZA0rPTUhaE-yFfFQMXgE,2722
 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/circuit_analyser/__init__.py,sha256=RbyIObAAb-w0Ky4fB198xAfxTh2doquN9ez68SZSZgo,536
+ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.cp312-win_amd64.pyd,sha256=HHml4RcdmX8c3XesRgch1KhLs8tVeA18ENOhT6zBpmk,53248
+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
 ck/example/alarm.py,sha256=QkHoUb6MxZzCOCX4nLE8UJazNEqAPqrFWQ01lslvdsk,25274
 ck/example/asia.py,sha256=IX8L-9YCk_DxE-PjYTv1VL33V2oxkHrL7rHmDkMj3kY,1295
@@ -77,17 +80,17 @@ ck/pgm_compiler/named_pgm_compilers.py,sha256=kYMomYlsW7xbL0hzTWQb41EckkugaCfuYH
 ck/pgm_compiler/pgm_compiler.py,sha256=F44PtlwqMG0FS6KzOYKZuyZT6olWAVtBH-QXZPzz4O8,616
 ck/pgm_compiler/recursive_conditioning.py,sha256=U0NdIns8yLQtYR_MOf1w__CChpOMDlgRCL2nFRhtnzU,7936
 ck/pgm_compiler/variable_elimination.py,sha256=irAZ5b0vRGL_WGq7UrfQpMXhYBZO5YI2U_jf1-YV92Q,3547
-ck/pgm_compiler/ace/__init__.py,sha256=BkZXAF32Pk8QU7jhkuKvHqtsFasPjf8gxiZbyrGDDbQ,82
+ck/pgm_compiler/ace/__init__.py,sha256=Rud883H68yz2Dw-NkiiTPC6rmii6hHKMHbtiU6_liug,97
 ck/pgm_compiler/ace/ace.py,sha256=iyDacqArXW1cVP6tBabxRmmLWIHabuPkCoq2tWBm2ww,10397
 ck/pgm_compiler/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/pgm_compiler/support/clusters.py,sha256=7jsZfPqv29vZNxmtiHBCBo3mEfvLQ_ejYh69M_d-nmo,21381
 ck/pgm_compiler/support/factor_tables.py,sha256=tV9qE2zC8iwEQxTuXE6qiE6lmMpz4-Vc80_w5woo1tk,15556
 ck/pgm_compiler/support/join_tree.py,sha256=OGAuZVHzT0i4e6TJ03dOM7e3gbpuW9AyjZKvSBvKvJA,12894
-ck/pgm_compiler/support/named_compiler_maker.py,sha256=tQ79JOI8MknAziUiFhFGV9n4y6PPKrnbq3-quMmnrwY,974
-ck/pgm_compiler/support/circuit_table/__init__.py,sha256=V_hwJxsHqGucmE1k1VYg6QGzB9zJeaFBc2LBUyof3dk,172
-ck/pgm_compiler/support/circuit_table/_circuit_table_cy.cp312-win_amd64.pyd,sha256=m3OToh7KVIuOSxII_D0bbbDlnpUZ4bqjTOu9IoPH-DY,94720
-ck/pgm_compiler/support/circuit_table/_circuit_table_cy.pyx,sha256=JLC4_nsRPb8xC3alHE0G9Ojie9K4oUULVPrulkQnhds,11886
-ck/pgm_compiler/support/circuit_table/_circuit_table_py.py,sha256=Dr6R4BU_UGlDZYYq3jOlEdIwk_OilExaurSznIeajls,10146
+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.cp312-win_amd64.pyd,sha256=1hTK-DgCHmIsqsGw4fD-le9zLM5Z93k9plAKlF8KtpE,93696
+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
 ck/probability/empirical_probability_space.py,sha256=HoLxmigzlWFWQlcZQwDOYk-mjgf6RW1IPE-l0t8vMPw,1950
 ck/probability/pgm_probability_space.py,sha256=vK-drx145PWW2aYB8HttQcvhvqPfxVl72bPcFO8jw8M,1034
@@ -107,7 +110,7 @@ ck/sampling/wmc_gibbs_sampler.py,sha256=GMKVW2AVtsWtP6vxE3Y2dy-dKr7GoO_vLEA9eC30
 ck/sampling/wmc_metropolis_sampler.py,sha256=PRv7wtPZz7BcwN8iArsykVwqgY77v5km7rXcawFAUPQ,6470
 ck/sampling/wmc_rejection_sampler.py,sha256=cd0VONZf-oa491RRKfwT2LakQs0o_slgPCes8AOvSNc,4897
 ck/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ck/utils/iter_extras.py,sha256=DDml5Jprmun2RovJxkwXx1uJkWacYhZEnX1ARSX2TB4,4310
+ck/utils/iter_extras.py,sha256=QNd3mJxPsKN0Wg12K_Iuefto5A2Vv9leuMvymAdt4uo,4479
 ck/utils/local_config.py,sha256=-oTKvKCpm29JeHEhV1_qLC5fMS523unDzXr0VYE3M0U,9535
 ck/utils/map_list.py,sha256=T2OpjI7eDgC4geCtW_FsEr6ryiePOnKZwfDahB63zfA,3847
 ck/utils/map_set.py,sha256=BLu9BO3FCtzZlZ9MfP9STtIdQ4Me8-QKdwB7o15y7f8,3809
@@ -118,7 +121,7 @@ ck_demos/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 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=yF35GsYtFZxzTFqXlD_yoEg25BA8wROB5HbuOaxLPUs,1365
+ck_demos/ace/demo_ace.py,sha256=Ve_0Ho-jeOrfpFAV-XBSW_jxcWqFYeCQyo_VQd3Aik4,1458
 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
@@ -160,12 +163,12 @@ ck_demos/sampling/demo_marginal_direct_sampler.py,sha256=RhNunuIUnYI_GXp9m8wzadM
 ck_demos/sampling/demo_uniform_sampler.py,sha256=Z6tX_OYKGLc_w3-kEPK4KEZlJo7F5HOq_tUVppB_VQE,962
 ck_demos/sampling/demo_wmc_direct_sampler.py,sha256=c7maxTmZyIijaVdFs2h_KQbK30LvI-oCm2BXSUXVoD8,1113
 ck_demos/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ck_demos/utils/compare.py,sha256=MwigxgMqeV7slrzdIJYVJ340QBCCXOeUzUKOJkkd98w,4972
+ck_demos/utils/compare.py,sha256=Bwjpflevl4nusfA0zp96rInaVKFGuhC5Xv7HzA1Fobk,5088
 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.0a17.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
-compiled_knowledge-4.0.0a17.dist-info/METADATA,sha256=tOzAP4I8J_GgurONBokeDJvcG1Ycdizt7uW3pDqcM7Y,1838
-compiled_knowledge-4.0.0a17.dist-info/WHEEL,sha256=b7PoVIxzH_MOHKjftqMzQiGKfdHRlRFepVBVPg0y3vc,101
-compiled_knowledge-4.0.0a17.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
-compiled_knowledge-4.0.0a17.dist-info/RECORD,,
+compiled_knowledge-4.0.0a19.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
+compiled_knowledge-4.0.0a19.dist-info/METADATA,sha256=bLp-yhVx425Su0k6KY8otIbFy91Igxu6gLjMzttddCw,1838
+compiled_knowledge-4.0.0a19.dist-info/WHEEL,sha256=8UP9x9puWI0P1V_d7K2oMTBqfeLNm21CTzZ_Ptr0NXU,101
+compiled_knowledge-4.0.0a19.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
+compiled_knowledge-4.0.0a19.dist-info/RECORD,,

{compiled_knowledge-4.0.0a17.dist-info → compiled_knowledge-4.0.0a19.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: false
 Tag: cp312-cp312-win_amd64