PYTHON · NUMPY

The Gradient That Lies

Measure, on a contact you can solve exactly, that a differentiable simulator's contact gradient 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. Pass = you read the divergence exponent off the lab and find a stiffness where the sign is wrong.

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. Then find a stiffness where the derivative has the wrong SIGN, and decide what that means for anyone descending on it.

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. It is a consequence of differentiating the wrong object. 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 when you stiffen a penalty contact, the trajectory converges to the rigid one and its derivative does not converge to anything at all - it grows as the square root of stiffness, forever. Softening does not buy you gradient quality by giving up accuracy. It caps a divergence, and you pay the sim-to-real gap for the cap.

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 three 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, and read the divergence exponent (0.5) off the readout. 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. A discretisation error would have shrunk.
The exact entry is positive and the penalty 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.
The divergence exponent reads about 0.5 whatever sub-range you take. That is the whole result: the penalty derivative has no limit, so there is nothing for it to converge to and no stiffness at which it is right.

05Retrieve & space

Which way does each number go (typed): as contact stiffness rises, the forward error ____ and the gradient error ____ -> falls / rises. The two axes move in opposite directions, which is why no single stiffness is correct.
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? -> No. Holding the contact resolved at a constant step count leaves the error where it was; the error is a divergence in stiffness, not a discretisation.
The exponent (typed): the penalty contact gradient grows as stiffness to the power ____ -> one half. Measured 0.5127 against an exact 1/2.

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, rule out the timestep as a fix having tested it, and give the divergence exponent. Above all: you check a gradient against a reference before you descend on it, because a wrong sign does not announce itself.

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 that adaptive integration 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.

← Don't trust a PINN — certify it Back to course →

PYTHON · NUMPY

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. 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 arrays and values already in scope

You change

the code you write in each cell

Fixed

the dataset and the checks that grade you