Download notebook

Reproducing SILVA and Source Methods¶

This lab makes the reproduction boundary executable. It inspects all canonical families, resolves aliases to their real constructor signatures, builds a custom conditioned equilibrium, adapts a joint diffusion trajectory to an observation-conditioned restoration step, and emits a structured run record.

The universal equation is

$$ \begin{aligned} z_0 &= I_\eta(x), \\ z^\star &= T_\theta(z^\star,x), \\ \widehat y &= Q_\psi(z^\star). \end{aligned} $$

A source method is reproduced only when its equation, data release, preprocessing, dimensions, numerical settings, training schedule, checkpoints, seeds, and metrics are all declared. Compact checks verify mechanisms; they do not stand in for an unexecuted published benchmark.

Numbered literature: [1], [4], [5], [7], [8], [9], [22], [23], [31], [32], [36], [37], [38], [43], [44], [45], [46], [47], [48], [49], [50], [51], [52], [53], [58], [59], [60], [61], [62], [63], [64], [65], [66], [67], [68], [69], [70], [71], [72], [73], [74]. Each number opens the complete citation and its primary external source.

In [1]:

from dataclasses import asdict

import torch
from torch import nn

from silva_networks import (
    SILVAConditionedEquilibrium,
    SILVADiffusionEquilibrium,
    SILVAZeroInitializer,
    SolverConfig,
    all_silva_reproduction_specs,
    audit_silva_reproduction_specs,
    silva_reproduction_spec,
    validate_silva_transition,
)

torch.manual_seed(27)
assert audit_silva_reproduction_specs() == ()
specs = all_silva_reproduction_specs()
assert len(specs) == 64
[(spec.family, spec.source_relation, spec.verification_level) for spec in specs]

from dataclasses import asdict import torch from torch import nn from silva_networks import ( SILVAConditionedEquilibrium, SILVADiffusionEquilibrium, SILVAZeroInitializer, SolverConfig, all_silva_reproduction_specs, audit_silva_reproduction_specs, silva_reproduction_spec, validate_silva_transition, ) torch.manual_seed(27) assert audit_silva_reproduction_specs() == () specs = all_silva_reproduction_specs() assert len(specs) == 64 [(spec.family, spec.source_relation, spec.verification_level) for spec in specs]

Out[1]:

[('silva_layer', 'silva-native', 'compact-verified'),
 ('silva_graph', 'silva-native', 'compact-verified'),
 ('silva_graph_preset', 'silva-native', 'compact-verified'),
 ('silva_cortex', 'silva-native', 'compact-verified'),
 ('silva_cortex_network', 'silva-native', 'compact-verified'),
 ('silva_image_cortex', 'silva-native', 'compact-verified'),
 ('compact_deq', 'paper-adaptation', 'compact-verified'),
 ('message_passing_deq', 'paper-adaptation', 'compact-verified'),
 ('mdeq', 'paper-adaptation', 'compact-verified'),
 ('multiscale_vision_deq', 'paper-adaptation', 'compact-verified'),
 ('sequence_deq', 'paper-adaptation', 'compact-verified'),
 ('implicit_graph', 'paper-adaptation', 'compact-verified'),
 ('implicit_neural_representation', 'paper-adaptation', 'compact-verified'),
 ('diffusion_equilibrium', 'paper-adaptation', 'compact-verified'),
 ('scientific_operator', 'paper-adaptation', 'compact-verified'),
 ('fourier_operator_equilibrium', 'paper-adaptation', 'compact-verified'),
 ('implicit_time_step', 'paper-adaptation', 'compact-verified'),
 ('silva_deq_flow', 'paper-adaptation', 'compact-verified'),
 ('raft_deq_flow', 'paper-adaptation', 'compact-verified'),
 ('quadratic_optimization', 'paper-adaptation', 'compact-verified'),
 ('silva_projected_qp', 'paper-adaptation', 'compact-verified'),
 ('silva_fno_deq', 'paper-adaptation', 'compact-verified'),
 ('silva_physics_graph_deq', 'paper-adaptation', 'compact-verified'),
 ('silva_homotopy_equilibrium', 'paper-adaptation', 'compact-verified'),
 ('silva_distributional_deq', 'paper-adaptation', 'compact-verified'),
 ('silva_monotone_graph_equilibrium', 'paper-adaptation', 'compact-verified'),
 ('silva_generative_equilibrium_transformer',
  'paper-adaptation',
  'compact-verified'),
 ('silva_poisson_mirror_equilibrium', 'paper-adaptation', 'compact-verified'),
 ('silva_physics_informed_equilibrium',
  'paper-adaptation',
  'compact-verified'),
 ('silva_implicit_dae_step', 'paper-adaptation', 'compact-verified'),
 ('silva_consistency_deq', 'paper-adaptation', 'compact-verified'),
 ('silva_psi_gnn', 'paper-adaptation', 'compact-verified'),
 ('silva_ifno', 'paper-adaptation', 'compact-verified'),
 ('silva_snarf', 'paper-adaptation', 'compact-verified'),
 ('silva_mesh_inference', 'paper-adaptation', 'compact-verified'),
 ('silva_physics_guided_diffusion_pde',
  'paper-adaptation',
  'compact-verified'),
 ('silva_therino', 'paper-adaptation', 'compact-verified'),
 ('silva_fixed_point_diffusion', 'paper-adaptation', 'compact-verified'),
 ('silva_monotone_operator_equilibrium',
  'paper-adaptation',
  'compact-verified'),
 ('silva_positive_concave_equilibrium',
  'paper-adaptation',
  'compact-verified'),
 ('silva_non_euclidean_equilibrium', 'paper-adaptation', 'compact-verified'),
 ('silva_efficient_infinite_graph', 'paper-adaptation', 'compact-verified'),
 ('silva_multiscale_graph_implicit', 'paper-adaptation', 'compact-verified'),
 ('silva_delta_equilibrium', 'paper-adaptation', 'compact-verified'),
 ('silva_hyper_deq', 'paper-adaptation', 'compact-verified'),
 ('silva_quantum_deq', 'paper-adaptation', 'compact-verified'),
 ('silva_bayesian_deq', 'paper-adaptation', 'compact-verified'),
 ('silva_joint_inference_equilibrium', 'paper-adaptation', 'compact-verified'),
 ('silva_implicit_spatiotemporal', 'paper-adaptation', 'compact-verified'),
 ('silva_certified_equilibrium', 'paper-adaptation', 'compact-verified'),
 ('silva_lipschitz_mdeq', 'paper-adaptation', 'compact-verified'),
 ('silva_subhomogeneous_equilibrium', 'paper-adaptation', 'compact-verified'),
 ('silva_algorithmic_reasoner', 'paper-adaptation', 'compact-verified'),
 ('silva_hamiltonian_equilibrium', 'paper-adaptation', 'compact-verified'),
 ('silva_inverse_imaging_equilibrium', 'paper-adaptation', 'compact-verified'),
 ('silva_snapshot_compressive_equilibrium',
  'paper-adaptation',
  'compact-verified'),
 ('silva_magnetic_particle_equilibrium',
  'paper-adaptation',
  'compact-verified'),
 ('silva_sparse_hyperspectral_equilibrium',
  'paper-adaptation',
  'compact-verified'),
 ('silva_serialized_smoothing_equilibrium',
  'paper-adaptation',
  'compact-verified'),
 ('silva_diffusion_restoration_equilibrium',
  'paper-adaptation',
  'compact-verified'),
 ('silva_recurrent_equilibrium_network',
  'paper-adaptation',
  'compact-verified'),
 ('silva_lipschitz_robust_equilibrium',
  'paper-adaptation',
  'compact-verified'),
 ('silva_image_matting_equilibrium', 'paper-adaptation', 'compact-verified'),
 ('silva_dynamic_economic_equilibrium',
  'paper-adaptation',
  'compact-verified')]

Inspect the Complete Contract¶

The record separates scientific and numerical responsibilities:

Field	Question answered
equation	What state-preserving map is solved?
source_relation	Is this native SILVA or a cited mechanism adaptation?
datasets and preprocessing	What observations enter the experiment?
data_sources and data_access	Where can the data be obtained or regenerated, and under which conditions?
storage_plan	How should raw data, processed shards, trajectories, and checkpoints be budgeted?
compact_data	Which deterministic package fixture validates the mechanism first?
source_scale_steps	Which ordered steps turn that fixture into a cited full experiment?
metrics	What must be measured besides solver residual?
notebooks and tests	What executable evidence exists locally?
configurable_parts	Which operators and scale axes may be changed?
preserved_mechanisms	Which source mechanisms remain present?
silva_extensions	Which components may be replaced or enlarged inside SILVA?
benchmark_requirements	Which source-protocol obligations remain for benchmark equivalence?
constructor_signature	Which exact public arguments are accepted?

The residual

$$ r(z^\star,x)=T_\theta(z^\star,x)-z^\star $$

checks the equilibrium equation. It does not measure classification accuracy, field error, physical residual, FID, endpoint error, or reconstruction quality.

In [2]:

for family in (
    "fno_deq",
    "mignn",
    "pideq",
    "deq_ddim",
    "mondeq",
    "pcdeq",
    "nemon",
    "eignn",
    "mgnni",
    "deltadeq",
):
    spec = silva_reproduction_spec(family)
    print("\n", spec.family)
    print(" equation:", spec.equation)
    print(" preserves:", spec.preserved_mechanisms)
    print(" SILVA extensions:", spec.silva_extensions)
    print(" benchmark requires:", spec.benchmark_requirements)
    print(" data:", spec.datasets)
    print(" data sources:", spec.data_sources)
    print(" access:", spec.data_access)
    print(" storage:", spec.storage_plan)
    print(" source-scale steps:", spec.source_scale_steps)
    print(" metrics:", spec.metrics)
    print(" signature:", spec.constructor_signature)

for family in ( "fno_deq", "mignn", "pideq", "deq_ddim", "mondeq", "pcdeq", "nemon", "eignn", "mgnni", "deltadeq", ): spec = silva_reproduction_spec(family) print("\n", spec.family) print(" equation:", spec.equation) print(" preserves:", spec.preserved_mechanisms) print(" SILVA extensions:", spec.silva_extensions) print(" benchmark requires:", spec.benchmark_requirements) print(" data:", spec.datasets) print(" data sources:", spec.data_sources) print(" access:", spec.data_access) print(" storage:", spec.storage_plan) print(" source-scale steps:", spec.source_scale_steps) print(" metrics:", spec.metrics) print(" signature:", spec.constructor_signature)

 silva_fno_deq
 equation: u_star = sigma(S(a,f) + FNO_theta(u_star))
 preserves: ('input-injected weight-tied Fourier operator solved at infinite-depth equilibrium',)
 SILVA extensions: ('replace forcing lift, tied block, boundary field, geometry field, or readout',)
 benchmark requires: ('source Darcy/Navier-Stokes data, modes, widths, training budget, seeds, and relative L2',)
 data: ('Darcy flow', 'steady incompressible Navier-Stokes')
 data sources: ('https://github.com/risteskilab/deq-neural-operators',)
 access: ('Follow the cited repository and dataset terms, then record source revisions and archive checksums.',)
 storage: ('Measure one processed sample, estimate the complete split, and budget raw data, processed shards, checkpoints, optimizer state, and diagnostics separately.',)
 source-scale steps: ('Acquire the cited data and preserve its official split, preprocessing, units, and metric.', 'Build the same SILVA family with source-aligned task modules and scale controls.', 'Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.')
 metrics: ('relative L2 error', 'PDE residual', 'noise robustness', 'memory')
 signature: (in_channels: 'int', state_channels: 'int', out_channels: 'int', *, modes_height: 'int' = 4, modes_width: 'int' = 4, block_depth: 'int' = 1, state_scale: 'float' = 0.1, activation: 'Callable[[Tensor], Tensor]' = <built-in method tanh of type object>, forcing_lift: 'nn.Module | None' = None, block: 'nn.Module | None' = None, readout: 'nn.Module | None' = None, config: 'SolverConfig | None' = None)

 silva_monotone_graph_equilibrium
 equation: Z_star = prox(alpha f)(B(X) + W G Z_star)
 preserves: ('monotone graph equilibrium with a constrained channel operator and proximal step',)
 SILVA extensions: ('replace proximal map, factorization, graph operator, or head under the margin contract',)
 benchmark requires: ('source graph splits, normalization, monotonicity parameterization, training, and accuracy',)
 data: ('node and graph long-range benchmarks',)
 data sources: ('https://github.com/Utah-Math-Data-Science/MIGNN',)
 access: ('Follow the cited repository and dataset terms, then record source revisions and archive checksums.',)
 storage: ('Measure one processed sample, estimate the complete split, and budget raw data, processed shards, checkpoints, optimizer state, and diagnostics separately.',)
 source-scale steps: ('Acquire the cited data and preserve its official split, preprocessing, units, and metric.', 'Build the same SILVA family with source-aligned task modules and scale controls.', 'Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.')
 metrics: ('node or graph accuracy', 'monotonicity certificate', 'residual', 'runtime')
 signature: (in_dim: 'int', state_dim: 'int', out_dim: 'int', *, margin: 'float' = 0.1, step_size: 'float' = 0.8, operator_rank: 'int | None' = None, transition: 'nn.Module | None' = None, readout: 'nn.Module | None' = None, certificate: 'Callable[[], Tensor] | None' = None, config: 'SolverConfig | None' = None)

 silva_physics_informed_equilibrium
 equation: z_star(t)=T_theta(z_star(t),t); (I-dT/dz) dz_star/dt=dT/dt
 preserves: ('equilibrium state with implicit time derivative and physics-informed residual terms',)
 SILVA extensions: ('replace dynamics, transition, readout, derivative mode, and residual weights',)
 benchmark requires: ('source IVP, collocation, initial conditions, optimizer, Jacobian weight, and IAE',)
 data: ('Van der Pol or declared nonlinear IVP',)
 data sources: ('https://github.com/brunompacheco/pideq',)
 access: ('Follow the cited repository and dataset terms, then record source revisions and archive checksums.',)
 storage: ('Measure one processed sample, estimate the complete split, and budget raw data, processed shards, checkpoints, optimizer state, and diagnostics separately.',)
 source-scale steps: ('Acquire the cited data and preserve its official split, preprocessing, units, and metric.', 'Build the same SILVA family with source-aligned task modules and scale controls.', 'Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.')
 metrics: ('integral absolute error', 'ODE residual', 'initial-condition error', 'residual')
 signature: (state_dim: 'int', output_dim: 'int', *, time_dim: 'int' = 1, hidden_dim: 'int | None' = None, state_scale: 'float' = 0.2, transition: 'nn.Module | None' = None, readout: 'nn.Module | None' = None, derivative_mode: 'DerivativeMode' = 'auto', dense_derivative_threshold: 'int' = 64, derivative_max_iter: 'int' = 50, derivative_tol: 'float' = 1e-06, config: 'SolverConfig | None' = None)

 diffusion_equilibrium
 equation: X_star[0]=noise; X_star[k+1]=D_k(X_star[k], condition)
 preserves: ('joint reverse trajectory represented and solved as one equilibrium state',)
 SILVA extensions: ('replace the complete reverse step, schedule, denoiser, and data-consistency map',)
 benchmark requires: ('source checkpoint, noise schedule, initialization, data operator, data, and metric',)
 data: ('declared diffusion noise/sample pairs', 'CelebA-HQ or ImageNet restoration inputs when a restoration step is supplied')
 data sources: ('https://github.com/locuslab/deq-ddim', 'https://github.com/caojiezhang/DeqIR')
 access: ('Follow the cited repository and dataset terms, then record source revisions and archive checksums.',)
 storage: ('Measure one processed sample, estimate the complete split, and budget raw data, processed shards, checkpoints, optimizer state, and diagnostics separately.',)
 source-scale steps: ('Acquire the cited data and preserve its official split, preprocessing, units, and metric.', 'Build the same SILVA family with source-aligned task modules and scale controls.', 'Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.')
 metrics: ('FID or restoration PSNR/SSIM', 'residual', 'sampling time')
 signature: (denoiser: 'nn.Module | None', alphas_cumprod: 'Tensor', timesteps: 'Sequence[int]', *, eta: 'float' = 0.0, step_operator: 'Callable[..., Tensor] | nn.Module | None' = None, data_consistency: 'Callable[..., Tensor] | nn.Module | None' = None, config: 'SolverConfig | None' = None)

 silva_monotone_operator_equilibrium
 equation: 0 in (I-W)z_star-Ux-b+partial f(z_star); W=(1-m)I-A^T A+B-B^T
 preserves: ('strongly monotone parameterization W=(1-m)I-A^T A+B-B^T', 'forward-backward and Peaceman-Rachford operator splittings', 'proximal nonlinearities and implicit differentiation at the solved equilibrium')
 SILVA extensions: ('replace the source, proximal map, monotone operator, splitter, readout, or solver', 'inspect the monotonicity margin and numerical residual on every solve')
 benchmark requires: ('source architecture width/depth, convolutional parameterization, data split, and augmentation', 'splitting step size, forward/backward tolerances, optimizer, regularization, and seeds', 'task accuracy, residual, evaluation count, memory, and source baselines')
 data: ('MNIST', 'CIFAR-10', 'SVHN', 'compact known-solution monotone inclusions')
 data sources: ('https://arxiv.org/abs/2006.08591', 'https://github.com/locuslab/monotone_op_net')
 access: ('MNIST, CIFAR-10, and SVHN have established public acquisition routes under their stated terms.', 'Record the source repository revision, data split, augmentation, and any pretrained checkpoint checksum.')
 storage: ('Dense operator storage scales quadratically with state width; structured convolutions replace that term with kernel parameters and feature maps.', 'Budget activations, solver history, checkpoints, and optimizer state separately even when implicit differentiation avoids storing every iteration.')
 source-scale steps: ('Acquire one source benchmark and reproduce its split, normalization, augmentation, and architecture dimensions.', 'Choose the forward-backward or Peaceman-Rachford route and match the monotone factorization, proximal map, step, and solver tolerances.', 'Validate the compact known-solution case, then report task accuracy, certificate, residual, evaluations, runtime, and memory at source scale.')
 metrics: ('task accuracy', 'monotonicity certificate', 'fixed-point residual', 'operator evaluations', 'runtime and memory')
 signature: (in_dim: 'int', state_dim: 'int', out_dim: 'int', *, operator: 'nn.Module | None' = None, source: 'nn.Module | None' = None, prox: 'Callable[[Tensor], Tensor]' = <function relu>, readout: 'nn.Module | None' = None, splitting: 'MonotoneSplitting' = 'forward_backward', step_size: 'float' = 1.0, margin: 'float' = 1.0, config: 'SolverConfig | None' = None) -> 'None'

 silva_positive_concave_equilibrium
 equation: z_star=phi(W_positive z_star+s_positive(x)); W_positive>=0
 preserves: ('entrywise nonnegative recurrent operators and nonnegative source injection', 'published variant-one tanh/softsign/ReLU6 and variant-two sigmoid maps', 'fixed-point iteration over vector or convolutional positive-concave states')
 SILVA extensions: ('replace the positive operator, source, activation variant, readout, or solver', 'use linear or spatial convolutions while retaining positivity diagnostics')
 benchmark requires: ('source data split, preprocessing, positive parameterization, widths, kernels, and activations', 'solver iterations, optimizer, learning-rate schedule, regularization, and seeds', 'task accuracy, fixed-point residual, positivity minimum, runtime, and source baselines')
 data: ('MNIST', 'CIFAR-10', 'SVHN', 'compact positive-concave vector and image equilibria')
 data sources: ('https://proceedings.mlr.press/v235/gabor24a.html', 'https://github.com/mateuszgabor/pcdeq')
 access: ('Acquire the declared image benchmark through its official or framework-provided route and preserve the source split.', 'Record preprocessing, positivity parameterization, activation variant, and source revision before comparing results.')
 storage: ('Vector tasks are small; convolutional tasks are dominated by equilibrium feature maps times solver history and precision.', 'Store raw positive parameters and transformed nonnegative weights only when diagnostics cannot be regenerated from the checkpoint.')
 source-scale steps: ('Acquire one source vision task and reproduce its image preprocessing, split, and classifier head.', 'Match published variant 1 or 2, nonnegative parameterization, activation, convolutional width, and fixed-point budget.', 'Verify positivity and compact convergence first, then report task accuracy, residual, runtime, and memory with all source hyperparameters.')
 metrics: ('task accuracy', 'minimum state and weight', 'fixed-point residual', 'runtime and memory')
 signature: (in_dim: 'int', state_dim: 'int', out_dim: 'int', *, variant: 'PositiveVariant' = 1, operator: 'PositiveOperator' = 'linear', activation: 'str | None' = None, kernel_size: 'int' = 3, weight_parameterization: 'PositiveWeightParameterization' = 'softplus', transition: 'nn.Module | None' = None, source: 'nn.Module | None' = None, readout: 'nn.Module | None' = None, config: 'SolverConfig | None' = None) -> 'None'

 silva_non_euclidean_equilibrium
 equation: z_star=phi(A z_star+B x+b); mu_infinity,D(A)<1
 preserves: ('weighted-infinity matrix-measure contraction certificate', 'diagonally weighted parameterization and averaged fixed-point iteration', 'input-output sensitivity bound in the learned non-Euclidean metric')
 SILVA extensions: ('replace the certified operator, source, activation, metric, averaging, or readout', 'learn the metric jointly while exposing the one-sided bound and sensitivity certificate')
 benchmark requires: ('source architecture, metric initialization, one-sided target, data perturbations, and preprocessing', 'averaging rule, solver tolerance, optimizer, robustness protocol, and seeds', 'task accuracy, certified bound, empirical sensitivity, residual, and source baselines')
 data: ('MNIST', 'CIFAR-10', 'compact weighted-infinity perturbation pairs')
 data sources: ('https://arxiv.org/abs/2106.03194', 'https://github.com/davydovalexander/Non-Euclidean_Mon_Op_Net')
 access: ('Acquire the declared vision benchmark through its stated public route and preserve train/test preprocessing.', 'Archive clean and perturbed evaluation indices, perturbation norm, metric weights, and checkpoint revision together.')
 storage: ('Budget the base checkpoint, learned metric, clean/perturbed batches, solver traces, and certificate tables independently.', 'For large dense states, prefer structured operators because the unconstrained matrix and its optimizer state scale quadratically.')
 source-scale steps: ('Acquire one declared benchmark and reproduce clean and perturbed evaluation preprocessing.', 'Match the weighted metric, one-sided matrix-measure target, averaging rule, architecture, and solver settings.', 'Verify the compact certificate and empirical sensitivity, then report clean/robust task metrics, residuals, runtime, and memory.')
 metrics: ('clean and perturbed task metric', 'one-sided Lipschitz certificate', 'empirical sensitivity', 'fixed-point residual')
 signature: (in_dim: 'int', state_dim: 'int', out_dim: 'int', *, operator: 'nn.Module | None' = None, source: 'nn.Module | None' = None, activation: 'Callable[[Tensor], Tensor]' = <function relu>, readout: 'nn.Module | None' = None, one_sided_bound: 'float' = 0.05, averaging: 'float | None' = None, config: 'SolverConfig | None' = None) -> 'None'

 silva_efficient_infinite_graph
 equation: Z_star=gamma S^T Z_star g(F)^T+X; g(F)=F^T F/||F^T F||_F
 preserves: ('Frobenius-normalized positive-semidefinite channel Gram map', 'graph/channel eigendecomposition for an exact dense symmetric solve', 'the same equilibrium equation through iterative sparse or directed propagation')
 SILVA extensions: ('replace source, readout, graph operator, channel factor, gamma, or solve route', 'precompute and reuse a graph spectrum without changing the SILVA state contract')
 benchmark requires: ('source graph split, features, graph normalization, labels, and transductive protocol', 'hidden width, gamma, optimizer, weight decay, early stopping, and seeds', 'node accuracy, closed-form agreement, denominator margin, runtime, and memory')
 data: ('Cora', 'Citeseer', 'Pubmed', 'Amazon co-purchase graphs', 'compact chain graphs')
 data sources: ('https://arxiv.org/abs/2202.10720', 'https://github.com/liu-jc/EIGNN')
 access: ('Citation and co-purchase graph datasets are publicly distributed through their respective benchmark providers.', 'Retain the exact split, feature normalization, self-loop convention, graph normalization, and source revision.')
 storage: ('Sparse iterative storage is proportional to edges plus node states; the dense closed form additionally stores graph eigenvectors with quadratic node cost.', 'Precompute dense spectra only when they fit comfortably; shard features and use sparse propagation for large graphs.')
 source-scale steps: ('Acquire a declared graph benchmark and preserve its official features, labels, split, and normalization.', 'Use the normalized channel Gram map and match gamma, width, optimizer, early stopping, and either spectral or iterative solve route.', 'Check closed-form/iterative agreement on a compact graph before reporting source-scale node accuracy, denominator margin, runtime, and memory.')
 metrics: ('node accuracy', 'closed-form/iterative agreement', 'denominator margin', 'runtime and memory')
 signature: (in_dim: 'int', state_dim: 'int', out_dim: 'int', *, gamma: 'float' = 0.8, learnable_gamma: 'bool' = False, source: 'nn.Module | None' = None, readout: 'nn.Module | None' = None, solve_mode: 'GraphSolveMode' = 'auto', gram_epsilon: 'float' = 1e-12, config: 'SolverConfig | None' = None) -> 'None'

 silva_multiscale_graph_implicit
 equation: Z_m_star=gamma S^m Z_m_star g(F_m)^T+X; Z=sum_m beta_m(Z_m_star)Z_m_star
 preserves: ('one infinite graph equilibrium for each declared graph-power scale', 'independent normalized channel factors across scales', 'nodewise softmax attention over converged scale states')
 SILVA extensions: ('replace scales, factors, source, per-scale solvers, attention, fusion, or readout', 'inspect each scale state and attention distribution before adding new graph powers')
 benchmark requires: ('source graph split, features, graph normalization, labels, and scale list', 'per-scale widths, gamma, attention dimension, optimizer, early stopping, and seeds', 'node accuracy, per-scale residuals, attention statistics, runtime, and memory')
 data: ('Cora', 'Citeseer', 'Pubmed', 'Amazon', 'Coauthor', 'compact multiscale chain graphs')
 data sources: ('https://arxiv.org/abs/2210.08353', 'https://github.com/liu-jc/MGNNI')
 access: ("Use the benchmark provider's original graph, labels, and declared transductive split.", 'Cache graph powers or sparse propagation plans by dataset checksum, normalization, and scale list.')
 storage: ('State storage scales with nodes times state width times the number of graph scales, plus per-scale solver history.', 'Cache sparse graph powers or repeated sparse propagation plans rather than materializing dense matrices.')
 source-scale steps: ('Acquire a declared graph benchmark and preserve the official split, graph normalization, and feature preprocessing.', 'Match graph-power scales, per-scale channel factors, equilibrium budgets, and nodewise attention fusion.', 'Validate per-scale states and normalized attention on the compact case, then report task accuracy, residuals, fusion statistics, runtime, and memory.')
 metrics: ('node accuracy', 'per-scale residual', 'attention entropy and scale usage', 'runtime and memory')
 signature: (in_dim: 'int', state_dim: 'int', out_dim: 'int', *, scales: 'Sequence[int]' = (1, 2), gamma: 'float' = 0.8, source: 'nn.Module | None' = None, graph_source: 'nn.Module | None' = None, readout: 'nn.Module | None' = None, fusion: 'ScaleFusion' = 'attention', attention_dim: 'int | None' = None, gram_epsilon: 'float' = 1e-12, config: 'SolverConfig | Sequence[SolverConfig] | None' = None) -> 'None'

 silva_delta_equilibrium
 equation: c_k=c_(k-1)+W mask(|z_k-z_(k-1)|>tau)(z_k-z_(k-1))
 preserves: ('cached linear or convolutional recurrent output updated from thresholded state deltas', 'zero-threshold algebraic equivalence to full recurrent evaluation', 'full-map training with independently selectable delta-cached inference')
 SILVA extensions: ('replace source, recurrent operator, activation, readout, threshold, or solver', 'record active elements, exact full-map residual, and task error for every threshold')
 benchmark requires: ('source model checkpoint, recurrent operators, data preprocessing, and evaluation sequence', 'threshold policy, warm starts, solver tolerances, hardware, precision, and seeds', 'task metric, active fraction, exact residual, latency, memory traffic, and source baseline')
 data: ('FlyingChairs', 'Sintel', 'KITTI', 'compact heterogeneous-rate equilibria')
 data sources: ('https://papers.nips.cc/paper_files/paper/2024/hash/69f5b860d6dc469ac6e52f03866b73c4-Abstract-Conference.html', 'https://github.com/ZuowenWang0000/Delta-Deep-Equilibrium-Models')
 access: ('FlyingChairs, Sintel, and KITTI retain their own download and evaluation terms.', 'Store the base checkpoint separately from delta thresholds and report whether the evaluation route uses warm starts or cached states.')
 storage: ('The cache stores one previous state and one recurrent output per wrapped operator in addition to the ordinary solver state.', 'For image or flow evaluation, log activity summaries rather than full boolean masks unless a detailed profiling shard is required.')
 source-scale steps: ('Load a source-compatible checkpoint and reproduce the task data preprocessing and ordinary full-map evaluation first.', 'Wrap supported recurrent linear or convolutional operators, begin at zero threshold, and verify prediction/state equivalence and exact residual.', 'Sweep thresholds and report task degradation, active fraction, wall time, memory traffic, solver evaluations, and hardware details.')
 metrics: ('task metric', 'active fraction', 'exact full-map residual', 'latency and memory traffic')
 signature: (in_dim: 'int', state_dim: 'int', out_dim: 'int', *, recurrent: 'nn.Module | None' = None, source: 'nn.Module | None' = None, activation: 'Callable[[Tensor], Tensor]' = <built-in method tanh of type object>, readout: 'nn.Module | None' = None, delta_threshold: 'float' = 0.0, config: 'SolverConfig | None' = None) -> 'None'

Audit All 64 Source-Conformance Records¶

Every family has a distinct governing equation and three additional records: what is retained from the source mechanism, what SILVA allows the user to replace or scale, and what must still be reproduced before comparing with the source benchmark. This avoids treating a compact mechanism check as a full paper result while keeping the architecture open for new experiments.

In [3]:

assert all(spec.equation for spec in specs)
assert len({spec.preserved_mechanisms for spec in specs}) == len(specs)
assert len({spec.silva_extensions for spec in specs}) == len(specs)
assert len({spec.benchmark_requirements for spec in specs}) == len(specs)
assert all(spec.data_sources for spec in specs)
assert all(spec.data_access for spec in specs)
assert all(spec.storage_plan for spec in specs)
assert all(spec.compact_data for spec in specs)
assert all(spec.source_scale_steps for spec in specs)

for spec in specs:
    print(f"\n{spec.family}")
    print(" equation:", spec.equation)
    print(" preserves:", *spec.preserved_mechanisms)
    print(" extends:", *spec.silva_extensions)
    print(" benchmark requires:", *spec.benchmark_requirements)
    print(" data sources:", *spec.data_sources)
    print(" source-scale steps:", *spec.source_scale_steps)
    print(" references:", *spec.paper_refs)
    print(" repositories:", *spec.repositories)

assert all(spec.equation for spec in specs) assert len({spec.preserved_mechanisms for spec in specs}) == len(specs) assert len({spec.silva_extensions for spec in specs}) == len(specs) assert len({spec.benchmark_requirements for spec in specs}) == len(specs) assert all(spec.data_sources for spec in specs) assert all(spec.data_access for spec in specs) assert all(spec.storage_plan for spec in specs) assert all(spec.compact_data for spec in specs) assert all(spec.source_scale_steps for spec in specs) for spec in specs: print(f"\n{spec.family}") print(" equation:", spec.equation) print(" preserves:", *spec.preserved_mechanisms) print(" extends:", *spec.silva_extensions) print(" benchmark requires:", *spec.benchmark_requirements) print(" data sources:", *spec.data_sources) print(" source-scale steps:", *spec.source_scale_steps) print(" references:", *spec.paper_refs) print(" repositories:", *spec.repositories)

silva_layer
 equation: z_star = sigma(S(x) + H(z_star) + L(z_star; E) + G(z_star; b))
 preserves: named stimulus, self, local, and global fields in one equilibrium point
 extends: replace any field, activation, normalization, readout, or solver independently
 benchmark requires: article task, operator choices, initialization, training schedule, seeds, and metrics
 data sources: https://github.com/jseluis/silva-networks
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 1 4
 repositories: https://github.com/jseluis/silva-networks

silva_graph
 equation: Z[l]_star = T[l](Z[l]_star, Z[l-1]_star; E, batch)
 preserves: sparse graph-conditioned local fields and independently solved stacked points
 extends: mix local, attention, self, and graph-level global fields by layer
 benchmark requires: graph split, edge preprocessing, pooling, depth, optimizer, seeds, and task metric
 data sources: https://github.com/jseluis/silva-networks
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 1 15 16
 repositories: https://github.com/jseluis/silva-networks

silva_graph_preset
 equation: Z[l]_star = sigma(S[l](X[l]) + L_graph[l](Z[l]_star; E) + G[l](Z[l]_star; b))
 preserves: configured graph stimulus, message, attention, and pooling route
 extends: replace preset points or interaction modes while retaining the graph contract
 benchmark requires: dataset split, feature encoding, graph batching, preset options, and task metric
 data sources: https://github.com/jseluis/silva-networks
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 1 16 17
 repositories: https://github.com/jseluis/silva-networks

silva_cortex
 equation: z_star = sigma(E_x(x) + A_theta(z_star, x) + L(z_star) + G(z_star))
 preserves: one shape-preserving equilibrium point with a user-defined internal module graph
 extends: compose dense, convolutional, U-Net, attention, spectral, or custom modules
 benchmark requires: declared internal graph, tensor contract, solver, training schedule, and task data
 data sources: https://github.com/jseluis/silva-networks
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 1 4
 repositories: https://github.com/jseluis/silva-networks

silva_cortex_network
 equation: z[1]_star=C[1](z[1]_star,x); z[k]_star=C[k](z[k]_star,lambda[k-1](z[k-1]_star))
 preserves: ordered heterogeneous equilibrium points connected by explicit link maps
 extends: give every point a distinct architecture, state shape, solver, and link projection
 benchmark requires: complete point/link graph, per-point settings, data route, optimizer, and metrics
 data sources: https://github.com/jseluis/silva-networks
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 1 4
 repositories: https://github.com/jseluis/silva-networks

silva_image_cortex
 equation: r=Retina(x); z[1]_star=C[1](z[1]_star,r); z[k]_star=C[k](z[k]_star,lambda[k-1](z[k-1]_star)); y=Q(z[K]_star)
 preserves: image retina followed by linked fast/slow spatial equilibrium points
 extends: replace retina, point operators, links, pooling, and classification head
 benchmark requires: image preprocessing, resolution, augmentation, point widths, schedule, and accuracy
 data sources: https://github.com/jseluis/silva-networks
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 1 27 29
 repositories: https://github.com/jseluis/silva-networks

compact_deq
 equation: z_star = tanh(W_z z_star + W_x x + b)
 preserves: weight-tied affine-tanh fixed point and implicit differentiation
 extends: replace the affine map or solver while retaining the equilibrium contract
 benchmark requires: source sequence data, adaptive embeddings, memory, optimizer, and perplexity protocol
 data sources: https://github.com/locuslab/deq
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 4
 repositories: https://github.com/locuslab/deq

message_passing_deq
 equation: Z_star = sigma(S(X) + L_G(Z_star))
 preserves: weight-tied graph message aggregation inside a fixed point
 extends: add edge features, physics fields, global context, or alternative aggregation
 benchmark requires: source graph, normalization, split, message map, training schedule, and accuracy
 data sources: https://github.com/locuslab/deq
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 4 16
 repositories: https://github.com/locuslab/deq

mdeq
 equation: Z_star[r] = T_r(Z_star[1:R], X) for every resolution r
 preserves: simultaneously solved states with learned cross-resolution fusion
 extends: replace scale blocks, add resolutions, or attach a task-specific head
 benchmark requires: source stem, branch widths, fusion graph, augmentation, schedule, and metric
 data sources: https://github.com/locuslab/mdeq
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 5
 repositories: https://github.com/locuslab/mdeq

multiscale_vision_deq
 equation: Z_star[r] = T_r(Z_star[1:R], X) for every resolution r
 preserves: full multiresolution equilibrium with every-to-every scale fusion
 extends: change the resolution pyramid, residual blocks, fusion, or dense-prediction head
 benchmark requires: source image data, crop/augmentation, branch layout, training budget, and metric
 data sources: https://github.com/locuslab/mdeq
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 5
 repositories: https://github.com/locuslab/mdeq

sequence_deq
 equation: Z_star = T_theta(Z_star, embeddings, mask, memory)
 preserves: weight-tied sequence equilibrium with relative-attention or trellis transition
 extends: replace attention, memory, injection, vocabulary bands, or sequence readout
 benchmark requires: source corpus, tokenization, memory schedule, adaptive bands, training, and perplexity
 data sources: https://github.com/locuslab/deq
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 4
 repositories: https://github.com/locuslab/deq

implicit_graph
 equation: Z_star = phi(W Z_star A + B X)
 preserves: implicit graph propagation with a constrained well-posed channel map
 extends: replace normalization, graph operator, constraint parameterization, or readout
 benchmark requires: source graph splits, adjacency processing, constraint rule, optimizer, and accuracy
 data sources: https://github.com/SwiftieH/IGNN
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 36
 repositories: https://github.com/SwiftieH/IGNN

implicit_neural_representation
 equation: Z_star(c) = phi(S(c) + H(Z_star(c)))
 preserves: coordinate-conditioned injection and a shared implicit feature state
 extends: select sinusoidal, Fourier, Gabor, or custom coordinate encodings and readouts
 benchmark requires: source signal, coordinate sampling, encoding bandwidth, optimization, and PSNR
 data sources: https://github.com/jseluis/silva-networks
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 37
 repositories: https://github.com/jseluis/silva-networks

diffusion_equilibrium
 equation: X_star[0]=noise; X_star[k+1]=D_k(X_star[k], condition)
 preserves: joint reverse trajectory represented and solved as one equilibrium state
 extends: replace the complete reverse step, schedule, denoiser, and data-consistency map
 benchmark requires: source checkpoint, noise schedule, initialization, data operator, data, and metric
 data sources: https://github.com/locuslab/deq-ddim https://github.com/caojiezhang/DeqIR
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 38 49
 repositories: https://github.com/locuslab/deq-ddim https://github.com/caojiezhang/DeqIR

scientific_operator
 equation: u_star = sigma(S(a,f) + K_theta(u_star) + P(u_star))
 preserves: source-to-field injection plus a shape-preserving repeated field operator
 extends: insert convolutional, U-Net, Fourier, graph, or custom physical operators
 benchmark requires: PDE data generator, mesh/grid, normalization, boundaries, training, and field metric
 data sources: https://github.com/neuraloperator/neuraloperator https://github.com/jseluis/silva-networks
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 31 32
 repositories: https://github.com/neuraloperator/neuraloperator https://github.com/jseluis/silva-networks

fourier_operator_equilibrium
 equation: u_star = sigma(S(a,f) + F_inv(R_theta F(u_star)) + W u_star)
 preserves: truncated Fourier convolution combined with local channel mixing at equilibrium
 extends: mix spectral, local, boundary, geometry, and conservation fields
 benchmark requires: source PDE data, resolution, modes, normalization, boundaries, and relative error
 data sources: https://github.com/neuraloperator/neuraloperator
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 31 32
 repositories: https://github.com/neuraloperator/neuraloperator

implicit_time_step
 equation: u_next = u_now + dt F(u_next, context)
 preserves: backward implicit time step solved through a fixed-point residual
 extends: replace the dynamics, spatial discretization, projector, or nonlinear solver
 benchmark requires: governing dynamics, discretization, step schedule, initial data, and trajectory error
 data sources: https://github.com/jseluis/silva-networks
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 7
 repositories: https://github.com/jseluis/silva-networks

silva_deq_flow
 equation: flow_star = U_theta(flow_star, features, correlation)
 preserves: weight-tied optical-flow update solved to an equilibrium flow field
 extends: replace feature, correlation, update, and correction modules
 benchmark requires: source image pairs, preprocessing, correlation settings, training stages, and EPE
 data sources: https://github.com/locuslab/deq-flow
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 22 23
 repositories: https://github.com/locuslab/deq-flow

raft_deq_flow
 equation: (h_star,flow_star) = U_theta(h_star,flow_star,context,correlation)
 preserves: coupled hidden-state and flow equilibrium with RAFT-style correlation lookup
 extends: replace encoders, correlation implementation, update block, or correction route
 benchmark requires: source datasets, stage schedule, augmentations, checkpoint, iterations, and EPE
 data sources: https://github.com/princeton-vl/RAFT https://github.com/locuslab/deq-flow
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 22 23
 repositories: https://github.com/princeton-vl/RAFT https://github.com/locuslab/deq-flow

quadratic_optimization
 equation: z_star = z_star - alpha(Q z_star + c(x))
 preserves: first-order equilibrium whose root is an unconstrained quadratic minimizer
 extends: parameterize the Hessian, linear term, initializer, solver, or downstream loss
 benchmark requires: problem distribution, conditioning, objective definition, solver tolerance, and error
 data sources: https://github.com/jseluis/silva-networks
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 8
 repositories: https://github.com/jseluis/silva-networks

silva_projected_qp
 equation: z_star = projection_C(z_star - alpha(Q z_star + c(x)))
 preserves: projected first-order fixed point for a constrained quadratic program
 extends: replace the projection, constraints, objective parameterization, or root solver
 benchmark requires: source QP distribution, constraints, feasibility tolerance, KKT metric, and gradients
 data sources: https://github.com/cvxpy/cvxpylayers https://github.com/jseluis/silva-networks
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 8 9
 repositories: https://github.com/cvxpy/cvxpylayers https://github.com/jseluis/silva-networks

silva_fno_deq
 equation: u_star = sigma(S(a,f) + FNO_theta(u_star))
 preserves: input-injected weight-tied Fourier operator solved at infinite-depth equilibrium
 extends: replace forcing lift, tied block, boundary field, geometry field, or readout
 benchmark requires: source Darcy/Navier-Stokes data, modes, widths, training budget, seeds, and relative L2
 data sources: https://github.com/risteskilab/deq-neural-operators
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 31 43
 repositories: https://github.com/risteskilab/deq-neural-operators

silva_physics_graph_deq
 equation: Z_star = sigma(S(X) + diffusion_G(Z_star) + advection_G(Z_star))
 preserves: diffusion and advection laws embedded as graph transition fields
 extends: add or replace source, reaction, diffusion, advection, and observation branches
 benchmark requires: source sensor graph, physical coefficients, units, split, schedule, and field metric
 data sources: https://github.com/jseluis/silva-networks
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 44
 repositories: https://github.com/jseluis/silva-networks

silva_homotopy_equilibrium
 equation: dz/ds = T_theta(z,x) - z; T_theta(z_star,x)-z_star=0
 preserves: continuous residual flow whose stationary endpoint satisfies the fixed-point equation
 extends: replace residual field, continuation schedule, integrator, or terminal readout
 benchmark requires: source architecture, ODE solver/tolerances, horizon, data, training, and accuracy
 data sources: https://github.com/wadx2019/homoode https://github.com/SciML/DeepEquilibriumNetworks.jl
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 7 46 58
 repositories: https://github.com/wadx2019/homoode https://github.com/SciML/DeepEquilibriumNetworks.jl

silva_distributional_deq
 equation: mu_star = Phi_theta(mu_star, nu_input)
 preserves: permutation-compatible equilibrium over masked empirical measures
 extends: replace equivariant transition, discrepancy, particle encoder, or aggregation
 benchmark requires: source point-cloud conversion, masks, discrepancy, model scale, training, and metric
 data sources: https://github.com/j-geuter/DDEQs
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 45
 repositories: https://github.com/j-geuter/DDEQs

silva_monotone_graph_equilibrium
 equation: Z_star = prox(alpha f)(B(X) + W G Z_star)
 preserves: monotone graph equilibrium with a constrained channel operator and proximal step
 extends: replace proximal map, factorization, graph operator, or head under the margin contract
 benchmark requires: source graph splits, normalization, monotonicity parameterization, training, and accuracy
 data sources: https://github.com/Utah-Math-Data-Science/MIGNN
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 47
 repositories: https://github.com/Utah-Math-Data-Science/MIGNN

silva_generative_equilibrium_transformer
 equation: Z_star = T_theta(Z_star, injection(noise,label)); image = decoder(Z_star)
 preserves: one-time condition injection followed by a weight-tied token equilibrium
 extends: replace injector, attention core, patch geometry, decoder, or distillation objective
 benchmark requires: source teacher, teacher pairs, labels, training recipe, sampling protocol, and FID
 data sources: https://github.com/locuslab/get
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 48
 repositories: https://github.com/locuslab/get

silva_poisson_mirror_equilibrium
 equation: u_star = mirror_Burg(u_star, grad Poisson(Au,y) + regularizer(u_star))
 preserves: positive Burg-geometry mirror step for Poisson data fidelity
 extends: replace forward/adjoint maps, regularizer gradient, mirror step, or tiling
 benchmark requires: source forward model, count statistics, regularizer, training, initialization, and PSNR
 data sources: https://github.com/christiandaniele/DEQ-MD
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 50
 repositories: https://github.com/christiandaniele/DEQ-MD

silva_physics_informed_equilibrium
 equation: z_star(t)=T_theta(z_star(t),t); (I-dT/dz) dz_star/dt=dT/dt
 preserves: equilibrium state with implicit time derivative and physics-informed residual terms
 extends: replace dynamics, transition, readout, derivative mode, and residual weights
 benchmark requires: source IVP, collocation, initial conditions, optimizer, Jacobian weight, and IAE
 data sources: https://github.com/brunompacheco/pideq
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 51
 repositories: https://github.com/brunompacheco/pideq

silva_implicit_dae_step
 equation: Y_i=y_n+dt sum_j a_ij f(Y_j,Z_j); 0=g(Y_i,Z_i)
 preserves: implicit Runge-Kutta stage root with differential and algebraic constraints
 extends: replace tableau, dynamics, constraints, learned closures, or Newton-Krylov controls
 benchmark requires: source DAE, index assumptions, consistent initialization, time grid, tolerances, and error
 data sources: https://github.com/jseluis/silva-networks
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 52
 repositories: https://github.com/jseluis/silva-networks

silva_consistency_deq
 equation: g_phi(z_t,t,x)=c_skip(t)z_t+c_out(t)P_phi(z_<=t,t,x)
 preserves: fixed initial state and solver-induced teacher trajectory terminally anchored consistency parameterization two-state Anderson-structured refinement and local/global consistency losses
 extends: inject any SILVA teacher transition, student refiner, readout, time schedule, and task loss choose one-step or chained few-step inference and maintain an EMA target
 benchmark requires: pretrained teacher checkpoint and exact solver settings cached trajectories, time mapping, augmentation, optimizer, EMA, and task protocol WikiText-103, ImageNet, or OGB preprocessing and published evaluation budget
 data sources: https://github.com/landrarwolf/CDEQ https://www.salesforce.com/blog/the-wikitext-long-term-dependency-language-modeling-dataset/ https://ogb.stanford.edu/docs/nodeprop/ https://www.image-net.org/
 source-scale steps: Acquire one official task and reproduce its teacher preprocessing and evaluation first. Load the teacher checkpoint into the matching SILVA transition and cache deterministic solver trajectories. Train the refiner with global/local consistency and an EMA target, then sweep one, two, and few-step inference against teacher quality and latency.
 references: 59
 repositories: https://github.com/landrarwolf/CDEQ

silva_psi_gnn
 equation: H_star=h_theta(H_star,G); U_hat=D(H_star); L_res=MSE(A U_hat-B)
 preserves: encode-process-decode graph equilibrium separate interior incoming/outgoing and Neumann incoming messages fixed Dirichlet latent values, Broyden root solving, PDE residual, and Jacobian stabilization
 extends: replace every message/update network, encoder, decoder, root solver, and loss weight accept arbitrary first-order unstructured meshes through coordinates and directed edges
 benchmark requires: paper mesh generator, GMSH first-order elements, 6000/2000/2000 split, and approximately 500 nodes finite-element residual matrices for training, mixed boundaries, optimizer groups, and seeds published residual, LU error, parameter count, and variable-resolution evaluation
 data sources: https://arxiv.org/abs/2302.10891 https://gmsh.info/
 source-scale steps: Generate the 6000/2000/2000 mesh split with first-order elements, mixed boundaries, and approximately 500 training nodes per graph. Convert each mesh to the SILVAPsiGNN tensor contract without densifying edges or finite-element matrices. Train residual, Jacobian, latent-consistency, and reconstruction terms, then evaluate new geometries, resolutions, boundaries, and initial states.
 references: 60
 repositories: https://arxiv.org/abs/2302.10891

silva_ifno
 equation: h_(l+1)=h_l+dt sigma(W h_l+F_inv(R_theta F(h_l))+c)
 preserves: layer-independent Fourier kernel, pointwise channel map, bias, and residual increment input lift and shallow projection for displacement or damage fields shared-depth nonlocal integration and optional zero-increment root solve
 extends: replace lift, spectral/local increment, activation, boundary projection, and readout represent coordinates, material fields, body forces, Dirichlet values, and traction as input channels
 benchmark requires: source simulation or DIC fields, train/test split, grid, normalization, modes, and depth continuation task-specific hyperelastic, anisotropic, brittle-fracture, or experimental loading protocol relative field error, resolution transfer, depth stability, and source baselines
 data sources: https://arxiv.org/abs/2203.08205
 source-scale steps: Choose exactly one source material task and reproduce its simulator or DIC preprocessing, units, split, and normalization. Map coordinates, material descriptors, loads, and boundary values to input channels and use the shared SILVAIFNO increment at the reported depth and modes. Evaluate displacement or damage error, depth stability, and resolution transfer before adding new constitutive regimes.
 references: 61
 repositories: https://arxiv.org/abs/2203.08205

silva_snarf
 equation: d_w(x,B)=sum_b w_b(x) B_b x; d_w(x_star,B)-x_posed=0
 preserves: pose-independent canonical blend-weight field and pose-conditioned occupancy field linear blend forward deformation with inverse-bone multi-start root initialization implicit canonical correspondences, residual filtering, and soft occupancy union
 extends: replace weight/occupancy fields, transforms, pose conditioning, root solver, and aggregation sample posed occupancy grids and connect an optional marching-cubes backend
 benchmark requires: source subject meshes, bone transforms, canonical pose, query sampler, and train/validation sequences 2D Stick or DFaust/AMASS/CAPE access, occupancy labels, bootstrap losses, and root threshold unseen-pose reconstruction metrics, correspondence success, and mesh extraction settings
 data sources: https://github.com/xuchen-ethz/snarf https://amass.is.tue.mpg.de/ https://dfaust.is.tue.mpg.de/ https://cape.is.tue.mpg.de/ https://smpl.is.tue.mpg.de/
 source-scale steps: Acquire the permitted SMPL and motion/mesh assets and run the source point-sampling preprocessing for a declared subject split. Train canonical blend weights and occupancy with inverse-bone starts, Broyden roots, residual filtering, and pose conditioning. Evaluate within-distribution and unseen poses, correspondence success, occupancy quality, and marching-cubes reconstruction with fixed settings.
 references: 62
 repositories: https://github.com/xuchen-ethz/snarf

silva_mesh_inference
 equation: z_i_star=(b_i+sum_j w_ij z_j_star)/(lambda_i+tau_i+sum_j w_ij)
 preserves: receiver-autonomous nonnegative typed admission and source emission carriers anchored directed Jacobi relaxation whose system is an M-matrix centralized optimum comparison and numerical convergence certificate
 extends: supply field-specific anchors, observations, precisions, admission, emission, and clamped coordinates replace synchronous solving with a bounded-delay asynchronous executor under the same operator
 benchmark requires: paper synthetic lineage/carrier cases, source-novel forwarding policy, and noise model connectivity, asymmetry, anchor-density, latency, and confidentiality probe sweeps centralized Bayes optimum, spectral gap, recovery error, and communication accounting
 data sources: https://arxiv.org/abs/2606.19537 https://github.com/sym-bot/mesh-memory-protocol
 source-scale steps: Generate topology, typed observations, precisions, admission/emission policies, lineage, and seeds as a versioned case table. Run distributed relaxation and the centralized solve for every case, retaining the M-matrix and spectral-radius certificates. Sweep connectivity, asymmetry, noise, anchor density, latency, and forwarding while reporting agreement and communication cost.
 references: 63
 repositories: https://github.com/sym-bot/mesh-memory-protocol

silva_physics_guided_diffusion_pde
 equation: u_(t-1)=ProjectBoundary(Smooth(Prior(u_t))-eta grad E_PDE(u_t)+noise_t)
 preserves: standard data-trained field prior separated from physics at inference reverse denoising, Gaussian smoothing, residual-energy guidance, and hard boundary projection deterministic and stochastic schedules over Poisson, diffusion, or Burgers fields
 extends: replace prior, energy, differential discretization, smoother, schedule, projector, and stochasticity reuse one prior across coefficient or equation changes when field shape and normalization agree
 benchmark requires: source 64x64 fields, 4000 snapshots, global max-absolute scaling, and trained three-level U-Net prior Poisson/diffusion/Burgers coefficient ranges, boundary/initial data, reverse schedule, and guidance steps PDE residual, relative solution error, boundary error, convergence trace, and source baselines
 data sources: https://arxiv.org/abs/2604.01242
 source-scale steps: Generate the source 64x64 Poisson, diffusion, or Burgers fields and reproduce global max-absolute normalization. Train the three-level field prior independently of the PDE residual and freeze its checkpoint. Run deterministic and stochastic guided reverse schedules with Gaussian smoothing and hard boundary projection, then report field, residual, and boundary errors.
 references: 64
 repositories: https://arxiv.org/abs/2604.01242

silva_therino
 equation: epsilon_star=ProjectMacro(U_theta([epsilon_star, C:epsilon_star, 0.5 epsilon_star:C:epsilon_star, epsilon_bar]))
 preserves: fixed-point iteration in the physical strain field rather than an abstract latent state thermodynamic encoding through strain, stress, elastic energy density, and macroscopic loading shared neural-operator update, macroscopic-strain projection, and strain/stress/energy supervision
 extends: replace the constitutive encoder, neural operator, projection, solver, and each supervised loss term support differentiable constitutive maps beyond linear elasticity while retaining the physical-state contract
 benchmark requires: source periodic microstructure generator, finite-element labels, stiffness contrast, loading cases, and normalization three-dimensional Fourier operator width/modes, Anderson settings, optimizer, schedule, and random seeds strain, stress, energy, homogenized response, out-of-distribution contrast, and iteration metrics
 data sources: https://arxiv.org/abs/2411.06529 https://doi.org/10.1016/j.cma.2025.117939
 source-scale steps: Reproduce the source periodic microstructure generator, constituent laws, finite-element labels, load cases, split, and normalization before fitting the operator. Configure the physical-state transition with the reported three-dimensional Fourier update, macroscopic-strain projection, and Anderson solve. Train strain, stress, and energy objectives and report localization, homogenized response, contrast transfer, iterations, and memory against the declared baselines.
 references: 73
 repositories: https://arxiv.org/abs/2411.06529

silva_fixed_point_diffusion
 equation: z_t_star=F_theta(z_t_star, P(x_t), t); epsilon_hat=Q(z_t_star, x_t, t)
 preserves: explicit pre-processing, input projection/injection, timestep-conditioned implicit block, and explicit post-processing sequential reverse diffusion with the previous timestep equilibrium reused as the next initialization per-timestep iteration allocation and stochastic Jacobian-free backpropagation through sampled unrolled steps
 extends: replace pre, projection, fixed-point transition, post, conditioning, reverse scheduler, and allocation policy independently embed convolutional, attention, transformer, or operator transitions while preserving the timestep fixed-point interface
 benchmark requires: source latent encoder, image preprocessing, diffusion schedule, task split, and pretrained or jointly trained components reported timestep allocation, stochastic backward sampling, optimizer, precision, checkpoints, and generation budget FID-50K or task metric, block evaluations, equilibrium residual, wall time, memory, and source baselines
 data sources: https://arxiv.org/abs/2401.08741 https://openaccess.thecvf.com/content/CVPR2024/html/Bai_Fixed-Point_Diffusion_Models_CVPR_2024_paper.html
 source-scale steps: Acquire one declared image task and reproduce its resize/crop, latent encoder, diffusion schedule, split, and evaluation preprocessing. Configure explicit pre/projection/post blocks around the timestep-conditioned fixed point, then reproduce the source per-timestep iteration allocation and state reuse. Train with the declared stochastic Jacobian-free schedule and compare FID-50K, block evaluations, latency, memory, and residuals at equal sampling budgets.
 references: 74
 repositories: https://lukemelas.github.io/fixed-point-diffusion-models/

silva_monotone_operator_equilibrium
 equation: 0 in (I-W)z_star-Ux-b+partial f(z_star); W=(1-m)I-A^T A+B-B^T
 preserves: strongly monotone parameterization W=(1-m)I-A^T A+B-B^T forward-backward and Peaceman-Rachford operator splittings proximal nonlinearities and implicit differentiation at the solved equilibrium
 extends: replace the source, proximal map, monotone operator, splitter, readout, or solver inspect the monotonicity margin and numerical residual on every solve
 benchmark requires: source architecture width/depth, convolutional parameterization, data split, and augmentation splitting step size, forward/backward tolerances, optimizer, regularization, and seeds task accuracy, residual, evaluation count, memory, and source baselines
 data sources: https://arxiv.org/abs/2006.08591 https://github.com/locuslab/monotone_op_net
 source-scale steps: Acquire one source benchmark and reproduce its split, normalization, augmentation, and architecture dimensions. Choose the forward-backward or Peaceman-Rachford route and match the monotone factorization, proximal map, step, and solver tolerances. Validate the compact known-solution case, then report task accuracy, certificate, residual, evaluations, runtime, and memory at source scale.
 references: 75
 repositories: https://github.com/locuslab/monotone_op_net

silva_positive_concave_equilibrium
 equation: z_star=phi(W_positive z_star+s_positive(x)); W_positive>=0
 preserves: entrywise nonnegative recurrent operators and nonnegative source injection published variant-one tanh/softsign/ReLU6 and variant-two sigmoid maps fixed-point iteration over vector or convolutional positive-concave states
 extends: replace the positive operator, source, activation variant, readout, or solver use linear or spatial convolutions while retaining positivity diagnostics
 benchmark requires: source data split, preprocessing, positive parameterization, widths, kernels, and activations solver iterations, optimizer, learning-rate schedule, regularization, and seeds task accuracy, fixed-point residual, positivity minimum, runtime, and source baselines
 data sources: https://proceedings.mlr.press/v235/gabor24a.html https://github.com/mateuszgabor/pcdeq
 source-scale steps: Acquire one source vision task and reproduce its image preprocessing, split, and classifier head. Match published variant 1 or 2, nonnegative parameterization, activation, convolutional width, and fixed-point budget. Verify positivity and compact convergence first, then report task accuracy, residual, runtime, and memory with all source hyperparameters.
 references: 76
 repositories: https://github.com/mateuszgabor/pcdeq

silva_non_euclidean_equilibrium
 equation: z_star=phi(A z_star+B x+b); mu_infinity,D(A)<1
 preserves: weighted-infinity matrix-measure contraction certificate diagonally weighted parameterization and averaged fixed-point iteration input-output sensitivity bound in the learned non-Euclidean metric
 extends: replace the certified operator, source, activation, metric, averaging, or readout learn the metric jointly while exposing the one-sided bound and sensitivity certificate
 benchmark requires: source architecture, metric initialization, one-sided target, data perturbations, and preprocessing averaging rule, solver tolerance, optimizer, robustness protocol, and seeds task accuracy, certified bound, empirical sensitivity, residual, and source baselines
 data sources: https://arxiv.org/abs/2106.03194 https://github.com/davydovalexander/Non-Euclidean_Mon_Op_Net
 source-scale steps: Acquire one declared benchmark and reproduce clean and perturbed evaluation preprocessing. Match the weighted metric, one-sided matrix-measure target, averaging rule, architecture, and solver settings. Verify the compact certificate and empirical sensitivity, then report clean/robust task metrics, residuals, runtime, and memory.
 references: 77
 repositories: https://github.com/davydovalexander/Non-Euclidean_Mon_Op_Net

silva_efficient_infinite_graph
 equation: Z_star=gamma S^T Z_star g(F)^T+X; g(F)=F^T F/||F^T F||_F
 preserves: Frobenius-normalized positive-semidefinite channel Gram map graph/channel eigendecomposition for an exact dense symmetric solve the same equilibrium equation through iterative sparse or directed propagation
 extends: replace source, readout, graph operator, channel factor, gamma, or solve route precompute and reuse a graph spectrum without changing the SILVA state contract
 benchmark requires: source graph split, features, graph normalization, labels, and transductive protocol hidden width, gamma, optimizer, weight decay, early stopping, and seeds node accuracy, closed-form agreement, denominator margin, runtime, and memory
 data sources: https://arxiv.org/abs/2202.10720 https://github.com/liu-jc/EIGNN
 source-scale steps: Acquire a declared graph benchmark and preserve its official features, labels, split, and normalization. Use the normalized channel Gram map and match gamma, width, optimizer, early stopping, and either spectral or iterative solve route. Check closed-form/iterative agreement on a compact graph before reporting source-scale node accuracy, denominator margin, runtime, and memory.
 references: 78
 repositories: https://github.com/liu-jc/EIGNN

silva_multiscale_graph_implicit
 equation: Z_m_star=gamma S^m Z_m_star g(F_m)^T+X; Z=sum_m beta_m(Z_m_star)Z_m_star
 preserves: one infinite graph equilibrium for each declared graph-power scale independent normalized channel factors across scales nodewise softmax attention over converged scale states
 extends: replace scales, factors, source, per-scale solvers, attention, fusion, or readout inspect each scale state and attention distribution before adding new graph powers
 benchmark requires: source graph split, features, graph normalization, labels, and scale list per-scale widths, gamma, attention dimension, optimizer, early stopping, and seeds node accuracy, per-scale residuals, attention statistics, runtime, and memory
 data sources: https://arxiv.org/abs/2210.08353 https://github.com/liu-jc/MGNNI
 source-scale steps: Acquire a declared graph benchmark and preserve the official split, graph normalization, and feature preprocessing. Match graph-power scales, per-scale channel factors, equilibrium budgets, and nodewise attention fusion. Validate per-scale states and normalized attention on the compact case, then report task accuracy, residuals, fusion statistics, runtime, and memory.
 references: 79
 repositories: https://github.com/liu-jc/MGNNI

silva_delta_equilibrium
 equation: c_k=c_(k-1)+W mask(|z_k-z_(k-1)|>tau)(z_k-z_(k-1))
 preserves: cached linear or convolutional recurrent output updated from thresholded state deltas zero-threshold algebraic equivalence to full recurrent evaluation full-map training with independently selectable delta-cached inference
 extends: replace source, recurrent operator, activation, readout, threshold, or solver record active elements, exact full-map residual, and task error for every threshold
 benchmark requires: source model checkpoint, recurrent operators, data preprocessing, and evaluation sequence threshold policy, warm starts, solver tolerances, hardware, precision, and seeds task metric, active fraction, exact residual, latency, memory traffic, and source baseline
 data sources: https://papers.nips.cc/paper_files/paper/2024/hash/69f5b860d6dc469ac6e52f03866b73c4-Abstract-Conference.html https://github.com/ZuowenWang0000/Delta-Deep-Equilibrium-Models
 source-scale steps: Load a source-compatible checkpoint and reproduce the task data preprocessing and ordinary full-map evaluation first. Wrap supported recurrent linear or convolutional operators, begin at zero threshold, and verify prediction/state equivalence and exact residual. Sweep thresholds and report task degradation, active fraction, wall time, memory traffic, solver evaluations, and hardware details.
 references: 80
 repositories: https://github.com/ZuowenWang0000/Delta-Deep-Equilibrium-Models

silva_hyper_deq
 equation: z_0=h_phi(x); alpha_k,beta_k=H_phi(r_(k-m+1:k),x); z_(k+1)=beta_k sum_i alpha_(k,i) f(z_i,x)+(1-beta_k) sum_i alpha_(k,i) z_i
 preserves: learned condition-to-state initialization and learned Anderson coefficients/mixing high-precision teacher equilibrium and weighted trajectory supervision
 extends: replace every task module while retaining one learned-solver contract inspect every coefficient, mixing value, state, and residual in the accelerated path
 benchmark requires: source task model/checkpoint, teacher solver budget, training split, latency protocol, and task metric
 data sources: https://openreview.net/forum?id=B0oHOwT5ENL https://github.com/locuslab/deq https://www.salesforce.com/blog/the-wikitext-long-term-dependency-language-modeling-dataset/ https://www.image-net.org/ https://www.cityscapes-dataset.com/
 source-scale steps: Choose one source task, reproduce its ordinary equilibrium transition and checkpoint, and verify the unaccelerated task metric first. Generate high-precision roots and solver trajectories with fixed tolerances, then train the initializer and learned Anderson controller against that immutable teacher cache. Compare equal-budget classical and learned solvers on residual, task metric, operator evaluations, latency, memory, and failure rate before testing transfer to new inputs or transitions.
 references: 87
 repositories: https://github.com/locuslab/deq

silva_quantum_deq
 equation: z_star=Measure(U_theta(Encode(z_star+S(x)))); y_hat=Q(z_star)
 preserves: feature injection, repeated quantum-circuit measurement, and fixed-point solving direct, warmup, and implicit training routes with Jacobian regularization
 extends: replace the circuit backend while preserving measured state and solver contracts inspect circuit, fixed-point, gradient, and task diagnostics independently
 benchmark requires: source dataset split, wire count, encoding, circuit seed, solver budgets, schedule, and task metric
 data sources: https://arxiv.org/abs/2410.23940 https://github.com/martaskrt/qdeq https://yann.lecun.com/exdb/mnist/ https://github.com/zalandoresearch/fashion-mnist https://www.cs.toronto.edu/~kriz/cifar.html
 source-scale steps: Acquire one declared image benchmark, preserve its official split, and reproduce the source image filter, class subset, encoding, wire count, and circuit seed. Match the fixed and trainable gate sequences, measurement/interpolation rule, direct warmup, implicit-solver budget, backward rule, and Jacobian regularization schedule. Report task accuracy, residual, iterations, circuit evaluations, gradient variance, wall time, memory, and shots or exact-statevector setting against direct and classical baselines.
 references: 90
 repositories: https://github.com/martaskrt/qdeq

silva_bayesian_deq
 equation: theta_s~q_phi(theta); z_s_star=T_theta_s(z_s_star,x); p(y|x)=S^{-1} sum_s p(y|z_s_star)
 preserves: posterior-sampled transition parameters and one equilibrium per sample sequential warm starts across nearby posterior samples predictive mean, variance, and posterior regularization
 extends: replace the posterior transition, sampler, root solver, or task readout compare independent and sequential inference under an identical sample order
 benchmark requires: source dataset, posterior parameterization, sample count, solver budget, optimizer, seeds, calibration and task metrics
 data sources: https://openreview.net/forum?id=hT9FJBePUR
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 94
 repositories: https://openreview.net/forum?id=hT9FJBePUR

silva_joint_inference_equilibrium
 equation: (z_star,u_star)=(T_theta(z_star,u_star,y), Projection_C(u_star-eta g_phi(u_star,z_star,y)))
 preserves: one augmented fixed point jointly updates representation and optimized input projection-compatible input update and independently replaceable representation branch
 extends: supply inverse-problem, latent inversion, adversarial, or meta-learning updates inspect state and optimized-input residuals separately
 benchmark requires: source task, initialization, objective, projection, model checkpoint, solver, optimizer, seeds, and task metric
 data sources: https://github.com/locuslab/JIIO-DEQ
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 95
 repositories: https://github.com/locuslab/JIIO-DEQ

silva_implicit_spatiotemporal
 equation: u_(n+1)=u_n+dt[(1-theta)F(u_n,c_n)+theta F(u_(n+1),c_n)]
 preserves: implicit theta-method steps with additive known and learned physical dynamics replaceable boundary projection and decoded trajectory readout
 extends: supply grid, spectral, finite-volume, graph, or custom differentiable dynamics change time step, implicitness, horizon, closure, and checkpoint segmentation independently
 benchmark requires: governing PDE, discretization, initial/boundary data, source split, horizon, solver tolerances, optimizer, seeds, trajectory metrics, runtime, and memory
 data sources: https://arxiv.org/abs/2504.02260
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 96
 repositories: https://arxiv.org/abs/2504.02260

silva_certified_equilibrium
 equation: z_star=phi(W z_star+U x+b), ||W||_infinity<1; [z_lower,z_upper]=IBP_fixed_point([x_lower,x_upper])
 preserves: contractive affine equilibrium with a monotone activation coupled lower/upper interval fixed point and signed-affine output bounds exportable ReLU affine system for semialgebraic certificate programs
 extends: replace bounded source, state operator, activation, readout, or certificate backend report natural and certified accuracy as separate metrics
 benchmark requires: source dataset, perturbation norm/radius, contraction parameterization, bound solver, training schedule, seeds, natural accuracy, certified accuracy, and certificate runtime
 data sources: https://openreview.net/forum?id=y1PXylgrXZ https://github.com/locuslab/monotone_op_net
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 97 98
 repositories: https://openreview.net/forum?id=y1PXylgrXZ https://github.com/locuslab/monotone_op_net

silva_lipschitz_mdeq
 equation: z_star=tanh(S_theta(x)+W_hat z_star), ||W_hat||_infinity<=rho<1; z_star=concat(z_star[1],...,z_star[R])
 preserves: simultaneous multiscale state packed into one fixed point explicitly bounded recurrent cross-scale map and inspectable branch states
 extends: replace injection, cross-scale operator, branch dimensions, readout, or solver retain the measured contraction while introducing convolutional scale adapters
 benchmark requires: source image task, scale graph, Lipschitz target, augmentation, optimizer, solver, seeds, accuracy/segmentation metric, runtime, and memory
 data sources: https://github.com/iiduka-researches/Lipschitz_mdeq
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 99
 repositories: https://github.com/iiduka-researches/Lipschitz_mdeq

silva_subhomogeneous_equilibrium
 equation: z_star=norm_p((tanh(W z_star)+f_theta(x)+a)^q), a>1, 0<q<=1
 preserves: translated positive transition, configurable subhomogeneity degree, and p-normalization strictly positive normalized states without a contraction requirement
 extends: replace the positive input map, state map, norm, power, readout, or solver compare finite-p and infinity-normalized variants under identical data
 benchmark requires: source task, transition variant, normalization order, translation, power, optimizer, solver, seeds, and task metric
 data sources: https://arxiv.org/abs/2403.00720
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 100
 repositories: https://arxiv.org/abs/2403.00720

silva_algorithmic_reasoner
 equation: h_v_star=tanh(E(x_v)+rho mean_(u,v) M_theta(h_u_star,h_v_star))
 preserves: encode-process-decode graph reasoning with a solved processor state shared message processor and graph-size-independent equilibrium depth
 extends: replace encoders, message functions, hint decoders, output heads, or root solver add individual CLRS algorithm specifications without changing the equilibrium interface
 benchmark requires: CLRS task/version, graph generator, train/evaluation sizes, hint schedule, processor, solver, optimizer, seeds, and official metric
 data sources: https://github.com/HekpoMaH/DEAR https://github.com/google-deepmind/clrs
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 101
 repositories: https://github.com/HekpoMaH/DEAR https://github.com/google-deepmind/clrs

silva_hamiltonian_equilibrium
 equation: H_star=sym(Phi_theta(features, pairwise_distances)+gamma tanh(H_star))
 preserves: self-consistent symmetric Hamiltonian updated from invariant pair geometry replaceable molecular interaction backbone and explicit self-consistency gain
 extends: insert equivariant orbital features, block-sparse heads, overlap matrices, or spectral losses retain symmetry and coordinate-invariance tests as the backbone grows
 benchmark requires: dataset revision, species/orbital basis, geometry units, split, equivariant backbone, loss, solver, seeds, Hamiltonian and spectral metrics
 data sources: https://github.com/Zun-Wang/DEQHNet
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 102
 repositories: https://github.com/Zun-Wang/DEQHNet

silva_inverse_imaging_equilibrium
 equation: x_star=D_theta(x_star-eta A^T(A x_star-y))
 preserves: known forward/adjoint data consistency followed by a learned image prior shape-preserving reconstruction fixed point with independent operator and prior modules
 extends: replace sensing, adjoint, prior, step rule, projection, or solver support matrix-free MRI, tomography, blur, super-resolution, and compressive operators
 benchmark requires: dataset, degradation operator and parameters, split, normalization, prior checkpoint, solver, optimizer, seeds, PSNR/SSIM, runtime, and memory
 data sources: https://arxiv.org/abs/2102.07944
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 103
 repositories: https://arxiv.org/abs/2102.07944

silva_snapshot_compressive_equilibrium
 equation: v_star=D_theta(v_star+eta Phi^T(Phi Phi^T)^-1(y-Phi v_star))
 preserves: coded snapshot measurement and analytic mask-adjoint correction volumetric learned prior over the reconstructed frame stack
 extends: replace masks, data-consistency gain, 3D prior, temporal representation, or solver run calibrated real masks or generated mask ensembles through the same transition contract
 benchmark requires: video set, mask files/checksums, frame grouping, crop protocol, prior architecture, optimizer, solver, seeds, PSNR/SSIM, runtime, and memory
 data sources: https://github.com/IndigoPurple/DEQSCI
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 104
 repositories: https://github.com/IndigoPurple/DEQSCI

silva_magnetic_particle_equilibrium
 equation: (x_star,z_d_star,z_p_star,d_d_star,d_p_star)=T_ADMM_theta(.,y,A)
 preserves: packed primal, split-variable, and dual state for a learned ADMM equilibrium known system matrix with independently learned prior and data-consistency maps
 extends: replace calibrated matrix multiplication with matrix-free operators replace the regularizer, learned consistency, penalty schedule, splitting, or readout
 benchmark requires: OpenMPIData revision, system-matrix calibration, frequency selection, normalization, split, ADMM settings, optimizer, seeds, image metric, runtime, and memory
 data sources: https://github.com/icon-lab/DEQ-MPI
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 105
 repositories: https://github.com/icon-lab/DEQ-MPI

silva_sparse_hyperspectral_equilibrium
 equation: c_star=soft_threshold(c_star-eta D_a(D_s c_star-y)+lambda D_a P_theta(D_s c_star))
 preserves: analysis/synthesis dictionaries, sparse shrinkage, and learned spectral-spatial prior equilibrium solved in the latent sparse-code space
 extends: replace dictionaries, threshold, shrinkage, cube prior, noise model, or solver add low-rank, nonlocal, transformer, or wavelength-aware proximal maps
 benchmark requires: dataset revision, wavelength bands, noise process, crop/split, dictionary widths, optimizer, solver, seeds, PSNR/SSIM/SAM, runtime, and memory
 data sources: https://arxiv.org/abs/2203.15901
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 106
 repositories: https://arxiv.org/abs/2203.15901

silva_serialized_smoothing_equilibrium
 equation: z_i_star=T_theta(z_i_star,x+sigma epsilon_i), z_i^(0)=stopgrad(z_(i-1)_star)
 preserves: Gaussian smoothing samples solved sequentially with equilibrium warm starts class-count confidence lower bound and certified-radius calculation
 extends: replace classifier, noise law, confidence interval, sample order, cache, or solver measure certificate agreement and iteration savings against independent solves
 benchmark requires: classifier checkpoint, dataset split, noise scale, sample counts, confidence rule, serialization order, seeds, certified accuracy, abstention, runtime, and memory
 data sources: https://github.com/WeizhiGao/Serialized-Randomized-Smoothing
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 107
 repositories: https://github.com/WeizhiGao/Serialized-Randomized-Smoothing

silva_diffusion_restoration_equilibrium
 equation: X_star=T_theta(X_star,y,mask,noise), X_star=(x_T_star,...,x_0_star)
 preserves: joint state containing the complete reverse restoration trajectory hard observation projection at every solved trajectory component
 extends: replace denoiser, degradation model, schedule, trajectory coupling, partition, or solver warm-start neighboring degradations and compare sequential versus joint inference
 benchmark requires: dataset, degradation and mask protocol, diffusion checkpoint, schedule, solver, seeds, PSNR/SSIM/LPIPS, sampling time, and memory
 data sources: https://github.com/caojiezhang/DeqIR
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 108
 repositories: https://github.com/caojiezhang/DeqIR

silva_recurrent_equilibrium_network
 equation: w_t_star=phi(D11 w_t_star+C1 x_t+D12 u_t); x_(t+1)=A x_t+B1 w_t_star+B2 u_t
 preserves: dynamic state recurrence with an algebraic equilibrium at each time index bounded algebraic map and independently inspectable state/equilibrium/output trajectories
 extends: replace dynamic matrices, algebraic map, input coupling, readout, or per-step solver use structured state-space, control, identification, or physics-informed modules
 benchmark requires: sequence dataset, sampling interval, state normalization, initialization, horizon, optimizer, solver, seeds, rollout metric, stability, runtime, and memory
 data sources: https://arxiv.org/abs/2104.05942
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 109
 repositories: https://arxiv.org/abs/2104.05942

silva_lipschitz_robust_equilibrium
 equation: z_star=tanh(W_bar z_star+U_bar x+b), Lip(Q o z_star)<=L_Q L_U/(1-L_W)
 preserves: bounded recurrent, input, and readout maps with an explicit global constant margin-derived input certificate and selectable structured parameterization
 extends: select LBEN, orthogonal, sandwich, or coupled maps replace bounded modules, activation, readout, attack, or certificate evaluator
 benchmark requires: dataset, normalization, architecture, parameterization, target bound, threat model, optimizer, solver, seeds, clean/robust/certified accuracy, runtime, and memory
 data sources: https://github.com/AaronHavens/ExploitingLipschitzDEQ
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 110
 repositories: https://github.com/AaronHavens/ExploitingLipschitzDEQ

silva_image_matting_equilibrium
 equation: alpha_star=Project_trimap(sigmoid(R_theta(alpha_star,E_theta(image,trimap))))
 preserves: image/trimap encoder, recurrent alpha refiner, and exact known-region projection solved unknown-region alpha matte with independently replaceable modules
 extends: replace encoder, refiner, trimap thresholds, composition branch, losses, or solver add multiscale crops, foreground prediction, and full-resolution refinement
 benchmark requires: matting dataset/version, foreground/background composition, trimap generation, crop split, losses, optimizer, solver, seeds, SAD/MSE/gradient/connectivity metrics
 data sources: https://github.com/CurioPocket/DEQ-Matt
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 111
 repositories: https://github.com/CurioPocket/DEQ-Matt

silva_dynamic_economic_equilibrium
 equation: c_t+k_(t+1)=resources(s_t); u'(c_t)=beta E[u'(c_(t+1)) R_(t+1)]
 preserves: feasible policy shares satisfying the resource equation by construction differentiable Euler-equation residuals for label-free simulated-state training
 extends: replace utility, production, shocks, policy network, expectations, constraints, or equilibrium conditions extend from stochastic growth to heterogeneous-agent and multi-country systems
 benchmark requires: economic model equations/parameters, shock process, state domain, simulation and quadrature rules, optimizer, seeds, Euler/residual errors, policy comparison, runtime, and memory
 data sources: https://github.com/sischei/DeepEquilibriumNets
 source-scale steps: Acquire the cited data and preserve its official split, preprocessing, units, and metric. Build the same SILVA family with source-aligned task modules and scale controls. Run forward, loss, backward, checkpoint resume, and metric validation on a small shard before the complete experiment.
 references: 112
 repositories: https://github.com/sischei/DeepEquilibriumNets

Build a New Transition From Its Equation¶

For the compact transition

$$ T_\theta(z,x)=\tanh\!\left(W_xx+0.15\,h_\theta(z)\right), $$

the source projection and recurrent field remain independently replaceable. The validator checks shape, device, dtype, finiteness, and state-gradient compatibility before the solver is introduced.

In [4]:

class CustomTransition(nn.Module):
    def __init__(self, input_dim=2, state_dim=4):
        super().__init__()
        self.source = nn.Linear(input_dim, state_dim)
        self.recurrent = nn.Sequential(
            nn.Linear(state_dim, 8),
            nn.Tanh(),
            nn.Linear(8, state_dim),
        )

    def forward(self, state, inputs):
        return torch.tanh(self.source(inputs) + 0.15 * self.recurrent(state))


inputs = torch.linspace(-1.0, 1.0, 12).reshape(6, 2)
transition = CustomTransition()
report = validate_silva_transition(transition, torch.zeros(6, 4), inputs)
assert report.valid

custom = SILVAConditionedEquilibrium(
    transition,
    SILVAZeroInitializer(4),
    readout=nn.Linear(4, 1),
    config=SolverConfig(
        solver="anderson",
        max_iter=30,
        tol=1e-6,
        backward_mode="implicit",
        backward_solver="gmres",
        anderson_batch_dims=1,
    ),
)
custom_result = custom(inputs, return_result=True)
custom_result.output.square().mean().backward()
assert custom_result.output.shape == (6, 1)
assert all(parameter.grad is not None for parameter in custom.parameters())
print("custom residual:", custom_result.solver_result.residual)

class CustomTransition(nn.Module): def __init__(self, input_dim=2, state_dim=4): super().__init__() self.source = nn.Linear(input_dim, state_dim) self.recurrent = nn.Sequential( nn.Linear(state_dim, 8), nn.Tanh(), nn.Linear(8, state_dim), ) def forward(self, state, inputs): return torch.tanh(self.source(inputs) + 0.15 * self.recurrent(state)) inputs = torch.linspace(-1.0, 1.0, 12).reshape(6, 2) transition = CustomTransition() report = validate_silva_transition(transition, torch.zeros(6, 4), inputs) assert report.valid custom = SILVAConditionedEquilibrium( transition, SILVAZeroInitializer(4), readout=nn.Linear(4, 1), config=SolverConfig( solver="anderson", max_iter=30, tol=1e-6, backward_mode="implicit", backward_solver="gmres", anderson_batch_dims=1, ), ) custom_result = custom(inputs, return_result=True) custom_result.output.square().mean().backward() assert custom_result.output.shape == (6, 1) assert all(parameter.grad is not None for parameter in custom.parameters()) print("custom residual:", custom_result.solver_result.residual)

custom residual: 9.929138968800544e-07

Joint Diffusion Restoration Inside SILVA¶

Let $X=(x_{t_0},\ldots,x_{t_K})$ be one joint trajectory. A restoration adaptation uses

$$ x_{t_{k+1}}^+ =P_{y,t_{k+1}}\!\left(D_{t_k\rightarrow t_{k+1}} (x_{t_k};c,\xi_k)\right), $$

where $D$ is a complete reverse step and $P$ is a declared measurement or data-consistency operator. The triangular transition updates all trajectory positions from the previous solver state. The step, observation operator, schedule, stochastic terms, condition, and initial trajectory are separately controllable.

In [5]:

class CompleteReverseStep(nn.Module):
    def __init__(self):
        super().__init__()
        self.scale = nn.Parameter(torch.tensor(0.4))

    def forward(self, state, timestep, next_timestep, condition, noise):
        del timestep, next_timestep, noise
        return self.scale * state + condition


class ObservationOperator(nn.Module):
    def __init__(self):
        super().__init__()
        self.logit = nn.Parameter(torch.tensor(0.0))

    def forward(self, candidate, observation, next_timestep):
        del next_timestep
        weight = self.logit.sigmoid()
        return weight * candidate + (1.0 - weight) * observation


restoration = SILVADiffusionEquilibrium(
    denoiser=None,
    alphas_cumprod=torch.tensor([0.95, 0.80, 0.60]),
    timesteps=(2, 1, 0),
    step_operator=CompleteReverseStep(),
    data_consistency=ObservationOperator(),
    config=SolverConfig(
        solver="picard",
        max_iter=5,
        tol=1e-7,
        backward_mode="unrolled",
        anderson_batch_dims=0,
    ),
)
noise = torch.randn(2, 1, 4, 4, requires_grad=True)
condition = torch.full_like(noise, 0.1, requires_grad=True)
observation = torch.zeros_like(noise, requires_grad=True)
restoration_result = restoration(
    noise,
    condition=condition,
    observation=observation,
    return_result=True,
)
restoration_result.output.square().mean().backward()
assert restoration_result.trajectory.shape == (3, *noise.shape)
assert observation.grad is not None
print("restoration residual:", restoration_result.solver_result.residual)

class CompleteReverseStep(nn.Module): def __init__(self): super().__init__() self.scale = nn.Parameter(torch.tensor(0.4)) def forward(self, state, timestep, next_timestep, condition, noise): del timestep, next_timestep, noise return self.scale * state + condition class ObservationOperator(nn.Module): def __init__(self): super().__init__() self.logit = nn.Parameter(torch.tensor(0.0)) def forward(self, candidate, observation, next_timestep): del next_timestep weight = self.logit.sigmoid() return weight * candidate + (1.0 - weight) * observation restoration = SILVADiffusionEquilibrium( denoiser=None, alphas_cumprod=torch.tensor([0.95, 0.80, 0.60]), timesteps=(2, 1, 0), step_operator=CompleteReverseStep(), data_consistency=ObservationOperator(), config=SolverConfig( solver="picard", max_iter=5, tol=1e-7, backward_mode="unrolled", anderson_batch_dims=0, ), ) noise = torch.randn(2, 1, 4, 4, requires_grad=True) condition = torch.full_like(noise, 0.1, requires_grad=True) observation = torch.zeros_like(noise, requires_grad=True) restoration_result = restoration( noise, condition=condition, observation=observation, return_result=True, ) restoration_result.output.square().mean().backward() assert restoration_result.trajectory.shape == (3, *noise.shape) assert observation.grad is not None print("restoration residual:", restoration_result.solver_result.residual)

restoration residual: 0.0

Record What Was Actually Run¶

A benchmark record must preserve the source relationship and every deviation from the cited protocol. This prevents a compact mechanism check from being mistaken for a published-scale result and makes controlled extensions possible.

In [6]:

selected = silva_reproduction_spec("deq_ddim")
run_record = {
    "family": selected.family,
    "paper_refs": selected.paper_refs,
    "source_relation": selected.source_relation,
    "verification_level": selected.verification_level,
    "dataset": "deterministic compact tensors",
    "split": "single checked batch",
    "model_options": {
        "trajectory_steps": 3,
        "complete_step": "CompleteReverseStep",
        "observation_operator": "ObservationOperator",
    },
    "solver": asdict(restoration.config),
    "metrics": {
        "fixed_point_residual": restoration_result.solver_result.residual,
        "output_norm": float(restoration_result.output.detach().norm()),
    },
    "seed": 27,
    "deviations": "compact mechanism check; no published image benchmark claimed",
}
assert run_record["metrics"]["fixed_point_residual"] < 1e-5
run_record

selected = silva_reproduction_spec("deq_ddim") run_record = { "family": selected.family, "paper_refs": selected.paper_refs, "source_relation": selected.source_relation, "verification_level": selected.verification_level, "dataset": "deterministic compact tensors", "split": "single checked batch", "model_options": { "trajectory_steps": 3, "complete_step": "CompleteReverseStep", "observation_operator": "ObservationOperator", }, "solver": asdict(restoration.config), "metrics": { "fixed_point_residual": restoration_result.solver_result.residual, "output_norm": float(restoration_result.output.detach().norm()), }, "seed": 27, "deviations": "compact mechanism check; no published image benchmark claimed", } assert run_record["metrics"]["fixed_point_residual"] < 1e-5 run_record

Out[6]:

{'family': 'diffusion_equilibrium',
 'paper_refs': (38, 49),
 'source_relation': 'paper-adaptation',
 'verification_level': 'compact-verified',
 'dataset': 'deterministic compact tensors',
 'split': 'single checked batch',
 'model_options': {'trajectory_steps': 3,
  'complete_step': 'CompleteReverseStep',
  'observation_operator': 'ObservationOperator'},
 'solver': {'solver': 'picard',
  'max_iter': 5,
  'tol': 1e-07,
  'alpha': 1.0,
  'history': 5,
  'ridge': 0.0001,
  'beta': 1.0,
  'stop_mode': 'absolute',
  'relative_eps': 1e-08,
  'anderson_batch_dims': 0,
  'track_residuals': True,
  'reengage': True,
  'backward_mode': 'unrolled',
  'backward_solver': 'gmres',
  'backward_max_iter': 50,
  'backward_tol': 1e-06,
  'backward_stop_mode': 'absolute',
  'backward_relative_eps': 1e-08,
  'phantom_steps': 1,
  'phantom_tau': 1.0,
  'neumann_terms': 5,
  'shine_refine_steps': 0,
  'indexing': (),
  'return_best': False},
 'metrics': {'fixed_point_residual': 0.0, 'output_norm': 0.4447976052761078},
 'seed': 27,
 'deviations': 'compact mechanism check; no published image benchmark claimed'}

From 27 Reproducing Silva And Source Methods to a Custom SILVA Family¶

The construction in this notebook can be separated into the universal conditioned-equilibrium contract

$$ z_0=I_\eta(x),\qquad z^\star=T_\theta(z^\star,x),\qquad \widehat y=Q_\psi(z^\star). $$

For this topic:

Part	Concrete interpretation
Equilibrium state	the tensor solved to equilibrium
Condition	the observed input or source tensor
Repeated computation	the state-preserving transition evaluated by the root solver
Required invariants	shape, device, dtype, finiteness, and differentiability
Replaceable components	initializer, source encoder, transition, readout, and solver

The initializer and source path are evaluated outside or alongside the root solve. Only the state-preserving transition is repeated. Replacing an internal architecture does not change this equation, provided the transition still maps the same state space into itself.

In [7]:

silva-extension-curriculum

import torch as silva_extension_torch
from torch import nn as silva_extension_nn

from silva_networks import (
    SILVAConditionedEquilibrium,
    SILVAZeroInitializer,
    SolverConfig,
    validate_silva_transition,
)


class NotebookExtensionTransition(silva_extension_nn.Module):
    def __init__(self, condition_dim=2, state_dim=3):
        super().__init__()
        self.source = silva_extension_nn.Linear(condition_dim, state_dim)
        self.state_field = silva_extension_nn.Sequential(
            silva_extension_nn.Linear(state_dim, 2 * state_dim),
            silva_extension_nn.Tanh(),
            silva_extension_nn.Linear(2 * state_dim, state_dim),
        )

    def forward(self, state, condition):
        return silva_extension_torch.tanh(
            self.source(condition) + 0.15 * self.state_field(state)
        )


silva_extension_torch.manual_seed(610)
notebook_condition = silva_extension_torch.linspace(-1.0, 1.0, 8).reshape(4, 2)
notebook_state0 = silva_extension_torch.zeros(4, 3)
notebook_transition = NotebookExtensionTransition()

notebook_report = validate_silva_transition(
    notebook_transition,
    notebook_state0,
    notebook_condition,
)
assert notebook_report.valid

with silva_extension_torch.no_grad():
    notebook_reference_step = silva_extension_torch.tanh(
        notebook_transition.source(notebook_condition)
        + 0.15 * notebook_transition.state_field(notebook_state0)
    )
silva_extension_torch.testing.assert_close(
    notebook_transition(notebook_state0, notebook_condition),
    notebook_reference_step,
)

notebook_custom_model = SILVAConditionedEquilibrium(
    notebook_transition,
    SILVAZeroInitializer(3),
    readout=silva_extension_nn.Linear(3, 1),
    config=SolverConfig(
        solver="picard",
        max_iter=40,
        tol=1e-7,
        backward_mode="implicit",
        backward_solver="gmres",
        anderson_batch_dims=1,
    ),
)
notebook_custom_result = notebook_custom_model(
    notebook_condition,
    return_result=True,
)
assert notebook_custom_result.output.shape == (4, 1)
assert notebook_custom_result.solver_result.residual < 1e-5

notebook_custom_result.output.square().mean().backward()
assert all(
    parameter.grad is not None and silva_extension_torch.isfinite(parameter.grad).all()
    for parameter in notebook_custom_model.parameters()
)
print("custom transition:", notebook_report)
print("equilibrium residual:", notebook_custom_result.solver_result.residual)

import torch as silva_extension_torch from torch import nn as silva_extension_nn from silva_networks import ( SILVAConditionedEquilibrium, SILVAZeroInitializer, SolverConfig, validate_silva_transition, ) class NotebookExtensionTransition(silva_extension_nn.Module): def __init__(self, condition_dim=2, state_dim=3): super().__init__() self.source = silva_extension_nn.Linear(condition_dim, state_dim) self.state_field = silva_extension_nn.Sequential( silva_extension_nn.Linear(state_dim, 2 * state_dim), silva_extension_nn.Tanh(), silva_extension_nn.Linear(2 * state_dim, state_dim), ) def forward(self, state, condition): return silva_extension_torch.tanh( self.source(condition) + 0.15 * self.state_field(state) ) silva_extension_torch.manual_seed(610) notebook_condition = silva_extension_torch.linspace(-1.0, 1.0, 8).reshape(4, 2) notebook_state0 = silva_extension_torch.zeros(4, 3) notebook_transition = NotebookExtensionTransition() notebook_report = validate_silva_transition( notebook_transition, notebook_state0, notebook_condition, ) assert notebook_report.valid with silva_extension_torch.no_grad(): notebook_reference_step = silva_extension_torch.tanh( notebook_transition.source(notebook_condition) + 0.15 * notebook_transition.state_field(notebook_state0) ) silva_extension_torch.testing.assert_close( notebook_transition(notebook_state0, notebook_condition), notebook_reference_step, ) notebook_custom_model = SILVAConditionedEquilibrium( notebook_transition, SILVAZeroInitializer(3), readout=silva_extension_nn.Linear(3, 1), config=SolverConfig( solver="picard", max_iter=40, tol=1e-7, backward_mode="implicit", backward_solver="gmres", anderson_batch_dims=1, ), ) notebook_custom_result = notebook_custom_model( notebook_condition, return_result=True, ) assert notebook_custom_result.output.shape == (4, 1) assert notebook_custom_result.solver_result.residual < 1e-5 notebook_custom_result.output.square().mean().backward() assert all( parameter.grad is not None and silva_extension_torch.isfinite(parameter.grad).all() for parameter in notebook_custom_model.parameters() ) print("custom transition:", notebook_report) print("equilibrium residual:", notebook_custom_result.solver_result.residual)

custom transition: SILVATransitionReport(state_shape=(4, 3), output_shape=(4, 3), preserves_shape=True, preserves_device=True, preserves_dtype=True, finite=True, differentiable=True, parameter_count=54)
equilibrium residual: 5.960464477539063e-08

Numerical Equivalence, Compact Reproduction, and Scale¶

Before training, compare one packaged transition with an independently written update:

$$ e_{\mathrm{step}} =\frac{\|T_\theta(z,x)-T_{\mathrm{ref}}(z,x)\|_2} {\|T_{\mathrm{ref}}(z,x)\|_2+\varepsilon}. $$

After solving, report the fixed-point residual separately:

$$ e_{\mathrm{fp}} =\frac{\|T_\theta(z^\star,x)-z^\star\|_2} {\|z^\star\|_2+\varepsilon}. $$

For this notebook, a compact reproduction must declare and assert fixed-point residual and task error against a deterministic target. A full experiment must additionally record the source dataset version and split, preprocessing, architecture widths, solver and optimizer schedules, random seeds, baseline configuration, checkpoints, and every deviation from the cited protocol.

The principal scaling axes are state width, batch size, and data volume. Increase one axis at a time, retain the compact deterministic case as a regression test, and record task error, domain-specific residual, forward residual, backward linear residual, memory use, and runtime independently.

Extension Exercises¶

1. Replace one component from this notebook while preserving its state and domain invariants.
2. Write the replacement first as an independent reference function, then as a module, and assert one-step equivalence.
3. Compare two solver configurations on the identical trained transition.
4. Add a compact baseline and a predeclared metric threshold.
5. Create a full-scale configuration without weakening the compact tests.

The complete authoring protocol is documented in Extending SILVA.

In [8]:

silva-extension-curriculum

notebook_reproduction_record = {
    "notebook": '27_reproducing_silva_and_source_methods.ipynb',
    "state": 'the tensor solved to equilibrium',
    "condition": 'the observed input or source tensor',
    "transition": 'the state-preserving transition evaluated by the root solver',
    "invariants": 'shape, device, dtype, finiteness, and differentiability',
    "compact_metric": 'fixed-point residual and task error against a deterministic target',
    "scale_axis": 'state width, batch size, and data volume',
}
assert all(notebook_reproduction_record.values())
notebook_reproduction_record

notebook_reproduction_record = { "notebook": '27_reproducing_silva_and_source_methods.ipynb', "state": 'the tensor solved to equilibrium', "condition": 'the observed input or source tensor', "transition": 'the state-preserving transition evaluated by the root solver', "invariants": 'shape, device, dtype, finiteness, and differentiability', "compact_metric": 'fixed-point residual and task error against a deterministic target', "scale_axis": 'state width, batch size, and data volume', } assert all(notebook_reproduction_record.values()) notebook_reproduction_record

Out[8]:

{'notebook': '27_reproducing_silva_and_source_methods.ipynb',
 'state': 'the tensor solved to equilibrium',
 'condition': 'the observed input or source tensor',
 'transition': 'the state-preserving transition evaluated by the root solver',
 'invariants': 'shape, device, dtype, finiteness, and differentiability',
 'compact_metric': 'fixed-point residual and task error against a deterministic target',
 'scale_axis': 'state width, batch size, and data volume'}

Worked Convergence and Sensitivity Study¶

The preceding example demonstrates one configured solve. This additional study changes the transition feedback factor while keeping the source fixed, so solver effort and implicit sensitivity can be read separately from task behavior. Locally, one eigendirection of a nonlinear transition can be represented by

$$ z_{k+1} = \rho z_k + u, \qquad 0 \leq \rho < 1. $$

Its equilibrium is

$$ z^\star = \frac{u}{1-\rho}. $$

Subtracting the fixed-point equation from the iteration gives the exact error recursion

$$ e_{k+1} = \rho e_k, \qquad |e_k| = \rho^k |e_0|. $$

For a requested absolute tolerance $\tau$, the idealized iteration estimate is

$$ k \geq \frac{\log(\tau/|e_0|)}{\log \rho}. $$

The same factor controls sensitivity. Differentiating the equilibrium with respect to the source gives

$$ \frac{\partial z^\star}{\partial u} =\frac{1}{1-\rho}. $$

Thus a transition can remain contractive while becoming expensive and highly sensitive as $\rho$ approaches one. The table and figure below measure this effect rather than merely stating it. They provide a reference envelope for the notebook's actual state, the tensor solved to equilibrium, and its repeated map, the state-preserving transition evaluated by the root solver. The scalar study does not replace the domain model; it supplies a result whose convergence rate and derivative are known exactly, so the same reporting code can be trusted before it is applied to the larger transition.

In [9]:

silva-extension-curriculum

import math as silva_deepening_math
import torch as silva_deepening_torch

silva_deepening_rates = (0.20, 0.45, 0.70, 0.85)
silva_deepening_source = 0.35
silva_deepening_tolerance = 1e-8
silva_deepening_histories = {}
silva_deepening_rows = []

for silva_deepening_rho in silva_deepening_rates:
    silva_deepening_state = silva_deepening_torch.tensor(0.0)
    silva_deepening_exact = silva_deepening_source / (1.0 - silva_deepening_rho)
    silva_deepening_history = []
    for silva_deepening_iteration in range(1, 241):
        silva_deepening_next = (
            silva_deepening_rho * silva_deepening_state + silva_deepening_source
        )
        silva_deepening_residual = abs(
            float(silva_deepening_next - silva_deepening_state)
        )
        silva_deepening_history.append(silva_deepening_residual)
        silva_deepening_state = silva_deepening_next
        if silva_deepening_residual < silva_deepening_tolerance:
            break

    silva_deepening_u = silva_deepening_torch.tensor(
        silva_deepening_source, requires_grad=True
    )
    silva_deepening_solution = silva_deepening_u / (1.0 - silva_deepening_rho)
    silva_deepening_solution.backward()
    silva_deepening_expected_sensitivity = 1.0 / (1.0 - silva_deepening_rho)
    silva_deepening_gradient_error = abs(
        float(silva_deepening_u.grad) - silva_deepening_expected_sensitivity
    )
    silva_deepening_histories[silva_deepening_rho] = silva_deepening_history
    silva_deepening_rows.append(
        (
            silva_deepening_rho,
            silva_deepening_iteration,
            silva_deepening_history[-1],
            abs(float(silva_deepening_state) - silva_deepening_exact),
            float(silva_deepening_u.grad),
            silva_deepening_gradient_error,
        )
    )

print('transition feedback factor')
print("rho | iterations | final residual | exact-state error | sensitivity | gradient error")
for silva_deepening_row in silva_deepening_rows:
    print(
        f"{silva_deepening_row[0]:.2f} | {silva_deepening_row[1]:3d} | "
        f"{silva_deepening_row[2]:.3e} | {silva_deepening_row[3]:.3e} | "
        f"{silva_deepening_row[4]:.4f} | {silva_deepening_row[5]:.3e}"
    )

assert all(row[2] < silva_deepening_tolerance for row in silva_deepening_rows)
assert all(row[3] < 1e-6 for row in silva_deepening_rows)
assert all(row[5] < 1e-6 for row in silva_deepening_rows)

import math as silva_deepening_math import torch as silva_deepening_torch silva_deepening_rates = (0.20, 0.45, 0.70, 0.85) silva_deepening_source = 0.35 silva_deepening_tolerance = 1e-8 silva_deepening_histories = {} silva_deepening_rows = [] for silva_deepening_rho in silva_deepening_rates: silva_deepening_state = silva_deepening_torch.tensor(0.0) silva_deepening_exact = silva_deepening_source / (1.0 - silva_deepening_rho) silva_deepening_history = [] for silva_deepening_iteration in range(1, 241): silva_deepening_next = ( silva_deepening_rho * silva_deepening_state + silva_deepening_source ) silva_deepening_residual = abs( float(silva_deepening_next - silva_deepening_state) ) silva_deepening_history.append(silva_deepening_residual) silva_deepening_state = silva_deepening_next if silva_deepening_residual < silva_deepening_tolerance: break silva_deepening_u = silva_deepening_torch.tensor( silva_deepening_source, requires_grad=True ) silva_deepening_solution = silva_deepening_u / (1.0 - silva_deepening_rho) silva_deepening_solution.backward() silva_deepening_expected_sensitivity = 1.0 / (1.0 - silva_deepening_rho) silva_deepening_gradient_error = abs( float(silva_deepening_u.grad) - silva_deepening_expected_sensitivity ) silva_deepening_histories[silva_deepening_rho] = silva_deepening_history silva_deepening_rows.append( ( silva_deepening_rho, silva_deepening_iteration, silva_deepening_history[-1], abs(float(silva_deepening_state) - silva_deepening_exact), float(silva_deepening_u.grad), silva_deepening_gradient_error, ) ) print('transition feedback factor') print("rho | iterations | final residual | exact-state error | sensitivity | gradient error") for silva_deepening_row in silva_deepening_rows: print( f"{silva_deepening_row[0]:.2f} | {silva_deepening_row[1]:3d} | " f"{silva_deepening_row[2]:.3e} | {silva_deepening_row[3]:.3e} | " f"{silva_deepening_row[4]:.4f} | {silva_deepening_row[5]:.3e}" ) assert all(row[2] < silva_deepening_tolerance for row in silva_deepening_rows) assert all(row[3] < 1e-6 for row in silva_deepening_rows) assert all(row[5] < 1e-6 for row in silva_deepening_rows)

transition feedback factor
rho | iterations | final residual | exact-state error | sensitivity | gradient error
0.20 |  12 | 0.000e+00 | 5.551e-17 | 1.2500 | 0.000e+00
0.45 |  23 | 0.000e+00 | 1.084e-08 | 1.8182 | 6.502e-08
0.70 |  45 | 0.000e+00 | 1.589e-07 | 3.3333 | 7.947e-08
0.85 |  93 | 0.000e+00 | 5.563e-07 | 6.6667 | 1.589e-07

In [10]:

silva-extension-curriculum

import matplotlib.pyplot as silva_deepening_plt

silva_deepening_plt.rcParams.update({"figure.dpi": 300, "savefig.dpi": 300})
silva_deepening_figure, silva_deepening_axes = silva_deepening_plt.subplots(
    1, 2, figsize=(8.6, 3.2)
)
for silva_deepening_rho, silva_deepening_history in silva_deepening_histories.items():
    silva_deepening_axes[0].semilogy(
        range(1, len(silva_deepening_history) + 1),
        silva_deepening_history,
        marker="o",
        markersize=2,
        linewidth=1.2,
        label=f"rho={silva_deepening_rho:.2f}",
    )
silva_deepening_axes[0].axhline(
    silva_deepening_tolerance, color="black", linestyle="--", linewidth=0.9
)
silva_deepening_axes[0].set_xlabel("iteration")
silva_deepening_axes[0].set_ylabel("absolute residual")
silva_deepening_axes[0].set_title("Residual trajectories")
silva_deepening_axes[0].legend(fontsize=7)

silva_deepening_axes[1].plot(
    [row[0] for row in silva_deepening_rows],
    [row[1] for row in silva_deepening_rows],
    marker="o",
    label="iterations",
)
silva_deepening_sensitivity_axis = silva_deepening_axes[1].twinx()
silva_deepening_sensitivity_axis.plot(
    [row[0] for row in silva_deepening_rows],
    [row[4] for row in silva_deepening_rows],
    color="tab:red",
    marker="s",
    label="sensitivity",
)
silva_deepening_axes[1].set_xlabel('transition feedback factor')
silva_deepening_axes[1].set_ylabel("iterations")
silva_deepening_sensitivity_axis.set_ylabel("implicit sensitivity", color="tab:red")
silva_deepening_axes[1].set_title("Cost and sensitivity")
silva_deepening_figure.tight_layout()
silva_deepening_plt.show()

import matplotlib.pyplot as silva_deepening_plt silva_deepening_plt.rcParams.update({"figure.dpi": 300, "savefig.dpi": 300}) silva_deepening_figure, silva_deepening_axes = silva_deepening_plt.subplots( 1, 2, figsize=(8.6, 3.2) ) for silva_deepening_rho, silva_deepening_history in silva_deepening_histories.items(): silva_deepening_axes[0].semilogy( range(1, len(silva_deepening_history) + 1), silva_deepening_history, marker="o", markersize=2, linewidth=1.2, label=f"rho={silva_deepening_rho:.2f}", ) silva_deepening_axes[0].axhline( silva_deepening_tolerance, color="black", linestyle="--", linewidth=0.9 ) silva_deepening_axes[0].set_xlabel("iteration") silva_deepening_axes[0].set_ylabel("absolute residual") silva_deepening_axes[0].set_title("Residual trajectories") silva_deepening_axes[0].legend(fontsize=7) silva_deepening_axes[1].plot( [row[0] for row in silva_deepening_rows], [row[1] for row in silva_deepening_rows], marker="o", label="iterations", ) silva_deepening_sensitivity_axis = silva_deepening_axes[1].twinx() silva_deepening_sensitivity_axis.plot( [row[0] for row in silva_deepening_rows], [row[4] for row in silva_deepening_rows], color="tab:red", marker="s", label="sensitivity", ) silva_deepening_axes[1].set_xlabel('transition feedback factor') silva_deepening_axes[1].set_ylabel("iterations") silva_deepening_sensitivity_axis.set_ylabel("implicit sensitivity", color="tab:red") silva_deepening_axes[1].set_title("Cost and sensitivity") silva_deepening_figure.tight_layout() silva_deepening_plt.show()

Reading and Extending the Result¶

The measured residual curves become flatter as the transition feedback factor increases. The iteration count and the exact sensitivity rise together, but they answer different questions: iterations measure numerical work, while sensitivity describes how strongly the equilibrium reacts to the source. The gradient-error column verifies the differentiation path against the analytic derivative.

Apply the same separation to this notebook's full model:

Report	Notebook-specific interpretation
Task evidence	fixed-point residual and task error against a deterministic target
Forward residual	Re-evaluate the complete transition at the returned state
Empirical rate	Compare consecutive residuals only after the transient regime
Backward residual	Record the linear-adjoint stopping value independently
Sensitivity	Perturb one declared source field while preserving all other inputs
Structural checks	shape, device, dtype, finiteness, and differentiability
Scale sweep	Change one of state width, batch size, and data volume at a time

A richer experiment should now repeat the sweep with at least two forward solvers, two tolerances, and multiple seeds. Keep model parameters and data identical when comparing solvers. Then change one architecture or data-scale axis, retain the compact analytic study as a regression test, and report task quality, residuals, iterations, runtime, memory, gradient norms, and failed convergence cases together.

Where to Go Next¶

Question	Page
How are source methods represented without losing SILVA structure?	Reproducing SILVA and Source Methods
Which source-aware records and builders are public?	Reproducibility API
How should the resulting experiment be scaled?	Full-Scale SILVA