compiled-knowledge 4.0.0a24__cp312-cp312-win_amd64.whl → 4.1.0__cp312-cp312-win_amd64.whl

ck/pgm.py

@@ -15,33 +15,34 @@ from ck.utils.iter_extras import (
 from ck.utils.np_extras import NDArrayFloat64, NDArrayUInt8
 
 State: TypeAlias = Union[int, str, bool, float, None]
-State.__doc__ = \
-    """
-    The type for a possible state of a random variable.
-    """
-
-Instance: TypeAlias = Sequence[int]
-Instance.__doc__ = \
-    """
-    An instance (of a sequence of random variables) is a sequence of integers
-    that are state indexes, co-indexed with a known sequence of random variables.
-    """
-
-Key: TypeAlias = Union[Instance, int]
-Key.__doc__ = \
-    """
-    A key identifies an instance, either as an instance itself or a
-    single integer, representing an instance with one dimension.
-    """
+"""
+The type for a possible state of a random variable.
+"""
+
+Instance: TypeAlias = Tuple[int, ...]
+"""
+An instance (of a sequence of random variables) is a tuple of integers
+that are state indexes, co-indexed with a known sequence of random variables.
+"""
+
+Key: TypeAlias = Union[Sequence[int], int]
+"""
+A key identifies an instance, either as a sequence of integers or a
+single integer. The integers are state indexes, co-indexed with a known
+sequence of random variables. A single integer represents an instance with
+one dimension.
+"""
 
 Shape: TypeAlias = Sequence[int]
-Key.__doc__ = \
-    """
-    The type for the "shape" of a sequence of random variables.
-    That is, the shape of (rv1, rv2, rv3) is (len(rv1), len(rv2), len(rv3)).
-    """
+"""
+The type for the "shape" of a sequence of random variables.
+That is, the shape of (rv1, rv2, rv3) is (len(rv1), len(rv2), len(rv3)).
+"""
 
-DEFAULT_CPT_TOLERANCE: float = 0.000001  # A tolerance when checking CPT distributions sum to one (or zero).
+DEFAULT_CPT_TOLERANCE: float = 0.000001
+"""
+A tolerance when checking CPT distributions sum to one (or zero).
+"""
 
 
 class PGM:
@@ -214,14 +215,17 @@ class PGM:
         The returned random variable will have an `idx` equal to the value of
         `self.number_of_rvs` just prior to adding the new random variable.
 
+        The states of the random variable can be specified either as an integer
+        representing the number of states, or as a sequence of state values. If a
+        single integer, `n`, is provided then the states will be: 0, 1, ..., n-1.
+        If a sequence of states are provided then the states must be unique.
+
         Assumes:
             Provided states contain no duplicates.
 
         Args:
             name: a name for the random variable.
-            states: either an integer number of states or a sequence of state values. If a
-                single integer, `n`, is provided then the states will be 0, 1, ..., n-1.
-                If a sequence of states are provided then the states must be unique.
+            states: either the number of states or a sequence of state values.
 
         Returns:
             a RandomVariable object belonging to this PGM.
@@ -241,10 +245,11 @@ class PGM:
 
         Assumes:
             The given random variables all belong to this PGM.
+
             The random variables contain no duplicates.
 
         Args:
-            *rvs: the random variables.
+            rvs: the random variables.
 
         Returns:
             a Factor object belonging to this PGM.
@@ -336,17 +341,18 @@ class PGM:
             *input_rvs: RandomVariable
     ) -> Factor:
         """
-        Add a sparse 0/1 factor to this PGM representing:
-            result_rv ==  function(*rvs).
-        That is:
+        Add a sparse 0/1 factor to this PGM representing `result_rv == function(*rvs)`.
+        That is::
+
             factor[result_s, *input_s] = 1, if result_s == function(*input_s);
                                        = 0, otherwise.
+
         Args:
             function: a function from state indexes of the input random variables to a state index
                 of the result random variable. The function should take the same number of arguments
                 as `input_rvs` and return a state index for `result_rv`.
             result_rv: the random variable defining result values.
-            *input_rvs: the random variables defining input values.
+            input_rvs: the random variables defining input values.
 
         Returns:
             a Factor object belonging to this PGM, with a configured sparse potential function.
@@ -378,16 +384,17 @@ class PGM:
         """
         Render indicators as a string.
 
-        For example:
+        For example::
             pgm = PGM()
             a = pgm.new_rv('A', ('x', 'y', 'z'))
             b = pgm.new_rv('B', (3, 5))
             print(pgm.indicator_str(a[0], b[1], a[2]))
-        will print:
+
+        will print::
             A=x, B=5, A=z
 
         Args:
-            *indicators: the indicators to render.
+            indicators: the indicators to render.
             sep: the separator to use between the random variable and its state.
             delim: the delimiter to used when rendering multiple indicators.
 
@@ -406,16 +413,17 @@ class PGM:
         """
         Render indicators as a string, grouping indicators by random variable.
 
-        For example:
+        For example::
             pgm = PGM()
             a = pgm.new_rv('A', ('x', 'y', 'z'))
             b = pgm.new_rv('B', (3, 5))
             print(pgm.condition_str(a[0], b[1], a[2]))
-        will print:
+
+        will print::
             A in {x, z}, B=5
 
         Args:
-            *indicators: the indicators to render.
+            indicators: the indicators to render.
         Return:
             a string representation of the given indicators, as a condition.
         """
@@ -588,9 +596,11 @@ class PGM:
 
         # Factors form a DAG
         states: NDArrayUInt8 = np.zeros(self.number_of_factors, dtype=np.uint8)
-        for factor in self._factors:
-            if self._has_cycle(factor, child_to_factor, states):
-                return False
+        if any(
+            self._has_cycle(factor, child_to_factor, states)
+            for factor in self._factors
+        ):
+            return False
 
         # All tests passed
         return True
@@ -770,7 +780,7 @@ class PGM:
         next_prefix: str = prefix + indent
         next_next_prefix: str = next_prefix + indent
 
-        print(f'{prefix}PGM id={id(self)} name={self.name!r}')
+        print(f'{prefix}PGM id={id(self)}')
         self.dump_synopsis(prefix=next_prefix, precision=precision, max_state_digits=max_state_digits)
 
         print(f'{prefix}random variables ({self.number_of_rvs})')
@@ -784,16 +794,16 @@ class PGM:
 
         print(f'{prefix}factors ({self.number_of_factors})')
         for factor in self.factors:
-            rv_idxs = [rv.idx for rv in factor.rvs]
+            factor_rvs = ', '.join(repr(rv.name) for rv in factor.rvs)
             if factor.is_zero:
-                function_ref = '<zero>'
+                function_ref = '<ZeroPotentialFunction>'
             else:
                 function = factor.function
                 function_ref = f'{id(function)}: {function.__class__.__name__}'
 
-            print(f'{next_prefix}{factor.idx:>3} rvs={rv_idxs} function={function_ref}')
+            print(f'{next_prefix}{factor.idx:>3} rvs=({factor_rvs}) function={function_ref}')
 
-        print(f'{prefix}functions ({self.number_of_functions})')
+        print(f'{prefix}functions, excluding ZeroPotentialFunction ({sum(1 for _ in self.non_zero_functions)})')
         for function in sorted(self.non_zero_functions, key=lambda f: id(f)):
             print(f'{next_prefix}{id(function):>13}: {function.__class__.__name__}')
             function.dump(prefix=next_next_prefix, show_function_values=show_function_values, show_id_class=False)
@@ -930,9 +940,9 @@ class RandomVariable(Sequence[Indicator]):
     in the random variable's PGM list of random variables.
 
     A random variable behaves like a sequence of Indicators, where each indicator represents a random
-    variable being in a particular state. Specifically for a random variable rv, len(rv) is the
+    variable being in a particular state. Specifically for a random variable rv, `len(rv)` is the
     number of states of the random variable and rv[i] is the Indicators representing that
-    rv is in the ith state. When sliced, the result is a tuple, i.e. rv[1:3] = (rv[1], rv[2]).
+    rv is in the ith state. When sliced, the result is a tuple, i.e. `rv[1:3] = (rv[1], rv[2])`.
 
     A RandomVariable has a name. This is for human convenience and has no functional purpose
     within a PGM.
@@ -942,15 +952,18 @@ class RandomVariable(Sequence[Indicator]):
         """
         Create a new random variable, in the given PGM.
 
+        The states of the random variable can be specified either as an integer
+        representing the number of states, or as a sequence of state values. If a
+        single integer, `n`, is provided then the states will be: 0, 1, ..., n-1.
+        If a sequence of states are provided then the states must be unique.
+
         Assumes:
             Provided states contain no duplicates.
 
         Args:
             pgm: the PGM that the random variable will belong to.
             name: a name for the random variable.
-            states: either an integer number of states or a sequence of state values. If a
-                single integer, `n`, is provided then the states will be 0, 1, ..., n-1.
-                If a sequence of states are provided then the states must be unique.
+            states: either the number of states or a sequence of state values.
         """
         self._pgm: PGM = pgm
         self._name: str = name
@@ -1212,15 +1225,14 @@ class RVMap(Sequence[RandomVariable]):
     In addition to accessing a random variable by its index, an RVMap enables
     access to the PGM random variable via the name of each random variable.
 
-    For example, if `pgm.rvs[1]` is a random variable named `xray`, then:
-    ```
-    rvs = RVMap(pgm)
+    For example, if `pgm.rvs[1]` is a random variable named `xray`, then::
 
-    # These all retrieve the same random variable object.
-    xray = rvs[1]
-    xray = rvs('xray')
-    xray = rvs.xray
-    ```
+        rvs = RVMap(pgm)
+
+        # These all retrieve the same random variable object.
+        xray = rvs[1]
+        xray = rvs('xray')
+        xray = rvs.xray
 
     To use an RVMap on a PGM, the random variable names must be unique across the PGM.
     """
@@ -1527,7 +1539,7 @@ class Factor:
         Set to the potential function to a new `ClausePotentialFunction` object.
 
         Args:
-            *key: defines the random variable states of the clause. The key is a sequence of
+            key: defines the random variable states of the clause. The key is a sequence of
                 random variable state indexes, co-indexed with `Factor.rvs`.
 
         Returns:
@@ -1556,7 +1568,7 @@ class Factor:
         return self._potential_function
 
 
-@dataclass(frozen=True, eq=True)
+@dataclass(frozen=True, eq=True, slots=True)
 class ParamId:
     """
     A ParamId identifies a parameter of a potential function.
@@ -1863,7 +1875,7 @@ class PotentialFunction(ABC):
             a hypothetical parameter index assuming that every valid key has a unique parameter
             as per DensePotentialFunction.
         """
-        return _natural_key_idx(self._shape, key)
+        return natural_key_idx(self._shape, key)
 
     def param_id(self, param_idx: int) -> ParamId:
         """
@@ -2021,7 +2033,7 @@ class ZeroPotentialFunction(PotentialFunction):
         return 0
 
     def param_idx(self, key: Key) -> int:
-        return _natural_key_idx(self._shape, key)
+        return natural_key_idx(self._shape, key)
 
     def is_cpt(self, tolerance=DEFAULT_CPT_TOLERANCE) -> bool:
         return True
@@ -2164,7 +2176,7 @@ class DensePotentialFunction(PotentialFunction):
         """
         Set the values of the potential function using the given iterator.
 
-        Mapping instances to *values is as follows:
+        Mapping instances to values is as follows:
             Given Factor(rv1, rv2) where rv1 has 2 states, and rv2 has 3 states:
             values[0] represents instance (0,0)
             values[1] represents instance (0,1)
@@ -2209,7 +2221,7 @@ class DensePotentialFunction(PotentialFunction):
         The order of values is the same as set_iter.
         
         Args:
-            *value: the values to use.
+            value: the values to use.
             
         Returns:
             self
@@ -2414,7 +2426,7 @@ class SparsePotentialFunction(PotentialFunction):
         """
         Set the values of the potential function using the given iterator.
 
-        Mapping instances to *values is as follows:
+        Mapping instances to values is as follows:
             Given Factor(rv1, rv2) where rv1 has 2 states, and rv2 has 3 states:
             values[0] represents instance (0,0)
             values[1] represents instance (0,1)
@@ -2636,7 +2648,7 @@ class CompactPotentialFunction(PotentialFunction):
         """
         Set the values of the potential function using the given iterator.
 
-        Mapping instances to *values is as follows:
+        Mapping instances to `values` is as follows:
             Given Factor(rv1, rv2) where rv1 has 2 states, and rv2 has 3 states:
             values[0] represents instance (0,0)
             values[1] represents instance (0,1)
@@ -2679,7 +2691,7 @@ class CompactPotentialFunction(PotentialFunction):
         The order of values is the same as set_iter.
 
         Args:
-            *value: the values to use.
+            value: the values to use.
 
         Returns:
             self
@@ -3071,7 +3083,8 @@ class CPTPotentialFunction(PotentialFunction):
         Calls self.set_cpd(parent_states, cpd) for each row (parent_states, cpd)
         in rows. Any unmentioned parent states will have zero probabilities.
 
-        Example usage, assuming three Boolean random variables:
+        Example usage, assuming three Boolean random variables::
+
             pgm.Factor(x, y, z).set_cpt().set(
                 # y  z    x[0] x[1]
                 ((0, 0), (0.1, 0.9)),
@@ -3079,9 +3092,9 @@ class CPTPotentialFunction(PotentialFunction):
                 ((1, 0), (0.1, 0.9)),
                 ((1, 1), (0.1, 0.9))
             )
-        
+
         Args:
-            *rows: are tuples (key, cpd) used to set the potential function values.
+            rows: are tuples (key, cpd) used to set the potential function values.
             
         Raises:
             ValueError: if a CPD is not valid.
@@ -3105,7 +3118,7 @@ class CPTPotentialFunction(PotentialFunction):
         Any list entry may be None, indicating 'guaranteed zero' for the associated parent states.
 
         Args:
-            *cpds: are the CPDs used to set the potential function values.
+            cpds: are the CPDs used to set the potential function values.
             
         Raises:
             ValueError: if a CPD is not valid.
@@ -3355,26 +3368,7 @@ def rv_instances_as_indicators(*rvs: RandomVariable, flip: bool = False) -> Iter
     return _combos(rvs, flip=not flip)
 
 
-def _key_to_instance(key: Key) -> Instance:
-    """
-    Convert a key to an instance.
-
-    Args:
-        key: a key into a state space.
-
-    Returns:
-        A instance from the state space, as a tuple of state indexes, co-indexed with the given shape.
-
-    Assumes:
-        The key is valid for the implied state space.
-    """
-    if isinstance(key, int):
-        return (key,)
-    else:
-        return tuple(key)
-
-
-def _natural_key_idx(shape: Shape, key: Key) -> int:
+def natural_key_idx(shape: Shape, key: Key) -> int:
     """
     What is the natural index of the given key, assuming the given shape.
 
@@ -3400,6 +3394,25 @@ def _natural_key_idx(shape: Shape, key: Key) -> int:
     return result
 
 
+def _key_to_instance(key: Key) -> Instance:
+    """
+    Convert a key to an instance.
+
+    Args:
+        key: a key into a state space.
+
+    Returns:
+        A instance from the state space, as a tuple of state indexes, co-indexed with the given shape.
+
+    Assumes:
+        The key is valid for the implied state space.
+    """
+    if isinstance(key, int):
+        return (key,)
+    else:
+        return tuple(key)
+
+
 def _zero_space(shape: Shape) -> int:
     """
     Return the size of the zero space of the given shape. This is the number

ck/pgm_circuit/marginals_program.py

@@ -308,6 +308,11 @@ class MarginalsProgram(ProgramWithSlotmap, ProbabilitySpace):
         The sampler will yield state lists, where the state
         values are co-indexed with rvs, or self.rvs if rvs is None.
 
+        For more information about this sampler, see the publication:
+        Suresh, S., Drake, B. (2025). Sampling of Large Probabilistic Graphical Models
+        Using Arithmetic Circuits. AI 2024: Advances in Artificial Intelligence. AI 2024.
+        Lecture Notes in Computer Science, vol 15443. https://doi.org/10.1007/978-981-96-0351-0_13.
+
         Args:
             rvs: the list of random variables to sample; the
                 yielded state vectors are co-indexed with rvs; if None,

ck/pgm_circuit/mpe_program.py

@@ -228,10 +228,9 @@ class MPEProgram(ProgramWithSlotmap):
 class MPEResult:
     """
     An MPE result is the result of MPE inference.
-
-    Fields:
-        wmc: the weighted model count value of the MPE solution.
-        mpe: The MPE solution instance. If there are ties then this will just be once instance.
     """
     wmc: float
+    """the weighted model count value of the MPE solution."""
+
     mpe: Instance
+    """the MPE solution instance. If there are ties then this will just be once instance."""

ck/pgm_circuit/pgm_circuit.py

@@ -16,33 +16,42 @@ class PGMCircuit:
     holds the values of the parameters. Specifically, given parameter id `param_id`, then
     `parameter_values[slot_map[param_id] - number_of_indicators]` is the value of the
     identified parameter as it was in the PGM.
-
-    Fields:
-        rvs: holds the random variables from the PGM as it was compiled, in order.
-
-        conditions: any conditions on `rvs` that were compiled into the circuit.
-
-        number_of_indicators: is the number of indicators in `rvs` which is
-            `sum(len(rv) for rv in rvs`. Specifically, `circuit.vars[i]` is the circuit variable
-            corresponding to the ith indicator, where `circuit` is `circuit_top.circuit` and
-            indicators are ordered as per `rvs`.
-
-        number_of_parameters: is the number of parameters from the PGM that are
-            represented as circuit variables. This may be zero if parameters from the PGM
-            were compiled as constants.
-
-        slot_map[x]: gives the index of the circuit variable corresponding to x,
-            where x is either a random variable indicator (Indicator) or a parameter id (ParamId).
-
     """
 
     rvs: Sequence[RandomVariable]
+    """holds the random variables from the PGM as it was compiled, in order."""
+
     conditions: Sequence[Indicator]
+    """any conditions on `rvs` that were compiled into the circuit."""
+
     circuit_top: CircuitNode
+    """the top circuit node defining the network function."""
+
     number_of_indicators: int
+    """
+    the number of indicators in `rvs` which is
+    `sum(len(rv) for rv in rvs`. Specifically, `circuit.vars[i]` is the circuit variable
+    corresponding to the ith indicator, where `circuit` is `circuit_top.circuit` and
+    indicators are ordered as per `rvs`.
+    """
+
     number_of_parameters: int
+    """
+    the number of parameters from the PGM that are
+    represented as circuit variables. This may be zero if parameters from the PGM
+    were compiled as constants.
+    """
+
     slot_map: SlotMap
+    """
+    gives the index of the circuit variable corresponding to x,
+    where x is either a random variable indicator (Indicator) or a parameter id (ParamId).
+    """
+
     parameter_values: NDArray
+    """
+    parameter values, co-indexed with the circuit variables, counting beyond `number_of_indicators`.
+    """
 
     def dump(self, *, prefix: str = '', indent: str = '    ') -> None:
         """

ck/pgm_circuit/program_with_slotmap.py

@@ -1,6 +1,8 @@
-from typing import Tuple, Sequence, Dict, Iterable
+from typing import Tuple, Sequence, Dict
 
-from ck.pgm import RandomVariable, rv_instances, Instance, rv_instances_as_indicators, Indicator, ParamId
+import numpy as np
+
+from ck.pgm import RandomVariable, Indicator, ParamId
 from ck.pgm_circuit.slot_map import SlotMap, SlotKey
 from ck.probability.probability_space import Condition, check_condition
 from ck.program.program_buffer import ProgramBuffer
@@ -69,40 +71,6 @@ class ProgramWithSlotmap:
     def slot_map(self) -> SlotMap:
         return self._slot_map
 
-    def instances(self, flip: bool = False) -> Iterable[Instance]:
-        """
-        Enumerate instances of the random variables.
-
-        Each instance is a tuples of state indexes, co-indexed with the given random variables.
-
-        The order is the natural index order (i.e., last random variable changing most quickly).
-
-        Args:
-            flip: if true, then first random variable changes most quickly.
-
-        Returns:
-            an iteration over tuples, each tuple holds state indexes
-            co-indexed with the given random variables.
-        """
-        return rv_instances(*self._rvs, flip=flip)
-
-    def instances_as_indicators(self, flip: bool = False) -> Iterable[Sequence[Indicator]]:
-        """
-        Enumerate instances of the random variables.
-
-        Each instance is a tuples of indicators, co-indexed with the given random variables.
-
-        The order is the natural index order (i.e., last random variable changing most quickly).
-
-        Args:
-            flip: if true, then first random variable changes most quickly.
-
-        Returns:
-            an iteration over tuples, each tuples holds random variable indicators
-            co-indexed with the given random variables.
-        """
-        return rv_instances_as_indicators(*self._rvs, flip=flip)
-
     def compute(self) -> NDArrayNumeric:
         """
         Execute the program to compute and return the result. As per `ProgramBuffer.compute`.
@@ -114,7 +82,10 @@ class ProgramWithSlotmap:
 
     def compute_conditioned(self, *condition: Condition) -> NDArrayNumeric:
         """
-        Equivalent to:
+        Compute the program value, after setting the given condition.
+
+        Equivalent to::
+
             self.set_condition(*condition)
             return self.compute()
         """
@@ -143,29 +114,36 @@ class ProgramWithSlotmap:
         """
         return self._program_buffer.vars
 
-    def __setitem__(self, item: int | slice | SlotKey | Iterable[SlotKey], value: float) -> None:
+    def __setitem__(self, item: int | slice | SlotKey | RandomVariable, value: float) -> None:
         """
-        Set one or more input slot values, identified by slot keys.
+        Set input slot value/s.
         """
         if isinstance(item, (int, slice)):
             self._program_buffer[item] = value
         elif isinstance(item, (Indicator, ParamId)):
             self._program_buffer[self._slot_map[item]] = value
+        elif isinstance(item, RandomVariable):
+            for ind in item:
+                self._program_buffer[self._slot_map[ind]] = value
         else:
-            # Assume its iterable
-            for i in item:
-                self[i] = value
+            raise IndexError(f'unknown index type: {type(item)}')
 
-    def __getitem__(self, item: int | slice | SlotKey) -> NDArrayNumeric:
+    def __getitem__(self, item: int | slice | SlotKey | RandomVariable) -> NDArrayNumeric:
         """
-        Get an input slot value, identified by a slot key.
+        Get input slot value/s.
         """
         if isinstance(item, (int, slice)):
             return self._program_buffer[item]
         elif isinstance(item, (Indicator, ParamId)):
             return self._program_buffer[self._slot_map[item]]
+        elif isinstance(item, RandomVariable):
+            return np.fromiter(
+                (self._program_buffer[self._slot_map[ind]] for ind in item),
+                dtype=self._program_buffer.dtype,
+                count=len(item)
+            )
         else:
-            raise IndexError('unknown index type')
+            raise IndexError(f'unknown index type: {type(item)}')
 
     def set_condition(self, *condition: Condition) -> None:
         """
@@ -208,7 +186,10 @@ class ProgramWithSlotmap:
 
         Args:
             rv: a random variable whose indicators are in the slot map.
-            values: list of values, assumes len(values) == len(rv).
+            values: list of values
+
+        Assumes:
+            len(values) == len(rv).
         """
         for i in range(len(rv)):
             self[rv[i]] = values[i]

ck/pgm_circuit/support/compile_circuit.py

@@ -30,11 +30,9 @@ def compile_results(
         a compiled RawProgram.
     """
     circuit: Circuit = pgm_circuit.circuit_top.circuit
-    if const_parameters:
-        parameter_values = pgm_circuit.parameter_values
-        number_of_indicators = pgm_circuit.number_of_indicators
+    if const_parameters and len(pgm_circuit.parameter_values) > 0:
         with TmpConst(circuit) as tmp:
-            for slot, value in enumerate(parameter_values, start=number_of_indicators):
+            for slot, value in enumerate(pgm_circuit.parameter_values, start=pgm_circuit.number_of_indicators):
                 tmp.set_const(slot, value)
             raw_program: RawProgram = compiler(*results, circuit=circuit)
     else:

ck/pgm_circuit/wmc_program.py

@@ -132,6 +132,11 @@ class WMCProgram(ProgramWithSlotmap, ProbabilitySpace):
         * calls rand.random() once and rand.randrange(...) n times,
         * calls self.program().compute_result() at least once and <= 1 + m.
 
+        For more information about this sampler, see the publication:
+        Suresh, S., Drake, B. (2025). Sampling of Large Probabilistic Graphical Models
+        Using Arithmetic Circuits. AI 2024: Advances in Artificial Intelligence. AI 2024.
+        Lecture Notes in Computer Science, vol 15443. https://doi.org/10.1007/978-981-96-0351-0_13.
+
         Args:
             rvs: the list of random variables to sample; the
                 yielded state vectors are co-indexed with rvs; if None,

ck/pgm_compiler/support/circuit_table/_circuit_table_cy.c

@@ -13,7 +13,7 @@
             "/O2"
         ],
         "include_dirs": [
-            "C:\\Users\\runneradmin\\AppData\\Local\\Temp\\build-env-b7kylfcw\\Lib\\site-packages\\numpy\\_core\\include"
+            "C:\\Users\\runneradmin\\AppData\\Local\\Temp\\build-env-gp1o6j1g\\Lib\\site-packages\\numpy\\_core\\include"
         ],
         "name": "ck.pgm_compiler.support.circuit_table._circuit_table_cy",
         "sources": [