Skip to content

Packaging

A fast predictor that answers only when a bound admits it

40fresh layouts with zero violations of the predictor’s own error bound; its raw fast answers were admitted on none of them

The result

A fast stand-in for our coupling solver that answers only when a bound on its own error admits the answer, and otherwise refines or escalates.

Limit Zero bound violations on the fresh layouts tested, against our own solver; not yet fast: its raw answers were admitted on no layout.

A fast stand-in for a slow solver is useful only if you know when to trust it. This one carries a bound on its own error for each query. When the bound admits the answer, it answers; when it does not, the system refines the answer with the real solver or escalates. In our test its error bound had zero violations on the fresh layouts, against our own solver’s residual, and its raw fast answers were admitted for none of them.

A dotted magenta underline marks a number read straight from a published file when this page was built.

On this page
  1. What it shows
  2. Why it matters
  3. Who should care
  4. The limits, in the record’s words

What it shows

The record states the result this way:

The published record says, word for word (an excerpt)

A fast predictor may answer only when a sound bound admits it; otherwise the system refines or escalates, so there is never a silently uncertified fast answer.

In plain words: each fast answer comes with a bound on its error, computed from the solver’s own residual. If the bound is too wide, the answer is not given as fast; it is refined with the real solver or passed on.

On 40 fresh layouts the bound was never violated. That is the useful half. The honest half is that the raw fast answers were certified on 0% of layouts, so in this test every answer went through refinement, and starting from the fast answer saved only 0.5% of the solver’s iterations.

Why it matters

A design flow that uses a fast stand-in needs to know which answers to trust without re-running the slow solver every time. Zero violations on the fresh layouts tested, against our own solver’s residual, is the property that would make a stand-in safe to put in a flow. How often it lets an answer through is what decides whether it saves time, and here it does not yet.

What is ours, and what is not

Predictors that abstain, and fast solves that carry a certified error bound, are known (see the prior art below). What is ours is this bound for our coupling stand-in and the test that it holds on fresh layouts.

Who should care

  • Teams putting fast stand-ins into signoff flows, where a silent wrong answer costs more than a slow one.
  • Reviewers of our results. The negative half is stated, not hidden.

The limits, in the record’s words

The published record says, word for word (an excerpt)

Blunt honest negative: raw certified coverage at τ_rel = 1e-3 is 0% — the model residual of order 1–10 far exceeds the ~1.2e-2 compression ceiling — and warm-start iteration reduction is 0.5%, NEGATIVE at N=8.

The published record says, word for word (an excerpt)

Zero bound violations on 40 fresh layouts; refined C versus frozen scipy ≤1.4e-11; fault-A inflates the bound ~1.2e11×.

In plain words: zero violations of its error bound on 40 fresh layouts against our own solver’s residual; not yet fast. It is a soundness contract over our own solver’s residual, not accuracy against silicon.

Open source for this step

Tools and datasets we publish for the package step of building a multi-chip package. They are the checkers around this work, not a copy of the result itself.

  • physics-lint: One command that checks a folder of physics models against a fixed set of named physical rules, with findings straight into CI.
  • maxwell-lint: Flags a coupling extractor whose answers no passive set of conductors could produce.
  • sparam-lint: Is your signal-response model physically possible? Five physical laws checked from the command line.
  • interval-core: The interval arithmetic core behind our proofs over whole families of layouts.
  • touchstone-tools: Read, write and convert Touchstone files, the standard text files that record how signals pass through a package's connections, and refuse to write one that cannot be read back.
  • physics-lint-mcp: The physics checks, callable by an AI agent.
  • physics-lint-action: A GitHub Action that fails the build when a model breaks one of a fixed set of named physical rules.
  • Signal-response validity corpus: A labelled corpus of physically invalid signal-response networks, and a scorer that grades any checker against it.
  • screening-ceiling: The screening-ceiling family as an open dataset.

Ask about a result, or check one yourself

Founder: Nick Harris. AI agents do our research and engineering. Each result page says how it was checked: against an outside solver, by an interval-arithmetic proof, by a Lean-checked step, or against our own simulator; these checks ran on our own machines. Who we are · How the work is checked

Every result on this site links to the file it comes from. Acquisition, licensing and partnership enquiries go to one address, nick@chipletos.com, and a person reads it.

Write to us Read the results

Each number links to the file it comes from; every file is listed, with its checksum, on Published files.

When a number is left off

We leave a number off a page, or mark it, when

  • its file has not loaded yet
  • nobody has looked into it yet
  • a search for it found nothing
  • its file holds no value for it
  • its file is missing or altered
  • files disagree on what it describes
  • its sample is too small for the claim
  • two files give different values
  • its file cannot be published
  • it was measured over ninety days ago
  • the question does not apply here
  • the program behind it stopped with an error