PYTHON · NUMPY

Don't trust a PINN — certify it

A PINN drives a residual toward zero — a soft penalty, not a guarantee. Compute an a-posteriori certificate: a rigorous bound on the true error from the trained net's own residual, needing no true solution. Then watch the same idea become an energy certificate on a controller and on a frozen policy. Soft → structural → proven.

01Challenge

You just trained a PINN and the loss went to nearly zero. Is the answer right? Not necessarily — the loss is a soft penalty over sampled points, and a net can look converged yet be badly wrong (spectral bias). The fix is a certificate you can compute WITHOUT the true solution. For u''+ω²u=0 the error e=uθ−u_true obeys the same equation forced by the net's own residual r(t), giving a rigorous bound ‖e‖ ≤ |e₀| + |e₁|/ω + (1/ω)∫|r|. Train the PINN in the Bench, then open the three live tools: watch the certificate tighten as training proceeds, watch spectral bias trip it red on a plausible-looking curve, and watch the very same energy become a certificate that guards a controller's every action.

Predict firstA physics-informed net's training loss went to nearly zero. Does that guarantee its solution is correct?

02Model

A physics-informed net only SOFTLY satisfies the physics: it penalizes the PDE residual at sampled points, so 'the loss went down' is not 'the solution is correct.' The honest move is a certificate, in three rungs. (1) A-POSTERIORI BOUND — for a well-posed linear problem the solution error obeys the PDE forced by the trained net's own residual, so you bound the true error from the residual alone, with no access to the true solution: for u''+ω²u=0, ‖e‖∞ ≤ |e₀| + |e₁|/ω + (1/ω)∫|r| (a Grönwall / Mishra–Molinaro estimate). Small bound ⇒ trust it; large bound ⇒ the net has silently failed. (2) STRUCTURAL — write the ansatz so the conditions hold EXACTLY (u = 1 + t²N(t) makes u(0)=1, u'(0)=0 by construction), tightening the bound for free. (3) PROVEN — go all the way to an energy that is simultaneously the control objective and a Lyapunov certificate; then the certificate can gate a frozen, black-box policy, substituting a certified action only when the policy's action would fail ΔV+α‖s‖²<0. That is the soft → structural → proven ladder: PINNs are the entry rung, the certificate is where the guarantee lives. Honest scope: a-posteriori certification is rigorous for well-posed elliptic/parabolic regimes and open for hyperbolic/chaotic — always name the domain of validity.

03Guided practice

Step A (train): press Train on the PINN Bench — the residual falls and the green curve locks onto cos(ωt). Step B (certify the solution): open 'the PINN certificate trust-meter' and step the training epochs — watch the certified error bound fall 2.1 → 0.02; switch to ω=8 to see spectral bias keep the residual (and the bound) large while the curve still looks plausible — a silent failure the certificate catches. Step C (structural rung): note how the hard-constraint ansatz makes the initial conditions exact and tightens the bound with no extra training. Step D (proven rung): open 'one energy, controller and certificate' and 'a physics gate on a frozen policy' — the same idea, now an energy that certifies a controller's every action, at microseconds per step.

04Feedback

PASS WHEN PASS when the PINN solves u''+ω²u=0 to low error. Now you know how to PROVE it: the a-posteriori bound turns the residual into a rigorous error estimate — trust the certificate, not the loss.

If your run fails, check:

Press Train ×3000, then open 'the PINN certificate trust-meter' under Go further.
Step the training epochs in the trust-meter and watch the certified bound fall; switch to ω=8 to see the certificate catch a silent failure.

05Retrieve & space

Why is a low PINN training loss not a guarantee that the solution is correct?
How can you bound a PINN's true error WITHOUT knowing the true solution — what quantities does the bound use?
What are the three rungs of the soft → structural → proven ladder, and which one carries a formal guarantee?

06Mastery & project

You turned a trained PINN into a trusted one: an a-posteriori certificate bounds the true error from the residual alone, a hard-constraint ansatz makes the conditions exact, and — the frontier — one energy becomes both a controller and its own certificate, gating a policy's every action. Verify-first: don't trust, certify.

This is the entry rung of the certificate ladder that runs through the Institute's Physical-AI work: a solution certificate, then a Lyapunov/energy certificate that gates control. Next on the roadmap: a physics-informed dynamics model driving certified model-predictive control on the Rust engine.

GO FURTHER · THE LIVE PLAYGROUND

Live: the PINN certificate trust-meter ↗ — Compute the a-posteriori error bound on a trained PINN; step the epochs to watch it tighten, and switch to ω=8 to see spectral bias trip the certificate red — a silent failure caught.
Live: one energy, controller and certificate ↗ — A single learned energy that is both the controller (descend it) and its own Lyapunov certificate, proven on a nonlinear pendulum.
Live: a physics gate on a frozen policy ↗ — The energy becomes a certificate on every action — a frozen policy is corrected only when its torque would violate ΔV+α‖s‖²<0, at microseconds per step.
Live: certified PINN-MPC (a surrogate you can trust) ↗ — A learned surrogate is the model inside model-predictive control; every plan carries a certified trust band that voids when the state goes out-of-distribution — verify-first applied to the control model.
Energy Is the Certificate ↗ — the paper behind the proven rung: one scalar energy as both objective and formal guarantee.

← When coefficients break The Gradient That Lies →

PYTHON · NUMPY

Don't trust a PINN — certify it

Live ferromotion-wasm: train the PINN, then certify it. The Bench trains the same u''+ω²u=0 network; the certificate below turns its residual into a rigorous error bound — then follow the three live tools under 'Go further'.

You read

the arrays and values already in scope

You change

the code you write in each cell

Fixed

the dataset and the checks that grade you