fxtensor-salmon 1.2.2__tar.gz → 1.4.0__tar.gz

{fxtensor_salmon-1.2.2/src/fxtensor_salmon.egg-info → fxtensor_salmon-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fxtensor_salmon
-Version: 1.2.2
+Version: 1.4.0
 Summary: Markov Tensor Module
 Author-email: Tadachika Oki <sakesnare@gmail.com>
 License: Copyright 2025 Tadachika Oki
@@ -12,6 +12,7 @@ License: Copyright 2025 Tadachika Oki
         THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
         
 Project-URL: Homepage, https://github.com/salmonsnare/fxtensor-salmon
+Project-URL: Documentation, https://salmonsnare.github.io/fxtensor-salmon/
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
@@ -25,12 +26,21 @@ Requires-Dist: pytest; extra == "dev"
 Requires-Dist: ruff; extra == "dev"
 Provides-Extra: discopy
 Requires-Dist: discopy<2,>=1.2; extra == "discopy"
+Provides-Extra: docs
+Requires-Dist: sphinx>=7.4; extra == "docs"
+Requires-Dist: furo>=2024.8.6; extra == "docs"
+Requires-Dist: discopy<2,>=1.2; python_version >= "3.10" and extra == "docs"
 Dynamic: license-file
 
 # FXTensor
 
 FXTensor is a Python library for tensor-based computations, particularly suited for modeling probabilistic systems and processes inspired by category theory. It leverages NumPy for efficient numerical computations. The library primarily supports labeled indices for enhanced readability while maintaining compatibility with unlabeled numeric indices.
 
+## Documentation
+
+- [English](https://salmonsnare.github.io/fxtensor-salmon/en/)
+- [日本語](https://salmonsnare.github.io/fxtensor-salmon/ja/)
+
 ## Core Concepts
 
 An FXTensor is defined by its `profile` and `data`, with optional string labels to make tensors more intuitive and meaningful.
@@ -173,6 +183,67 @@ Model a weather system with states “Sunny” or “Rainy.”
   p_sunny = sunny_tomorrow.data[sunny_idx]  # 0.8
   ```
 
+### Conditional independence: weather, umbrella, and the forecast
+
+The forecast drives both the weather you meet and whether you carry an umbrella. Given the forecast they are conditionally independent. The marginal on weather and umbrella still couples them.
+
+The API orders the joint as weather ⊗ umbrella ⊗ forecast (`X ⊗ Y ⊗ Z`, with `Z` last). The figure draws the same variables as `X ⊗ Z ⊗ Y` and is read bottom to top. Left: `X ⊥ Y | Z` is the copy–discard equation. Right: `conditional_product` is `p_Z ; copy_Z ; (p(x|z) ⊗ id_Z ⊗ q(y|z))`. Bottom: when `Z` is trivial, the joint is the product of the marginals.
+
+<img src="https://raw.githubusercontent.com/salmonsnare/fxtensor-salmon/main/docs/_static/figures/conditional_independence.svg" alt="Conditional independence X ⊥ Y | Z and conditional_product">
+
+```python
+forecast = ['Sunny', 'Rainy']
+weather = ['Dry', 'Wet']
+umbrella = ['Leave', 'Take']
+p_wf = FXTensor([[], [weather, forecast]], data=np.array([
+    [0.45, 0.05],  # Dry
+    [0.05, 0.45],  # Wet
+]))
+p_uf = FXTensor([[], [umbrella, forecast]], data=np.array([
+    [0.40, 0.10],  # Leave
+    [0.10, 0.40],  # Take
+]))
+joint = FXTensor.conditional_product(p_wf, p_uf, 2)
+assert joint.labels == (None, [weather, umbrella, forecast])
+assert joint.is_conditionally_independent(2, 3)
+weather_umbrella = joint.marginalization(3)
+assert not weather_umbrella.is_independent(2)
+```
+
+### Exchangeability: a coin with an unknown bias
+
+A prior on the bias of a coin makes the sequence of flips exchangeable. The flips are not independent, unless that prior is a point mass.
+
+A state `p: I → X^{⊗n}` is exchangeable at position `k` (1-based) when swapping the `k`-th and `(k+1)`-th wires leaves it unchanged: `p ; (id^{⊗(k-1)} ⊗ swap(X,X) ⊗ id^{⊗(n-k-1)}) = p`, with `(k-1) + 2 + (n-k-1) = n`. A sequence `p_n: I → X^{⊗n}` is Kolmogorov consistent when discarding the `n`-th wire recovers `p_{n-1}`: `p_n ; (id^{⊗(n-1)} ⊗ !) = p_{n-1}`.
+
+<img src="https://raw.githubusercontent.com/salmonsnare/fxtensor-salmon/main/docs/_static/figures/exchangeability.svg" alt="p ; (id^{⊗(k-1)} ⊗ swap(X,X) ⊗ id^{⊗(n-k-1)}) = p">
+
+<img src="https://raw.githubusercontent.com/salmonsnare/fxtensor-salmon/main/docs/_static/figures/kolmogorov_consistency.svg" alt="p_n ; (id^{⊗(n-1)} ⊗ !) = p_{n-1}">
+
+```python
+bias = ["fair", "heads"]
+side = ["H", "T"]
+prior = FXTensor([[], [bias]], data=np.array([0.5, 0.5]))
+kernel = FXTensor(
+    [[bias], [side]],
+    data=np.array([
+        [0.5, 0.5],  # fair
+        [0.9, 0.1],  # heads
+    ]),
+)
+flips = FXTensor.mixture_of_iid(prior, kernel, 3)
+assert flips.labels == (None, [side, side, side])
+assert flips.is_exchangeable()
+sequence = [FXTensor.mixture_of_iid(prior, kernel, n) for n in range(1, 5)]
+assert FXTensor.is_kolmogorov_consistent(sequence)
+pair = flips.marginalization(3)
+assert not pair.is_independent(2)
+
+point = FXTensor([[], [bias]], data=np.array([0.0, 1.0]))
+fixed = FXTensor.mixture_of_iid(point, kernel, 3)
+assert fixed.is_independent(2)
+```
+
 ## Advanced Example: Multidimensional System (Labeled)
 
 Model **Season** (Spring, Summer, Other) and **Weather** (Sunny, Rainy) given **Location** (Urban, Rural).
@@ -398,6 +469,14 @@ Every morphism is Markov (discard is natural), `f ; ! = !` — in `FXTensor`, ea
 | `partial_composition` | Compose only some output wires | Keep a prefix of the outputs and feed the suffix into another kernel |
 | `jointification` | Joint of two states | Combine two independent states (states only) |
 | `conditional` | Kernel `A → X ⊗ Y` → `A ⊗ X → Y` | Conditionalize a kernel (generalizes `conditionalization`) |
+| `is_conditionally_independent` | `X ⊥ Y` given `Z`, codomain `X ⊗ Y ⊗ Z` | Test a state or kernel against the copy–discard equation |
+| `conditional_product` | Joint on `X ⊗ Y ⊗ Z` from joints on `X ⊗ Z` and `Y ⊗ Z` | Build a conditionally independent joint (states or kernels that share a domain) |
+| `is_independent` | `X ⊥ Y` when `Z` is empty | Special case of conditional independence |
+| `is_exchangeable` | Invariance of `I → X^{⊗n}` under adjacent swaps | Test whether swapping the `k`-th and `(k+1)`-th factors leaves a state unchanged |
+| `symmetrize` | Average over permutations of the factors | Turn a joint state into an exchangeable one |
+| `is_kolmogorov_consistent` | `p_n ; (id^{⊗(n-1)} ⊗ !) = p_{n-1}` | Check that discarding the `n`-th wire recovers the previous state |
+| `iid` | `p ⊗ … ⊗ p` | Build an i.i.d. state or kernel |
+| `mixture_of_iid` | `prior ; copy_Θ^{(n)} ; kernel^{⊗n}` | Mix i.i.d. sequences (exchangeable, and independent only for a Dirac prior) |
 | `bayesian_inversion` | `f: X → Y` and prior `I → X` → `f†: Y → X` | Bayesian update / posterior kernel |
 | `almost_surely_equal` | `f = g` p-a.s. | Compare kernels only where the prior has mass |
 | `is_absolutely_continuous` | `p ≪ q` | Check support inclusion of states / kernels |
@@ -554,3 +633,5 @@ pytest
 - [3] [K. Cho and B. Jacobs, Disintegration and Bayesian Inversion via String Diagrams (arXiv:1709.00322)](https://arxiv.org/abs/1709.00322)
 - [4] [T. Fritz, A synthetic approach to Markov kernels, conditional independence and theorems on sufficient statistics (arXiv:1908.07021)](https://arxiv.org/abs/1908.07021)
 - [5] [T. Fritz, T. Gonda, A. Lorenzin, P. Perrone, D. Stein, Absolute continuity, supports and idempotent splitting in categorical probability (arXiv:2308.00651)](https://arxiv.org/abs/2308.00651)
+- [6] [T. Fritz, T. Gonda, P. Perrone, De Finetti's theorem in categorical probability (arXiv:2105.02639)](https://arxiv.org/abs/2105.02639)
+- [7] [F. Vaccarino, Statistical models as natural transformations (arXiv:2609.22929)](https://arxiv.org/abs/2609.22929)

{fxtensor_salmon-1.2.2 → fxtensor_salmon-1.4.0}/README.md

@@ -2,6 +2,11 @@
 
 FXTensor is a Python library for tensor-based computations, particularly suited for modeling probabilistic systems and processes inspired by category theory. It leverages NumPy for efficient numerical computations. The library primarily supports labeled indices for enhanced readability while maintaining compatibility with unlabeled numeric indices.
 
+## Documentation
+
+- [English](https://salmonsnare.github.io/fxtensor-salmon/en/)
+- [日本語](https://salmonsnare.github.io/fxtensor-salmon/ja/)
+
 ## Core Concepts
 
 An FXTensor is defined by its `profile` and `data`, with optional string labels to make tensors more intuitive and meaningful.
@@ -144,6 +149,67 @@ Model a weather system with states “Sunny” or “Rainy.”
   p_sunny = sunny_tomorrow.data[sunny_idx]  # 0.8
   ```
 
+### Conditional independence: weather, umbrella, and the forecast
+
+The forecast drives both the weather you meet and whether you carry an umbrella. Given the forecast they are conditionally independent. The marginal on weather and umbrella still couples them.
+
+The API orders the joint as weather ⊗ umbrella ⊗ forecast (`X ⊗ Y ⊗ Z`, with `Z` last). The figure draws the same variables as `X ⊗ Z ⊗ Y` and is read bottom to top. Left: `X ⊥ Y | Z` is the copy–discard equation. Right: `conditional_product` is `p_Z ; copy_Z ; (p(x|z) ⊗ id_Z ⊗ q(y|z))`. Bottom: when `Z` is trivial, the joint is the product of the marginals.
+
+<img src="https://raw.githubusercontent.com/salmonsnare/fxtensor-salmon/main/docs/_static/figures/conditional_independence.svg" alt="Conditional independence X ⊥ Y | Z and conditional_product">
+
+```python
+forecast = ['Sunny', 'Rainy']
+weather = ['Dry', 'Wet']
+umbrella = ['Leave', 'Take']
+p_wf = FXTensor([[], [weather, forecast]], data=np.array([
+    [0.45, 0.05],  # Dry
+    [0.05, 0.45],  # Wet
+]))
+p_uf = FXTensor([[], [umbrella, forecast]], data=np.array([
+    [0.40, 0.10],  # Leave
+    [0.10, 0.40],  # Take
+]))
+joint = FXTensor.conditional_product(p_wf, p_uf, 2)
+assert joint.labels == (None, [weather, umbrella, forecast])
+assert joint.is_conditionally_independent(2, 3)
+weather_umbrella = joint.marginalization(3)
+assert not weather_umbrella.is_independent(2)
+```
+
+### Exchangeability: a coin with an unknown bias
+
+A prior on the bias of a coin makes the sequence of flips exchangeable. The flips are not independent, unless that prior is a point mass.
+
+A state `p: I → X^{⊗n}` is exchangeable at position `k` (1-based) when swapping the `k`-th and `(k+1)`-th wires leaves it unchanged: `p ; (id^{⊗(k-1)} ⊗ swap(X,X) ⊗ id^{⊗(n-k-1)}) = p`, with `(k-1) + 2 + (n-k-1) = n`. A sequence `p_n: I → X^{⊗n}` is Kolmogorov consistent when discarding the `n`-th wire recovers `p_{n-1}`: `p_n ; (id^{⊗(n-1)} ⊗ !) = p_{n-1}`.
+
+<img src="https://raw.githubusercontent.com/salmonsnare/fxtensor-salmon/main/docs/_static/figures/exchangeability.svg" alt="p ; (id^{⊗(k-1)} ⊗ swap(X,X) ⊗ id^{⊗(n-k-1)}) = p">
+
+<img src="https://raw.githubusercontent.com/salmonsnare/fxtensor-salmon/main/docs/_static/figures/kolmogorov_consistency.svg" alt="p_n ; (id^{⊗(n-1)} ⊗ !) = p_{n-1}">
+
+```python
+bias = ["fair", "heads"]
+side = ["H", "T"]
+prior = FXTensor([[], [bias]], data=np.array([0.5, 0.5]))
+kernel = FXTensor(
+    [[bias], [side]],
+    data=np.array([
+        [0.5, 0.5],  # fair
+        [0.9, 0.1],  # heads
+    ]),
+)
+flips = FXTensor.mixture_of_iid(prior, kernel, 3)
+assert flips.labels == (None, [side, side, side])
+assert flips.is_exchangeable()
+sequence = [FXTensor.mixture_of_iid(prior, kernel, n) for n in range(1, 5)]
+assert FXTensor.is_kolmogorov_consistent(sequence)
+pair = flips.marginalization(3)
+assert not pair.is_independent(2)
+
+point = FXTensor([[], [bias]], data=np.array([0.0, 1.0]))
+fixed = FXTensor.mixture_of_iid(point, kernel, 3)
+assert fixed.is_independent(2)
+```
+
 ## Advanced Example: Multidimensional System (Labeled)
 
 Model **Season** (Spring, Summer, Other) and **Weather** (Sunny, Rainy) given **Location** (Urban, Rural).
@@ -369,6 +435,14 @@ Every morphism is Markov (discard is natural), `f ; ! = !` — in `FXTensor`, ea
 | `partial_composition` | Compose only some output wires | Keep a prefix of the outputs and feed the suffix into another kernel |
 | `jointification` | Joint of two states | Combine two independent states (states only) |
 | `conditional` | Kernel `A → X ⊗ Y` → `A ⊗ X → Y` | Conditionalize a kernel (generalizes `conditionalization`) |
+| `is_conditionally_independent` | `X ⊥ Y` given `Z`, codomain `X ⊗ Y ⊗ Z` | Test a state or kernel against the copy–discard equation |
+| `conditional_product` | Joint on `X ⊗ Y ⊗ Z` from joints on `X ⊗ Z` and `Y ⊗ Z` | Build a conditionally independent joint (states or kernels that share a domain) |
+| `is_independent` | `X ⊥ Y` when `Z` is empty | Special case of conditional independence |
+| `is_exchangeable` | Invariance of `I → X^{⊗n}` under adjacent swaps | Test whether swapping the `k`-th and `(k+1)`-th factors leaves a state unchanged |
+| `symmetrize` | Average over permutations of the factors | Turn a joint state into an exchangeable one |
+| `is_kolmogorov_consistent` | `p_n ; (id^{⊗(n-1)} ⊗ !) = p_{n-1}` | Check that discarding the `n`-th wire recovers the previous state |
+| `iid` | `p ⊗ … ⊗ p` | Build an i.i.d. state or kernel |
+| `mixture_of_iid` | `prior ; copy_Θ^{(n)} ; kernel^{⊗n}` | Mix i.i.d. sequences (exchangeable, and independent only for a Dirac prior) |
 | `bayesian_inversion` | `f: X → Y` and prior `I → X` → `f†: Y → X` | Bayesian update / posterior kernel |
 | `almost_surely_equal` | `f = g` p-a.s. | Compare kernels only where the prior has mass |
 | `is_absolutely_continuous` | `p ≪ q` | Check support inclusion of states / kernels |
@@ -525,3 +599,5 @@ pytest
 - [3] [K. Cho and B. Jacobs, Disintegration and Bayesian Inversion via String Diagrams (arXiv:1709.00322)](https://arxiv.org/abs/1709.00322)
 - [4] [T. Fritz, A synthetic approach to Markov kernels, conditional independence and theorems on sufficient statistics (arXiv:1908.07021)](https://arxiv.org/abs/1908.07021)
 - [5] [T. Fritz, T. Gonda, A. Lorenzin, P. Perrone, D. Stein, Absolute continuity, supports and idempotent splitting in categorical probability (arXiv:2308.00651)](https://arxiv.org/abs/2308.00651)
+- [6] [T. Fritz, T. Gonda, P. Perrone, De Finetti's theorem in categorical probability (arXiv:2105.02639)](https://arxiv.org/abs/2105.02639)
+- [7] [F. Vaccarino, Statistical models as natural transformations (arXiv:2609.22929)](https://arxiv.org/abs/2609.22929)

{fxtensor_salmon-1.2.2 → fxtensor_salmon-1.4.0}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fxtensor_salmon"
-version = "1.2.2"
+version = "1.4.0"
 authors = [
   { name="Tadachika Oki", email="sakesnare@gmail.com" }, 
 ]
@@ -33,9 +33,15 @@ dev = [
 discopy = [
     "discopy>=1.2,<2",
 ]
+docs = [
+    "sphinx>=7.4",
+    "furo>=2024.8.6",
+    "discopy>=1.2,<2; python_version>='3.10'",
+]
 
 [project.urls]
 Homepage = "https://github.com/salmonsnare/fxtensor-salmon"
+Documentation = "https://salmonsnare.github.io/fxtensor-salmon/"
 
 [tool.setuptools.packages.find]
 where = ["src"]

{fxtensor_salmon-1.2.2 → fxtensor_salmon-1.4.0}/src/fxtensor_salmon/core.py

@@ -2,13 +2,15 @@ from __future__ import annotations
 import numpy as np
 from typing import List, Tuple, Union, Optional
 
+from .exchangeability import ExchangeabilityMixin
+from .independence import IndependenceMixin
 from .io import IOMixin
 from .operations import OperationsMixin
 from .profile import _constructor_profile, _parse_profile
 from .special import SpecialMixin
 
 
-class FXTensor(IOMixin, OperationsMixin, SpecialMixin):
+class FXTensor(IOMixin, OperationsMixin, SpecialMixin, IndependenceMixin, ExchangeabilityMixin):
     """A tensor with support for string-labeled dimensions and tensor operations."""
 
     _RTOL = 1e-05

fxtensor_salmon-1.4.0/src/fxtensor_salmon/exchangeability.py

@@ -0,0 +1,328 @@
+"""Exchangeability and Kolmogorov consistency for finite states.
+
+A state ``p: I → X^{⊗n}`` is exchangeable at position ``k`` (1-based) when
+
+``p ; (id^{⊗(k-1)} ⊗ swap(X, X) ⊗ id^{⊗(n-k-1)}) = p``.
+
+Swapping the ``k``-th and ``(k+1)``-th wires leaves ``p`` unchanged.
+Those wires use ``(k-1) + 2 + (n-k-1) = n`` factors.
+
+A sequence ``p_n: I → X^{⊗n}`` is Kolmogorov consistent when
+
+``p_n ; (id^{⊗(n-1)} ⊗ !) = p_{n-1}``.
+
+Discarding the ``n``-th wire of ``p_n`` yields ``p_{n-1}``.
+"""
+
+from __future__ import annotations
+
+import itertools
+import warnings
+
+import numpy as np
+
+
+_SYMMETRIZE_WARN_ABOVE = 8
+
+
+def _tolerances(cls, atol, rtol):
+    if atol is None:
+        atol = cls._ATOL
+    if rtol is None:
+        rtol = cls._RTOL
+    return atol, rtol
+
+
+def _parse_block(block):
+    """Return the dimension list of one factor ``X``."""
+    if isinstance(block, tuple):
+        block = list(block)
+    if not isinstance(block, list) or not block:
+        raise ValueError("block must be a non-empty list of positive dimensions")
+    dims = []
+    for axis in block:
+        if isinstance(axis, bool) or not isinstance(axis, int) or axis <= 0:
+            raise ValueError("block must be a non-empty list of positive dimensions")
+        dims.append(axis)
+    return dims
+
+
+def _factors(codomain, block):
+    """Split a codomain into ``n`` copies of ``X``.
+
+    ``block is None`` means each axis is one factor (the default of one
+    axis). Every axis must then have the same size. Otherwise ``block`` is
+    the dimension list of ``X`` and must tile the codomain.
+    """
+    codomain = list(codomain)
+    if block is None:
+        if not codomain:
+            return [], 0
+        size = codomain[0]
+        if any(axis != size for axis in codomain):
+            raise ValueError(
+                "codomain factors are not the same type X; pass block to group axes"
+            )
+        return [size], len(codomain)
+    dims = _parse_block(block)
+    width = len(dims)
+    if len(codomain) % width != 0:
+        raise ValueError("codomain length is not a multiple of the block")
+    count = len(codomain) // width
+    for index in range(count):
+        piece = codomain[index * width:(index + 1) * width]
+        if piece != dims:
+            raise ValueError("codomain factors are not the same type X")
+    return dims, count
+
+
+def _require_state(tensor, method):
+    if tensor._profile[0]:
+        raise ValueError(f"{method} expects a state I → X^{{⊗n}}")
+
+
+def _tensor_all(cls, factors):
+    acc = factors[0]
+    for factor in factors[1:]:
+        acc = acc.tensor_product(factor)
+    return acc
+
+
+def _adjacent_swap_morphism(cls, x_dims, k, n):
+    """``id^{⊗(k-1)} ⊗ swap(X, X) ⊗ id^{⊗(n-k-1)}``.
+
+    ``k`` is 1-based. The three blocks use ``(k-1) + 2 + (n-k-1) = n``
+    factors of ``X``.
+    """
+    if not (1 <= k <= n - 1):
+        raise ValueError("swap position k is out of range")
+    factors = []
+    left = k - 1
+    right = n - k - 1
+    if left:
+        factors.append(cls.identity_tensor(list(x_dims) * left))
+    factors.append(cls.swap(list(x_dims), list(x_dims)))
+    if right:
+        factors.append(cls.identity_tensor(list(x_dims) * right))
+    return _tensor_all(cls, factors)
+
+
+def _discard_last_morphism(cls, x_dims, n):
+    """``id^{⊗(n-1)} ⊗ !`` on ``X^{⊗n}``, discarding the ``n``-th wire."""
+    if n < 1:
+        raise ValueError("n must be positive")
+    factors = []
+    if n - 1:
+        factors.append(cls.identity_tensor(list(x_dims) * (n - 1)))
+    factors.append(cls.exclamation(list(x_dims)))
+    return _tensor_all(cls, factors)
+
+
+def _same_data(left, right, atol, rtol):
+    if left.shape != right.shape:
+        return False
+    return bool(np.allclose(left, right, rtol=rtol, atol=atol))
+
+
+def _permutation_axes(perm, width):
+    order = []
+    for block_index in perm:
+        start = block_index * width
+        order.extend(range(start, start + width))
+    return order
+
+
+class ExchangeabilityMixin:
+    """Mixin that adds exchangeability and Kolmogorov consistency.
+
+    States are morphisms ``I → X^{⊗n}``. ``X`` is one codomain axis unless
+    ``block`` gives the dimension list of a multi-axis factor.
+    """
+
+    def is_exchangeable(self, block=None, atol=None, rtol=None):
+        """Return whether this state is invariant under every adjacent swap.
+
+        The state ``p: I → X^{⊗n}`` is exchangeable at position ``k``
+        (1-based) when
+
+        ``p ; (id^{⊗(k-1)} ⊗ swap(X, X) ⊗ id^{⊗(n-k-1)}) = p``.
+
+        Swapping the ``k``-th and ``(k+1)``-th wires leaves ``p`` unchanged.
+        The identity wires and the two swapped wires use
+        ``(k-1) + 2 + (n-k-1) = n`` factors. Adjacent transpositions
+        generate the symmetric group, so this checks ``k = 1 .. n-1``.
+        ``n < 2`` is vacuously true.
+
+        ``block`` is the dimension list of one factor ``X``. The default,
+        ``None``, takes each codomain axis as one factor; those axes must
+        share a size. ``swap`` carries no labels, so the comparison is on
+        ``data`` via ``numpy.allclose``. ``atol`` and ``rtol`` default to
+        ``FXTensor._ATOL`` and ``FXTensor._RTOL``.
+
+        Raises
+        ------
+        ValueError
+            If ``self`` is not a state, or the codomain is not ``X^{⊗n}``.
+        """
+        _require_state(self, "is_exchangeable")
+        x_dims, count = _factors(self._profile[1], block)
+        if count < 2:
+            return True
+        atol, rtol = _tolerances(type(self), atol, rtol)
+        cls = type(self)
+        for k in range(1, count):
+            swapped = self.composition(_adjacent_swap_morphism(cls, x_dims, k, count))
+            if not _same_data(swapped.data, self.data, atol, rtol):
+                return False
+        return True
+
+    def symmetrize(self, block=None):
+        """Return the average of this state over every permutation of ``X``.
+
+        The result has the same profile and labels and satisfies
+        :meth:`is_exchangeable` for the same ``block``. Averaging again
+        changes nothing, and an exchangeable state is left unchanged.
+        ``n > 8`` warns: the average runs through ``n!`` permutations.
+
+        Raises
+        ------
+        ValueError
+            If ``self`` is not a state, or the codomain is not ``X^{⊗n}``.
+        """
+        _require_state(self, "symmetrize")
+        x_dims, count = _factors(self._profile[1], block)
+        if count > _SYMMETRIZE_WARN_ABOVE:
+            warnings.warn(
+                f"symmetrize averages {count}! permutations; n={count} is above 8",
+                stacklevel=2,
+            )
+        if count < 2:
+            return self.copy()
+        width = len(x_dims)
+        total = np.zeros(self.data.shape, dtype=float)
+        n_perms = 0
+        for perm in itertools.permutations(range(count)):
+            total += np.transpose(self.data, _permutation_axes(perm, width))
+            n_perms += 1
+        averaged = total / n_perms
+        return self._spawn(self._profile[0], self._profile[1], self._labels, averaged)
+
+    @classmethod
+    def is_kolmogorov_consistent(cls, states, block=None, atol=None, rtol=None):
+        """Return whether discarding the last factor reproduces the previous state.
+
+        ``states`` is the list ``[p_1, p_2, ..., p_N]`` with
+        ``p_n: I → X^{⊗n}`` (so ``states[0]`` is ``p_1``). The sequence is
+        Kolmogorov consistent when, for every ``n ≥ 2``,
+
+        ``p_n ; (id^{⊗(n-1)} ⊗ !) = p_{n-1}``.
+
+        ``!`` is :meth:`exclamation` on the last factor: discarding the
+        ``n``-th wire of ``p_n`` yields ``p_{n-1}``. A list of length 0 or
+        1 is consistent. ``block`` selects ``X`` as in
+        :meth:`is_exchangeable`; the default is one axis, and
+        ``states[n-1]`` must then have ``n`` axes of that size. Values are
+        compared on ``data`` with ``numpy.allclose``. ``atol`` and ``rtol``
+        default to ``FXTensor._ATOL`` and ``FXTensor._RTOL``.
+
+        Raises
+        ------
+        ValueError
+            If an entry is not a state ``I → X^{⊗n}`` for that position, or
+            the factors are not a common type ``X``.
+        """
+        try:
+            sequence = list(states)
+        except TypeError as exc:
+            raise ValueError("states must be a sequence of FXTensor states") from exc
+        for state in sequence:
+            if not isinstance(state, cls):
+                raise ValueError("states must be a sequence of FXTensor states")
+            _require_state(state, "is_kolmogorov_consistent")
+        if not sequence:
+            return True
+        parsed = [_factors(state._profile[1], block) for state in sequence]
+        x_dims = parsed[0][0]
+        if not x_dims:
+            raise ValueError("codomain must be X^{⊗n} for a non-empty X")
+        for index, (dims, count) in enumerate(parsed):
+            n = index + 1
+            if dims != x_dims or count != n:
+                raise ValueError(f"states[{index}] must be a state I → X^{{⊗{n}}}")
+        if len(sequence) < 2:
+            return True
+        atol, rtol = _tolerances(cls, atol, rtol)
+        for n in range(2, len(sequence) + 1):
+            discarded = sequence[n - 1].composition(
+                _discard_last_morphism(cls, x_dims, n)
+            )
+            if not _same_data(discarded.data, sequence[n - 2].data, atol, rtol):
+                return False
+        return True
+
+    @classmethod
+    def iid(cls, p, n):
+        """Return the tensor product of ``n`` copies of ``p``.
+
+        Labels are taken from ``p``. For a state ``I → X`` the result is
+        ``I → X^{⊗n}``. ``n=1`` returns a copy of ``p``.
+
+        Raises
+        ------
+        ValueError
+            If ``p`` is not an ``FXTensor``, or ``n`` is not a positive integer.
+        """
+        if not isinstance(p, cls):
+            raise ValueError("p must be an FXTensor")
+        if isinstance(n, bool) or not isinstance(n, int) or n < 1:
+            raise ValueError("n must be a positive integer")
+        result = p.copy()
+        for _ in range(n - 1):
+            result = result.tensor_product(p)
+        return result
+
+    @classmethod
+    def mixture_of_iid(cls, prior, kernel, n):
+        """Return ``prior ; copy_Θ^{(n)} ; kernel^{⊗n}``.
+
+        ``prior`` is a state ``I → Θ`` and ``kernel`` is a kernel
+        ``Θ → X``. The result is a state ``I → X^{⊗n}``: one draw from the
+        prior, copied, then ``n`` independent samples from the kernel. It is
+        exchangeable and, as ``n`` varies, Kolmogorov consistent. Codomain
+        labels are the codomain labels of ``kernel``, repeated ``n`` times.
+
+        Raises
+        ------
+        ValueError
+            If ``prior`` is not a state, the profiles do not meet, or ``n``
+            is not a positive integer.
+        """
+        if not isinstance(prior, cls) or not isinstance(kernel, cls):
+            raise ValueError("prior and kernel must be FXTensor values")
+        if prior._profile[0]:
+            raise ValueError("prior must be a state I → Θ")
+        if list(prior._profile[1]) != list(kernel._profile[0]):
+            raise ValueError("prior codomain must match the domain of kernel")
+        if isinstance(n, bool) or not isinstance(n, int) or n < 1:
+            raise ValueError("n must be a positive integer")
+        if prior._labels is not None and prior._labels[1]:
+            theta = prior._labels[1]
+        else:
+            theta = list(prior._profile[1])
+        copied = prior.composition(cls.copy_tensor(theta, n))
+        kernels = kernel.copy()
+        for _ in range(n - 1):
+            kernels = kernels.tensor_product(kernel)
+        result = copied.composition(kernels)
+        if (
+            result._labels is None
+            and kernel._labels is not None
+            and kernel._labels[1]
+        ):
+            result = result._spawn(
+                result._profile[0],
+                result._profile[1],
+                ([], list(kernel._labels[1]) * n),
+                result.data,
+            )
+        return result