screening-ceiling

📖 Documentation site — the portfolio narrative, the concepts, a full walkthrough, and what all of this proves (and does not).

A machine-certified impossibility result about coupling extraction, plus the concrete layouts where a plausible extractor predicts impossible physics.

Most ML-for-physics datasets are samples: here are some inputs, here are the answers, fit something. This one is different in a way worth being precise about. It carries a universal claim — a statement about every layout in a continuous four-parameter family, established by interval branch-and-bound rather than by sampling — together with existential counterexamples that refute a specific competing method.

Why this exists

When conductors are packed together, every other conductor screens the field between any two. So a pair's mutual capacitance inside an array is at most its isolated-pair value:

k = |C_full| / |C_iso|  ≤  1

Pairwise-superposition extraction — used throughout fast parasitic extraction — assumes k ≡ 1. The certified claim here is that on a particular manufacturable family it is provably never right, and quantifies by how much:

For every layout in the family box, k ≤ 0.909090909091. A pairwise extractor therefore over-predicts the worst coupling by at least 10.000002% on every member of the family — not on average, not usually, always.

And the other direction: a second-order Born correction, the obvious cheap fix when a full solve is too slow, does not merely stay inaccurate — on 27 layouts here it predicts k > 1, which is anti-screening, a physical impossibility.

30-second quickstart

No install, no dependencies, nothing from the repository that produced it:

python3 verify.py

screening-ceiling  independent re-derivation (stdlib only)

  claim              k <= 0.909090909091 for every layout in the family
  forced error       pairwise over-predicts by >= 10.0000%

  regions            256 x 25 samples = 6400 layouts
  worst sampled k    0.903974725909   (bound 0.909090909091)
  margin to bound    0.005116183182
  violations         0
  worst at           region 3.0.3.3  d0_um=55.7830 jog_mult=0.3838 pt_mult=1.0009 sep_mult=4.4492

  counterexamples    27/27 re-derived and confirmed above the ceiling

  consistent: no sampled layout exceeds the bound, and every counterexample re-derives

  scope: A complete interval theorem about the frozen MONOPOLE-CLOSURE model only. The closure-vs-BEM/PDE model gap remains additive and unresolved. This witness does not establish Maxwell, BEM, driven-S, fabrication, or measured-silicon truth.

verify.py rebuilds the electrostatics from the published geometry using the standard library alone — its own Gauss-Jordan inverse, its own potential matrix. It does not import this dataset's producer, numpy, or anything else.

Sampling cannot prove the universal claim. That is what the interval branch-and-bound in the source proof is for. What sampling can do is refute it, and that is the useful thing to hand a skeptical reader: a cheap, dependency-free way to try to catch us being wrong.

Loading

from loader import load_regions, load_counterexamples, load_theorem

theorem = load_theorem()
print(theorem["statement"])
print(theorem["honest_scope"])          # read this one

for c in load_counterexamples():
    print(c["case_id"], c["k_predicted"], c["n_pairs_violating"], "/", c["n_pairs_total"])

Optional conveniences: to_pandas("regions") and to_hf_dataset().

Contents

data/certified_regions.jsonl — 256 rows, the universal claim

The branch-and-bound partition. Each row is one region of the family box that the prover certified, having subdivided it into leaves until the interval enclosure of k fell below the bound everywhere inside.

Field	Type	Meaning
region_id	string	position in the 4×4×4×4 root partition, e.g. 3.0.3.3
bounds	object	{d0_um, pt_mult, sep_mult, jog_mult} → {lo, hi}
status	string	CERTIFIED for every row in this release
certified_leaves	int	leaves the region was subdivided into
processed_leaves	int	leaves examined, including interior splits
sup_certified_k_hi	float	largest k the enclosure admits anywhere in the region
volume_fraction_of_region	float	fraction certified (1.0 throughout)
unresolved_leaves	int	leaves left undecided (0 throughout)

Totals: 237,490 certified leaves, 474,724 processed, 0 failure regions, 0 unresolved, certified volume fraction 1.0.

The published rows are the 256-region partition rather than all 237,490 leaves: every region carries its own certification and can be re-derived independently, while the leaf-level subdivision beneath it stays in the source prover.

data/counterexamples.jsonl — 27 rows, the existential refutation

Layouts where born_second_order predicts k > 1.

Field	Type	Meaning
case_id	string	e.g. born2_n6_p100_s1
model	string	born_second_order
n_conductors	int	6, 8 or 12
nominal_pitch_um	float	60, 80 or 100
seed	int	generator seed
worst_pair	[int, int]	indices of the worst-violating pair
k_predicted	float	predicted screening factor (> 1 for every row)
n_pairs_violating	int	pairs above the ceiling in this layout
n_pairs_total	int	ordered pairs in this layout
xy_um	[[float, float]]	conductor centres, micrometres
radius_um	[float]	conductor radii, micrometres
eps_r	float	relative permittivity (4.6)

2,060 violating pairs across the 27 layouts, worst k = 3.5141. Full coordinates are included deliberately: a counterexample you cannot rebuild is an anecdote, not evidence.

data/theorem.json — the claim, its scope, its provenance

The statement, the family box, the certified totals, the exact geometry definition, and the SHA-256 of the source proof witness.

Geometry

Four parallel circular conductors forming two tight pairs:

pitch      = 1.6 · d0 · pt_mult
separation = pitch · sep_mult
jog        = jog_mult · separation

centres: (0,0)  (pitch,0)  (separation,jog)  (separation+pitch,jog)
every conductor has diameter d0

Family box: d0 ∈ [25,60] µm, pt_mult ∈ [1.0,1.2], sep_mult ∈ [2.5,4.5], jog_mult ∈ [−0.4,0.4]. Self-term radius scale 1.0.

loader.family_layout(...) builds it for you.

Scope, honestly

This is a theorem about the monopole-closure model, not about Maxwell. The closure is a zero-parameter analytic multiple-scattering model that matches a boundary-element reference to 0.081% in the exact two-cylinder limit, but the closure-versus-solver gap is an additive, disclosed, unresolved term. It is never absorbed into the bound.

Two figures on this page are cited rather than checkable, and both are marked where they appear. This is the first: the 0.081% comes from the boundary-element solver used to develop the closure, which is not part of this release. It is quoted because it bounds how much trust the closure has earned. Everything else on this page, apart from the 0.9053 noted below, re-derives by running verify.py.

The scope line travels with the data, in theorem.json:

A complete interval theorem about the frozen MONOPOLE-CLOSURE model only. The closure-vs-BEM/PDE model gap remains additive and unresolved. This witness does not establish Maxwell, BEM, driven-S, fabrication, or measured-silicon truth.

Three further limits worth stating plainly:

• One family, not all layouts. Four conductors in a specific arrangement. Nothing here says anything about a different topology.
• The bound is not tight. The certified supremum is 0.90909089; the worst layout found by adversarial search is ≈0.9053. The gap is the price of a first-order interval relaxation, not a claim about physics. That 0.9053 is the second figure on this page you cannot re-derive from the release — it came from a differential-evolution search in the source prover. What you can check here is weaker but points the same way: verify.py reports a worst sampled k of 0.903974725909 at its defaults, and sampling harder climbs toward that 0.9053 without ever reaching the bound — at --seed 7, 25 / 100 / 400 samples per region give 0.902144353337, 0.903775408593, 0.904308125283, with zero violations at each.
• No measured data. Every number is computational.

Reproduction

python3 verify.py --samples 100 --seed 7   # sample harder, different seed
python3 verify.py --self-test              # prove the checker still discriminates
python3 export.py --check                  # confirm data matches a fresh export

The self-test is the part that makes a clean report worth anything. It fabricates an impossible bound, tampers with a published value, and requires the checker to reject both — then confirms an isolated pair reproduces k = 1.000000000000 exactly, since a lone pair has nothing to screen it.

Troubleshooting

verify.py reports violations — that is the interesting outcome, and we want to hear about it. Sampling cannot prove the bound but it can refute it, so a genuine violation means the theorem is wrong. Before reporting, re-run with --self-test to confirm the checker still discriminates: a checker that has stopped working can produce either verdict.

ModuleNotFoundError: numpy from verify.py — it should never import numpy. If it does, the file has been edited; the shipped version runs under env -i /usr/bin/python3 with nothing installed, and a test asserts it imports no third-party module.

loader.to_pandas or to_hf_dataset raises ImportError — those two are conveniences and do need pandas / datasets. Everything else, including verify.py, is standard library only.

The Hub viewer shows two configs and you wanted one table — regions and counterexamples have different schemas and are deliberately separate. Pick the config in the viewer's dropdown, or use load_regions() / load_counterexamples().

export.py --check says the data does not match — it re-derives the files from the committed proof witness and compares. A mismatch means either the data or the witness was edited. Counterexample regeneration also needs maxwell-lint installed, since they are produced by running its reference models.

You want every certified leaf, not the 256 regions — the release publishes the 256-region partition with per-region certification and the aggregate leaf counts, so the 237,490 leaves are attested but not enumerated file-by-file. Any region can be re-derived independently; ask if you need the full subdivision.

Provenance

Exported by export.py from a committed proof witness produced by an outward-rounded interval branch-and-bound prover (256 parallel roots, 243.5 s wall clock, centered/mean-value enclosure forms). The witness digest is recorded in theorem.json; export.py --check re-derives the files and compares.

Counterexamples are generated by running the open-source maxwell-lint reference models, so they are reproducible from published code alone.

Citation

@misc{screening_ceiling_2026,
  title  = {Screening Ceiling: Certified Regions and Counterexamples for
            Many-Body Coupling Extraction},
  author = {ChipletOS / Genesis contributors},
  year   = {2026},
  note   = {CC-BY-4.0}
}

The rest of the toolkit

Eight artifacts that answer one question in different places: is this model physically possible? Each is a grader — it can tell you a model is wrong; none can tell you one is right.

sparam-lint	Is an S-parameter model physically possible? Five laws + a negative control.
maxwell-lint	Does a coupling extractor predict impossible physics? Screening ceiling k ≤ 1.
abstain-bench	Does a model know when to shut up? Abstention recall, never pooled with accuracy.
sparam-conformance	11 labelled networks with verified ground truth. Grades the graders.
screening-ceiling ← you are here	A certified impossibility result + 27 counterexamples. Zero-dependency verifier.
physics-lint-action	The same checks, in your CI.
physics-lint-mcp	A physics oracle your AI agent can call.
Try it in your browser	All three checks, no install, runs client-side.

These tools grade a model. Producing one that is passive by construction — so it cannot fail these laws whatever its parameters — and accurate at speed in the many-body regime, with calibrated abstention and a fail-closed signoff certificate, is the commercial core: ChipletOS.

Licence

CC-BY-4.0. Synthetic and computational throughout; no proprietary or measured data. Attribution: ChipletOS / Genesis contributors.

Related

• maxwell-lint — run the ceiling test on your extractor
• sparam-conformance — the S-parameter analogue
• ChipletOS — the closed core: a learned many-body coupling operator that stays inside this ceiling and is accurate at speed, with calibrated abstention and a fail-closed signoff certificate

Contributing

One non-negotiable rule here: the verifier must import nothing from this project, so a skeptic can read it in one sitting and run it with nothing installed. CONTRIBUTING.md has the detail. Each sibling repository states its own, and they differ — that is deliberate, and it is why each is trustworthy on its own terms.