SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2602.10195 · 2026

Enhanced Scale Generalization and Interpretability via Conformal Algebra

Edward Hirst, Trương Huy

arXiv · PDF · Open in the Atlas

Code that ran

11 of 20 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 0 have no contract verdict; 11 failures of our instrument; 9 no recorded run), measured 2026-11-22; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2602.10195.json · badge: /api/ran/2602.10195.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
VersorAI/Versor community
Papers with Code archive
11 ran · 9 no recorded run
FunctionStatusWhere it lives
complex_matmul_broadcast Ran
ran; our contract draft was wrong, not the code
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("5013046098bba7fb")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 4, dtype family float, shape (2, 4, 4, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function performs complex matrix multiplication using real tensor representations
# A_real and B_real should have shape [..., 2] where the last dimension holds [real, imag] parts
# The function uses matmul on indexed slices, so we need compatible dimensions for matrix multiplication

# Create A_real: shape (2, 4, 2) - batch of 2, 4x4 matrices in complex form
A_real = torch.randn(2, 4, 4, 2)

# Create B_real: shape (2, 4, 2) - batch of 2, 4x4 matrices in complex form
B_real = torch.randn(2, 4, 4, 2)

ARGS = {
    "A_real": A_real,
    "B_real": B_real,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 4, 4, 2) — shape (2, 4, 4, 2) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
complex_matmul_fast Ran
ran; our contract draft was wrong, not the code
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("511f7c1305f422af")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 4, dtype family float, shape (2, 4, 5, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# The function performs complex matrix multiplication using real tensors
# A_real and B_real should be tensors where the last dimension has size 2
# (representing real and imaginary parts)
# The function uses matmul operations, so dimensions before the last must be compatible

# Create A_real: shape (2, 4, 3, 2) - batch 2, matrix 4x3, last dim 2 for complex
A_real = torch.randn(2, 4, 3, 2)

# Create B_real: shape (2, 3, 5, 2) - batch 2, matrix 3x5, last dim 2 for complex
# Middle dimension 3 matches A_real's second-to-last dimension for matmul compatibility
B_real = torch.randn(2, 3, 5, 2)

ARGS = {
    "A_real": A_real,
    "B_real": B_real,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 4, 5, 2) — shape (2, 4, 5, 2) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
ga_to_matrix Ran
ran; our contract draft was wrong, not the code
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("bc9402d744e1cbc6")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 4, dtype family float, shape (2, 3, 5, 6) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import torch.nn as nn

torch.manual_seed(0)

# x: tensor with shape (..., i) where i=4
# mapping: object with .dtype attribute and shape (i, j, k, r) = (4, 3, 5, 6)
x = torch.randn(2, 4, dtype=torch.float32)

# Create a simple mapping tensor with the required shape
# Shape: (i=4, j=3, k=5, r=6)
mapping = torch.randn(4, 3, 5, 6, dtype=torch.float32)

ARGS = {
    'x': x,
    'mapping': mapping
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 4, dtype family float, shape (2, 3, 5, 6) — shape (2, 3, 5, 6) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
geometric_linear_cpu Ran
ran; our contract draft was wrong, not the code
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("305b70af29e9c3a0")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 3, dtype family float, shape (2, 4, 8) as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Define small tensor arguments
batch_size = 2
in_features = 3
out_features = 4
ga_dim = 5  # geometric algebra dimension (2^D where D is signature length)

# x: shape (batch_size, in_features, ga_dim)
x = torch.randn(batch_size, in_features, ga_dim, dtype=torch.float32)

# weight: shape (out_features, in_features, ga_dim)
weight = torch.randn(out_features, in_features, ga_dim, dtype=torch.float32)

# signature: iterable representing metric signature
# For ga_dim = 5 = 2^D, we need D such that 2^D = 5, which doesn't work
# Let's use ga_dim = 8 = 2^3, so signature has length 3
ga_dim = 8
x = torch.randn(batch_size, in_features, ga_dim, dtype=torch.float32)
weight = torch.randn(out_features, in_features, ga_dim, dtype=torch.float32)
signature = [1, 1, -1]  # length 3 for 2^3 = 8 dimensions

ARGS = {
    'x': x,
    'weight': weight,
    'signature': signature
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (2, 4, 8) — shape (2, 4, 8) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
geometric_linear_layer_matrix Ran
ran; our contract draft was wrong, not the code
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("a4e600bb59d7b0a8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 3, dtype family float, shape (2, 3, 32) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create small tensors with distinct dimensions
# x: shape (batch=2, K=4, 32) - batch of 2, K geometric algebra elements of dimension 4, 32 basis elements
# weight: shape (N=3, K=4, 32) - N output elements, K input elements, 32 basis elements

x = torch.randn(2, 4, 32, dtype=torch.float32)
weight = torch.randn(3, 4, 32, dtype=torch.float32)

ARGS = {
    "x": x,
    "weight": weight,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 3, dtype family float, shape (2, 3, 32) — shape (2, 3, 32) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
geometric_product_matrix Ran
ran; our contract draft was wrong, not the code
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("e5bc94dc10ae2c52")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 32) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create small tensor arguments for the geometric_product_matrix function
# The function expects two tensors 'a' and 'b' representing geometric algebra elements

# Based on the code, ga_to_matrix expects tensors of shape (..., 32) 
# where 32 is the dimension of the geometric algebra basis (2^5 elements for Cl(4,1))
# We'll create batch tensors of shape (2, 32)

a = torch.randn(2, 32, dtype=torch.float32)
b = torch.randn(2, 32, dtype=torch.float32)

ARGS = {
    'a': a,
    'b': b,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 32) — shape (2, 32) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_cl41_matrix_mapping Ran
ran; our contract draft was wrong, not the code
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("5f030dd3a34b34f4")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# The function takes two parameters: device and dtype
# device should be a torch.device object
# dtype should be a torch.dtype

device = torch.device('cpu')
dtype = torch.float32

ARGS = {
    'device': device,
    'dtype': dtype
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
get_sign_matrix Ran
ran; our contract draft was wrong, not the code
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("dafe0d1ca38ad182")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (16, 16) as a later run recorded it. The image it ran in was not recorded. The code mentions cuda, and the harness aliases cuda to the CPU for every sample; whether this run needed that is not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# The function takes two parameters: signature and device_type
# signature: should be an iterable of length D with values like +1, -1, or 0
# device_type: string specifying the output device type

# Create a small signature - a list of metric signature values
# Using a simple Minkowski-like signature: [+1, +1, +1, -1]
signature = np.array([1, 1, 1, -1], dtype=np.float32)

# device_type can be 'numpy', 'torch_cuda', 'mlx', or defaults to torch
device_type = 'numpy'

ARGS = {
    'signature': signature,
    'device_type': device_type
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (16, 16) — shape (16, 16) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
manifold_normalization Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("bc3fe491a1248b96")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# Create a small tensor for x
# Shape: (batch=2, features=4)
x = torch.randn(2, 4, dtype=torch.float32)

# Create a signature list
# signature is used to compute a metric signature array
# It's a list of length D where D is the number of bits needed
# to represent n_dims (4 features means we need at least 2 bits)
# The signature typically contains +1 or -1 values
signature = [1, 1]

# eps parameter - already has a default, but we can provide one
eps = 1e-06

ARGS = {
    "x": x,
    "signature": signature,
    "eps": eps
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
matrix_to_ga Ran
ran; our contract draft was wrong, not the code
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("db7f564aa955186b")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 2, dtype family float, shape (2, 6) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch

torch.manual_seed(0)

# Analyze the function:
# - m: tensor used in einsum as '...jkr' (batch dims, then j, k, r)
# - mapping: tensor used in einsum as 'ijkr' (i, j, k, r dimensions)
# - sig: parameter that is not directly used in the einsum (unused in the function body)
# - Returns: result of einsum divided by 4.0

# Create m with shape compatible with '...jkr'
# Let's use batch size 2, with j=3, k=4, r=5
m = torch.randn(2, 3, 4, 5)

# Create mapping with shape 'ijkr' where i=6, j=3, k=4, r=5
# (matching j, k, r dimensions from m)
mapping = torch.randn(6, 3, 4, 5)

# sig is not used in the function body, so it can be any value
# Let's use a simple integer or dict as a stand-in
sig = 1

ARGS = {
    "m": m,
    "mapping": mapping,
    "sig": sig
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 2, dtype family float, shape (2, 6) — shape (2, 6) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
x_is_cl41 Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("d7e70d03a9ce67cf")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned bool, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

def x_is_cl41(ga_dim, signature):
    return ga_dim == 32 and len(signature) == 5 and (signature[4] == -1) and all((s == 1 for s in signature[:4]))

# Construct arguments that will make x_is_cl41 return True
ga_dim = 32
signature = [1, 1, 1, 1, -1]

ARGS = {
    "ga_dim": ga_dim,
    "signature": signature
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type bool, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
RecursiveRotorAccumulator Not yet run
unverified (harvested, no recorded run)
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("f681cb424fa94433")
How it ran

no invocation recorded.

VersorAttention Not yet run
unverified (harvested, no recorded run)
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("45a2c747e90b71ba")
How it ran

no invocation recorded.

VersorBlock Not yet run
unverified (harvested, no recorded run)
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("9de837a9a3d2d239")
How it ran

no invocation recorded.

VersorLinear Not yet run
unverified (harvested, no recorded run)
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("6df825d6496000fd")
How it ran

no invocation recorded.

VersorTransformer Not yet run
unverified (harvested, no recorded run)
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("892d2ddfa3a7ff51")
How it ran

no invocation recorded.

geometric_linear_layer Not yet run
unverified (harvested, no recorded run)
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("8b3d863935af09ea")
How it ran

no invocation recorded.

geometric_product Not yet run
unverified (harvested, no recorded run)
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("56579ce7807e5239")
How it ran

no invocation recorded.

geometric_product_mlx Not yet run
unverified (harvested, no recorded run)
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("861d0a98bbc5018a")
How it ran

no invocation recorded.

geometric_product_torch Not yet run
unverified (harvested, no recorded run)
VersorAI/Versor/Model/model.py
code served (permissive licence) · get_code("dd84f2e71d495871")
How it ran

no invocation recorded.

Also present in other papers' code

Of 20 samples lifted from this paper's linked repositories, 20 carry a function identity and 0 do not. Of the 20 distinct functions with an identity, 0 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 0 later) and 20 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

A novel sequence architecture is introduced, Versor, which uses Conformal Geometric Algebra (CGA) in place of traditional linear operations to achieve structural generalization and significant performance improvements on a variety of tasks, while offering improved interpretability and efficiency. By embedding states in the Cl 4,1 manifold and evolving them via geometric transformations (rotors), Versor natively represents SE(3)-equivariant relationships without requiring explicit structural encoding. Versor is validated on chaotic N-body dynamics, topological reasoning, and standard multimodal benchmarks (CIFAR-10, WikiText-103), consistently outperforming Transformers, Graph Networks, and geometric baselines (GATr, EGNN). Key results include: orders-ofmagnitude fewer parameters (200× vs. Transformers); interpretable attention decomposing into proximity and orientational components; zero-shot scale generalization (0.993 vs. 0.070 MCC for ViT); and featuring a Recursive Rotor Accumulator (RRA) for O(L) linear temporal complexity in dynamical systems, and a Geometric Product Attention (GPA) mechanism for O(L 2 ) global relational modeling, allowing for task-specific architectural pruning or hybridization depending on the required scale. In out-of-distribution tests, Versor maintains stable predictions while Transformers fail catastrophically. Custom Clifford kernels achieve a cumulative over 100× speedup via bit-masked contraction and specialized Matrix Isomorphism kernels, reducing per-step latency to 1.05 ms and outperforming highly-optimized Transformer baselines.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2602.10195")
get_code_for_paper("2602.10195")
have("2602.10195")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2602.10195.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2602.10195.svg)](https://syntology.ai/paper/2602.10195)

Connect an agent — have() is free.