How ZeroProofML Works

Why singularities matter

The hardest parts of scientific ML are exactly the regimes where the math breaks: censored measurements, resonant poles, and kinematic locks. Standard neural nets carry a smoothness bias - when they see a pole, they blunt it; when a quantity is undefined, they invent a finite stand-in. That’s fine for interpolation, but in safety-critical pipelines it is a silent failure.

ZeroProofML was built to make those singularities first-class citizens. Instead of trying to regularize them away, we model them explicitly and carry that algebra all the way through training and deployment.

What makes ZeroProofML different

• Signed Common Meadows (SCM). We use a totalized arithmetic where division by zero yields an absorptive element $\perp$. That lets us describe “undefined” states algebraically instead of relying on NaN/Inf heuristics.
• Projective tuples. The network predicts pairs $\langle N,D\rangle$ so that gradients see a smooth surface even when $D$ heads toward zero. We only decode to $N/D$ (or to $\perp$) at inference time.
• Train on Smooth, Infer on Strict. During training we keep the computation smooth, enforce margins around $|D|$, and supervise the sign/orientation. At deployment we flip on the strict SCM decoder with auditable thresholds: if $|D|<\tau_{\text{infer}}$ we emit $\perp$, otherwise we return $N/D$ with the right phase information.
• Shared-structure heads. For complex-valued domains we tie real and imaginary parts through a shared denominator, and for robotics we bound $|D|$ away from zero so the model behaves like a well-conditioned rational controller.

Together these steps turn “handle every singularity by hand” into “use the same operator everywhere.”

The workflow

• Encode the physics. Choose the rational head shape (real, complex, or projective gate) that matches your system.
• Train smoothly. Optimize on tuples with implicit fit, margin, and sign losses. Because the tuples are normalized, gradients stay finite even when the denominator should collapse.
• Auditably deploy. At inference time the SCM decoder emits either a finite number or $\perp$. That bottom signal can flow through downstream calculations, so every caller can treat undefined states consistently.

Proof points from the latest suite

We stress-tested the framework on three domains from the latest paper. Each benchmark used the same data splits and training budget across methods.

Pharma / Dose-Response (informational singularity)

• Goal: Reject censored IC50 measurements instead of hallucinating finite values, while still predicting below/above direction when possible.
• Result: Angular SCM with the soft curriculum drives false accepts on censored data down to the noise floor while keeping zero false rejects, whereas a rational+$\epsilon$ baseline accepts more than half of those censored inputs.
• Direction options: The default tuple-only sign rule keeps things simple; a harder curriculum brings back full three-way regime identification at the cost of regression quality, and a frozen SCM gate plus a tiny direction head gives high direction accuracy without touching the safety boundary.
• Impact: Every downstream consumer (e.g., therapeutic index calculations) can key off the same $\perp$ flag instead of writing bespoke reject logic.

Electronics / RF Filters (spectral singularity)

• Goal: Extrapolate from low-$Q_f$ training data to extremely high-$Q_f$ resonances without clipping peaks or drifting in phase.
• Result: The shared-denominator SCM model roughly doubles the success yield relative to a deep MLP, keeps resonance peaks near their true magnitude, and tightens the phase error dramatically.
• Ablations: Removing the shared denominator drops yield, showing the constraint - not just “being rational” - drives coherence.
• Impact: Designers can explore high-$Q$ filters with far fewer full-wave simulations because the surrogate keeps both amplitude and phase aligned with the physics.

Robotics / Near-Singular IK (optimization stability)

• Goal: Maintain predictable inverse-kinematics behavior as a planar arm approaches full extension where $\det J$ collapses toward zero.
• Result: The SCM variant intentionally trades a small amount of mean error for roughly an order-of-magnitude reduction in seed-to-seed variance, while the rational+$\epsilon$ baseline is unstable.
• Tail behavior: Near the kinematic lock, the SCM model avoids the MLP’s systematic under-response and keeps tail deviations bounded. Strict inference never triggered $\perp$ because $|D|$ is bounded, keeping the focus on optimization geometry.
• Impact: Controllers get consistent behavior across random seeds, which is easier to certify than a slightly more accurate but highly variable model.

When to reach for ZeroProofML

Great fit:

• Safety-critical loops where “undefined” must propagate cleanly (clinical dose modeling, diagnostics, mission-critical robotics).
• Extrapolation-heavy tasks that lean on physical asymptotes (spectral design, scattering, stiff ODE surrogates).
• Workloads that need deterministic reject semantics or variance control across seeds.

Probably overkill:

• Pure interpolation in smooth regimes (standard CV/NLP benchmarks).
• Settings without a measurable singular structure, where an MLP already fits and the SCM gate would never fire.

If your models are still fighting $\epsilon$-hacks or post-hoc reject rules, swapping in the SCM head is the fastest way to make singularities auditable and trustworthy.