From ae1af29a87e811947ed1e4304d34ffa7be691730 Mon Sep 17 00:00:00 2001 From: Jeremie Gince Date: Thu, 2 Jul 2026 06:08:09 -0400 Subject: [PATCH 1/6] Enhance PfaffianStrategy to handle numerically singular inputs with adaptive criteria --- src/torch_pfaffian/strategies/strategy.py | 52 ++++++++++++++------ tests/test_strategies/test_strategy.py | 60 +++++++++++++++++++++++ 2 files changed, 96 insertions(+), 16 deletions(-) diff --git a/src/torch_pfaffian/strategies/strategy.py b/src/torch_pfaffian/strategies/strategy.py index c457960..e742afe 100644 --- a/src/torch_pfaffian/strategies/strategy.py +++ b/src/torch_pfaffian/strategies/strategy.py @@ -1,9 +1,17 @@ +import math + import torch class PfaffianStrategy(torch.autograd.Function): EPSILON = 1e-30 NAME = "PfaffianStrategy" + # A batch element is routed to the exact minor-based adjugate when |pf| <= eps^0.75 * scale^(n/2) + # (relative to the entry scale, since pf is a degree-n/2 polynomial in the entries), or when the + # LU inverse fails its residual check ||A A^{-1} - I||_max > eps^0.5. Exponents of the dtype eps + # keep both criteria dtype-adaptive (float64: ~1e-12 and ~1.5e-8; float32: ~6e-6 and ~3e-4). + SINGULARITY_RTOL_EXPONENT = 0.75 + INVERSE_RESIDUAL_RTOL_EXPONENT = 0.5 @staticmethod def setup_context(ctx: torch.autograd.function.FunctionCtx, inputs, output): @@ -27,11 +35,22 @@ def pfaffian_grad_matrix( Gradient of the signed Pfaffian with respect to the input matrix. Uses the closed form ``d pf(A) / d A = (1 / 2) pf(A) (A^{-1})^T`` via the Pfaffian adjugate - ``pf(A) A^{-1}``. For invertible inputs the adjugate is ``pf(A) * inv(A)`` (a single inverse); - for singular inputs (``pf == 0``), where that product would be ``0`` and miss the true - derivative, the adjugate is recomputed exactly from minor Pfaffians via - :meth:`_pfaffian_adjugate` (using ``cls``'s own forward). The minor-based path runs only on the - singular batch elements, so invertible inputs keep the single cheap inverse. + ``pf(A) A^{-1}``. For well-conditioned inputs the adjugate is ``pf(A) * inv(A)`` (a single + inverse); for (numerically) singular inputs, where that product would be inaccurate or + garbage, the adjugate is recomputed exactly from minor Pfaffians via + :meth:`_pfaffian_adjugate` (using ``cls``'s own forward). The minor-based path runs only on + the flagged batch elements, so well-conditioned inputs keep the single cheap inverse. + + An element is flagged singular by two dtype-adaptive criteria (see the class constants): + the relative magnitude test ``|pf| <= eps^0.75 * scale^(n/2)`` with ``scale`` the largest + entry magnitude (an exactly-singular matrix has a forward Pfaffian of round-off size, never + exactly ``0``, so an exact ``pf == 0`` test would route it to the LU inverse, which raises + on real inputs and silently returns garbage on complex inputs), and a residual check + ``||A A^{-1} - I||_max > eps^0.5`` that catches ill-conditioned elements whose Pfaffian is + not small (for example one tiny and one huge singular-value pair). The magnitude test is + evaluated in log space so ``scale^(n/2)`` cannot overflow. Both tests only ever move + elements to the exact minor-based path, so flagging a well-conditioned element costs speed, + never accuracy. The inverse uses :func:`torch.linalg.inv` (an LU factorization) rather than :func:`torch.linalg.pinv` (an SVD). A skew-symmetric ``A`` is invertible exactly when @@ -39,7 +58,7 @@ def pfaffian_grad_matrix( invertible elements, where the LU factorization is the correct and robust tool. The SVD-based pseudo-inverse can fail to converge on ill-conditioned or near-repeated-singular-value inputs, which the LU factorization does not. Because ``inv`` raises on an exactly-singular matrix, the - ``pf == 0`` elements (whose inverse is discarded anyway) are replaced by the identity before the + flagged elements (whose inverse is discarded anyway) are replaced by the identity before the batched inverse so the call stays well-posed. The Pfaffian is holomorphic in the entries of ``A``, so for complex inputs the backward returns @@ -53,17 +72,18 @@ def pfaffian_grad_matrix( :return: Gradient of the input matrix, of shape ``(..., n, n)``. :rtype: torch.Tensor """ - singular = pfaffian == 0 dimension = matrix.shape[-1] - any_singular = bool(singular.any()) - if any_singular: - identity = torch.eye(dimension, dtype=matrix.dtype, device=matrix.device).expand_as(matrix) - safe_matrix = torch.where(singular[..., None, None], identity, matrix) # (..., n, n) - inverse = torch.linalg.inv(safe_matrix) - else: - inverse = torch.linalg.inv(matrix) - adjugate = pfaffian[..., None, None] * inverse # pf(A) A^{-1}; 0 where pf == 0 - if any_singular: + epsilon = torch.finfo(matrix.dtype).eps + entry_scale = matrix.abs().amax(dim=(-2, -1)) # (...,) + log_threshold = (dimension // 2) * torch.log(entry_scale) + cls.SINGULARITY_RTOL_EXPONENT * math.log(epsilon) + singular = (entry_scale == 0) | (torch.log(pfaffian.abs()) <= log_threshold) # log(0) = -inf is covered + identity = torch.eye(dimension, dtype=matrix.dtype, device=matrix.device).expand_as(matrix) + safe_matrix = torch.where(singular[..., None, None], identity, matrix) # (..., n, n) + inverse = torch.linalg.inv(safe_matrix) + residual = (safe_matrix @ inverse - identity).abs().amax(dim=(-2, -1)) # (...,) + singular = singular | (residual > epsilon**cls.INVERSE_RESIDUAL_RTOL_EXPONENT) + adjugate = pfaffian[..., None, None] * inverse # pf(A) A^{-1}; discarded where singular + if bool(singular.any()): flat_matrix = matrix.reshape(-1, dimension, dimension) flat_adjugate = adjugate.reshape(-1, dimension, dimension) singular_index = singular.reshape(-1).nonzero(as_tuple=True)[0] diff --git a/tests/test_strategies/test_strategy.py b/tests/test_strategies/test_strategy.py index 0519954..bec1389 100644 --- a/tests/test_strategies/test_strategy.py +++ b/tests/test_strategies/test_strategy.py @@ -126,3 +126,63 @@ def test_grad_matrix_ill_conditioned_invertible_is_finite_and_exact(self): expected = torch.einsum("ij->ji", 0.5 * grad_output * pfaffian * torch.linalg.inv(matrix)) assert torch.isfinite(result).all() torch.testing.assert_close(result, expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + def test_grad_matrix_numerically_singular_real_does_not_raise(self): + # A rank-deficient skew matrix has a forward Pfaffian of + # round-off size, not exactly 0, so an exact ``pf == 0`` test routed it to the LU inverse, + # which raised on real inputs. The relative magnitude test must route it to the exact + # minor adjugate instead. + generator = torch.Generator().manual_seed(4) + first = torch.randn(6, dtype=torch.float64, generator=generator) + second = torch.randn(6, dtype=torch.float64, generator=generator) + matrix = torch.outer(first, second) - torch.outer(second, first) # rank 2, pf = 0 exactly in math + pfaffian = PfaffianParlettReid.forward(matrix) + assert pfaffian != 0.0 # round-off, the regression trigger + grad_output = torch.tensor(1.0, dtype=torch.float64) + result = PfaffianParlettReid.pfaffian_grad_matrix(matrix, pfaffian, grad_output) + minor_adjugate = PfaffianParlettReid._pfaffian_adjugate(matrix[None])[0] + expected = torch.einsum("ij->ji", 0.5 * grad_output * minor_adjugate) + assert torch.isfinite(result).all() + torch.testing.assert_close(result, expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + def test_grad_matrix_numerically_singular_complex_is_exact(self): + # On complex inputs the LU inverse of a + # numerically singular matrix returns garbage without raising, so the old exact + # ``pf == 0`` test produced an O(1)-wrong gradient silently. + generator = torch.Generator().manual_seed(5) + first = torch.randn(6, dtype=torch.float64, generator=generator) + 1j * torch.randn( + 6, dtype=torch.float64, generator=generator + ) + second = torch.randn(6, dtype=torch.float64, generator=generator) + 1j * torch.randn( + 6, dtype=torch.float64, generator=generator + ) + matrix = torch.outer(first, second) - torch.outer(second, first) # rank 2, pf = 0 exactly in math + pfaffian = PfaffianParlettReid.forward(matrix) + grad_output = torch.tensor(1.0 + 0.0j, dtype=torch.complex128) + result = PfaffianParlettReid.pfaffian_grad_matrix(matrix, pfaffian, grad_output) + minor_adjugate = PfaffianParlettReid._pfaffian_adjugate(matrix[None])[0] + expected = torch.einsum("ij->ji", 0.5 * grad_output * minor_adjugate.conj()) + assert torch.isfinite(result.real).all() and torch.isfinite(result.imag).all() + torch.testing.assert_close(result, expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + def test_grad_matrix_residual_check_catches_moderate_pfaffian_ill_conditioning(self): + # One tiny and several unit singular-value pairs: the Pfaffian magnitude (1e-10) passes the + # relative magnitude test, but the LU inverse is too inaccurate (condition number ~1e10); + # the residual check must route the element to the exact minor adjugate. + scales = torch.tensor([1e-10, 1.0, 1.0, 1.0], dtype=torch.float64) + blocks = [torch.tensor([[0.0, scale], [-scale, 0.0]], dtype=torch.float64) for scale in scales] + generator = torch.Generator().manual_seed(6) + random_full = torch.randn(8, 8, dtype=torch.float64, generator=generator) + rotation, _ = torch.linalg.qr(random_full) + matrix = rotation.transpose(-1, -2) @ torch.block_diag(*blocks) @ rotation + matrix = 0.5 * (matrix - matrix.transpose(-1, -2)) + pfaffian = PfaffianParlettReid.forward(matrix) + grad_output = torch.tensor(1.0, dtype=torch.float64) + result = PfaffianParlettReid.pfaffian_grad_matrix(matrix, pfaffian, grad_output) + minor_adjugate = PfaffianParlettReid._pfaffian_adjugate(matrix[None])[0] + expected = torch.einsum("ij->ji", 0.5 * grad_output * minor_adjugate) + torch.testing.assert_close(result, expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + def test_class_singularity_constants(self): + assert PfaffianStrategy.SINGULARITY_RTOL_EXPONENT == 0.75 + assert PfaffianStrategy.INVERSE_RESIDUAL_RTOL_EXPONENT == 0.5 From 97af5bf32f11b27359d9a3464761c001b34b89d8 Mon Sep 17 00:00:00 2001 From: Jeremie Gince Date: Wed, 8 Jul 2026 12:22:11 -0400 Subject: [PATCH 2/6] Enhance PfaffianStrategy to improve handling of LU-singular matrices and add tests for edge cases --- src/torch_pfaffian/strategies/strategy.py | 33 ++++++---- tests/test_strategies/test_strategy.py | 76 +++++++++++++++++++++++ 2 files changed, 96 insertions(+), 13 deletions(-) diff --git a/src/torch_pfaffian/strategies/strategy.py b/src/torch_pfaffian/strategies/strategy.py index e742afe..e2ce4f4 100644 --- a/src/torch_pfaffian/strategies/strategy.py +++ b/src/torch_pfaffian/strategies/strategy.py @@ -41,25 +41,29 @@ def pfaffian_grad_matrix( :meth:`_pfaffian_adjugate` (using ``cls``'s own forward). The minor-based path runs only on the flagged batch elements, so well-conditioned inputs keep the single cheap inverse. - An element is flagged singular by two dtype-adaptive criteria (see the class constants): + An element is flagged singular by three dtype-adaptive criteria (see the class constants): the relative magnitude test ``|pf| <= eps^0.75 * scale^(n/2)`` with ``scale`` the largest entry magnitude (an exactly-singular matrix has a forward Pfaffian of round-off size, never exactly ``0``, so an exact ``pf == 0`` test would route it to the LU inverse, which raises - on real inputs and silently returns garbage on complex inputs), and a residual check - ``||A A^{-1} - I||_max > eps^0.5`` that catches ill-conditioned elements whose Pfaffian is - not small (for example one tiny and one huge singular-value pair). The magnitude test is - evaluated in log space so ``scale^(n/2)`` cannot overflow. Both tests only ever move - elements to the exact minor-based path, so flagging a well-conditioned element costs speed, - never accuracy. + on real inputs and silently returns garbage on complex inputs), the LU ``info`` returned by + :func:`torch.linalg.inv_ex` (``info != 0`` marks the elements the LU backend reports as + singular, catching a matrix the magnitude proxy missed because its forward round-off Pfaffian + exceeded ``eps^0.75 * scale^(n/2)``), and a residual check ``||A A^{-1} - I||_max > eps^0.5`` + that catches ill-conditioned elements whose Pfaffian is not small (for example one tiny and + one huge singular-value pair). The magnitude test is evaluated in log space so ``scale^(n/2)`` + cannot overflow. All three tests only ever move elements to the exact minor-based path, so + flagging a well-conditioned element costs speed, never accuracy. - The inverse uses :func:`torch.linalg.inv` (an LU factorization) rather than + The inverse uses :func:`torch.linalg.inv_ex` (an LU factorization) rather than :func:`torch.linalg.pinv` (an SVD). A skew-symmetric ``A`` is invertible exactly when ``pf(A) != 0`` (since ``det(A) = pf(A)^2``), so the inverse is only ever relied upon on the invertible elements, where the LU factorization is the correct and robust tool. The SVD-based pseudo-inverse can fail to converge on ill-conditioned or near-repeated-singular-value inputs, - which the LU factorization does not. Because ``inv`` raises on an exactly-singular matrix, the - flagged elements (whose inverse is discarded anyway) are replaced by the identity before the - batched inverse so the call stays well-posed. + which the LU factorization does not. The flagged elements (whose inverse is discarded anyway) + are replaced by the identity before the batched inverse to keep it well-conditioned, and + :func:`torch.linalg.inv_ex` returns an ``info`` code instead of raising, so a singular element + the magnitude test missed is reported through ``info`` rather than aborting the process from + inside autograd backward. The Pfaffian is holomorphic in the entries of ``A``, so for complex inputs the backward returns the conjugate of the analytic derivative, ``conj(d pf / d A) * grad_output``, which is PyTorch's @@ -73,14 +77,17 @@ def pfaffian_grad_matrix( :rtype: torch.Tensor """ dimension = matrix.shape[-1] + if dimension == 0: + return torch.zeros_like(matrix) # pf of a 0x0 matrix is the constant 1; the gradient is empty epsilon = torch.finfo(matrix.dtype).eps entry_scale = matrix.abs().amax(dim=(-2, -1)) # (...,) log_threshold = (dimension // 2) * torch.log(entry_scale) + cls.SINGULARITY_RTOL_EXPONENT * math.log(epsilon) singular = (entry_scale == 0) | (torch.log(pfaffian.abs()) <= log_threshold) # log(0) = -inf is covered identity = torch.eye(dimension, dtype=matrix.dtype, device=matrix.device).expand_as(matrix) safe_matrix = torch.where(singular[..., None, None], identity, matrix) # (..., n, n) - inverse = torch.linalg.inv(safe_matrix) - residual = (safe_matrix @ inverse - identity).abs().amax(dim=(-2, -1)) # (...,) + inverse, info = torch.linalg.inv_ex(safe_matrix) # non-raising; info != 0 marks LU-singular elements + singular = singular | (info != 0) # exactly the elements the LU backend cannot invert + residual = (safe_matrix @ inverse - identity).abs().amax(dim=(-2, -1)) # (...,); nan on LU-singular singular = singular | (residual > epsilon**cls.INVERSE_RESIDUAL_RTOL_EXPONENT) adjugate = pfaffian[..., None, None] * inverse # pf(A) A^{-1}; discarded where singular if bool(singular.any()): diff --git a/tests/test_strategies/test_strategy.py b/tests/test_strategies/test_strategy.py index bec1389..9b94545 100644 --- a/tests/test_strategies/test_strategy.py +++ b/tests/test_strategies/test_strategy.py @@ -183,6 +183,82 @@ def test_grad_matrix_residual_check_catches_moderate_pfaffian_ill_conditioning(s expected = torch.einsum("ij->ji", 0.5 * grad_output * minor_adjugate) torch.testing.assert_close(result, expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + def test_grad_matrix_lu_singular_above_magnitude_threshold_does_not_raise(self): + # Regression for the backward core dump: a matrix that is exactly singular to the LU + # factorization (a zero pivot) can carry a forward Pfaffian whose magnitude sits *above* the + # relative magnitude threshold (the forward's round-off for a singular matrix can exceed + # eps^0.75 * scale^(n/2)), so the magnitude test never flags it. It then reached the raising + # torch.linalg.inv and, inside autograd backward, aborted the process. The LU info from + # torch.linalg.inv_ex must flag it and route it to the exact minor adjugate. + singular = torch.zeros(4, 4, dtype=torch.float64) + singular[2, 3] = 1.0 + singular[3, 2] = -1.0 # rank 2, exactly singular, true pf = 0 + entry_scale = singular.abs().amax() + threshold = ( + entry_scale ** (4 // 2) * torch.finfo(torch.float64).eps ** PfaffianStrategy.SINGULARITY_RTOL_EXPONENT + ) + above_threshold_pfaffian = torch.tensor(0.5, dtype=torch.float64) + assert above_threshold_pfaffian.abs() > threshold # not caught by the magnitude test + grad_output = torch.tensor(1.0, dtype=torch.float64) + result = PfaffianParlettReid.pfaffian_grad_matrix(singular, above_threshold_pfaffian, grad_output) + minor_adjugate = PfaffianParlettReid._pfaffian_adjugate(singular[None])[0] + expected = torch.einsum("ij->ji", 0.5 * grad_output * minor_adjugate) + assert torch.isfinite(result).all() + torch.testing.assert_close(result, expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + def test_grad_matrix_lu_singular_complex_above_threshold_is_finite_and_exact(self): + # The complex counterpart: torch.linalg.inv returns garbage (no raise) for a numerically + # singular complex matrix above the magnitude threshold, silently corrupting the gradient. + # The LU info flag must route it to the exact minor adjugate instead. + singular = torch.zeros(4, 4, dtype=torch.complex128) + singular[2, 3] = 1.0 + 0.0j + singular[3, 2] = -1.0 + 0.0j # rank 2, exactly singular, true pf = 0 + above_threshold_pfaffian = torch.tensor(0.5 + 0.0j, dtype=torch.complex128) + grad_output = torch.tensor(1.0 + 0.0j, dtype=torch.complex128) + result = PfaffianParlettReid.pfaffian_grad_matrix(singular, above_threshold_pfaffian, grad_output) + minor_adjugate = PfaffianParlettReid._pfaffian_adjugate(singular[None])[0] + expected = torch.einsum("ij->ji", 0.5 * grad_output * minor_adjugate.conj()) + assert torch.isfinite(result.real).all() and torch.isfinite(result.imag).all() + torch.testing.assert_close(result, expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + def test_grad_matrix_mixed_lu_singular_batch_matches_closed_forms(self): + # A batch mixing an LU-singular element (above the magnitude threshold) with an invertible + # element: the batched torch.linalg.inv_ex must not raise, and each element must match its + # exact closed form. Guards against inf/nan from the singular element's discarded inverse + # leaking into the invertible element's gradient. + singular = torch.zeros(4, 4, dtype=torch.float64) + singular[2, 3] = 1.0 + singular[3, 2] = -1.0 + invertible = _random_skew(4, seed=7) + matrix = torch.stack([singular, invertible]) + invertible_pfaffian = PfaffianParlettReid.forward(invertible) + pfaffian = torch.stack([torch.tensor(0.5, dtype=torch.float64), invertible_pfaffian]) + grad_output = torch.tensor([1.3, -0.7], dtype=torch.float64) + result = PfaffianParlettReid.pfaffian_grad_matrix(matrix, pfaffian, grad_output) + expected_invertible = torch.einsum( + "ij->ji", 0.5 * grad_output[1] * invertible_pfaffian * torch.linalg.inv(invertible) + ) + minor_adjugate = PfaffianParlettReid._pfaffian_adjugate(singular[None])[0] + expected_singular = torch.einsum("ij->ji", 0.5 * grad_output[0] * minor_adjugate) + assert torch.isfinite(result).all() + torch.testing.assert_close( + result[1], expected_invertible, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON + ) + torch.testing.assert_close( + result[0], expected_singular, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON + ) + + def test_grad_matrix_empty_matrix_returns_empty_gradient(self): + # A 0x0 matrix has the constant Pfaffian 1, so the forward supports dimension == 0. The + # backward must return the empty (..., 0, 0) gradient instead of raising on the zero-size + # amax reduction used by the singularity criteria. + matrix = torch.zeros(1, 0, 0, dtype=torch.float64) + pfaffian = torch.ones(1, dtype=torch.float64) + grad_output = torch.ones(1, dtype=torch.float64) + result = PfaffianParlettReid.pfaffian_grad_matrix(matrix, pfaffian, grad_output) + assert result.shape == matrix.shape + assert result.dtype == matrix.dtype + def test_class_singularity_constants(self): assert PfaffianStrategy.SINGULARITY_RTOL_EXPONENT == 0.75 assert PfaffianStrategy.INVERSE_RESIDUAL_RTOL_EXPONENT == 0.5 From 98415690307a180715a24db0c1aaf5b630d5bab5 Mon Sep 17 00:00:00 2001 From: Jeremie Gince Date: Mon, 13 Jul 2026 16:41:31 -0400 Subject: [PATCH 3/6] Add new Pfaffian strategies and enhance existing ones for improved gradient handling --- rust/src/lib.rs | 312 +++++++++++++++++- src/torch_pfaffian/__init__.py | 131 ++++++-- src/torch_pfaffian/kernels/__init__.py | 3 + src/torch_pfaffian/kernels/det_magnitude.py | 85 +++++ .../kernels/parlett_reid_slog.py | 108 ++++++ src/torch_pfaffian/kernels/small_n.py | 82 +++++ src/torch_pfaffian/strategies/__init__.py | 2 + .../strategies/pfaffian_block_det.py | 10 + .../strategies/pfaffian_fdbpf.py | 10 +- .../strategies/pfaffian_slog.py | 61 ++++ .../strategies/pfaffian_small.py | 32 ++ src/torch_pfaffian/strategies/strategy.py | 19 ++ tests/reference.py | 159 +++++++++ tests/test__rust.py | 113 +++++++ tests/test_kernels/__init__.py | 0 tests/test_kernels/test_det_magnitude.py | 146 ++++++++ tests/test_kernels/test_parlett_reid_slog.py | 142 ++++++++ tests/test_kernels/test_small_n.py | 127 +++++++ .../test_pfaffian_block_det.py | 19 ++ tests/test_strategies/test_pfaffian_fdbpf.py | 20 ++ tests/test_strategies/test_pfaffian_slog.py | 99 ++++++ tests/test_strategies/test_pfaffian_small.py | 106 ++++++ tests/test_strategies/test_strategy.py | 24 ++ tests/test_torch_pfaffian.py | 174 +++++++++- 24 files changed, 1933 insertions(+), 51 deletions(-) create mode 100644 src/torch_pfaffian/kernels/__init__.py create mode 100644 src/torch_pfaffian/kernels/det_magnitude.py create mode 100644 src/torch_pfaffian/kernels/parlett_reid_slog.py create mode 100644 src/torch_pfaffian/kernels/small_n.py create mode 100644 src/torch_pfaffian/strategies/pfaffian_slog.py create mode 100644 src/torch_pfaffian/strategies/pfaffian_small.py create mode 100644 tests/reference.py create mode 100644 tests/test__rust.py create mode 100644 tests/test_kernels/__init__.py create mode 100644 tests/test_kernels/test_det_magnitude.py create mode 100644 tests/test_kernels/test_parlett_reid_slog.py create mode 100644 tests/test_kernels/test_small_n.py create mode 100644 tests/test_strategies/test_pfaffian_slog.py create mode 100644 tests/test_strategies/test_pfaffian_small.py diff --git a/rust/src/lib.rs b/rust/src/lib.rs index 29b3193..7674488 100644 --- a/rust/src/lib.rs +++ b/rust/src/lib.rs @@ -53,14 +53,49 @@ impl Magnitude for Complex { } } -/// Signed Pfaffian of a single skew-symmetric matrix via Parlett-Reid elimination. +/// Unit-modulus phase ``self / |self|`` of a nonzero scalar, staying in the native type. +/// +/// For real scalars this is the sign (``+-1``); for complex scalars it is the unit phasor. Used only +/// by the log-domain (slog) kernel, so it is implemented for the four precisions that expose a slog +/// entry point (not ``f16``). Callers guard against a zero magnitude before dividing. +trait SlogScalar: Magnitude { + fn unit_phase(self) -> Self; +} + +impl SlogScalar for f32 { + fn unit_phase(self) -> f32 { + self / self.abs() + } +} + +impl SlogScalar for f64 { + fn unit_phase(self) -> f64 { + self / self.abs() + } +} + +impl SlogScalar for Complex { + fn unit_phase(self) -> Complex { + self / self.norm() + } +} + +impl SlogScalar for Complex { + fn unit_phase(self) -> Complex { + self / self.norm() + } +} + +/// Signed Pfaffian of a single skew-symmetric matrix held as a flat row-major buffer. /// /// Generic over the scalar type so the same algorithm serves ``f32``/``f64`` and their complex -/// counterparts: the arithmetic runs in the native type while pivoting compares magnitudes. The -/// matrix is copied into a flat row-major buffer so the hot rank-2 Schur update runs over a -/// contiguous row slice, which the compiler can auto-vectorize (far cheaper than per-element -/// strided ndarray indexing). -fn pfaffian_one(matrix: Array2) -> T +/// counterparts: the arithmetic runs in the native type while pivoting compares magnitudes. Working +/// on a flat ``Vec`` (indexed ``data[row * dimension + col]``) keeps the hot rank-2 Schur update over +/// a contiguous row slice, which the compiler can auto-vectorize. The caller owns the buffer, so this +/// runs under ``py.allow_threads`` with no borrow of Python-managed data. A pivot column whose +/// magnitude falls below ``PIVOT_EPSILON`` yields ``0`` (the historical linear-domain threshold; the +/// slog kernel uses an exact-zero test instead). +fn pfaffian_from_flat(mut data: Vec, dimension: usize) -> T where T: Copy + Zero @@ -72,14 +107,12 @@ where + Mul + Div, { - let dimension = matrix.nrows(); if dimension % 2 == 1 { return T::zero(); } if dimension == 0 { return T::one(); } - let mut data: Vec = matrix.iter().copied().collect(); // row-major, len dimension * dimension let mut sign = T::one(); let mut column = 0usize; while column + 2 < dimension { @@ -133,10 +166,129 @@ where pfaffian } -/// Signed Pfaffian of each owned matrix, computed in parallel across the batch above a threshold. +/// Signed Pfaffian of a single owned ``Array2``: copies it into a flat row-major buffer and runs +/// [`pfaffian_from_flat`]. This is the per-matrix worker that [`signed_pfaffian_owned`] maps over the +/// batch (the copy from the numpy view happens once in [`owned_matrices`] and once here, matching the +/// released kernel); the slog entry points use their own single-copy [`flat_matrices`] path. +fn pfaffian_one(matrix: Array2) -> T +where + T: Copy + + Zero + + One + + Magnitude + + Neg + + Add + + Sub + + Mul + + Div, +{ + let dimension = matrix.nrows(); + pfaffian_from_flat(matrix.iter().copied().collect(), dimension) +} + +/// Log-domain signed Pfaffian ``(phase, log|Pf|)`` of a single skew-symmetric matrix (flat buffer). /// -/// The batch elements are independent, so they are mapped over rayon threads; the per-matrix -/// Parlett-Reid elimination itself stays sequential. The caller releases the GIL around this. +/// The same Parlett-Reid elimination as [`pfaffian_from_flat`], but the linear product of the +/// superdiagonal entries is factored into a unit-modulus ``phase`` (native type) and a ``log|Pf|`` +/// accumulated in ``f64`` (``+= |pivot|.ln()``), which neither overflows for large matrices nor +/// underflows for tiny Pfaffians. A zero pivot is detected exactly (magnitude ``== 0``, not an epsilon +/// threshold), giving ``(0, -inf)`` for that matrix; its remaining updates would be benign, so the +/// early return is equivalent. Odd ``dimension`` gives ``(0, -inf)`` and ``dimension == 0`` gives +/// ``(1, 0)``. Reconstruction ``phase * exp(log_abs)`` equals the value [`pfaffian_from_flat`] would +/// return, up to the log/exp rounding, so it matches ``signed_pfaffian_*`` within tolerance. +fn slog_pfaffian_from_flat(mut data: Vec, dimension: usize) -> (T, f64) +where + T: Copy + + Zero + + One + + SlogScalar + + Neg + + Add + + Sub + + Mul + + Div, +{ + if dimension % 2 == 1 { + return (T::zero(), f64::NEG_INFINITY); + } + if dimension == 0 { + return (T::one(), 0.0); + } + let mut sign = T::one(); + let mut column = 0usize; + while column + 2 < dimension { + // Partial pivoting: largest magnitude data[row, column] for row > column + 1. + let mut pivot_row = column + 2; + let mut best = data[(column + 2) * dimension + column].magnitude(); + for row in (column + 3)..dimension { + let candidate = data[row * dimension + column].magnitude(); + if candidate > best { + best = candidate; + pivot_row = row; + } + } + if best > data[(column + 1) * dimension + column].magnitude() { + // Congruence swap of rows then columns column+1 <-> pivot_row; each swap flips the phase. + for index in 0..dimension { + data.swap((column + 1) * dimension + index, pivot_row * dimension + index); + } + for index in 0..dimension { + data.swap(index * dimension + (column + 1), index * dimension + pivot_row); + } + sign = -sign; + } + let pivot = data[(column + 1) * dimension + column]; + if pivot.magnitude() == 0.0 { + // Exact zero pivot column: Pf = 0 with no epsilon fudge. + return (T::zero(), f64::NEG_INFINITY); + } + // Rank-2 skew Schur-complement update on the trailing block, read from originals. + let base = column + 2; + let length = dimension - base; + let tau: Vec = (0..length).map(|k| data[(base + k) * dimension + column] / pivot).collect(); + let next: Vec = (0..length).map(|k| data[(base + k) * dimension + (column + 1)]).collect(); + for row_offset in 0..length { + let tau_row = tau[row_offset]; + let next_row = next[row_offset]; + let start = (base + row_offset) * dimension + base; + let row = &mut data[start..start + length]; + for column_offset in 0..length { + row[column_offset] = + row[column_offset] + tau_row * next[column_offset] - next_row * tau[column_offset]; + } + } + column += 2; + } + // Factor the product of the superdiagonal entries into (unit phase, sum of log-magnitudes). + let mut phase = sign; + let mut log_abs = 0.0_f64; + let mut index = 0usize; + while index < dimension { + let entry = data[index * dimension + (index + 1)]; + let magnitude = entry.magnitude(); + if magnitude == 0.0 { + return (T::zero(), f64::NEG_INFINITY); + } + phase = phase * entry.unit_phase(); + log_abs += magnitude.ln(); + index += 2; + } + (phase, log_abs) +} + +/// Build one flat row-major buffer per ``(n, n)`` slice of a ``(batch, n, n)`` view (one copy each) +/// and return them together with the shared matrix dimension ``n``. +fn flat_matrices(matrix: &PyReadonlyArray3<'_, T>) -> (Vec>, usize) { + let view = matrix.as_array(); + let batch = view.shape()[0]; + let dimension = view.shape()[1]; + let flats = (0..batch) + .map(|index| view.index_axis(Axis(0), index).iter().copied().collect()) + .collect(); + (flats, dimension) +} + +/// Signed Pfaffian of each owned matrix, computed in parallel across the batch above a threshold. fn signed_pfaffian_owned(matrices: Vec>) -> Vec where T: Copy @@ -165,6 +317,28 @@ fn owned_matrices(matrix: &PyReadonlyArray3<'_, T>) - (0..batch).map(|index| view.index_axis(Axis(0), index).to_owned()).collect() } +/// Log-domain signed Pfaffian ``(phase, log|Pf|)`` of each flat matrix, parallel above a threshold. +fn signed_slog_flat(flats: Vec>, dimension: usize) -> Vec<(T, f64)> +where + T: Copy + + Zero + + One + + SlogScalar + + Neg + + Add + + Sub + + Mul + + Div + + Send + + Sync, +{ + if flats.len() >= PARALLEL_BATCH_THRESHOLD { + flats.into_par_iter().map(|flat| slog_pfaffian_from_flat(flat, dimension)).collect() + } else { + flats.into_iter().map(|flat| slog_pfaffian_from_flat(flat, dimension)).collect() + } +} + /// Signed Pfaffian of a batch of ``float64`` skew-symmetric matrices, shape ``(batch, n, n)``. #[pyfunction] fn signed_pfaffian_f64<'py>(py: Python<'py>, matrix: PyReadonlyArray3<'py, f64>) -> Bound<'py, PyArray1> { @@ -214,6 +388,63 @@ fn signed_pfaffian_c64<'py>( Array1::from(results).into_pyarray(py) } +/// Log-domain signed Pfaffian of a batch of ``float64`` matrices: returns ``(phase, log|Pf|)`` arrays. +#[pyfunction] +fn signed_slog_pfaffian_f64<'py>( + py: Python<'py>, + matrix: PyReadonlyArray3<'py, f64>, +) -> (Bound<'py, PyArray1>, Bound<'py, PyArray1>) { + let (flats, dimension) = flat_matrices(&matrix); + let results = py.allow_threads(|| signed_slog_flat(flats, dimension)); + let (phases, logs): (Vec, Vec) = results.into_iter().unzip(); + (Array1::from(phases).into_pyarray(py), Array1::from(logs).into_pyarray(py)) +} + +/// Log-domain signed Pfaffian of a batch of ``float32`` matrices: returns ``(phase, log|Pf|)`` arrays. +/// +/// ``log|Pf|`` is accumulated in ``f64`` for accuracy and cast to ``float32`` at the boundary. +#[pyfunction] +fn signed_slog_pfaffian_f32<'py>( + py: Python<'py>, + matrix: PyReadonlyArray3<'py, f32>, +) -> (Bound<'py, PyArray1>, Bound<'py, PyArray1>) { + let (flats, dimension) = flat_matrices(&matrix); + let results = py.allow_threads(|| signed_slog_flat(flats, dimension)); + let (phases, logs): (Vec, Vec) = results.into_iter().unzip(); + let logs: Vec = logs.into_iter().map(|value| value as f32).collect(); + (Array1::from(phases).into_pyarray(py), Array1::from(logs).into_pyarray(py)) +} + +/// Log-domain signed Pfaffian of a batch of ``complex128`` matrices: returns ``(phase, log|Pf|)``. +/// +/// ``phase`` is the unit-modulus complex phasor; ``log|Pf|`` is the real (``float64``) log-magnitude. +#[pyfunction] +fn signed_slog_pfaffian_c128<'py>( + py: Python<'py>, + matrix: PyReadonlyArray3<'py, Complex64>, +) -> (Bound<'py, PyArray1>, Bound<'py, PyArray1>) { + let (flats, dimension) = flat_matrices(&matrix); + let results = py.allow_threads(|| signed_slog_flat(flats, dimension)); + let (phases, logs): (Vec, Vec) = results.into_iter().unzip(); + (Array1::from(phases).into_pyarray(py), Array1::from(logs).into_pyarray(py)) +} + +/// Log-domain signed Pfaffian of a batch of ``complex64`` matrices: returns ``(phase, log|Pf|)``. +/// +/// ``phase`` is the unit-modulus complex phasor; ``log|Pf|`` is accumulated in ``f64`` and cast to +/// the real ``float32`` type at the boundary. +#[pyfunction] +fn signed_slog_pfaffian_c64<'py>( + py: Python<'py>, + matrix: PyReadonlyArray3<'py, Complex32>, +) -> (Bound<'py, PyArray1>, Bound<'py, PyArray1>) { + let (flats, dimension) = flat_matrices(&matrix); + let results = py.allow_threads(|| signed_slog_flat(flats, dimension)); + let (phases, logs): (Vec, Vec) = results.into_iter().unzip(); + let logs: Vec = logs.into_iter().map(|value| value as f32).collect(); + (Array1::from(phases).into_pyarray(py), Array1::from(logs).into_pyarray(py)) +} + #[pymodule] fn _rust(module: &Bound<'_, PyModule>) -> PyResult<()> { module.add_function(wrap_pyfunction!(signed_pfaffian_f64, module)?)?; @@ -221,15 +452,19 @@ fn _rust(module: &Bound<'_, PyModule>) -> PyResult<()> { module.add_function(wrap_pyfunction!(signed_pfaffian_f16, module)?)?; module.add_function(wrap_pyfunction!(signed_pfaffian_c128, module)?)?; module.add_function(wrap_pyfunction!(signed_pfaffian_c64, module)?)?; + module.add_function(wrap_pyfunction!(signed_slog_pfaffian_f64, module)?)?; + module.add_function(wrap_pyfunction!(signed_slog_pfaffian_f32, module)?)?; + module.add_function(wrap_pyfunction!(signed_slog_pfaffian_c128, module)?)?; + module.add_function(wrap_pyfunction!(signed_slog_pfaffian_c64, module)?)?; Ok(()) } #[cfg(test)] mod tests { - use super::pfaffian_one; + use super::{pfaffian_one, slog_pfaffian_from_flat}; use half::f16; use num_complex::Complex; - use numpy::ndarray::array; + use numpy::ndarray::{array, Array2}; #[test] fn two_by_two_is_signed() { @@ -263,7 +498,7 @@ mod tests { fn odd_is_zero_and_empty_is_one() { let odd = array![[0.0_f64, 1.0, 2.0], [-1.0, 0.0, 3.0], [-2.0, -3.0, 0.0]]; assert_eq!(pfaffian_one(odd), 0.0); - let empty = numpy::ndarray::Array2::::zeros((0, 0)); + let empty = Array2::::zeros((0, 0)); assert_eq!(pfaffian_one(empty), 1.0); } @@ -325,4 +560,53 @@ mod tests { ]; assert!(pfaffian_one(m).norm() < 1e-12); } + + #[test] + fn slog_two_by_two_reconstructs_signed() { + // pf([[0, -3], [3, 0]]) = -3 -> phase = -1, log|Pf| = ln(3). + let (phase, log_abs) = slog_pfaffian_from_flat(vec![0.0_f64, -3.0, 3.0, 0.0], 2); + assert!((phase - (-1.0)).abs() < 1e-12); + assert!((log_abs - 3.0_f64.ln()).abs() < 1e-12); + assert!((phase * log_abs.exp() - (-3.0)).abs() < 1e-12); + } + + #[test] + fn slog_matches_linear_four_by_four() { + let (a, b, c, d, e, f) = (1.0_f64, 2.0, 3.0, 4.0, 5.0, 6.0); + let data = vec![0.0, a, b, c, -a, 0.0, d, e, -b, -d, 0.0, f, -c, -e, -f, 0.0]; + let linear = pfaffian_one(Array2::from_shape_vec((4, 4), data.clone()).unwrap()); + let (phase, log_abs) = slog_pfaffian_from_flat(data, 4); + assert!((phase * log_abs.exp() - linear).abs() < 1e-9); + } + + #[test] + fn slog_exact_zero_pivot_is_zero_neg_inf() { + // 4x4 with only the trailing 2x2 block nonzero: the first pivot column is zero, so Pf = 0. + let data = vec![ + 0.0_f64, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, -1.0, 0.0, + ]; + let (phase, log_abs) = slog_pfaffian_from_flat(data, 4); + assert_eq!(phase, 0.0); + assert_eq!(log_abs, f64::NEG_INFINITY); + } + + #[test] + fn slog_odd_and_empty() { + let (phase, log_abs) = slog_pfaffian_from_flat(vec![0.0_f64; 9], 3); + assert_eq!(phase, 0.0); + assert_eq!(log_abs, f64::NEG_INFINITY); + let (phase, log_abs) = slog_pfaffian_from_flat(Vec::::new(), 0); + assert_eq!(phase, 1.0); + assert_eq!(log_abs, 0.0); + } + + #[test] + fn slog_complex_two_by_two() { + // pf([[0, z], [-z, 0]]) = z; phase * exp(log|Pf|) reconstructs z. + let z = Complex::new(1.0_f64, 2.0); + let zero = Complex::new(0.0_f64, 0.0); + let (phase, log_abs) = slog_pfaffian_from_flat(vec![zero, z, -z, zero], 2); + let reconstructed = phase * Complex::new(log_abs.exp(), 0.0); + assert!((reconstructed - z).norm() < 1e-12); + } } diff --git a/src/torch_pfaffian/__init__.py b/src/torch_pfaffian/__init__.py index 9182bf5..921f98b 100644 --- a/src/torch_pfaffian/__init__.py +++ b/src/torch_pfaffian/__init__.py @@ -20,12 +20,17 @@ import torch +from .kernels import log_magnitude_pfaffian, magnitude_pfaffian from .strategies import * from .utils import get_all_subclasses warnings.filterwarnings("ignore", category=Warning, module="docutils") warnings.filterwarnings("ignore", category=Warning, module="sphinx") +# Matrices with last dimension at most AUTO_SMALL_MAX are routed to the exact unrolled small-m kernel, +# which is the measured CPU winner in that range; larger inputs use the Parlett-Reid / determinant paths. +AUTO_SMALL_MAX = 6 + pfaffian_strategy_map = {_cls.NAME.lower().strip(): _cls for _cls in get_all_subclasses(PfaffianStrategy)} @@ -36,7 +41,32 @@ def get_pfaffian_function(name: str = PfaffianFDBPf.NAME) -> Callable[[torch.Ten return pfaffian_strategy_map[name].apply -def pfaffian(matrix: torch.Tensor, *, sign: bool = True, check_input: bool = False) -> torch.Tensor: +def slog_pfaffian(matrix: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]: + """ + Log-domain signed Pfaffian of a batch of skew-symmetric matrices as ``(phase, log|Pf|)``. + + Thin wrapper over :class:`~torch_pfaffian.strategies.pfaffian_slog.SlogPfaffianStrategy`. The + reconstruction is ``Pf = phase * exp(log_abs)``. The log domain neither overflows for large + matrices nor underflows for tiny Pfaffians, and the kernel never synchronizes with the host. + ``log_abs`` is differentiable wherever ``Pf != 0``; ``phase`` is non-differentiable (use + :func:`pfaffian` with ``sign=True`` for the full derivative). + + :param matrix: Skew-symmetric matrix of shape ``(..., 2n, 2n)``. + :return: A pair ``(phase, log_abs)``, each of shape ``(...,)``. ``phase`` shares the input dtype + (``0`` when ``Pf = 0``); ``log_abs`` is in the matching real dtype (``-inf`` when ``Pf = 0``). + :rtype: tuple[torch.Tensor, torch.Tensor] + """ + return SlogPfaffianStrategy.apply(matrix) + + +def pfaffian( + matrix: torch.Tensor, + *, + sign: bool = True, + check_input: bool = False, + check_finite: bool = True, + epsilon: float | None = None, +) -> torch.Tensor: """ Compute the Pfaffian of a skew-symmetric matrix, choosing the strategy from the input. @@ -45,25 +75,37 @@ def pfaffian(matrix: torch.Tensor, *, sign: bool = True, check_input: bool = Fal Strategy selection: - =================================== =========================== ========================================= - Condition Strategy Reason - =================================== =========================== ========================================= - ``sign=True``, Rust built, CPU input ``RustPfaffianParlettReid`` fastest signed path (native Rust kernel) - ``sign=True``, otherwise ``PfaffianParlettReid`` GPU-native and pure-Python fallback - ``sign=False``, grad needed ``PfaffianFDBPf`` magnitude only; robust analytic backward - ``sign=False``, no grad ``PfaffianDet`` cheapest: ``sqrt(|det|)`` only - =================================== =========================== ========================================= - - The Rust kernel runs on CPU (in real and complex precisions), so a non-CPU (e.g. CUDA) input is - routed to ``PfaffianParlettReid``, which runs natively on the input device and avoids a host - round-trip. Both strategies compute the correct complex signed Pfaffian without discarding the - imaginary part and are differentiable end-to-end for real and complex inputs (the complex backward - follows PyTorch's Wirtinger convention). + ========================================== =========================== ================================== + Condition Strategy Reason + ========================================== =========================== ================================== + ``m <= AUTO_SMALL_MAX`` ``PfaffianSmall`` exact unrolled kernel (all dtypes) + ``sign=True``, Rust built, CPU input ``RustPfaffianParlettReid`` fastest signed path (native Rust) + ``sign=True``, otherwise ``PfaffianParlettReid`` GPU-native and pure-Python fallback + ``sign=False``, ``epsilon`` given ``magnitude_pfaffian`` log-domain magnitude with floor + ``sign=False``, grad needed ``PfaffianFDBPf`` magnitude only; robust backward + ``sign=False``, no grad ``PfaffianDet`` cheapest: ``sqrt(|det|)`` only + ========================================== =========================== ================================== + + Matrices with last dimension ``m <= AUTO_SMALL_MAX`` take the exact unrolled ``PfaffianSmall`` path + first, regardless of ``sign`` and device (``|Pf|`` for ``sign=False``); it is exact for every dtype + and differentiable end-to-end. For larger matrices the Rust kernel runs on CPU (in real and complex + precisions), so a non-CPU (e.g. CUDA) input is routed to ``PfaffianParlettReid``, which runs + natively on the input device and avoids a host round-trip. All signed strategies compute the correct + complex signed Pfaffian without discarding the imaginary part and are differentiable end-to-end for + real and complex inputs (the complex backward follows PyTorch's Wirtinger convention). The Pfaffian is only defined for skew-symmetric matrices; the strategies assume this and do not - check it. Pass ``check_input=True`` to validate the assumption. For large matrices the Pfaffian - can exceed the floating range and overflow to ``inf``; a ``RuntimeWarning`` is emitted when the - result is not finite. + check it. Pass ``check_input=True`` to validate the assumption. The chosen strategy is the fastest + correct one for the input, so calling ``pfaffian`` is all most callers need. For inputs with a wide + dynamic range the fast linear-domain path can overflow to ``inf`` even when the true Pfaffian is + finite; with ``check_finite=True`` (default) such results are transparently recomputed in the log + domain and recovered, so the caller gets the correct value without reaching for :func:`slog_pfaffian`. + Only a magnitude that genuinely exceeds the input dtype's floating range remains non-finite, and only + then is a ``RuntimeWarning`` emitted. One extreme case is not auto-recovered: for ``m > AUTO_SMALL_MAX`` + the linear signed path declares a pivot magnitude below ``PfaffianStrategy.EPSILON`` (``1e-30``) an + exact zero, so a matrix whose Pfaffian hinges on such a sub-``1e-30`` pivot is reported as ``0``. + :func:`slog_pfaffian`, which uses an exact-zero pivot test, computes these extreme inputs correctly + (as does the unrolled ``m <= AUTO_SMALL_MAX`` path, which has no pivot floor). :param matrix: Skew-symmetric matrix of shape ``(..., 2n, 2n)``. :param sign: When ``True`` (default) return the signed Pfaffian, otherwise its magnitude. @@ -71,6 +113,14 @@ def pfaffian(matrix: torch.Tensor, *, sign: bool = True, check_input: bool = Fal and skew-symmetric (``A == -A^T``) before computing, raising ``ValueError`` otherwise. Off by default (``False``) so trusted inputs pay nothing; the check is an O(n^2) comparison, cheap relative to the O(n^3) Pfaffian. + :param check_finite: When ``True`` (default), verify the result is finite; if the fast path + overflowed, recompute in the log domain and recover the value, warning only if it still exceeds + the dtype's range. This costs one device-to-host synchronization; pass ``False`` to skip both the + check and the recovery in hot loops (the raw fast-path result, possibly ``inf``, is returned). + :param epsilon: Only affects the magnitude path (``sign=False``). When a float is given, the + magnitude is computed in the log domain and floored at ``sqrt(epsilon)`` (keeping gradients + alive below the floor). When ``None`` (default), the routing is unchanged and the magnitude is + computed via ``PfaffianFDBPf`` / ``PfaffianDet`` using ``PfaffianStrategy.EPSILON``. :return: The Pfaffian of the input, of shape ``(...,)``. :rtype: torch.Tensor """ @@ -80,22 +130,51 @@ def pfaffian(matrix: torch.Tensor, *, sign: bool = True, check_input: bool = Fal if not torch.allclose(matrix, -matrix.transpose(-1, -2)): raise ValueError("Input matrix is not skew-symmetric (A != -A^T).") - if sign: + if matrix.shape[-1] <= AUTO_SMALL_MAX: + # The exact unrolled kernel wins in this range and is device- and dtype-agnostic. + if sign: + result = PfaffianSmall.apply(matrix) + else: + result = PfaffianSmall.apply(matrix).abs() + if epsilon is not None: + result = torch.clamp(result, min=epsilon**0.5) + elif sign: # The Rust kernel is CPU-only, so non-CPU inputs use the device-native PyTorch strategy. if RustPfaffianParlettReid is not None and matrix.device.type == "cpu": result = RustPfaffianParlettReid.apply(matrix) else: result = PfaffianParlettReid.apply(matrix) + elif epsilon is not None: + result = magnitude_pfaffian(matrix, epsilon=epsilon) elif matrix.requires_grad and torch.is_grad_enabled(): result = PfaffianFDBPf.apply(matrix) else: result = PfaffianDet.apply(matrix) - if not torch.isfinite(result).all(): - warnings.warn( - "Pfaffian is not finite (overflow to inf/nan): its magnitude exceeds the floating range " - "of the input dtype at this matrix dimension. Consider a higher-precision dtype.", - RuntimeWarning, - stacklevel=2, - ) + if check_finite and not torch.isfinite(result).all(): + # The linear-domain fast paths can overflow to inf on wide-dynamic-range inputs whose true + # Pfaffian is finite. Transparently recover those elements in the log domain (Pf = phase * + # exp(log|Pf|) for the signed path, exp(log|Pf|) for the magnitude path), so the caller gets + # the correct value without reaching for slog_pfaffian. Only a magnitude that genuinely exceeds + # the dtype's float range stays non-finite, and only then is a warning emitted. + # Recompute the whole batch in the log domain and use it: its reconstruction equals the linear + # result on the finite elements (to log/exp rounding) and stays finite on the overflowed ones, + # and its gradient (``0.5 * Pf * (A^{-1})^T`` for the signed path) is finite everywhere. The + # linear graph is discarded, avoiding the ``0 * inf = NaN`` its backward would form from the + # saved infinite Pfaffian. + if sign: + phase, log_abs = slog_pfaffian(matrix) + result = phase * torch.exp(log_abs).to(phase.dtype) + else: + result = torch.exp(log_magnitude_pfaffian(matrix)) + if epsilon is not None: + result = torch.clamp(result, min=epsilon**0.5) + if not torch.isfinite(result).all(): + warnings.warn( + "Pfaffian is not finite after log-domain recovery: its true magnitude genuinely exceeds " + "the floating range of the input dtype at this matrix dimension. Use slog_pfaffian for the " + "log-magnitude, or a higher-precision dtype.", + RuntimeWarning, + stacklevel=2, + ) return result diff --git a/src/torch_pfaffian/kernels/__init__.py b/src/torch_pfaffian/kernels/__init__.py new file mode 100644 index 0000000..0542e8b --- /dev/null +++ b/src/torch_pfaffian/kernels/__init__.py @@ -0,0 +1,3 @@ +from .det_magnitude import log_magnitude_pfaffian, magnitude_pfaffian +from .parlett_reid_slog import parlett_reid_slog +from .small_n import SMALL_N_MAX, small_pfaffian diff --git a/src/torch_pfaffian/kernels/det_magnitude.py b/src/torch_pfaffian/kernels/det_magnitude.py new file mode 100644 index 0000000..761374d --- /dev/null +++ b/src/torch_pfaffian/kernels/det_magnitude.py @@ -0,0 +1,85 @@ +import math + +import torch + + +class LogMagnitudePfaffian(torch.autograd.Function): + r""" + Differentiable ``log|Pf(A)| = 0.5 * log|det(A)|`` using a single factorization in each direction. + + The forward computes one :func:`torch.linalg.slogdet`; the backward supplies the analytic gradient + ``0.5 * (A^{-1})^T`` (Wirtinger-conjugated for complex inputs) through a single non-raising + :func:`torch.linalg.inv_ex`, instead of differentiating through ``slogdet``. Differentiating through + ``slogdet`` forms ``grad * A^{-T}``, which is infinite at an exactly-singular input, so even the + correct upstream multiplier of ``0`` would give ``0 * inf = NaN``. Here exactly-singular elements + (``det(A) == 0``, so ``slogdet`` returns sign ``0``) keep the correct ``-inf`` value and receive a + zero gradient: the identity is substituted before the inverse so the factorization stays finite, and + the gradient is masked to zero there. Numerically singular elements (a round-off ``det`` with nonzero + sign) are already finite and left unchanged. No host synchronization happens in either direction. + """ + + @staticmethod + def forward(ctx: torch.autograd.function.FunctionCtx, matrix: torch.Tensor) -> torch.Tensor: + sign, log_abs_det = torch.linalg.slogdet(matrix) + ctx.save_for_backward(matrix, sign == 0) # sign == 0 marks exactly-singular (det == 0) elements + return 0.5 * log_abs_det + + @staticmethod + def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output: torch.Tensor) -> torch.Tensor | None: + matrix, singular = ctx.saved_tensors + if not ctx.needs_input_grad[0]: + return None + identity = torch.eye(matrix.shape[-1], dtype=matrix.dtype, device=matrix.device).expand_as(matrix) + safe_matrix = torch.where(singular[..., None, None], identity, matrix) # invertible at singular elements + inverse, _ = torch.linalg.inv_ex(safe_matrix) # non-raising; safe_matrix is never singular + grad = 0.5 * grad_output[..., None, None] * inverse.conj().transpose(-1, -2) + return torch.where(singular[..., None, None], torch.zeros_like(grad), grad) + + +def log_magnitude_pfaffian(matrix: torch.Tensor) -> torch.Tensor: + r""" + Log-magnitude ``log|Pf(A)| = 0.5 * log|det(A)|`` of a batch of skew-symmetric matrices. + + The value is computed through :func:`torch.linalg.slogdet`, so it works in the log domain and stays + finite (and keeps its gradient alive) even for tiny Pfaffians such as probabilities of order + ``2^{-k}`` that would underflow the linear-domain ``sqrt(|det|)``. The gradient uses the analytic + :class:`LogMagnitudePfaffian`, a single factorization each direction that is ``NaN``-free at + exactly-singular inputs (see that class). Odd-dimensional inputs are singular, so the log-magnitude + is ``-inf`` (returned with an autograd connection so a backward through it yields a zero gradient + rather than raising, and without reading the entries so ``inf`` / ``nan`` inputs stay ``-inf``). + + :param matrix: Skew-symmetric matrices of shape ``(..., m, m)``, real or complex floating point. + :return: The log-magnitude of shape ``(...,)`` in the input's real floating dtype (real for + complex inputs, since a magnitude is real-valued). + :rtype: torch.Tensor + """ + if matrix.shape[-1] % 2 == 1: + batch_shape = matrix.shape[:-2] + real_dtype = matrix.real.dtype if matrix.dtype.is_complex else matrix.dtype + connected_zero = matrix.reshape(*batch_shape, -1)[..., :0].sum(-1) # value 0, grad_fn, entries unread + if matrix.dtype.is_complex: + connected_zero = connected_zero.real + return connected_zero + torch.full(batch_shape, -torch.inf, dtype=real_dtype, device=matrix.device) + return LogMagnitudePfaffian.apply(matrix) + + +def magnitude_pfaffian(matrix: torch.Tensor, *, epsilon: float = 0.0) -> torch.Tensor: + r""" + Magnitude ``|Pf(A)|`` of a batch of skew-symmetric matrices, real-valued and differentiable. + + The magnitude is obtained by exponentiating :func:`log_magnitude_pfaffian`. When ``epsilon`` is + positive the log-magnitude is floored at ``0.5 * log(epsilon)`` before exponentiation, reproducing + the historical ``sqrt(clamp(|det|, epsilon))`` floor as a function argument rather than a mutable + global. Prefer the default ``0.0`` together with :func:`log_magnitude_pfaffian` for gradient-safe + small probabilities. + + :param matrix: Skew-symmetric matrices of shape ``(..., m, m)``, real or complex floating point. + :param epsilon: When positive, floors the result at ``sqrt(epsilon)``. The default ``0.0`` applies + no floor. + :return: The magnitude ``|Pf(A)|`` of shape ``(...,)`` in the input's real floating dtype. + :rtype: torch.Tensor + """ + log_pf = log_magnitude_pfaffian(matrix) + if epsilon > 0.0: + log_pf = torch.clamp(log_pf, min=0.5 * math.log(epsilon)) + return torch.exp(log_pf) diff --git a/src/torch_pfaffian/kernels/parlett_reid_slog.py b/src/torch_pfaffian/kernels/parlett_reid_slog.py new file mode 100644 index 0000000..b95501f --- /dev/null +++ b/src/torch_pfaffian/kernels/parlett_reid_slog.py @@ -0,0 +1,108 @@ +import torch + + +def _real_dtype_of(dtype: torch.dtype) -> torch.dtype: + """ + Real floating dtype associated with ``dtype``. + + :param dtype: A real or complex floating dtype. + :return: ``dtype`` itself when real, otherwise its real component dtype + (``complex64`` maps to ``float32`` and ``complex128`` to ``float64``). + :rtype: torch.dtype + """ + if dtype.is_complex: + return torch.float32 if dtype == torch.complex64 else torch.float64 + return dtype + + +@torch.no_grad() +def parlett_reid_slog(matrix: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]: + r""" + Log-domain signed Pfaffian of a batch of skew-symmetric matrices via Parlett-Reid elimination. + + The batched skew-tridiagonalization with partial pivoting is run device-side with no host + synchronization (no ``.item()``, ``.any()`` or ``isfinite().all()``), and the result is + accumulated as ``(phase, log|Pf|)`` rather than a raw product. The log domain removes both the + overflow at large dimensions and the underflow for tiny Pfaffians (probabilities of order + ``2^{-k}``). Real and complex inputs share the single code path: ``phase`` is ``+-1`` (or ``0``) + for real inputs and a unit-modulus complex number for complex inputs. An exact zero pivot column + terminates that batch element cleanly with ``(0, -inf)``, since its remaining rank-2 updates + vanish, so no epsilon threshold is needed. + + :param matrix: Skew-symmetric matrices of shape ``(..., m, m)``, real or complex floating point. + :return: A pair ``(phase, log_abs)`` where ``phase`` has shape ``(...,)`` and matches the input + dtype (with ``Pf = phase * exp(log_abs)``, and ``phase = 0`` when ``Pf = 0``), and ``log_abs`` + has shape ``(...,)`` in the matching real dtype (``-inf`` when ``Pf = 0``). Odd ``m`` gives + ``(0, -inf)`` and ``m = 0`` gives ``(1, 0)``. + :rtype: tuple[torch.Tensor, torch.Tensor] + """ + if matrix.ndim < 2 or matrix.shape[-1] != matrix.shape[-2]: + raise ValueError(f"expected (..., m, m) square matrices, got shape {tuple(matrix.shape)}") + batch_shape = matrix.shape[:-2] + dimension = matrix.shape[-1] + device = matrix.device + dtype = matrix.dtype + real_dtype = _real_dtype_of(dtype) + + if dimension % 2 == 1: + return ( + torch.zeros(batch_shape, dtype=dtype, device=device), + torch.full(batch_shape, -torch.inf, dtype=real_dtype, device=device), + ) + if dimension == 0: + return ( + torch.ones(batch_shape, dtype=dtype, device=device), + torch.zeros(batch_shape, dtype=real_dtype, device=device), + ) + + working = matrix.reshape(-1, dimension, dimension).clone() # (batch, m, m) + batch = working.shape[0] + batch_index = torch.arange(batch, device=device) + phase = torch.ones(batch, dtype=dtype, device=device) + log_abs = torch.zeros(batch, dtype=real_dtype, device=device) + alive = torch.ones(batch, dtype=torch.bool, device=device) + zero_log = torch.zeros((), dtype=real_dtype, device=device) + one_phase = torch.ones((), dtype=dtype, device=device) + + for column in range(0, dimension - 2, 2): + # Partial pivoting: bring the largest |a[column, row]| (row > column) into position (column, column + 1). + pivot_row = torch.argmax(working[:, column, column + 1 :].abs(), dim=1) + column + 1 + need_swap = pivot_row != (column + 1) + row_next = working[:, column + 1, :].clone() + row_pivot = working[batch_index, pivot_row, :] + working[:, column + 1, :] = row_pivot + working[batch_index, pivot_row, :] = torch.where(need_swap[:, None], row_next, row_pivot) + col_next = working[:, :, column + 1].clone() + col_pivot = working[batch_index, :, pivot_row] + working[:, :, column + 1] = col_pivot + working[batch_index, :, pivot_row] = torch.where(need_swap[:, None], col_next, col_pivot) + phase = torch.where(need_swap, -phase, phase) + + pivot = working[:, column, column + 1] + abs_pivot = pivot.abs() + is_zero = abs_pivot == 0 + alive = alive & ~is_zero + safe_abs = torch.where(is_zero, torch.ones_like(abs_pivot), abs_pivot) + safe_pivot = torch.where(is_zero, one_phase, pivot) + phase = phase * (safe_pivot / safe_abs) + log_abs = log_abs + torch.where(is_zero, zero_log, safe_abs.log()) + + # Schur complement of the leading 2x2 block onto the trailing submatrix. + first_row_tail = working[:, column, column + 2 :] # (batch, m - column - 2) + second_row_tail = working[:, column + 1, column + 2 :] # (batch, m - column - 2) + update = second_row_tail.unsqueeze(-1) * first_row_tail.unsqueeze(-2) + update = update - update.transpose(-1, -2) + working[:, column + 2 :, column + 2 :] += update / safe_pivot[:, None, None] + + last = working[:, dimension - 2, dimension - 1] + abs_last = last.abs() + is_zero = abs_last == 0 + alive = alive & ~is_zero + safe_abs = torch.where(is_zero, torch.ones_like(abs_last), abs_last) + safe_last = torch.where(is_zero, one_phase, last) + phase = phase * (safe_last / safe_abs) + log_abs = log_abs + torch.where(is_zero, zero_log, safe_abs.log()) + + phase = torch.where(alive, phase, torch.zeros_like(phase)) + log_abs = torch.where(alive, log_abs, torch.full_like(log_abs, -torch.inf)) + return phase.reshape(batch_shape), log_abs.reshape(batch_shape) diff --git a/src/torch_pfaffian/kernels/small_n.py b/src/torch_pfaffian/kernels/small_n.py new file mode 100644 index 0000000..ec9506f --- /dev/null +++ b/src/torch_pfaffian/kernels/small_n.py @@ -0,0 +1,82 @@ +from functools import lru_cache + +import torch + +SMALL_N_MAX = 10 + + +@lru_cache(maxsize=None) +def _matching_tables( + dimension: int, +) -> tuple[tuple[tuple[int, ...], ...], tuple[tuple[int, ...], ...], tuple[float, ...]]: + r""" + Perfect-matching tables of ``{0, ..., dimension - 1}`` with their permutation signs. + + The ``(dimension - 1)!!`` perfect matchings are enumerated once per dimension (memoized) so the + unrolled kernel can evaluate them as a single batched gather. Each matching contributes a term + ``sign * prod_k a[rows[k], cols[k]]`` to the Pfaffian. + + :param dimension: Even matrix dimension. + :return: A triple ``(rows, cols, signs)`` where ``rows`` and ``cols`` each hold one + ``dimension // 2`` tuple of indices per matching and ``signs`` holds the matching's + permutation sign. + :rtype: tuple[tuple[tuple[int, ...], ...], tuple[tuple[int, ...], ...], tuple[float, ...]] + """ + rows: list[tuple[int, ...]] = [] + cols: list[tuple[int, ...]] = [] + signs: list[float] = [] + + def expand(indices: tuple[int, ...], row_acc: tuple[int, ...], col_acc: tuple[int, ...], sign: float) -> None: + if not indices: + rows.append(row_acc) + cols.append(col_acc) + signs.append(sign) + return + first, rest = indices[0], indices[1:] + for position, partner in enumerate(rest): + remaining = tuple(index for index in rest if index != partner) + expand(remaining, row_acc + (first,), col_acc + (partner,), sign * (-1.0) ** position) + + expand(tuple(range(dimension)), (), (), 1.0) + return tuple(rows), tuple(cols), tuple(signs) + + +def small_pfaffian(matrix: torch.Tensor) -> torch.Tensor: + r""" + Signed/complex Pfaffian of a batch ``(..., m, m)`` for even ``m <= SMALL_N_MAX`` via unrolled matchings. + + This is the compile-time form of the recursive expansion: the perfect matchings are enumerated + once per dimension and evaluated as one batched gather followed by unrolled elementwise products + and a matvec with the sign vector, with no elimination loop or data-dependent control flow. The + factor product is unrolled (rather than :func:`torch.prod`) so that zero entries still get correct + product-rule gradients, making the kernel exact and autograd-friendly for the supported sizes. + + :param matrix: Skew-symmetric matrices of shape ``(..., m, m)`` with even ``m <= SMALL_N_MAX``. + :return: The signed Pfaffian of shape ``(...,)``, sharing the input backend, dtype and device. + :rtype: torch.Tensor + """ + dimension = matrix.shape[-1] + if matrix.ndim < 2 or matrix.shape[-2] != dimension: + raise ValueError(f"expected (..., m, m) square matrices, got shape {tuple(matrix.shape)}") + if dimension % 2 == 1: + # Value 0 but carrying a grad connection to matrix (gradient 0), so autograd returns a zero + # gradient instead of raising on a fresh constant with no grad_fn. Summing an empty slice + # (rather than the whole matrix times 0) keeps this inf/nan-safe: the odd-dim Pfaffian is 0 + # regardless of the entries, so non-finite entries must not contaminate the result. + return matrix.reshape(*matrix.shape[:-2], -1)[..., :0].sum(-1) + if dimension == 0: + return matrix.reshape(*matrix.shape[:-2], -1)[..., :0].sum(-1) + 1 # pf of a 0x0 matrix is 1 + if dimension == 2: + return matrix[..., 0, 1] + if dimension > SMALL_N_MAX: + raise ValueError(f"small_pfaffian supports m <= {SMALL_N_MAX}, got {dimension}") + + rows, cols, signs = _matching_tables(dimension) + row_index = torch.tensor(rows, dtype=torch.long, device=matrix.device) # (n_terms, m // 2) + col_index = torch.tensor(cols, dtype=torch.long, device=matrix.device) # (n_terms, m // 2) + sign_vector = torch.tensor(signs, dtype=matrix.dtype, device=matrix.device) # (n_terms,) + factors = matrix[..., row_index, col_index] # (..., n_terms, m // 2) + product = factors[..., 0] + for factor_index in range(1, dimension // 2): + product = product * factors[..., factor_index] + return product @ sign_vector diff --git a/src/torch_pfaffian/strategies/__init__.py b/src/torch_pfaffian/strategies/__init__.py index 482bc29..a31a23f 100644 --- a/src/torch_pfaffian/strategies/__init__.py +++ b/src/torch_pfaffian/strategies/__init__.py @@ -6,6 +6,8 @@ from .pfaffian_det import PfaffianDet from .pfaffian_fdbpf import PfaffianFDBPf from .pfaffian_parlett_reid import PfaffianParlettReid +from .pfaffian_slog import SlogPfaffianStrategy +from .pfaffian_small import PfaffianSmall from .strategy import PfaffianStrategy try: diff --git a/src/torch_pfaffian/strategies/pfaffian_block_det.py b/src/torch_pfaffian/strategies/pfaffian_block_det.py index d29b646..4d920c0 100644 --- a/src/torch_pfaffian/strategies/pfaffian_block_det.py +++ b/src/torch_pfaffian/strategies/pfaffian_block_det.py @@ -56,6 +56,16 @@ def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output: torch. block = matrix[..., :n, n:] # (..., n, n) upper-right block constant = (-1) ** (n * (n - 1) // 2) singular = pf == 0 + if not PfaffianBlockDet.EXACT_SINGULAR_GRAD: + # Sync-free path: multiplying the inverse by pf zeroes the gradient at singular blocks + # (pf == 0) exactly, so no host branch runs. + identity = torch.eye(n, dtype=matrix.dtype, device=matrix.device).expand_as(block) + safe_block = torch.where(singular[..., None, None], identity, block) + inverse, _ = torch.linalg.inv_ex(safe_block) + adjugate_transpose = pf[..., None, None] * inverse.transpose(-1, -2) # zero where pf == 0 + grad_matrix = torch.zeros_like(matrix) + grad_matrix[..., :n, n:] = grad_output[..., None, None] * adjugate_transpose + return grad_matrix if bool(singular.any()): identity = torch.eye(n, dtype=matrix.dtype, device=matrix.device).expand_as(block) safe_block = torch.where(singular[..., None, None], identity, block) diff --git a/src/torch_pfaffian/strategies/pfaffian_fdbpf.py b/src/torch_pfaffian/strategies/pfaffian_fdbpf.py index 732d57f..de600d2 100644 --- a/src/torch_pfaffian/strategies/pfaffian_fdbpf.py +++ b/src/torch_pfaffian/strategies/pfaffian_fdbpf.py @@ -48,10 +48,18 @@ def backward(ctx: torch.autograd.function.BackwardCFunction, grad_output: torch. # The forward clamps the radicand at EPSILON, so a singular element has pf exactly at the floor # sqrt(EPSILON) (or 0 for odd dimensions). Computing the floor with the same dtype and sqrt as # the forward makes the comparison exact rather than dependent on a hand-written threshold. + dimension = matrix.shape[-1] singular_floor = matrix.new_tensor(PfaffianFDBPf.EPSILON).sqrt() singular = pf <= singular_floor + if not PfaffianFDBPf.EXACT_SINGULAR_GRAD: + # Sync-free path: replace singular elements by the identity for the batched inverse and + # assign them an exactly zero gradient, so no host branch runs. + identity = torch.eye(dimension, dtype=matrix.dtype, device=matrix.device).expand_as(matrix) + safe_matrix = torch.where(singular[..., None, None], identity, matrix) + inverse, _ = torch.linalg.inv_ex(safe_matrix) + grad = torch.einsum("...,...ij->...ji", 0.5 * grad_output * pf, inverse) + return torch.where(singular[..., None, None], torch.zeros_like(grad), grad) if bool(singular.any()): - dimension = matrix.shape[-1] identity = torch.eye(dimension, dtype=matrix.dtype, device=matrix.device).expand_as(matrix) safe_matrix = torch.where(singular[..., None, None], identity, matrix) inverse = torch.linalg.inv(safe_matrix) diff --git a/src/torch_pfaffian/strategies/pfaffian_slog.py b/src/torch_pfaffian/strategies/pfaffian_slog.py new file mode 100644 index 0000000..5d7c8de --- /dev/null +++ b/src/torch_pfaffian/strategies/pfaffian_slog.py @@ -0,0 +1,61 @@ +from typing import Any + +import torch + +from ..kernels.parlett_reid_slog import parlett_reid_slog + + +class SlogPfaffianStrategy(torch.autograd.Function): + r""" + Log-domain signed Pfaffian returning ``(phase, log|Pf|)`` with an analytic backward for ``log|Pf|``. + + This is a standalone :class:`torch.autograd.Function` (deliberately not a + :class:`~torch_pfaffian.strategies.strategy.PfaffianStrategy` subclass, so it does not enter the + scalar-returning strategy registry). The forward is the host-synchronization-free + :func:`~torch_pfaffian.kernels.parlett_reid_slog.parlett_reid_slog`; the returned ``phase`` is + marked non-differentiable (for real inputs it is piecewise constant, and callers needing the full + complex derivative use the linear-domain :class:`PfaffianParlettReid`). ``log|Pf|`` is + differentiable wherever ``Pf != 0``, with gradient ``0.5 * (A^{-1})^T`` under PyTorch's Wirtinger + convention (the ``.conj()`` is a no-op for real inputs); batch elements with ``Pf = 0`` receive an + exactly zero gradient. + + The input is a skew-symmetric matrix of shape ``(..., m, m)``. + """ + + @staticmethod + def forward(matrix: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]: + return parlett_reid_slog(matrix) + + @staticmethod + def setup_context(ctx: Any, inputs: tuple[torch.Tensor, ...], output: tuple[torch.Tensor, torch.Tensor]) -> None: + (matrix,) = inputs + phase, _ = output + ctx.save_for_backward(matrix, phase) + ctx.mark_non_differentiable(phase) + + @staticmethod + def backward(ctx: Any, *grad_outputs: Any) -> torch.Tensor: + r""" + Gradient of ``log|Pf(A)|`` with respect to the input matrix. + + .. math:: + \frac{\partial \log|\text{pf}(A)|}{\partial A_{ij}} = \frac{1}{2} (A^{-1})_{ji} + + The gradient of the non-differentiable ``phase`` output is ignored. Singular elements + (``phase == 0``) are replaced by the identity before the batched inverse and then assigned an + exactly zero gradient, so the backward never synchronizes with the host and never raises. + + :param ctx: Context holding the saved input matrix and the forward phase. + :param grad_outputs: Gradients of ``(phase, log_abs)`` with respect to the loss; only the + ``log_abs`` gradient is used. + :return: Gradient of the input matrix, of shape ``(..., m, m)``. + :rtype: torch.Tensor + """ + _grad_phase, grad_log_abs = grad_outputs + matrix, phase = ctx.saved_tensors + singular = phase == 0 + identity = torch.eye(matrix.shape[-1], dtype=matrix.dtype, device=matrix.device) + safe_matrix = torch.where(singular[..., None, None], identity, matrix) + inverse_transposed_conj = torch.linalg.inv(safe_matrix).conj().transpose(-1, -2) + grad = 0.5 * grad_log_abs[..., None, None] * inverse_transposed_conj + return torch.where(singular[..., None, None], torch.zeros_like(grad), grad) diff --git a/src/torch_pfaffian/strategies/pfaffian_small.py b/src/torch_pfaffian/strategies/pfaffian_small.py new file mode 100644 index 0000000..2440abb --- /dev/null +++ b/src/torch_pfaffian/strategies/pfaffian_small.py @@ -0,0 +1,32 @@ +import torch + +from ..kernels.small_n import small_pfaffian +from .strategy import PfaffianStrategy + + +class PfaffianSmall(PfaffianStrategy): + r""" + Signed Pfaffian for small even dimensions via the unrolled perfect-matching kernel. + + Like :class:`PfaffianDet`, this strategy differentiates straight through plain tensor ops rather + than a custom analytic backward, so it overrides :meth:`apply` to call + :func:`~torch_pfaffian.kernels.small_n.small_pfaffian` directly and lets autograd handle the + backward. The kernel is exact and autograd-friendly for even dimensions ``m <= SMALL_N_MAX``. + + For ``m >= 2`` the input is re-skew-symmetrized (``A = 0.5 * (A - A^T)``) before the kernel. The + unrolled kernel only reads the upper triangle, so raw autograd would pile the whole gradient + there, whereas the analytic vector-Jacobian product of the other strategies returns the + skew-split convention ``0.5 * pf(A) (A^{-1})^T``. The projection is idempotent for skew inputs, so + the forward is unchanged while the gradient matches the other strategies (including at ``m = 2``, + where the gradient is ``[[0, 0.5], [-0.5, 0]]`` rather than the upper-triangle ``[[0, 1], [0, 0]]``). + + The input is a skew-symmetric matrix of shape ``(..., m, m)``. + """ + + NAME = "PfaffianSmall" + + @staticmethod + def apply(matrix: torch.Tensor) -> torch.Tensor: + if matrix.shape[-1] >= 2: + matrix = 0.5 * (matrix - matrix.transpose(-1, -2)) + return small_pfaffian(matrix) diff --git a/src/torch_pfaffian/strategies/strategy.py b/src/torch_pfaffian/strategies/strategy.py index e2ce4f4..720ac03 100644 --- a/src/torch_pfaffian/strategies/strategy.py +++ b/src/torch_pfaffian/strategies/strategy.py @@ -6,6 +6,11 @@ class PfaffianStrategy(torch.autograd.Function): EPSILON = 1e-30 NAME = "PfaffianStrategy" + # When True (default) the singular-element gradient is the exact minor-based Pfaffian adjugate, + # which preserves the historical behavior at the cost of one host synchronization per backward. + # When False the backward is fully sync-free: singular elements (pf == 0) get an exactly zero + # gradient via torch.where, so no .any()/.item() branch and no minor loop run. + EXACT_SINGULAR_GRAD = True # A batch element is routed to the exact minor-based adjugate when |pf| <= eps^0.75 * scale^(n/2) # (relative to the entry scale, since pf is a degree-n/2 polynomial in the entries), or when the # LU inverse fails its residual check ||A A^{-1} - I||_max > eps^0.5. Exponents of the dtype eps @@ -70,6 +75,11 @@ def pfaffian_grad_matrix( Wirtinger convention for complex autograd (``z.grad = d L / d conj(z)``). For real inputs the conjugation is a no-op, so real gradients are unchanged. + All of the above assumes :attr:`EXACT_SINGULAR_GRAD` is ``True`` (the default). When it is + ``False`` the backward takes a fully host-synchronization-free path: singular elements + (``pf == 0``) receive an exactly zero gradient (the true Pfaffian-adjugate derivative there is + nonzero only at corank exactly 2), skipping the ``.any()`` branch and the minor loop entirely. + :param matrix: The saved input matrix of shape ``(..., n, n)``. :param pfaffian: The saved forward Pfaffian of shape ``(...,)``. :param grad_output: Gradient of the output with respect to the loss, of shape ``(...,)``. @@ -79,6 +89,15 @@ def pfaffian_grad_matrix( dimension = matrix.shape[-1] if dimension == 0: return torch.zeros_like(matrix) # pf of a 0x0 matrix is the constant 1; the gradient is empty + if not cls.EXACT_SINGULAR_GRAD: + # Sync-free path: singular elements (pf == 0) get an exactly zero gradient (multiplying the + # inverse by pf zeroes it there), so no host branch and no minor loop are needed. + singular = pfaffian == 0 + identity = torch.eye(dimension, dtype=matrix.dtype, device=matrix.device).expand_as(matrix) + safe_matrix = torch.where(singular[..., None, None], identity, matrix) # (..., n, n) + inverse, _ = torch.linalg.inv_ex(safe_matrix) # non-raising; discarded where singular + adjugate = pfaffian[..., None, None] * inverse # pf(A) A^{-1}; exactly zero where pf == 0 + return torch.einsum("...,...ij->...ji", 0.5 * grad_output, adjugate.conj()) epsilon = torch.finfo(matrix.dtype).eps entry_scale = matrix.abs().amax(dim=(-2, -1)) # (...,) log_threshold = (dimension // 2) * torch.log(entry_scale) + cls.SINGULARITY_RTOL_EXPONENT * math.log(epsilon) diff --git a/tests/reference.py b/tests/reference.py new file mode 100644 index 0000000..4bcdf73 --- /dev/null +++ b/tests/reference.py @@ -0,0 +1,159 @@ +from fractions import Fraction +from typing import Any, Sequence + +import numpy as np + + +def _as_rows(matrix: Any) -> list[list[Any]]: + if isinstance(matrix, np.ndarray): + return [list(row) for row in matrix.tolist()] if matrix.dtype != object else [list(row) for row in matrix] + return [list(row) for row in matrix] + + +def pfaffian_combinatorial(matrix: Any) -> Any: + """ + Pfaffian by the perfect-matching (recursive Laplace) expansion. + + Exact for exact scalar types; O((m-1)!!) terms. ``matrix`` must be square and + skew-symmetric; odd dimension returns 0. + """ + rows = _as_rows(matrix) + m = len(rows) + if m == 0: + return 1 + if m % 2 == 1: + return 0 + + def expand(indices: Sequence[int]) -> Any: + if len(indices) == 2: + return rows[indices[0]][indices[1]] + first, rest = indices[0], indices[1:] + total = None + for k, j in enumerate(rest): + remaining = tuple(idx for idx in rest if idx != j) + term = rows[first][j] * expand(remaining) + if k % 2 == 1: + term = -term + total = term if total is None else total + term + return total + + return expand(tuple(range(m))) + + +def det_exact(matrix: Any) -> Fraction: + """Exact determinant of a matrix with int/Fraction entries (fraction-free Bareiss).""" + rows = [[Fraction(x) for x in row] for row in _as_rows(matrix)] + m = len(rows) + if m == 0: + return Fraction(1) + sign = 1 + prev = Fraction(1) + for c in range(m - 1): + if rows[c][c] == 0: + for r in range(c + 1, m): + if rows[r][c] != 0: + rows[c], rows[r] = rows[r], rows[c] + sign = -sign + break + else: + return Fraction(0) + for r in range(c + 1, m): + for k in range(c + 1, m): + rows[r][k] = (rows[r][k] * rows[c][c] - rows[r][c] * rows[c][k]) / prev + rows[r][c] = Fraction(0) + prev = rows[c][c] + return sign * rows[m - 1][m - 1] + + +def pfaffian_numpy(matrix: np.ndarray) -> complex | float: + """ + Pfaffian of one skew-symmetric matrix by pivoted block Parlett-Reid elimination. + + Supports real and complex dtypes. Partial pivoting: at each step the row/column + pair (c+1, r) with the largest |M[c, r]| is swapped into position c+1 (each swap + flips the sign). A vanishing pivot column means Pf = 0 exactly. + """ + a = np.array(matrix, copy=True) + m = a.shape[-1] + if a.shape != (m, m): + raise ValueError(f"expected a single square matrix, got shape {a.shape}") + if m % 2 == 1: + return 0.0 + if m == 0: + return 1.0 + + result = a.dtype.type(1) + for c in range(0, m - 2, 2): + # Pivot: bring the largest |M[c, r]| (r > c) into position (c, c+1). + r = int(np.argmax(np.abs(a[c, c + 1 :]))) + c + 1 + if a[c, r] == 0: + return 0.0 + if r != c + 1: + a[[c + 1, r], :] = a[[r, c + 1], :] + a[:, [c + 1, r]] = a[:, [r, c + 1]] + result = -result + pivot = a[c, c + 1] + result = result * pivot + # Schur complement of the leading 2x2 block onto the trailing submatrix. + b1 = a[c, c + 2 :] + b2 = a[c + 1, c + 2 :] + a[c + 2 :, c + 2 :] += (np.outer(b2, b1) - np.outer(b1, b2)) / pivot + result = result * a[m - 2, m - 1] + return complex(result) if np.iscomplexobj(a) else float(result) + + +def slog_pfaffian_numpy(matrix: np.ndarray) -> tuple[complex | float, float]: + """(sign_or_phase, log|Pf|) variant of :func:`pfaffian_numpy`; (0, -inf) when Pf = 0.""" + a = np.array(matrix, copy=True) + m = a.shape[-1] + if m % 2 == 1: + return 0.0, -np.inf + if m == 0: + return 1.0, 0.0 + + phase = a.dtype.type(1) + log_abs = 0.0 + for c in range(0, m - 2, 2): + r = int(np.argmax(np.abs(a[c, c + 1 :]))) + c + 1 + if a[c, r] == 0: + return 0.0, -np.inf + if r != c + 1: + a[[c + 1, r], :] = a[[r, c + 1], :] + a[:, [c + 1, r]] = a[:, [r, c + 1]] + phase = -phase + pivot = a[c, c + 1] + phase = phase * (pivot / abs(pivot)) + log_abs += float(np.log(abs(pivot))) + b1 = a[c, c + 2 :] + b2 = a[c + 1, c + 2 :] + a[c + 2 :, c + 2 :] += (np.outer(b2, b1) - np.outer(b1, b2)) / pivot + last = a[m - 2, m - 1] + if last == 0: + return 0.0, -np.inf + phase = phase * (last / abs(last)) + log_abs += float(np.log(abs(last))) + if np.iscomplexobj(a): + return complex(phase), log_abs + return float(np.real(phase)), log_abs + + +def random_skew(rng: np.random.Generator, m: int, dtype: type = np.float64, scale: float = 1.0) -> np.ndarray: + """Random dense skew-symmetric matrix (complex if ``dtype`` is complex).""" + x = rng.standard_normal((m, m)) * scale + if np.issubdtype(dtype, np.complexfloating): + x = x + 1j * rng.standard_normal((m, m)) * scale + x = x.astype(dtype) + return x - x.T + + +def random_skew_fractions(rng: np.random.Generator, m: int, denominator: int = 16, max_num: int = 32) -> np.ndarray: + """Random skew-symmetric matrix of exact Fractions (object dtype), for exact-arithmetic tests.""" + a = np.zeros((m, m), dtype=object) + for i in range(m): + for j in range(i + 1, m): + value = Fraction(int(rng.integers(-max_num, max_num + 1)), denominator) + a[i, j] = value + a[j, i] = -value + for i in range(m): + a[i, i] = Fraction(0) + return a diff --git a/tests/test__rust.py b/tests/test__rust.py new file mode 100644 index 0000000..e8c5e03 --- /dev/null +++ b/tests/test__rust.py @@ -0,0 +1,113 @@ +import numpy as np +import pytest + +from tests.configs import ( + ATOL_APPROX_COMPARISON, + ATOL_SCALAR_COMPARISON, + N_RANDOM_TESTS_PER_CASE, + RTOL_APPROX_COMPARISON, + RTOL_SCALAR_COMPARISON, + TEST_SEED, +) +from tests.reference import random_skew, slog_pfaffian_numpy + +_rust = pytest.importorskip("torch_pfaffian._rust") + +# (signed kernel, slog kernel, numpy dtype, tight?) for each precision that exposes a slog entry point. +_KERNELS = [ + ("signed_pfaffian_f64", "signed_slog_pfaffian_f64", np.float64, True), + ("signed_pfaffian_f32", "signed_slog_pfaffian_f32", np.float32, False), + ("signed_pfaffian_c128", "signed_slog_pfaffian_c128", np.complex128, True), + ("signed_pfaffian_c64", "signed_slog_pfaffian_c64", np.complex64, False), +] + + +def _skew_batch(count: int, dimension: int, rng: np.random.Generator, dtype: type, scale: float = 1.0) -> np.ndarray: + return np.stack([random_skew(rng, dimension, dtype=dtype, scale=scale) for _ in range(count)]) + + +def _reconstruct(phase: np.ndarray, log_abs: np.ndarray) -> np.ndarray: + # phase * exp(log_abs); exponentiate in float64 so a moderate float32 log does not overflow. + return phase * np.exp(log_abs.astype(np.float64)).astype(phase.dtype) + + +class TestRustSlog: + @pytest.mark.parametrize("signed_name, slog_name, dtype, tight", _KERNELS) + def test_reconstructs_signed_kernel(self, signed_name, slog_name, dtype, tight): + rng = np.random.default_rng(TEST_SEED) + batch = _skew_batch(N_RANDOM_TESTS_PER_CASE, 8, rng, dtype) + signed = getattr(_rust, signed_name)(batch) + phase, log_abs = getattr(_rust, slog_name)(batch) + assert phase.dtype == np.dtype(dtype) + assert log_abs.dtype == np.empty(0, dtype).real.dtype # f64->f64, f32->f32, c128->f64, c64->f32 + atol = ATOL_SCALAR_COMPARISON if tight else ATOL_APPROX_COMPARISON + rtol = RTOL_SCALAR_COMPARISON if tight else RTOL_APPROX_COMPARISON + np.testing.assert_allclose(_reconstruct(phase, log_abs), signed, atol=atol, rtol=rtol) + + @pytest.mark.parametrize("signed_name, slog_name, dtype, tight", _KERNELS) + def test_matches_slog_numpy_oracle(self, signed_name, slog_name, dtype, tight): + rng = np.random.default_rng(TEST_SEED + 1) + batch = _skew_batch(N_RANDOM_TESTS_PER_CASE, 6, rng, dtype) + phase, log_abs = getattr(_rust, slog_name)(batch) + atol = ATOL_SCALAR_COMPARISON if tight else ATOL_APPROX_COMPARISON + rtol = RTOL_SCALAR_COMPARISON if tight else RTOL_APPROX_COMPARISON + for index in range(batch.shape[0]): + reference = ( + batch[index].astype(np.complex128) if np.iscomplexobj(batch) else batch[index].astype(np.float64) + ) + expected_phase, expected_log = slog_pfaffian_numpy(reference) + np.testing.assert_allclose(phase[index], expected_phase, atol=atol, rtol=rtol) + np.testing.assert_allclose(float(log_abs[index]), expected_log, atol=atol, rtol=rtol) + + @pytest.mark.parametrize( + "slog_name, dtype", [("signed_slog_pfaffian_f64", np.float64), ("signed_slog_pfaffian_c128", np.complex128)] + ) + def test_exact_zero_pivot_gives_zero_phase_and_neg_inf_log(self, slog_name, dtype): + matrix = np.zeros((1, 4, 4), dtype=dtype) + matrix[0, 2, 3] = 1.0 + matrix[0, 3, 2] = -1.0 + phase, log_abs = getattr(_rust, slog_name)(matrix) + assert phase[0] == 0 + assert np.isneginf(log_abs[0]) + + @pytest.mark.parametrize( + "signed_name, slog_name, dtype", + [ + ("signed_pfaffian_f64", "signed_slog_pfaffian_f64", np.float64), + ("signed_pfaffian_c128", "signed_slog_pfaffian_c128", np.complex128), + ], + ) + def test_no_overflow_at_large_scale(self, signed_name, slog_name, dtype): + # At scale 1e120 the linear signed kernel overflows to inf, but the log-domain kernel stays finite. + rng = np.random.default_rng(TEST_SEED) + batch = _skew_batch(2, 8, rng, dtype, scale=1e120) + signed = getattr(_rust, signed_name)(batch) + _, log_abs = getattr(_rust, slog_name)(batch) + assert not np.isfinite(signed).all() + assert np.isfinite(log_abs).all() + + def test_odd_dimension_and_empty(self): + rng = np.random.default_rng(TEST_SEED) + odd = _skew_batch(3, 5, rng, np.float64) + phase, log_abs = _rust.signed_slog_pfaffian_f64(odd) + assert np.all(phase == 0) + assert np.all(np.isneginf(log_abs)) + empty = np.zeros((2, 0, 0), dtype=np.float64) + phase, log_abs = _rust.signed_slog_pfaffian_f64(empty) + np.testing.assert_array_equal(phase, np.ones(2)) + np.testing.assert_array_equal(log_abs, np.zeros(2)) + + def test_batched_matches_serial_below_and_above_parallel_threshold(self): + # The rayon split at PARALLEL_BATCH_THRESHOLD must not change results: a large batch agrees + # element-wise with the same matrices evaluated one at a time. + rng = np.random.default_rng(TEST_SEED) + batch = _skew_batch(16, 6, rng, np.float64) + phase, log_abs = _rust.signed_slog_pfaffian_f64(batch) + for index in range(batch.shape[0]): + one_phase, one_log = _rust.signed_slog_pfaffian_f64(batch[index : index + 1]) + np.testing.assert_allclose( + phase[index], one_phase[0], atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON + ) + np.testing.assert_allclose( + log_abs[index], one_log[0], atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON + ) diff --git a/tests/test_kernels/__init__.py b/tests/test_kernels/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/tests/test_kernels/test_det_magnitude.py b/tests/test_kernels/test_det_magnitude.py new file mode 100644 index 0000000..2141d02 --- /dev/null +++ b/tests/test_kernels/test_det_magnitude.py @@ -0,0 +1,146 @@ +import numpy as np +import torch + +from tests.configs import ( + ATOL_MATRIX_COMPARISON, + ATOL_SCALAR_COMPARISON, + N_RANDOM_TESTS_PER_CASE, + RTOL_MATRIX_COMPARISON, + RTOL_SCALAR_COMPARISON, + TEST_SEED, +) +from tests.reference import random_skew +from torch_pfaffian import pfaffian +from torch_pfaffian.kernels.det_magnitude import LogMagnitudePfaffian, log_magnitude_pfaffian, magnitude_pfaffian + + +def _skew_batch( + shape: tuple[int, ...], dimension: int, rng: np.random.Generator, dtype: type = np.float64 +) -> torch.Tensor: + count = int(np.prod(shape)) + matrices = np.stack([random_skew(rng, dimension, dtype=dtype) for _ in range(count)]) + return torch.from_numpy(matrices.reshape(*shape, dimension, dimension)) + + +def _block_antidiagonal(block: torch.Tensor) -> torch.Tensor: + zero = torch.zeros_like(block) + top = torch.cat([zero, block], dim=-1) + bottom = torch.cat([-block.transpose(-1, -2), zero], dim=-1) + return torch.cat([top, bottom], dim=-2) + + +class TestDetMagnitude: + def test_magnitude_matches_sqrt_abs_det(self): + for dimension in (2, 4, 6, 8): + rng = np.random.default_rng(TEST_SEED + dimension) + batch = _skew_batch((N_RANDOM_TESTS_PER_CASE,), dimension, rng) + result = magnitude_pfaffian(batch) + expected = torch.sqrt(torch.abs(torch.linalg.det(batch))) + torch.testing.assert_close(result, expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON) + + def test_log_magnitude_matches_half_logabsdet(self): + rng = np.random.default_rng(TEST_SEED) + batch = _skew_batch((N_RANDOM_TESTS_PER_CASE,), 6, rng) + result = log_magnitude_pfaffian(batch) + expected = 0.5 * torch.linalg.slogdet(batch).logabsdet + torch.testing.assert_close(result, expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON) + + def test_odd_dimension_real_is_neg_inf_and_zero(self): + matrix = torch.zeros(3, 5, 5, dtype=torch.float64) + assert torch.all(log_magnitude_pfaffian(matrix) == -torch.inf) + assert torch.all(magnitude_pfaffian(matrix) == 0.0) + + def test_odd_dimension_complex_returns_real_neg_inf(self): + matrix = torch.zeros(2, 5, 5, dtype=torch.complex128) + result = log_magnitude_pfaffian(matrix) + assert result.dtype == torch.float64 + assert torch.all(result == -torch.inf) + + def test_epsilon_floors_tiny_magnitude(self): + block = 1e-3 * torch.eye(4, dtype=torch.float64) + matrix = _block_antidiagonal(block) # |Pf| = (1e-3)^4 = 1e-12 + floored = magnitude_pfaffian(matrix, epsilon=1e-10) + torch.testing.assert_close( + floored, torch.tensor(1e-5, dtype=torch.float64), atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON + ) + unfloored = magnitude_pfaffian(matrix) + assert unfloored.item() < floored.item() + + def test_gradcheck(self): + generator = torch.Generator().manual_seed(TEST_SEED) + matrix = torch.randn(2, 4, 4, dtype=torch.float64, generator=generator, requires_grad=True) + assert torch.autograd.gradcheck(lambda tensor: magnitude_pfaffian(tensor - tensor.transpose(-1, -2)), (matrix,)) + assert torch.autograd.gradcheck( + lambda tensor: log_magnitude_pfaffian(tensor - tensor.transpose(-1, -2)), (matrix,) + ) + + def test_log_magnitude_gradient_alive_for_tiny_pfaffians(self): + # Regression against the sqrt(clamp(|det|, eps)) dead-gradient issue: the log-domain magnitude + # stays finite and differentiable for a Pfaffian around 1e-60. + rng = np.random.default_rng(TEST_SEED) + matrix = torch.from_numpy(random_skew(rng, 8, scale=1e-60)).requires_grad_(True) + log_pf = log_magnitude_pfaffian(matrix) + assert torch.isfinite(log_pf).all() + log_pf.backward() + assert matrix.grad is not None + assert torch.any(matrix.grad != 0) + assert not torch.isnan(matrix.grad).any() + + def test_preserves_device_and_batch_shape(self): + rng = np.random.default_rng(TEST_SEED) + batch = _skew_batch((2, 3), 4, rng) + result = magnitude_pfaffian(batch) + assert result.shape == (2, 3) + assert result.device == batch.device + + def test_singular_gradient_is_finite_and_zero_without_nan(self): + # An exactly-singular element (det == 0) previously made slogdet's backward 0 * inf = NaN. It + # must now give a finite, exactly-zero gradient, while the invertible element is unchanged. + rng = np.random.default_rng(TEST_SEED) + invertible = torch.from_numpy(random_skew(rng, 4)) + corank_two = torch.zeros(4, 4, dtype=torch.float64) + corank_two[0, 1] = 1.0 + corank_two[1, 0] = -1.0 # rank 2, det == 0 exactly + zero = torch.zeros(4, 4, dtype=torch.float64) + batch = torch.stack([invertible, corank_two, zero]).requires_grad_(True) + magnitude_pfaffian(batch).sum().backward() + assert not torch.isnan(batch.grad).any() + assert torch.isfinite(batch.grad).all() + assert torch.all(batch.grad[1] == 0) + assert torch.all(batch.grad[2] == 0) + magnitude = magnitude_pfaffian(invertible) + expected = magnitude * 0.5 * torch.linalg.inv(invertible).transpose(-1, -2) + torch.testing.assert_close(batch.grad[0], expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + def test_singular_gradient_complex_is_finite_without_nan(self): + rng = np.random.default_rng(TEST_SEED) + invertible = torch.from_numpy(random_skew(rng, 4, dtype=np.complex128)) + zero = torch.zeros(4, 4, dtype=torch.complex128) + batch = torch.stack([invertible, zero]).requires_grad_(True) + magnitude_pfaffian(batch).sum().backward() + assert not torch.isnan(batch.grad.real).any() + assert not torch.isnan(batch.grad.imag).any() + assert torch.isfinite(batch.grad.real).all() + assert torch.isfinite(batch.grad.imag).all() + assert torch.all(batch.grad[1] == 0) + + def test_log_magnitude_backward_returns_none_without_input_grad(self): + matrix = torch.zeros(4, 4, dtype=torch.float64) + + class _Context: + saved_tensors = (matrix, torch.zeros((), dtype=torch.bool)) + needs_input_grad = (False,) + + assert LogMagnitudePfaffian.backward(_Context(), torch.ones(())) is None + + def test_singular_gradient_via_public_epsilon_path(self): + # m = 8 > AUTO_SMALL_MAX with sign=False and epsilon routes to magnitude_pfaffian; the + # exactly-singular element must get a finite zero gradient there too. + block = 1e-3 * torch.eye(4, dtype=torch.float64) + good = _block_antidiagonal(block) # 8x8, |Pf| = 1e-12, invertible + singular = torch.zeros(8, 8, dtype=torch.float64) + batch = torch.stack([good, singular]).requires_grad_(True) + pfaffian(batch, sign=False, epsilon=1e-120).sum().backward() + assert not torch.isnan(batch.grad).any() + assert torch.isfinite(batch.grad).all() + assert torch.all(batch.grad[1] == 0) diff --git a/tests/test_kernels/test_parlett_reid_slog.py b/tests/test_kernels/test_parlett_reid_slog.py new file mode 100644 index 0000000..2abbdac --- /dev/null +++ b/tests/test_kernels/test_parlett_reid_slog.py @@ -0,0 +1,142 @@ +import numpy as np +import pytest +import torch + +from tests.configs import ( + ATOL_APPROX_COMPARISON, + ATOL_SCALAR_COMPARISON, + N_RANDOM_TESTS_PER_CASE, + RTOL_APPROX_COMPARISON, + RTOL_SCALAR_COMPARISON, + TEST_SEED, +) +from tests.reference import pfaffian_numpy, random_skew, slog_pfaffian_numpy +from torch_pfaffian.kernels.parlett_reid_slog import parlett_reid_slog + + +def _skew_batch( + shape: tuple[int, ...], dimension: int, rng: np.random.Generator, dtype: type = np.float64, scale: float = 1.0 +) -> torch.Tensor: + count = int(np.prod(shape)) + matrices = np.stack([random_skew(rng, dimension, dtype=dtype, scale=scale) for _ in range(count)]) + return torch.from_numpy(matrices.reshape(*shape, dimension, dimension)) + + +class TestParlettReidSlog: + def test_reconstructs_pfaffian_numpy_real(self): + for dimension in (2, 4, 6, 8, 10): + rng = np.random.default_rng(TEST_SEED + dimension) + batch = _skew_batch((N_RANDOM_TESTS_PER_CASE,), dimension, rng) + phase, log_abs = parlett_reid_slog(batch) + reconstructed = phase * torch.exp(log_abs) + expected = torch.tensor( + [pfaffian_numpy(batch[index].numpy()) for index in range(batch.shape[0])], dtype=batch.dtype + ) + torch.testing.assert_close( + reconstructed, expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON + ) + + def test_reconstructs_pfaffian_numpy_complex(self): + for dimension in (2, 4, 6, 8): + rng = np.random.default_rng(TEST_SEED + dimension) + batch = _skew_batch((N_RANDOM_TESTS_PER_CASE,), dimension, rng, dtype=np.complex128) + phase, log_abs = parlett_reid_slog(batch) + reconstructed = phase * torch.exp(log_abs).to(phase.dtype) + expected = torch.tensor( + [pfaffian_numpy(batch[index].numpy()) for index in range(batch.shape[0])], dtype=batch.dtype + ) + torch.testing.assert_close( + reconstructed, expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON + ) + + def test_matches_slog_numpy_phase_and_log(self): + rng = np.random.default_rng(TEST_SEED) + batch = _skew_batch((N_RANDOM_TESTS_PER_CASE,), 8, rng) + phase, log_abs = parlett_reid_slog(batch) + for index in range(batch.shape[0]): + expected_phase, expected_log = slog_pfaffian_numpy(batch[index].numpy()) + torch.testing.assert_close( + phase[index], torch.tensor(expected_phase, dtype=batch.dtype), atol=ATOL_SCALAR_COMPARISON, rtol=0.0 + ) + torch.testing.assert_close( + log_abs[index], + torch.tensor(expected_log, dtype=batch.dtype), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + def test_nested_batch_shapes(self): + rng = np.random.default_rng(TEST_SEED) + batch = _skew_batch((2, 3), 6, rng) + phase, log_abs = parlett_reid_slog(batch) + assert phase.shape == (2, 3) + assert log_abs.shape == (2, 3) + flat_phase, flat_log = parlett_reid_slog(batch.reshape(6, 6, 6)) + torch.testing.assert_close(phase.reshape(6), flat_phase) + torch.testing.assert_close(log_abs.reshape(6), flat_log) + + def test_zero_matrix_gives_zero_phase_and_neg_inf_log(self): + matrix = torch.zeros(2, 4, 4, dtype=torch.float64) + phase, log_abs = parlett_reid_slog(matrix) + assert torch.all(phase == 0) + assert torch.all(log_abs == -torch.inf) + + def test_odd_dimension(self): + rng = np.random.default_rng(TEST_SEED) + batch = _skew_batch((3,), 5, rng) + phase, log_abs = parlett_reid_slog(batch) + assert torch.all(phase == 0) + assert torch.all(log_abs == -torch.inf) + + def test_empty_matrix(self): + matrix = torch.zeros(3, 0, 0, dtype=torch.float64) + phase, log_abs = parlett_reid_slog(matrix) + torch.testing.assert_close(phase, torch.ones(3, dtype=torch.float64)) + torch.testing.assert_close(log_abs, torch.zeros(3, dtype=torch.float64)) + + def test_no_overflow_or_underflow_at_extreme_scale(self): + rng = np.random.default_rng(TEST_SEED) + for scale in (1e120, 1e-120): + batch = _skew_batch((2,), 32, rng, scale=scale) + phase, log_abs = parlett_reid_slog(batch) + assert torch.isfinite(log_abs).all() + torch.testing.assert_close(phase.abs(), torch.ones_like(phase.abs())) + + def test_float32_reasonable_accuracy(self): + rng = np.random.default_rng(TEST_SEED) + batch = _skew_batch((4,), 8, rng, dtype=np.float32) + phase, log_abs = parlett_reid_slog(batch) + reconstructed = (phase * torch.exp(log_abs)).numpy() + expected = np.array( + [pfaffian_numpy(batch[index].numpy().astype(np.float64)) for index in range(batch.shape[0])] + ) + np.testing.assert_allclose(reconstructed, expected, atol=ATOL_APPROX_COMPARISON, rtol=RTOL_APPROX_COMPARISON) + + def test_complex64_supported(self): + rng = np.random.default_rng(TEST_SEED) + batch = _skew_batch((3,), 6, rng, dtype=np.complex64) + phase, log_abs = parlett_reid_slog(batch) + reconstructed = (phase * torch.exp(log_abs).to(phase.dtype)).numpy() + expected = np.array( + [pfaffian_numpy(batch[index].numpy().astype(np.complex128)) for index in range(batch.shape[0])] + ) + np.testing.assert_allclose(reconstructed, expected, atol=ATOL_APPROX_COMPARISON, rtol=RTOL_APPROX_COMPARISON) + + def test_non_square_raises(self): + with pytest.raises(ValueError, match="square"): + parlett_reid_slog(torch.zeros(3, 4, dtype=torch.float64)) + + def test_preserves_dtype_and_device(self): + rng = np.random.default_rng(TEST_SEED) + for dtype in (np.float32, np.float64, np.complex64, np.complex128): + batch = _skew_batch((2,), 4, rng, dtype=dtype) + phase, _ = parlett_reid_slog(batch) + assert phase.dtype == batch.dtype + assert phase.device == batch.device + + def test_log_abs_real_dtype_matches_complex_precision(self): + rng = np.random.default_rng(TEST_SEED) + complex64_batch = _skew_batch((2,), 4, rng, dtype=np.complex64) + complex128_batch = _skew_batch((2,), 4, rng, dtype=np.complex128) + assert parlett_reid_slog(complex64_batch)[1].dtype == torch.float32 + assert parlett_reid_slog(complex128_batch)[1].dtype == torch.float64 diff --git a/tests/test_kernels/test_small_n.py b/tests/test_kernels/test_small_n.py new file mode 100644 index 0000000..6a2ad69 --- /dev/null +++ b/tests/test_kernels/test_small_n.py @@ -0,0 +1,127 @@ +import numpy as np +import pytest +import torch + +from tests.configs import ( + ATOL_SCALAR_COMPARISON, + N_RANDOM_TESTS_PER_CASE, + RTOL_SCALAR_COMPARISON, + TEST_SEED, +) +from tests.reference import pfaffian_combinatorial, random_skew +from torch_pfaffian.kernels.small_n import SMALL_N_MAX, _matching_tables, small_pfaffian + + +def _skew_batch( + shape: tuple[int, ...], dimension: int, rng: np.random.Generator, dtype: type = np.float64 +) -> torch.Tensor: + count = int(np.prod(shape)) + matrices = np.stack([random_skew(rng, dimension, dtype=dtype) for _ in range(count)]) + return torch.from_numpy(matrices.reshape(*shape, dimension, dimension)) + + +class TestSmallN: + def test_matches_combinatorial_real(self): + for dimension in (2, 4, 6, 8, 10): + rng = np.random.default_rng(TEST_SEED + dimension) + batch = _skew_batch((N_RANDOM_TESTS_PER_CASE,), dimension, rng) + expected = torch.tensor( + [pfaffian_combinatorial(batch[index].numpy()) for index in range(batch.shape[0])], dtype=batch.dtype + ) + torch.testing.assert_close( + small_pfaffian(batch), expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON + ) + + def test_matches_combinatorial_complex(self): + for dimension in (2, 4, 6, 8): + rng = np.random.default_rng(TEST_SEED + dimension) + batch = _skew_batch((N_RANDOM_TESTS_PER_CASE,), dimension, rng, dtype=np.complex128) + expected = torch.tensor( + [pfaffian_combinatorial(batch[index].numpy()) for index in range(batch.shape[0])], dtype=batch.dtype + ) + torch.testing.assert_close( + small_pfaffian(batch), expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON + ) + + def test_two_by_two_returns_upper_entry(self): + matrix = torch.tensor([[0.0, -3.0], [3.0, 0.0]], dtype=torch.float64) + torch.testing.assert_close(small_pfaffian(matrix), torch.tensor(-3.0, dtype=torch.float64)) + + def test_edge_cases(self): + assert small_pfaffian(torch.zeros(0, 0, dtype=torch.float64)).item() == 1.0 + rng = np.random.default_rng(TEST_SEED) + odd = _skew_batch((2,), 5, rng) + torch.testing.assert_close(small_pfaffian(odd), torch.zeros(2, dtype=torch.float64)) + with pytest.raises(ValueError, match="m <= 10"): + small_pfaffian(torch.zeros(12, 12, dtype=torch.float64)) + with pytest.raises(ValueError, match="square"): + small_pfaffian(torch.zeros(4, 5, dtype=torch.float64)) + + def test_gradcheck_real(self): + for dimension in (4, 6): + generator = torch.Generator().manual_seed(TEST_SEED) + matrix = torch.randn(2, dimension, dimension, dtype=torch.float64, generator=generator, requires_grad=True) + assert torch.autograd.gradcheck(lambda tensor: small_pfaffian(tensor - tensor.transpose(-1, -2)), (matrix,)) + + def test_gradcheck_complex(self): + generator = torch.Generator().manual_seed(TEST_SEED) + matrix = torch.randn(2, 4, 4, dtype=torch.complex128, generator=generator, requires_grad=True) + assert torch.autograd.gradcheck(lambda tensor: small_pfaffian(tensor - tensor.transpose(-1, -2)), (matrix,)) + + def test_matching_table_term_counts(self): + for dimension, count in ((2, 1), (4, 3), (6, 15), (8, 105), (10, 945)): + rows, cols, signs = _matching_tables(dimension) + assert len(rows) == count + assert len(cols) == count + assert len(signs) == count + + def test_small_n_max_is_ten(self): + assert SMALL_N_MAX == 10 + + def test_preserves_dtype_and_device(self): + rng = np.random.default_rng(TEST_SEED) + for dtype in (np.float32, np.float64, np.complex64, np.complex128): + batch = _skew_batch((2,), 6, rng, dtype=dtype) + result = small_pfaffian(batch) + assert result.dtype == batch.dtype + assert result.device == batch.device + + def test_odd_dimension_backward_returns_zero_grad(self): + # The odd short-circuit must carry a grad connection so backward returns a zero gradient + # instead of raising on a constant with no grad_fn. + generator = torch.Generator().manual_seed(TEST_SEED) + matrix = torch.randn(2, 5, 5, dtype=torch.float64, generator=generator, requires_grad=True) + small_pfaffian(matrix).sum().backward() + assert matrix.grad is not None + assert torch.isfinite(matrix.grad).all() + assert torch.all(matrix.grad == 0) + + def test_empty_dimension_backward_returns_zero_grad(self): + matrix = torch.zeros(2, 0, 0, dtype=torch.float64, requires_grad=True) + result = small_pfaffian(matrix) + torch.testing.assert_close(result, torch.ones(2, dtype=torch.float64)) + result.sum().backward() # must not raise + assert matrix.grad is not None + assert matrix.grad.shape == matrix.shape + + def test_odd_dimension_with_non_finite_entries_is_zero(self): + # The odd-dim Pfaffian is 0 regardless of the entries; inf/nan entries must not contaminate the + # result (the grad-carrying short-circuit must not compute inf * 0 = nan, including cross-batch). + single = torch.full((5, 5), float("inf"), dtype=torch.float64) + result = small_pfaffian(single) + assert result.item() == 0.0 + assert torch.isfinite(result).all() + generator = torch.Generator().manual_seed(TEST_SEED) + finite_odd = torch.randn(5, 5, dtype=torch.float64, generator=generator) + finite_odd = finite_odd - finite_odd.transpose(-1, -2) + non_finite_odd = torch.full((5, 5), float("nan"), dtype=torch.float64) + batched = small_pfaffian(torch.stack([finite_odd, non_finite_odd])) + torch.testing.assert_close(batched, torch.zeros(2, dtype=torch.float64)) + assert not torch.isnan(batched).any() + + def test_odd_dimension_non_finite_backward_returns_finite_zero_grad(self): + matrix = torch.full((5, 5), float("inf"), dtype=torch.float64, requires_grad=True) + small_pfaffian(matrix).sum().backward() + assert matrix.grad is not None + assert torch.isfinite(matrix.grad).all() + assert torch.all(matrix.grad == 0) diff --git a/tests/test_strategies/test_pfaffian_block_det.py b/tests/test_strategies/test_pfaffian_block_det.py index c7d9881..58a9ae4 100644 --- a/tests/test_strategies/test_pfaffian_block_det.py +++ b/tests/test_strategies/test_pfaffian_block_det.py @@ -131,6 +131,25 @@ def test_backward_mixed_singular_invertible_batch_matches_inverse(self): matrix.grad[1, :3, 3:], expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON ) + def test_exact_singular_grad_false_gives_zero_grad_at_singular(self, monkeypatch): + # With EXACT_SINGULAR_GRAD disabled the backward is host-sync-free: a singular block (pf == 0) + # gets an exactly zero gradient, while an invertible one matches the inverse-based closed form. + monkeypatch.setattr(PfaffianBlockDet, "EXACT_SINGULAR_GRAD", False) + rng = np.random.default_rng(TEST_SEED) + singular_block = torch.zeros(3, 3, dtype=torch.float64) + invertible_block = torch.tensor(rng.random((3, 3))) + torch.eye(3) + matrix = torch.stack( + [_block_antidiagonal(singular_block), _block_antidiagonal(invertible_block)] + ).requires_grad_(True) + PfaffianBlockDet.apply(matrix).sum().backward() + assert torch.isfinite(matrix.grad).all() + assert torch.all(matrix.grad[0] == 0) # sync-free: singular block gets exactly zero gradient + constant = (-1) ** (3 * (3 - 1) // 2) + expected = constant * torch.linalg.det(invertible_block) * torch.linalg.inv(invertible_block).transpose(-1, -2) + torch.testing.assert_close( + matrix.grad[1, :3, 3:], expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON + ) + def test_adjugate_override_delegates_to_parlett_reid(self): # PfaffianBlockDet.forward is block-only, so its adjugate must defer to the general strategy. from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid diff --git a/tests/test_strategies/test_pfaffian_fdbpf.py b/tests/test_strategies/test_pfaffian_fdbpf.py index 8a4f25c..cb6386c 100644 --- a/tests/test_strategies/test_pfaffian_fdbpf.py +++ b/tests/test_strategies/test_pfaffian_fdbpf.py @@ -137,6 +137,26 @@ def test_backward_mixed_singular_invertible_batch_matches_inverse(self): matrix.grad[1], expected_invertible, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON ) + def test_exact_singular_grad_false_gives_zero_grad_at_singular(self, monkeypatch): + # With EXACT_SINGULAR_GRAD disabled the magnitude backward is host-sync-free: a singular + # element (pf at the floor) gets an exactly zero gradient, while an invertible one matches the + # inverse-based closed form. + monkeypatch.setattr(PfaffianFDBPf, "EXACT_SINGULAR_GRAD", False) + singular = torch.zeros(4, 4, dtype=torch.float64) + invertible = torch.tensor( + [[0.0, 1.0, 0.0, 0.0], [-1.0, 0.0, 0.0, 0.0], [0.0, 0.0, 0.0, 2.0], [0.0, 0.0, -2.0, 0.0]], + dtype=torch.float64, + ) + matrix = torch.stack([singular, invertible]).requires_grad_(True) + magnitude = PfaffianFDBPf.apply(matrix) + magnitude.sum().backward() + assert torch.isfinite(matrix.grad).all() + assert torch.all(matrix.grad[0] == 0) # sync-free: singular element gets exactly zero gradient + expected_invertible = torch.einsum("ij->ji", 0.5 * magnitude[1].detach() * torch.linalg.inv(invertible)) + torch.testing.assert_close( + matrix.grad[1], expected_invertible, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON + ) + def test_backward_ill_conditioned_is_finite_and_matches_inverse(self): # Ill-conditioned invertible input (the regime where the SVD pseudo-inverse fails to converge): # the LU inverse stays finite and the gradient matches the inverse closed form. diff --git a/tests/test_strategies/test_pfaffian_slog.py b/tests/test_strategies/test_pfaffian_slog.py new file mode 100644 index 0000000..a0f5fc2 --- /dev/null +++ b/tests/test_strategies/test_pfaffian_slog.py @@ -0,0 +1,99 @@ +import numpy as np +import torch + +from tests.configs import ( + ATOL_SCALAR_COMPARISON, + N_RANDOM_TESTS_PER_CASE, + RTOL_SCALAR_COMPARISON, + TEST_SEED, +) +from tests.reference import random_skew +from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid +from torch_pfaffian.strategies.pfaffian_slog import SlogPfaffianStrategy + + +def _skew_batch( + shape: tuple[int, ...], dimension: int, rng: np.random.Generator, dtype: type = np.float64 +) -> torch.Tensor: + count = int(np.prod(shape)) + matrices = np.stack([random_skew(rng, dimension, dtype=dtype) for _ in range(count)]) + return torch.from_numpy(matrices.reshape(*shape, dimension, dimension)) + + +class TestSlogPfaffianStrategy: + def test_reconstructs_signed_pfaffian(self): + for dimension in (2, 4, 6, 8): + rng = np.random.default_rng(TEST_SEED + dimension) + batch = _skew_batch((N_RANDOM_TESTS_PER_CASE,), dimension, rng) + phase, log_abs = SlogPfaffianStrategy.apply(batch) + reconstructed = phase * torch.exp(log_abs) + expected = PfaffianParlettReid.apply(batch) + torch.testing.assert_close( + reconstructed, expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON + ) + + def test_reconstructs_signed_pfaffian_complex(self): + rng = np.random.default_rng(TEST_SEED) + batch = _skew_batch((N_RANDOM_TESTS_PER_CASE,), 6, rng, dtype=np.complex128) + phase, log_abs = SlogPfaffianStrategy.apply(batch) + reconstructed = phase * torch.exp(log_abs).to(phase.dtype) + expected = PfaffianParlettReid.apply(batch) + torch.testing.assert_close(reconstructed, expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON) + + def test_phase_is_non_differentiable(self): + matrix = _skew_batch((2,), 4, np.random.default_rng(TEST_SEED)).requires_grad_(True) + phase, log_abs = SlogPfaffianStrategy.apply(matrix) + assert not phase.requires_grad + assert log_abs.requires_grad + + def test_gradcheck_log_abs_real(self): + for dimension in (4, 6): + generator = torch.Generator().manual_seed(TEST_SEED) + matrix = torch.randn(2, dimension, dimension, dtype=torch.float64, generator=generator, requires_grad=True) + assert torch.autograd.gradcheck( + lambda tensor: SlogPfaffianStrategy.apply(tensor - tensor.transpose(-1, -2))[1], (matrix,) + ) + + def test_complex_backward_is_finite(self): + generator = torch.Generator().manual_seed(TEST_SEED) + matrix = torch.randn(2, 4, 4, dtype=torch.complex128, generator=generator, requires_grad=True) + _, log_abs = SlogPfaffianStrategy.apply(matrix - matrix.transpose(-1, -2)) + log_abs.sum().backward() + assert torch.isfinite(matrix.grad.real).all() + assert torch.isfinite(matrix.grad.imag).all() + + def test_odd_empty_and_zero(self): + rng = np.random.default_rng(TEST_SEED) + odd = _skew_batch((3,), 5, rng) + phase, log_abs = SlogPfaffianStrategy.apply(odd) + assert torch.all(phase == 0) + assert torch.all(log_abs == -torch.inf) + empty = torch.zeros(2, 0, 0, dtype=torch.float64) + phase, log_abs = SlogPfaffianStrategy.apply(empty) + torch.testing.assert_close(phase, torch.ones(2, dtype=torch.float64)) + torch.testing.assert_close(log_abs, torch.zeros(2, dtype=torch.float64)) + zero = torch.zeros(2, 4, 4, dtype=torch.float64) + phase, log_abs = SlogPfaffianStrategy.apply(zero) + assert torch.all(phase == 0) + assert torch.all(log_abs == -torch.inf) + + def test_singular_elements_get_zero_gradient(self): + rng = np.random.default_rng(TEST_SEED) + batch = torch.stack( + [torch.from_numpy(random_skew(rng, 4)), torch.zeros(4, 4, dtype=torch.float64)] + ).requires_grad_(True) + _, log_abs = SlogPfaffianStrategy.apply(batch) + finite = torch.isfinite(log_abs) + log_abs[finite].sum().backward() + assert batch.grad is not None + assert not torch.isnan(batch.grad).any() + assert torch.all(batch.grad[1] == 0) + assert torch.any(batch.grad[0] != 0) + + def test_preserves_dtype_and_device(self): + rng = np.random.default_rng(TEST_SEED) + for dtype in (np.float32, np.float64, np.complex64, np.complex128): + batch = _skew_batch((2,), 4, rng, dtype=dtype) + phase, _ = SlogPfaffianStrategy.apply(batch) + assert phase.dtype == batch.dtype + assert phase.device == batch.device diff --git a/tests/test_strategies/test_pfaffian_small.py b/tests/test_strategies/test_pfaffian_small.py new file mode 100644 index 0000000..8ded918 --- /dev/null +++ b/tests/test_strategies/test_pfaffian_small.py @@ -0,0 +1,106 @@ +import numpy as np +import torch + +from tests.configs import ( + ATOL_MATRIX_COMPARISON, + ATOL_SCALAR_COMPARISON, + N_RANDOM_TESTS_PER_CASE, + RTOL_MATRIX_COMPARISON, + RTOL_SCALAR_COMPARISON, + TEST_SEED, +) +from tests.reference import pfaffian_combinatorial, random_skew +from torch_pfaffian import get_pfaffian_function, pfaffian_strategy_map +from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid +from torch_pfaffian.strategies.pfaffian_small import PfaffianSmall + + +def _skew_batch( + shape: tuple[int, ...], dimension: int, rng: np.random.Generator, dtype: type = np.float64 +) -> torch.Tensor: + count = int(np.prod(shape)) + matrices = np.stack([random_skew(rng, dimension, dtype=dtype) for _ in range(count)]) + return torch.from_numpy(matrices.reshape(*shape, dimension, dimension)) + + +class TestPfaffianSmall: + def test_matches_combinatorial_oracle_real(self): + for dimension in (2, 4, 6): + rng = np.random.default_rng(TEST_SEED + dimension) + batch = _skew_batch((N_RANDOM_TESTS_PER_CASE,), dimension, rng) + expected = torch.tensor( + [pfaffian_combinatorial(batch[index].numpy()) for index in range(batch.shape[0])], dtype=batch.dtype + ) + torch.testing.assert_close( + PfaffianSmall.apply(batch), expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON + ) + + def test_matches_combinatorial_oracle_complex(self): + rng = np.random.default_rng(TEST_SEED) + batch = _skew_batch((N_RANDOM_TESTS_PER_CASE,), 6, rng, dtype=np.complex128) + expected = torch.tensor( + [pfaffian_combinatorial(batch[index].numpy()) for index in range(batch.shape[0])], dtype=batch.dtype + ) + torch.testing.assert_close( + PfaffianSmall.apply(batch), expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON + ) + + def test_name_and_registration(self): + assert PfaffianSmall.NAME == "PfaffianSmall" + assert PfaffianSmall.NAME.lower().strip() in pfaffian_strategy_map + assert get_pfaffian_function(PfaffianSmall.NAME) == PfaffianSmall.apply + + def test_gradcheck_real(self): + # gradcheck on full (non-skew) inputs exercises the internal re-skew-symmetrization. + for dimension in (2, 4, 6): + generator = torch.Generator().manual_seed(TEST_SEED) + matrix = torch.randn(2, dimension, dimension, dtype=torch.float64, generator=generator, requires_grad=True) + assert torch.autograd.gradcheck(PfaffianSmall.apply, (matrix,)) + + def test_gradcheck_complex(self): + generator = torch.Generator().manual_seed(TEST_SEED) + matrix = torch.randn(2, 4, 4, dtype=torch.complex128, generator=generator, requires_grad=True) + assert torch.autograd.gradcheck(PfaffianSmall.apply, (matrix,)) + + def test_signed_gradient_matches_analytic_formula(self): + # The re-skew-symmetrization makes the gradient of a full-matrix skew input equal the analytic + # VJP 0.5 * pf(A) * (A^{-1})^T (skew-split), rather than piling in the upper triangle. + rng = np.random.default_rng(TEST_SEED) + matrix = torch.from_numpy(random_skew(rng, 6)).requires_grad_(True) + pfaffian = PfaffianSmall.apply(matrix) + pfaffian.backward() + expected = 0.5 * pfaffian.detach() * torch.linalg.inv(matrix.detach()).transpose(-1, -2) + torch.testing.assert_close(matrix.grad, expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + def test_odd_and_empty(self): + rng = np.random.default_rng(TEST_SEED) + odd = _skew_batch((2,), 5, rng) + torch.testing.assert_close(PfaffianSmall.apply(odd), torch.zeros(2, dtype=torch.float64)) + empty = torch.zeros(2, 0, 0, dtype=torch.float64) + torch.testing.assert_close(PfaffianSmall.apply(empty), torch.ones(2, dtype=torch.float64)) + + def test_two_by_two_is_signed(self): + matrix = torch.tensor([[0.0, -3.0], [3.0, 0.0]], dtype=torch.float64) + torch.testing.assert_close(PfaffianSmall.apply(matrix), torch.tensor(-3.0, dtype=torch.float64)) + + def test_two_by_two_gradient_matches_parlett_reid(self): + # Re-skewing at m == 2 gives the skew-split gradient [[0, 0.5], [-0.5, 0]] (matching every other + # strategy) rather than the upper-triangle [[0, 1], [0, 0]] of the raw unrolled kernel. + for dtype in (torch.float64, torch.complex128): + small_input = torch.tensor([[0.0, -3.0], [3.0, 0.0]], dtype=dtype, requires_grad=True) + reference_input = small_input.detach().clone().requires_grad_(True) + small_output = PfaffianSmall.apply(small_input) + small_output.backward(torch.ones_like(small_output)) + reference_output = PfaffianParlettReid.apply(reference_input) + reference_output.backward(torch.ones_like(reference_output)) + torch.testing.assert_close( + small_input.grad, reference_input.grad, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON + ) + + def test_preserves_dtype_and_device(self): + rng = np.random.default_rng(TEST_SEED) + for dtype in (torch.float32, torch.float64, torch.complex64, torch.complex128): + batch = _skew_batch((2,), 6, rng).to(dtype) + result = PfaffianSmall.apply(batch) + assert result.dtype == dtype + assert result.device == batch.device diff --git a/tests/test_strategies/test_strategy.py b/tests/test_strategies/test_strategy.py index 9b94545..03c56c3 100644 --- a/tests/test_strategies/test_strategy.py +++ b/tests/test_strategies/test_strategy.py @@ -262,3 +262,27 @@ def test_grad_matrix_empty_matrix_returns_empty_gradient(self): def test_class_singularity_constants(self): assert PfaffianStrategy.SINGULARITY_RTOL_EXPONENT == 0.75 assert PfaffianStrategy.INVERSE_RESIDUAL_RTOL_EXPONENT == 0.5 + + def test_exact_singular_grad_default_is_true(self): + # The default keeps the historical exact minor-based adjugate at singular elements. + assert PfaffianStrategy.EXACT_SINGULAR_GRAD is True + + def test_grad_matrix_sync_free_gives_zero_grad_at_singular(self, monkeypatch): + # With EXACT_SINGULAR_GRAD disabled the backward is host-sync-free: exactly-singular elements + # (pf == 0) receive an exactly zero gradient, while invertible elements match the inverse form. + monkeypatch.setattr(PfaffianParlettReid, "EXACT_SINGULAR_GRAD", False) + singular = torch.zeros(4, 4, dtype=torch.float64) + singular[2, 3] = 1.0 + singular[3, 2] = -1.0 + invertible = _random_skew(4, seed=1) + matrix = torch.stack([singular, invertible]) + pfaffian = PfaffianParlettReid.forward(matrix) + assert pfaffian[0] == 0.0 # the improved forward returns exactly 0 for the singular element + grad_output = torch.ones(2, dtype=torch.float64) + result = PfaffianParlettReid.pfaffian_grad_matrix(matrix, pfaffian, grad_output) + assert torch.isfinite(result).all() + assert torch.all(result[0] == 0) # sync-free: singular element gets exactly zero gradient + expected_invertible = torch.einsum("ij->ji", 0.5 * grad_output[1] * pfaffian[1] * torch.linalg.inv(invertible)) + torch.testing.assert_close( + result[1], expected_invertible, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON + ) diff --git a/tests/test_torch_pfaffian.py b/tests/test_torch_pfaffian.py index 5eaed78..98bf9a9 100644 --- a/tests/test_torch_pfaffian.py +++ b/tests/test_torch_pfaffian.py @@ -7,8 +7,10 @@ import torch_pfaffian from tests.configs import ( + ATOL_MATRIX_COMPARISON, ATOL_SCALAR_COMPARISON, N_RANDOM_TESTS_PER_CASE, + RTOL_MATRIX_COMPARISON, RTOL_SCALAR_COMPARISON, TEST_SEED, ) @@ -38,6 +40,24 @@ def _rand_skew_complex(dimension: int, rng: np.random.Generator) -> np.ndarray: return entries - entries.T +def _block_antidiagonal(block: torch.Tensor) -> torch.Tensor: + # Skew matrix [[0, block], [-block^T, 0]] whose Pfaffian magnitude is |det(block)|. + zero = torch.zeros_like(block) + top = torch.cat([zero, block], dim=-1) + bottom = torch.cat([-block.transpose(-1, -2), zero], dim=-1) + return torch.cat([top, bottom], dim=-2) + + +def _block_diagonal_skew(coefficients: list[float]) -> torch.Tensor: + # Block-diagonal skew matrix of 2x2 blocks [[0, c], [-c, 0]]; its Pfaffian is the product of the c. + dimension = 2 * len(coefficients) + matrix = torch.zeros(dimension, dimension, dtype=torch.float64) + for index, coefficient in enumerate(coefficients): + matrix[2 * index, 2 * index + 1] = coefficient + matrix[2 * index + 1, 2 * index] = -coefficient + return matrix + + class TestTorchPfaffian: def test_rust_parlett_reid_registered_when_available(self): pytest.importorskip("torch_pfaffian._rust") @@ -80,6 +100,14 @@ def test_parlett_reid_is_registered(self): def _skew_matrix() -> torch.Tensor: return torch.tensor([[0.0, -3.0], [3.0, 0.0]], dtype=torch.float64) + @staticmethod + def _large_skew_matrix() -> torch.Tensor: + # A skew matrix larger than AUTO_SMALL_MAX so dispatch bypasses the small-m kernel and the + # Rust/Parlett-Reid/Det/FDBPf routing under test is exercised. + generator = torch.Generator().manual_seed(0) + full = torch.randn(8, 8, dtype=torch.float64, generator=generator) + return full - full.transpose(-1, -2) + def test_pfaffian_signed_by_default_matches_parlett_reid(self): matrix = self._skew_matrix() torch.testing.assert_close(pfaffian(matrix), PfaffianParlettReid.apply(matrix)) @@ -94,7 +122,7 @@ def test_pfaffian_routes_sign_true_to_rust_when_available(self): pytest.importorskip("torch_pfaffian._rust") with mock.patch.object(torch_pfaffian, "RustPfaffianParlettReid") as fake: fake.apply.return_value = torch.zeros(()) - pfaffian(self._skew_matrix(), sign=True) + pfaffian(self._large_skew_matrix(), sign=True) fake.apply.assert_called_once() def test_pfaffian_routes_sign_true_to_python_when_rust_unavailable(self): @@ -103,7 +131,7 @@ def test_pfaffian_routes_sign_true_to_python_when_rust_unavailable(self): mock.patch.object(torch_pfaffian, "PfaffianParlettReid") as fake, ): fake.apply.return_value = torch.zeros(()) - pfaffian(self._skew_matrix(), sign=True) + pfaffian(self._large_skew_matrix(), sign=True) fake.apply.assert_called_once() def test_pfaffian_sign_true_routes_to_python_on_non_cpu_device(self): @@ -111,6 +139,7 @@ def test_pfaffian_sign_true_routes_to_python_on_non_cpu_device(self): pytest.importorskip("torch_pfaffian._rust") non_cpu_matrix = mock.MagicMock() non_cpu_matrix.device.type = "cuda" + non_cpu_matrix.shape = (8, 8) # larger than AUTO_SMALL_MAX so the small-m kernel is bypassed with ( mock.patch.object(torch_pfaffian, "RustPfaffianParlettReid") as fake_rust, mock.patch.object(torch_pfaffian, "PfaffianParlettReid") as fake_python, @@ -123,22 +152,45 @@ def test_pfaffian_sign_true_routes_to_python_on_non_cpu_device(self): def test_pfaffian_routes_magnitude_no_grad_to_det(self): with mock.patch.object(torch_pfaffian, "PfaffianDet") as fake: fake.apply.return_value = torch.zeros(()) - pfaffian(self._skew_matrix(), sign=False) + pfaffian(self._large_skew_matrix(), sign=False) fake.apply.assert_called_once() def test_pfaffian_routes_magnitude_with_grad_to_fdbpf(self): - matrix = self._skew_matrix().requires_grad_(True) + matrix = self._large_skew_matrix().requires_grad_(True) with mock.patch.object(torch_pfaffian, "PfaffianFDBPf") as fake: fake.apply.return_value = torch.zeros((), requires_grad=True) pfaffian(matrix, sign=False) fake.apply.assert_called_once() + def test_pfaffian_routes_small_dimension_to_pfaffian_small(self): + with mock.patch.object(torch_pfaffian, "PfaffianSmall") as fake: + fake.apply.return_value = torch.zeros(()) + pfaffian(self._skew_matrix(), sign=True) + fake.apply.assert_called_once() + + def test_pfaffian_routes_small_dimension_magnitude_to_pfaffian_small(self): + with mock.patch.object(torch_pfaffian, "PfaffianSmall") as fake: + fake.apply.return_value = torch.zeros(()) + pfaffian(self._skew_matrix(), sign=False) + fake.apply.assert_called_once() + def test_pfaffian_signed_backward_flows(self): matrix = self._skew_matrix().requires_grad_(True) pfaffian(matrix).backward() assert matrix.grad is not None assert matrix.grad.shape == matrix.shape + def test_pfaffian_small_odd_dimension_backward_returns_zero_grad(self): + # Odd m <= AUTO_SMALL_MAX with grad must not raise (the small path once returned a constant with + # no grad_fn); backward returns a finite zero gradient, matching the large-m Parlett-Reid path. + generator = torch.Generator().manual_seed(1) + full = torch.randn(5, 5, dtype=torch.float64, generator=generator) + matrix = (full - full.transpose(-1, -2)).requires_grad_(True) + pfaffian(matrix, sign=True).sum().backward() + assert matrix.grad is not None + assert torch.isfinite(matrix.grad).all() + assert torch.all(matrix.grad == 0) + def test_pfaffian_check_input_rejects_non_skew(self): non_skew = torch.tensor([[1.0, 2.0], [3.0, 4.0]], dtype=torch.float64) with pytest.raises(ValueError, match="skew-symmetric"): @@ -195,10 +247,11 @@ def test_pfaffian_sign_true_complex_supports_batched_shapes(self): torch.testing.assert_close(result, expected, atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON) def test_pfaffian_sign_true_complex_routes_to_rust_on_cpu(self): - # The Rust kernel now handles complex natively, so complex CPU inputs take the fast Rust path. + # The Rust kernel now handles complex natively, so complex CPU inputs above AUTO_SMALL_MAX take + # the fast Rust path (smaller ones take the exact unrolled kernel). pytest.importorskip("torch_pfaffian._rust") rng = np.random.default_rng(TEST_SEED) - matrix = torch.tensor(_rand_skew_complex(4, rng), dtype=torch.complex128) + matrix = torch.tensor(_rand_skew_complex(8, rng), dtype=torch.complex128) with mock.patch.object(torch_pfaffian, "RustPfaffianParlettReid") as fake_rust: fake_rust.apply.return_value = torch.zeros((), dtype=torch.complex128) pfaffian(matrix, sign=True) @@ -261,10 +314,111 @@ def test_pfaffian_sign_true_complex_singular_is_zero_without_nan(self): def test_pfaffian_warns_when_result_overflows(self): # A 4x4 block-antidiagonal with huge entries makes the Pfaffian overflow to inf. block = torch.tensor([[1e200, 0.0], [0.0, 1e200]], dtype=torch.float64) - zero = torch.zeros_like(block) - top = torch.cat([zero, block], dim=-1) - bottom = torch.cat([-block.transpose(-1, -2), zero], dim=-1) - matrix = torch.cat([top, bottom], dim=-2) + matrix = _block_antidiagonal(block) with pytest.warns(RuntimeWarning, match="not finite"): result = pfaffian(matrix) assert not torch.isfinite(result).all() + + def test_pfaffian_check_finite_false_skips_overflow_warning(self): + # check_finite=False skips the mandatory isfinite host sync (and its warning). + block = torch.tensor([[1e200, 0.0], [0.0, 1e200]], dtype=torch.float64) + matrix = _block_antidiagonal(block) + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + result = pfaffian(matrix, check_finite=False) + assert not any("not finite" in str(warning.message) for warning in caught) + assert not torch.isfinite(result).all() # the overflow still happens; only the check is skipped + + def test_pfaffian_auto_recovers_signed_transient_overflow(self): + # A wide-dynamic-range input whose linear product overflows mid-way while the true Pfaffian is + # finite is transparently recovered in the log domain: the default path returns the finite value + # with no warning, while check_finite=False exposes the raw inf. No user action (no slog) needed. + matrix = _block_diagonal_skew([1e200, 1e200, 1e-29, 1e-29, 1e-29, 1e-29, 1e-29, 1e-29]) + raw = pfaffian(matrix, sign=True, check_finite=False) + assert not torch.isfinite(raw) # the raw fast path overflows to inf + phase, log_abs = torch_pfaffian.slog_pfaffian(matrix) + expected = phase * torch.exp(log_abs).to(phase.dtype) + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + recovered = pfaffian(matrix, sign=True) + assert torch.isfinite(recovered) + assert not any(issubclass(warning.category, RuntimeWarning) for warning in caught) + torch.testing.assert_close(recovered, expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + def test_pfaffian_auto_recovers_signed_transient_overflow_gradient_is_finite(self): + # The recovered value stays differentiable: the linear graph (whose saved inf Pfaffian would + # give 0 * inf = NaN in its backward) is discarded in favor of the log-domain reconstruction. + matrix = _block_diagonal_skew([1e200, 1e200, 1e-29, 1e-29, 1e-29, 1e-29, 1e-29, 1e-29]) + matrix.requires_grad_(True) + pfaffian(matrix, sign=True).backward() + assert matrix.grad is not None + assert torch.isfinite(matrix.grad).all() + assert torch.any(matrix.grad != 0) + + def test_pfaffian_auto_recovers_magnitude_transient_overflow(self): + # The magnitude path (sign=False) recovers overflow the same way, via the log-domain magnitude. + matrix = _block_diagonal_skew([1e200, 1e200, 1e-29, 1e-29, 1e-29, 1e-29, 1e-29, 1e-29]) + raw = pfaffian(matrix, sign=False, check_finite=False) + assert not torch.isfinite(raw) + expected = torch.exp(torch_pfaffian.log_magnitude_pfaffian(matrix)) + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + recovered = pfaffian(matrix, sign=False) + assert torch.isfinite(recovered) + assert not any(issubclass(warning.category, RuntimeWarning) for warning in caught) + torch.testing.assert_close(recovered, expected, atol=ATOL_MATRIX_COMPARISON, rtol=RTOL_MATRIX_COMPARISON) + + def test_pfaffian_magnitude_epsilon_genuinely_huge_still_warns(self): + # sign=False with epsilon on a genuinely out-of-range magnitude: the log-domain recovery + # re-applies the sqrt(epsilon) floor and, since the true value exceeds the dtype range, warns. + matrix = _block_antidiagonal(torch.tensor([[1e200, 0.0], [0.0, 1e200]], dtype=torch.float64)) + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + result = pfaffian(matrix, sign=False, epsilon=1e-10) + assert not torch.isfinite(result) + assert any(issubclass(warning.category, RuntimeWarning) for warning in caught) + + def test_auto_small_max_constant(self): + assert torch_pfaffian.AUTO_SMALL_MAX == 6 + + def test_slog_pfaffian_reconstructs_signed_pfaffian(self): + # The public slog wrapper returns (phase, log|Pf|) reconstructing the signed Pfaffian. + rng = np.random.default_rng(TEST_SEED) + matrix = torch.tensor(_rand_skew_complex(8, rng), dtype=torch.complex128) + phase, log_abs = torch_pfaffian.slog_pfaffian(matrix) + reconstructed = phase * torch.exp(log_abs).to(phase.dtype) + torch.testing.assert_close( + reconstructed, pfaffian(matrix, sign=True), atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON + ) + + def test_pfaffian_epsilon_floors_magnitude_on_determinant_path(self): + # m = 8 > AUTO_SMALL_MAX, sign=False, epsilon given: the log-domain magnitude path floors at + # sqrt(epsilon), whereas the default (epsilon=None) returns the true tiny magnitude. + block = 1e-3 * torch.eye(4, dtype=torch.float64) + matrix = _block_antidiagonal(block) # 8x8 skew, |Pf| = (1e-3)^4 = 1e-12 + floored = pfaffian(matrix, sign=False, epsilon=1e-10) + torch.testing.assert_close( + floored, torch.tensor(1e-5, dtype=torch.float64), atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON + ) + unfloored = pfaffian(matrix, sign=False) + assert unfloored.item() < floored.item() + + def test_pfaffian_epsilon_none_matches_default_magnitude(self): + rng = np.random.default_rng(TEST_SEED) + matrix = torch.tensor(_rand_skew_complex(8, rng).real, dtype=torch.float64) + matrix = 0.5 * (matrix - matrix.transpose(-1, -2)) + torch.testing.assert_close( + pfaffian(matrix, sign=False, epsilon=None), + PfaffianDet.apply(matrix), + atol=ATOL_SCALAR_COMPARISON, + rtol=RTOL_SCALAR_COMPARISON, + ) + + def test_pfaffian_epsilon_floors_magnitude_on_small_path(self): + # m = 4 <= AUTO_SMALL_MAX, sign=False, epsilon given: the small path clamps |Pf| at sqrt(epsilon). + block = 1e-3 * torch.eye(2, dtype=torch.float64) + matrix = _block_antidiagonal(block) # 4x4 skew, |Pf| = (1e-3)^2 = 1e-6 + floored = pfaffian(matrix, sign=False, epsilon=1e-8) + torch.testing.assert_close( + floored, torch.tensor(1e-4, dtype=torch.float64), atol=ATOL_SCALAR_COMPARISON, rtol=RTOL_SCALAR_COMPARISON + ) From 8016339b3ee70146b0c970541ef7d5e92d781a5f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=A9mie=20Gince?= <50332514+JeremieGince@users.noreply.github.com> Date: Mon, 13 Jul 2026 17:25:04 -0400 Subject: [PATCH 4/6] Remove old benchmark files --- notebooks/_strategies_benchmark_helpers.py | 198 ----------- notebooks/strategies_benchmark.ipynb | 363 --------------------- 2 files changed, 561 deletions(-) delete mode 100644 notebooks/_strategies_benchmark_helpers.py delete mode 100644 notebooks/strategies_benchmark.ipynb diff --git a/notebooks/_strategies_benchmark_helpers.py b/notebooks/_strategies_benchmark_helpers.py deleted file mode 100644 index 824c4d2..0000000 --- a/notebooks/_strategies_benchmark_helpers.py +++ /dev/null @@ -1,198 +0,0 @@ -import time -from collections.abc import Callable - -import matplotlib.pyplot as plt -import numpy as np -import pandas as pd -import seaborn as sns -import torch -from torch.profiler import ProfilerActivity, profile -from tqdm.auto import tqdm - -from torch_pfaffian.strategies.pfaffian_block_det import PfaffianBlockDet -from torch_pfaffian.strategies.strategy import PfaffianStrategy - -Strategy = type[PfaffianStrategy] -BenchmarkResults = pd.DataFrame - -METRICS = ("forward_time", "backward_time", "forward_memory", "forward_backward_memory") - - -def make_block_antidiagonal( - n: int, batch_size: int, dtype: torch.dtype = torch.float32, device: str = "cpu" -) -> torch.Tensor: - """ - Build a batch of block-antidiagonal skew matrices ``[[0, B], [-B^T, 0]]`` of dimension ``n``. - - :param n: Matrix dimension (even); the result has shape ``(batch_size, n, n)``. - :param batch_size: Number of matrices in the batch. - :param dtype: Floating dtype of the matrices. - :param device: Device on which to allocate the matrices. - :return: A tensor of shape ``(batch_size, n, n)``. - :rtype: torch.Tensor - """ - half = n // 2 - block = torch.randn(batch_size, half, half, dtype=dtype, device=device) - zero = torch.zeros_like(block) - top = torch.cat([zero, block], dim=-1) - bottom = torch.cat([-block.transpose(-1, -2), zero], dim=-1) - return torch.cat([top, bottom], dim=-2) - - -def make_random_skew(n: int, batch_size: int, dtype: torch.dtype = torch.float32, device: str = "cpu") -> torch.Tensor: - """ - Build a batch of general (dense) random skew-symmetric matrices of dimension ``n``. - - Unlike :func:`make_block_antidiagonal`, the result has no block structure, so it is a - representative input for the strategies that accept any skew-symmetric matrix (every strategy - except ``PfaffianBlockDet``, which only computes the true Pfaffian on block-antidiagonal inputs). - - :param n: Matrix dimension (even); the result has shape ``(batch_size, n, n)``. - :param batch_size: Number of matrices in the batch. - :param dtype: Floating dtype of the matrices. - :param device: Device on which to allocate the matrices. - :return: A tensor of shape ``(batch_size, n, n)``. - :rtype: torch.Tensor - """ - full = torch.randn(batch_size, n, n, dtype=dtype, device=device) - return full - full.transpose(-1, -2) - - -def _synchronize(is_cuda: bool) -> None: - if is_cuda: - torch.cuda.synchronize() - - -def _median_time(fn: Callable[[], object], is_cuda: bool, n_repeats: int = 3) -> float: - fn() # warm-up - _synchronize(is_cuda) - timings = [] - for _ in range(n_repeats): - _synchronize(is_cuda) - start = time.perf_counter() - fn() - _synchronize(is_cuda) - timings.append(time.perf_counter() - start) - return float(np.median(timings)) - - -def _peak_memory(fn: Callable[[], object], is_cuda: bool) -> float: - # On CUDA this is the true peak; on CPU it is the profiler-reported allocated bytes. - if is_cuda: - torch.cuda.reset_peak_memory_stats() - fn() - torch.cuda.synchronize() - return float(torch.cuda.max_memory_allocated()) - with profile(activities=[ProfilerActivity.CPU], profile_memory=True) as prof: - fn() - return float(sum(e.cpu_memory_usage for e in prof.key_averages() if e.cpu_memory_usage > 0)) - - -def _forward_call(strategy: Strategy, matrix: torch.Tensor) -> torch.Tensor: - return strategy.apply(matrix) - - -def _forward_backward_call(strategy: Strategy, matrix: torch.Tensor) -> torch.Tensor: - grad_matrix = matrix.detach().clone().requires_grad_(True) - strategy.apply(grad_matrix).sum().backward() - return grad_matrix - - -def benchmark_strategies( - strategies: list[Strategy], - sizes_n: list[int], - batch_size: int, - device: str = "cpu", - n_seeds: int = 20, - n_repeats: int = 3, -) -> pd.DataFrame: - """ - Benchmark forward/backward time and memory of each strategy over several random seeds. - - Returns a tidy DataFrame with one row per (strategy, dimension, seed) combination and one - column per metric. Pass it directly to :func:`plot_results` or use pandas/seaborn to - build custom views. - - :param strategies: The strategy classes to benchmark (each exposes ``NAME`` and ``apply``). - :param sizes_n: Matrix dimensions to sweep (even integers); each yields ``n x n`` matrices. - :param batch_size: Number of matrices per benchmarked batch. - :param device: Device on which to run the benchmark. - :param n_seeds: Number of random seeds used to build the confidence intervals. - :param n_repeats: Number of timed repeats per seed (the median is kept). - :return: A DataFrame with columns ``strategy``, ``dimension``, ``seed``, and one column per - metric in :data:`METRICS`. - :rtype: pandas.DataFrame - """ - is_cuda = device == "cuda" - records = [] - p_bar = tqdm(total=len(sizes_n) * len(strategies) * n_seeds, desc="Benchmarking strategies") - for n in sizes_n: - for seed in range(n_seeds): - torch.manual_seed(seed) - # PfaffianBlockDet only returns the true Pfaffian on block-antidiagonal inputs; every - # other strategy is valid on any skew matrix. - block_matrix = make_block_antidiagonal(n, batch_size, dtype=torch.float32, device=device) - random_matrix = make_random_skew(n, batch_size, dtype=torch.float32, device=device) - for strategy in strategies: - matrix = block_matrix if strategy is PfaffianBlockDet else random_matrix - p_bar.set_description(f"Benchmarking {strategy.NAME:^30} (n: {n:^5} | seed: {seed:^5})") - forward_time = _median_time(lambda: _forward_call(strategy, matrix), is_cuda, n_repeats) - full_time = _median_time(lambda: _forward_backward_call(strategy, matrix), is_cuda, n_repeats) - records.append( - { - "strategy": strategy.NAME, - "dimension": n, - "seed": seed, - "forward_time": forward_time, - "backward_time": max(full_time - forward_time, 0.0), - "forward_memory": _peak_memory(lambda: _forward_call(strategy, matrix), is_cuda), - "forward_backward_memory": _peak_memory( - lambda: _forward_backward_call(strategy, matrix), is_cuda - ), - } - ) - p_bar.update(1) - p_bar.close() - return pd.DataFrame(records) - - -def plot_results(results: pd.DataFrame, strategies: list[Strategy], batch_size: int, device: str = "cpu") -> plt.Figure: - """ - Plot the benchmark results as a 2x2 grid of time and memory panels with 95% CI bands. - - :param results: The DataFrame returned by :func:`benchmark_strategies`. - :param strategies: The strategy classes that were benchmarked. - :param batch_size: Batch size used for the benchmark (shown in the title). - :param device: Device used for the benchmark (shown in the title and memory label). - :return: The matplotlib figure. - :rtype: matplotlib.figure.Figure - """ - memory_label = "peak memory (bytes, CUDA)" if device == "cuda" else "allocated bytes (CPU)" - panels = [ - ("forward_time", "Forward time", "time [s]"), - ("backward_time", "Backward time", "time [s]"), - ("forward_memory", "Forward memory", memory_label), - ("forward_backward_memory", "Forward + backward memory", memory_label), - ] - - df_long = results.melt( - id_vars=["strategy", "dimension", "seed"], - value_vars=list(METRICS), - var_name="metric", - value_name="value", - ) - - fig, axes = plt.subplots(2, 2, figsize=(12, 9)) - for ax, (metric_key, title, ylabel) in zip(axes.flat, panels): - subset = df_long[df_long["metric"] == metric_key] - sns.lineplot(data=subset, x="dimension", y="value", hue="strategy", marker="o", ax=ax) - ax.set_title(title) - ax.set_xlabel("matrix dimension") - ax.set_ylabel(ylabel) - ax.set_xscale("log", base=2) - ax.set_yscale("log") - ax.grid(True, which="both", linestyle=":", alpha=0.5) - - fig.suptitle(f"Pfaffian strategies benchmark (batch_size={batch_size}, device={device}, 95% CI over seeds)") - fig.tight_layout() - return fig diff --git a/notebooks/strategies_benchmark.ipynb b/notebooks/strategies_benchmark.ipynb deleted file mode 100644 index 4bdeb88..0000000 --- a/notebooks/strategies_benchmark.ipynb +++ /dev/null @@ -1,363 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "56c973ab", - "metadata": {}, - "source": "# Benchmarking the Pfaffian strategies\n\nThis notebook benchmarks the available Pfaffian strategies in terms of **time** and **memory** for both the **forward** and **backward** passes.\n\nFive strategies are compared:\n\n- `PfaffianFDBPf`: computes the Pfaffian from `sqrt(|det(A)|)` with a custom **analytic** backward. Valid for any skew-symmetric matrix.\n- `PfaffianBlockDet`: computes the Pfaffian from the determinant of the upper-right block, with a custom analytic backward.\n- `PfaffianDet`: a reference baseline that also computes `pf = sqrt(|det(A)|)` but differentiates straight through `det`/`sqrt` with **plain autograd** (no custom backward), to expose the cost of naive autodiff against the analytic backward of `PfaffianFDBPf`.\n- `PfaffianParlettReid`: computes the **signed** Pfaffian via batched Parlett-Reid skew-tridiagonalization, with a custom analytic backward. Valid for any skew-symmetric matrix.\n- `RustPfaffianParlettReid`: the same signed Parlett-Reid forward implemented in Rust (PyO3), with the analytic PyTorch backward. Available when the native extension is built.\n\nEach strategy is invoked through `Strategy.apply(matrix)`.\n\nFor each strategy and matrix size we report, **averaged over 20 random seeds with 95% confidence intervals**:\n\n- the median forward time,\n- the median backward time,\n- the forward peak memory,\n- the forward + backward peak memory." - }, - { - "cell_type": "markdown", - "id": "55b95a09", - "metadata": {}, - "source": "## Validity note\n\n`PfaffianBlockDet`'s forward only returns the *true* Pfaffian for **block-antidiagonal** skew matrices of the form\n\n$$ A = \\begin{pmatrix} 0 & B \\\\ -B^{T} & 0 \\end{pmatrix}. $$\n\nSo when it is benchmarked, `PfaffianBlockDet` is fed block-antidiagonal inputs, the only shape on which it is valid. Every other strategy is valid on **any** skew-symmetric matrix, so those are benchmarked on **general (dense) random skew-symmetric matrices** — a representative, unstructured workload. Each strategy is therefore measured on an input it computes correctly." - }, - { - "cell_type": "code", - "id": "657871cca9161529", - "metadata": { - "ExecuteTime": { - "end_time": "2026-06-11T16:23:48.414931740Z", - "start_time": "2026-06-11T16:23:47.000678649Z" - } - }, - "source": [ - "import os\n", - "import sys\n", - "\n", - "# The helper module lives next to this notebook; ensure it is importable both when\n", - "# running the notebook directly and when it is executed during the Sphinx docs build.\n", - "sys.path.insert(0, os.getcwd())\n", - "\n", - "import torch\n", - "from _strategies_benchmark_helpers import benchmark_strategies, plot_results\n", - "\n", - "from torch_pfaffian.strategies.pfaffian_det import PfaffianDet\n", - "from torch_pfaffian.strategies.pfaffian_fdbpf import PfaffianFDBPf\n", - "from torch_pfaffian.strategies.pfaffian_parlett_reid import PfaffianParlettReid\n", - "\n", - "try:\n", - " from torch_pfaffian.strategies.pfaffian_rust_parlett_reid import RustPfaffianParlettReid\n", - "except ImportError:\n", - " RustPfaffianParlettReid = None\n", - "\n", - "strategies = [\n", - " PfaffianFDBPf,\n", - " # PfaffianBlockDet,\n", - " PfaffianDet,\n", - " PfaffianParlettReid,\n", - "]\n", - "if RustPfaffianParlettReid is not None:\n", - " strategies.append(RustPfaffianParlettReid)\n", - "\n", - "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", - "print(f\"Running benchmarks on device: {device}\")" - ], - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running benchmarks on device: cpu\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/local/USHERBROOKE/ginj2102/github/TorchPfaffian/.venv/lib/python3.14/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n" - ] - } - ], - "execution_count": 1 - }, - { - "cell_type": "markdown", - "id": "8838f08f", - "metadata": {}, - "source": [ - "## Running the benchmark\n", - "\n", - "The benchmarking and plotting logic lives in `_strategies_benchmark_helpers.py` to keep this notebook focused on the narrative. `benchmark_strategies` sweeps the matrix dimension `n` and, for every strategy, measures each metric once per seed across `n_seeds` seeds, returning the across-seed mean and the half-width of the 95% confidence interval." - ] - }, - { - "cell_type": "code", - "id": "6ace4294c6d4b34", - "metadata": { - "ExecuteTime": { - "end_time": "2026-06-11T16:45:30.960103917Z", - "start_time": "2026-06-11T16:23:48.423661244Z" - } - }, - "source": [ - "sizes_n = [2, 4, 8, 16, 32, 64, 128, 256]\n", - "batch_size = 32\n", - "n_seeds = 20\n", - "\n", - "results = benchmark_strategies(strategies, sizes_n, batch_size, device=device, n_seeds=n_seeds)\n", - "results" - ], - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Benchmarking PfaffianFDBPf (n: 2 | seed: 0 ): 0%| | 0/640 [00:00\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
strategydimensionseedforward_timebackward_timeforward_memoryforward_backward_memory
0PfaffianFDBPf200.0109240.0000004.192000e+031.990900e+04
1PfaffianDet200.0116490.0000004.056000e+031.349800e+04
2PfaffianParlettReid200.0001470.0000553.032000e+031.905000e+04
3RustPfaffianParlettReid200.0004510.0003600.000000e+001.576200e+04
4PfaffianFDBPf210.0059890.0000004.304000e+032.016500e+04
........................
635RustPfaffianParlettReid256180.0078181.2186730.000000e+001.849201e+08
636PfaffianFDBPf256190.0038080.3512908.631040e+061.851625e+08
637PfaffianDet256190.0119550.0224828.630912e+061.261957e+08
638PfaffianParlettReid256190.5630662.2152502.212422e+092.396682e+09
639RustPfaffianParlettReid256190.0069331.0718160.000000e+001.849202e+08
\n", - "

640 rows × 7 columns

\n", - "" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "execution_count": 2 - }, - { - "cell_type": "markdown", - "id": "0ad995ad", - "metadata": {}, - "source": [ - "## Results" - ] - }, - { - "cell_type": "code", - "id": "e414240b2fc6064e", - "metadata": { - "execution": { - "iopub.execute_input": "2026-06-10T18:29:48.418076Z", - "iopub.status.busy": "2026-06-10T18:29:48.417741Z", - "iopub.status.idle": "2026-06-10T18:29:49.863382Z", - "shell.execute_reply": "2026-06-10T18:29:49.862404Z" - }, - "ExecuteTime": { - "end_time": "2026-06-11T16:45:32.958826885Z", - "start_time": "2026-06-11T16:45:31.043008384Z" - } - }, - "source": [ - "fig = plot_results(results, strategies, batch_size, device=device)" - ], - "outputs": [ - { - "data": { - "text/plain": [ - "
" - ], - "image/png": "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" - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "execution_count": 3 - }, - { - "cell_type": "markdown", - "id": "8e444db9", - "metadata": {}, - "source": "## Conclusions and caveats\n\nThe figure above reports, as a function of the matrix dimension $n$, the median forward time, the median backward time, the forward peak memory, and the combined forward + backward peak memory for every strategy. The general-purpose strategies are evaluated on general random skew-symmetric matrices; `PfaffianBlockDet`, when included, is evaluated on block-antidiagonal skew matrices (the only inputs for which it is valid). Shaded bands are 95% confidence intervals over the random seeds (they are essentially invisible for memory, which is seed-independent for a fixed shape).\n\n**Memory-metric caveat.** The memory numbers depend on the device:\n\n- On **CUDA**, the reported value is a true peak obtained from `torch.cuda.reset_peak_memory_stats()` / `torch.cuda.max_memory_allocated()`.\n- On **CPU** (the continuous-integration case), no equivalent peak counter exists, so we report the **allocated bytes** measured by `torch.profiler` instead. This is an aggregate of allocations rather than a strict instantaneous peak, so CPU and CUDA memory values are not directly comparable and the absolute CPU numbers should be read as a relative indicator across strategies and sizes.\n\n`PfaffianFDBPf` and `PfaffianDet` share the same forward (`sqrt(|det(A)|)`); their difference is the backward, so the backward panels highlight the analytic custom backward against plain autograd." - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.14.0" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} From 81233666aefb308714d1a2a61e0fca0d3716b02e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=A9mie=20Gince?= <50332514+JeremieGince@users.noreply.github.com> Date: Mon, 13 Jul 2026 17:31:54 -0400 Subject: [PATCH 5/6] Add pfaffian tutorial notebook and fix docs rendering - Add a lightweight tutorial for the public `pfaffian` function that executes live during the Sphinx build (replaces the removed benchmark). - Fix index.rst placeholders () and point the Tutorials toctree at the new notebook. - Enable MyST dollarmath/amsmath and use the maintained jsDelivr MathJax build so the tutorial's LaTeX renders instead of showing as raw text. --- notebooks/tutorial.ipynb | 358 +++++++++++++++++++++++++++++++++++++++ sphinx/source/conf.py | 8 +- sphinx/source/index.rst | 12 +- 3 files changed, 369 insertions(+), 9 deletions(-) create mode 100644 notebooks/tutorial.ipynb diff --git a/notebooks/tutorial.ipynb b/notebooks/tutorial.ipynb new file mode 100644 index 0000000..7b261d7 --- /dev/null +++ b/notebooks/tutorial.ipynb @@ -0,0 +1,358 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "5024a218", + "metadata": {}, + "source": [ + "# The `pfaffian` function\n", + "\n", + "The **Pfaffian** of a $2n \\times 2n$ skew-symmetric matrix $A$ (a square matrix with\n", + "$A^{\\top} = -A$) is a polynomial in its entries, with several equivalent definitions.\n", + "\n", + "**Formal definition (sum over perfect matchings).** Let $\\Pi$ be the set of all *perfect matchings*\n", + "of $\\{1, 2, \\dots, 2n\\}$: partitions into $n$ unordered pairs\n", + "$\\alpha = \\{(i_1, j_1), \\dots, (i_n, j_n)\\}$ with every $i_k < j_k$. Then\n", + "\n", + "$$\\operatorname{Pf}(A) = \\sum_{\\alpha \\in \\Pi} \\operatorname{sgn}(\\alpha)\\, a_{i_1 j_1}\\, a_{i_2 j_2} \\cdots a_{i_n j_n},$$\n", + "\n", + "where $\\operatorname{sgn}(\\alpha)$ is the sign of the permutation that sends $(1, 2, \\dots, 2n)$ to\n", + "$(i_1, j_1, \\dots, i_n, j_n)$. Equivalently, as a sum over the full symmetric group $S_{2n}$,\n", + "\n", + "$$\\operatorname{Pf}(A) = \\frac{1}{2^n\\, n!} \\sum_{\\sigma \\in S_{2n}} \\operatorname{sgn}(\\sigma)\\, \\prod_{k=1}^{n} a_{\\sigma(2k-1)\\, \\sigma(2k)}.$$\n", + "\n", + "**Recursive definition (expansion along a row).** The Pfaffian also satisfies a Laplace-like\n", + "recursion. Writing $A_{\\hat{1}\\hat{\\jmath}}$ for the $(2n-2) \\times (2n-2)$ matrix obtained by\n", + "deleting rows and columns $1$ and $j$ from $A$,\n", + "\n", + "$$\\operatorname{Pf}(A) = \\sum_{j=2}^{2n} (-1)^{j}\\, a_{1 j}\\, \\operatorname{Pf}\\!\\big(A_{\\hat{1}\\hat{\\jmath}}\\big),$$\n", + "\n", + "with the base cases $\\operatorname{Pf} = 1$ for the empty $0 \\times 0$ matrix and\n", + "$\\operatorname{Pf}\\!\\begin{pmatrix} 0 & a \\\\ -a & 0 \\end{pmatrix} = a$ for the $2 \\times 2$ case.\n", + "\n", + "**Relation to the determinant.** All of these agree, and the Pfaffian is the *signed square root* of\n", + "the determinant:\n", + "\n", + "$$\\operatorname{Pf}(A)^2 = \\det(A).$$\n", + "\n", + "Where $\\sqrt{\\det A}$ loses the sign, the Pfaffian keeps it. `torch_pfaffian.pfaffian` computes it for\n", + "PyTorch tensors. This tutorial shows the inputs the function accepts and the outputs it returns." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4eb7785e", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-13T21:25:35.292871Z", + "iopub.status.busy": "2026-07-13T21:25:35.291863Z", + "iopub.status.idle": "2026-07-13T21:25:38.342053Z", + "shell.execute_reply": "2026-07-13T21:25:38.341040Z" + } + }, + "outputs": [], + "source": [ + "import torch\n", + "\n", + "from torch_pfaffian import pfaffian\n", + "\n", + "# Seed the RNG so the random example matrices below are reproducible.\n", + "_ = torch.manual_seed(0)" + ] + }, + { + "cell_type": "markdown", + "id": "80e28cd8", + "metadata": {}, + "source": [ + "## Input: a single skew-symmetric matrix\n", + "\n", + "The basic input is a skew-symmetric matrix of shape `(2n, 2n)`, and the output is a scalar tensor:\n", + "its Pfaffian. For a $2 \\times 2$ matrix $\\begin{pmatrix} 0 & a \\\\ -a & 0 \\end{pmatrix}$ the Pfaffian\n", + "is simply $a$." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "794e34ac", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-13T21:25:38.345122Z", + "iopub.status.busy": "2026-07-13T21:25:38.345122Z", + "iopub.status.idle": "2026-07-13T21:25:38.357785Z", + "shell.execute_reply": "2026-07-13T21:25:38.356776Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input shape : (2, 2)\n", + "output : tensor(-3.)\n" + ] + } + ], + "source": [ + "matrix = torch.tensor([[0.0, -3.0], [3.0, 0.0]])\n", + "pf = pfaffian(matrix)\n", + "\n", + "print(\"input shape :\", tuple(matrix.shape))\n", + "print(\"output :\", pf)" + ] + }, + { + "cell_type": "markdown", + "id": "03059147", + "metadata": {}, + "source": [ + "Any skew-symmetric matrix works. A quick way to build one is `A = M - M.T`, which is\n", + "skew-symmetric by construction. The defining identity $\\operatorname{Pf}(A)^2 = \\det(A)$ then\n", + "holds:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "10ebf677", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-13T21:25:38.361811Z", + "iopub.status.busy": "2026-07-13T21:25:38.360301Z", + "iopub.status.idle": "2026-07-13T21:25:38.368938Z", + "shell.execute_reply": "2026-07-13T21:25:38.368938Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pf(A) = 0.682274341583252\n", + "Pf(A) ** 2 = 0.46549826860427856\n", + "det(A) = 0.4654996395111084\n" + ] + } + ], + "source": [ + "m = torch.randn(6, 6)\n", + "a = m - m.T # skew-symmetric: a.T == -a\n", + "\n", + "pf = pfaffian(a)\n", + "print(\"Pf(A) =\", pf.item())\n", + "print(\"Pf(A) ** 2 =\", (pf**2).item())\n", + "print(\"det(A) =\", torch.linalg.det(a).item())" + ] + }, + { + "cell_type": "markdown", + "id": "a46a1565", + "metadata": {}, + "source": [ + "## Input: a batch of matrices\n", + "\n", + "Leading dimensions are treated as a batch. An input of shape `(..., 2n, 2n)` returns one Pfaffian\n", + "per matrix, with shape `(...,)`." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "bcfda368", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-13T21:25:38.372977Z", + "iopub.status.busy": "2026-07-13T21:25:38.372977Z", + "iopub.status.idle": "2026-07-13T21:25:38.380618Z", + "shell.execute_reply": "2026-07-13T21:25:38.380113Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input shape : (4, 8, 8)\n", + "output shape: (4,)\n", + "output : tensor([-22.6322, 11.7543, 5.5873, -16.7749])\n" + ] + } + ], + "source": [ + "batch = torch.randn(4, 8, 8)\n", + "batch = batch - batch.transpose(-1, -2) # skew-symmetric in the last two dims\n", + "\n", + "pfs = pfaffian(batch)\n", + "print(\"input shape :\", tuple(batch.shape))\n", + "print(\"output shape:\", tuple(pfs.shape))\n", + "print(\"output :\", pfs)" + ] + }, + { + "cell_type": "markdown", + "id": "3bdd646c", + "metadata": {}, + "source": [ + "## Input dtype: real or complex\n", + "\n", + "The Pfaffian is defined for complex skew-symmetric matrices too. The output matches the input's\n", + "dtype: a real input gives a real Pfaffian, a complex input gives a complex one." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7f230a25", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-13T21:25:38.384451Z", + "iopub.status.busy": "2026-07-13T21:25:38.383930Z", + "iopub.status.idle": "2026-07-13T21:25:38.392680Z", + "shell.execute_reply": "2026-07-13T21:25:38.391647Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "real input -> torch.float32 | -3.7162179946899414\n", + "complex input -> torch.complex64 | (-0.5062580108642578+0.7343237996101379j)\n" + ] + } + ], + "source": [ + "real = torch.randn(4, 4)\n", + "real = real - real.T\n", + "\n", + "complex_matrix = torch.randn(4, 4, dtype=torch.complex64)\n", + "complex_matrix = complex_matrix - complex_matrix.transpose(-1, -2)\n", + "\n", + "print(\"real input ->\", pfaffian(real).dtype, \"|\", pfaffian(real).item())\n", + "print(\"complex input ->\", pfaffian(complex_matrix).dtype, \"|\", pfaffian(complex_matrix).item())" + ] + }, + { + "cell_type": "markdown", + "id": "9f1d6ffe", + "metadata": {}, + "source": [ + "## Output: signed value or magnitude\n", + "\n", + "By default `pfaffian` returns the **signed** Pfaffian. Pass `sign=False` to get only its magnitude\n", + "$|\\operatorname{Pf}(A)|$, which takes a cheaper determinant-based path when the sign is not needed.\n", + "Here the $2 \\times 2$ matrix has a negative Pfaffian, so the two differ by the sign:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0ec435e8", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-13T21:25:38.395300Z", + "iopub.status.busy": "2026-07-13T21:25:38.395300Z", + "iopub.status.idle": "2026-07-13T21:25:38.401040Z", + "shell.execute_reply": "2026-07-13T21:25:38.401040Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "signed (default) : -3.0\n", + "magnitude : 3.0\n" + ] + } + ], + "source": [ + "print(\"signed (default) :\", pfaffian(matrix).item())\n", + "print(\"magnitude :\", pfaffian(matrix, sign=False).item())" + ] + }, + { + "cell_type": "markdown", + "id": "b4fd3feb", + "metadata": {}, + "source": [ + "## Output: differentiable\n", + "\n", + "If the input requires gradients, so does the output: `pfaffian` is fully compatible with\n", + "`torch.autograd`, so it composes with any PyTorch computation and backpropagates." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "08bba05a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-13T21:25:38.403668Z", + "iopub.status.busy": "2026-07-13T21:25:38.403668Z", + "iopub.status.idle": "2026-07-13T21:25:38.409793Z", + "shell.execute_reply": "2026-07-13T21:25:38.409266Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "input.requires_grad : True\n", + "gradient shape : (6, 6)\n" + ] + } + ], + "source": [ + "a_grad = a.clone().requires_grad_(True)\n", + "pfaffian(a_grad).backward()\n", + "\n", + "print(\"input.requires_grad :\", a_grad.requires_grad)\n", + "print(\"gradient shape :\", tuple(a_grad.grad.shape))" + ] + }, + { + "cell_type": "markdown", + "id": "69e60b67", + "metadata": {}, + "source": [ + "## Summary\n", + "\n", + "| Input to `pfaffian` | Output |\n", + "| --- | --- |\n", + "| skew-symmetric matrix `(2n, 2n)` | scalar Pfaffian |\n", + "| batch `(..., 2n, 2n)` | Pfaffians of shape `(...,)` |\n", + "| real or complex dtype | Pfaffian of the same dtype |\n", + "| `requires_grad=True` | differentiable output |\n", + "| CPU or CUDA tensor | result on the same device |\n", + "\n", + "In every case the output shares the input's dtype, device, and backend, and returns a value whose\n", + "square is $\\det(A)$." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.11" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/sphinx/source/conf.py b/sphinx/source/conf.py index cf7d59f..a8b5bd5 100644 --- a/sphinx/source/conf.py +++ b/sphinx/source/conf.py @@ -92,6 +92,10 @@ def join(dir): nb_execution_mode = "force" nb_execution_timeout = 300 +# Enable dollar-delimited ($...$, $$...$$) and amsmath (e.g. pmatrix) math in MyST markdown and +# notebook markdown cells, so the LaTeX in the tutorial renders instead of showing as raw text. +myst_enable_extensions = ["amsmath", "dollarmath"] + templates_path = ["_templates"] exclude_patterns = [] @@ -104,8 +108,8 @@ def join(dir): # html_css_files = [ # 'css/float_right.css', # ] -# mathjax_path = "https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js" -mathjax_path = "https://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML" +# The old cdn.mathjax.org host was retired in 2017; use the maintained MathJax 3 build on jsDelivr. +mathjax_path = "https://cdn.jsdelivr.net/npm/mathjax@3/es5/tex-mml-chtml.js" latex_engine = "xelatex" latex_elements = { "preamble": r"\usepackage{physics}" diff --git a/sphinx/source/index.rst b/sphinx/source/index.rst index 360fc34..d3f634e 100644 --- a/sphinx/source/index.rst +++ b/sphinx/source/index.rst @@ -1,10 +1,8 @@ -.. documentation master file, created by - sphinx-quickstart on Thu Sep 1 13:05:39 2022. - You can adapt this file completely to your liking, but it should at least - contain the root `toctree` directive. +.. TorchPfaffian documentation master file. + It should contain the root `toctree` directive that ties the pages together. -Welcome to 's documentation! -====================================== +Welcome to TorchPfaffian's documentation! +========================================= .. toctree:: :maxdepth: 4 @@ -16,7 +14,7 @@ Welcome to 's documentation! :maxdepth: 4 :caption: Tutorials: - notebooks/strategies_benchmark + notebooks/tutorial .. toctree:: :maxdepth: 4 From b1e5b0db3b0d7b2230d29fdcb876451b4ddc4cc5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=A9mie=20Gince?= <50332514+JeremieGince@users.noreply.github.com> Date: Mon, 13 Jul 2026 17:40:20 -0400 Subject: [PATCH 6/6] grant write access to docs.yml --- .github/workflows/docs.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml index 6dfd348..c050dc1 100644 --- a/.github/workflows/docs.yml +++ b/.github/workflows/docs.yml @@ -4,6 +4,9 @@ on: push: branches: ["main", "dev"] +permissions: + contents: write + jobs: Build-Docs: