compiled-knowledge 4.1.0a3__cp312-cp312-macosx_11_0_arm64.whl → 4.2.0a1__cp312-cp312-macosx_11_0_arm64.whl

ck/circuit_compiler/llvm_compiler.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from enum import Enum
+from enum import Enum, auto
 from typing import Sequence, Optional, Tuple, Dict, Protocol, assert_never
 
 import llvmlite.binding as llvm
@@ -15,9 +15,9 @@ from ..program.raw_program import RawProgramFunction
 
 
 class Flavour(Enum):
-    STACK = 0  # No working temporary memory requested - all on stack.
-    TMPS = 1  # Working temporary memory used for op node calculations.
-    FUNCS = 2  # Working temporary memory used for op node calculations, one sub-function per op-node.
+    STACK = auto()  # No working temporary memory requested - all on stack.
+    TMPS = auto()  # Working temporary memory used for op node calculations.
+    FUNCS = auto()  # Working temporary memory used for op node calculations, one sub-function per op-node.
 
 
 DEFAULT_TYPE_INFO: TypeInfo = DataType.FLOAT_64.value

ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.c

@@ -15,7 +15,7 @@
             "-O3"
         ],
         "include_dirs": [
-            "/private/var/folders/y6/nj790rtn62lfktb1sh__79hc0000gn/T/build-env-ocuq5f7z/lib/python3.12/site-packages/numpy/_core/include"
+            "/private/var/folders/y6/nj790rtn62lfktb1sh__79hc0000gn/T/build-env-puw5bxqw/lib/python3.12/site-packages/numpy/_core/include"
         ],
         "name": "ck.circuit_compiler.support.circuit_analyser._circuit_analyser_cy",
         "sources": [

ck/circuit_compiler/support/input_vars.py

@@ -3,7 +3,7 @@ This module supports circuit compilers and interpreters by inferring and checkin
 that are explicitly or implicitly referred to by a client.
 """
 
-from enum import Enum
+from enum import Enum, auto
 from itertools import chain
 from typing import Sequence, Optional, Set, Iterable, List
 
@@ -15,9 +15,9 @@ class InferVars(Enum):
     An enum specifying how to automatically infer a program's input variables.
     """
 
-    ALL = 'all'  # all circuit vars are input vars
-    REF = 'ref'  # only referenced vars are input vars
-    LOW = 'low'  # input vars are circuit vars[0 : max_referenced + 1]
+    ALL = auto()  # all circuit vars are input vars
+    REF = auto()  # only referenced vars are input vars
+    LOW = auto()  # input vars are circuit vars[0 : max_referenced + 1]
 
 
 # Type for specifying input circuit vars

ck/learning/coalesce_cross_tables.py

@@ -22,10 +22,18 @@ def coalesce_cross_tables(crosstabs: Sequence[CrossTable], rvs: Sequence[RandomV
 
     `a` is a column vector with one entry for each instance of rvs seen in the cross-tables.
 
-    `b` is a column vector containing all probabilities from all cross-tables (normalised weights).
+    `b` is a column vector containing all probabilities from all cross-tables.
 
     `m` is a sparse matrix with m[i, j] = 1 where b[j] is in the sum for source probability a[i].
 
+    "Best" means the vector `a` with:
+    * `a[i] >= 0` for all i, then
+    * `b - m a` having the smallest L2 norm, then
+    * `a` having the smallest L2 norm.
+
+    The given crosstables will be used to form `b`. The entries each cross-table will be normalised
+    to represent a probability distribution over the cross-table's instances (keys).
+
     Args:
         crosstabs: a collection of cross-tables to coalesce.
         rvs: the random variables that cross-tables will be projected on to.
@@ -171,8 +179,8 @@ def _make_matrix(
     Returns:
         the tuple (m, b, a_keys) where
         'm' is a sparse matrix,
-        'b' is a numpy array of crosstab probabilities,
-        'a_keys' are the keys for the solution probabilities.
+        'b' is a numpy array of crosstab probabilities (normalised as needed),
+        'a_keys' are the keys for the solution probabilities, co-indexed with `a`.
     """
 
     # Sum out any unneeded random variables

ck/learning/model_from_cross_tables.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass, field
+from enum import Enum, auto
 from itertools import chain
 from typing import Iterable, List, Tuple, Dict, Sequence, Set, Optional
 
@@ -12,7 +13,37 @@ from ck.pgm import PGM, RandomVariable
 from ck.utils.map_list import MapList
 
 
-def model_from_cross_tables(pgm: PGM, cross_tables: Iterable[CrossTable]) -> None:
+class ParameterInference(Enum):
+    """
+    There are variations on the method for inferring a CPT's parameter values.
+    This enum defines the possible variations.
+    """
+    first = auto()
+    """
+    Use the first cross-table found that covers the CPT's random variables.
+    If there is no such cross-table, revert to the `all` method.
+    This is the fastest method.
+    """
+
+    sum = auto()
+    """
+    Use the sum of cross-tables that cover the CPT's random variables.
+    If there are no such cross-tables, revert to the `all` method.
+    This is the second fastest method.
+    """
+
+    all = auto()
+    """
+    Project all cross-tables onto the needed random variables, then use
+    `coalesce_cross_tables` to solve for the best parameter values.
+    """
+
+
+def model_from_cross_tables(
+        pgm: PGM,
+        cross_tables: Iterable[CrossTable],
+        method: ParameterInference = ParameterInference.sum,
+) -> None:
     """
     Make best efforts to construct a Bayesian network model given only the
     evidence from the supplied cross-tables.
@@ -24,6 +55,7 @@ def model_from_cross_tables(pgm: PGM, cross_tables: Iterable[CrossTable]) -> Non
     Args:
         pgm: the PGM to add factors and potential function to.
         cross_tables: available cross-tables to build a model from.
+        method: what parameter inference method to use.
 
     Raises:
         ValueError: If `pgm` has any existing factors.
@@ -33,11 +65,16 @@ def model_from_cross_tables(pgm: PGM, cross_tables: Iterable[CrossTable]) -> Non
     cpts: List[CrossTable] = get_cpts(
         rvs=pgm.rvs,
         cross_tables=cross_tables,
+        method=method,
     )
     make_factors(pgm, cpts)
 
 
-def get_cpts(rvs: Sequence[RandomVariable], cross_tables: Iterable[CrossTable]) -> ParameterValues:
+def get_cpts(
+        rvs: Sequence[RandomVariable],
+        cross_tables: Iterable[CrossTable],
+        method: ParameterInference = ParameterInference.sum,
+) -> ParameterValues:
     """
     Make best efforts to define a Bayesian network model given only the
     evidence from the supplied cross-tables.
@@ -53,6 +90,7 @@ def get_cpts(rvs: Sequence[RandomVariable], cross_tables: Iterable[CrossTable])
     Args:
         rvs: the random variables to define a network structure over.
         cross_tables: available cross-tables to build a model from.
+        method: what parameter inference method to use.
 
     Returns:
         ParameterValues object as a list of CPTs, each CPT can be used to create
@@ -90,13 +128,17 @@ def get_cpts(rvs: Sequence[RandomVariable], cross_tables: Iterable[CrossTable])
     # Make the factors, depth first.
     done: Set[int] = set()
     for model_factor in model_factors:
-        _infer_cpt(model_factor, done)
+        _infer_cpt(model_factor, done, method)
 
     # Return the CPTs that define the structure
     return [model_factor.cpt for model_factor in model_factors]
 
 
-def _infer_cpt(model_factor: _ModelFactor, done: Set[int]) -> None:
+def _infer_cpt(
+        model_factor: _ModelFactor,
+        done: Set[int],
+        method: ParameterInference,
+) -> None:
     """
     Depth-first recursively infer the model factors as CPTs.
     This sets `model_factor.cpt` and `model_factor.parent_rvs` for
@@ -110,7 +152,7 @@ def _infer_cpt(model_factor: _ModelFactor, done: Set[int]) -> None:
 
     # Recursively visit the child factors
     for child_model_factor in model_factor.child_factors:
-        _infer_cpt(child_model_factor, done)
+        _infer_cpt(child_model_factor, done, method)
 
     # Get all relevant cross-tables to set the parameters
     crosstabs: Sequence[CrossTable] = model_factor.cross_tables
@@ -121,19 +163,20 @@ def _infer_cpt(model_factor: _ModelFactor, done: Set[int]) -> None:
 
     # Get the parameters
     rvs = [child_rv] + list(model_factor.parent_rvs)
-    crosstab: CrossTable = _infer_parameters(rvs, crosstabs, child_crosstabs)
+    crosstab: CrossTable = _infer_parameter_values(rvs, crosstabs, child_crosstabs, method)
     cpt, parent_sums = cpt_and_parent_sums_from_crosstab(crosstab)
     model_factor.cpt = cpt
     model_factor.parent_sums = parent_sums
 
 
-def _infer_parameters(
+def _infer_parameter_values(
         rvs: Sequence[RandomVariable],
         crosstabs: Sequence[CrossTable],
         child_crosstabs: Sequence[CrossTable],
+        method: ParameterInference,
 ) -> CrossTable:
     """
-    Make best efforts to infer a probability distribution over the give random variables,
+    Make best efforts to infer a probability distribution over the given random variables,
     with evidence from the given cross-tables.
 
     Returns:
@@ -144,8 +187,16 @@ def _infer_parameters(
         `rvs` has no duplicates.
     """
 
+    if method == ParameterInference.all:
+        # Forced to use all cross-tables with `coalesce_cross_tables`
+        projected_crosstabs: List[CrossTable] = [
+            crosstab.project(rvs)
+            for crosstab in chain(crosstabs, child_crosstabs)
+        ]
+        return coalesce_cross_tables(projected_crosstabs, rvs)
+
     # Project crosstables onto rvs, splitting them into complete and partial coverage of `rvs`.
-    # Completely covering cross-tables will be accumulated into `complete_crosstab` while others
+    # Completely covering cross-tables will be summed into `complete_crosstab` while others
     # will be appended to partial_crosstabs.
     complete_crosstab: Optional[CrossTable] = None
     partial_crosstabs: List[CrossTable] = []
@@ -153,10 +204,13 @@ def _infer_parameters(
         available_rvs: Set[RandomVariable] = set(available_crosstab.rvs)
         if available_rvs.issuperset(rvs):
             to_add: CrossTable = available_crosstab.project(rvs)
+            if method == ParameterInference.first:
+                # Take the first available solution.
+                return to_add
             if complete_crosstab is None:
                 complete_crosstab = to_add
             else:
-                complete_crosstab.add_all(to_add.project(rvs).items())
+                complete_crosstab.add_all(to_add.items())
         else:
             partial_crosstabs.append(available_crosstab)
 

ck/pgm_compiler/support/circuit_table/_circuit_table_cy.c

@@ -15,7 +15,7 @@
             "-O3"
         ],
         "include_dirs": [
-            "/private/var/folders/y6/nj790rtn62lfktb1sh__79hc0000gn/T/build-env-ocuq5f7z/lib/python3.12/site-packages/numpy/_core/include"
+            "/private/var/folders/y6/nj790rtn62lfktb1sh__79hc0000gn/T/build-env-puw5bxqw/lib/python3.12/site-packages/numpy/_core/include"
         ],
         "name": "ck.pgm_compiler.support.circuit_table._circuit_table_cy",
         "sources": [

ck/utils/map_dict.py

@@ -0,0 +1,89 @@
+"""
+This module defines a class "MapDict" for mapping keys to dicts.
+"""
+
+from typing import TypeVar, Generic, Dict, MutableMapping, Iterator, KeysView, ValuesView, ItemsView
+
+_K = TypeVar('_K')
+_KV = TypeVar('_KV')
+_V = TypeVar('_V')
+
+
+class MapDict(Generic[_K, _KV, _V], MutableMapping[_K, Dict[_KV, _V]]):
+    """
+    A MapDict keeps a dict for each key.
+    """
+    __slots__ = ('_map',)
+
+    def __init__(self):
+        self._map: Dict[_K, Dict[_KV, _V]] = {}
+
+    def __str__(self) -> str:
+        return str(self._map)
+
+    def __repr__(self) -> str:
+        args = ', '.join(f'{key!r}:{key!r}' for key, val in self.items())
+        class_name = self.__class__.__name__
+        return f'{class_name}({args})'
+
+    def __len__(self) -> int:
+        return len(self._map)
+
+    def __bool__(self) -> bool:
+        return len(self) > 0
+
+    def __getitem__(self, key: _K) -> Dict[_KV, _V]:
+        return self._map[key]
+
+    def __setitem__(self, key: _K, val: Dict[_KV, _V]):
+        if not isinstance(val, dict):
+            class_name = self.__class__.__name__
+            raise RuntimeError(f'every {class_name} value must be a dict')
+        self._map[key] = val
+
+    def __delitem__(self, key: _K):
+        del self._map[key]
+
+    def __iter__(self) -> Iterator[_K]:
+        return iter(self._map)
+
+    def __contains__(self, key: _K) -> bool:
+        return key in self._map
+
+    def keys(self) -> KeysView[_K]:
+        return self._map.keys()
+
+    def values(self) -> ValuesView[Dict[_KV, _V]]:
+        return self._map.values()
+
+    def items(self) -> ItemsView[_K, Dict[_KV, _V]]:
+        return self._map.items()
+
+    def get(self, key: _K, default=None):
+        """
+        Get the list corresponding to the given key.
+        If the key is not yet in the MapList then the
+        supplied default will be returned.
+        """
+        return self._map.get(key, default)
+
+    def get_dict(self, key: _K) -> Dict[_KV, _V]:
+        """
+        Get the dict corresponding to the given key.
+
+        This method will always return a dict in the MapDict, even if
+        it requires a new dict being created.
+
+        Modifying the returned dict affects this MapDict object.
+        """
+        the_dict = self._map.get(key)
+        if the_dict is None:
+            the_dict = {}
+            self._map[key] = the_dict
+        return the_dict
+
+    def clear(self):
+        """
+        Remove all items.
+        """
+        return self._map.clear()

ck_demos/learning/demo_bayesian_network_from_cross_tables.py

@@ -14,11 +14,10 @@ EXCLUDE_UNNECESSARY_CROSS_TABLES = True
 
 
 def main() -> None:
-    number_of_samples: int = 10000  # How many instances to make for the model dataset
-
     # Create a dataset based on model which is an example PGM
+    number_of_samples: int = 10000  # How many instances to make for the model dataset
     model: PGM = example.Student()
-    model_dataset = dataset_from_sampler(
+    model_dataset: HardDataset = dataset_from_sampler(
         WMCProgram(DEFAULT_PGM_COMPILER(model)).sample_direct(),
         number_of_samples,
     )

{compiled_knowledge-4.1.0a3.dist-info → compiled_knowledge-4.2.0a1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: compiled-knowledge
-Version: 4.1.0a3
+Version: 4.2.0a1
 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.1.0a3.dist-info → compiled_knowledge-4.2.0a1.dist-info}/RECORD

@@ -5,7 +5,7 @@ ck_demos/dataset/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 ck_demos/dataset/demo_dataset_builder.py,sha256=a9o-rw8PzpLq_5wtwjH0L15-eacbELlc7tfLrREJBqM,987
 ck_demos/learning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck_demos/learning/demo_simple_learning.py,sha256=CZPzcsnTD8TK7nzGg3XUsx4exqggQXOT6UVwrV0ScF8,1483
-ck_demos/learning/demo_bayesian_network_from_cross_tables.py,sha256=sUpeUFI8WjveRo8Evz4woWyarrVN84E1DzYcM-2NOy0,2579
+ck_demos/learning/demo_bayesian_network_from_cross_tables.py,sha256=FmW5ylFVu7ONkKQVDCUGXXcOuNKdz3f1qbktOt2cX6Q,2591
 ck_demos/circuit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck_demos/circuit/demo_derivatives.py,sha256=6VwnW_Dbm2MWQFfJ46UQQFecV56QdfGpL7srthw5Py0,1143
 ck_demos/circuit/demo_circuit_dump.py,sha256=85x7UJV6cg6XVYU-PPsuKQVTBw5WZBfkhi6Avo9XbOs,436
@@ -58,11 +58,11 @@ ck_demos/pgm_inference/demo_inferencing_mpe_cancer.py,sha256=hS9U2kyqjFgJ8jnVBtT
 ck_demos/pgm_inference/demo_inferencing_wmc_and_mpe_sprinkler.py,sha256=-q4Z1Fzf7-BuwVFTFXdGRY-zUNrY-SAU7ooaov2o_lM,5128
 ck_demos/getting_started/simple_demo.py,sha256=hiYscNnfkEwHCQ3ymXAswAYO5jAKR7cseb36pjzuus8,650
 ck_demos/getting_started/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-compiled_knowledge-4.1.0a3.dist-info/RECORD,,
-compiled_knowledge-4.1.0a3.dist-info/WHEEL,sha256=V1loQ6TpxABu1APUg0MoTRBOzSKT5xVc3skizX-ovCU,136
-compiled_knowledge-4.1.0a3.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
-compiled_knowledge-4.1.0a3.dist-info/METADATA,sha256=GsnkOBTsYHaifQhlQzBzQdrpKIBNWLPhSNuC6sUjET8,1808
-compiled_knowledge-4.1.0a3.dist-info/licenses/LICENSE.txt,sha256=-LmkmqXKYojmS3zDxXAeTbsA82fnHA0KaRvpfIoEdjA,1068
+compiled_knowledge-4.2.0a1.dist-info/RECORD,,
+compiled_knowledge-4.2.0a1.dist-info/WHEEL,sha256=V1loQ6TpxABu1APUg0MoTRBOzSKT5xVc3skizX-ovCU,136
+compiled_knowledge-4.2.0a1.dist-info/top_level.txt,sha256=Cf8DAfd2vcnLiA7HlxoduOzV0Q-8surE3kzX8P9qdks,12
+compiled_knowledge-4.2.0a1.dist-info/METADATA,sha256=3YM6rMFGtHgoZ7Uj1QPmIUiSN0oznniDl6p7JEl0_Rk,1808
+compiled_knowledge-4.2.0a1.dist-info/licenses/LICENSE.txt,sha256=-LmkmqXKYojmS3zDxXAeTbsA82fnHA0KaRvpfIoEdjA,1068
 ck/pgm.py,sha256=EwKTWuYV9-0OfgJQfBw59MfGDLtxFe3wlgbYlkTqj1Y,117703
 ck/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/pgm_circuit/target_marginals_program.py,sha256=qWz9FkAFzt8YHLZJzPkpRnvDH76BXm-dcEWhoqCkrOw,3665
@@ -120,18 +120,18 @@ ck/dataset/dataset.py,sha256=iQGOqVrNll6QMPcRcV2phUbe0fCfpVmUVbcBIaqYx0s,25531
 ck/dataset/dataset_from_crosstable.py,sha256=rOdDFfb_2rnUJT3iZrLbZkeQcRJa5EzFVBs0hSdE57U,2281
 ck/dataset/sampled_dataset.py,sha256=Vcz2WN6IKdmK8DsFeXLten7Id3Kc2epC6qs2ZW7mvWU,3261
 ck/dataset/dataset_from_csv.py,sha256=q4qjOsJFYAmw22xDaHcS6XC3nwqmkT-RoOaRNr_zJ8I,5802
-ck/learning/model_from_cross_tables.py,sha256=nB4dCsGgFtTMS-WaNvlJjzKCvRbs7uTUUxFQr5EcGG4,9083
+ck/learning/model_from_cross_tables.py,sha256=227hBGF0hAmcObdI3wG1RUIPE-Y92wYp2gOcSAeUp44,10750
 ck/learning/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/learning/parameters.py,sha256=x5yP-zxkpm0HfBusOxK5vImUnYanUJeZUjxgOwKNVAc,4388
-ck/learning/coalesce_cross_tables.py,sha256=dQcHXasQU1bEmTCLuiuCVDHEIRt77BNbFp1E5y-qfaI,12926
+ck/learning/coalesce_cross_tables.py,sha256=pPBH4GcNHtmLfEpstyq3zFYyarYxyAduEEXpqaimLAM,13297
 ck/learning/train_generative_bn.py,sha256=hwmhbg4RKh3JvDlG7xOJm1apScXJ1Mmfgu4nasM-cwQ,8019
-ck/circuit/_circuit_cy.c,sha256=aUtvxUkF49UVCUYoFIuvdVRUgW9iBIBorKLciPlRaMA,1704292
+ck/circuit/_circuit_cy.c,sha256=gYwPt5JgPL9uq2kjpqyN_IelnfxdG4dEmm2SqNQCbig,1704292
 ck/circuit/_circuit_cy.pyx,sha256=mER1HK5yyf4UAj9ibn7fUQNyXwoxwxp7PClULPhY9B4,26995
 ck/circuit/__init__.py,sha256=B1jwDE_Xb6hOQE8DecjaTVotOnDxJaT7jsvPfGDXqCU,401
 ck/circuit/_circuit_cy.pxd,sha256=ZcW8xjw4oGQqD5gwz73GXc1H8NxpdAswFWzc2CUWWcA,1025
 ck/circuit/_circuit_py.py,sha256=hADjCFDC1LJKUdyiKZzNLFt7ZkUNJ0IYwEYRj594K4g,27495
 ck/circuit/tmp_const.py,sha256=q01bkIvTEg1l-qFcfl2B8NrSzKlqcWU7McNm4HKv7bU,2300
-ck/circuit/_circuit_cy.cpython-312-darwin.so,sha256=vHyDzjVhhIfFWG3m4vFqZkdh09lq25c22SUOcIVrDtE,335296
+ck/circuit/_circuit_cy.cpython-312-darwin.so,sha256=B58E391BE1pjGHl2yOlXsb2j7tqLICkUPduqeUg2J9g,335296
 ck/sampling/wmc_metropolis_sampler.py,sha256=jfXb-MG0jAoMyepgq9zel2amqK-gmYrCtKuxJStl8VY,6305
 ck/sampling/wmc_direct_sampler.py,sha256=Pkv-u4GjN3npBrcQ92raoTrEIel1vpiDoE8LrlcfYJE,7094
 ck/sampling/sampler_support.py,sha256=AD47QPXlXSTiy7Jm-adD6US3cYeSwBimOY2jB5b2qn4,9534
@@ -142,6 +142,7 @@ ck/sampling/uniform_sampler.py,sha256=XV7i0urWgsJ0nIQA6ONlO8GevsfRdw1dfZuqzRdbnB
 ck/sampling/sampler.py,sha256=LtMm9_kBlZeuIEdYr_DcO218f7OUSnciddiEaEE22Dc,2244
 ck/sampling/wmc_gibbs_sampler.py,sha256=t5pIxr3Kkz37hG0guxVUQWivUZ1T-4lT47yu8qxrZko,6414
 ck/sampling/forward_sampler.py,sha256=gHWEue69Z7EcrnHlVURJBhZh1t5RApMV0ioxJao3GkU,8137
+ck/utils/map_dict.py,sha256=TSSh4CL1wZC9JBlwGWRGmFQ3hcpZwmZ0kpjI1gPZ-pQ,2458
 ck/utils/random_extras.py,sha256=l9CfQM6k-b6KGESJXw9zF--Hqp4yadw2IU9uSoklai0,1796
 ck/utils/map_set.py,sha256=T5E3j4Lz08vg8eviRBc-4F10xz1-CKIg6KiHVoGhdts,3681
 ck/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -164,15 +165,15 @@ ck/pgm_compiler/support/named_compiler_maker.py,sha256=Qz8a9gwY46Q3dtRCZEZ2czq5z
 ck/pgm_compiler/support/circuit_table/__init__.py,sha256=1kWjAZR5Rj6PYNdbCEbuyE2VtIDQU4Qf-3HPFzBlezs,562
 ck/pgm_compiler/support/circuit_table/_circuit_table_cy.pyx,sha256=Fsjw8P9clKQioqlLyr1JirUK5oYkeotpDMy5sMo7Khk,11683
 ck/pgm_compiler/support/circuit_table/_circuit_table_py.py,sha256=OZJC-JGX3ovCSv7nJtNYq7735KZ2eb4TQOlZdZbhPmk,10983
-ck/pgm_compiler/support/circuit_table/_circuit_table_cy.c,sha256=Ga_LmT5hlGc_mn8muLefX9zdt3vXEMiZDUxtMOLTKFU,714044
-ck/pgm_compiler/support/circuit_table/_circuit_table_cy.cpython-312-darwin.so,sha256=AupPKDwtObM-KjI_dNhVC46hsCE3lKCNU86ArZJKbFo,165096
+ck/pgm_compiler/support/circuit_table/_circuit_table_cy.c,sha256=jl_Vj-dyyNjLvg8Bwqjg8qjLVtmT5QIsdQ4GfMnRo5M,714044
+ck/pgm_compiler/support/circuit_table/_circuit_table_cy.cpython-312-darwin.so,sha256=IMUXynqFcx7T_CppIJkG8Ynd5aH2X8htHIiiHK4SNj8,165096
 ck/pgm_compiler/ace/ace.py,sha256=An83dHxE_gQFcEs6H5qgm0PlNFnJSGGuvLJNC2H3hGU,10098
 ck/pgm_compiler/ace/__init__.py,sha256=5HWep-yL1Mr6z5VWEaIYpLumCdeso85J-l_-hQaVusM,96
 ck/program/raw_program.py,sha256=U7kLBCSLtP1CfG09RrzmGo7E3sZdNr7wr2V1qkTfVGc,4106
 ck/program/program_buffer.py,sha256=IHwAHTKIaUlhcbNFTuSxPWKyExIsOxxX6ffUn4KfheU,5485
 ck/program/__init__.py,sha256=Rifdxk-l6cCjXLpwc6Q0pVXNDsllAwaFlRqRx3cURho,107
 ck/program/program.py,sha256=ohsnE0CEy8O4q8uGB_YEjoJKAPhY1Mz_a08Z7fy7TLw,4047
-ck/circuit_compiler/llvm_compiler.py,sha256=SFhfrthrDuAYUjH_DYRD7FBU8eg2db5T4QGBGfoewnw,13635
+ck/circuit_compiler/llvm_compiler.py,sha256=XaAPrMaR5Y0EQT7Zukpa5TFybdBXVLo8_A2cU2lzPtw,13656
 ck/circuit_compiler/circuit_compiler.py,sha256=Sl7FS42GXrDL6eG_WNKILcSQl7Wlccgs5Dd1l0EZMsU,1121
 ck/circuit_compiler/__init__.py,sha256=eRN6chBEt64PK5e6EFGyBNZBn6BXhXb6R3m12zPA1Qg,130
 ck/circuit_compiler/named_circuit_compilers.py,sha256=paKyG876tdG_bdSHJU6KW5HxQrutmV_T80GPpz8A65s,2227
@@ -181,15 +182,15 @@ ck/circuit_compiler/llvm_vm_compiler.py,sha256=rM_6F5st3k9X5K1_MwzKJwDhQo1794voo
 ck/circuit_compiler/cython_vm_compiler/cython_vm_compiler.py,sha256=GdtBkipud8vylXYArOJvZ-10U9L_PL0oJrkyrnFGH2Q,4345
 ck/circuit_compiler/cython_vm_compiler/__init__.py,sha256=ks0sISOJ-XHIHgHnESyFsheNWvcSJQkbsrj1wVlnzTE,48
 ck/circuit_compiler/cython_vm_compiler/_compiler.pyx,sha256=RssdkoAcB3Ahes8xisqFy0PQyOPmC3GLEC2xR-miQaE,12898
-ck/circuit_compiler/cython_vm_compiler/_compiler.cpython-312-darwin.so,sha256=2wyk0kvPM3Fh5jhKb4vYxEjNXmugaqPSDMwsVA7Ss9c,163488
-ck/circuit_compiler/cython_vm_compiler/_compiler.c,sha256=BQYbYiuXvCtEBoKnQZIRfX7pMcCsZ0zTg1BVrGxMDc0,857789
+ck/circuit_compiler/cython_vm_compiler/_compiler.cpython-312-darwin.so,sha256=drpILWhPHsPsqPdu7r60g64OQGXkE5t3YJTSEEhY-qc,163488
+ck/circuit_compiler/cython_vm_compiler/_compiler.c,sha256=OKxPxgQnSwjLUp6nlxquGeabFXf5xqP_kLw904VLl4A,857789
 ck/circuit_compiler/support/llvm_ir_function.py,sha256=sMLKfwz90YcsrVyxsuY0Ymo1ibFOcul4Qiwdake-VkI,8321
-ck/circuit_compiler/support/input_vars.py,sha256=EZrvyhD9XVtf5GuDBluFNWhAOVixP7-_ETxAHLTpBcs,4664
+ck/circuit_compiler/support/input_vars.py,sha256=0g1I5GezT6Dt6ptJJgNFPTyHfRrpunTIkJOUqZhkP84,4673
 ck/circuit_compiler/support/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.pyx,sha256=a0fKmkwRNscJmy6qoO2AOqJYmHYptrQmkRSrDg3G-wg,3233
 ck/circuit_compiler/support/circuit_analyser/__init__.py,sha256=WhNwfg7GHVeI4k_m7owPGWxX0MyZg_wtcp2MA07qbWg,523
-ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.cpython-312-darwin.so,sha256=uJDX2rKQ7KKz5JJ2SHRfAH2c8ZA_fJIXn_l688fFUAo,104936
-ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.c,sha256=R9IDuwbPkxUv9Xne8j_ulU0Dd3eXhY2hq5I1XmjnbUk,438223
+ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.cpython-312-darwin.so,sha256=MycKij0HvH7_FfYgSD_RYrwMbTaDdgq7k_Tz2iGzca8,104936
+ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_cy.c,sha256=OiC5DlYl76XoiEzX71ssoRLT-a3aEJsyQ82WyDEakVQ,438223
 ck/circuit_compiler/support/circuit_analyser/_circuit_analyser_py.py,sha256=CMdXV6Rot5CCoK1UsurQdGK0UOx_09B6V7mCc_6-gfI,2993
 ck/in_out/render_net.py,sha256=VePvN6aYWuzEkW-Hv-qGT9QneOvsnrBMmS_KYueuj2I,4970
 ck/in_out/render_bugs.py,sha256=c39KbaD4gEiauFsZq2KUhDEEa-3cuY5kuvz97pEWVpw,3272