compiled-knowledge 4.1.0a2__cp312-cp312-win_amd64.whl → 4.2.0a1__cp312-cp312-win_amd64.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

@@ -596,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
@@ -778,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})')
@@ -792,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)

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/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-zvpv36cx\\Lib\\site-packages\\numpy\\_core\\include"
+            "C:\\Users\\runneradmin\\AppData\\Local\\Temp\\build-env-75r5_lk9\\Lib\\site-packages\\numpy\\_core\\include"
         ],
         "name": "ck.pgm_compiler.support.circuit_table._circuit_table_cy",
         "sources": [

ck/probability/divergence.py

@@ -0,0 +1,226 @@
+"""
+This module implements several divergences which measure the difference
+between two distributions.
+"""
+import math
+from typing import Sequence
+
+import numpy as np
+
+from ck.pgm import RandomVariable, rv_instances_as_indicators, PGM
+from ck.probability.probability_space import ProbabilitySpace
+
+_NAN: float = np.nan  # Not-a-number (i.e., the result of an invalid calculation).
+
+
+def kl(p: ProbabilitySpace, q: ProbabilitySpace) -> float:
+    """
+    Compute the Kullback-Leibler divergence between p & q,
+    where p is the true distribution.
+
+    This implementation uses logarithms, base 2.
+
+    Args:
+        p: a probability space to compare to.
+        q: the other probability space.
+
+    Returns:
+        the Kullback–Leibler (KL) divergence of p & q, where p is
+        the true distribution.
+
+    Raises:
+        ValueError: if `p` and `q` do not have compatible random variables.specifically:
+            * `len(self.rvs) == len(other.rvs)`
+            * `len(other.rvs[i]) == len(self.rvs[i])` for all `i`
+            * `other.rvs[i].idx == self.rvs[i].idx` for all `i`.
+
+    Warning:
+        this method will enumerate the whole probability space.
+    """
+    if not _compatible_rvs(p.rvs, q.rvs):
+        raise ValueError('incompatible random variables')
+
+    total = 0.0
+    for x in rv_instances_as_indicators(*p.rvs):
+        p_x = p.probability(*x)
+        q_x = q.probability(*x)
+        if p_x <= 0 or q_x <= 0:
+            return _NAN
+        total += p_x * math.log2(p_x / q_x)
+    return total
+
+
+def pseudo_kl(p: ProbabilitySpace, q: ProbabilitySpace) -> float:
+    """
+    A kind of KL divergence, factored by the structure of `p`.
+    This is an experimental measure.
+
+    This implementation uses logarithms, base 2.
+
+    Args:
+        p: a probability space to compare to.
+        q: the other probability space.
+
+    Returns:
+        the factored histogram intersection between the two probability spaces.
+
+    Raises:
+        ValueError: if `p` and `q` do not have compatible random variables.specifically:
+            * `len(self.rvs) == len(other.rvs)`
+            * `len(other.rvs[i]) == len(self.rvs[i])` for all `i`
+            * `other.rvs[i].idx == self.rvs[i].idx` for all `i`.
+        ValueError: if not all random variable of `p` are from a single PGM, which must
+            have a Bayesian network structure.
+    """
+    p_rvs: Sequence[RandomVariable] = p.rvs
+    q_rvs: Sequence[RandomVariable] = q.rvs
+
+    if not _compatible_rvs(p_rvs, q_rvs):
+        raise ValueError('incompatible random variables')
+
+    if len(p_rvs) == 0:
+        return _NAN
+
+    pgm: PGM = p_rvs[0].pgm
+    if any(rv.pgm is not pgm for rv in p_rvs):
+        raise ValueError('p random variables are not from a single PGM.')
+    if not pgm.is_structure_bayesian:
+        raise ValueError('p does not have Bayesian network structure.')
+
+    # Across the two spaces, corresponding random variables are equivalent;
+    # i.e., same number of states and same `idx` values. Therefore,
+    # indicators from either one space can be used in both spaces.
+
+    total: float = 0
+    for factor in pgm.factors:
+        for x in rv_instances_as_indicators(*factor.rvs):  # every possible state of factor rvs
+            p_x = p.probability(*x)
+            q_x = q.probability(*x)
+            if p_x <= 0 or q_x <= 0:
+                return _NAN
+            total += p_x * math.log2(p_x / q_x)
+    return total
+
+
+def hi(p: ProbabilitySpace, q: ProbabilitySpace) -> float:
+    """
+    Compute the histogram intersection between this probability spaces and the given other.
+
+    The histogram intersection between two probability spaces P and Q,
+    with state spaces X, is defined as:
+        HI(P, Q) = sum(min(P(x), Q(x)) for x in X)
+
+    Args:
+        p: a probability space to compare to.
+        q: the other probability space.
+
+    Returns:
+        the histogram intersection between the two probability spaces.
+
+    Raises:
+        ValueError: if `p` and `q` do not have compatible random variables.specifically:
+            * `len(self.rvs) == len(other.rvs)`
+            * `len(other.rvs[i]) == len(self.rvs[i])` for all `i`
+            * `other.rvs[i].idx == self.rvs[i].idx` for all `i`.
+
+    Warning:
+        this method will enumerate the whole probability space.
+
+    """
+    p_rvs: Sequence[RandomVariable] = p.rvs
+    q_rvs: Sequence[RandomVariable] = q.rvs
+
+    if not _compatible_rvs(p_rvs, q_rvs):
+        raise ValueError('incompatible random variables')
+
+    # Across the two spaces, corresponding random variables are equivalent;
+    # i.e., same number of states and same `idx` values. Therefore,
+    # indicators from either one space can be used in both spaces.
+
+    return sum(
+        min(p.probability(*x), q.probability(*x))
+        for x in rv_instances_as_indicators(*p_rvs)
+    )
+
+
+def fhi(p: ProbabilitySpace, q: ProbabilitySpace) -> float:
+    """
+    Compute the factored histogram intersection between this probability spaces and the given other.
+
+    The factored histogram intersection between two probability spaces P and Q,
+    with state spaces X and factorisation F, is defined as:
+        FHI(P, Q) = 1/n sum(P(Y=y) CHI(P, Q, X | Y=y)
+        where:
+            CHI(P, Q, X | Y=y) = HI(P(X | Y=y), Q(X | Y=y))
+            HI(P, Q) = sum(min(P(X=x), Q(X=x)) for x in f)
+
+    The value of _n_ is the sum ofP(Y=y) over all CPT rows. However,
+    this always equals the number of CPTs, i.e., the number of random
+    variables.
+
+    The factorisation F is taken from the `p`.
+
+    For more information about factored histogram intersection, 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:
+        p: a probability space to compare to.
+        q: the other probability space.
+
+    Returns:
+        the factored histogram intersection between the two probability spaces.
+
+    Raises:
+        ValueError: if `p` and `q` do not have compatible random variables.specifically:
+            * `len(self.rvs) == len(other.rvs)`
+            * `len(other.rvs[i]) == len(self.rvs[i])` for all `i`
+            * `other.rvs[i].idx == self.rvs[i].idx` for all `i`.
+        ValueError: if not all random variable of `p` are from a single PGM, which must
+            have a Bayesian network structure.
+    """
+    p_rvs: Sequence[RandomVariable] = p.rvs
+    q_rvs: Sequence[RandomVariable] = q.rvs
+
+    if not _compatible_rvs(p_rvs, q_rvs):
+        raise ValueError('incompatible random variables')
+
+    if len(p_rvs) == 0:
+        return 0
+
+    pgm: PGM = p_rvs[0].pgm
+    if any(rv.pgm is not pgm for rv in p_rvs):
+        raise ValueError('p random variables are not from a single PGM.')
+    if not pgm.is_structure_bayesian:
+        raise ValueError('p does not have Bayesian network structure.')
+
+    # Across the two spaces, corresponding random variables are equivalent;
+    # i.e., same number of states and same `idx` values. Therefore,
+    # indicators from either one space can be used in both spaces.
+
+    # Loop over all CPTs, accumulating the total
+    total: float = 0
+    for factor in pgm.factors:
+        child: RandomVariable = factor.rvs[0]
+        parents: Sequence[RandomVariable] = factor.rvs[1:]
+        # Loop over all rows of the CPT
+        for parent_indicators in rv_instances_as_indicators(*parents):
+            p_marginal = p.marginal_distribution(child, condition=parent_indicators)
+            q_marginal = q.marginal_distribution(child, condition=parent_indicators)
+            row_hi = np.minimum(p_marginal, q_marginal).sum().item()
+            pr_row = p.probability(*parent_indicators)
+            total += pr_row * row_hi
+
+    return total / len(p_rvs)
+
+
+def _compatible_rvs(rvs1: Sequence[RandomVariable], rvs2: Sequence[RandomVariable]) -> bool:
+    """
+    The rvs are compatible if they have the same number of random variables
+    and the corresponding indicators are equal.
+    """
+    return (
+            len(rvs1) == len(rvs2)
+            and all(len(rv1) == len(rv2) and rv1.idx == rv2.idx for rv1, rv2 in zip(rvs1, rvs2))
+    )