Datasets:

nickh007
/

screening-ceiling

---
license: cc-by-4.0
task_categories:
  - tabular-classification
  - tabular-regression
tags:
  - physics
  - electromagnetics
  - verification
  - interval-arithmetic
  - formal-methods
  - counterexamples
  - eda
  - parasitic-extraction
pretty_name: Screening Ceiling — Certified Regions and Counterexamples
size_categories:
  - n<1K
configs:
  - config_name: regions
    data_files: data/certified_regions.jsonl
  - config_name: counterexamples
    data_files: data/counterexamples.jsonl
---
# screening-ceiling

![Licence](https://img.shields.io/badge/data-CC--BY--4.0-green) ![Regions](https://img.shields.io/badge/certified%20regions-256-blue) ![Leaves](https://img.shields.io/badge/certified%20leaves-237%2C490-blue) ![Counterexamples](https://img.shields.io/badge/counterexamples-27-orange) ![Verifier](https://img.shields.io/badge/verifier-zero%20dependency-brightgreen) ![Tests](https://img.shields.io/badge/tests-41%20collected-brightgreen)

📖 **[Documentation site](https://nickharris808.github.io/physics-lint/)** — 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:

```bash
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

```python
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

```bash
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`](https://github.com/nickharris808/maxwell-lint) reference models, so they are reproducible
from published code alone.
## Citation
```bibtex
@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`](https://github.com/nickharris808/sparam-lint) | Is an S-parameter model physically possible? Five laws + a negative control. |
| [`maxwell-lint`](https://github.com/nickharris808/maxwell-lint) | Does a coupling extractor predict impossible physics? Screening ceiling k ≤ 1. |
| [`abstain-bench`](https://github.com/nickharris808/abstain-bench) | Does a model know when to shut up? Abstention recall, never pooled with accuracy. |
| [`sparam-conformance`](https://huggingface.co/datasets/nickh007/sparam-conformance) | 11 labelled networks with verified ground truth. Grades the graders. |
| [`screening-ceiling`](https://huggingface.co/datasets/nickh007/screening-ceiling) ← you are here | A certified impossibility result + 27 counterexamples. Zero-dependency verifier. |
| [`physics-lint-action`](https://github.com/nickharris808/physics-lint-action) | The same checks, in your CI. |
| [`physics-lint-mcp`](https://github.com/nickharris808/physics-lint-mcp) | A physics oracle your AI agent can call. |
| [**Try it in your browser**](https://huggingface.co/spaces/nickh007/physics-lint) | 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](https://chipletos.com)**.
## Licence
**CC-BY-4.0.** Synthetic and computational throughout; no proprietary or
measured data. Attribution: ChipletOS / Genesis contributors.
## Related
- [`maxwell-lint`](https://github.com/nickharris808/maxwell-lint) — run the ceiling test on *your* extractor
- [`sparam-conformance`](https://huggingface.co/datasets/nickh007/sparam-conformance) — the S-parameter analogue
- [ChipletOS](https://chipletos.com) — 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`](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.

	---
	license: cc-by-4.0
	task_categories:
	- tabular-classification
	- tabular-regression
	tags:
	- physics
	- electromagnetics
	- verification
	- interval-arithmetic
	- formal-methods
	- counterexamples
	- eda
	- parasitic-extraction
	pretty_name: Screening Ceiling — Certified Regions and Counterexamples
	size_categories:
	- n<1K
	configs:
	- config_name: regions
	data_files: data/certified_regions.jsonl
	- config_name: counterexamples
	data_files: data/counterexamples.jsonl
	---

	# screening-ceiling

	![Licence](https://img.shields.io/badge/data-CC--BY--4.0-green) ![Regions](https://img.shields.io/badge/certified%20regions-256-blue) ![Leaves](https://img.shields.io/badge/certified%20leaves-237%2C490-blue) ![Counterexamples](https://img.shields.io/badge/counterexamples-27-orange) ![Verifier](https://img.shields.io/badge/verifier-zero%20dependency-brightgreen) ![Tests](https://img.shields.io/badge/tests-41%20collected-brightgreen)

	📖 [Documentation site](https://nickharris808.github.io/physics-lint/) — 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:

	```bash
	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

	```python
	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

	```bash
	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`](https://github.com/nickharris808/maxwell-lint) reference models, so they are reproducible
	from published code alone.

	## Citation

	```bibtex
	@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`](https://github.com/nickharris808/sparam-lint) \| Is an S-parameter model physically possible? Five laws + a negative control. \|
	\| [`maxwell-lint`](https://github.com/nickharris808/maxwell-lint) \| Does a coupling extractor predict impossible physics? Screening ceiling k ≤ 1. \|
	\| [`abstain-bench`](https://github.com/nickharris808/abstain-bench) \| Does a model know when to shut up? Abstention recall, never pooled with accuracy. \|
	\| [`sparam-conformance`](https://huggingface.co/datasets/nickh007/sparam-conformance) \| 11 labelled networks with verified ground truth. Grades the graders. \|
	\| [`screening-ceiling`](https://huggingface.co/datasets/nickh007/screening-ceiling) ← you are here \| A certified impossibility result + 27 counterexamples. Zero-dependency verifier. \|
	\| [`physics-lint-action`](https://github.com/nickharris808/physics-lint-action) \| The same checks, in your CI. \|
	\| [`physics-lint-mcp`](https://github.com/nickharris808/physics-lint-mcp) \| A physics oracle your AI agent can call. \|
	\| [Try it in your browser](https://huggingface.co/spaces/nickh007/physics-lint) \| 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](https://chipletos.com).

	## Licence

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

	## Related

	- [`maxwell-lint`](https://github.com/nickharris808/maxwell-lint) — run the ceiling test on your extractor
	- [`sparam-conformance`](https://huggingface.co/datasets/nickh007/sparam-conformance) — the S-parameter analogue
	- [ChipletOS](https://chipletos.com) — 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`](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.