Download notebook

Research Citation Audit Notebook¶

This notebook turns a SILVA package configuration into a citation checklist. It is intentionally lightweight: the full method matrix lives in the documentation page research-citation-audit.md, while this notebook gives a reproducible reporting pattern for papers, READMEs, experiment logs, and model cards.

Always cite the SILVA paper/package when using package-specific SILVA presets, structured interaction fields, notebooks, or code. Add method citations only for the mechanisms actually used.

Numbered literature: [1], [2], [3], [4], [5], [6]. Each number opens the complete citation and its primary external source.

Citation Rules¶

Package choice	Citation family
equilibrium layer	SILVA, Deep Equilibrium Models, Deep Implicit Layers
Anderson solver	Anderson 1965, Walker-Ni 2011
Broyden solver	Broyden 1965
GMRES adjoint	Saad-Schultz 1986
graph attention	GAT, Attention Is All You Need
mean/set pooling	Deep Sets
top-k/channel attention	Attention Is All You Need, Set Transformer
dynamic kNN	Dynamic Graph CNN as related dynamic graph literature
molecular graph branch	MPNN, GAT, dataset source
Jacobian penalty	Hutchinson 1989, Jacobian-regularized DEQ
ODE bridge	Neural ODEs
optimization bridge	OptNet, differentiable convex optimization layers
multiscale bridge	MDEQ

In [1]:

CITATIONS = {
    "silva": [
        "Jose Luis Lima de Jesus Silva. SILVA Networks as Structured Implicit Layers and Vector Attractors via Dynamic Interaction Fields. 2026. arXiv:2607.28989.",
        "Dr. Jose Luis Silva. SILVA Networks package. https://github.com/jseluis/silva-networks. DOI: 10.5281/zenodo.21770098",
    ],
    "deq": ["Bai, Kolter, and Koltun. Deep Equilibrium Models. NeurIPS 2019. arXiv:1909.01377"],
    "implicit": ["Duvenaud, Kolter, and Johnson. Deep Implicit Layers tutorial. NeurIPS 2020."],
    "anderson": [
        "Anderson. Iterative Procedures for Nonlinear Integral Equations. JACM 1965.",
        "Walker and Ni. Anderson Acceleration for Fixed-Point Iterations. SIAM JNA 2011.",
    ],
    "broyden": ["Broyden. A Class of Methods for Solving Nonlinear Simultaneous Equations. Math. Comp. 1965."],
    "gmres": ["Saad and Schultz. GMRES. SIAM J. Sci. Stat. Comput. 1986."],
    "gat": ["Velickovic et al. Graph Attention Networks. ICLR 2018. arXiv:1710.10903"],
    "attention": ["Vaswani et al. Attention Is All You Need. 2017. arXiv:1706.03762"],
    "gcn_mpnn": [
        "Kipf and Welling. Semi-Supervised Classification with Graph Convolutional Networks. ICLR 2017.",
        "Gilmer et al. Neural Message Passing for Quantum Chemistry. 2017. arXiv:1704.01212",
    ],
    "sets": [
        "Zaheer et al. Deep Sets. NeurIPS 2017. arXiv:1703.06114",
        "Lee et al. Set Transformer. ICML 2019. arXiv:1810.00825",
    ],
    "dynamic_knn": ["Wang et al. Dynamic Graph CNN for Learning on Point Clouds. TOG 2019. arXiv:1801.07829"],
    "jacobian": [
        "Hutchinson. A Stochastic Estimator of the Trace. Communications in Statistics 1989.",
        "Bai, Koltun, and Kolter. Stabilizing Equilibrium Models by Jacobian Regularization. ICML 2021.",
    ],
    "ode": ["Chen et al. Neural Ordinary Differential Equations. NeurIPS 2018. arXiv:1806.07366"],
    "optimization": [
        "Amos and Kolter. OptNet: Differentiable Optimization as a Layer in Neural Networks. ICML 2017.",
        "Agrawal et al. Differentiable Convex Optimization Layers. NeurIPS 2019.",
    ],
    "mdeq": ["Bai, Koltun, and Kolter. Multiscale Deep Equilibrium Models. NeurIPS 2020."],
}

def citation_checklist(*, solver="picard", graph_mode=None, attention_mode=None, case="graph", jacobian_penalty=False, bridge=None):
    keys = ["silva", "deq"]
    if solver == "anderson":
        keys.append("anderson")
    if solver == "broyden":
        keys.append("broyden")
    if solver == "gmres":
        keys.append("gmres")
    if graph_mode in {"GAT", "gat", "graph_attention"}:
        keys.extend(["gat", "attention"])
    if graph_mode in {"graph", "mean"}:
        keys.append("gcn_mpnn")
    if attention_mode in {"simple", "mean", "static"}:
        keys.append("sets")
    if attention_mode in {"topk", "multi-head", "channel_attention", "simple"}:
        keys.append("attention")
    if graph_mode in {"knn", "GNN"}:
        keys.append("dynamic_knn")
    if case == "molecule":
        keys.extend(["gcn_mpnn", "gat"])
    if jacobian_penalty:
        keys.append("jacobian")
    if bridge == "ode":
        keys.append("ode")
    if bridge == "optimization":
        keys.append("optimization")
    if bridge == "mdeq":
        keys.append("mdeq")
    if bridge in {"fixed_point", "autodiff", "deq"}:
        keys.append("implicit")

    seen = []
    for key in keys:
        if key not in seen:
            seen.append(key)
    return {key: CITATIONS[key] for key in seen}

CITATIONS = { "silva": [ "Jose Luis Lima de Jesus Silva. SILVA Networks as Structured Implicit Layers and Vector Attractors via Dynamic Interaction Fields. 2026. arXiv:2607.28989.", "Dr. Jose Luis Silva. SILVA Networks package. https://github.com/jseluis/silva-networks. DOI: 10.5281/zenodo.21770098", ], "deq": ["Bai, Kolter, and Koltun. Deep Equilibrium Models. NeurIPS 2019. arXiv:1909.01377"], "implicit": ["Duvenaud, Kolter, and Johnson. Deep Implicit Layers tutorial. NeurIPS 2020."], "anderson": [ "Anderson. Iterative Procedures for Nonlinear Integral Equations. JACM 1965.", "Walker and Ni. Anderson Acceleration for Fixed-Point Iterations. SIAM JNA 2011.", ], "broyden": ["Broyden. A Class of Methods for Solving Nonlinear Simultaneous Equations. Math. Comp. 1965."], "gmres": ["Saad and Schultz. GMRES. SIAM J. Sci. Stat. Comput. 1986."], "gat": ["Velickovic et al. Graph Attention Networks. ICLR 2018. arXiv:1710.10903"], "attention": ["Vaswani et al. Attention Is All You Need. 2017. arXiv:1706.03762"], "gcn_mpnn": [ "Kipf and Welling. Semi-Supervised Classification with Graph Convolutional Networks. ICLR 2017.", "Gilmer et al. Neural Message Passing for Quantum Chemistry. 2017. arXiv:1704.01212", ], "sets": [ "Zaheer et al. Deep Sets. NeurIPS 2017. arXiv:1703.06114", "Lee et al. Set Transformer. ICML 2019. arXiv:1810.00825", ], "dynamic_knn": ["Wang et al. Dynamic Graph CNN for Learning on Point Clouds. TOG 2019. arXiv:1801.07829"], "jacobian": [ "Hutchinson. A Stochastic Estimator of the Trace. Communications in Statistics 1989.", "Bai, Koltun, and Kolter. Stabilizing Equilibrium Models by Jacobian Regularization. ICML 2021.", ], "ode": ["Chen et al. Neural Ordinary Differential Equations. NeurIPS 2018. arXiv:1806.07366"], "optimization": [ "Amos and Kolter. OptNet: Differentiable Optimization as a Layer in Neural Networks. ICML 2017.", "Agrawal et al. Differentiable Convex Optimization Layers. NeurIPS 2019.", ], "mdeq": ["Bai, Koltun, and Kolter. Multiscale Deep Equilibrium Models. NeurIPS 2020."], } def citation_checklist(*, solver="picard", graph_mode=None, attention_mode=None, case="graph", jacobian_penalty=False, bridge=None): keys = ["silva", "deq"] if solver == "anderson": keys.append("anderson") if solver == "broyden": keys.append("broyden") if solver == "gmres": keys.append("gmres") if graph_mode in {"GAT", "gat", "graph_attention"}: keys.extend(["gat", "attention"]) if graph_mode in {"graph", "mean"}: keys.append("gcn_mpnn") if attention_mode in {"simple", "mean", "static"}: keys.append("sets") if attention_mode in {"topk", "multi-head", "channel_attention", "simple"}: keys.append("attention") if graph_mode in {"knn", "GNN"}: keys.append("dynamic_knn") if case == "molecule": keys.extend(["gcn_mpnn", "gat"]) if jacobian_penalty: keys.append("jacobian") if bridge == "ode": keys.append("ode") if bridge == "optimization": keys.append("optimization") if bridge == "mdeq": keys.append("mdeq") if bridge in {"fixed_point", "autodiff", "deq"}: keys.append("implicit") seen = [] for key in keys: if key not in seen: seen.append(key) return {key: CITATIONS[key] for key in seen}

In [2]:

report = citation_checklist(
    solver="anderson",
    graph_mode="GAT",
    attention_mode="simple",
    case="graph",
    jacobian_penalty=True,
)

for family, citations in report.items():
    print(f"\n[{family}]")
    for citation in citations:
        print("-", citation)

report = citation_checklist( solver="anderson", graph_mode="GAT", attention_mode="simple", case="graph", jacobian_penalty=True, ) for family, citations in report.items(): print(f"\n[{family}]") for citation in citations: print("-", citation)

[silva]
- Jose Luis Lima de Jesus Silva. SILVA Networks as Structured Implicit Layers and Vector Attractors via Dynamic Interaction Fields. 2026. arXiv:2607.28989.
- Dr. Jose Luis Silva. SILVA Networks package. https://github.com/jseluis/silva-networks. DOI: 10.5281/zenodo.21770098

[deq]
- Bai, Kolter, and Koltun. Deep Equilibrium Models. NeurIPS 2019. arXiv:1909.01377

[anderson]
- Anderson. Iterative Procedures for Nonlinear Integral Equations. JACM 1965.
- Walker and Ni. Anderson Acceleration for Fixed-Point Iterations. SIAM JNA 2011.

[gat]
- Velickovic et al. Graph Attention Networks. ICLR 2018. arXiv:1710.10903

[attention]
- Vaswani et al. Attention Is All You Need. 2017. arXiv:1706.03762

[sets]
- Zaheer et al. Deep Sets. NeurIPS 2017. arXiv:1703.06114
- Lee et al. Set Transformer. ICML 2019. arXiv:1810.00825

[jacobian]
- Hutchinson. A Stochastic Estimator of the Trace. Communications in Statistics 1989.
- Bai, Koltun, and Kolter. Stabilizing Equilibrium Models by Jacobian Regularization. ICML 2021.

Reporting Template¶

A concise methods sentence can be assembled from the checklist:

The model used SILVA Networks as structured equilibrium layers, solved with Anderson acceleration, using a GAT-style local graph branch and a gated mean-field global branch. Residual and Jacobian diagnostics are reported.

Then cite SILVA/package, DEQ, Anderson/Walker-Ni, GAT, Attention, Deep Sets, Hutchinson, and Jacobian-regularized DEQ as selected by the checklist.

From 07 Research Citation Audit 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 [3]:

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 [4]:

silva-extension-curriculum

notebook_reproduction_record = {
    "notebook": '07_research_citation_audit.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": '07_research_citation_audit.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[4]:

{'notebook': '07_research_citation_audit.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 [5]:

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 [6]:

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
Which citation records and identifiers were checked?	Research Citation Audit
How should methods and metrics be reported?	Citation-Aware Reporting
Where is the maintained bibliography?	Paper and References