README.md

---
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-39%20passing-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, **not** all 237,490 leaves —
the source proof records per-region certification and aggregate counts. That is
a real limitation of what is published and it is stated rather than glossed: you
can re-derive any region yourself, but you are not being handed every leaf.

### `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.

That 0.081% comes from the boundary-element solver used to develop the closure,
which is **not part of this release** — so unlike every other figure on this
page, you cannot re-derive it from what is published here. It is quoted because
it bounds how much trust the closure has earned, and a reader is entitled to
know which numbers are checkable and which are taken on our word.

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** — they are not published.
The source proof records per-region certification plus aggregate counts, so the
237,490 leaves are attested but not enumerated here. That is a real limit of
this release and is stated rather than glossed.

## 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.