tensorsig 0.1.0__tar.gz

tensorsig-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Erlend Aune
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

tensorsig-0.1.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: tensorsig
+Version: 0.1.0
+Summary: Differentiable tensor signatures, offset-coded signatures, and log-signatures for PyTorch.
+Keywords: deep-learning,pytorch,signatures,time-series
+Author: Erlend Aune
+Author-email: Erlend Aune <erlend.aune@pm.me>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Dist: torch>=2.14
+Requires-Python: >=3.14
+Project-URL: Documentation, https://froskekongen.github.io/tensorsig/
+Project-URL: Issues, https://github.com/Froskekongen/tensorsig/issues
+Project-URL: Repository, https://github.com/Froskekongen/tensorsig
+Project-URL: Releases, https://github.com/Froskekongen/tensorsig/releases
+Description-Content-Type: text/markdown
+
+# tensorsig
+
+`tensorsig` provides differentiable signature, log-signature, and offset-coded
+signature features for PyTorch.
+
+The first release is being prepared. The public API may change between `0.x`
+releases.
+
+## Installation
+
+`tensorsig` requires Python 3.14 or newer and PyTorch 2.14 or newer.
+
+Until the first PyPI release, install from a checkout of this repository:
+
+```console
+python -m pip install .
+```
+
+After publication, install with `python -m pip install tensorsig`.
+
+## Quick start
+
+```python
+import torch
+
+from tensorsig.classical.signatures import log_signature, signature
+
+path = torch.tensor(
+    [[[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [2.0, 1.0]]],
+    dtype=torch.float64,
+)
+
+first_turn = path[:, :3]
+sig = signature(first_turn, depth=2)
+logsig = log_signature(first_turn, depth=2)
+
+assert sig.shape == (1, 6)
+assert logsig.shape == (1, 3)
+torch.testing.assert_close(
+    sig,
+    torch.tensor([[1.0, 1.0, 0.5, 1.0, 0.0, 0.5]], dtype=path.dtype),
+)
+torch.testing.assert_close(
+    logsig,
+    torch.tensor([[1.0, 1.0, 0.5]], dtype=path.dtype),
+)
+```
+
+Start with the practitioner guides to
+[signatures and logsignatures](https://froskekongen.github.io/tensorsig/signatures/).
+The complete callable surface is in the
+[API reference](https://froskekongen.github.io/tensorsig/api/).
+The hosted documentation will become available with the first release. Until
+then, use the local preview described under [Development](#development).
+
+## Choosing local features
+
+| Need | Start with |
+| --- | --- |
+| Classical logsignatures after path lifts | `tensorsig.augmentations` followed by `classical.windows.WindowedLogSignature` in `torch.nn.Sequential` |
+| Signatures or logsignatures retaining local offset information | `offset_coded_signatures.plans.LocalRealization` with a `codes.OffsetCode` |
+| Scalar polynomials in physical increments | `offset_coded_signatures.plans.compile_polynomial` |
+| Apply a compiled local plan to a path | `offset_coded_signatures.layers.LocalFeatures` or `LocalLinear` |
+| Explicit quotient window algorithms on increment streams | `offset_coded_signatures.windows.WindowLogSignature` |
+
+The [offset-coded signatures guide](https://froskekongen.github.io/tensorsig/offset_coded_signatures/)
+shows these constructions and their input conventions. Offset-coded windows
+count increments; classical windows count points. Path augmentations are shared
+across both families and run before window extraction.
+
+## Citing
+
+If you use `tensorsig`, cite the software version or commit you used. Citation
+metadata is provided in
+[`CITATION.cff`](https://github.com/Froskekongen/tensorsig/blob/main/CITATION.cff),
+which GitHub exposes through **Cite this repository** in APA and BibTeX formats.
+
+Zenodo DOI links will be added after the first archived release. For
+reproducible work, use that release's version-specific DOI; use the concept
+DOI when referring to `tensorsig` independently of a particular version.
+
+## Development
+
+The project uses [uv](https://docs.astral.sh/uv/) and keeps its development
+environment in the committed `uv.lock`. Python requirements are defined in
+`pyproject.toml`.
+
+```console
+uv sync --locked
+uv run ruff check .
+uv run ruff format --check .
+uv run pytest -q
+```
+
+Generate and strictly build the complete HTML documentation with:
+
+```console
+uv run python scripts/generate_docs.py
+```
+
+To build, start a local preview, and open it in your browser:
+
+```console
+uv run python scripts/generate_docs.py --serve
+```
+
+The HTML site is written to `site/`. Stop the preview with Ctrl+C. After editing
+Python guides or docstrings, rerun the script to regenerate the documentation.
+
+Validate a prepared release with `scripts/release.sh --check X.Y.Z`, then publish
+it from clean `main` with `scripts/release.sh X.Y.Z`. Keep the package version and
+`CITATION.cff` version aligned, and set `date-released` in `CITATION.cff` to the
+actual release date before running the release checks. GitHub Actions publishes
+to PyPI and deploys the documentation when the GitHub Release is published. The
+PyPI Trusted Publisher and GitHub Pages Actions source must be configured before
+the first release.
+
+## License
+
+`tensorsig` is released under the
+[MIT License](https://github.com/Froskekongen/tensorsig/blob/main/LICENSE).

tensorsig-0.1.0/README.md

@@ -0,0 +1,121 @@
+# tensorsig
+
+`tensorsig` provides differentiable signature, log-signature, and offset-coded
+signature features for PyTorch.
+
+The first release is being prepared. The public API may change between `0.x`
+releases.
+
+## Installation
+
+`tensorsig` requires Python 3.14 or newer and PyTorch 2.14 or newer.
+
+Until the first PyPI release, install from a checkout of this repository:
+
+```console
+python -m pip install .
+```
+
+After publication, install with `python -m pip install tensorsig`.
+
+## Quick start
+
+```python
+import torch
+
+from tensorsig.classical.signatures import log_signature, signature
+
+path = torch.tensor(
+    [[[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [2.0, 1.0]]],
+    dtype=torch.float64,
+)
+
+first_turn = path[:, :3]
+sig = signature(first_turn, depth=2)
+logsig = log_signature(first_turn, depth=2)
+
+assert sig.shape == (1, 6)
+assert logsig.shape == (1, 3)
+torch.testing.assert_close(
+    sig,
+    torch.tensor([[1.0, 1.0, 0.5, 1.0, 0.0, 0.5]], dtype=path.dtype),
+)
+torch.testing.assert_close(
+    logsig,
+    torch.tensor([[1.0, 1.0, 0.5]], dtype=path.dtype),
+)
+```
+
+Start with the practitioner guides to
+[signatures and logsignatures](https://froskekongen.github.io/tensorsig/signatures/).
+The complete callable surface is in the
+[API reference](https://froskekongen.github.io/tensorsig/api/).
+The hosted documentation will become available with the first release. Until
+then, use the local preview described under [Development](#development).
+
+## Choosing local features
+
+| Need | Start with |
+| --- | --- |
+| Classical logsignatures after path lifts | `tensorsig.augmentations` followed by `classical.windows.WindowedLogSignature` in `torch.nn.Sequential` |
+| Signatures or logsignatures retaining local offset information | `offset_coded_signatures.plans.LocalRealization` with a `codes.OffsetCode` |
+| Scalar polynomials in physical increments | `offset_coded_signatures.plans.compile_polynomial` |
+| Apply a compiled local plan to a path | `offset_coded_signatures.layers.LocalFeatures` or `LocalLinear` |
+| Explicit quotient window algorithms on increment streams | `offset_coded_signatures.windows.WindowLogSignature` |
+
+The [offset-coded signatures guide](https://froskekongen.github.io/tensorsig/offset_coded_signatures/)
+shows these constructions and their input conventions. Offset-coded windows
+count increments; classical windows count points. Path augmentations are shared
+across both families and run before window extraction.
+
+## Citing
+
+If you use `tensorsig`, cite the software version or commit you used. Citation
+metadata is provided in
+[`CITATION.cff`](https://github.com/Froskekongen/tensorsig/blob/main/CITATION.cff),
+which GitHub exposes through **Cite this repository** in APA and BibTeX formats.
+
+Zenodo DOI links will be added after the first archived release. For
+reproducible work, use that release's version-specific DOI; use the concept
+DOI when referring to `tensorsig` independently of a particular version.
+
+## Development
+
+The project uses [uv](https://docs.astral.sh/uv/) and keeps its development
+environment in the committed `uv.lock`. Python requirements are defined in
+`pyproject.toml`.
+
+```console
+uv sync --locked
+uv run ruff check .
+uv run ruff format --check .
+uv run pytest -q
+```
+
+Generate and strictly build the complete HTML documentation with:
+
+```console
+uv run python scripts/generate_docs.py
+```
+
+To build, start a local preview, and open it in your browser:
+
+```console
+uv run python scripts/generate_docs.py --serve
+```
+
+The HTML site is written to `site/`. Stop the preview with Ctrl+C. After editing
+Python guides or docstrings, rerun the script to regenerate the documentation.
+
+Validate a prepared release with `scripts/release.sh --check X.Y.Z`, then publish
+it from clean `main` with `scripts/release.sh X.Y.Z`. Keep the package version and
+`CITATION.cff` version aligned, and set `date-released` in `CITATION.cff` to the
+actual release date before running the release checks. GitHub Actions publishes
+to PyPI and deploys the documentation when the GitHub Release is published. The
+PyPI Trusted Publisher and GitHub Pages Actions source must be configured before
+the first release.
+
+## License
+
+`tensorsig` is released under the
+[MIT License](https://github.com/Froskekongen/tensorsig/blob/main/LICENSE).

tensorsig-0.1.0/pyproject.toml

@@ -0,0 +1,75 @@
+[project]
+name = "tensorsig"
+version = "0.1.0"
+description = "Differentiable tensor signatures, offset-coded signatures, and log-signatures for PyTorch."
+readme = "README.md"
+requires-python = ">=3.14"
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = [
+    "deep-learning",
+    "pytorch",
+    "signatures",
+    "time-series",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = ["torch>=2.14"]
+
+[[project.authors]]
+name = "Erlend Aune"
+email = "erlend.aune@pm.me"
+
+[project.urls]
+Documentation = "https://froskekongen.github.io/tensorsig/"
+Issues = "https://github.com/Froskekongen/tensorsig/issues"
+Repository = "https://github.com/Froskekongen/tensorsig"
+Releases = "https://github.com/Froskekongen/tensorsig/releases"
+
+[dependency-groups]
+docs = [
+    "griffelib>=2.2.0",
+    "jupytext>=1.17.3",
+    "mkdocstrings[python]>=0.25.0",
+    "zensical>=0.0.57",
+]
+test = [
+    { include-group = "docs" },
+    "numpy>=2.3",
+    "pytest>=9.0.1",
+    "ruff>=0.14.8",
+]
+dev = [
+    { include-group = "test" },
+    "esig>=1.0.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.13.6,<0.14.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+source-exclude = [
+    "/src/tensorsig/experimental",
+    "*.sqlite",
+    "*.sqlite-*",
+    ".DS_Store",
+    "/src/**/*.md",
+]
+
+[tool.ruff.lint]
+select = [
+    "E4",
+    "E7",
+    "E9",
+    "F",
+]

tensorsig-0.1.0/pyproject.toml.orig

@@ -0,0 +1,66 @@
+[project]
+name = "tensorsig"
+version = "0.1.0"
+description = "Differentiable tensor signatures, offset-coded signatures, and log-signatures for PyTorch."
+readme = "README.md"
+requires-python = ">=3.14"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+    { name = "Erlend Aune", email = "erlend.aune@pm.me" },
+]
+keywords = ["deep-learning", "pytorch", "signatures", "time-series"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Mathematics",
+]
+dependencies = [
+    "torch>=2.14",
+]
+
+[project.urls]
+Documentation = "https://froskekongen.github.io/tensorsig/"
+Issues = "https://github.com/Froskekongen/tensorsig/issues"
+Repository = "https://github.com/Froskekongen/tensorsig"
+Releases = "https://github.com/Froskekongen/tensorsig/releases"
+
+[dependency-groups]
+docs = [
+    "griffelib>=2.2.0",
+    "jupytext>=1.17.3",
+    "mkdocstrings[python]>=0.25.0",
+    "zensical>=0.0.57",
+]
+test = [
+    { include-group = "docs" },
+    "numpy>=2.3",
+    "pytest>=9.0.1",
+    "ruff>=0.14.8",
+]
+dev = [
+    { include-group = "test" },
+    "esig>=1.0.0",
+]
+
+[build-system]
+requires = ["uv_build>=0.13.6,<0.14.0"]
+build-backend = "uv_build"
+
+[tool.uv.build-backend]
+source-exclude = [
+    "/src/tensorsig/experimental",
+    "*.sqlite",
+    "*.sqlite-*",
+    ".DS_Store",
+    "/src/**/*.md",
+]
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F"]

tensorsig-0.1.0/src/tensorsig/__init__.py

@@ -0,0 +1,24 @@
+"""Differentiable tensor-signature tools for PyTorch.
+
+The public API is organized into domain modules:
+
+- ``tensorsig.classical`` for path signatures and log-signatures;
+- ``tensorsig.augmentations`` for composable path lifts;
+- ``tensorsig.algebra`` for Hall and Lyndon basis utilities;
+- ``tensorsig.tensor_ops`` for low-level tensor-algebra operations; and
+- ``tensorsig.offset_coded_signatures`` for local coded features.
+"""
+
+from . import classical as classical
+from . import augmentations as augmentations
+from . import algebra as algebra
+from . import tensor_ops as tensor_ops
+from . import offset_coded_signatures as offset_coded_signatures
+
+__all__ = [
+    "classical",
+    "augmentations",
+    "algebra",
+    "tensor_ops",
+    "offset_coded_signatures",
+]

tensorsig-0.1.0/src/tensorsig/algebra/__init__.py

@@ -0,0 +1,17 @@
+"""Free Lie coordinates and Eulerian tensor-word projection.
+
+Hall trees and Lyndon words are two coordinate systems for the same truncated
+free Lie algebra. Their modules expose basis construction, dimensions, and
+stable human-readable coordinate labels; numerical log-signature evaluation
+lives in ``tensorsig.classical.signatures``.
+"""
+
+from . import hall as hall
+from . import lyndon as lyndon
+from . import eulerian as eulerian
+
+__all__ = [
+    "hall",
+    "lyndon",
+    "eulerian",
+]

tensorsig-0.1.0/src/tensorsig/algebra/bch_coefficients.py

@@ -0,0 +1,135 @@
+"""Simple BCH coefficient generator (tensor-algebra series with exact rationals).
+
+This module provides functions to generate Baker-Campbell-Hausdorff coefficients
+using exact rational arithmetic. It computes word -> rational coefficient mappings
+for log(prod_i exp(E_i)), where E_i are the one-letter generators (1..width),
+truncated to a given depth.
+
+This is intended for verification/offline coefficient generation (tests, debug),
+not runtime. Arithmetic uses Python's Fractions and concatenation; no external
+CAS is required.
+"""
+
+from __future__ import annotations
+
+import math
+from fractions import Fraction
+from typing import Dict, Tuple
+
+Word = Tuple[int, ...]
+CoeffMap = Dict[Word, Fraction]
+
+
+def _mul_series(a: CoeffMap, b: CoeffMap, depth: int) -> CoeffMap:
+    """Cauchy product of two series, truncating words beyond `depth`."""
+    out: CoeffMap = {}
+    for w1, c1 in a.items():
+        for w2, c2 in b.items():
+            w = w1 + w2
+            if len(w) > depth:
+                continue
+            out[w] = out.get(w, Fraction(0)) + c1 * c2
+    return out
+
+
+def _pow_series(a: CoeffMap, n: int, depth: int) -> CoeffMap:
+    """Binary exponentiation of a series (non-negative integer power)."""
+    if n < 0:
+        raise ValueError("Series exponent must be non-negative.")
+    if n == 0:
+        return {(): Fraction(1)}
+    result: CoeffMap = {(): Fraction(1)}
+    base = a
+    exp = n
+    while exp:
+        if exp & 1:
+            result = _mul_series(result, base, depth)
+        exp //= 2
+        if exp:
+            base = _mul_series(base, base, depth)
+    return result
+
+
+def _exp_single(letter: int, depth: int) -> CoeffMap:
+    """Truncated exp(e_letter) = sum_{k>=0} e_letter^k / k! up to `depth`."""
+    out: CoeffMap = {(): Fraction(1)}
+    word = (letter,)
+    for k in range(1, depth + 1):
+        out[word * k] = Fraction(1, math.factorial(k))
+    return out
+
+
+def _log_series(series: CoeffMap, depth: int) -> CoeffMap:
+    """Formal log of a series with constant term 1, truncated to `depth`."""
+    if series.get((), None) != 1:
+        raise ValueError("log_series expects identity coefficient 1.")
+    U = dict(series)
+    U.pop((), None)
+    result: CoeffMap = {}
+    for n in range(1, depth + 1):
+        term = _pow_series(U, n, depth)
+        sign = -1 if (n % 2 == 0) else 1
+        coeff = Fraction(sign, n)
+        for w, c in term.items():
+            if len(w) == 0:
+                continue
+            result[w] = result.get(w, Fraction(0)) + coeff * c
+    return result
+
+
+def bch_coeffs(width: int, depth: int) -> CoeffMap:
+    """Coefficients for log(prod_{i=1}^width exp(e_i)) truncated to `depth`.
+
+    Computes the exact rational coefficients for the Baker-Campbell-Hausdorff
+    expansion of the product of exponentials of generators, truncated to the
+    specified depth.
+
+    Parameters
+    ----------
+    width : int
+        Number of generators (path dimension). Must be >= 1.
+    depth : int
+        Truncation depth. Must be >= 1.
+
+    Returns
+    -------
+    CoeffMap
+        Dictionary mapping tensor-algebra words (tuples of generator indices)
+        to rational coefficients (Fraction objects) in the series expansion.
+        Words are tuples of integers from 1 to width, representing the
+        generators in order.
+
+    Examples
+    --------
+    >>> from tensorsig.algebra.bch_coefficients import bch_coeffs
+    >>> from fractions import Fraction
+    >>>
+    >>> # BCH coefficients for width=2, depth=2
+    >>> coeffs = bch_coeffs(2, 2)
+    >>> # Check some expected coefficients
+    >>> coeffs[(1,)] == Fraction(1, 1)
+    True
+    >>> coeffs[(2,)] == Fraction(1, 1)
+    True
+    >>> # The bracket [1, 2] has coefficient 1/2, split across (1, 2) and (2, 1)
+    >>> coeffs.get((1, 2), 0) == Fraction(1, 2)
+    True
+    >>> coeffs.get((2, 1), 0) == Fraction(-1, 2)
+    True
+    >>> coeffs.get((1, 2), 0) - coeffs.get((2, 1), 0) == Fraction(1, 1)
+    True
+    >>>
+    >>> # BCH coefficients for width=3, depth=2
+    >>> coeffs = bch_coeffs(3, 2)
+    >>> # Three degree-1 generators
+    >>> len([w for w in coeffs.keys() if len(w) == 1])
+    3
+    """
+    if depth < 1 or width < 1:
+        return {}
+    # Multiply exp of each generator in order
+    prod: CoeffMap = {(): Fraction(1)}
+    for letter in range(1, width + 1):
+        prod = _mul_series(prod, _exp_single(letter, depth), depth)
+    log_series = _log_series(prod, depth)
+    return {w: c for w, c in log_series.items() if len(w) <= depth and c != 0}

tensorsig-0.1.0/src/tensorsig/algebra/eulerian.py

@@ -0,0 +1,68 @@
+"""First Eulerian idempotent on homogeneous tensor words.
+
+The exact permutation coefficients are shared by dense tensor projection and
+quotient enveloping-algebra readouts. Projection preserves tensor dtype,
+device, and autograd; the permutation formula has factorial cost in depth.
+"""
+
+from fractions import Fraction
+from functools import lru_cache
+from itertools import permutations
+from math import comb
+
+import torch
+from torch import Tensor
+
+
+__all__ = ["eulerian_permutations", "eulerian_project_columns"]
+
+
+@lru_cache(maxsize=None)
+def eulerian_permutations(
+    length: int,
+) -> tuple[tuple[tuple[int, ...], Fraction], ...]:
+    """Return permutations and exact first-Eulerian-idempotent coefficients.
+
+    ``length`` is a non-negative integer. Degree zero has an empty schedule,
+    since the first Eulerian idempotent annihilates the scalar unit.
+    """
+    if not isinstance(length, int) or isinstance(length, bool) or length < 0:
+        raise ValueError("length must be a non-negative integer.")
+    if length == 0:
+        return ()
+    schedule = []
+    for permutation in permutations(range(length)):
+        descents = sum(
+            left > right for left, right in zip(permutation, permutation[1:])
+        )
+        schedule.append(
+            (
+                permutation,
+                Fraction((-1) ** descents, length * comb(length - 1, descents)),
+            )
+        )
+    return tuple(schedule)
+
+
+def eulerian_project_columns(matrix: Tensor, width: int, depth: int) -> Tensor:
+    """Apply the first Eulerian idempotent to tensor-word columns.
+
+    ``matrix`` has shape ``(width**depth, columns)`` in lexicographic word
+    order. The columns are independent inputs, and the result has the same
+    shape. Width and depth must be positive integers.
+    """
+    for name, value in (("width", width), ("depth", depth)):
+        if not isinstance(value, int) or isinstance(value, bool) or value < 1:
+            raise ValueError(f"{name} must be a positive integer.")
+    expected_rows = width**depth
+    if matrix.ndim != 2 or matrix.shape[0] != expected_rows:
+        raise ValueError(
+            f"Expected matrix shape ({expected_rows}, columns), got {tuple(matrix.shape)}."
+        )
+    if not matrix.dtype.is_floating_point:
+        raise ValueError("matrix must have a floating-point dtype.")
+    tensor = matrix.reshape(*([width] * depth), matrix.shape[1])
+    projected = torch.zeros_like(tensor)
+    for permutation, coefficient in eulerian_permutations(depth):
+        projected = projected + float(coefficient) * tensor.permute(*permutation, depth)
+    return projected.reshape(expected_rows, matrix.shape[1])