Architecture ideas

Attention variants, state-space and recurrent cells, normalization and token-mixing schemes — each tested against the standard block it replaces.

△ Mechanism confirmed, baseline not beaten 2026

Partial-ReNoise Neural Architecture Mutation

Replace independent architecture generation with a diffusion mutation kernel that starts from a known valid neural architecture, re-noises it for only a fraction of the diffusion horizon, and denoises it conditionally toward a new architecture. The resulting candidates should remain closer to the parent and retain validity at low mutation strength, while larger re-noising fractions should produce greater novelty and access to distinct architectural basins.

Useful8/10
Difficulty6/10
Novelty6/10
Paper: From Generation to Discovery: Diffusion Mutation Kernels for Circuit and Physical Design arXiv:2608.27649
△ Mechanism confirmed, baseline not beaten 2026

Delay-Aware Plug-and-Play Residual Capacity

Construct a residual network from independently attachable modules, but permit only a number of modules whose aggregate feedback gain lies inside a delay-dependent admissible interval. Estimate deployed end-to-end latency and each module's local Jacobian gain, then reject or bypass additional modules when the predicted delayed-loop stability boundary is crossed. This turns variable-width or depth scaling into a falsifiable control problem rather than an empirical choice.

Useful8/10
Difficulty6/10
Novelty7/10
Paper: Admissible Unit Range of Plug-and-Play Distributed Energy Resource (DER) Systems Under Delay: A Scalable Design Framework arXiv:2608.23328
△ Mechanism confirmed, baseline not beaten 2026

Critical-Region LP Policy Layer

Replace black-box differentiation through an embedded LP decision with an analytic Jacobian computed from the LP’s active basis. A neural policy emits LP coefficients or right-hand sides; the LP returns the decision, while the backward pass uses the basis inverse and dual sensitivity, avoiding solver unrolling and finite-difference noise.

Useful8/10
Difficulty5/10
Novelty5/10
Paper: Simulation-Optimization of Systems of Optimizers: Exploiting the Inner Optimization's Geometry arXiv:2608.18129
△ Mechanism confirmed, baseline not beaten 2026

Differentiable Asymmetric Admissibility Layer

Replace hard clipping or post-hoc asymmetric saturation with a dynamic output state that remains inside a prescribed asymmetric interval. A neural network emits a command uc, while the realized output u evolves through the APIR vector field, producing bounded actions, temporal smoothing, and gradients that remain available in the interior.

Useful8/10
Difficulty4/10
Novelty7/10
Paper: Admissibility-Preserving Control for Strict-Feedback Nonlinear Systems with Asymmetric Actuator Constraints arXiv:2608.15375
△ Mechanism confirmed, baseline not beaten 2026

LP-Embedded Input-Convex MLP

Replace a standard ReLU surrogate with an input convex neural network whose hidden-to-hidden weights are constrained to be nonnegative. The network remains piecewise linear and expressive, but its convexity allows downstream minimization to use continuous ReLU epigraph constraints instead of binary activation variables, potentially eliminating the integrality bottleneck of neural optimization.

Useful8/10
Difficulty5/10
Novelty5/10
Paper: Input convex neural networks as surrogates in mathematical optimisation arXiv:2608.09707
△ Mechanism confirmed, baseline not beaten 2026

MCIS Safety Shield for Neural Controllers

Compute an inner approximation of the states from which a neural controller can keep the plant inside a prescribed safe domain indefinitely, then use the resulting regulation map as a safety shield around the network. At each state, the network proposes an action, but the shield projects or replaces it with an action certified to remain in the invariant set.

Useful8/10
Difficulty6/10
Novelty6/10
Paper: Computing the Maximal Controlled Invariant Set for Neural Network Control Systems arXiv:2608.07908
△ Mechanism confirmed, baseline not beaten 2026

Recursive Butterfly Linear Layer

Replace a square dense projection in a Transformer or MLP with a trainable recursive butterfly matrix. The layer preserves multiscale channel interactions while constraining every complementary row-column block to rank at most k, reducing parameters and enabling recursive structured matrix-vector products. Unlike an arbitrary sparse layer, the construction has an explicit recursive factorization and a quasi-optimal approximation guarantee among matrices with the same butterfly rank.

Useful8/10
Difficulty6/10
Novelty5/10
Paper: A recursive butterfly factorization with optimality guarantees arXiv:2607.29361
△ Mechanism confirmed, baseline not beaten 2026

Sparse-Graph Tensorized Linear Layer

Replace a dense neural-network weight tensor with a graph tensor network whose physical modes and internal edge ranks are specified by a sparse rank-adjacency matrix. Unlike tensor-train or hierarchical Tucker layers, the graph can contain selected cycles and skip connections between tensor modes, allowing the factorization topology to match correlations in the weight tensor. Fit the layer with GTN-SVD at a prescribed tolerance and compare accuracy, parameter count, and tensor-contraction…

Useful8/10
Difficulty6/10
Novelty5/10
Paper: Computing with traceable tensor networks arXiv:2608.02849
△ Mechanism confirmed, baseline not beaten 2026

Certified contraction implicit layer

Replace a deep feed-forward block by the fixed point z=phi(Wz+Vx+b), with the recurrent weight W constrained so that the fixed point is unique for every input. The same condition makes forward fixed-point iteration stable and makes implicit differentiation well-conditioned, allowing depth-independent memory usage while providing a measurable spectral failure boundary.

Useful8/10
Difficulty5/10
Novelty4/10
Paper: Implicit Neural Networks as Static Controllers: Certificates and Performance Separation arXiv:2607.11122
△ Mechanism confirmed, baseline not beaten 2026

Accumulator-Carrying Picard ResNet

Build a residual module whose state explicitly contains both a persistent context representation and an accumulator. Each residual branch computes one learned correction and adds it to the accumulator, instead of forcing every layer to represent the complete output from scratch. This provides a concrete solver-like architecture for high-dimensional regression and iterative latent prediction.

Useful7/10
Difficulty4/10
Novelty5/10
Paper: Residual neural networks overcome the curse of dimensionality for semilinear heat equations arXiv:2609.03626
△ Mechanism confirmed, baseline not beaten 2026

Degree-Calibrated Stable Residual Flow

Construct a continuous-depth or recurrent residual block with a prescribed polynomial Lyapunov decay near its equilibrium. The architecture combines a fixed radial stabilizer with a learned component that is constrained to have zero radial projection, allowing slow algebraic transients and long memory while preventing asymptotic hidden-state growth.

Useful7/10
Difficulty6/10
Novelty8/10
Paper: On a Gradation for Asymptotic Stability arXiv:2609.03120
△ Mechanism confirmed, baseline not beaten 2026

Regularity-Matched Random Fourier Layer

Replace the usual isotropic Gaussian random Fourier features with a frequency distribution matched to the expected spectral regularity of the target function. For coordinate fields, operator-learning maps, or PDE solution surrogates, this should place more features where the target Fourier energy lies and improve approximation at the same feature count. Stabilize the resulting feature matrix with whitening or ridge regression because spectral accuracy can create severe ill-conditioning.

Useful7/10
Difficulty4/10
Novelty5/10
Paper: Spectral Convergence of Random Feature Method in Multiple Dimensions arXiv:2609.03401
△ Mechanism confirmed, baseline not beaten 2026

Block-TT 3D Neural Operator

Represent a large linear map acting on a Cartesian 3D grid and multiple physical channels as a TT-matrix, while retaining separate TT blocks for channel couplings that have different semantics. Apply the layer by sequential contractions with TT cores rather than materializing a dense matrix or a full 3D convolution kernel. Rank truncation provides an explicit accuracy-versus-memory knob and can be applied after optimizer updates.

Useful7/10
Difficulty5/10
Novelty5/10
Paper: Tensor-Train Methods for 3D Linear Elasticity: Block and Global Operator Representations with Solver Performance Analysis arXiv:2608.23595
△ Mechanism confirmed, baseline not beaten 2026

Multiplicity-balanced symmetric interaction layer

Replace a dense degree-m tensor interaction layer by a symmetric orbit-parameterized layer with one parameter per exponent vector and explicit multinomial scaling. This preserves the contribution of all ordered tensor entries represented by one orbit, while reducing parameter count and avoiding the amplitude distortion of unweighted monomial compression.

Useful7/10
Difficulty4/10
Novelty7/10
Paper: Orbit compression and asymptotic contractivity for symmetric Bohnenblust--Hille inequalities arXiv:2608.13753
△ Mechanism confirmed, baseline not beaten 2026

Doubly-Stochastic Hyper-Residual Blocks

Replace a single residual stream or unconstrained hyper-connection with S parallel feature streams whose cross-stream mixing matrix is doubly stochastic. Parameterize the matrix with Sinkhorn normalization so every layer preserves total stream mass while still learning adaptive information routing. This is a low-overhead alternative to dense cross-stream attention and should reduce stream explosion, collapse, and sensitivity to depth.

Useful7/10
Difficulty5/10
Novelty7/10
Paper: Resource-efficient Semantic Coding Schemes with Manifold-constrained Hyper-connections arXiv:2608.13253
△ Mechanism confirmed, baseline not beaten 2026

Measurement-Space Neural Operator with Mesh Transfer

Build a neural operator around explicit input and output measurement spaces rather than forcing the network to consume and emit a fixed grid. The same learned latent surrogate can be reused on alternative sensor layouts or query meshes through reconstruction and re-encoding maps, with a consistency loss enforcing agreement between measurement pipelines.

Useful7/10
Difficulty6/10
Novelty5/10
Paper: Kernel Methods for Learning Operators with Multiple Inputs and Outputs arXiv:2608.11831
△ Mechanism confirmed, baseline not beaten 2026

Finite Hyperplane Representative Verification

Replace dense continuous action search during neural-controller verification with a finite set of representative inputs induced by affine pieces of the interval neural dynamics. This makes safety checking parallel over state cells and candidate actions, enabling much cheaper certification or repeated safe-set updates.

Useful7/10
Difficulty7/10
Novelty8/10
Paper: Computing the Maximal Controlled Invariant Set for Neural Network Control Systems arXiv:2608.07908
△ Mechanism confirmed, baseline not beaten 2026

Magnitude-Ordered Certified Binary Accumulation

Replace fixed-length binary dot products with accumulations whose terms are processed in descending order of weight magnitude. Stop as soon as the current partial sum is larger in magnitude than the total absolute magnitude of all remaining terms; the output sign is then guaranteed to equal the full dot-product sign, eliminating unnecessary additions without changing accuracy.

Useful7/10
Difficulty4/10
Novelty7/10
Paper: Threshold-Based Early Stopping of Accumulations in Neural Networks with Binary Activation arXiv:2608.06177
△ Mechanism confirmed, baseline not beaten 2026

Toda-Krylov adaptive polynomial layer

Replace a fixed-order polynomial or recurrent state-space block by an Arnoldi basis built from a learned operator and the current input, and use subdiagonal coefficients as geometry-aware gates over Krylov depth. The gates quantify how much genuinely new direction each operator application contributes, allowing the layer to stop early near Krylov breakdown and suppress redundant or unstable directions.

Useful7/10
Difficulty5/10
Novelty7/10
Paper: Two-dimensional Toda--Arnoldi correspondence: Holomorphic Krylov geometry and counterdiabatic transport arXiv:2608.04850
△ Mechanism confirmed, baseline not beaten 2026

Warm-Started Exact Rank Pruning

Parameterize a trainable weight update as \(\Delta W=UV^{\top}\) with an excessive initial rank \(r\), and penalize active columns using an exact column \(\ell_{2,0}\) penalty. Increase \(\lambda\) along a warm-started path and hard-delete redundant paired columns, producing an automatically selected rank without training a separate model for every candidate rank. Apply scale balancing after each update so pruning decisions are invariant to reciprocal rescaling of factor pairs.

Useful7/10
Difficulty5/10
Novelty6/10
Paper: Automatic Model-Order Selection for Nonnegative Matrix Factorization via Column $\ell_{2,0}$ Regularization arXiv:2607.24193
△ Mechanism confirmed, baseline not beaten 2026

Exact Neural de Rham Backbone

Replace independently parameterized scalar, vector, and higher-order neural outputs with consecutive spaces of ReLU-power differential forms linked by an exact exterior-derivative layer. The network can then produce curl-free, divergence-free, or more general closed fields by construction, while the complex prevents artificial null-space modes that commonly appear when differential constraints are enforced only through sampled residual losses.

Useful7/10
Difficulty5/10
Novelty7/10
Paper: ReLU$^k$ Neural de Rham Complexes arXiv:2607.22478
△ Mechanism confirmed, baseline not beaten 2026

Cholesky-Structured SPD Classifier

Build an SPD classifier and residual head directly from Cholesky factors, using lower-triangular differences and matrix-power terms instead of generic eigendecomposition-based logarithm operators. This retains covariance geometry while making positive-definiteness automatic and backpropagation more numerically stable for minibatch training.

Useful7/10
Difficulty6/10
Novelty7/10
Paper: Riemannian Deep Learning: Modules, Networks, and Geometries arXiv:2607.19305
△ Mechanism confirmed, baseline not beaten 2026

Identity-Paired Progressive Depth

Grow a neural network by appending a trainable block together with an analytically initialized inverse block, so the newly added depth is exactly the identity at insertion time. After insertion, untie and optimize the two blocks independently; this preserves the current function while providing additional trainable degrees of freedom. For architectures with one expensive mixing operation followed by cheap channelwise blocks, the same construction can increase depth without repeatedly paying for…

Useful7/10
Difficulty5/10
Novelty5/10
Paper: Identity-Paired Progressive Depth Training: When Trainability Persists Beyond Expressibility arXiv:2607.16800
△ Mechanism confirmed, baseline not beaten 2026

Event-driven shared-neuron graph

Replace a conventional feed-forward block with a sparse temporal graph whose hidden units are shared across many computation paths. Each arriving message updates a shared accumulator, applies a nonlinear response, and schedules delayed messages to downstream neurons; constructive or destructive interaction emerges when multiple paths visit the same unit.

Useful7/10
Difficulty6/10
Novelty8/10
Paper: NeuronSoup: Evolving Asynchronous, Shared-Neuron Temporal Graphs without Backpropagation arXiv:2607.15217