SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2010.08895 · 2020

Fourier Neural Operator for Parametric Partial Differential Equations

Nikola Kovachki, Andrew Stuart, Zongyi Li, Burigede Liu, Kaushik Bhattacharya

arXiv · PDF · Open in the Atlas

Code that ran

23 of 33 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (5 of them constructed an object rather than computing a result; 4 honoured the contract we drafted, 1 violated it and 15 have no contract verdict; 3 failures of our instrument; 10 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; 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/2010.08895.json · badge: /api/ran/2010.08895.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
sala-group/autows-bench-101 community (classifier label)
classifier basis not recorded on the link
6 ran · 6 no recorded run
nickhnelsen/random-features-banach community
Papers with Code archive
3 ran · 2 no recorded run
nickhnelsen/fourier-neural-mappings community
Papers with Code archive
2 ran · 1 no recorded run
linfengyu77/efkan community
Papers with Code archive
2 ran · 1 no recorded run
shawnrosofsky/pino_applications community
Papers with Code archive
2 ran · 0 no recorded run
pdebench/pdebench community
Papers with Code archive
2 ran · 0 no recorded run
nboulle/pde-learning community
Papers with Code archive
2 ran · 0 no recorded run
jaybhat02/summer_fourier_neural_operator community
Papers with Code archive
1 ran · 0 no recorded run
cognitivemodeling/finn community
Papers with Code archive
1 ran · 0 no recorded run
gegewen/ufno community
Papers with Code archive
1 ran · 0 no recorded run
copy not recorded community
not in the paper's declared repositories
1 ran · 0 no recorded run
FunctionStatusWhere it lives
FNN2d Ran
ran on a synthesized input · constructed an object; no result was computed
shawnrosofsky/pino_applications/models/fourier2d.py
code served (permissive licence) · get_code("e9c8e75829087fe5")
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, FNN2d: 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 numpy as np

torch.manual_seed(0)

ARGS = {
    'modes1': [4, 4, 4, 4],
    'modes2': [4, 4, 4, 4],
    'width': 8,
    'fc_dim': 16,
    'layers': [8, 8, 8, 8, 8],
    'in_dim': 3,
    'out_dim': 1,
    'activation': 'tanh',
    'pad_x': 0,
    'pad_y': 0,
}
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 FNN2d — 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 FNN2d 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
FNO1d Ran
ran on a synthesized input · constructed an object; no result was computed
pdebench/pdebench/pdebench/models/fno/fno.py
pointer only (licence: NOASSERTION) · get_code("44f1a5e7148b72d6")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, pdebench/pdebench (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

FNO2d Ran
ran on a synthesized input · constructed an object; no result was computed
jaybhat02/summer_fourier_neural_operator/fourier_neural_operator_mod/fourier_2d_time.py
pointer only (licence: NONE) · get_code("018315f9be478a54")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, jaybhat02/summer_fourier_neural_operator when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

FNO2d Ran
ran on a synthesized input
nboulle/pde-learning/src/fno.py
code served (permissive licence) · get_code("34d17243748b7c9e")
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 torch.nn as nn
import torch.nn.functional as F

class SpectralConv2d(nn.Module):

    def __init__(self, in_channels, out_channels, modes1, modes2):
        super(SpectralConv2d, self).__init__()
        '\n        2D Fourier layer. It does FFT, linear transform, and Inverse FFT.    \n        '
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.modes1 = modes1
        self.modes2 = modes2
        self.scale = 1 / (in_channels * out_channels)
        self.weights1 = nn.Parameter(self.scale * torch.rand(in_channels, out_channels, self.modes1, self.modes2, dtype=torch.cfloat))
        self.weights2 = nn.Parameter(self.scale * torch.rand(in_channels, out_channels, self.modes1, self.modes2, dtype=torch.cfloat))

    def compl_mul2d(self, input, weights):
        return torch.einsum('bixy,ioxy->boxy', input, weights)

    def forward(self, x):
        batchsize = x.shape[0]
        x_ft = torch.fft.rfft2(x)
        out_ft = torch.zeros(batchsize, self.out_channels, x.size(-2), x.size(-1) // 2 + 1, dtype=torch.cfloat, device=x.device)
        out_ft[:, :, :self.modes1, :self.modes2] = self.compl_mul2d(x_ft[:, :, :self.modes1, :self.modes2], self.weights1)
        out_ft[:, :, -self.modes1:, :self.modes2] = self.compl_mul2d(x_ft[:, :, -self.modes1:, :self.modes2], self.weights2)
        x = torch.fft.irfft2(out_ft, s=(x.size(-2), x.size(-1)))
        return x

class FNO2d(nn.Module):

    def __init__(self, modes1, modes2, width):
        super(FNO2d, self).__init__()
        "\n        The overall network. It contains 4 layers of the Fourier layer.\n        1. Lift the input to the desire channel dimension by self.fc0 .\n        2. 4 layers of the integral operators u' = (W + K)(u).\n            W defined by self.w; K defined by self.conv .\n        3. Project from the channel space to the output space by self.fc1 and self.fc2 .\n        \n        input: the solution of the coefficient function and locations (a(x, y), x, y)\n        input shape: (batchsize, x=s, y=s, c=3)\n        output: the solution \n        output shape: (batchsize, x=s, y=s, c=1)\n        "
        self.modes1 = modes1
        self.modes2 = modes2
        self.width = width
        self.fc0 = nn.Linear(3, self.width)
        self.conv0 = SpectralConv2d(self.width, self.width, self.modes1, self.modes2)
        self.conv1 = SpectralConv2d(self.width, self.width, self.modes1, self.modes2)
        self.conv2 = SpectralConv2d(self.width, self.width, self.modes1, self.modes2)
        self.conv3 = SpectralConv2d(self.width, self.width, self.modes1, self.modes2)
        self.w0 = nn.Conv1d(self.width, self.width, 1)
        self.w1 = nn.Conv1d(self.width, self.width, 1)
        self.w2 = nn.Conv1d(self.width, self.width, 1)
        self.w3 = nn.Conv1d(self.width, self.width, 1)
        self.fc1 = nn.Linear(self.width, 128)
        self.fc2 = nn.Linear(128, 1)

    def forward(self, x):
        batchsize = x.shape[0]
        size_x, size_y = (x.shape[1], x.shape[2])
        x = self.fc0(x)
        x = x.permute(0, 3, 1, 2)
        x1 = self.conv0(x)
        x2 = self.w0(x.view(batchsize, self.width, -1)).view(batchsize, self.width, size_x, size_y)
        x = x1 + x2
        x = F.relu(x)
        x1 = self.conv1(x)
        x2 = self.w1(x.view(batchsize, self.width, -1)).view(batchsize, self.width, size_x, size_y)
        x = x1 + x2
        x = F.relu(x)
        x1 = self.conv2(x)
        x2 = self.w2(x.view(batchsize, self.width, -1)).view(batchsize, self.width, size_x, size_y)
        x = x1 + x2
        x = F.relu(x)
        x1 = self.conv3(x)
        x2 = self.w3(x.view(batchsize, self.width, -1)).view(batchsize, self.width, size_x, size_y)
        x = x1 + x2
        x = x.permute(0, 2, 3, 1)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.fc2(x)
        return x

INIT_ARGS = {
    'modes1': 4,
    'modes2': 4,
    'width': 8
}

ARGS = {
    'x': torch.randn(2, 12, 12, 3)
}
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 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)
FNO2d Ran
ran on a synthesized input
cognitivemodeling/finn/models/fno/fno.py
pointer only (licence: NONE) · get_code("1e73700250bdba1f")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, cognitivemodeling/finn when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

MLP Ran
ran on a synthesized input · constructed an object; no result was computed
nickhnelsen/fourier-neural-mappings/models/func_to_func2d.py
code served (permissive licence) · get_code("0057226681fa403f")
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, MLP: 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_in': 4,
    'channels_hid': 8,
    'channels_out': 3,
    'act': 'gelu'
}
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 MLP — 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 MLP 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
SpectralConv1d Ran
ran on a synthesized input
pdebench/pdebench/pdebench/models/fno/fno.py
pointer only (licence: NOASSERTION) · get_code("415e019751b09258")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, pdebench/pdebench (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

SpectralConv2d Ran
ran on a synthesized input · constructed an object; no result was computed
shawnrosofsky/pino_applications/models/fourier2d.py
code served (permissive licence) · get_code("be7a5d5cc639c6eb")
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
import numpy as np

torch.manual_seed(0)

# Define the function and class from the problem
def compl_mul2d(a, b):
    return torch.einsum('bixy,ioxy->boxy', a, b)

class SpectralConv2d(nn.Module):

    def __init__(self, in_channels, out_channels, modes1, modes2):
        super(SpectralConv2d, self).__init__()
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.modes1 = modes1
        self.modes2 = modes2
        self.scale = 1 / (in_channels * out_channels)
        self.weights1 = nn.Parameter(self.scale * torch.rand(in_channels, out_channels, self.modes1, self.modes2, dtype=torch.cfloat))
        self.weights2 = nn.Parameter(self.scale * torch.rand(in_channels, out_channels, self.modes1, self.modes2, dtype=torch.cfloat))

    def forward(self, x, gridy=None):
        batchsize = x.shape[0]
        size1 = x.shape[-2]
        size2 = x.shape[-1]
        x_ft = torch.fft.rfftn(x, dim=[2, 3])
        if gridy is None:
            out_ft = torch.zeros(batchsize, self.out_channels, x.size(-2), x.size(-1) // 2 + 1, device=x.device, dtype=torch.cfloat)
            out_ft[:, :, :self.modes1, :self.modes2] = compl_mul2d(x_ft[:, :, :self.modes1, :self.modes2], self.weights1)
            out_ft[:, :, -self.modes1:, :self.modes2] = compl_mul2d(x_ft[:, :, -self.modes1:, :self.modes2], self.weights2)
            x = torch.fft.irfftn(out_ft, s=(x.size(-2), x.size(-1)), dim=[2, 3])
        else:
            factor1 = compl_mul2d(x_ft[:, :, :self.modes1, :self.modes2], self.weights1)
            factor2 = compl_mul2d(x_ft[:, :, -self.modes1:, :self.modes2], self.weights2)
            x = self.ifft2d(gridy, factor1, factor2, self.modes1, self.modes2) / (size1 * size2)
        return x

    def ifft2d(self, gridy, coeff1, coeff2, k1, k2):
        batchsize = gridy.shape[0]
        N = gridy.shape[1]
        device = gridy.device
        m1 = 2 * k1
        m2 = 2 * k2 - 1
        k_x1 = torch.cat((torch.arange(start=0, end=k1, step=1), torch.arange(start=-k1, end=0, step=1)), 0).reshape(m1, 1).repeat(1, m2).to(device)
        k_x2 = torch.cat((torch.arange(start=0, end=k2, step=1), torch.arange(start=-(k2 - 1), end=0, step=1)), 0).reshape(1, m2).repeat(m1, 1).to(device)
        K1 = torch.outer(gridy[:, :, 0].view(-1), k_x1.view(-1)).reshape(batchsize, N, m1, m2)
        K2 = torch.outer(gridy[:, :, 1].view(-1), k_x2.view(-1)).reshape(batchsize, N, m1, m2)
        K = K1 + K2
        basis = torch.exp(1j * 2 * np.pi * K).to(device)
        coeff3 = coeff1[:, :, 1:, 1:].flip(-1, -2).conj()
        coeff4 = torch.cat([coeff1[:, :, 0:1, 1:].flip(-1).conj(), coeff2[:, :, :, 1:].flip(-1, -2).conj()], dim=-2)
        coeff12 = torch.cat([coeff1, coeff2], dim=-2)
        coeff43 = torch.cat([coeff4, coeff3], dim=-2)
        coeff = torch.cat([coeff12, coeff43], dim=-1)
        Y = torch.einsum('bcxy,bnxy->bcn', coeff, basis)
        Y = Y.real
        return Y

ARGS = {
    'in_channels': 4,
    'out_channels': 3,
    'modes1': 2,
    'modes2': 2
}
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 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
SpectralConv2d Ran
ran on a synthesized input
nboulle/pde-learning/src/fno.py
code served (permissive licence) · get_code("3b603d3349fea9bc")
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, shape (2, 4, 8, 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

class SpectralConv2d(nn.Module):

    def __init__(self, in_channels, out_channels, modes1, modes2):
        super(SpectralConv2d, self).__init__()
        '\n        2D Fourier layer. It does FFT, linear transform, and Inverse FFT.    \n        '
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.modes1 = modes1
        self.modes2 = modes2
        self.scale = 1 / (in_channels * out_channels)
        self.weights1 = nn.Parameter(self.scale * torch.rand(in_channels, out_channels, self.modes1, self.modes2, dtype=torch.cfloat))
        self.weights2 = nn.Parameter(self.scale * torch.rand(in_channels, out_channels, self.modes1, self.modes2, dtype=torch.cfloat))

    def compl_mul2d(self, input, weights):
        return torch.einsum('bixy,ioxy->boxy', input, weights)

    def forward(self, x):
        batchsize = x.shape[0]
        x_ft = torch.fft.rfft2(x)
        out_ft = torch.zeros(batchsize, self.out_channels, x.size(-2), x.size(-1) // 2 + 1, dtype=torch.cfloat, device=x.device)
        out_ft[:, :, :self.modes1, :self.modes2] = self.compl_mul2d(x_ft[:, :, :self.modes1, :self.modes2], self.weights1)
        out_ft[:, :, -self.modes1:, :self.modes2] = self.compl_mul2d(x_ft[:, :, -self.modes1:, :self.modes2], self.weights2)
        x = torch.fft.irfft2(out_ft, s=(x.size(-2), x.size(-1)))
        return x


INIT_ARGS = {
    'in_channels': 3,
    'out_channels': 4,
    'modes1': 4,
    'modes2': 3,
}

ARGS = {
    'x': torch.randn(2, 3, 8, 6),
}

if __name__ == '__main__':
    model = SpectralConv2d(**INIT_ARGS)
    output = model(**ARGS)
    print(f"Input shape: {ARGS['x'].shape}")
    print(f"Output shape: {output.shape}")
    print(f"Expected output shape: (2, {INIT_ARGS['out_channels']}, 8, 6)")
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 4, dtype family float, shape (2, 4, 8, 6) — shape (2, 4, 8, 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: torch and numpy seeded to 0 by the harness immediately before the class was constructed from INIT_ARGS (fixture_check.py)
SpectralConv3d Ran
ran on a synthesized input
gegewen/ufno/ufno.py
pointer only (licence: NOASSERTION) · get_code("43721daaa73dda7d")
How it ran

The body of this sample is withheld: GitHub could not classify the licence of this paper's repository, gegewen/ufno (NOASSERTION). The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

act_filter Ran
ran, violated the contract we drafted
nickhnelsen/random-features-banach/burgers/RFM_burg_vectorized.py
code served (permissive licence) · get_code("ae9b83e2af1bca27")
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 (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 numpy as np

# Create sample numpy arrays with distinct dimensions
r = np.array([[0.1, 0.5, 1.0, 2.0],
              [0.3, 0.8, 1.5, 3.0]])

al_rf = np.array([[0.5, 1.0, 1.5, 2.0],
                  [0.6, 0.9, 1.2, 1.8]])

ARGS = {
    "r": r,
    "al_rf": al_rf
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — 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 (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
batch_train Ran
ran, honoured the contract we drafted
linfengyu77/efkan/run/fourier_2d.py
pointer only (licence: NONE) · get_code("115846cb2a37a207")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, linfengyu77/efkan when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

batch_validate Ran
ran, honoured the contract we drafted
linfengyu77/efkan/run/fourier_2d.py
pointer only (licence: NONE) · get_code("b24c55b23b133810")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, linfengyu77/efkan when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

compl_mul2d Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
this paper's copy was not recorded; identical code first harvested from NeuralOperator/markov_neural_operator
pointer only · get_code("ad9e509694013de8")
How it ran

The body of this sample is withheld: this paper's copy of the code was not recorded (its link names no repository or source path), so no licence was read for it. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

contrastive_loss Ran
ran on a synthesized input
sala-group/autows-bench-101/wrench/endmodel/cosine.py
code served (permissive licence) · get_code("8c515f7346076b72")
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 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 torch.nn.functional as F

torch.manual_seed(0)

# Create small tensors for inputs and feat
# inputs: logits or probabilities, shape (batch_size, num_classes)
# feat: features, shape (batch_size, feature_dim)
batch_size = 2
num_classes = 4
feature_dim = 3

inputs = torch.randn(batch_size, num_classes)
feat = torch.randn(batch_size, feature_dim)

device = torch.device('cpu')

ARGS = {
    'inputs': inputs,
    'feat': feat,
    'margin': 2.0,
    'device': device
}
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 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
elu Ran
ran, honoured the contract we drafted
nickhnelsen/random-features-banach/burgers/RFM_burg_vectorized.py
code served (permissive licence) · get_code("a4620d563e73bf14")
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) and returned ndarray, 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 numpy as np

# Create a small numpy array for testing
r = np.array([[-2.0, -1.0, 0.0, 1.0],
              [2.0, -0.5, 0.5, 3.0]])

# Define alpha parameter
alpha = 1.0

# Construct the ARGS dictionary
ARGS = {
    'r': r,
    'alpha': alpha
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy — 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 (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
evaluate Ran
ran on a synthesized input
sala-group/autows-bench-101/datasets/domainnet/generate_dataset.py
code served (permissive licence) · get_code("921658703d7b0dea")
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 float64, ndim 0, 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 numpy as np

torch.manual_seed(0)

# Define a simple model that the evaluate function can use
class SimpleModel(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Linear(4, 3)
    
    def forward(self, x):
        return self.fc(x)

# Create model instance
model = SimpleModel()

# Create a simple dataloader as a list of (x, y) tuples
# x: batch of 2 samples with 4 features
# y: batch of 2 labels (class indices for 3 classes)
dataloader = [
    (torch.randn(2, 4), torch.tensor([0, 1], dtype=torch.long)),
    (torch.randn(2, 4), torch.tensor([2, 0], dtype=torch.long))
]

# Set device to CPU
device = 'cpu'

# Build ARGS dictionary
ARGS = {
    'model': model,
    'dataloader': dataloader,
    'device': device
}
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 float64, ndim 0, dtype family float — no output shape is stated: observe_signature.py recorded float ndim 0, which disagrees with the fixture run
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_grid2d Ran
ran; our contract draft was wrong, not the code
nickhnelsen/fourier-neural-mappings/models/func_to_func2d.py
code served (permissive licence) · get_code("75b8fd037daf88fb")
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, 3, 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 expects:
# - shape: a tuple/list with 3 elements (batchsize, size_x, size_y)
# - device: a torch device object

shape = (2, 4, 3)  # batchsize=2, size_x=4, size_y=3
device = torch.device('cpu')

ARGS = {
    'shape': shape,
    'device': device
}
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, 3, 2) — shape (2, 4, 3, 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
random_embedding Ran
ran, honoured the contract we drafted
sala-group/autows-bench-101/wrench/layers.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from jiacheng-ye/UANet, is pointer only (licence: NONE) · get_code("ffcb36e0c6ef81dd")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from jiacheng-ye/UANet, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

rf_fourier_batch Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
nickhnelsen/random-features-banach/burgers/RFM_burg_vectorized.py
code served (permissive licence) · get_code("3c41ff4fbe49279b")
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 3, dtype family float, shape (5, 4, 3) 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 numpy as np

# Set random seed for reproducibility
np.random.seed(0)

# Construct arguments for rf_fourier_batch
# a_batch: (K, n) array where K must be > 1 (since a_batch[:-1] is used)
# w_batch: (K, m, 2) array where K must be > 1
# K_fine: integer, default 1025
# nu_rf: float, default 0.0025
# al_rf: integer, default 4

K = 5  # Must be > 1 for a_batch[:-1] and w_batch[:-1] indexing
n = 4  # Number of columns in a_batch
m = 3  # Number of GRFs (second dimension of w_batch)

# Create a_batch: shape (K, n) = (5, 4)
a_batch = np.random.randn(K, n).astype(np.float64)

# Create w_batch: shape (K, m, 2) = (5, 3, 2)
w_batch = np.random.randn(K, m, 2).astype(np.float64)

# Optional parameters with defaults
nu_rf = 0.0025
al_rf = 4
K_fine = 1025

ARGS = {
    'a_batch': a_batch,
    'w_batch': w_batch,
    'nu_rf': nu_rf,
    'al_rf': al_rf,
    'K_fine': K_fine
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, scipy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family float, shape (5, 4, 3) — shape (5, 4, 3) 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
run_supervised Ran
ran on a synthesized input
sala-group/autows-bench-101/fwrench/utils/autows.py
code served (permissive licence) · get_code("4ea52fc0a8f886ab")
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 copy
import numpy as np
from sklearn.linear_model import LogisticRegression
import logging

# Create a simple logger
logger = logging.getLogger('test')
logger.setLevel(logging.INFO)
handler = logging.StreamHandler()
logger.addHandler(handler)

# Create a minimal stand-in class for embedded data with examples and labels
class EmbeddedData:
    def __init__(self, n_samples=2, feature_dim=4):
        self.examples = [{'feature': np.random.randn(feature_dim)} for _ in range(n_samples)]
        self.labels = np.array([0, 1])

# Create a minimal stand-in class for raw data with coverage support
class RawData:
    def __init__(self, n_samples=2):
        self.n_lf = 0
        self.weak_labels = []
        self.n_samples = n_samples
    
    def get_covered_subset(self):
        # Return a modified copy that represents covered subset
        covered = copy.deepcopy(self)
        return covered

# Construct the arguments
valid_data = RawData(n_samples=2)
train_data = RawData(n_samples=3)
test_data = RawData(n_samples=2)

valid_data_embed = EmbeddedData(n_samples=2, feature_dim=4)
train_data_embed = EmbeddedData(n_samples=3, feature_dim=4)
test_data_embed = EmbeddedData(n_samples=2, feature_dim=4)

ARGS = {
    'valid_data': valid_data,
    'train_data': train_data,
    'test_data': test_data,
    'valid_data_embed': valid_data_embed,
    'train_data_embed': train_data_embed,
    'test_data_embed': test_data_embed,
    'logger': logger,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — 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
run_zero_shot_clip Ran
ran on a synthesized input
sala-group/autows-bench-101/fwrench/utils/autows.py
code served (permissive licence) · get_code("97bb008fb8d19225")
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 copy
import numpy as np
from sklearn.metrics import accuracy_score


class MockLogger:
    def info(self, msg):
        pass


class MockDataset:
    def __init__(self, n_samples=2, n_classes=3):
        self.labels = np.array([0, 1])
        self.n_lf = 0
        self.weak_labels = []
        self.n_samples = n_samples
        self.n_classes = n_classes
    
    def get_covered_subset(self):
        return copy.deepcopy(self)


class MockEmbedding:
    def __init__(self, n_samples=2, n_classes=3):
        self.examples = [
            {'feature': np.random.randn(n_classes).astype(np.float32)}
            for _ in range(n_samples)
        ]


valid_data = MockDataset(n_samples=2, n_classes=3)
train_data = MockDataset(n_samples=2, n_classes=3)
test_data = MockDataset(n_samples=2, n_classes=3)

valid_data_embed = MockEmbedding(n_samples=2, n_classes=3)
train_data_embed = MockEmbedding(n_samples=2, n_classes=3)
test_data_embed = MockEmbedding(n_samples=2, n_classes=3)

logger = MockLogger()

ARGS = {
    'valid_data': valid_data,
    'train_data': train_data,
    'test_data': test_data,
    'valid_data_embed': valid_data_embed,
    'train_data_embed': train_data_embed,
    'test_data_embed': test_data_embed,
    'logger': logger
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, sklearn — 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
soft_frequency Ran
ran on a synthesized input
sala-group/autows-bench-101/wrench/endmodel/cosine.py
code served (permissive licence) · get_code("8b6fde8bcb2e818b")
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 torch.nn as nn

torch.manual_seed(0)

# Create a small logits tensor
# Shape: (batch_size=2, num_classes=4)
logits = torch.randn(2, 4)

# ARGS dictionary mapping all parameters
ARGS = {
    "logits": logits,
    "probs": False
}
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, 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
FNO2d Not yet run
unverified (harvested, no recorded run)
nickhnelsen/fourier-neural-mappings/models/func_to_func2d.py
code served (permissive licence) · get_code("ca1b1ee29ab5ade8")
How it ran

no invocation recorded.

InnerProduct1D Not yet run
unverified (harvested, no recorded run)
nickhnelsen/random-features-banach/burgers/RFM_burg_vectorized.py
code served (permissive licence) · get_code("c12dd0141d061b51")
How it ran

no invocation recorded.

RandomFeatureModel Not yet run
unverified (harvested, no recorded run)
nickhnelsen/random-features-banach/burgers/RFM_burg_vectorized.py
code served (permissive licence) · get_code("e5823763a3a7c008")
How it ran

no invocation recorded.

apply Not yet run
unverified (harvested, no recorded run)
sala-group/autows-bench-101/datasets/domainnet/generate_dataset.py
code served (permissive licence) · get_code("07ee8af22f7425f5")
How it ran

no invocation recorded.

calc_loss Not yet run
unverified (harvested, no recorded run)
sala-group/autows-bench-101/wrench/endmodel/cosine.py
code served (permissive licence) · get_code("ad14014186a0bf9e")
How it ran

no invocation recorded.

calc_perprof Not yet run
unverified (harvested, no recorded run)
sala-group/autows-bench-101/optperfprofpy.py
code served (permissive licence) · get_code("090db0ef0c0a0483")
How it ran

no invocation recorded.

check_bert_model Not yet run
unverified (harvested, no recorded run)
sala-group/autows-bench-101/wrench/basemodel.py
code served (permissive licence) · get_code("c9a213796a572f53")
How it ran

no invocation recorded.

check_vision_model Not yet run
unverified (harvested, no recorded run)
sala-group/autows-bench-101/wrench/basemodel.py
code served (permissive licence) · get_code("4ac4f520b6d01aa2")
How it ran

no invocation recorded.

run_train Not yet run
unverified (harvested, no recorded run)
linfengyu77/efkan/run/fourier_2d.py
pointer only (licence: NONE) · get_code("a3813efcc16fedd4")
How it ran

The body of this sample is withheld: GitHub detected no licence in this paper's repository, linfengyu77/efkan when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. No invocation recorded.

train Not yet run
unverified (harvested, no recorded run)
sala-group/autows-bench-101/datasets/domainnet/generate_dataset.py
code served (permissive licence) · get_code("6a451e4111fcdd7e")
How it ran

no invocation recorded.

Also present in other papers' code

Of 33 samples lifted from this paper's linked repositories, 33 carry a function identity and 0 do not. Of the 33 distinct functions with an identity, 7 are also present in other papers whose code we hold (0 with at least one paper dated earlier, 0 the same month, 7 later) and 26 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.

FunctionAlso present inEarliest-datedOthers named
random_embedding 2 other papers
2 later
2012.10608 (2020-12)
Uncertainty-Aware Label Refinement for Sequence Labeling
2210.02724 (2022-10)
Leveraging Instance Features for Label Aggregation in Programmatic Weak Supervision
calc_loss 1 other paper
1 later
2210.02724 (2022-10)
Leveraging Instance Features for Label Aggregation in Programmatic Weak Supervision
check_bert_model 1 other paper
1 later
2210.02724 (2022-10)
Leveraging Instance Features for Label Aggregation in Programmatic Weak Supervision
check_vision_model 1 other paper
1 later
2210.02724 (2022-10)
Leveraging Instance Features for Label Aggregation in Programmatic Weak Supervision
compl_mul2d
brick of this paper's assembly: helper
1 other paper
1 later
2106.06898 (2021-06)
Learning Dissipative Dynamics in Chaotic Systems
contrastive_loss 1 other paper
1 later
2210.02724 (2022-10)
Leveraging Instance Features for Label Aggregation in Programmatic Weak Supervision
soft_frequency 1 other paper
1 later
2210.02724 (2022-10)
Leveraging Instance Features for Label Aggregation in Programmatic Weak Supervision

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

The classical development of neural networks has primarily focused on learning mappings between finite-dimensional Euclidean spaces. Recently, this has been generalized to neural operators that learn mappings between function spaces. For partial differential equations (PDEs), neural operators directly learn the mapping from any functional parametric dependence to the solution. Thus, they learn an entire family of PDEs, in contrast to classical methods which solve one instance of the equation. In this work, we formulate a new neural operator by parameterizing the integral kernel directly in Fourier space, allowing for an expressive and efficient architecture. We perform experiments on Burgers' equation, Darcy flow, and Navier-Stokes equation. The Fourier neural operator is the first ML-based method to successfully model turbulent flows with zero-shot super-resolution. It is up to three orders of magnitude faster compared to traditional PDE solvers. Additionally, it achieves superior accuracy compared to previous learning-based solvers under fixed resolution.

For agents

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

get_harvested_code_for_paper("2010.08895")
get_code_for_paper("2010.08895")
have("2010.08895")

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

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

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

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

Connect an agent — have() is free.