compiled-knowledge 4.0.0a16__cp312-cp312-win_amd64.whl → 4.0.0a17__cp312-cp312-win_amd64.whl

ck/circuit_compiler/cython_vm_compiler/_compiler.pyx

@@ -1,17 +1,15 @@
 from __future__ import annotations
 
-from pickletools import long1
-from typing import Sequence, Dict, List, Tuple, Set, Optional, Iterator
+from typing import Dict, Tuple, Sequence
 
 import numpy as np
 import ctypes as ct
 
 from ck import circuit
-from ck.circuit import CircuitNode, ConstNode, VarNode, OpNode, ADD, Circuit
+from ck.circuit import OpNode, VarNode, CircuitNode
 from ck.circuit_compiler.support.circuit_analyser import CircuitAnalysis, analyze_circuit
-from ck.circuit_compiler.support.input_vars import infer_input_vars, InputVars
-from ck.program.raw_program import RawProgram, RawProgramFunction
-from ck.utils.np_extras import DType, NDArrayNumeric, NDArray, DTypeNumeric
+from ck.program.raw_program import RawProgramFunction
+from ck.utils.np_extras import NDArrayNumeric, DTypeNumeric
 
 from cpython.mem cimport PyMem_Malloc, PyMem_Realloc, PyMem_Free
 
@@ -63,21 +61,21 @@ def make_function(
 
 
 # VM instructions
-ADD = circuit.ADD
-MUL = circuit.MUL
-COPY: int = max(ADD, MUL) + 1
+cdef int ADD = circuit.ADD
+cdef int MUL = circuit.MUL
+cdef int COPY = max(ADD, MUL) + 1
 
 # VM arrays
-VARS: int = 0
-TMPS: int = 1
-CONSTS: int = 2
-RESULT: int = 3
+cdef int VARS = 0
+cdef int TMPS = 1
+cdef int CONSTS = 2
+cdef int RESULT = 3
 
 
-def _make_instructions_from_analysis(
-        analysis: CircuitAnalysis,
-        dtype: DTypeNumeric,
-) -> Tuple[Instructions, NDArrayNumeric]:
+cdef tuple[Instructions, cnp.ndarray] _make_instructions_from_analysis(
+        object analysis: CircuitAnalysis,
+        object dtype: DTypeNumeric,
+): # -> Tuple[Instructions, NDArrayNumeric]:
     if dtype != np.float64:
         raise RuntimeError(f'only DType {np.float64} currently supported')
 
@@ -91,7 +89,7 @@ def _make_instructions_from_analysis(
         np_consts[i] = node.value
 
     # Where to get input values for each possible node.
-    node_to_element: Dict[int, ElementID] = {}
+    cdef dict[int, ElementID] node_to_element  = {}
     # const nodes
     for node_id, const_idx in node_to_const_idx.items():
         node_to_element[node_id] = ElementID(CONSTS, const_idx)
@@ -110,21 +108,16 @@ def _make_instructions_from_analysis(
     # Build instructions
     instructions: Instructions = Instructions()
 
-    op_node: OpNode
+    cdef object op_node
     for op_node in analysis.op_nodes:
-        dest: ElementID = node_to_element[id(op_node)]
-        args: list[ElementID] = [
-            node_to_element[id(arg)]
-            for arg in op_node.args
-        ]
-        instructions.append(op_node.symbol, args, dest)
+        instructions.append_op(op_node.symbol, op_node, node_to_element)
 
     # Add any copy operations, i.e., result nodes that are not op nodes
     for i, node in enumerate(analysis.result_nodes):
         if not isinstance(node, OpNode):
             dest: ElementID = ElementID(RESULT, i)
-            args: list[ElementID] = [node_to_element[id(node)]]
-            instructions.append(COPY, args, dest)
+            src: ElementID = node_to_element[id(node)]
+            instructions.append_copy(src, dest)
 
     return instructions, np_consts
 
@@ -143,32 +136,63 @@ cdef struct Instruction:
 
 cdef class Instructions:
     cdef Instruction* instructions
+    cdef int allocated
     cdef int num_instructions
 
-    def __init__(self):
-        self.instructions = <Instruction*> PyMem_Malloc(0)
+    def __init__(self) -> None:
         self.num_instructions = 0
+        self.allocated = 64
+        self.instructions = <Instruction*> PyMem_Malloc(self.allocated * sizeof(Instruction))
+
+    cdef void append_copy(
+            self,
+            ElementID src,
+            ElementID dest,
+    ) except*:
+        c_args = <ElementID*> PyMem_Malloc(sizeof(ElementID))
+        if not c_args:
+            raise MemoryError()
 
-    def append(self, int symbol, list[ElementID] args, ElementID dest) -> None:
+        c_args[0] = src
+        self._append(COPY, 1, c_args, dest)
+
+    cdef void append_op(self, int symbol, object op_node: OpNode, dict[int, ElementID] node_to_element) except*:
+        args = op_node.args
         cdef int num_args = len(args)
-        cdef int i
 
-        c_args = <ElementID*> PyMem_Malloc(
-            num_args * sizeof(ElementID))
+        # Create the instruction arguments array
+        c_args = <ElementID*> PyMem_Malloc(num_args * sizeof(ElementID))
         if not c_args:
             raise MemoryError()
 
-        for i in range(num_args):
-            c_args[i] = args[i]
+        cdef int i = num_args
+        while i > 0:
+            i -= 1
+            c_args[i] = node_to_element[id(args[i])]
+
+        dest: ElementID = node_to_element[id(op_node)]
+
+        self._append(symbol, num_args, c_args, dest)
+
+
+    cdef void _append(self, int symbol, int num_args, ElementID* c_args, ElementID dest) except *:
+        cdef int i
 
         cdef int num_instructions = self.num_instructions
-        self.instructions = <Instruction*> PyMem_Realloc(
-            self.instructions,
-            sizeof(Instruction) * (num_instructions + 1)
-        )
-        if not self.instructions:
-            raise MemoryError()
 
+        # Ensure sufficient instruction memory
+        cdef int allocated = self.allocated
+        if num_instructions == allocated:
+            allocated *= 2
+            self.instructions = <Instruction*> PyMem_Realloc(
+                self.instructions,
+                allocated * sizeof(Instruction),
+            )
+            if not self.instructions:
+                raise MemoryError()
+            self.allocated = allocated
+
+        # Add the instruction
         self.instructions[num_instructions] = Instruction(
             symbol,
             num_args,
@@ -177,7 +201,7 @@ cdef class Instructions:
         )
         self.num_instructions = num_instructions + 1
 
-    def __dealloc__(self):
+    def __dealloc__(self) -> None:
         cdef Instruction* instructions = self.instructions
         if instructions:
             for i in range(self.num_instructions):
@@ -194,15 +218,15 @@ cdef void cvm_float64(
     double* consts,
     double* result,
     Instructions instructions,
-):
-    # Core virtual machine.
+) except *:
+    # Core virtual machine (for dtype float64).
 
-    cdef int i, num_args, symbol
+    cdef int i, symbol
     cdef double accumulator
     cdef ElementID* args
-    cdef ElementID elem
+    cdef ElementID  elem
 
-    # index the four arrays by constants VARS, TMPS, CONSTS, and RESULT
+    # Index the four arrays by constants VARS, TMPS, CONSTS, and RESULT
     cdef (double*) arrays[4]
     arrays[VARS] = vars_in
     arrays[TMPS] = tmps
@@ -210,29 +234,32 @@ cdef void cvm_float64(
     arrays[RESULT] = result
 
     cdef Instruction* instruction_ptr = instructions.instructions
-    for _ in range(instructions.num_instructions):
+    cdef int num_instructions = instructions.num_instructions
 
-        symbol = instruction_ptr[0].symbol
-        args = instruction_ptr[0].args
-        num_args = instruction_ptr[0].num_args
+    while num_instructions > 0:
+        num_instructions -= 1
+
+        symbol = instruction_ptr.symbol
+        args = instruction_ptr.args
 
         elem = args[0]
         accumulator = arrays[elem.array][elem.index]
 
         if symbol == ADD:
-            for i in range(1, num_args):
+            i = instruction_ptr.num_args
+            while i > 1:
+                i -= 1
                 elem = args[i]
                 accumulator += arrays[elem.array][elem.index]
         elif symbol == MUL:
-            for i in range(1, num_args):
+            i = instruction_ptr.num_args
+            while i > 1:
+                i -= 1
                 elem = args[i]
                 accumulator *= arrays[elem.array][elem.index]
-        elif symbol == COPY:
-            pass
-        else:
-            raise RuntimeError('symbol not understood: ' + str(symbol))
+        # else symbol == COPY, nothing to do
 
-        elem = instruction_ptr[0].dest
+        elem = instruction_ptr.dest
         arrays[elem.array][elem.index] = accumulator
 
         # Advance the instruction pointer

ck/circuit_compiler/named_circuit_compilers.py

@@ -54,4 +54,4 @@ class NamedCircuitCompiler(Enum):
         return self.value[0]
 
 
-DEFAULT_CIRCUIT_COMPILER: NamedCircuitCompiler = NamedCircuitCompiler.LLVM_VM
+DEFAULT_CIRCUIT_COMPILER: NamedCircuitCompiler = NamedCircuitCompiler.CYTHON_VM

ck/pgm_compiler/factor_elimination.py

@@ -149,7 +149,7 @@ def join_tree_to_circuit(
         limit_product_tree_search,
     )
     top: CircuitNode = top_table.top()
-    top_table.circuit.remove_unreachable_op_nodes(top)
+    top.circuit.remove_unreachable_op_nodes(top)
 
     return PGMCircuit(
         rvs=tuple(pgm.rvs),
@@ -169,27 +169,37 @@ def _circuit_tables_from_join_tree(
 ) -> CircuitTable:
     """
     This is a basic algorithm for constructing a circuit table from a join tree.
+    Algorithm synopsis:
+    1) Get a CircuitTable for each factor allocated to this join tree node, and
+       for each child of the join tree node (recursive call to _circuit_tables_from_join_tree).
+    2) Form a binary tree of the collected circuit tables.
+    3) Perform table products and sum-outs for each node in the binary tree, which should
+       leave a single circuit table with a single row.
     """
-    # The PGM factors allocated to this join tree node
-    factors: List[CircuitTable] = [
-        factor_tables.get_table(factor)
-        for factor in join_tree.factors
-    ]
-
-    # The children of this join tree node
-    factors.extend(
-        _circuit_tables_from_join_tree(factor_tables, child, limit_product_tree_search)
-        for child in join_tree.children
+    # Get all the factors to combine.
+    factors: List[CircuitTable] = list(
+        chain(
+            (
+                # The PGM factors allocated to this join tree node
+                factor_tables.get_table(factor)
+                for factor in join_tree.factors
+            ),
+            (
+                # The children of this join tree node
+                _circuit_tables_from_join_tree(factor_tables, child, limit_product_tree_search)
+                for child in join_tree.children
+            ),
+        )
     )
 
     # The usual join tree approach just forms the product all the tables in `factors`.
     # The tree width is not affected by the order of products, however some orders
     # lead to smaller numbers of arithmetic operations.
     #
-    # If `options.optimise_products` is true, then heuristics are used
+    # If `limit_product_tree_search > 1`, then heuristics are used
     # reduce the number of arithmetic operations.
 
-    # Deal with the special case: no factors
+    # Deal with the special case: zero factors
     if len(factors) == 0:
         circuit = factor_tables.circuit
         if len(join_tree.separator) == 0:

ck/pgm_compiler/support/circuit_table/__init__.py

@@ -1,5 +1,5 @@
-# from .circuit_table_py import (
-from .circuit_table import (
+# from ._circuit_table_py import (
+from ._circuit_table_cy import (
     CircuitTable,
     TableInstance,
     sum_out,

ck/pgm_compiler/support/circuit_table/{circuit_table.pyx → _circuit_table_cy.pyx}

@@ -142,7 +142,7 @@ cpdef object sum_out(object table: CircuitTable, object rv_idxs: Iterable[int]):
 
     for group_instance_tuple, to_add in groups.items():
         node = circuit.optimised_add(to_add)
-        if not node.is_zero():
+        if not node.is_zero:
             rows[group_instance_tuple] = node
 
     return new_table
@@ -159,7 +159,7 @@ cpdef object sum_out_all(object table: CircuitTable):  # -> CircuitTable:
         node = next(iter(table.rows.values()))
     else:
         node: CircuitNode = circuit.optimised_add(table.rows.values())
-        if node.is_zero():
+        if node.is_zero:
             return CircuitTable(circuit, ())
 
     return CircuitTable(circuit, (), [((), node)])
@@ -190,7 +190,7 @@ cpdef object product(x: CircuitTable, y: CircuitTable):  # -> CircuitTable:
 
     # Special case: y == 0 or 1, and has no random variables.
     if len(y.rv_idxs) == 0:
-        if len(y) == 1 and y.top().is_one():
+        if len(y) == 1 and y.top().is_one:
             return x
         elif len(y) == 0:
             return CircuitTable(circuit, x.rv_idxs)
@@ -259,7 +259,7 @@ cpdef object product(x: CircuitTable, y: CircuitTable):  # -> CircuitTable:
             co.append(x_instance[i])
         co_tuple = tuple(co)
 
-        if x_node.is_one():
+        if x_node.is_one:
             # Multiplying by one.
             # Iterate over matching y rows.
             got = y_index.get(co_tuple)
@@ -301,7 +301,7 @@ cdef object _product_no_common_rvs(x: CircuitTable, y: CircuitTable):  # -> Circ
     cdef tuple[int, ...] instance
 
     for x_instance, x_node in x.rows.items():
-        if x_node.is_one():
+        if x_node.is_one:
             for y_instance, y_node in y.rows.items():
                 instance = x_instance + y_instance
                 table.rows[instance] = y_node
@@ -314,12 +314,12 @@ cdef object _product_no_common_rvs(x: CircuitTable, y: CircuitTable):  # -> Circ
 
 
 cdef object _optimised_mul(object circuit: Circuit, object x: CircuitNode, object y: CircuitNode):  # -> CircuitNode
-    if x.is_zero():
+    if x.is_zero:
         return x
-    if y.is_zero():
+    if y.is_zero:
         return y
-    if x.is_one():
+    if x.is_one:
         return y
-    if y.is_one():
+    if y.is_one:
         return x
     return circuit.mul(x, y)

ck/pgm_compiler/support/circuit_table/{circuit_table_py.py → _circuit_table_py.py}

@@ -129,7 +129,7 @@ def sum_out(table: CircuitTable, rv_idxs: Iterable[int]) -> CircuitTable:
     def _result_rows() -> Iterator[Tuple[TableInstance, CircuitNode]]:
         for group, to_add in groups.items():
             _node: CircuitNode = circuit.optimised_add(to_add)
-            if not _node.is_zero():
+            if not _node.is_zero:
                 yield group, _node
 
     return CircuitTable(circuit, remaining_rv_idxs, _result_rows())
@@ -148,7 +148,7 @@ def sum_out_all(table: CircuitTable) -> CircuitTable:
         node = next(iter(table.rows.values()))
     else:
         node: CircuitNode = circuit.optimised_add(table.rows.values())
-        if node.is_zero():
+        if node.is_zero:
             return CircuitTable(circuit, ())
 
     return CircuitTable(circuit, (), [((), node)])
@@ -185,7 +185,7 @@ def product(x: CircuitTable, y: CircuitTable) -> CircuitTable:
 
     # Special case: y == 0 or 1, and has no random variables.
     if y_rv_idxs == ():
-        if len(y) == 1 and y.top().is_one():
+        if len(y) == 1 and y.top().is_one:
             return x
         elif len(y) == 0:
             return CircuitTable(circuit, x_rv_idxs)
@@ -225,7 +225,7 @@ def product(x: CircuitTable, y: CircuitTable) -> CircuitTable:
         # Rows with constant node values of one are optimised out.
         for _x_instance, _x_node in x.rows.items():
             _co = tuple(_x_instance[i] for i in co_from_x_map)
-            if _x_node.is_one():
+            if _x_node.is_one:
                 # Multiplying by one.
                 # Iterate over matching y rows.
                 for _yo, _y_node in y_index.get(_co, ()):
@@ -257,7 +257,7 @@ def _product_no_common_rvs(x: CircuitTable, y: CircuitTable) -> CircuitTable:
 
     def _result_rows() -> Iterator[Tuple[TableInstance, CircuitNode]]:
         for x_instance, x_node in x.rows.items():
-            if x_node.is_one():
+            if x_node.is_one:
                 for y_instance, y_node in y.rows.items():
                     instance = x_instance + y_instance
                     yield instance, y_node

ck/pgm_compiler/support/clusters.py

@@ -180,11 +180,11 @@ def optimal_prefix(clusters: Clusters) -> None:
 
 class Clusters:
     """
-    Holds the state of a connection graph while eliminating variables
-    to identify clusters a PGM graph.
+    A Clusters object holds the state of a connection graph while
+    eliminating variables to construct clusters for a PGM graph.
 
-    The clusters can either be in-progress, `len(Clusters.uneliminated) > 0`,
-    or be completed, `len(Clusters.uneliminated) == 0`.
+    The Clusters object can either be "in-progress" where `len(Clusters.uneliminated) > 0`,
+    or be "completed" where `len(Clusters.uneliminated) == 0`.
 
     See Adnan Darwiche, 2009, Modeling and Reasoning with Bayesian Networks, p164.
     """
@@ -229,6 +229,9 @@ class Clusters:
     @property
     def eliminated(self) -> List[int]:
         """
+        Get the list of eliminated random variables (as random variable
+        indices, in elimination order).
+
         Assumes:
             * The returned list will not be modified by the caller.
 
@@ -240,6 +243,8 @@ class Clusters:
     @property
     def uneliminated(self) -> Set[int]:
         """
+        Get the set of uneliminated random variables (as random variable indices).
+
         Assumes:
             * The returned set will not be modified by the caller.
 
@@ -285,6 +290,8 @@ class Clusters:
 
     def max_cluster_size(self) -> int:
         """
+        Calculate the maximum cluster size over all clusters.
+
         Returns:
             the maximum `len(cluster)` over all clusters.
         """
@@ -292,6 +299,11 @@ class Clusters:
 
     def max_cluster_weighted_size(self, rv_log_sizes: Sequence[float]) -> float:
         """
+        Calculate the maximum cluster weighted size over all clusters.
+
+        Args:
+            rv_log_sizes: is an array of random variable sizes, such that
+                for a random variable `rv`, `rv_log_sizes[rv.idx] = log2(len(rv))`.
         Returns:
             the maximum `sum(rv_log_sizes[rv_idx] for rv_idx in cluster)` over all clusters.
         """

ck/pgm_compiler/support/factor_tables.py

@@ -348,7 +348,7 @@ def _make_factor_table(
                 mul_vars[instance[inst_index]]
                 for inst_index, mul_vars in zip(inst_to_mul, mul_rvs_vars)
             )
-            if not node.is_one():
+            if not node.is_one:
                 to_mul += (node,)
             if len(to_mul) == 0:
                 yield instance, circuit.one

ck/pgm_compiler/support/join_tree.py

@@ -15,6 +15,11 @@ from ck.utils.np_extras import NDArrayFloat64
 
 @dataclass
 class JoinTree:
+    """
+    This is a recursive data structure representing a join-tree.
+    Each node in the join-tree is represented by a JoinTree object.
+    """
+
     # The PGM that this join tree is for.
     pgm: PGM
 
@@ -40,6 +45,12 @@ class JoinTree:
 
     def max_cluster_weighted_size(self, rv_log_sizes: Sequence[float]) -> float:
         """
+        Calculate the maximum cluster weighted size for this cluster and its children.
+
+        Args:
+            rv_log_sizes: is an array of random variable sizes, such that
+                for a random variable `rv`, `rv_log_sizes[rv.idx] = log2(len(rv))`.
+
         Returns:
             the maximum `log2` over self and all children, recursively.
         """
@@ -82,8 +93,8 @@ JoinTreeAlgorithm = Callable[[PGM], JoinTree]
 
 def _join_tree_algorithm(pgm_to_clusters: ClusterAlgorithm) -> JoinTreeAlgorithm:
     """
-    Helper function for creating a standard JoinTreeAlgorithm from
-    a ClusterAlgorithm.
+    Helper function for creating a standard JoinTreeAlgorithm
+    from a ClusterAlgorithm.
 
     Args:
         pgm_to_clusters: The clusters method to use.
@@ -112,14 +123,17 @@ MIN_TRADITIONAL_WEIGHTED_FILL: JoinTreeAlgorithm = _join_tree_algorithm(min_trad
 
 def clusters_to_join_tree(clusters: Clusters) -> JoinTree:
     """
-    Construct a join tree maker for the given PGM and random variable clusters.
+    Construct a join tree from the given random variable clusters.
 
     A join tree is formed by finding a minimum spanning tree over the clusters
-    where the cost between a pair of cluster is defined according to
-    `separator_cost_counts` and `costing`.
+    where the cost between a pair of clusters is the number of random variables
+    in common (using separator state space size to break ties).
 
     Args:
-        clusters: the clusters that resulted from graph clusters of the given PGM.
+        clusters: the clusters that resulted from graph clusters of a PGM.
+
+    Returns:
+        a JoinTree.
     """
     pgm: PGM = clusters.pgm
     cluster_sets: List[Set[int]] = clusters.clusters
@@ -170,6 +184,19 @@ def _make_spanning_tree_small_root(cost: NDArrayFloat64, clusters: List[Set[int]
     """
     Construct a minimum spanning tree over the clusters, where the root is the cluster with
     the smallest number of random variable.
+
+    Args:
+        cost: is an N x N matrix of costs between N clusters.
+        clusters: is a list of N clusters, each cluster is a set of random variable indices.
+
+    Returns:
+        (spanning_tree, root_index)
+
+        spanning_tree: is a spanning tree represented as a list of nodes, the list is coindexed with
+        the given cost matrix, each node is a list of children, each child being
+        represented as an index into the list of nodes.
+
+        root_index: is the index the chosen root of the spanning tree.
     """
     root_custer_index: int = 0
     root_size: int = len(clusters[root_custer_index])
@@ -185,10 +212,22 @@ def _make_spanning_tree_small_root(cost: NDArrayFloat64, clusters: List[Set[int]
 def _make_spanning_tree_arbitrary_root(cost: NDArrayFloat64) -> Tuple[List[List[int]], int]:
     """
     Construct a minimum spanning tree over the clusters, starting at an arbitrary root.
+
+    Args:
+        cost: is an N x N matrix of costs between N clusters.
+
+    Returns:
+        (spanning_tree, root_index)
+
+        spanning_tree: is a spanning tree represented as a list of nodes, the list is coindexed with
+        the given cost matrix, each node is a list of children, each child being
+        represented as an index into the list of nodes.
+
+        root_index: is the index the chosen root of the spanning tree.
     """
-    root_custer_index: int = 0
-    children: List[List[int]] = _make_spanning_tree_at_root(cost, root_custer_index)
-    return children, root_custer_index
+    root_index: int = 0
+    spanning_tree: List[List[int]] = _make_spanning_tree_at_root(cost, root_index)
+    return spanning_tree, root_index
 
 
 def _make_spanning_tree_at_root(
@@ -202,6 +241,12 @@ def _make_spanning_tree_at_root(
         cost: and nxn matrix where n is the number of clusters and cost[i, j]
             gives the cost between clusters i and j.
         root_custer_index: a nominated root cluster to be the root of the tree.
+
+    Returns:
+        a spanning tree represented as a list of nodes, the list is coindexed with
+        the given cost matrix, each node is a list of children, each child being
+        represented as an index into the list of nodes. The root node is the
+        index `root_custer_index` as passed to this function.
     """
     number_of_clusters: int = cost.shape[0]
 
@@ -257,7 +302,19 @@ def _form_join_tree_r(
         cluster_factors: List[List[Factor]],
 ) -> JoinTree:
     """
-    Recursively build the join tree data structure.
+    Recursively build a JoinTree from the spanning tree `children`.
+    This function merely pull the corresponding component from the
+    arguments to make a JoinTree object, doing this recursively
+    for the children.
+
+    Args:
+        pgm: the source PGM for the join tree.
+        cluster_index: index for the node we are processing (current root). This
+            indexes into `children`, `clusters`, and `cluster_factors`.
+        parent_cluster: set of random variable indices in the parent cluster.
+        children: list of spanning tree nodes, as per `_make_spanning_tree_at_root` result.
+        clusters: list of clusters, each cluster is a set of random variable indices.
+        cluster_factors: assignment of factors to clusters.
     """
     cluster: Set[int] = clusters[cluster_index]
     factors: List[Factor] = cluster_factors[cluster_index]

ck/pgm_compiler/variable_elimination.py

@@ -51,6 +51,8 @@ def compile_pgm(
 
     elimination_order: Sequence[int] = algorithm(pgm).eliminated
 
+    # Eliminate rvs from the factor tables according to the
+    # elimination order.
     cur_tables: List[CircuitTable] = list(factor_tables.tables)
     for rv_idx in elimination_order:
         next_tables: List[CircuitTable] = []

ck_demos/pgm_compiler/demo_compiler_dump.py

@@ -9,6 +9,16 @@ from ck.pgm_compiler.support.join_tree import JoinTree, clusters_to_join_tree
 
 
 def main() -> None:
+    """
+    This demo shows the full compilation chain for factor elimination.
+
+    Process:
+        Rain example -> PGM
+        min_degree -> Clusters
+        clusters_to_join_tree -> JoinTree
+        join_tree_to_circuit -> PGMCircuit
+        default circuit compiler -> WMCProgram
+    """
     pgm: PGM = example.Rain()
 
     print(f'PGM {pgm.name!r}')