Coverage Registry

The coverage registry connects each public SILVA implementation family to its derivation, executable notebook, validation tests, and runnable examples. It lets readers move from an imported object to the exact learning and verification material that supports it.

from silva_networks import implementation_cases

for case in implementation_cases():
    print(case.key, case.tutorial, case.notebooks, case.examples)

What the Registry Checks

Field	Meaning
`key`	stable implementation identifier
`public_objects`	importable package objects
`tutorial`	documentation page explaining the equations and usage
`notebooks`	executable notebooks that exercise the implementation
`smoke_tests`	validation files that check shape, residual, gradient, or constraint behavior
`examples`	runnable scripts when a compact public example exists
`scope`	concise claim about what the implementation covers

The registry does not claim that one short run reproduces a paper result. Its scope is traceability: every listed public family has a reader-facing derivation, executable use, and focused behavioral checks.

Finding Material for One Object

from silva_networks import implementation_cases

target = "SILVACortexLayer"
case = next(c for c in implementation_cases() if target in c.public_objects)

print("derivation:", case.tutorial)
print("notebooks:", *case.notebooks)
print("examples:", *case.examples)
print("validated by:", *case.smoke_tests)

The registry itself is validated during release checks: referenced paths must exist and every public_objects entry must be importable from the package root. The API Overview provides a role-based route through the same surface.

API Docs

Operational Contract

This API surface connects coverage, reproduction, data, and scale configuration to the same SILVA experiment contract used by the learning pages and notebooks. Its central relation is

\[ F_\theta(z;x)=0,\qquad \widehat F_{\theta,s}(z;x)=0\ \text{uses the same mathematical contract at scale tier }s \]

Part	What must remain inspectable
State	the selected family, constructor contract, runtime tier, and data-loader configuration.
Condition	changing a runtime tier may change numerical budgets and resource use but must not silently change the family equation.
Diagnostic	coverage record, verification level, solver settings, effective batch size, and source-scale metrics.
Replacement point	compact defaults with family-specific modules, official data adapters, and an archived experiment configuration.
Scale axes	solver iterations, tolerance, model width, batch size, precision, workers, process count, and checkpoint interval.

The relevant method lineage is recorded in the SILVA construction [1] and the selected family's primary references. Those references define the source mechanisms; this API exposes them through SILVA objects so a reader can inspect, replace, solve, differentiate, and scale the construction.

Complete Compact Study

Run the complete repository program below from the project root. The page uses the same file that is exercised by the test suite, so the displayed call is not an isolated fragment.

"""Inspect one family from public API coverage through executable scale defaults."""

from __future__ import annotations

from silva_networks import (
    SILVADataLoaderConfig,
    implementation_cases,
    runtime_for_tier,
    silva_family_guide,
    silva_reproduction_spec,
    silva_scaling_defaults,
)

family = "fno_deq"
case = next(item for item in implementation_cases() if item.key == "recent_equilibrium_families")
guide = silva_family_guide(family)
reproduction = silva_reproduction_spec(family)
defaults = silva_scaling_defaults(family, tier="smoke")
runtime = runtime_for_tier("smoke")
loader = SILVADataLoaderConfig(batch_size=4, workers=0)

print("family", family)
print("public objects", len(case.public_objects))
print("verification", reproduction.verification_level)
print("benchmark tasks", len(guide.benchmark_tasks))
print("solver", defaults["config"].solver)
print("max iterations", defaults["config"].max_iter)
print("runtime", runtime.device, runtime.mixed_precision)
print("loader", loader.batch_size, loader.workers)

python examples/api_scale_workflow.py

Measured Compact Output

family fno_deq
public objects 12
verification compact-verified
benchmark tasks 2
solver anderson
max iterations 12
runtime auto none
loader 4 0

Interpret the Output

The family resolves through four independent registries: public coverage, source relation, scale guidance, and runtime/data configuration. The compact-verified label describes repository evidence; it does not convert the two listed benchmark tasks into claimed benchmark results.

For a controlled experiment, retain the compact call as a regression case and change one scale axis at a time. Record the resolved constructor, data source and split, preprocessing, seed, forward and backward solver settings, task metric, normalized residual, iteration count, runtime, peak memory, and any failed convergence case. A larger run becomes evidence only when its own resolved configuration and outputs are archived; the compact output above is evidence for the executable mechanism and its stated invariants.

Implementation coverage registry for tutorials, notebooks, and validation tests.

The registry is documentation-facing: it records which public implementation families are represented by a tutorial, an executable notebook, and at least one validation test or example. It keeps release checks explicit as the package grows.

SILVAImplementationCase `dataclass`

Public implementation family and its learning/test coverage.

Parameters:

Name	Type	Description	Default
`key`	`str`	Stable package-facing case identifier.	required
`public_objects`	`tuple[str, ...]`	Importable classes or functions that define the public API.	required
`tutorial`	`str`	Documentation page explaining the implementation.	required
`notebooks`	`tuple[str, ...]`	Notebook paths that exercise the implementation.	required
`smoke_tests`	`tuple[str, ...]`	Validation-test paths that check the implementation.	required
`examples`	`tuple[str, ...]`	Optional runnable example scripts.	`()`
`scope`	`str`	Short statement of what the implementation claims.	`''`

Source code in src/silva_networks/coverage.py

@dataclass(frozen=True)
class SILVAImplementationCase:
    """Public implementation family and its learning/test coverage.

    Args:
        key: Stable package-facing case identifier.
        public_objects: Importable classes or functions that define the public API.
        tutorial: Documentation page explaining the implementation.
        notebooks: Notebook paths that exercise the implementation.
        smoke_tests: Validation-test paths that check the implementation.
        examples: Optional runnable example scripts.
        scope: Short statement of what the implementation claims.
    """

    key: str
    public_objects: tuple[str, ...]
    tutorial: str
    notebooks: tuple[str, ...]
    smoke_tests: tuple[str, ...]
    examples: tuple[str, ...] = ()
    scope: str = ""

implementation_cases

implementation_cases()

Return the public implementation coverage registry.