compiled-knowledge 4.0.0a25__cp312-cp312-win32.whl → 4.1.0__cp312-cp312-win32.whl

ck/learning/parameters.py

@@ -0,0 +1,117 @@
+"""
+General functions for setting the parameter values of a PGM.
+"""
+from typing import List, Tuple, TypeAlias
+
+import numpy as np
+
+from ck.dataset.cross_table import CrossTable
+from ck.pgm import PGM, CPTPotentialFunction, Instance, SparsePotentialFunction, DensePotentialFunction, Factor
+from ck.utils.map_list import MapList
+from ck.utils.np_extras import NDArrayFloat64
+
+
+ParameterValues: TypeAlias = List[CrossTable]
+
+
+def make_factors(pgm: PGM, parameter_values: List[CrossTable]) -> None:
+    for factor in parameter_values:
+        pgm.new_factor(*factor.rvs)
+    set_potential_functions(pgm, parameter_values)
+
+
+def set_potential_functions(pgm: PGM, parameter_values: List[CrossTable]) -> None:
+    """
+    Set the potential function of each PGM factor to one heuristically chosen,
+    using the given parameter values. Then set the parameter values of the potential
+    function to those given by `parameter_values`.
+
+    This function modifies `pgm` in-place, iteratively calling `set_potential_function`.
+
+    Args:
+        pgm (PGM): the PGM to have its potential functions set.
+        parameter_values: the parameter values,
+    """
+    for factor, factor_parameter_values in zip(pgm.factors, parameter_values):
+        set_potential_function(factor, factor_parameter_values)
+
+
+def set_potential_function(factor: Factor, parameter_values: CrossTable) -> None:
+    """
+    Set the potential function of the given factor to one heuristically chosen,
+    using the given parameter values. Then set the parameter values of the potential
+    function to those given by `parameter_values`.
+
+    The potential function will be either a ZeroPotentialFunction, DensePotentialFunction,
+    or SparsePotentialFunction.
+
+    This function modifies `factor` in-place.
+
+    Args:
+        factor: The factor to update.
+        parameter_values: the parameter values,
+    """
+    number_of_parameters: int = len(parameter_values)
+    if number_of_parameters == 0:
+        factor.set_zero()
+    else:
+        if number_of_parameters < 100 or number_of_parameters > factor.number_of_states * 0.9:
+            pot_function: DensePotentialFunction = factor.set_dense()
+        else:
+            pot_function: SparsePotentialFunction = factor.set_sparse()
+        for instance, weight in parameter_values.items():
+            pot_function[instance] = weight
+
+
+def set_zero(pgm: PGM) -> None:
+    """
+    Set the potential function of each PGM factor to zero.
+    """
+    for factor in pgm.factors:
+        factor.set_zero()
+
+
+def set_dense(pgm: PGM, parameter_values: List[CrossTable]) -> None:
+    """
+    Set the potential function of each PGM factor to a DensePotentialFunction,
+    using the given parameter values.
+    """
+    for factor, cpt in zip(pgm.factors, parameter_values):
+        pot_function: DensePotentialFunction = factor.set_dense()
+        for instance, weight in cpt.items():
+            pot_function[instance] = weight
+
+
+def set_sparse(pgm: PGM, parameter_values: List[CrossTable]) -> None:
+    """
+    Set the potential function of each PGM factor to a SparsePotentialFunction,
+    using the given parameter values.
+    """
+    for factor, cpt in zip(pgm.factors, parameter_values):
+        pot_function: SparsePotentialFunction = factor.set_sparse()
+        for instance, weight in cpt.items():
+            pot_function[instance] = weight
+
+
+def set_cpt(pgm: PGM, parameter_values: List[CrossTable], normalise_cpds: bool = True) -> None:
+    """
+    Set the potential function of each PGM factor to a CPTPotentialFunction,
+    using the given parameter values.
+    """
+    for factor, cpt in zip(pgm.factors, parameter_values):
+        pot_function: CPTPotentialFunction = factor.set_cpt()
+
+        # Group cpt values by parent instance
+        cpds: MapList[Instance, Tuple[int, float]] = MapList()
+        for instance, weight in cpt.items():
+            cpds.append(instance[1:], (instance[0], weight))
+
+        # Set the CPDs
+        cpd_size = len(cpt.rvs[0])  # size of the child random variable
+        for parent_instance, cpd in cpds.items():
+            cpd_array: NDArrayFloat64 = np.zeros(cpd_size, dtype=np.float64)
+            for child_state_index, weight in cpd:
+                cpd_array[child_state_index] = weight
+            if normalise_cpds:
+                cpd_array /= cpd_array.sum()
+            pot_function.set_cpd(parent_instance, cpd_array)

ck/learning/train_generative_bn.py

@@ -0,0 +1,198 @@
+from __future__ import annotations
+
+from typing import List, Mapping, Tuple
+
+from ck.dataset import SoftDataset, HardDataset
+from ck.dataset.cross_table import CrossTable, cross_table_from_dataset
+from ck.learning.parameters import set_potential_functions, ParameterValues
+from ck.pgm import PGM
+
+
+def train_generative_bn(
+        pgm: PGM,
+        dataset: HardDataset | SoftDataset,
+        *,
+        dirichlet_prior: float | Mapping[int, float | CrossTable] = 0,
+        check_bayesian_network: bool = True,
+) -> None:
+    """
+    Maximum-likelihood, generative training for a Bayesian network.
+
+    The potential function of the given PGM will be set to new potential functions
+    with the learned parameter values.
+
+    Args:
+        pgm: the probabilistic graphical model defining the model structure.
+            Potential function values are ignored and need not be set.
+        dataset: a dataset of random variable states.
+        dirichlet_prior: provides a Dirichlet prior for each factor in `pgm`.
+            This can be represented in multiple ways:
+            (a) as a uniform prior that is the same for all factors, represented as a float value,
+            (b) as a mapping from a factor index to a uniform prior, i.e., a float value,
+            (c) as a mapping from a factor index to an arbitrary Dirichlet prior, i.e., a cross-table.
+            If there is no entry in the mapping for a factor, then the value 0 will be used for that factor.
+            If a cross-table is provided as a prior, then it must have the same random variables as
+            the factor it pertains to.
+            The default value for `dirichlet_prior` is 0.
+            See `CrossTable` for more explanation.
+        check_bayesian_network: if true and not `pgm.is_structure_bayesian` an exception will be raised.
+
+    Raises:
+        ValueError: if the given PGM does not have a Bayesian network structure, and check_bayesian_network is True.
+    """
+    if check_bayesian_network and not pgm.is_structure_bayesian:
+        raise ValueError('the given PGM is not a Bayesian network')
+    cpts: List[CrossTable] = get_cpts(
+        pgm=pgm,
+        dataset=dataset,
+        dirichlet_prior=dirichlet_prior,
+    )
+    set_potential_functions(pgm, cpts)
+
+
+def get_cpts(
+        pgm: PGM,
+        dataset: HardDataset | SoftDataset,
+        *,
+        dirichlet_prior: float | Mapping[int, float | CrossTable] = 0,
+) -> ParameterValues:
+    """
+    This function applies `cpt_from_crosstab` to each cross-table from `get_factor_cross_tables`.
+    The resulting parameter values are CPTs that can be used directly to update the parameters
+    of the given PGM, so long as it has a Bayesian network structure.
+
+    To update the given PGM from the resulting `cpts` use `set_potential_functions(pgm, cpts)`.
+
+    Args:
+        pgm: the probabilistic graphical model defining the model structure.
+            Potential function values are ignored and need not be set.
+        dataset: a dataset of random variable states.
+        dirichlet_prior: provides a Dirichlet prior for each factor in `pgm`.
+            This can be represented in multiple ways:
+            (a) as a uniform prior that is the same for all factors, represented as a float value,
+            (b) as a mapping from a factor index to a uniform prior, i.e., a float value,
+            (c) as a mapping from a factor index to an arbitrary Dirichlet prior, i.e., a cross-table.
+            If there is no entry in the mapping for a factor, then the value 0 will be used for that factor.
+            If a cross-table is provided as a prior, then it must have the same random variables as
+            the factor it pertains to.
+            The default value for `dirichlet_prior` is 0.
+            See `CrossTable` for more explanation.
+
+    Returns:
+        ParameterValues object, a CPT for each factor in the given PGM, as a list of cross-tables, co-indexed
+        with the PGM factors.
+    """
+    cross_tables: List[CrossTable] = get_factor_cross_tables(
+        pgm=pgm,
+        dataset=dataset,
+        dirichlet_prior=dirichlet_prior,
+    )
+    cpts: List[CrossTable] = list(map(cpt_from_crosstab, cross_tables))
+    return cpts
+
+
+def get_factor_cross_tables(
+        pgm: PGM,
+        dataset: HardDataset | SoftDataset,
+        *,
+        dirichlet_prior: float | Mapping[int, float | CrossTable] = 0,
+) -> ParameterValues:
+    """
+    Compute a cross-table for each factor of the given PGM, using the data from
+    the given dataset.
+
+    Args:
+        pgm: the probabilistic graphical model defining the model structure.
+            Potential function values are ignored and need not be set.
+        dataset: a dataset of random variable states.
+        dirichlet_prior: provides a Dirichlet prior for each factor in `pgm`.
+            This can be represented in multiple ways:
+            (a) as a uniform prior that is the same for all factors, represented as a float value,
+            (b) as a mapping from a factor index to a uniform prior, i.e., a float value,
+            (c) as a mapping from a factor index to an arbitrary Dirichlet prior, i.e., a cross-table.
+            If there is no entry in the mapping for a factor, then the value 0 will be used for that factor.
+            If a cross-table is provided as a prior, then it must have the same random variables as
+            the factor it pertains to.
+            The default value for `dirichlet_prior` is 0.
+            See `CrossTable` for more explanation.
+
+    Returns:
+        ParameterValues object, a crosstable for each factor in the given PGM, as
+        per `cross_table_from_dataset`.
+
+    Assumes:
+        every random variable of the PGM is in the dataset.
+    """
+    factor_dict: Mapping[int, float | CrossTable]
+    default_prior: float
+    if isinstance(dirichlet_prior, (float, int)):
+        factor_dict = {}
+        default_prior = dirichlet_prior
+    else:
+        factor_dict = dirichlet_prior
+        default_prior = 0
+
+    cross_tables: List[CrossTable] = [
+        cross_table_from_dataset(
+            dataset,
+            factor.rvs,
+            dirichlet_prior=factor_dict.get(factor.idx, default_prior),
+        )
+        for factor in pgm.factors
+    ]
+    return cross_tables
+
+
+def cpt_from_crosstab(crosstab: CrossTable) -> CrossTable:
+    """
+    Convert the given cross-table to a conditional probability table (CPT),
+    assuming the first random variable of the cross-table is the child
+    and remaining random variables are the parents.
+
+    Args:
+        crosstab: a CrossTable representing the weight of unique instances.
+
+    Returns:
+        A cross-table that is a conditional probability table.
+
+    Assumes:
+        the first random variable in `crosstab.rvs` is the child random variable.
+    """
+    return cpt_and_parent_sums_from_crosstab(crosstab)[0]
+
+
+def cpt_and_parent_sums_from_crosstab(crosstab: CrossTable) -> Tuple[CrossTable, CrossTable]:
+    """
+    Convert the given cross-table to a conditional probability table (CPT),
+    assuming the first random variable of the cross-table is the child
+    and remaining random variables are the parents.
+
+    Args:
+        crosstab: a CrossTable representing the weight of unique instances.
+
+    Returns:
+        A cross-table that is a conditional probability table.
+        A cross-table of the parent sums that were divided out of `crosstab`
+
+    Assumes:
+        the first random variable in `crosstab.rvs` is the child random variable.
+    """
+    # Get the sum of weights for parent states
+    parent_sums: CrossTable = CrossTable(
+        rvs=crosstab.rvs[1:],
+        update=(
+            (instance[1:], weight)
+            for instance, weight in crosstab.items()
+        )
+    )
+
+    # Construct the normalised cross-tables, i.e., the CPTs.
+    cpt = CrossTable(
+        rvs=crosstab.rvs,
+        update=(
+            (instance, weight / parent_sums[instance[1:]])
+            for instance, weight in crosstab.items()
+        )
+    )
+
+    return cpt, parent_sums

ck/pgm.py

@@ -19,16 +19,18 @@ State: TypeAlias = Union[int, str, bool, float, None]
 The type for a possible state of a random variable.
 """
 
-Instance: TypeAlias = Sequence[int]
+Instance: TypeAlias = Tuple[int, ...]
 """
-An instance (of a sequence of random variables) is a sequence of integers
+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[Instance, int]
+Key: TypeAlias = Union[Sequence[int], int]
 """
-A key identifies an instance, either as an instance itself or a
-single integer, representing an instance with one dimension.
+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]
@@ -594,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
@@ -776,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})')
@@ -790,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)
@@ -1871,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:
         """
@@ -2029,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
@@ -3364,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.
 
@@ -3409,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/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`.
@@ -146,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:
         """
@@ -211,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-8cwjzb8_\\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": [

ck/probability/cross_table_probability_space.py

@@ -0,0 +1,53 @@
+from typing import Sequence, Tuple, Dict
+
+from ck.dataset.cross_table import CrossTable, Instance
+from ck.pgm import RandomVariable, Indicator
+from ck.probability.probability_space import ProbabilitySpace, Condition, check_condition
+
+
+class CrossTableProbabilitySpace(ProbabilitySpace):
+    def __init__(self, cross_table: CrossTable):
+        """
+        Enable probabilistic queries over a sample from a sample space.
+        Note that this is not necessarily an efficient approach to calculating probabilities and statistics.
+
+        Args:
+            cross_table: a CrossTable to adapt to a ProbabilitySpace.
+        """
+        self._cross_table: CrossTable = cross_table
+        self._rv_idx_to_sample_idx: Dict[int, int] = {
+            rv.idx: i
+            for i, rv in enumerate(cross_table.rvs)
+        }
+
+    @property
+    def rvs(self) -> Sequence[RandomVariable]:
+        return self._cross_table.rvs
+
+    def wmc(self, *condition: Condition) -> float:
+        condition: Tuple[Indicator, ...] = check_condition(condition)
+        rvs: Sequence[RandomVariable] = self._cross_table.rvs
+
+        checks = [set() for _ in rvs]
+        for ind in condition:
+            checks[self._rv_idx_to_sample_idx[ind.rv_idx]].add(ind.state_idx)
+        for i in range(len(checks)):
+            if len(checks[i]) > 0:
+                checks[i] = set(range(len(rvs[i]))).difference(checks[i])
+
+        def satisfied(item: Tuple[Instance, float]) -> float:
+            """
+            Return the weight of the instance, if the instance satisfies
+            the condition, else return 0.
+            """
+            instance, weight = item
+            if any((state in check) for state, check in zip(instance, checks)):
+                return 0
+            else:
+                return weight
+
+        return sum(map(satisfied, self._cross_table.items()))
+
+    @property
+    def z(self) -> float:
+        return self._cross_table.total_weight()