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

ck/pgm_compiler/support/clusters.py

@@ -9,7 +9,7 @@ from ck.pgm import PGM
 
 # A VEObjective is a variable elimination objective function.
 # An objective function is a function from a random variable index (int)
-# to an objected value (float or int). This is used to select
+# to an objective value (float or int). This is used to select
 # a random variable to eliminate in `ve_greedy_min`.
 VEObjective = Callable[[int], int | float]
 

ck/pgm_compiler/variable_elimination.py

@@ -69,13 +69,13 @@ def compile_pgm(
                 tables_with_rv.append(product(x, y))
             next_tables.append(sum_out(tables_with_rv[0], (rv_idx,)))
             cur_tables = next_tables
-    # All rvs are now eliminated
+
+    # All rvs are now eliminated - all tables should have a single top.
     tops: List[CircuitNode] = [
         table.top()
         for table in cur_tables
-        if len(table) > 0
     ]
-    top = factor_tables.circuit.optimised_add(tops)
+    top: CircuitNode = factor_tables.circuit.optimised_mul(tops)
     top.circuit.remove_unreachable_op_nodes(top)
 
     return PGMCircuit(

ck/probability/empirical_probability_space.py

@@ -7,6 +7,9 @@ from ck.probability.probability_space import ProbabilitySpace, Condition, check_
 class EmpiricalProbabilitySpace(ProbabilitySpace):
     def __init__(self, rvs: Sequence[RandomVariable], samples: Iterable[Instance]):
         """
+        Enable probabilistic queries over a sample from a sample space.
+        Note that this is not necessarily an efficient approach to calculating probabilities and statistics.
+
         Assumes:
             len(sample) == len(rvs), for each sample in samples.
             0 <= sample[i] < len(rvs[i]), for each sample in samples, for i in range(len(rvs)).

ck/probability/pgm_probability_space.py

@@ -0,0 +1,32 @@
+from typing import Sequence, Iterable, Tuple, Dict, List
+
+from ck.pgm import RandomVariable, Indicator, Instance, PGM
+from ck.probability.probability_space import ProbabilitySpace, Condition, check_condition
+
+
+class PGMProbabilitySpace(ProbabilitySpace):
+    def __init__(self, pgm: PGM):
+        """
+        Enable probabilistic queries directly on a PGM.
+        Note that this is not necessarily an efficient approach to calculating probabilities and statistics.
+
+        Args:
+            pgm: The PGM to query.
+        """
+        self._pgm = pgm
+        self._z = None
+
+    @property
+    def rvs(self) -> Sequence[RandomVariable]:
+        return self._pgm.rvs
+
+    def wmc(self, *condition: Condition) -> float:
+        condition: Tuple[Indicator, ...] = check_condition(condition)
+        return self._pgm.value_product_indicators(*condition)
+
+    @property
+    def z(self) -> float:
+        if self._z is None:
+            self._z = self._pgm.value_product_indicators()
+        return self._z
+

ck/probability/probability_space.py

@@ -3,6 +3,7 @@ An abstract class for object providing probabilities.
 """
 import math
 from abc import ABC, abstractmethod
+from itertools import chain
 from typing import Sequence, Tuple, Iterable, Callable
 
 import numpy as np
@@ -75,15 +76,38 @@ class ProbabilitySpace(ABC):
             the probability of the given indicators, conditioned on the given conditions.
         """
         condition: Tuple[Indicator, ...] = check_condition(condition)
+
         if len(condition) == 0:
             z = self.z
+            if z <= 0:
+                return np.nan
         else:
             z = self.wmc(*condition)
-            indicators += condition  # append the condition
-        if z > 0:
-            return self.wmc(*indicators) / z
-        else:
-            return np.nan
+            if z <= 0:
+                return np.nan
+
+            # Combine the indicators with the condition
+            # If a variable is mentioned in both the indicators and condition, then
+            # we need to take the intersection, and check for contradictions.
+            # If a variable is mentioned in the condition but not indicators, then
+            # the rv condition needs to be added to the indicators.
+            indicator_groups: MapSet[int, Indicator] = _group_indicators(indicators)
+            condition_groups: MapSet[int, Indicator] = _group_indicators(condition)
+
+            for rv_idx, indicators in condition_groups.items():
+                indicator_group = indicator_groups.get(rv_idx)
+                if indicator_group is None:
+                    indicator_groups.add_all(rv_idx, indicators)
+                else:
+                    indicator_group.intersection_update(indicators)
+                    if len(indicator_group) == 0:
+                        # A contradiction between the indicators and conditions
+                        return 0.0
+
+            # Collect all the indicators from the updated indicator_groups
+            indicators = chain(*indicator_groups.values())
+
+        return self.wmc(*indicators) / z
 
     def marginal_distribution(self, *rvs: RandomVariable, condition: Condition = ()) -> NDArrayNumeric:
         """
@@ -160,9 +184,7 @@ class ProbabilitySpace(ABC):
         assert len(rv_indexes) == len(rvs), 'duplicated random variables not allowed'
 
         # Group conditioning indicators by random variable.
-        conditions_by_rvs = MapSet()
-        for ind in condition:
-            conditions_by_rvs.get_set(ind.rv_idx).add(ind.state_idx)
+        conditions_by_rvs = _group_states(condition)
 
         # See if any MAP random variable is also conditioned.
         # Reduce the state space of any conditioned MAP rv.
@@ -195,12 +217,12 @@ class ProbabilitySpace(ABC):
             # Loop over the state space of the 'loop' rvs
             best_probability = float('-inf')
             best_states = None
-            inds: Tuple[Indicator, ...]
-            for inds in _combos(loop_rvs):
-                probability = self.wmc(*(inds + new_conditions))
+            indicators: Tuple[Indicator, ...]
+            for indicators in _combos(loop_rvs):
+                probability = self.wmc(*(indicators + new_conditions))
                 if probability > best_probability:
                     best_probability = probability
-                    best_states = tuple(ind.state_idx for ind in inds)
+                    best_states = tuple(ind.state_idx for ind in indicators)
             condition_probability = self.wmc(*condition)
             return best_probability / condition_probability, best_states
 
@@ -551,6 +573,38 @@ def dtype_for_state_indexes(rvs: Iterable[RandomVariable]) -> DTypeStates:
     return dtype_for_number_of_states(max((len(rv) for rv in rvs), default=0))
 
 
+def _group_indicators(indicators: Iterable[Indicator]) -> MapSet[int, Indicator]:
+    """
+    Group the given indicators by rv_idx.
+
+    Args:
+        indicators: the indicators to group.
+
+    Returns:
+        A mapping from rv_idx to set of indicators.
+    """
+    groups: MapSet[int, Indicator] = MapSet()
+    for indicator in indicators:
+        groups.add(indicator.rv_idx, indicator)
+    return groups
+
+
+def _group_states(indicators: Iterable[Indicator]) -> MapSet[int, int]:
+    """
+    Group the given indicator states by rv_idx.
+
+    Args:
+        indicators: the indicators to group.
+
+    Returns:
+        A mapping from rv_idx to set of state indexes.
+    """
+    groups: MapSet[int, int] = MapSet()
+    for indicator in indicators:
+        groups.add(indicator.rv_idx, indicator.state_idx)
+    return groups
+
+
 def _normalise_marginal(distribution: NDArrayFloat64) -> None:
     """
     Update the values in the given distribution to

ck/sampling/sampler_support.py

@@ -13,7 +13,7 @@ from ck.utils.random_extras import Random
 # Type of a yield function. Support for a sampler.
 # A yield function may be used to implement a sampler's iterator, thus
 # it provides an Instance or single state index.
-YieldF = Callable[[NDArrayStates], Instance | int]
+YieldF = Callable[[NDArrayStates], int] | Callable[[NDArrayStates], Instance]
 
 
 @dataclass

ck/sampling/uniform_sampler.py

@@ -1,15 +1,15 @@
-from typing import Set, List, Iterator, Optional, Sequence
 import random
+from typing import Set, List, Iterator, Optional, Sequence
 
 import numpy as np
 
 from ck.pgm import Instance, RandomVariable, Indicator
 from ck.probability.probability_space import dtype_for_state_indexes, Condition, check_condition
-from .sampler import Sampler
-from .sampler_support import YieldF
 from ck.utils.map_set import MapSet
 from ck.utils.np_extras import DType
 from ck.utils.random_extras import Random
+from .sampler import Sampler
+from .sampler_support import YieldF
 
 
 class UniformSampler(Sampler):
@@ -39,11 +39,15 @@ class UniformSampler(Sampler):
             conditioned_rvs.add(ind.rv_idx, ind.state_idx)
 
         def get_possible_states(_rv: RandomVariable) -> List[int]:
+            """
+            Get the allowable states for a given random variable, given
+            conditions in `conditioned_rvs`.
+            """
             condition_states: Optional[Set[int]] = conditioned_rvs.get(_rv.idx)
             if condition_states is None:
                 return list(range(len(_rv)))
             else:
-                return [state_idx for state_idx in range(len(_rv)) if state_idx not in condition_states]
+                return list(condition_states)
 
         possible_states: List[List[int]] = [
             get_possible_states(rv)
@@ -63,4 +67,6 @@ class UniformSampler(Sampler):
             for i, l in enumerate(possible_states):
                 state_idx = rand.randrange(0, len(l))
                 state[i] = l[state_idx]
+            # We know the yield function will always provide either ints or Instances
+            # noinspection PyTypeChecker
             yield yield_f(state)

ck/sampling/wmc_direct_sampler.py

@@ -8,7 +8,7 @@ from ck.program.program_buffer import ProgramBuffer
 from ck.program.raw_program import RawProgram
 from ck.sampling.sampler import Sampler
 from ck.sampling.sampler_support import SampleRV, YieldF, SamplerInfo
-from ck.utils.np_extras import NDArrayNumeric
+from ck.utils.np_extras import NDArrayNumeric, NDArrayStates
 from ck.utils.random_extras import Random
 
 
@@ -52,7 +52,7 @@ class WMCDirectSampler(Sampler):
             return program_buffer.compute().item()
 
         # Set up working memory buffers
-        states = np.zeros(len(sample_rvs), dtype=self._state_dtype)
+        states: NDArrayStates = np.zeros(len(sample_rvs), dtype=self._state_dtype)
         buff_slots = np.zeros(self._max_number_of_states, dtype=np.uintp)
         buff_states = np.zeros(self._max_number_of_states, dtype=self._state_dtype)
 
@@ -153,6 +153,8 @@ class WMCDirectSampler(Sampler):
                 slots[slot] = 1
                 states[sample_rv.index] = state
 
+            # We know the yield function will always provide either ints or Instances
+            # noinspection PyTypeChecker
             yield yield_f(states)
 
             # Reset the one slots for the next iteration.

ck/sampling/wmc_gibbs_sampler.py

@@ -65,12 +65,16 @@ class WMCGibbsSampler(Sampler):
             if skip == 0:
                 while True:
                     self._next_sample_gibbs(sample_rvs, slots_1, program_buffer, prs, state, rand)
+                    # We know the yield function will always provide either ints or Instances
+                    # noinspection PyTypeChecker
                     yield yield_f(state)
             else:
                 while True:
                     for _ in range(skip):
                         self._next_sample_gibbs(sample_rvs, slots_1, program_buffer, prs, state, rand)
                     self._next_sample_gibbs(sample_rvs, slots_1, program_buffer, prs, state, rand)
+                    # We know the yield function will always provide either ints or Instances
+                    # noinspection PyTypeChecker
                     yield yield_f(state)
 
         else:
@@ -79,6 +83,8 @@ class WMCGibbsSampler(Sampler):
                 for _ in range(skip):
                     self._next_sample_gibbs(sample_rvs, slots_1, program_buffer, prs, state, rand)
                 self._next_sample_gibbs(sample_rvs, slots_1, program_buffer, prs, state, rand)
+                # We know the yield function will always provide either ints or Instances
+                # noinspection PyTypeChecker
                 yield yield_f(state)
                 if rand.random() < pr_restart:
                     # Set an initial system state

ck/sampling/wmc_metropolis_sampler.py

@@ -1,4 +1,4 @@
-from typing import Collection, Iterator, List, Sequence
+from typing import Collection, Iterator, Sequence
 
 import numpy as np
 
@@ -78,12 +78,16 @@ class WMCMetropolisSampler(Sampler):
             if skip == 0:
                 while True:
                     w = self._next_sample_metropolis(possibles, program_buffer, state, w, rand)
+                    # We know the yield function will always provide either ints or Instances
+                    # noinspection PyTypeChecker
                     yield yield_f(state)
             else:
                 while True:
                     for _ in range(skip):
                         w = self._next_sample_metropolis(possibles, program_buffer, state, w, rand)
                     w = self._next_sample_metropolis(possibles, program_buffer, state, w, rand)
+                    # We know the yield function will always provide either ints or Instances
+                    # noinspection PyTypeChecker
                     yield yield_f(state)
 
         else:
@@ -92,6 +96,8 @@ class WMCMetropolisSampler(Sampler):
                 for _ in range(skip):
                     w = self._next_sample_metropolis(possibles, program_buffer, state, w, rand)
                 w = self._next_sample_metropolis(possibles, program_buffer, state, w, rand)
+                # We know the yield function will always provide either ints or Instances
+                # noinspection PyTypeChecker
                 yield yield_f(state)
 
                 if rand.random() < pr_restart:

ck/sampling/wmc_rejection_sampler.py

@@ -91,6 +91,8 @@ class WMCRejectionSampler(Sampler):
             w: float = wmc()
 
             if rand.random() * self._w_max < w:
+                # We know the yield function will always provide either ints or Instances
+                # noinspection PyTypeChecker
                 yield yield_f(state)
 
             # Update w_not_seen and w_high to adapt w_max.

ck/utils/iter_extras.py

@@ -4,19 +4,19 @@ A module with extra iteration functions.
 from functools import reduce as _reduce
 from itertools import combinations, chain
 from operator import mul as _mul
-from typing import Iterable, Tuple, Iterator, Sequence, TypeVar
+from typing import Iterable, Tuple, Sequence, TypeVar
 
 _T = TypeVar('_T')
 
 
-def flatten(iterables: Iterable[Iterable[_T]]) -> Iterator[_T]:
+def flatten(iterables: Iterable[Iterable[_T]]) -> Iterable[_T]:
     """
     Iterate over the elements of an iterable of iterables.
     """
     return (elem for iterable in iterables for elem in iterable)
 
 
-def deep_flatten(iterables: Iterable) -> Iterator:
+def deep_flatten(iterables: Iterable) -> Iterable:
     """
     Iterate over the flattening of nested iterables.
     """
@@ -28,7 +28,7 @@ def deep_flatten(iterables: Iterable) -> Iterator:
             yield el
 
 
-def combos(list_of_lists: Sequence[Sequence[_T]], flip=False) -> Iterator[Tuple[_T, ...]]:
+def combos(list_of_lists: Sequence[Sequence[_T]], flip=False) -> Iterable[Tuple[_T, ...]]:
     """
     Iterate over all combinations of taking one element from each of the lists.
 
@@ -66,7 +66,7 @@ def combos(list_of_lists: Sequence[Sequence[_T]], flip=False) -> Iterator[Tuple[
                 return
 
 
-def combos_ranges(list_of_lens: Sequence[int], flip=False) -> Iterator[Tuple[int, ...]]:
+def combos_ranges(list_of_lens: Sequence[int], flip=False) -> Iterable[Tuple[int, ...]]:
     """
     Equivalent to combos([range(l) for l in list_of_lens], flip).
 
@@ -106,7 +106,7 @@ def pairs(elements: Iterable[_T]) -> Iterable[Tuple[_T, _T]]:
     return combinations(elements, 2)
 
 
-def sequential_pairs(elements: Sequence[_T]) -> Iterator[Tuple[_T, _T]]:
+def sequential_pairs(elements: Sequence[_T]) -> Iterable[Tuple[_T, _T]]:
     """
     Iterate over sequential pairs in the given list of elements.
     """
@@ -135,6 +135,9 @@ def unzip(xs: Iterable[Tuple[_T]]) -> Tuple[Iterable[_T]]:
     Inverse function of zip.
 
     E.g., a, b, c = unzip(zip(a, b, c))
+
+    Note that the Python type of `a`, `b`, and `c` may not be preserved, only
+    the contents, order and length are guaranteed.
     """
     return zip(*xs)
 

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

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

@@ -1,8 +1,9 @@
 ck/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ck/pgm.py,sha256=Q7JEgQu2qlH9Q9zeY8OQBDtx4SVIRqRzTrk9zU2sW3Q,122855
+ck/pgm.py,sha256=PcuoqQyymMvbmUWb62hIe4cly2k28EuF0R4yM-KYBvI,124358
 ck/circuit/__init__.py,sha256=tozFNNVzsgQDwFrtGzrgcFS4XTszhgyFmbMGfV5pimc,212
-ck/circuit/circuit.cp312-win_amd64.pyd,sha256=7_HJRc8SPE2HLER6jVAqsWlEaEnReR7h8IwXFzZfgPk,251904
-ck/circuit/circuit.pyx,sha256=fSTTsIwT6Yxls72qkCjGgez9uLD5zvdgT2dg03V0kvE,27598
+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_node.pyx,sha256=8RuEC1ngYxnsGryzQ1lOEPc4ewTxvKwc56sOxWLB9zs,4103
 ck/circuit/circuit_py.py,sha256=Y4g3vf3l1_3zS1g52b5Fi9F-4DupiZTeF8yiYiKz6Vc,27507
 ck/circuit/tmp_const.py,sha256=dG9FuGfoAG5qjYG1rNwekqKiea_KmVfxHMTOgCPbBiQ,2372
@@ -13,7 +14,8 @@ 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.cp312-win_amd64.pyd,sha256=pp9zyNdkjMjd5qVdsKoEU1mRc-LC29hWA17EwdaAtDs,92160
+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.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
@@ -64,33 +66,35 @@ ck/in_out/render_pomegranate.py,sha256=gGvXyX9vOoilGIIL3rsMB07gERMU-12XPsttfSb4x
 ck/pgm_circuit/__init__.py,sha256=B0CCjNMnPzrd0YiOEFdK4JzmRCvFIGJi3RJQ5Vg6fqA,37
 ck/pgm_circuit/marginals_program.py,sha256=DUvSND3ozQuBCZcmIsgwZ4w_IWCVV7O31Pm4PJ7ZDok,14786
 ck/pgm_circuit/mpe_program.py,sha256=IjHPZv2xKXZGp_FR1QFJgJpMhLKdajLgV33R4DEbn4o,10231
-ck/pgm_circuit/pgm_circuit.py,sha256=XI1ELtHAZBOqKpBeGAUebEfM0rGCBeFD8U0DOG9qMSo,3092
-ck/pgm_circuit/program_with_slotmap.py,sha256=cF60QkxeixZFbDWm84e_a5iJteRK6wHPOgoQEGu-7Qo,8890
+ck/pgm_circuit/pgm_circuit.py,sha256=3vKOh2gFGyB_PhfQgviCQGXv1t4dbawBL89sjm4-SPA,3287
+ck/pgm_circuit/program_with_slotmap.py,sha256=boS8Y1X60F-_pTM3wFyC4oP9jc-5zDc8Iv4vn7JUJWM,8959
 ck/pgm_circuit/slot_map.py,sha256=T4nBweoiivEdBDhYZ6GWpOXqSusRbp3vrSbCTyP1qpI,857
 ck/pgm_circuit/target_marginals_program.py,sha256=x4YQM-hUQRo2OLxodKJVOAKxqNlxmiDl9nGbbknypkY,3768
 ck/pgm_circuit/wmc_program.py,sha256=WtABU74FOCCJuKRCoDL4CyZ4CJXFmt9RSxiNNHsOhRY,12699
 ck/pgm_circuit/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/pgm_circuit/support/compile_circuit.py,sha256=RuYzDCRpfXZcY96sSW8v7x6ev9ScQ4IZkVqMdJUoMp8,3484
 ck/pgm_compiler/__init__.py,sha256=XCK1AWBBB9UYi6kbFnxMFzBL9a25EWfHnz_yn3ZKYuM,112
-ck/pgm_compiler/factor_elimination.py,sha256=eqmMLoOgYJNHYB-tVkC4dZDV_lV-L5aeyjNVurWQGx4,13131
+ck/pgm_compiler/factor_elimination.py,sha256=iZe7Y-YIm0P9I-h4jLomUS49QiEedAbWQ1btU5JRBLg,13244
 ck/pgm_compiler/named_pgm_compilers.py,sha256=zqRR8gER4zhl_RjXPHy8U0j5G-bQhYQZuG9hWptAHms,3720
 ck/pgm_compiler/pgm_compiler.py,sha256=F44PtlwqMG0FS6KzOYKZuyZT6olWAVtBH-QXZPzz4O8,616
-ck/pgm_compiler/recursive_conditioning.py,sha256=La7Z8ob3oR3f-JumZGTaJDoJSAIAF6lr63a4uq2epgw,7769
-ck/pgm_compiler/variable_elimination.py,sha256=rY9EFVNfPgpdaqGM6tv4lAucSz0_KKVUwPFksJm1Ums,3432
+ck/pgm_compiler/recursive_conditioning.py,sha256=dlLAKdV7KUf7hHRVIndBsMC1bGUvrOCXeOY0vGs6yHE,7935
+ck/pgm_compiler/variable_elimination.py,sha256=wNNntrng2OGSsnGHWr8cLHsMHDQgJodQxhu6h7RMung,3459
 ck/pgm_compiler/ace/__init__.py,sha256=BkZXAF32Pk8QU7jhkuKvHqtsFasPjf8gxiZbyrGDDbQ,82
-ck/pgm_compiler/ace/ace.py,sha256=iZVAgSx-cVOM90YpRWya3nKKTWWu0G4nx6QH-qyMJUQ,8639
+ck/pgm_compiler/ace/ace.py,sha256=SpOX8s0PsNP0I9X5_TagHo5Gh4kZYxciKuEQbuvpyE4,10131
 ck/pgm_compiler/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ck/pgm_compiler/support/clusters.py,sha256=ME63TxoSENoo8Gu2e_LH9lOe2hTYmBxRwX9iMHnNrEA,20820
+ck/pgm_compiler/support/clusters.py,sha256=96Up5XUgERh-t6KzSIOF2gtP5T4Ul83JK_aPtIR72Ic,20821
 ck/pgm_compiler/support/factor_tables.py,sha256=LAZbWtDVyTpxps7C4d3q38uUVkNnzRBO8JpYl9Qly-c,15081
 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.cp312-win_amd64.pyd,sha256=dKsVjjx2hgP8vJr2zTrJ4LtdnR5Sbv5Sl-JLvwPQMQQ,94720
+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.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
-ck/probability/empirical_probability_space.py,sha256=UZrGmsmnwubN697sBIHb8bYhSfjyq4VUe80Ug7zt1Lc,1765
-ck/probability/probability_space.py,sha256=UvXmadHMBn9CO-uepUM2A0ZScsvKGB-alNs2F1I4AX8,23886
+ck/probability/empirical_probability_space.py,sha256=HoLxmigzlWFWQlcZQwDOYk-mjgf6RW1IPE-l0t8vMPw,1950
+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_buffer.py,sha256=1fiUcT7sqyr4vu8jXzK3ZsrgURFhWMdm6hr2BeS9ONA,5665
@@ -99,14 +103,14 @@ 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
 ck/sampling/sampler.py,sha256=qhfguy8rnVQBVVXhJylvh-8Kq7rfHW62a3DEtv9v7Xc,2306
-ck/sampling/sampler_support.py,sha256=wOwU41DeHGcg4RFX0gCDt4PgYO-TLlQGCDZr-ZyS6Lw,9715
-ck/sampling/uniform_sampler.py,sha256=uBnPHwmYims3omK7SgpIb6A9n5dxmzzLEZFi752qgWM,2363
-ck/sampling/wmc_direct_sampler.py,sha256=7bddSATqi9ukWnOgL-lUEQkaftYpd4MfcuxBRQ5ZYWU,7106
-ck/sampling/wmc_gibbs_sampler.py,sha256=2UbPueYXkiueS6g7G2-nizrO7931W_EGwpF3LrJhTHA,6140
-ck/sampling/wmc_metropolis_sampler.py,sha256=4kRSfvK49IQDQC4Xm1JL4v7HoqkV3QG9x4U5p7Y8kX4,6049
-ck/sampling/wmc_rejection_sampler.py,sha256=ti77XDMahT2p9kXNWJzY1MKrwDWuSyVec-r1oeBxPHQ,4760
+ck/sampling/sampler_support.py,sha256=beFJ993yXyvy5y2T7tJmK638ESp3qvErFWoM3BEwD5E,9742
+ck/sampling/uniform_sampler.py,sha256=NCN1T77v4g4hsdNgIsZDxHBndfj4AghLSk8WKQt_2a0,2586
+ck/sampling/wmc_direct_sampler.py,sha256=7qiz-bRlQ59ZBJmg0bEG0y63pXTVXNVx4d410BGhnJg,7265
+ck/sampling/wmc_gibbs_sampler.py,sha256=GMKVW2AVtsWtP6vxE3Y2dy-dKr7GoO_vLEA9eC304fo,6567
+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=IvSMvviCntzSygjQHQz4rvj9PKhtB9vLCRa9GVTcZEA,4187
+ck/utils/iter_extras.py,sha256=DDml5Jprmun2RovJxkwXx1uJkWacYhZEnX1ARSX2TB4,4310
 ck/utils/map_list.py,sha256=T2OpjI7eDgC4geCtW_FsEr6ryiePOnKZwfDahB63zfA,3847
 ck/utils/map_set.py,sha256=BLu9BO3FCtzZlZ9MfP9STtIdQ4Me8-QKdwB7o15y7f8,3809
 ck/utils/np_extras.py,sha256=J5KIQJX3C79ltAfKKYc0B0HI43iyuUQxLI9HZ9FiORI,1734
@@ -161,8 +165,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.0a9.dist-info/licenses/LICENSE.txt,sha256=uMYx7tmroEKNASizbCOwPveMQsD5UErLDC1_SANmNn8,1089
-compiled_knowledge-4.0.0a9.dist-info/METADATA,sha256=QcgjS3opB1Q7tJpwBBHcWKFI0fvJIE_2j9Wj5mchtUY,1688
-compiled_knowledge-4.0.0a9.dist-info/WHEEL,sha256=b7PoVIxzH_MOHKjftqMzQiGKfdHRlRFepVBVPg0y3vc,101
-compiled_knowledge-4.0.0a9.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
-compiled_knowledge-4.0.0a9.dist-info/RECORD,,
+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,,