SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2603.12296 · 2026

Synthetic Data Generation for Brain-Computer Interfaces: Overview, Benchmarking, and Future Directions

Dongrui Wu, Ziwei Wang, Xingyi He, Zhentao He, Siyang Li, Hongbin Wang, Tianwang Jia, Jingwei Luo, Xiaoqing Chen

arXiv · PDF · Open in the Atlas

Code that ran

18 of 18 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; 1 honoured the contract we drafted, 2 violated it and 0 have no contract verdict; 15 failures of our instrument; 0 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/2603.12296.json · badge: /api/ran/2603.12296.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
wzwvv/DG4BCI canonical (classifier label)
classifier basis: census
18 ran · 0 no recorded run
FunctionStatusWhere it lives
compute_cosine_similarity Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
wzwvv/DG4BCI/Synthetic_Data_Evaluation/CosineSim.py
code served (permissive licence) · get_code("fe86c613fc8212a2")
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 float, 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 numpy as np

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

# Create small feature arrays
# real_features: shape (N, D) - let's use (2, 4) for 2 real samples, 4 dimensions
real_features = np.random.randn(2, 4).astype(np.float64)

# gen_features: shape (M, D) - let's use (3, 4) for 3 generated samples, 4 dimensions
gen_features = np.random.randn(3, 4).astype(np.float64)

# aggregate parameter - test with 'mean_vectors' mode
aggregate = 'mean_vectors'

# axis parameter - optional, set to None (default)
axis = None

ARGS = {
    'real_features': real_features,
    'gen_features': gen_features,
    'aggregate': aggregate,
    'axis': axis
}
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 float, 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
compute_cosine_similarity_per_sample Ran
ran, violated the contract we drafted
wzwvv/DG4BCI/Synthetic_Data_Evaluation/CosineSim.py
code served (permissive licence) · get_code("570e5a95e156caf1")
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 float, 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 numpy as np

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

# Create small feature matrices
# real_features: (N, D) shape - N samples, D dimensions
# gen_features: (N, D) shape - must match real_features shape
N = 2  # number of samples
D = 4  # feature dimension

# Generate random feature vectors
real_features = np.random.randn(N, D).astype(np.float64)
gen_features = np.random.randn(N, D).astype(np.float64)

ARGS = {
    "real_features": real_features,
    "gen_features": gen_features,
}
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 float, 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
compute_entropy_diversity Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
wzwvv/DG4BCI/Synthetic_Data_Evaluation/Entropy.py
code served (permissive licence) · get_code("954d5301fd9a4c0e")
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 float, 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 numpy as np

# Construct valid arguments for compute_entropy_diversity
gen_features = np.random.randn(8, 5)  # (M=8 samples, D=5 dimensions)
n_bins = 30

ARGS = {
    "gen_features": gen_features,
    "n_bins": n_bins,
}
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 float, 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
compute_entropy_stats Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
wzwvv/DG4BCI/Synthetic_Data_Evaluation/Entropy.py
code served (permissive licence) · get_code("c708cdcc27605036")
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, ndim 1, 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 numpy as np

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

# Create small sample feature arrays
# real_features: shape (N, D) where N=5 samples, D=4 dimensions
real_features = np.random.randn(5, 4).astype(np.float64)

# gen_features: shape (M, D) where M=3 samples, D=4 dimensions
gen_features = np.random.randn(3, 4).astype(np.float64)

# Number of bins for histogram
n_bins = 10

ARGS = {
    "real_features": real_features,
    "gen_features": gen_features,
    "n_bins": n_bins,
}
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 tuple, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
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
compute_fid Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
wzwvv/DG4BCI/Synthetic_Data_Evaluation/FID.py
code served (permissive licence) · get_code("efde5861d5b96c8c")
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 float, 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 numpy as np

np.random.seed(0)

# Create small feature arrays for real and generated data
# Using distinct dimensions: 8 samples, 4 features
real_features = np.random.randn(8, 4).astype(np.float32)
gen_features = np.random.randn(8, 4).astype(np.float32)

ARGS = {
    "real_features": real_features,
    "gen_features": gen_features,
    "eps": 1e-06,
    "normalize": True,
}
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 float, 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
compute_inception_score Ran
ran; our contract draft was wrong, not the code
wzwvv/DG4BCI/Synthetic_Data_Evaluation/IS.py
code served (permissive licence) · get_code("39e062653ef7d4d5")
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, ndim 1, 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 numpy as np

# Set random seeds for reproducibility
np.random.seed(42)

# Create small feature matrices
# real_features: (N, D) - 8 real samples with 4 features
real_features = np.random.randn(8, 4).astype(np.float32)

# gen_features: (M, D) - 6 generated samples with 4 features
gen_features = np.random.randn(6, 4).astype(np.float32)

# real_labels: (N,) - class labels for real samples, in range [0, num_classes-1]
real_labels = np.array([0, 1, 0, 1, 0, 1, 0, 1], dtype=np.int32)

# num_classes: 2 classes
num_classes = 2

# n_splits: split generated samples into 2 splits for averaging
n_splits = 2

# random_state: seed for reproducibility
random_state = 42

ARGS = {
    "real_features": real_features,
    "gen_features": gen_features,
    "real_labels": real_labels,
    "num_classes": num_classes,
    "n_splits": n_splits,
    "random_state": random_state,
}
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, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
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
compute_inception_score_simple Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
wzwvv/DG4BCI/Synthetic_Data_Evaluation/IS.py
code served (permissive licence) · get_code("97f0c97ed890a815")
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 float, 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 numpy as np

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

# Create small generated features: shape (M, D) = (12, 8)
# M=12 samples, D=8 dimensions
gen_features = np.random.randn(12, 8).astype(np.float32)

# real_labels is optional and unused in the function
real_labels = None

# num_classes is optional and unused in the function
num_classes = None

# n_bins for histogram discretization
n_bins = 10

ARGS = {
    "gen_features": gen_features,
    "real_labels": real_labels,
    "num_classes": num_classes,
    "n_bins": n_bins,
}
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 float, 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
compute_jaccard_similarity Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
wzwvv/DG4BCI/Synthetic_Data_Evaluation/JaccardSim.py
code served (permissive licence) · get_code("a06161606ce640b5")
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 float, 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 numpy as np

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

# Create sample feature arrays
# real_features: shape (N, D) where N=5 samples, D=4 features
real_features = np.random.randn(5, 4) * 10 + 50

# gen_features: shape (M, D) where M=3 samples, D=4 features
gen_features = np.random.randn(3, 4) * 10 + 50

ARGS = {
    'real_features': real_features,
    'gen_features': gen_features,
    'binarize': 'median',
    'threshold': None,
    'per_feature': False,
}
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 float, 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
compute_jaccard_similarity_1to1 Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
wzwvv/DG4BCI/Synthetic_Data_Evaluation/JaccardSim.py
code served (permissive licence) · get_code("956dc76653b8ab1a")
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 float, 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 numpy as np

np.random.seed(0)

# Create small feature matrices: (N=2, D=4)
# Real features: 2 samples, 4 dimensions
real_features = np.array([
    [0.1, 0.5, 0.3, 0.8],
    [0.2, 0.6, 0.4, 0.7]
], dtype=np.float64)

# Generated features: same shape
gen_features = np.array([
    [0.15, 0.55, 0.35, 0.75],
    [0.25, 0.65, 0.45, 0.72]
], dtype=np.float64)

ARGS = {
    'real_features': real_features,
    'gen_features': gen_features,
    'binarize': 'median'
}
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 float, 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
compute_mmd Ran
ran, violated the contract we drafted
wzwvv/DG4BCI/Synthetic_Data_Evaluation/MMD.py
code served (permissive licence) · get_code("767ba4732682b723")
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 float, 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 numpy as np

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

# Create small sample data for real and generated distributions
# Shape: (n_samples, n_features)
real = np.random.randn(2, 4).astype(np.float32)
gen = np.random.randn(3, 4).astype(np.float32)

ARGS = {
    "real": real,
    "gen": gen,
    "kernel": "rbf",
    "gamma": None,
}
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 float, 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
compute_prediction_entropy Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
wzwvv/DG4BCI/Synthetic_Data_Evaluation/Entropy.py
code served (permissive licence) · get_code("8d63492121e4097e")
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, ndim 1, 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 numpy as np

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

# Create small synthetic data
N = 8  # number of real samples
M = 6  # number of generated samples
D = 4  # feature dimension
num_classes = 3

# Real features: (N, D)
real_features = np.random.randn(N, D).astype(np.float32)

# Generated features: (M, D)
gen_features = np.random.randn(M, D).astype(np.float32)

# Real labels: (N,) with values in [0, num_classes)
real_labels = np.array([0, 1, 2, 0, 1, 2, 0, 1], dtype=np.int32)

ARGS = {
    "real_features": real_features,
    "gen_features": gen_features,
    "real_labels": real_labels,
    "num_classes": num_classes,
}
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, ndim 1, dtype family float — a tuple output has no array shape of its own; none is stated
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
compute_snr_eeg Ran
ran; our contract draft was wrong, not the code
wzwvv/DG4BCI/Synthetic_Data_Evaluation/SNR.py
code served (permissive licence) · get_code("532e1f1eee53c9d7")
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 float, 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 numpy as np

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

# Create sample EEG data
# Shape: (N, C, T) where N=batch, C=channels, T=time
real_eeg = np.random.randn(2, 4, 8).astype(np.float64)
gen_eeg = np.random.randn(2, 4, 8).astype(np.float64)

ARGS = {
    "real_eeg": real_eeg,
    "gen_eeg": gen_eeg,
    "per_channel": False,
    "axis_time": -1,
}
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 float, 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
compute_snr_features Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
wzwvv/DG4BCI/Synthetic_Data_Evaluation/SNR.py
code served (permissive licence) · get_code("b52800d247feccae")
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 float, 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 numpy as np

# Create small feature arrays
np.random.seed(0)

# Real features: 5 samples, 4 dimensions
real_features = np.random.randn(5, 4).astype(np.float64)

# Generated features: 3 samples, 4 dimensions
gen_features = np.random.randn(3, 4).astype(np.float64)

# Method parameter
method = 'mean_std'

ARGS = {
    'real_features': real_features,
    'gen_features': gen_features,
    'method': method,
}
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 float, 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
compute_snr_simple Ran
ran; our contract draft was wrong, not the code
wzwvv/DG4BCI/Synthetic_Data_Evaluation/SNR.py
code served (permissive licence) · get_code("7f4a0c696d170ab7")
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 float, 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 numpy as np

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

# Create small numpy arrays for real and generated features
# Shape: (batch_size, feature_dim)
real_features = np.random.randn(2, 4).astype(np.float64)
gen_features = np.random.randn(2, 4).astype(np.float64)

# Small epsilon value for numerical stability
eps = 1e-08

ARGS = {
    "real_features": real_features,
    "gen_features": gen_features,
    "eps": eps,
}
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 float, 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
data_alignment_returnref Ran
ran, honoured the contract we drafted
wzwvv/DG4BCI/Synthetic_Data_Generation/Knowledge_based/CR.py
code served (permissive licence) · get_code("948ad027c94c7d52")
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 numpy as np
from scipy.linalg import fractional_matrix_power

# Create a small EEG data array
# Shape: (batch_size, channels, time_samples)
# Using distinct dimensions: 2 samples, 4 channels, 5 time points
np.random.seed(0)
x = np.random.randn(2, 4, 5)

ARGS = {
    "x": x
}
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 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
data_aug Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
wzwvv/DG4BCI/Synthetic_Data_Generation/Knowledge_based/Baselines.py
code served (permissive licence) · get_code("a8082675d383dd03")
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 numpy as np
from scipy.signal import hilbert

np.random.seed(0)

# Create sample data with shape (num_samples, time_steps, num_channels)
# Using small dimensions: 2 samples, 128 time steps, 22 channels
num_samples = 2
time_steps = 128
num_channels = 22

data = np.random.randn(num_samples, time_steps, num_channels).astype(np.float32)

# Create labels - all non-negative so they pass the if labels[i] >= 0 check
labels = np.array([0, 1], dtype=np.int32)

# size parameter should match the time_steps dimension
size = time_steps

# flag_aug is a tuple/list of 4 boolean flags: [mult_flag, noise_flag, neg_flag, freq_mod_flag]
flag_aug = [True, True, True, True]

ARGS = {
    'data': data,
    'labels': labels,
    'size': size,
    'flag_aug': flag_aug
}
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 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
data_mult_f Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
wzwvv/DG4BCI/Synthetic_Data_Generation/Knowledge_based/Baselines.py
code served (permissive licence) · get_code("191cd19232b470c3")
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 numpy as np

# Construct small valid data and labels
# data should be indexable and support multiplication
# labels should be indexable and support comparison with >= 0

batch_size = 2
size = 4
n_channels = 22

# Create data: shape (batch_size, size, n_channels) or flat that can be reshaped
# The function multiplies data[i] by a scalar and reshapes at the end
# So data[i] should be something that when multiplied gives a numeric array
data = np.random.randn(batch_size, size, n_channels).astype(np.float32)

# Create labels: some >= 0 (will be kept), some < 0 (will be filtered out)
labels = np.array([0.5, -1.0])  # First will pass filter, second will not

ARGS = {
    "data": data,
    "labels": labels,
    "size": size,
    "n_channels": n_channels,
}
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 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
data_noise_f Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
wzwvv/DG4BCI/Synthetic_Data_Generation/Knowledge_based/Baselines.py
code served (permissive licence) · get_code("c5a2c7a7f9df455b")
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 numpy as np

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

# Create small sample data
# data should be a list of 2D arrays (time steps x channels)
data = [
    np.random.randn(10, 22),  # 10 time steps, 22 channels
    np.random.randn(10, 22),  # 10 time steps, 22 channels
]

# Create labels (all non-negative to pass the if condition)
labels = np.array([0, 1])

# size parameter should match the first dimension after reshape
# The function reshapes to [-1, size, n_channels]
# With 2 samples of shape (10, 22), flattened is 2*10*22 = 440 elements
# Reshaped to [-1, size, 22] means -1 = 440 / (size * 22)
# If size = 10, then -1 = 440 / (10 * 22) = 2
size = 10

# n_channels is the number of channels per time step
n_channels = 22

ARGS = {
    "data": data,
    "labels": labels,
    "size": size,
    "n_channels": n_channels,
}
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 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

Also present in other papers' code

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

Deep learning has achieved transformative performance across diverse domains, largely driven by large-scale and high-quality training data. In contrast, the development of brain-computer interfaces (BCIs) is fundamentally constrained by limited, heterogeneous, and privacy-sensitive neural recordings. Generating synthetic yet physiologically plausible brain signals has therefore emerged as a promising strategy to mitigate data scarcity, improve model generalization, and support data-efficient BCIs. This survey provides a comprehensive review of synthetic brain data generation for BCIs, covering methodological taxonomies, benchmark experiments, evaluation metrics, key applications, and future directions. We systematically categorize existing generation approaches into four types: signaltransformation-based, feature-based, model-based, and translation-based generation, and discuss their characteristics, advantages, and limitations. Furthermore, we benchmark representative brain signal generation approaches across four BCI paradigms, including motor imagery, epileptic seizure detection, steady-state visually evoked potentials, and auditory attention detection, to provide an objective comparison of their downstream utility. We also summarize evaluation principles for generated brain signals from multiple perspectives, including signal realism, physiological plausibility, downstream utility, and privacy preservation. Finally, we discuss the potential and challenges of current generation approaches and outline future research directions toward accurate, data-efficient, generalizable, and privacy-aware BCI systems. The benchmark codebase is available at https://github.com/wzwvv/DG4BCI.

For agents

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

get_harvested_code_for_paper("2603.12296")
get_code_for_paper("2603.12296")
have("2603.12296")

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

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

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

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

Connect an agent — have() is free.