FERROMOTION · RUST → WASM

The Gradient That Lies

You take a contact you can solve exactly and refine the simulator's timestep. What happens to the gradient it returns?

Measure, on a contact you can solve exactly, that the gradient a differentiable simulator returns does not converge as the contact stiffens - it diverges as the square root of stiffness and points the wrong way over most of the usable range. Then find out WHICH PART of the simulator is responsible, because the obvious answer is the wrong one. Pass = you read the divergence exponent off the lab, find a stiffness where the sign is wrong, and show the same contact model getting the right answer once the integrator changes.

01Challenge

Module 6 told you a model you can differentiate is a model you can control by gradient descent. This module asks you to certify that instead of believing it. The Bench gives you one slider - contact stiffness - and two numbers computed from the real library: how far the soft-contact trajectory lands from a rigid impact, and how far its derivative lands from the exact one. Move the slider from 1e2 to 1e8 and watch which way each number goes. Find a stiffness where the derivative has the wrong SIGN. Then do the harder thing: decide what to blame. The timestep buttons and the tolerance button change different things, and only one of them fixes it.

Predict firstYou take a contact you can solve exactly and refine the simulator's timestep. What happens to the gradient it returns?

02Model

Every GPU-differentiable robotics simulator softens contact, because a spring is smooth and a smooth thing can be differentiated. The published position on this is a trade-off: stiff settings give you a faithful robot and unusable gradients, soft settings give you usable gradients and a sim-to-real gap, pick your poison. It is not a trade-off. A rigid impact is a discontinuity, and the derivative of a trajectory through one is not the derivative of any smooth approximation to it. It is the saltation matrix, and it carries a term no spring can contain: perturbing the state also moves the TIME of impact, and that term goes as one over the impact speed. Hit the ground at four metres per second and it is about four. Graze it at one centimetre per second and it is about sixteen hundred. It never appears as an error in the trajectory. It appears only in the derivative. So stiffen the contact and watch the gradient this simulator returns grow as the square root of stiffness, and flip sign, and stay flipped. Now the part where being careful pays. That measurement is correct, and the first explanation we attached to it was not. We said the spring was the culprit: that a penalty derivative has no limit to converge to, so no stiffness is right. Press the tolerance button. It is the same spring, the same stiffness, the same damping - only the integrator changed, from a fixed step to an error tolerance - and the answer lands on the exact one, in fewer steps than the fixed-step route spent getting the sign wrong. The spring was never the problem. Differentiating a FIXED-STEP rollout of it was.

03Guided practice

Step A (worked, fully shown): park the slider at 1e2, the softest setting. Read the two numbers: forward error is about 3.8 m - the trajectory is nowhere near a rigid bounce - and the gradient error is about 0.5, so the derivative is roughly right. This is the soft end of the published trade-off. Step B (worked): drag to 1e6. Forward error has fallen by about ninety times, to a few centimetres. Now look at the gradient error: it has RISEN to about forty-five, meaning the error is forty-five times the size of the whole correct answer. Step C (you drive): find any stiffness between 1e3 and 1e7 and check the sign line. The penalty model reports a negative number where the exact answer is positive. Step D (you drive): press the dt buttons to resolve the contact ten and a hundred times more finely. Predict first, then look: the gradient error does not move. It is not a discretisation error. Step E (read it off): the lab prints the divergence exponent measured over 1e4 to 1e8. It is 0.5. That is the law - the derivative grows as the square root of stiffness - and you just measured it rather than being told it.

04Feedback

PASS WHEN PASS when you have done four things on the live lab: found a stiffness where the sign line reads WRONG SIGN, confirmed the gradient error does not fall when you shrink dt, read the divergence exponent (0.5) off the readout, and turned on the tolerance route to see the same contact model land on the exact answer. There is no code to submit; the lab grades itself on what you have looked at.

If your run fails, check:

You are at 1e2, the softest setting, where the sign happens to agree. That is also where the forward error is about 3.8 m - a trajectory that is not simulating a bounce. Drag right until the sign line flips.
You shrank dt and expected the gradient error to fall. It did not, and that is the finding: at matched contact resolution the error stays within about 25% of where it was. Note carefully what this does and does not rule out. It rules out UNIFORM refinement. It does not rule out the integrator, which is what the tolerance button is for.
The exact entry is positive and the fixed-step entry is negative. That is not a tolerance problem. A descent direction built on it is not a descent direction - measured elsewhere in the library, an optimisation converges from 4 of 4 starts on the exact gradient and 0 of 4 on this one.
The forward error stops improving above about 1e6 and gets worse at 1e8. At a fixed timestep an explicit integrator cannot hold a stiffer spring, so you are watching the integrator lose stability, not the contact model improve. That is your first clue about which half of the simulator to suspect.
The divergence exponent reads about 0.5 whatever sub-range you take. That is a real property of the fixed-step autodiff gradient. It is not a property of the contact model: turn on the tolerance route and the same model, at the same stiffness, gives the exact answer.
You turned on the tolerance route and it sits at the bottom of the plot, flat. Read the step counts. At 1e6 it lands within 4e-3 of exact where the fixed-step route gets the sign wrong. Do NOT read the step counts as a saving: 199 is one rollout, and the Jacobian needs eight of them - about 14,800 force evaluations against the fixed route's 8,000. The tolerance route is roughly 1.85x MORE work. What you are buying is the right answer, not a cheaper one.
Look at the error split in the readout. At 1e6 the integrator contributes about 1.6e2 and the contact model about 9.4e-3, a ratio near 1.8e4. The two shares also move in OPPOSITE directions as you stiffen: the integrator's share grows, the contact model's share shrinks. That is the whole reassignment of blame, in two numbers you can watch move.

05Retrieve & space

Which way does each number go (typed): as contact stiffness rises, the forward error ____ and the fixed-step gradient error ____ -> falls / rises. The two axes move in opposite directions, which is why no single stiffness makes a fixed-step rollout both faithful and differentiable.
The missing term (short answer): name the quantity a saltation matrix contains that no smooth contact model does -> the time-of-impact term, proportional to 1/|impact speed|, unbounded as the impact grazes.
Predict-the-fix (multiple choice): a colleague proposes fixing the bad contact gradient with a smaller timestep. Does it work? -> Not if they mean a smaller UNIFORM timestep: measured, the error stays within about 25% across three decades of dt. It does work if they mean an error tolerance, which spends its steps unevenly. The two proposals sound identical and are not.
The exponent (typed): the fixed-step penalty contact gradient grows as stiffness to the power ____ -> one half. Measured 0.5127 in the audit and 0.5286 on the lab, against an exact 1/2.
Assign the blame (multiple choice): the gradient error at stiffness 1e6 splits into an integrator share and a contact-model share. Which dominates, and by roughly how much? -> The integrator, by about four orders of magnitude (1.6e2 against 9.4e-3). The contact model's share also SHRINKS as the contact stiffens, so the converged penalty gradient is approaching the exact rigid one, not departing from it.
The retracted claim (short answer): we originally said a penalty derivative 'has no limit to converge to'. What measurement overturned it, and what is the limit? -> Decomposing the error against a reference built without the integrator under test. The limit is the exact rigid saltation Jacobian, approached as roughly 1/sqrt(k) over the well-resolved decades (k^-0.50, R^2 = 1.0000).

06Mastery & project

You can state the two axes and which way each moves, name the time-of-impact term and why a spring cannot contain it, distinguish uniform refinement from tolerance-driven stepping having tested both, give the divergence exponent, and split the error into an integrator share and a contact-model share. Above all: you check a gradient against a reference before you descend on it, and when a measurement surprises you, you fix the attribution before you publish the explanation.

Not a capstone lesson. It is the certificate step for Module 6: control-by-gradient works exactly as far as the gradient is real, so any capstone that optimises through a contact has to say which route produced its derivative.

GO FURTHER · THE LIVE PLAYGROUND

The full audit, on a system with a closed-form answer ↗ · The stiffness sweep, the sign table, and the test showing uniform timestep refinement does not rescue it.
Does it break the optimisation? (measured, not asserted) ↗ · Exact gradient converges from 4 of 4 starts; penalty autodiff from 0 of 4, and from three of them it cannot take a single downhill step.
The same question on a quadruped with four frictional feet ↗ · Controlled to one variable, with the rigid step asserted bit-identical to the library's. The rigid law wins on both axes at once.
The exact gradient as a callable: hybrid_jacobian ↗ · Finds the events, brackets each to one timestep, and refuses on grazing, hidden state, or a probe-dependent answer.
The decomposition that reassigned the blame ↗ · Splits the error into an integrator share and a contact-model share, checks the reference against a closed-form answer, and reports the noise floor so the small numbers are not quoted below it. The independence is partial: dv/dv0 is 1 by algebra whatever the restitution, so that entry is genuinely integration-free, while the others are calibrated by a restitution the same adaptive rollout measured.

← Don't trust a PINN, certify it The Reference That Shares Its Machinery →

FERROMOTION · RUST → WASM

The Gradient That Lies

Live ferromotion-core: a penalty contact and a rigid impact on the same drop, with the rigid Jacobian computed by saltation matrix and verified against finite differences to 8e-10. One slider for stiffness, three buttons for the timestep, and one button that swaps the fixed step for an error tolerance while changing nothing else. Damping is scaled as 2*zeta*sqrt(k) so the realised restitution stays fixed and only the contact resolution changes - otherwise the sweep would be comparing different physics.

You read

the readout: what the Rust crate computes, recomputed as you change things

You change

the bench controls, and with them the assumption the measurement rests on

Fixed

the ferromotion crate doing the computing, and the check that decides pass