compiled-knowledge 4.0.0a23__cp312-cp312-win32.whl → 4.0.0a25__cp312-cp312-win32.whl

ck/pgm.py

@@ -1,6 +1,3 @@
-"""
-For more documentation on this module, refer to the Jupyter notebook docs/4_PGM_advanced.ipynb.
-"""
 from __future__ import annotations
 
 import math
@@ -8,7 +5,7 @@ from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from itertools import repeat as _repeat
 from typing import Sequence, Tuple, Dict, Optional, overload, Set, Iterable, List, Union, Callable, \
-    Collection, Any, Iterator
+    Collection, Any, Iterator, TypeAlias
 
 import numpy as np
 
@@ -17,21 +14,33 @@ from ck.utils.iter_extras import (
 )
 from ck.utils.np_extras import NDArrayFloat64, NDArrayUInt8
 
-# What types are permitted as random variable states
-State = Union[int, str, bool, float, None]
+State: TypeAlias = Union[int, str, bool, float, None]
+"""
+The type for a possible state of a random variable.
+"""
 
-# 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.
-Instance = Sequence[int]
+Instance: TypeAlias = Sequence[int]
+"""
+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.
+"""
 
-# A key identifies an instance.
-# A single integer is treated as an instance with one dimension.
-Key = Union[Sequence[int], int]
+Key: TypeAlias = Union[Instance, int]
+"""
+A key identifies an instance, either as an instance itself or a
+single integer, representing an instance with one dimension.
+"""
 
-# The shape of a sequence of random variables (e.g., a PGM, Factor or PotentialFunction).
-Shape = Sequence[int]
+Shape: TypeAlias = Sequence[int]
+"""
+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_TOLERANCE: float = 0.000001  # For checking CPT sums.
+DEFAULT_CPT_TOLERANCE: float = 0.000001
+"""
+A tolerance when checking CPT distributions sum to one (or zero).
+"""
 
 
 class PGM:
@@ -39,11 +48,9 @@ class PGM:
     A probabilistic graphical model (PGM) represents a joint probability distribution over
     a set of random variables. Specifically, a PGM is a factor graph with discrete random variables.
 
-    Add a random variable to a PGM, pgm, using `rv = pgm.new_rv(...)`.
-
-    Add a factor to the PGM, pgm, using `factor = pgm.new_factor(...)`.
+    Add a random variable to a PGM, `pgm`, using `rv = pgm.new_rv(...)`.
 
-    A PGM may be given a human-readable name.
+    Add a factor to the PGM, `pgm`, using `factor = pgm.new_factor(...)`.
     """
 
     def __init__(self, name: Optional[str] = None):
@@ -206,14 +213,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.
@@ -233,10 +243,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.
@@ -328,17 +339,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.
@@ -370,16 +382,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.
 
@@ -398,16 +411,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.
         """
@@ -587,7 +601,7 @@ class PGM:
         # All tests passed
         return True
 
-    def factors_are_cpts(self, tolerance: float = DEFAULT_TOLERANCE) -> bool:
+    def factors_are_cpts(self, tolerance: float = DEFAULT_CPT_TOLERANCE) -> bool:
         """
         Are all factor potential functions set with parameters values
         conforming to Conditional Probability Tables.
@@ -603,7 +617,7 @@ class PGM:
         """
         return all(function.is_cpt(tolerance) for function in self.functions)
 
-    def check_is_bayesian_network(self, tolerance: float = DEFAULT_TOLERANCE) -> bool:
+    def check_is_bayesian_network(self, tolerance: float = DEFAULT_CPT_TOLERANCE) -> bool:
         """
         Is this PGM a Bayesian network.
 
@@ -648,7 +662,7 @@ class PGM:
         This method has the same semantics as `ProbabilitySpace.wmc` without conditioning.
 
         Warning:
-            this is potentially computationally expensive as it marginalised random
+            this is potentially computationally expensive as it marginalises random
             variables not mentioned in the given indicators.
 
         Args:
@@ -658,29 +672,11 @@ class PGM:
             the product of factors, conditioned on the given instance. This is the
             computed value of the PGM, conditioned on the given instance.
         """
-        # # Create a filter from the indicators
-        # inst_filter: List[Set[int]] = [set() for _ in range(self.number_of_rvs)]
-        # for indicator in indicators:
-        #     rv_idx: int = indicator.rv_idx
-        #     inst_filter[rv_idx].add(indicator.state_idx)
-        # # Collect rvs not mentioned - to marginalise
-        # for rv, rv_filter in zip(self.rvs, inst_filter):
-        #     if len(rv_filter) == 0:
-        #         rv_filter.update(rv.state_range())
-        #
-        # def _sum_inst(_instance: Instance) -> bool:
-        #     return all(
-        #         (_state in _rv_filter)
-        #         for _state, _rv_filter in zip(_instance, inst_filter)
-        #     )
-        #
-        # # Accumulate the result
-        # sum_value = 0
-        # for instance in self.instances():
-        #     if _sum_inst(instance):
-        #         sum_value += self.value_product(instance)
-        #
-        # return sum_value
+        # Rather than naively checking all possible states of the PGM random
+        # variables, this method works to define the state space that should
+        # be summed over, based on the given indicators. Thus, if the given
+        # indicators constrain the state space to a small number of possibilities,
+        # then the sum is only performed over those possibilities.
 
         # Work out the space to sum over
         sum_space_set: List[Optional[Set[int]]] = [None] * self.number_of_rvs
@@ -719,11 +715,10 @@ class PGM:
             precision: a limit on the render precision of floating point numbers.
             max_state_digits: a limit on the number of digits when showing number of states as an integer.
         """
-        # limit the precision when displaying number of states
+        # Determine a limit to precision when displaying number of states
         num_states: int = self.number_of_states
         number_of_parameters = sum(function.number_of_parameters for function in self.functions)
         number_of_nz_parameters = sum(function.number_of_parameters for function in self.non_zero_functions)
-
         if math.log10(num_states) > max_state_digits:
             log_states = math.log10(num_states)
             exp = int(log_states)
@@ -731,7 +726,6 @@ class PGM:
             num_states_str = f'{man:,.{precision}f}e+{exp}'
         else:
             num_states_str = f'{num_states:,}'
-
         log_2_num_states = math.log2(num_states)
         if (
                 log_2_num_states == 0
@@ -820,9 +814,9 @@ class PGM:
 
         For a factor `f` the value of states[f.idx] is the search state.
         Specifically:
-        state 0 => the factor has not been seen yet,
-        state 1 => the factor is seen but not fully processed,
-        state 2 => the factor is fully processed.
+            state 0 => the factor has not been seen yet,
+            state 1 => the factor is seen but not fully processed,
+            state 2 => the factor is fully processed.
 
         Args:
             factor: the current Factor being checked.
@@ -942,9 +936,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.
@@ -954,15 +948,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
@@ -1040,7 +1037,7 @@ class RandomVariable(Sequence[Indicator]):
 
     def state_range(self) -> Iterable[int]:
         """
-        Iterate over the state indexes of this random variable, in order.
+        Iterate over the state indexes of this random variable, in ascending order.
 
         Returns:
             range(len(self))
@@ -1122,18 +1119,19 @@ class RandomVariable(Sequence[Indicator]):
 
     def __eq__(self, other) -> bool:
         """
-        Two random variable are equal if they are the same object.
+        Two random variables are equal if they are the same object.
         """
         return self is other
 
     def equivalent(self, other: RandomVariable | Sequence[Indicator]) -> bool:
         """
-        Two random variable are equivalent if their indicators are equal. Only
-        random variable indexes and state indexes are checked.
-
+        Two random variable are equivalent if their indicators are equal.
+        Only random variable indexes and state indexes are checked.
         This ignores the names of the random variable and the names of their states.
-        This means their indicators will work correctly in slot maps, even
-        if from different PGMs.
+
+        Slot maps operate across `equivalent` random variables.
+        This means indicators of equivalent random variables will work
+        correctly in slot maps, even if from different PGMs.
 
         Args:
             other: either a random variable or a sequence of Indicators.
@@ -1181,7 +1179,8 @@ class RandomVariable(Sequence[Indicator]):
         """
         Returns the first index of `value`.
         Raises ValueError if the value is not present.
-        Contracted by Sequence[Indicator].
+
+        This method is contracted by `Sequence[Indicator]`.
 
         Warning:
             This method is different to `self.idx`.
@@ -1198,7 +1197,10 @@ class RandomVariable(Sequence[Indicator]):
     def count(self, value: Any) -> int:
         """
         Returns the number of occurrences of `value`.
-        Contracted by Sequence[Indicator].
+        That is, if `value` is an indicator of this random variable
+        then 1 is returned, otherwise 0 is returned.
+
+        This method is contracted by `Sequence[Indicator]`.
         """
         if isinstance(value, Indicator):
             if value.rv_idx == self._idx and 0 <= value.state_idx < len(self):
@@ -1210,25 +1212,25 @@ class RVMap(Sequence[RandomVariable]):
     """
     Wrap a PGM to provide convenient access to PGM random variables.
 
-    An RVMap of a PGM behaves exactly like the PGM `rvs` property. That it, it
-    behaves like a sequence of RandomVariable objects.
+    An RVMap of a PGM behaves like the PGM `rvs` property (sequence of
+    RandomVariable objects), with additional access methods for the PGM's
+    random variables.
 
     If the underlying PGM is updated, then the RVMap will automatically update.
 
-    Additionally, an RVMap enables access to the PGM random variable via the name
-    of each random variable.
+    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::
 
-    for example, if `pgm.rvs[1]` is a random variable named `xray`, then
-    ```
-    rvs = RVMap(pgm)
+        rvs = RVMap(pgm)
 
-    # These all retrieve the same random variable object.
-    xray = rvs[1]
-    xray = rvs('xray')
-    xray = rvs.xray
-    ```
+        # 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 variable names must be unique across the PGM.
+    To use an RVMap on a PGM, the random variable names must be unique across the PGM.
     """
 
     def __init__(self, pgm: PGM, ignore_case: bool = False):
@@ -1248,28 +1250,6 @@ class RVMap(Sequence[RandomVariable]):
         # This may raise an exception.
         _ = self._rv_map
 
-    def _clean_name(self, name: str) -> str:
-        """
-        Adjust the case of the given name as needed.
-        """
-        return name.lower() if self._ignore_case else name
-
-    @property
-    def _rv_map(self) -> Dict[str, RandomVariable]:
-        """
-        Get the cached rv map, updating as needed if the PGM changed.
-        Returns:
-            a mapping from random variable name to random variable
-        """
-        if len(self.__rv_map) != len(self._pgm.rvs):
-            # There is a difference between the map and the PGM - create a new map.
-            self.__rv_map = {self._clean_name(rv.name): rv for rv in self._pgm.rvs}
-            if len(self.__rv_map) != len(self._pgm.rvs):
-                raise RuntimeError(f'random variable names are not unique')
-            if not self._reserved_names.isdisjoint(self.__rv_map.keys()):
-                raise RuntimeError(f'random variable names clash with reserved names.')
-        return self.__rv_map
-
     def new_rv(self, name: str, states: Union[int, Sequence[State]]) -> RandomVariable:
         """
         As per `PGM.new_rv`.
@@ -1304,6 +1284,29 @@ class RVMap(Sequence[RandomVariable]):
     def __getattr__(self, rv_name: str) -> RandomVariable:
         return self(rv_name)
 
+    @property
+    def _rv_map(self) -> Dict[str, RandomVariable]:
+        """
+        Get the cached random variable map, updating as needed if the PGM changed.
+
+        Returns:
+            a mapping from random variable name to random variable
+        """
+        if len(self.__rv_map) != len(self._pgm.rvs):
+            # There is a difference between the map and the PGM - create a new map.
+            self.__rv_map = {self._clean_name(rv.name): rv for rv in self._pgm.rvs}
+            if len(self.__rv_map) != len(self._pgm.rvs):
+                raise RuntimeError(f'random variable names are not unique')
+            if not self._reserved_names.isdisjoint(self.__rv_map.keys()):
+                raise RuntimeError(f'random variable names clash with reserved names.')
+        return self.__rv_map
+
+    def _clean_name(self, name: str) -> str:
+        """
+        Adjust the case of the given name as needed.
+        """
+        return name.lower() if self._ignore_case else name
+
 
 class Factor:
     """
@@ -1532,7 +1535,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:
@@ -1544,7 +1547,7 @@ class Factor:
         self._potential_function = ClausePotentialFunction(self, key)
         return self._potential_function
 
-    def set_cpt(self, tolerance: float = DEFAULT_TOLERANCE) -> CPTPotentialFunction:
+    def set_cpt(self, tolerance: float = DEFAULT_CPT_TOLERANCE) -> CPTPotentialFunction:
         """
         Set to the potential function to a new `CPTPotentialFunction` object.
 
@@ -1561,7 +1564,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.
@@ -1820,7 +1823,7 @@ class PotentialFunction(ABC):
         """
         ...
 
-    def is_cpt(self, tolerance=DEFAULT_TOLERANCE) -> bool:
+    def is_cpt(self, tolerance=DEFAULT_CPT_TOLERANCE) -> bool:
         """
         Is the potential function set with parameters values conforming to a
         Conditional Probability Table.
@@ -2028,7 +2031,7 @@ class ZeroPotentialFunction(PotentialFunction):
     def param_idx(self, key: Key) -> int:
         return _natural_key_idx(self._shape, key)
 
-    def is_cpt(self, tolerance=DEFAULT_TOLERANCE) -> bool:
+    def is_cpt(self, tolerance=DEFAULT_CPT_TOLERANCE) -> bool:
         return True
 
 
@@ -2169,7 +2172,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)
@@ -2214,7 +2217,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
@@ -2419,7 +2422,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)
@@ -2641,7 +2644,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)
@@ -2684,7 +2687,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
@@ -2836,7 +2839,7 @@ class ClausePotentialFunction(PotentialFunction):
         else:
             return None
 
-    def is_cpt(self, tolerance=DEFAULT_TOLERANCE) -> bool:
+    def is_cpt(self, tolerance=DEFAULT_CPT_TOLERANCE) -> bool:
         """
         A ClausePotentialFunction can only be a CTP when all entries are zero.
         """
@@ -2930,7 +2933,7 @@ class CPTPotentialFunction(PotentialFunction):
     def number_of_parameters(self) -> int:
         return len(self._values)
 
-    def is_cpt(self, tolerance=DEFAULT_TOLERANCE) -> bool:
+    def is_cpt(self, tolerance=DEFAULT_CPT_TOLERANCE) -> bool:
         if tolerance >= self._tolerance:
             return True
         else:
@@ -3015,12 +3018,11 @@ class CPTPotentialFunction(PotentialFunction):
 
     def cpds(self) -> Iterable[Tuple[Instance, Sequence[float]]]:
         """
-        Iterate over (parent_states, cpd) tuples.
-        This will exclude zero CPDs.
-        Do not change CPDs to (or from) zero while iterating over them.
-        
-        Get the CPD conditioned on parent states indicated by `parent_states`.
-        
+        Iterate over (parent_states, cpd) tuples. This will exclude zero CPDs.
+
+        Warning:
+            Do not change CPDs to (or from) zero while iterating over them.
+
         Returns:
             an iterator over pairs (instance, cpd) where,
             instance: is indicates the state of the parent random variables.
@@ -3077,7 +3079,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)),
@@ -3085,9 +3088,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.
@@ -3111,7 +3114,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.
@@ -3288,7 +3291,7 @@ def check_key(shape: Shape, key: Key) -> Instance:
         A instance from the state space, as a tuple of state indexes, co-indexed with the given shape.
 
     Raises:
-        KeyError if the key is not valid.
+        KeyError if the key is not valid for the given shape.
     """
     _key: Instance = _key_to_instance(key)
     if len(_key) != len(shape):
@@ -3336,8 +3339,8 @@ def rv_instances(*rvs: RandomVariable, flip: bool = False) -> Iterable[Instance]
         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.
+        an iteration over instances, each instance is a tuple of state
+        indexes, co-indexed with the given random variables.
     """
     shape = [len(rv) for rv in rvs]
     return _combos_ranges(shape, flip=not flip)
@@ -3384,6 +3387,10 @@ def _natural_key_idx(shape: Shape, key: Key) -> int:
     """
     What is the natural index of the given key, assuming the given shape.
 
+    The natural index of an instance is defined as the index of the
+    instance if all instances for the shape are enumerated as per
+    `rv_instances`.
+
     Args:
         shape: the shape defining the state space.
         key: a key into the state space.

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."""