fxtensor-salmon 1.2.0__tar.gz → 1.2.1__tar.gz

{fxtensor_salmon-1.2.0/src/fxtensor_salmon.egg-info → fxtensor_salmon-1.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fxtensor_salmon
-Version: 1.2.0
+Version: 1.2.1
 Summary: Markov Tensor Module
 Author-email: Tadachika Oki <sakesnare@gmail.com>
 License: Copyright 2025 Tadachika Oki
@@ -383,6 +383,8 @@ The `fxtensor-salmon` library is designed based on the **Markov Category**, a fr
 | `jointification` | Joint of two states | Combine two independent states (states only) |
 | `conditional` | Kernel `A → X ⊗ Y` → `A ⊗ X → Y` | Conditionalize a kernel (generalizes `conditionalization`) |
 | `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 |
 | `exclamation` | Discard morphism `X → I` | Build an all-ones discarding tensor |
 | `copy_tensor` | Copy morphism `X → X^{⊗ n}` | Deterministic copy / diagonal (`n=0` is discard) |
 | `delta_tensor` | Identity (alias of `identity_tensor`) | Build an identity kernel |
@@ -494,6 +496,20 @@ assert c.labels == ([['a'], ['x0', 'x1']], [['y0', 'y1']])
 assert np.allclose(c.data, [[[0.25, 0.75], [1/3, 2/3]]])
 ```
 
+#### `support`, `almost_surely_equal`, `is_absolutely_continuous` — a.s. reasoning
+
+`support()` returns the 0/1 indicator of nonzero entries (same profile and labels). `f.almost_surely_equal(g, p)` checks Fritz's `p ; copy ; (id ⊗ f) = p ; copy ; (id ⊗ g)`, i.e. `f` and `g` agree on the support of `p`. `p.is_absolutely_continuous(q)` checks `p ≪ q` (zero in `q` implies zero in `p`; input-wise for kernels, cf. arXiv:2308.00651). Zero is judged with `_ATOL`; labels are not compared.
+
+```python
+prior = FXTensor([[], [['x0', 'x1', 'x2']]], data=np.array([0.4, 0.6, 0.0]))
+f = FXTensor([[['x0', 'x1', 'x2']], [['y0', 'y1']]], data=np.array([[0.2, 0.8], [0.5, 0.5], [1.0, 0.0]]))
+g = FXTensor([[['x0', 'x1', 'x2']], [['y0', 'y1']]], data=np.array([[0.2, 0.8], [0.5, 0.5], [0.3, 0.7]]))
+assert np.array_equal(prior.support().data, [1.0, 1.0, 0.0])
+assert f.almost_surely_equal(g, prior)   # f and g differ only on the null point x2
+assert f.is_absolutely_continuous(g)     # f(·|x) ≪ g(·|x) for every x
+assert not g.is_absolutely_continuous(f)
+```
+
 ### Probabilistic Properties
 
 - `is_markov()`: Verifies if the tensor satisfies the normalization condition (sum of outputs equals 1 or 0). States (empty domain) always return `False`; check `np.isclose(state.data.sum(), 1)` for a normalized state.
@@ -513,3 +529,4 @@ pytest
 - [2] [檜山正幸のキマイラ飼育記 (はてなBlog), マルコフ圏におけるテンソル計算の手順とコツ](https://m-hiyama.hatenablog.com/entry/2021/04/05/153325)
 - [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)

{fxtensor_salmon-1.2.0 → fxtensor_salmon-1.2.1}/README.md

@@ -354,6 +354,8 @@ The `fxtensor-salmon` library is designed based on the **Markov Category**, a fr
 | `jointification` | Joint of two states | Combine two independent states (states only) |
 | `conditional` | Kernel `A → X ⊗ Y` → `A ⊗ X → Y` | Conditionalize a kernel (generalizes `conditionalization`) |
 | `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 |
 | `exclamation` | Discard morphism `X → I` | Build an all-ones discarding tensor |
 | `copy_tensor` | Copy morphism `X → X^{⊗ n}` | Deterministic copy / diagonal (`n=0` is discard) |
 | `delta_tensor` | Identity (alias of `identity_tensor`) | Build an identity kernel |
@@ -465,6 +467,20 @@ assert c.labels == ([['a'], ['x0', 'x1']], [['y0', 'y1']])
 assert np.allclose(c.data, [[[0.25, 0.75], [1/3, 2/3]]])
 ```
 
+#### `support`, `almost_surely_equal`, `is_absolutely_continuous` — a.s. reasoning
+
+`support()` returns the 0/1 indicator of nonzero entries (same profile and labels). `f.almost_surely_equal(g, p)` checks Fritz's `p ; copy ; (id ⊗ f) = p ; copy ; (id ⊗ g)`, i.e. `f` and `g` agree on the support of `p`. `p.is_absolutely_continuous(q)` checks `p ≪ q` (zero in `q` implies zero in `p`; input-wise for kernels, cf. arXiv:2308.00651). Zero is judged with `_ATOL`; labels are not compared.
+
+```python
+prior = FXTensor([[], [['x0', 'x1', 'x2']]], data=np.array([0.4, 0.6, 0.0]))
+f = FXTensor([[['x0', 'x1', 'x2']], [['y0', 'y1']]], data=np.array([[0.2, 0.8], [0.5, 0.5], [1.0, 0.0]]))
+g = FXTensor([[['x0', 'x1', 'x2']], [['y0', 'y1']]], data=np.array([[0.2, 0.8], [0.5, 0.5], [0.3, 0.7]]))
+assert np.array_equal(prior.support().data, [1.0, 1.0, 0.0])
+assert f.almost_surely_equal(g, prior)   # f and g differ only on the null point x2
+assert f.is_absolutely_continuous(g)     # f(·|x) ≪ g(·|x) for every x
+assert not g.is_absolutely_continuous(f)
+```
+
 ### Probabilistic Properties
 
 - `is_markov()`: Verifies if the tensor satisfies the normalization condition (sum of outputs equals 1 or 0). States (empty domain) always return `False`; check `np.isclose(state.data.sum(), 1)` for a normalized state.
@@ -484,3 +500,4 @@ pytest
 - [2] [檜山正幸のキマイラ飼育記 (はてなBlog), マルコフ圏におけるテンソル計算の手順とコツ](https://m-hiyama.hatenablog.com/entry/2021/04/05/153325)
 - [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)

{fxtensor_salmon-1.2.0 → fxtensor_salmon-1.2.1}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fxtensor_salmon"
-version = "1.2.0"
+version = "1.2.1"
 authors = [
   { name="Tadachika Oki", email="sakesnare@gmail.com" }, 
 ]

{fxtensor_salmon-1.2.0 → fxtensor_salmon-1.2.1}/src/fxtensor_salmon/operations.py

@@ -152,6 +152,56 @@ class OperationsMixin:
         one = np.isclose(rows, 1, rtol=rtol, atol=atol)
         return bool(np.all(zero | one) and np.all(one.sum(axis=1) == 1))
 
+    def support(self) -> 'FXTensor':
+        """Indicator tensor of the nonzero entries (same profile and labels).
+
+        For a state ``p: I → X`` this is the support ``{x : p(x) > 0}``; for a
+        kernel ``f: A → X`` it is the support relation ``{(a, x) : f(x|a) > 0}``.
+        Entries within ``_ATOL`` of zero count as zero.
+        """
+        rtol = type(self)._RTOL
+        atol = type(self)._ATOL
+        mask = ~np.isclose(self.data, 0, rtol=rtol, atol=atol)
+        return self._spawn(self._profile[0], self._profile[1], self._labels, mask.astype(float))
+
+    def almost_surely_equal(self, other: 'FXTensor', prior: 'FXTensor') -> bool:
+        """Check ``self = other`` ``prior``-almost surely.
+
+        For ``f, g: X → Y`` and a state ``p: I → X`` this is Fritz's
+        ``p ; copy ; (id ⊗ f) = p ; copy ; (id ⊗ g)``; for finite tensors it
+        means ``f(·|x) = g(·|x)`` for every ``x`` with ``p(x) > 0``. Only
+        profiles are compared, not labels.
+        """
+        if self._profile != other._profile:
+            raise ValueError("Tensors must have the same profile")
+        if prior._profile[0]:
+            raise ValueError("prior must be a state (empty domain)")
+        if prior._profile[1] != self._profile[0]:
+            raise ValueError("prior codomain must match the domain of self")
+        weights = prior.data.reshape(self._profile[0] + [1] * len(self._profile[1]))
+        return bool(np.allclose(
+            weights * self.data,
+            weights * other.data,
+            rtol=type(self)._RTOL,
+            atol=type(self)._ATOL,
+        ))
+
+    def is_absolutely_continuous(self, other: 'FXTensor') -> bool:
+        """Check ``self ≪ other``: wherever ``other`` is zero, ``self`` is zero.
+
+        For states this is the usual absolute continuity of distributions;
+        for kernels ``f, g: A → X`` it holds input-wise, i.e. ``f(·|a) ≪ g(·|a)``
+        for every ``a`` (finite case of Fritz et al., arXiv:2308.00651).
+        Only profiles are compared, not labels.
+        """
+        if self._profile != other._profile:
+            raise ValueError("Tensors must have the same profile")
+        rtol = type(self)._RTOL
+        atol = type(self)._ATOL
+        other_zero = np.isclose(other.data, 0, rtol=rtol, atol=atol)
+        self_zero = np.isclose(self.data, 0, rtol=rtol, atol=atol)
+        return bool(np.all(self_zero | ~other_zero))
+
     def marginalization(self, start_B: int) -> 'FXTensor':
         """Marginalize out a part of the codomain by summing over it."""
         domain_len = len(self._profile[0])

{fxtensor_salmon-1.2.0 → fxtensor_salmon-1.2.1/src/fxtensor_salmon.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fxtensor_salmon
-Version: 1.2.0
+Version: 1.2.1
 Summary: Markov Tensor Module
 Author-email: Tadachika Oki <sakesnare@gmail.com>
 License: Copyright 2025 Tadachika Oki
@@ -383,6 +383,8 @@ The `fxtensor-salmon` library is designed based on the **Markov Category**, a fr
 | `jointification` | Joint of two states | Combine two independent states (states only) |
 | `conditional` | Kernel `A → X ⊗ Y` → `A ⊗ X → Y` | Conditionalize a kernel (generalizes `conditionalization`) |
 | `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 |
 | `exclamation` | Discard morphism `X → I` | Build an all-ones discarding tensor |
 | `copy_tensor` | Copy morphism `X → X^{⊗ n}` | Deterministic copy / diagonal (`n=0` is discard) |
 | `delta_tensor` | Identity (alias of `identity_tensor`) | Build an identity kernel |
@@ -494,6 +496,20 @@ assert c.labels == ([['a'], ['x0', 'x1']], [['y0', 'y1']])
 assert np.allclose(c.data, [[[0.25, 0.75], [1/3, 2/3]]])
 ```
 
+#### `support`, `almost_surely_equal`, `is_absolutely_continuous` — a.s. reasoning
+
+`support()` returns the 0/1 indicator of nonzero entries (same profile and labels). `f.almost_surely_equal(g, p)` checks Fritz's `p ; copy ; (id ⊗ f) = p ; copy ; (id ⊗ g)`, i.e. `f` and `g` agree on the support of `p`. `p.is_absolutely_continuous(q)` checks `p ≪ q` (zero in `q` implies zero in `p`; input-wise for kernels, cf. arXiv:2308.00651). Zero is judged with `_ATOL`; labels are not compared.
+
+```python
+prior = FXTensor([[], [['x0', 'x1', 'x2']]], data=np.array([0.4, 0.6, 0.0]))
+f = FXTensor([[['x0', 'x1', 'x2']], [['y0', 'y1']]], data=np.array([[0.2, 0.8], [0.5, 0.5], [1.0, 0.0]]))
+g = FXTensor([[['x0', 'x1', 'x2']], [['y0', 'y1']]], data=np.array([[0.2, 0.8], [0.5, 0.5], [0.3, 0.7]]))
+assert np.array_equal(prior.support().data, [1.0, 1.0, 0.0])
+assert f.almost_surely_equal(g, prior)   # f and g differ only on the null point x2
+assert f.is_absolutely_continuous(g)     # f(·|x) ≪ g(·|x) for every x
+assert not g.is_absolutely_continuous(f)
+```
+
 ### Probabilistic Properties
 
 - `is_markov()`: Verifies if the tensor satisfies the normalization condition (sum of outputs equals 1 or 0). States (empty domain) always return `False`; check `np.isclose(state.data.sum(), 1)` for a normalized state.
@@ -513,3 +529,4 @@ pytest
 - [2] [檜山正幸のキマイラ飼育記 (はてなBlog), マルコフ圏におけるテンソル計算の手順とコツ](https://m-hiyama.hatenablog.com/entry/2021/04/05/153325)
 - [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)

{fxtensor_salmon-1.2.0 → fxtensor_salmon-1.2.1}/src/fxtensor_salmon.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ src/fxtensor_salmon.egg-info/SOURCES.txt
 src/fxtensor_salmon.egg-info/dependency_links.txt
 src/fxtensor_salmon.egg-info/requires.txt
 src/fxtensor_salmon.egg-info/top_level.txt
+tests/test_almost_surely.py
 tests/test_axioms.py
 tests/test_discopy.py
 tests/test_fxtensor.py

fxtensor_salmon-1.2.1/tests/test_almost_surely.py

@@ -0,0 +1,158 @@
+"""Tests for support, almost_surely_equal and is_absolutely_continuous.
+
+References: T. Fritz (arXiv:1908.07021), almost sure equality;
+T. Fritz, T. Gonda, A. Lorenzin, P. Perrone, D. Stein, "Absolute continuity,
+supports and idempotent splitting in categorical probability" (arXiv:2308.00651).
+"""
+import numpy as np
+import pytest
+
+from fxtensor_salmon import FXTensor
+
+from test_axioms import random_kernel
+
+X = ["x0", "x1", "x2"]
+Y = ["y0", "y1"]
+
+
+def joint(prior, f):
+    """prior ; copy ; (id ⊗ f)"""
+    x = prior.profile[1]
+    return prior.composition(FXTensor.copy_tensor(x)).composition(
+        FXTensor.identity_tensor(x).tensor_product(f)
+    )
+
+
+@pytest.fixture
+def prior():
+    # x2 has probability zero
+    return FXTensor([[], [X]], data=np.array([0.4, 0.6, 0.0]))
+
+
+@pytest.fixture
+def f():
+    return FXTensor([[X], [Y]], data=np.array([[0.2, 0.8], [0.5, 0.5], [1.0, 0.0]]))
+
+
+@pytest.fixture
+def g():
+    # differs from f only on the null point x2
+    return FXTensor([[X], [Y]], data=np.array([[0.2, 0.8], [0.5, 0.5], [0.3, 0.7]]))
+
+
+class TestSupport:
+    def test_state(self, prior):
+        s = prior.support()
+        assert s.labels == (None, [X])
+        assert np.array_equal(s.data, [1.0, 1.0, 0.0])
+
+    def test_kernel_relation(self, f):
+        s = f.support()
+        assert s.profile == f.profile
+        assert s.labels == f.labels
+        assert np.array_equal(s.data, [[1, 1], [1, 1], [1, 0]])
+
+    def test_tolerance(self):
+        p = FXTensor([[], [2]], data=np.array([1 - 1e-12, 1e-12]))
+        assert np.array_equal(p.support().data, [1.0, 0.0])
+
+    def test_support_of_composition(self, prior, f):
+        # supp(p;f) = {y : exists x in supp(p) with f(y|x) > 0}
+        expected = (prior.support().data @ f.support().data) > 0
+        assert np.array_equal(prior.composition(f).support().data, expected.astype(float))
+
+
+class TestAlmostSurelyEqual:
+    def test_differs_only_on_null_set(self, prior, f, g):
+        assert f.almost_surely_equal(g, prior)
+        assert f != g
+
+    def test_matches_joint_equation(self, prior, f, g):
+        assert joint(prior, f) == joint(prior, g)
+
+    def test_differs_on_support(self, prior, f):
+        h = FXTensor([[X], [Y]], data=np.array([[0.3, 0.7], [0.5, 0.5], [1.0, 0.0]]))
+        assert not f.almost_surely_equal(h, prior)
+        assert joint(prior, f) != joint(prior, h)
+
+    def test_full_support_prior_means_equality(self, f, g):
+        uniform = FXTensor([[], [X]], data=np.full(3, 1 / 3))
+        assert not f.almost_surely_equal(g, uniform)
+        assert f.almost_surely_equal(f.copy(), uniform)
+
+    def test_double_bayesian_inversion_is_almost_surely_equal(self, prior, g):
+        # with a non-full-support prior, (g†)† differs from g on x2 but agrees a.s.
+        inv = g.bayesian_inversion(prior)
+        double = inv.bayesian_inversion(prior.composition(g))
+        assert double != g
+        assert double.almost_surely_equal(g, prior)
+
+    def test_random_multi_axis(self):
+        p = random_kernel([], [2, 3], 40)
+        data = p.data.copy()
+        data[1, 2] = 0.0
+        p = FXTensor([[], [2, 3]], data=data / data.sum())
+        f = random_kernel([2, 3], [2], 41)
+        g_data = f.data.copy()
+        g_data[1, 2] = [0.9, 0.1]
+        g = FXTensor([[2, 3], [2]], data=g_data)
+        assert f.almost_surely_equal(g, p)
+        assert joint(p, f) == joint(p, g)
+
+    def test_labels_are_ignored(self, prior, f):
+        unlabeled = FXTensor([[3], [2]], data=f.data)
+        assert f.almost_surely_equal(unlabeled, prior)
+
+    def test_errors(self, prior, f):
+        with pytest.raises(ValueError):
+            f.almost_surely_equal(FXTensor([[3], [3]], data=np.eye(3)), prior)
+        with pytest.raises(ValueError):
+            f.almost_surely_equal(f, f)
+        with pytest.raises(ValueError):
+            f.almost_surely_equal(f, FXTensor([[], [2]], data=np.array([0.5, 0.5])))
+
+
+class TestAbsoluteContinuity:
+    def test_states(self):
+        p = FXTensor([[], [3]], data=np.array([0.5, 0.5, 0.0]))
+        q = FXTensor([[], [3]], data=np.array([0.2, 0.3, 0.5]))
+        assert p.is_absolutely_continuous(q)
+        assert not q.is_absolutely_continuous(p)
+
+    def test_equivalent_to_support_inclusion(self):
+        rng = np.random.default_rng(50)
+        for _ in range(20):
+            a = rng.random(4) * (rng.random(4) > 0.4)
+            b = rng.random(4) * (rng.random(4) > 0.4)
+            p, q = FXTensor([[], [4]], data=a), FXTensor([[], [4]], data=b)
+            inclusion = np.all(p.support().data <= q.support().data)
+            assert p.is_absolutely_continuous(q) == inclusion
+
+    def test_kernels_inputwise(self, f, g):
+        assert f.is_absolutely_continuous(g)
+        assert not g.is_absolutely_continuous(f)
+
+    def test_reflexive_and_transitive(self):
+        p = FXTensor([[], [3]], data=np.array([1.0, 0.0, 0.0]))
+        q = FXTensor([[], [3]], data=np.array([0.5, 0.5, 0.0]))
+        r = FXTensor([[], [3]], data=np.full(3, 1 / 3))
+        assert p.is_absolutely_continuous(p)
+        assert p.is_absolutely_continuous(q) and q.is_absolutely_continuous(r)
+        assert p.is_absolutely_continuous(r)
+
+    def test_preserved_by_composition(self, f):
+        p = FXTensor([[], [X]], data=np.array([1.0, 0.0, 0.0]))
+        q = FXTensor([[], [X]], data=np.array([0.5, 0.0, 0.5]))
+        assert p.is_absolutely_continuous(q)
+        assert p.composition(f).is_absolutely_continuous(q.composition(f))
+
+    def test_almost_sure_equality_transfers(self, prior, f, g):
+        # if p ≪ q and f = g q-a.s., then f = g p-a.s.
+        p = FXTensor([[], [X]], data=np.array([1.0, 0.0, 0.0]))
+        assert p.is_absolutely_continuous(prior)
+        assert f.almost_surely_equal(g, prior)
+        assert f.almost_surely_equal(g, p)
+
+    def test_profile_mismatch(self):
+        with pytest.raises(ValueError):
+            FXTensor([[], [2]], data=np.ones(2)).is_absolutely_continuous(FXTensor([[], [3]], data=np.ones(3)))