Sliding Pivot Model Explains Robot Throwing Release

Why robots throw worse than chimpanzees

Here is a puzzle the authors open with. People throw with speed and accuracy, and so do some animals, chimpanzees and elephants among them. Robots have lower communication latency and far more precise motor control than any animal, and yet they throw only occasionally and badly. Something the robot has in raw hardware terms is not translating into the skill. Where does the advantage leak away?

Yang Liu and Aude Billard argue the leak is in the release. A pick and throw robot is attractive for logistics because it can fling the current item toward its bin and move straight to the next pick, saving the time and energy of carrying a heavy arm all the way to the target. That only works if the robot can predict where the thrown object goes. The flight through the air is easy physics. The hard part is the moment of letting go.

Think about what release actually involves. The gripper does not vanish instantly. It opens over a short interval, and during that interval the normal force squeezing the object drops toward zero. As it drops, the friction that the finger pads can provide shrinks. The object first stays stuck to the hand, then starts to rotate around the finger pad, then finally slides free and flies off spinning. All of that happens in roughly 50 milliseconds, and the exact velocity and spin the object carries into the air are set during it. Model that window wrong and every throw lands in the wrong place.

The tool everyone reaches for, and why it fails here

When engineers model friction over a contact patch rather than a point, the standard tool is the limit surface. The idea, which goes back to Suh Goyal, Andy Ruina, and Jim Papadopoulos in the late 1980s, is elegant. For a given patch under Coulomb friction you can draw a closed surface in the space of tangential force and torque. Any sliding motion of the patch maps to a point on that surface, and the friction wrench points along the surface normal there. It bundles the coupling between sliding force and twisting torque into one clean geometric object.

The limit surface is usually approximated as an ellipsoid, defined by a quadratic function of the friction wrench.

Here \(\mu\) is the friction coefficient, \(r\) is the contact patch radius, and \(c\) is a constant near 0.6 that accounts for the pressure distribution. During sliding, the friction wrench is read off from the direction of the sliding velocity \(\mathbf{v}\).

Look closely at that expression and you can see the trouble coming. The friction wrench depends only on the direction of the sliding velocity, never on its magnitude. Double the sliding speed and the friction wrench does not change at all. Mathematicians call such a function positively homogeneous of degree zero, and it leaves a sharp discontinuity sitting in the state space of the system. When the sliding velocity is tiny, which is exactly the situation at the start of release, its direction can flip wildly from one instant to the next, and the friction wrench flips with it.

The authors run the simplest possible test, dropping a pinch grasped bar as the grip loosens, and the limit surface model falls apart. The predicted forces and velocities oscillate violently, a numerical thrashing that resembles the Zeno effect where infinitely many switches pile up in finite time. Shrink the time step and the oscillations do not go away. They are not a solver artifact you can tune out. They come from the friction law itself.

The velocity magnitude independent friction wrench induces oscillatory behavior in the transient dynamical system. This is not a numerical artifact arising from time discretization, and it should not be interpreted as an approximation of the continuous time dynamics. Liu and Billard, on why the limit surface model thrashes during release

There is a partial rescue. Borrowing an idea from one dimensional friction, the authors add viscous smoothing, letting the friction force grow linearly with slip speed until it reaches the Coulomb limit, and they solve the result with an implicit integrator. This smoothed limit surface, which they call ILS, does produce clean simulations and the highest accuracy of any model they test. The catch is cost. The implicit solver is roughly 20 times slower than the alternatives, and its runtime is unpredictable, which makes it a poor fit for planning or learning loops that need many fast, steady evaluations.

The Sliding Pivot idea

Rather than smooth over the discontinuity and pay for a stiff solver, Liu and Billard step back and ask what actually happens physically when the grip loosens. Their answer is the Sliding Pivot model, and its picture is intuitive once you see it.

Imagine the bar pinched between two finger pads, with its center of mass offset to one side, the way you would hold a hammer near the head. As the normal force fades, the bar cannot stay rigidly attached. Because the mass is offset, gravity puts more stress on the near contact than the far one, so one edge of the patch begins to give first. The object starts to rotate about the finger pad, a pivot, while the pad itself has not yet started to slide across the object. Only later, as the normal force keeps vanishing, does the whole patch lose its grip and slide. Release is a sequence, sticking then pivoting then sliding, and the model builds each phase explicitly.

The move that makes it work is a decoupling. The limit surface ties tangential friction and torsional friction together through one shared surface, and that coupling is the source of the discontinuity. Sliding Pivot cuts the tie and gives each its own simple limit that scales with the normal force.

The tangential friction can hold up to \(f_{\max}\) and the torsional friction can hold up to \(\tau_{\max}\), and each is checked on its own. This is less physically complete than the coupled limit surface, but it is exactly the simplification that removes the pathological switching.

The temporal hinge, grounded in a beam

Why should pivoting dominate the release at all? The authors give a clean argument using an overhanging beam, the kind of stress analysis a civil engineer would recognize. Model the bar as held at two contact points with friction at each. Work through the statics and a striking result drops out. Because the center of mass is offset, the stress at the far contact is much larger than the weight of the object, so that contact begins to slide well before the normal force has dropped to the level naively needed to support the weight. A hinge forms around the near contact and persists for an extended window.

They call this the temporal hinge, and it matches something seen in real materials, the detachment wave observed when rubber slides on glass. The angular acceleration during the hinge comes out negative, a clockwise spin for a bar held on its right, which is exactly what you see when a loosely held object tips off your fingers. The model is not inventing behavior. It is naming a phenomenon that contact physicists have measured.

The mechanics of the pivot

Once the pivot is established, the object becomes a one degree of freedom system rotating about the finger pad, and the dynamics are compact. The reflected rotational inertia at the pivot follows the parallel axis theorem, \(mh^2 + I\), where \(h\) is the distance from the pivot to the center of mass and \(I\) is the object inertia. The pivot acceleration during the sticking and pivoting phase is written in one expression.

While the external torsional load \(\tau^p\) stays below \(\tau_{\max}\) the object rides with the hand as an extended rigid body. Once it exceeds \(\tau_{\max}\) the object pivots, with the acceleration set by how much the load overshoots the shrinking friction limit. When the tangential load finally passes \(f_{\max}\), the patch slides and a separate set of sliding equations takes over, with the object center of mass falling under gravity minus whatever friction the dying contact still provides. The three phases hand off to each other in order, and each one is a short, readable calculation rather than a stiff numerical integration through a discontinuity.

Does it hold up on a real robot

This is where the paper earns trust. The models are tested on hardware, not only in simulation. The setup is a seven degree of freedom Franka Emika Panda arm with a Robotiq 2F-85 parallel gripper wearing a soft silicone fingertip, and an ATI Nano 17 force torque sensor mounted behind one finger pad to catch the vanishing normal force as the grip opens. The thrown object is a 3D printed bar with a configurable mass distribution and motion capture markers, tracked by an OptiTrack system at 250 Hz with 0.2 millimeter accuracy. The bar weighs 0.24 kg and spans 0.26 m.

The batch experiment is genuinely broad. The authors sweep 36 throwing conditions, two center of mass positions, three pitch angles, and six release motions from accelerating to decelerating, and repeat each five times for 180 throws. The mean flight time is 0.6 seconds, so landing error amplifies whatever the release model got wrong. Three models compete, the plain limit surface, the smoothed limit surface with implicit integration, and Sliding Pivot.

The story in the numbers is consistent. Sliding Pivot lands very close to the expensive smoothed model and far ahead of the plain limit surface. Against the limit surface it cuts horizontal velocity error by 40 percent and angular velocity error by 63 percent, and it reaches 2.4 cm mean error on where the bar lands and 15.4 degrees on how it is oriented. The smoothed model edges it out on most metrics, but only by about 10 percent, and it pays dearly for that edge.

The cost gap is the punchline. Sliding Pivot solves a throw in about 43 milliseconds, essentially the same as the plain limit surface at 48 milliseconds, while the smoothed model needs about 967 milliseconds per throw and with a huge variance. Generating the full study of 216000 predictions took 22 hours, with most of that time spent inside the implicit solver. For any downstream planner or learning loop that has to evaluate the release model thousands of times, the 20 times speedup at nearly the same accuracy is what matters.

In the single throw case study the contrast is even starker. Sliding Pivot cuts the landing horizontal position error by more than 99 percent, under 1 cm against 16 cm for the plain limit surface, and reduces the landing orientation error by 63 percent, 23 degrees against 62. The plain model also shows a systematic bias, always erring toward larger horizontal displacement, while Sliding Pivot scatters symmetrically around zero with no bias.

Standing next to the learning based throwers

It is fair to ask how a physics model compares to the data driven systems that have grabbed attention, TossingBot and TossNet. TossingBot learns a mapping from camera images to throwing outcomes and reaches about 85 percent accuracy on a target box after around 15000 real throws, but it does not model the object rotation. TossNet adds proprioceptive and force torque sensing and predicts orientation with about 4.5 degrees of error, but it trains on roughly 3000 real throws under much narrower conditions.

Sliding Pivot needs no throwing dataset at all. It is a physical model expressed in real units, so a robot can plug in an object mass, center of mass, and inertia, all of which can be estimated with standard payload identification, and predict throws for objects and conditions it has never seen. That is the transferability argument for physics over pure learning. The tradeoff is honesty about scope. The learning models can absorb messy effects a clean model omits, and the authors do not claim Sliding Pivot handles deformable or highly irregular objects.

Honest limitations

The paper is refreshingly candid about where the model strains. The decoupling that makes Sliding Pivot fast also makes it approximate. By treating tangential and torsional friction separately it drops the real coupling between them, and in the factor analysis the model shows inconsistent accuracy across large pitch angles, where the complex interplay of gravity and friction is not fully captured. The authors say plainly that the effects at different pitch angles are not sufficiently explained by the model.

There is also the base assumption of a symmetric, isotropic, pinch grasp between two identical finger pads, which they note may not hold for anthropomorphic hands with asymmetric contact. Air drag and the Magnus effect are neglected during the short release, reasonable for a heavy printed bar at indoor speeds but not a universal license. And the whole framework rests on Coulomb friction with a rigid object, so soft or deformable objects fall outside it.

Their own suggested path forward is worth noting because it closes a loop. To capture the effects Sliding Pivot misses, they point to soft contact models built on microscopic bristle deformation, specifically the LuGre friction model. That is the same family of models behind the planar friction work with LuGre dynamics and limit surfaces that this paper cites directly, which suggests the two lines of research are converging on the same answer from different directions.

Reproducing the Sliding Pivot release

The clearest way to feel how Sliding Pivot works is to simulate the release of a pinch grasped bar as the normal force fades and watch the three phases switch. The implementation below writes the model as a differentiable module, which suits robotics work that wants to place the release model inside a learning or trajectory optimization loop. It follows the paper’s dropping scenario, integrates the pivot dynamics with an explicit step, and prints the phase transitions along with the terminal twist. The comments mark where the coupling that the model deliberately drops would go back in.

# Sliding Pivot release model for a pinch grasped bar.
# Educational reimplementation of the release dynamics from Liu and
# Billard, "On Transient Release Dynamics in Robot Throwing: A Sliding
# Pivot Model" (IEEE T-RO 2026). Written as a torch.nn.Module so the
# model is differentiable and can sit inside a planning or learning loop.
# The three phases sticking, pivoting, sliding switch on the decoupled
# friction limits f_max = mu f_N and tau_max = c r mu f_N.
# Note. The paper reports physics routines, not training losses. The
# "loss" below is a landing residual for fitting mu and r, not a claim
# that the original work trained a network.

import torch
import torch.nn as nn


class SlidingPivotRelease(nn.Module):
    """Release of an offset center of mass bar under a vanishing grip.

    Phases follow the paper. While the loads sit inside the friction
    limits the bar rides with the hand. When the torsional load exceeds
    tau_max the bar pivots about the finger pad. When the tangential load
    exceeds f_max the patch slides and the bar falls free.
    """

    def __init__(self, m=0.2, h=0.1, rho=0.05, r=0.0075,
                 mu=0.8, c=0.6, g=9.81):
        super().__init__()
        self.m = m                    # object mass, kg
        self.h = h                    # pivot to center of mass offset, m
        self.I = m * rho * rho        # inertia from radius of gyration
        self.r = r                    # contact patch radius, m
        self.mu = mu                  # friction coefficient
        self.c = c                    # pressure distribution constant
        self.g = g

    def limits(self, f_n):
        """Decoupled tangential and torsional friction limits."""
        f_max = self.mu * f_n
        tau_max = self.c * self.r * self.mu * f_n
        return f_max, tau_max

    def step(self, omega, f_n, dt):
        """One integration step. Returns new pivot rate, phase, and wrench.

        Reflected inertia at the pivot uses the parallel axis theorem,
        J = m h^2 + I. Gravity supplies the external tangential load m g
        and the external torsional load about the pivot m g h.
        """
        J = self.m * self.h ** 2 + self.I
        f_max, tau_max = self.limits(f_n)

        tan_load = self.m * self.g               # gravity pulling the patch
        tor_load = self.m * self.g * self.h      # gravity torque about pivot
        sgn = 1.0 if tor_load >= 0.0 else -1.0

        if tan_load > f_max:
            # Sliding. The patch can no longer hold, the bar falls free
            # while the residual torsional friction still resists.
            phase = "sliding"
            alpha = sgn * torch.clamp(tor_load - tau_max, min=0.0) / J
            omega = omega + dt * alpha
        elif tor_load > tau_max:
            # Pivoting. One degree of freedom rotation about the pad.
            # Coupling with tangential friction is dropped on purpose here.
            phase = "pivoting"
            alpha = sgn * (tor_load - tau_max) / J
            omega = omega + dt * alpha
        else:
            # Sticking. The bar rides with the hand, no relative motion.
            phase = "sticking"
            alpha = torch.zeros_like(omega)

        # Wrench at the center of mass. Clockwise spin is negative.
        tau_cm = -torch.abs(torch.tensor(tor_load)) * (omega != 0).float()
        return omega, phase, alpha, tau_cm

    def forward(self, f_n_profile, dt=1e-4):
        """Roll out the release given a vanishing normal force profile.

        f_n_profile is a 1-D tensor of normal force samples in newtons.
        Returns the pivot rate history and the list of phases entered.
        """
        omega = torch.zeros(1)
        rate_hist, phases = [], []
        for t in range(f_n_profile.shape[0]):
            omega, phase, _, _ = self.step(omega, f_n_profile[t], dt)
            rate_hist.append(omega.clone())
            phases.append(phase)
        return torch.stack(rate_hist), phases

    def com_twist(self, omega):
        """Map pivot rate to center of mass linear speed, v = omega x h."""
        return omega * self.h


def landing_loss(model, f_n_profile, omega_ref, dt=1e-4):
    """Squared error on the detach pivot rate, for fitting mu and r.

    The paper identifies mu and r by matching landing poses. This is the
    same idea reduced to the release twist for a single scenario.
    """
    rate_hist, _ = model(f_n_profile, dt)
    return (rate_hist[-1] - omega_ref) ** 2


def smoke_test():
    """Runnable check on a vanishing normal force, dummy data."""
    model = SlidingPivotRelease()

    # Normal force starts at 80 N and falls linearly to zero over 50 ms,
    # matching the grasp force in the throwing experiments. The bar begins
    # stuck, then pivots as the torsional limit is crossed, then slides.
    steps = 500
    f_n = torch.linspace(80.0, 0.0, steps)
    rate_hist, phases = model(f_n)

    seen = []
    for p in phases:
        if not seen or seen[-1] != p:
            seen.append(p)
    detach_rate = rate_hist[-1].item()
    com_speed = model.com_twist(rate_hist[-1]).item()

    assert torch.isfinite(rate_hist).all(), "non finite pivot rate"
    assert seen == ["sticking", "pivoting", "sliding"], seen
    print("phase order  ", " then ".join(seen))
    print("detach pivot rate {:.3f} rad/s".format(detach_rate))
    print("detach CoM speed  {:.3f} m/s".format(com_speed))
    print("smoke test passed")


if __name__ == "__main__":
    smoke_test()

The one honest caveat in the code mirrors the one in the paper. During the pivoting phase the tangential and torsional friction are handled separately, which is the very decoupling that keeps the model fast and stable. To recover the coupling that a full limit surface would carry, you would reintroduce a shared friction limit between the tangential and torsional channels, at the cost of the smoothness that makes this model pleasant to integrate. The rest of the structure, the three phase switch and the pivot inertia, stays as is.

What this changes for robots that throw

Step back and the value is practical. A pick and throw station in a warehouse only pays off if the robot can place items into bins reliably, and reliability means predicting the landing pose before the object leaves the hand. A release model that runs in tens of milliseconds and predicts landing to within a few centimeters and about 15 degrees is fast enough to sit inside a motion planner and accurate enough to trust. That is the practical door Sliding Pivot opens.

The interpretability matters too. Because the model is written in real physical units with named phases, it transfers across robots and objects without retraining, and its predictions can be inspected and debugged rather than trusted as a black box. For anyone building the perception and planning stack around a throwing robot, this slots in beside the trajectory and scene reasoning problems the field is already working on, from how robot path planning has evolved to how language models reason about 3D scenes. You can browse the wider set of work through the robotics and autonomous systems pillar.

Conclusion

The core achievement of this paper is the first physical model of the transient release in robot throwing, a window of a few tens of milliseconds that decides the outcome and that had been treated as an afterthought. By recognizing that release proceeds through sticking, pivoting, and sliding, and by giving tangential and torsional friction their own limits that fade with the normal force, Liu and Billard turn a numerically hostile problem into three clean phases a fast solver can march through. The result matches a heavy smoothed model within about 10 percent while running more than 20 times faster, and it beats the conventional limit surface by wide margins on real hardware.

The conceptual shift underneath it is a preference for physical regularization over numerical patching. Faced with a friction law that oscillates because its wrench ignores velocity magnitude, the easy move is to smooth the math and reach for a stiff implicit solver. The harder and better move is to ask what the object is physically doing and to model that directly. The temporal hinge, justified through a plain beam analysis and echoed in real rubber on glass experiments, is the kind of insight that a purely numerical fix would have hidden.

The ideas travel beyond throwing. Any task that ends with a controlled release, placing a delicate part, handing an object to a person, or dropping an item onto a moving belt, lives in the same transient contact world, and the sticking to pivoting to sliding sequence should carry over with the object parameters swapped in. Because the model speaks in SI units, the object mass, center of mass, and inertia it needs can be estimated once and reused across a fleet of robots.

The limitations mark the edges rather than sink the work. The decoupling of tangential and torsional friction costs accuracy at large pitch angles, the symmetric pinch grasp assumption may not fit human like hands, and the rigid Coulomb friction base excludes soft objects. The authors point toward soft contact models with microscopic bristle deformation, the LuGre family, to fill those gaps, which ties this work to a broader effort to model contact more faithfully without giving up speed.

What lingers is how much was hiding in 50 milliseconds. A robot with faster reflexes and finer control than any animal still throws poorly, and the reason turns out to be a sliver of time at the moment of letting go. Model that sliver honestly and the throw comes good. That is a satisfying kind of result, the sort that reframes a problem rather than just nudging a number.

Frequently asked questions