Active Brownian particle vortex mass accumulation around circular obstacles can be accurately predicted by a Graph Neural Network (GNN) surrogate model trained on small-system simulations and extrapolated to the thermodynamic limit.

This discovery has a Claude-generated validation package with a full experimental design.

Precise Hypothesis

Spine & Adversarial ReadReady for validation

“A GNN trained only on small-scale active Brownian particle simulations can predict, without retraining, the vortex mass accumulation around circular obstacles in thermodynamic-limit-scale systems within 10% normalized RMSE.”

• highGraph neural networks with fixed local message-passing radius have a fundamental inductive bias toward local physics; vortex accumulation near an obstacle in active matter can depend on long-range hydrodynamic-like density waves and finite-size-dependent correlation lengths that no local-cutoff GNN can capture, making the extrapolation claim physically implausible for anything beyond dilute, weakly-correlated regimes.
  Partially addressed via multi-hop message passing (4-6 layers, extending effective receptive field) and explicit testing near the MIPS boundary as a stated failure boundary condition; however, the EVP does not yet include a dedicated correlation-length measurement step to quantify how far into the 'long-range' regime the method degrades — this is an acknowledged gap requiring an additional protocol step (measuring density-density correlation length vs. GNN error) before the claim can be fully defended.
• highThe choice of HOOMD-blue/LAMMPS ABP simulation as ground truth and a generic message-passing GNN architecture (rather than e.g. graph networks with explicit equivariance, or Neural Operators like FNO/DeepONet which are purpose-built for PDE/field extrapolation) is not justified against alternative methodologies; a reviewer would ask why GNN-over-particles rather than a continuum-field neural operator approach, given the target quantity (vortex mass accumulation) is fundamentally a coarse-grained density field.
  Not resolved in current EVP. This is a genuine methodology justification gap: the protocol should explicitly include a comparison arm against a Neural Operator baseline (FNO trained on coarse-grained density fields) alongside the mean-field MLP baseline, to justify why particle-graph representation is superior to a field-based approach for this extrapolation task. Recommend adding this as a required ablation before claiming methodological necessity of the GNN-on-graph approach.
• mediumEvidence Strength (0.67) and Verification Confidence (0.00) reported for this discovery suggest no independent verification has occurred yet; the composite score of 0.61 reflects an early-stage, internally-generated hypothesis with no external replication, and claims of '10% RMSE at thermodynamic limit' are currently untested projections rather than measured results.
  Acknowledged directly: this EVP is designed precisely to generate the first independent verification data. Success/failure criteria and abort checkpoints are structured so that a null result (RMSE >20%) is a valid, informative outcome rather than treated as an implementation bug, which mitigates confirmation bias risk in the validation design.

Experimental Protocol

ROI Projection

Implementation Sketch

# Phase A: Data generation
for (Pe, phi) in training_conditions:
    for N in [500, 1000, 2000]:
        run_hoomd_blue_ABP_sim(N, Pe, phi, obstacle=circular, steps=5e4)
        save_trajectory(positions, orientations, velocities)

for (Pe, phi) in eval_conditions:
    run_hoomd_blue_ABP_sim(N=50000, Pe, phi, obstacle=circular, steps=1e5, seeds=3)
    compute_ground_truth_vortex_mass(trajectory) -> M_true

# Phase B: Graph construction + labels
def build_graph(snapshot, cutoff=3.0*sigma):
    nodes = particle_features(pos, orientation, vel)
    edges = radius_graph(pos, cutoff)
    obstacle_node = obstacle_features(center, R)
    return Graph(nodes, edges, obstacle_node)

# Phase C: GNN model
class VortexGNN(nn.Module):
    # 5-layer message passing (EdgeConv/GraphNet blocks), hidden=128
    # readout: per-node density/vorticity contribution -> aggregate to M_pred
    forward(graph) -> local_density_field, M_pred

loss = MSE(M_pred, M_true) + lambda * mass_conservation_penalty

# Phase D: Training + zero-shot extrapolation
train(VortexGNN, small_system_graphs, epochs=200, optimizer=Adam(lr=1e-3))
validate_in_distribution(held_out_small_seeds)

for large_graph in thermodynamic_limit_test_set:
    M_pred = tiled_inference(VortexGNN, large_graph, patch_size=2000, overlap=200)
    compute_rmse(M_pred, M_true)

# Phase E: Ablations
baseline_MLP = train_MLP_on_density_only(...)
compare(VortexGNN, baseline_MLP, no_obstacle_node_variant)