Section 6.3: Contact, friction, and why contact-rich sim is hard

A Careful Control Loop

This section develops the technical contract for Contact, friction, and why contact-rich sim is hard into a usable mental model. First we define the object of study, then we connect it to the agent loop, then we test it with a compact implementation.

The key question in Contact, friction, and why contact-rich sim is hard is practical: what must the agent know, what can it observe, what action is available, and what evidence shows that the action worked under the stated conditions?

Theory

For Contact, friction, and why contact-rich sim is hard, the practical design rule is to make the interface inspectable before optimization begins: inputs, outputs, units, latency, bounds, and failure labels should all be visible in the saved artifact.

Worked Example: Impulse-Based Contact With Restitution and a Friction Cone

Hard contact is hard because it is a constrained, set-valued problem. An impulse-based resolution sidesteps stiff penalty forces by directly computing the impulse $J = (J_n, J_t)$ that corrects the relative velocity at the contact point in a single step. Two physical laws bound that impulse:

• Normal restitution. The post-impact normal velocity reverses by a factor of the coefficient of restitution $e \in [0,1]$: $v_n^{+} = -e\, v_n^{-}$. With $e=1$ the bounce is perfectly elastic; with $e=0$ the contact is fully plastic.
• Coulomb friction cone. The tangential impulse is limited by $\lVert J_t \rVert \le \mu J_n$. Inside the cone the contact sticks (relative tangential velocity is driven to zero); on the cone boundary it slides and friction opposes the slip direction.

The example resolves a point mass striking the ground at an angle. It computes the normal impulse from restitution, then clamps the sticking tangential impulse to the friction cone, which is exactly the projection a contact solver performs at every active contact.

import numpy as np

def resolve_contact(v_in, m, normal, e, mu):
    """Impulse-based resolution of a point mass hitting a surface.
    v_in   : incoming velocity (2D)
    normal : unit surface normal pointing away from the surface
    e      : coefficient of restitution in [0,1]
    mu     : Coulomb friction coefficient
    Returns post-impact velocity and the applied impulse."""
    n = normal / np.linalg.norm(normal)
    t = np.array([-n[1], n[0]])            # tangent direction

    vn = v_in @ n                          # normal component (negative if approaching)
    vt = v_in @ t                          # tangential component

    if vn >= 0:                            # separating, no contact impulse
        return v_in, np.zeros(2)

    # Normal impulse enforces v_n^+ = -e * v_n^-.
    Jn = -(1 + e) * vn * m                 # >= 0

    # Sticking tangential impulse would cancel all tangential velocity.
    Jt_stick = -vt * m
    Jt_max   = mu * Jn                     # friction-cone limit
    if abs(Jt_stick) <= Jt_max:
        Jt = Jt_stick                      # inside cone: stick
        mode = "stick"
    else:
        Jt = -np.sign(vt) * Jt_max         # on cone: slide, oppose slip
        mode = "slide"

    J = Jn * n + Jt * t
    v_out = v_in + J / m
    return v_out, J, mode

m = 0.5
v_in = np.array([3.0, -2.0])               # moving right and down
normal = np.array([0.0, 1.0])              # floor normal points up

for e, mu in [(0.0, 2.0), (0.8, 0.5), (0.8, 0.05)]:
    v_out, J, mode = resolve_contact(v_in, m, normal, e, mu)
    vn_out = v_out @ normal
    print(f"e={e} mu={mu:<4} -> v_out={np.round(v_out,3)} "
          f"vn_out={vn_out:+.3f} mode={mode}")

The output shows the three regimes a contact-rich simulator must get right: with $e=0$ the normal velocity is killed and high friction makes the contact stick; with $e=0.8$ the mass bounces, $v_n^{+}=0.8\,|v_n^{-}|$; and with low $\mu$ the tangential impulse saturates on the cone and the mass slides instead of sticking. The set-valued switch between stick and slide is precisely the active-set decision that makes contact-rich simulation non-smooth and timestep sensitive.

Practical Recipe

1. Write the observation, action, and success metric before choosing a model.
2. Build a baseline that is simple enough to debug by inspection.
3. Add the library implementation only after the baseline behavior is understood.
4. Record failures as structured cases: perception error, state error, planning error, control error, or evaluation error.
5. Run at least one perturbation test before trusting the result.

Production Pattern

Contact, friction, and why contact-rich sim is hard sits inside the Part II robotics contract: geometry defines where things are, kinematics defines what motion is possible, dynamics defines what motion costs, control defines how errors are corrected, and sensing defines what the agent can know on time.

Inspect contact as a numerical model with solver settings, not as a perfect physical event. This makes the section useful to students, builders, and researchers at the same time: the idea has an intuitive role, a formal interface, a runnable check, and a failure mode that can be reproduced.

Contact is hard because the model changes the instant two bodies touch. Before contact, the bodies follow smooth free motion. At contact, a constraint force appears, penetration must stay small, tangential slip may switch between sticking and sliding, and the solver must choose impulses that satisfy all of those requirements at once.

Use this recipe when turning Contact, friction, and why contact-rich sim is hard into code, a simulator experiment, or a robot diagnostic. The point is not to use every library. The point is to keep the hand-built baseline and the maintained-tool path comparable.

1. Specify mass, inertia, actuator limits, contact model, timestep, and solver tolerance before running a rollout.
2. Run one free-motion test and one contact test with logged energy, constraint violation, and penetration depth.
3. Compare the hand calculation with MuJoCo, Drake, Pinocchio, or MJX on the same model and timestep.
4. Store solver settings, random seed, initial state, trajectory, and failure labels in one artifact.
5. Scale to Isaac Lab or GPU-parallel simulation only after a small model passes deterministic checks.

For Contact, friction, and why contact-rich sim is hard, distrust smooth simulation until the section-specific physical assumption has been stress-tested: timestep, contact stiffness, damping, friction, actuation, and energy behavior should each have a small diagnostic.