SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2605.09096 · 2026

Bridging Spectral Operator Learning and U-Net Hierarchies: SpectraNet for Stable Autoregressive PDE Surrogates

Elias Ioup, Mahdi Abdelguerfi, Julian Simeonov, Enrique Noguera, Md Ferdaus

arXiv · PDF · Open in the Atlas

Code that ran

18 of 25 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (11 of them constructed an object rather than computing a result; 0 honoured the contract we drafted, 0 violated it and 14 have no contract verdict; 4 failures of our instrument; 7 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/2605.09096.json · badge: /api/ran/2605.09096.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
Enrikkk/spectranet community
Papers with Code archive
18 ran · 7 no recorded run
FunctionStatusWhere it lives
BottleneckSelfAttn2d Ran
ran on a synthesized input
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("72d384fbc1268cab")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 4, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim 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
from scipy import stats

INIT_ARGS = {
    "channels": 4,
    "n_heads": 2
}

# Construct input tensor: batch=2, channels=4, height=3, width=5
input_tensor = torch.randn(2, 4, 3, 5)

ARGS = {
    "x": input_tensor
}
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
Imports
numpy, scipy, 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 — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
ChannelAttention2d Ran
ran on a synthesized input · constructed an object; no result was computed
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("aba0f12d1a9a369d")
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 an instance of its own class, ChannelAttention2d: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

ARGS = {
    "channels": 16,
    "reduction": 4,
}
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 ChannelAttention2d — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a ChannelAttention2d output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
FourierKANLinear Ran
ran on a synthesized input
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("f35185e781b52884")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, class construct-then-call prompt, model not recorded) and returned Tensor, ndim 2, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim 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
import math

class FourierKANLinear(nn.Module):
    """Fourier-basis KAN variant — replaces the spline with cos/sin of a
    learnable mixing of input.  Cheaper at inference."""

    def __init__(self, in_features: int, out_features: int, grid_size: int=5):
        super().__init__()
        self.in_features = in_features
        self.out_features = out_features
        self.grid_size = grid_size
        self.fourier_weight = nn.Parameter(torch.empty(out_features, in_features, 2 * grid_size + 1))
        nn.init.normal_(self.fourier_weight, std=0.01)

    def forward(self, x):
        shape = x.shape
        x_flat = x.reshape(-1, self.in_features)
        k = torch.arange(1, self.grid_size + 1, device=x.device, dtype=x.dtype)
        xk = x_flat.unsqueeze(-1) * k.view(1, 1, -1) * math.pi
        basis = torch.cat([torch.ones(*x_flat.shape, 1, device=x.device, dtype=x.dtype), torch.cos(xk), torch.sin(xk)], dim=-1)
        out = torch.einsum('nif,oif->no', basis, self.fourier_weight)
        return out.reshape(*shape[:-1], self.out_features)


INIT_ARGS = {
    'in_features': 4,
    'out_features': 3,
    'grid_size': 5,
}

ARGS = {
    'x': torch.randn(2, 4),
}

if __name__ == '__main__':
    model = FourierKANLinear(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Output shape: {output.shape}")
    print(f"Expected shape: (2, 3)")
    assert output.shape == (2, 3), f"Shape mismatch: got {output.shape}, expected (2, 3)"
    print("Test passed!")
Setup block drafted by
a language model, class construct-then-call prompt, model not recorded
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 — no output shape is stated: observe_signature.py observed this class with its constructor sizes canonicalised where it could, which the node does not record, so its shape is not stated as this setup block's
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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
KANConv2d1x1 Ran
ran on a synthesized input · constructed an object; no result was computed
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("ebfdebcfcb1495c7")
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 an instance of its own class, KANConv2d1x1: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
import math

torch.manual_seed(0)

ARGS = {
    'in_channels': 4,
    'out_channels': 3,
    'kan_type': 'efficient',
    'grid_size': 5,
    'spline_order': 3,
}
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 KANConv2d1x1 — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a KANConv2d1x1 output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
KANLinear Ran
ran on a synthesized input · constructed an object; no result was computed
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("49d63dd3ce79b688")
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 an instance of its own class, KANLinear: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
import math

torch.manual_seed(0)

ARGS = {
    "in_features": 4,
    "out_features": 3,
    "grid_size": 5,
    "spline_order": 3,
    "scale_noise": 0.1,
    "scale_base": 1.0,
    "scale_spline": 1.0,
    "base_activation": nn.SiLU,
    "grid_eps": 0.02,
    "grid_range": (-1, 1),
}
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 KANLinear — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a KANLinear output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
KANLinearND Ran
ran on a synthesized input · constructed an object; no result was computed
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("c1a9b3df03f39b45")
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 an instance of its own class, KANLinearND: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
import math

torch.manual_seed(0)

ARGS = {
    "in_features": 4,
    "out_features": 3,
    "kan_type": "efficient",
    "grid_size": 5,
    "spline_order": 3,
}
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 KANLinearND — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a KANLinearND output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
KANMLP2d Ran
ran on a synthesized input · constructed an object; no result was computed
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("7a6ab6de7a4fca4f")
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 an instance of its own class, KANMLP2d: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
import math

torch.manual_seed(0)

ARGS = {
    'in_channels': 4,
    'out_channels': 8,
    'mid_channels': 6,
    'kan_type': 'efficient',
    'grid_size': 5,
    'spline_order': 3,
}
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 KANMLP2d — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a KANMLP2d output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
KANSpectralConv2d Ran
ran on a synthesized input · constructed an object; no result was computed
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("ffeb97e3ef0cbc97")
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 an instance of its own class, KANSpectralConv2d: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
import math

torch.manual_seed(0)

ARGS = {
    'in_channels': 3,
    'out_channels': 4,
    'modes1': 5,
    'modes2': 6,
    'kan_type': 'efficient',
    'grid_size': 5,
    'spline_order': 3,
}
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 KANSpectralConv2d — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a KANSpectralConv2d output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
MLP2d Ran
ran on a synthesized input · constructed an object; no result was computed
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("a9214b2dbfe3e949")
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 an instance of its own class, MLP2d: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

ARGS = {
    'in_channels': 4,
    'out_channels': 3,
    'mid_channels': 8,
    'mlp_groups': 2
}
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 MLP2d — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a MLP2d output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
SpatialAttention2d Ran
ran on a synthesized input · constructed an object; no result was computed
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("3f835f19a5862d50")
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 an instance of its own class, SpatialAttention2d: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

# SpatialAttention2d.__init__ takes k as a parameter
# SpatialAttention2d.forward expects an input tensor x with shape (batch, channels, height, width)

# Create a small input tensor: batch=2, channels=4, height=8, width=8
x = torch.randn(2, 4, 8, 8)

# The module is instantiated with k=7 (default or custom)
# Let's test with k=7
ARGS = {
    'k': 7,
}
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 SpatialAttention2d — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a SpatialAttention2d output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
SpectralAttention2d Ran
ran on a synthesized input · constructed an object; no result was computed
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("583d59089a703675")
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 an instance of its own class, SpectralAttention2d: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

class SpectralAttention2d(nn.Module):
    """Multi-head attention over the low-frequency spectral modes shared
    between the decoder feature map and its skip connection."""

    def __init__(self, channels: int, modes1: int, modes2: int, n_heads: int=4):
        super().__init__()
        self.modes1, self.modes2 = (modes1, modes2)
        self.n_heads = n_heads
        feat_dim = channels * 2
        assert feat_dim % n_heads == 0
        self.d_k = feat_dim // n_heads
        self.scale = self.d_k ** (-0.5)
        self.q_proj = nn.Linear(feat_dim, feat_dim)
        self.k_proj = nn.Linear(feat_dim, feat_dim)
        self.v_proj = nn.Linear(feat_dim, feat_dim)
        self.out_proj = nn.Linear(feat_dim, feat_dim)

    def forward(self, decoder, skip):
        B, C, X, Y = decoder.shape
        m1, m2 = (self.modes1, self.modes2)
        H, d = (self.n_heads, self.d_k)
        dec_ft = torch.fft.rfft2(decoder)
        skip_ft = torch.fft.rfft2(skip)
        dec_modes = dec_ft[:, :, :m1, :m2]
        skip_modes = skip_ft[:, :, :m1, :m2]
        n_tok = m1 * m2
        dec_ri = torch.view_as_real(dec_modes.contiguous())
        skip_ri = torch.view_as_real(skip_modes.contiguous())
        dec_tok = dec_ri.permute(0, 2, 3, 1, 4).reshape(B, n_tok, C * 2)
        skip_tok = skip_ri.permute(0, 2, 3, 1, 4).reshape(B, n_tok, C * 2)
        Q = self.q_proj(dec_tok).view(B, n_tok, H, d).permute(0, 2, 1, 3)
        K = self.k_proj(skip_tok).view(B, n_tok, H, d).permute(0, 2, 1, 3)
        V = self.v_proj(skip_tok).view(B, n_tok, H, d).permute(0, 2, 1, 3)
        attn = Q @ K.transpose(-2, -1) * self.scale
        attn = attn.softmax(dim=-1)
        out = (attn @ V).permute(0, 2, 1, 3).reshape(B, n_tok, C * 2)
        out = self.out_proj(out)
        out = out.view(B, m1, m2, C, 2).permute(0, 3, 1, 2, 4).contiguous()
        out_modes = torch.view_as_complex(out)
        out_ft = torch.zeros_like(skip_ft)
        out_ft[:, :, :m1, :m2] = out_modes
        return torch.fft.irfft2(out_ft, s=(X, Y))

# Create small test tensors
batch_size = 2
channels = 4
height = 8
width = 8
modes1 = 3
modes2 = 3
n_heads = 4

decoder = torch.randn(batch_size, channels, height, width)
skip = torch.randn(batch_size, channels, height, width)

ARGS = {
    "channels": channels,
    "modes1": modes1,
    "modes2": modes2,
    "n_heads": n_heads,
}
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 SpectralAttention2d — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a SpectralAttention2d output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
SpectralConfig Ran
ran on a synthesized input · constructed an object; no result was computed
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("a79f596ba911bdc6")
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 an instance of its own class, SpectralConfig: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn

torch.manual_seed(0)

ARGS = {
    'mode_truncation': 'box',
    'mlp_groups': 1,
    'spectral_envelope': False,
    'spectral_dropout': 0.0,
}
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 SpectralConfig — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a SpectralConfig output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
SpectralConv2d Ran
ran on a synthesized input · constructed an object; no result was computed
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("e4e7ee5864b83eea")
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 an instance of its own class, SpectralConv2d: the run constructed the object and did not call it, so no result was computed. 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 torch.nn as nn
from dataclasses import dataclass

torch.manual_seed(0)

@dataclass
class SpectralConfig:
    mode_truncation: str = 'box'
    mlp_groups: int = 1
    spectral_envelope: bool = False
    spectral_dropout: float = 0.0

ARGS = {
    'in_channels': 3,
    'out_channels': 4,
    'modes1': 5,
    'modes2': 6,
    'cfg': SpectralConfig(
        mode_truncation='box',
        mlp_groups=1,
        spectral_envelope=False,
        spectral_dropout=0.0
    )
}
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 SpectralConv2d — the run constructed an instance of its own class and did not call it; no shape is stated — the instrument coerces any output to an array; for a SpectralConv2d output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
_kan_kwargs Ran
ran; our contract draft was wrong, not the code
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("a630ddd9a6e0bf90")
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 dict. 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 torch.nn as nn

torch.manual_seed(0)

# Stand-in class for KANConfig
class KANConfig:
    def __init__(self, kan_type='efficient', grid_size=5, spline_order=3):
        self.kan_type = kan_type
        self.grid_size = grid_size
        self.spline_order = spline_order

# Test with all three cases the function handles
ARGS = {
    'kan_cfg': None
}
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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
default_kan_flags Ran
ran on a synthesized input
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("f8ed2bd5e5d93fff")
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 dict. 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

torch.manual_seed(0)

ARGS = {}
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 dict — a dict output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a dict output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
make_conv1x1 Ran
ran; our contract draft was wrong, not the code
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("020e088f0766fcb2")
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 KANConv2d1x1. 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 torch.nn as nn
import math

torch.manual_seed(0)

# The function signature is incomplete in the prompt, but based on context
# it should be: make_conv1x1(in_ch, out_ch, use_kan: bool, kan_cfg)
# Let's construct valid arguments for it.

# Simple stand-in KANConfig class
class KANConfig:
    def __init__(self, kan_type='efficient', grid_size=5, spline_order=3):
        self.kan_type = kan_type
        self.grid_size = grid_size
        self.spline_order = spline_order

# Test with both dict and object configs
kan_config_dict = {
    'kan_type': 'efficient',
    'grid_size': 5,
    'spline_order': 3
}

kan_config_obj = KANConfig(kan_type='efficient', grid_size=5, spline_order=3)

ARGS = {
    'in_ch': 4,
    'out_ch': 3,
    'use_kan': True,
    'kan_cfg': kan_config_dict
}
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 KANConv2d1x1 — a KANConv2d1x1 output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a KANConv2d1x1 output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
make_linear Ran
ran; our contract draft was wrong, not the code
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("5fd4284a6dbcc0fb")
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 KANLinearND. 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 torch.nn as nn

torch.manual_seed(0)

# Simple stand-in config class for kan_cfg parameter
class KANConfig:
    def __init__(self, kan_type='efficient', grid_size=5, spline_order=3):
        self.kan_type = kan_type
        self.grid_size = grid_size
        self.spline_order = spline_order

# Define arguments for make_linear function
ARGS = {
    'in_f': 4,
    'out_f': 3,
    'use_kan': True,
    'kan_cfg': KANConfig(kan_type='efficient', grid_size=5, spline_order=3)
}
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 KANLinearND — a KANLinearND output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a KANLinearND output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
resolve_attn Ran
ran; our contract draft was wrong, not the code
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("57ce50c3baa33a95")
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 str. 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 torch.nn as nn

torch.manual_seed(0)

ARGS = {
    'mode': 'progressive',
    'channels': 64
}
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 str — a str output has no array shape of its own; none is stated — the instrument coerces any output to an array; for a str output the recorded ndim 0 and dtype family float describe that coercion, not the output, and are not 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
AttentionGate2d Not yet run
unverified (harvested, no recorded run)
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("08bd5318c19481ce")
How it ran

no invocation recorded.

DecoderBlock2d Not yet run
unverified (harvested, no recorded run)
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("1721896d4496657e")
How it ran

no invocation recorded.

EncoderBlock2d Not yet run
unverified (harvested, no recorded run)
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("e1104c85613440c4")
How it ran

no invocation recorded.

MultiScaleOutput2d Not yet run
unverified (harvested, no recorded run)
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("ad63a669e0da1407")
How it ran

no invocation recorded.

SUNet2d Not yet run
unverified (harvested, no recorded run)
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("a1ac44c5e946e0f6")
How it ran

no invocation recorded.

make_mlp2d Not yet run
unverified (harvested, no recorded run)
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("03b10a7720906f08")
How it ran

no invocation recorded.

make_spectral_conv2d Not yet run
unverified (harvested, no recorded run)
Enrikkk/spectranet/spectranet/model.py
code served (permissive licence) · get_code("cec5e6971794d1d1")
How it ran

no invocation recorded.

Also present in other papers' code

Of 25 samples lifted from this paper's linked repositories, 25 carry a function identity and 0 do not. Of the 25 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 25 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

Neural operators for time-dependent PDEs face a structural tension: spectral architectures (FNO and descendants) inherit exponential rollout-error growth from their one-step Lipschitz constant, while hierarchical U-Net operators trade resolution invariance for multi-scale detail. We introduce SpectraNet, an autoregressive neural operator that composes truncated spectral convolutions inside a U-Net hierarchy with a Residual-Target Spectral Block trained under a Semigroup-Consistency Loss. The residual-target parametrization replaces L T stability blow-up with linear T δ drift (Theorem 1, conditional on staying in K), and the spectral path's parameter count is Θ(Lw 2 M 2 ), independent of grid N . Under a single unified protocol against 16 published neural-operator baselines on Navier-Stokes ν=10 -5 at 64×64, SpectraNet reaches test relative L 2 =0.0822 at 2.04 M parameters -2.33× fewer than canonical FNO at ≈ 20% lower error -and wins five of six rows in a cross-PDE comparison against FNO (NS at ν ∈ {10 -4 , 10 -3 }, PDEBench Shallow-Water 2D and Diffusion-Reaction, with the Active-Matter row going to FNO inside its seed spread). Trained from scratch at native 128 2 under the same protocol, SpectraNet improves to 0.0724 while FNO regresses to 0.3080; we caveat this in Section 7.4 since the unified protocol is not tuned per-architecture per-resolution. Free rollout stays bounded for T =100 where FNO diverges across all 200 test trajectories. On consumer CPU at B=1, SpectraNet runs sub-200 ms while the full-attention Transformer that wins raw L 2 pays ∼ 60× latency; we do not claim to beat that Transformer on raw L 2 , only to dominate the lightweight (≤ 5 M parameter, sub-200 ms CPU) Pareto frontier. Source code is available at https://github.com/Enrikkk/spectranet.

For agents

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

get_harvested_code_for_paper("2605.09096")
get_code_for_paper("2605.09096")
have("2605.09096")

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

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

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

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

Connect an agent — have() is free.