Consider a rigid object and a set of contacts \( \mathcal{C} = \{1,\dots,k\} \). Each contact \( i \) has position \( \mathbf{p}_i \in \mathbb{R}^3 \), outward normal \( \mathbf{n}_i \), and friction coefficient \( \mu_i \ge 0 \). External disturbances act as wrenches (combined forces and moments) on the object.

Informally:

• A grasp has form closure if the object cannot move infinitesimally without violating at least one unilateral contact constraint, even if all contact surfaces are frictionless.
• A grasp has force closure if, given friction limits at contacts, the contact forces can balance any external wrench while respecting unilateral and friction constraints.

In wrench space of dimension \( d = 3 \) (planar) or \( d = 6 \) (spatial), force closure requires that feasible contact wrenches generate a convex cone whose interior contains a neighborhood of the origin. Form closure, in its first-order version, can be expressed as a dual condition in twist space.

flowchart TD
  A["Object + contact set C"] --> B["Geometry only (frictionless normals)"]
  A --> D["Geometry + friction cones + forces"]
  B --> C["Form-closure test"]
  D --> E["Force-closure test"]
  C --> F["Immobilization: no nonzero feasible motion"]
  E --> G["Resist any external wrench with bounded forces"]
        

We now make these notions precise, starting from contact wrenches and their linear representations.

For a planar rigid body (motion in \( SE(2) \)), the wrench space is \( \mathbb{R}^3 \): \( \mathbf{w} = [f_x, f_y, m_z]^\top \). Let the object frame be located at a reference point \( \mathbf{p}_0 \) (often the center of mass). For contact \( i \) with position \( \mathbf{p}_i = [x_i, y_i]^\top \) and contact force \( \mathbf{f}_i = [f_{ix}, f_{iy}]^\top \), the induced wrench is

\[ \mathbf{w}_i = \begin{bmatrix} f_{ix} \\[4pt] f_{iy} \\[4pt] x_i f_{iy} - y_i f_{ix} \end{bmatrix} = \begin{bmatrix} 1 & 0 \\[2pt] 0 & 1 \\[2pt] -y_i & x_i \end{bmatrix} \mathbf{f}_i = G_i \mathbf{f}_i. \]

Here \( G_i \in \mathbb{R}^{3\times 2} \) is the local grasp matrix of contact \( i \). If we parametrize each contact by a set of primitive force directions \( \mathbf{d}_j \in \mathbb{R}^2 \) (e.g., edges of a linearized friction cone) and associate scalar magnitudes \( \alpha_j \ge 0 \), then

\[ \mathbf{w} = \sum_{j=1}^M \alpha_j \mathbf{w}_j, \quad \mathbf{w}_j = \begin{bmatrix} d_{jx} \\ d_{jy} \\ x_j d_{jy} - y_j d_{jx} \end{bmatrix}, \quad \mathbf{w} = G \boldsymbol{\alpha},\; G = [\mathbf{w}_1\ \dots\ \mathbf{w}_M], \ \boldsymbol{\alpha} \in \mathbb{R}^M_{\ge 0}. \]

The set of all wrenches achievable by nonnegative combinations of primitive directions is the convex cone \( \mathcal{C} = \{ G\boldsymbol{\alpha} \mid \boldsymbol{\alpha} \ge 0\} \subset \mathbb{R}^3 \). Force closure will be phrased as a condition on \( \mathcal{C} \). To model friction, we recall the Coulomb inequality at contact \( i \):

\[ \mathbf{f}_i = f_{n,i} \mathbf{n}_i + f_{t,i}\mathbf{t}_i,\quad f_{n,i} \ge 0,\quad |f_{t,i}| \le \mu_i f_{n,i}, \]

which defines a friction cone in force space. A common approximation is to replace this cone by a polyhedral cone spanned by a small number of boundary directions. For two-sided linearization in the plane:

\[ \phi_i = \arctan(\mu_i),\quad \mathbf{d}_i^{(1)} = \cos\phi_i\,\mathbf{n}_i + \sin\phi_i\,\mathbf{t}_i, \quad \mathbf{d}_i^{(2)} = \cos\phi_i\,\mathbf{n}_i - \sin\phi_i\,\mathbf{t}_i. \]

Using these primitive directions in the construction of \( G \) gives a polyhedral approximation of the wrench cone.

Let \( q \in \mathbb{R}^n \) be the configuration of the object (e.g., \( n=3 \) for planar pose), and let each unilateral contact constraint be described by a smooth gap function \( g_i(q) \ge 0 \). At a configuration \( q_0 \) with active contacts \( g_i(q_0) = 0 \), the linearization of the constraint is

\[ \dot{g}_i(q_0) = \nabla g_i(q_0)^\mathsf{T}\dot{q} = \mathbf{a}_i^\mathsf{T}\dot{q}, \quad \mathbf{a}_i = \nabla g_i(q_0). \]

Feasible instantaneous motions (allowing separation but not penetration) must satisfy \( \dot{g}_i(q_0) \ge 0 \) for all active contacts:

\[ \mathcal{V} = \bigl\{\dot{q} \in \mathbb{R}^n \,\bigm|\, A\dot{q} \ge 0 \bigr\},\quad A = \begin{bmatrix} \mathbf{a}_1^\mathsf{T} \\ \vdots \\ \mathbf{a}_k^\mathsf{T} \end{bmatrix}. \]

Definition (First-order form closure). A configuration \( q_0 \) is in first-order form closure if the only admissible velocity is \( \dot{q} = \mathbf{0} \), i.e., \( \mathcal{V} = \{\mathbf{0}\} \).

This has a dual characterization via Farkas' lemma / Gordan's theorem.

\[ \mathcal{V} = \{\mathbf{0}\} \quad\Longleftrightarrow\quad \exists\,\boldsymbol{\lambda} \in \mathbb{R}^k_{\gt 0}\ \text{s.t.}\ A^\mathsf{T}\boldsymbol{\lambda} = \mathbf{0}. \]

Sketch of proof. If such \( \boldsymbol{\lambda} \) exists, then for any admissible velocity \( \dot{q} \):

\[ 0 = \boldsymbol{\lambda}^\mathsf{T} A \dot{q} = \sum_{i=1}^k \lambda_i \mathbf{a}_i^\mathsf{T}\dot{q}. \]

But each term satisfies \( \mathbf{a}_i^\mathsf{T}\dot{q} \ge 0 \) and \( \lambda_i \gt 0 \), so the sum is zero only if \( \mathbf{a}_i^\mathsf{T}\dot{q} = 0 \) for all \( i \). Under generic conditions, this implies \( \dot{q} = \mathbf{0} \). Conversely, if \( \mathcal{V} = \{\mathbf{0}\} \), then by a separation argument in convex analysis, there must exist a strictly positive dual vector \( \boldsymbol{\lambda} \) satisfying the equality.

For planar rigid bodies, dimension \( n = 3 \), so we need at least four frictionless point contacts in general position to obtain form closure. This follows from the requirement that the normals define inequalities whose only common feasible velocity is the origin.

Recall the grasp map \( \mathbf{w} = G\boldsymbol{\alpha} \), where columns of \( G \) are primitive wrenches and \( \boldsymbol{\alpha} \ge 0 \) are nonnegative coefficients respecting unilateral constraints. Let the external wrench on the object be \( \mathbf{w}_{\text{ext}} \). Static equilibrium requires

\[ G\boldsymbol{\alpha} + \mathbf{w}_{\text{ext}} = \mathbf{0},\quad \boldsymbol{\alpha} \ge 0. \]

Definition (Force closure). A grasp is in force closure if for every external wrench \( \mathbf{w}_{\text{ext}} \in \mathbb{R}^d \) there exists a feasible contact force vector \( \boldsymbol{\alpha} \ge 0 \) satisfying the above equation, within prescribed force bounds.

Let the feasible wrench cone be \( \mathcal{C} = \{G\boldsymbol{\alpha} \mid \boldsymbol{\alpha} \ge 0\} \). The condition can be restated geometrically:

\[ \text{Force closure} \quad\Longleftrightarrow\quad \mathbf{0} \in \operatorname{int}(\mathcal{C}), \]

i.e., the origin lies in the interior of the convex cone generated by the primitive wrenches. Indeed, if this holds, then there exists \( \rho > 0 \) such that the closed ball \( B(\mathbf{0},\rho) \) is contained in \( \mathcal{C} \). For any external wrench \( \mathbf{w}_{\text{ext}} \), we can scale it and use the conic property to find \( \mathbf{w} \in \mathcal{C} \) with \( \mathbf{w} = -\mathbf{w}_{\text{ext}} \).

A useful algebraic criterion in the planar case (\( d = 3 \)) is:

\[ \text{Force closure in } \mathbb{R}^3 \quad\Longleftrightarrow\quad \operatorname{rank}(G) = 3\ \text{and}\ \exists\,\boldsymbol{\alpha} \in \mathbb{R}^M_{\gt 0} \ \text{s.t.}\ G\boldsymbol{\alpha} = \mathbf{0}. \]

The rank condition ensures that the cone spans all wrench directions, and the strictly positive coefficients enforce that the origin is in the interior rather than on the boundary. In practice, we approximate the condition \( \boldsymbol{\alpha} \gt \mathbf{0} \) by imposing lower bounds \( \alpha_i \ge \varepsilon \) for some small \( \varepsilon > 0 \).

Note the close analogy to form closure: in the twist space formulation, form closure corresponds to the absence of nonzero feasible twists; force closure corresponds, in the dual wrench space, to the ability to generate a cone around the origin.

For a planar grasp with point contacts and friction, a common pipeline for testing force closure is:

1. Linearize each friction cone into a small set of primitive force directions.
2. Build the wrench matrix \( G \) using the primitive directions.
3. Check that \( \operatorname{rank}(G) = 3 \) (for planar motion).
4. Solve a feasibility linear program to find \( \boldsymbol{\alpha} \) such that \( G\boldsymbol{\alpha} = \mathbf{0} \), \( \alpha_i \ge \varepsilon \), and \( \sum_i \alpha_i = 1 \).

The additional constraint \( \sum_i \alpha_i = 1 \) simply normalizes \( \boldsymbol{\alpha} \) and turns the cone into a convex hull of the normalized wrenches. The lower bounds \( \alpha_i \ge \varepsilon \) enforce interiority.

flowchart TD
  S["Contacts (p_i, n_i, mu_i)"] --> L["Linearize friction cones into directions d_j"]
  L --> G["Build wrench matrix G from p_i and d_j"]
  G --> R["Check rank(G) == 3"]
  R -->|false| NF["Not force-closure \n(cone not full-dimensional)"]
  R -->|true| LP["Solve LP: G * alpha = 0, sum(alpha) = 1, alpha >= eps"]
  LP -->|feasible| FC["Force-closure"]
  LP -->|infeasible| NFA["Not force-closure"]
        

We now implement this test in several programming environments commonly used in robotics.

We implement a planar force-closure test using numpy and scipy.optimize.linprog. The function assumes 2D contact locations and normals, and a scalar friction coefficient \( \mu \) for all contacts for simplicity.

import numpy as np
from math import atan, cos, sin
from scipy.optimize import linprog

def friction_directions_2d(n, mu):
    """
    Given a 2D unit normal n (pointing into the object) and scalar friction
    coefficient mu, return two unit vectors approximating the friction cone
    boundaries in the contact frame.
    """
    # Tangent vector (2D): rotate normal by +90 degrees
    t = np.array([-n[1], n[0]])
    phi = atan(mu)
    d1 = cos(phi) * n + sin(phi) * t
    d2 = cos(phi) * n - sin(phi) * t
    return [d1, d2]

def build_wrench_matrix_2d(positions, normals, mu):
    """
    positions: list of 2D np.array([x, y])
    normals:   list of unit 2D np.array for each contact
    mu:        scalar friction coefficient
    returns:   G in R^{3 x M}
    """
    wrenches = []
    for p, n in zip(positions, normals):
        dirs = friction_directions_2d(n, mu)
        for d in dirs:
            # primitive force direction d at contact p
            fx, fy = d[0], d[1]
            x, y = p[0], p[1]
            m = x * fy - y * fx  # planar moment about origin
            w = np.array([fx, fy, m])
            wrenches.append(w)
    G = np.stack(wrenches, axis=1)  # shape (3, M)
    return G

def is_force_closure_2d(positions, normals, mu, eps=1e-4):
    """
    Test force closure for planar object using LP:
      find alpha >= eps, sum(alpha) = 1, G alpha = 0.
    Returns True if LP is feasible and rank(G) == 3.
    """
    G = build_wrench_matrix_2d(positions, normals, mu)
    m, M = G.shape

    # Rank condition
    if np.linalg.matrix_rank(G) < 3:
        return False

    # LP: minimize 0 subject to A_eq * alpha = b_eq, bounds
    A_eq = np.vstack([G, np.ones((1, M))])  # shape (4, M)
    b_eq = np.zeros(m + 1)
    b_eq[-1] = 1.0  # sum(alpha) = 1

    c = np.zeros(M)
    bounds = [(eps, None) for _ in range(M)]

    res = linprog(c, A_eq=A_eq, b_eq=b_eq, bounds=bounds, method="highs")
    return res.success

if __name__ == "__main__":
    # Example: 3-finger planar grasp on a circle of radius 1
    positions = [
        np.array([1.0, 0.0]),
        np.array([-0.5, np.sqrt(3) / 2.0]),
        np.array([-0.5, -np.sqrt(3) / 2.0])
    ]
    # outward normals pointing roughly outward from the circle
    normals = [p / np.linalg.norm(p) for p in positions]
    mu = 0.8

    fc = is_force_closure_2d(positions, normals, mu)
    print("Force closure:", fc)
      

This code uses a simple two-direction approximation of the friction cone per contact. Increasing the number of directions improves accuracy but increases the number of variables in the LP.

In C++, the Eigen library is widely used for linear algebra in robotics (e.g., in ROS, Drake, Pinocchio). Below is a planar grasp matrix builder. For linear programming, one can interface with solvers such as qpOASES, OSQP, or GLPK; here we only sketch the LP call.

#include <Eigen/Dense>
#include <vector>
#include <cmath>

struct Contact2D {
    Eigen::Vector2d p;  // position
    Eigen::Vector2d n;  // inward unit normal
};

std::vector<Eigen::Vector2d> frictionDirections2D(
    const Eigen::Vector2d& n, double mu)
{
    std::vector<Eigen::Vector2d> dirs;
    Eigen::Vector2d t(-n.y(), n.x());  // tangent
    double phi = std::atan(mu);
    Eigen::Vector2d d1 = std::cos(phi) * n + std::sin(phi) * t;
    Eigen::Vector2d d2 = std::cos(phi) * n - std::sin(phi) * t;
    dirs.push_back(d1);
    dirs.push_back(d2);
    return dirs;
}

Eigen::MatrixXd buildWrenchMatrix2D(
    const std::vector<Contact2D>& contacts, double mu)
{
    std::vector<Eigen::Vector3d> wcols;
    for (const auto& c : contacts) {
        auto dirs = frictionDirections2D(c.n, mu);
        for (const auto& d : dirs) {
            double fx = d.x();
            double fy = d.y();
            double x = c.p.x();
            double y = c.p.y();
            double m = x * fy - y * fx;
            wcols.emplace_back(fx, fy, m);
        }
    }
    Eigen::MatrixXd G(3, static_cast<int>(wcols.size()));
    for (int j = 0; j < static_cast<int>(wcols.size()); ++j) {
        G.col(j) = wcols[j];
    }
    return G;
}

// Pseudo-code: call external LP solver to check feasibility:
//   minimize 0
//   subject to G * alpha = 0, sum(alpha) = 1, alpha_i >= eps.
//
// bool isForceClosure2D(const std::vector<Contact2D>& contacts,
//                       double mu, double eps = 1e-4)
// {
//     Eigen::MatrixXd G = buildWrenchMatrix2D(contacts, mu);
//     if (Eigen::FullPivLU<Eigen::MatrixXd>(G).rank() < 3)
//         return false;
//
//     int M = static_cast<int>(G.cols());
//     // Build LP matrices for your solver of choice.
//     // A_eq = [G; 1^T], b_eq = [0; 1],
//     // bounds: alpha_i in [eps, +inf).
//     // Solve and return true if feasible.
// }
      

In a full implementation, the LP assembly would be followed by a call to a numerical solver. The pattern mirrors the Python implementation, but uses Eigen::MatrixXd for all matrix operations.

For Java-based robotics stacks (or for Android-based robot systems), the EJML library provides dense linear algebra. Below we show construction of the planar grasp matrix. As before, the LP step is sketched; in practice, one would connect to a Java LP/QP solver.

import org.ejml.data.DMatrixRMaj;
import org.ejml.dense.row.CommonOps_DDRM;
import java.util.ArrayList;
import java.util.List;

class Contact2D {
    public double x, y;
    public double nx, ny;
    public Contact2D(double x, double y, double nx, double ny) {
        this.x = x; this.y = y; this.nx = nx; this.ny = ny;
    }
}

public class ForceClosure2D {

    public static List<double[]> frictionDirections2D(double nx, double ny, double mu) {
        List<double[]> dirs = new ArrayList<>();
        double tx = -ny;
        double ty = nx;
        double phi = Math.atan(mu);
        double cos = Math.cos(phi);
        double sin = Math.sin(phi);
        // d1
        dirs.add(new double[]{cos * nx + sin * tx, cos * ny + sin * ty});
        // d2
        dirs.add(new double[]{cos * nx - sin * tx, cos * ny - sin * ty});
        return dirs;
    }

    public static DMatrixRMaj buildWrenchMatrix2D(
            List<Contact2D> contacts, double mu)
    {
        List<double[]> cols = new ArrayList<>();
        for (Contact2D c : contacts) {
            for (double[] d : frictionDirections2D(c.nx, c.ny, mu)) {
                double fx = d[0];
                double fy = d[1];
                double m = c.x * fy - c.y * fx;
                cols.add(new double[]{fx, fy, m});
            }
        }
        int M = cols.size();
        DMatrixRMaj G = new DMatrixRMaj(3, M);
        for (int j = 0; j < M; ++j) {
            double[] w = cols.get(j);
            G.set(0, j, w[0]);
            G.set(1, j, w[1]);
            G.set(2, j, w[2]);
        }
        return G;
    }

    // Rank test using SVD or QR can be implemented via EJML.
    public static boolean isFullRank3(DMatrixRMaj G) {
        // Placeholder: use SingularOps_DDRM.rank() in a real implementation.
        return true;
    }

    public static void main(String[] args) {
        List<Contact2D> contacts = new ArrayList<>();
        contacts.add(new Contact2D(1.0, 0.0, 1.0, 0.0));
        contacts.add(new Contact2D(-0.5, Math.sqrt(3.0) / 2.0, -0.5,
                                   Math.sqrt(3.0) / 2.0));
        contacts.add(new Contact2D(-0.5, -Math.sqrt(3.0) / 2.0, -0.5,
                                   -Math.sqrt(3.0) / 2.0));

        double mu = 0.8;
        DMatrixRMaj G = buildWrenchMatrix2D(contacts, mu);
        boolean fullRank = isFullRank3(G);
        System.out.println("Rank test (placeholder): " + fullRank);

        // LP step omitted; use a Java LP solver to complete the test.
    }
}
      

Java-based simulation environments (e.g., custom robot simulators, some industrial stacks) can integrate this computation into grasp-synthesis pipelines in a similar way to Python or C++.

MATLAB is a traditional environment for robotics and control. Its linprog function solves linear programs, and Simulink can call MATLAB functions via MATLAB Function blocks.

function fc = isForceClosure2D(positions, normals, mu, eps)
% positions: N x 2 (x,y)
% normals:   N x 2 (nx,ny), inward unit normals
% mu:        scalar friction coefficient
% eps:       minimum alpha (interiority); default 1e-4

if nargin < 4
    eps = 1e-4;
end

N = size(positions, 1);
wcols = [];

for i = 1:N
    p = positions(i, :).';
    n = normals(i, :).';
    t = [-n(2); n(1)];
    phi = atan(mu);
    d1 = cos(phi) * n + sin(phi) * t;
    d2 = cos(phi) * n - sin(phi) * t;
    dirs = [d1, d2];
    for j = 1:2
        d = dirs(:, j);
        fx = d(1); fy = d(2);
        x = p(1); y = p(2);
        m = x * fy - y * fx;
        wcols = [wcols, [fx; fy; m]]; %#ok<AGROW>
    end
end

G = wcols;                % 3 x M
[~, s, ~] = svd(G);
rankG = sum(diag(s) > 1e-8);

if rankG < 3
    fc = false;
    return;
end

[m, M] = size(G);
Aeq = [G; ones(1, M)];
beq = [zeros(m, 1); 1];

f = zeros(M, 1);
lb = eps * ones(M, 1);
ub = [];  % no upper bounds

options = optimoptions("linprog", ...
    "Algorithm", "dual-simplex", ...
    "Display", "none");

[alpha, ~, exitflag] = linprog(f, [], [], Aeq, beq, lb, ub, options);
fc = (exitflag == 1);
end
      

In Simulink, a MATLAB Function block can call isForceClosure2D during simulation, enabling online checking of grasp robustness as contacts move on the object surface.

Mathematica provides symbolic and numeric optimization. The code below constructs a planar wrench matrix and uses LinearProgramming to test force closure.

Clear[frictionDirections2D, buildWrenchMatrix2D, isForceClosure2D];

frictionDirections2D[n_List, mu_] := Module[
  {t, phi, d1, d2},
  t = {-n[[2]], n[[1]]};
  phi = ArcTan[mu];
  d1 = Cos[phi] n + Sin[phi] t;
  d2 = Cos[phi] n - Sin[phi] t;
  {d1, d2}
];

buildWrenchMatrix2D[positions_List, normals_List, mu_] := Module[
  {cols = {}, p, n, dirs, d, fx, fy, x, y, m},
  Do[
    p = positions[[i]];
    n = normals[[i]];
    dirs = frictionDirections2D[n, mu];
    Do[
      d = dirs[[j]];
      fx = d[[1]]; fy = d[[2]];
      x = p[[1]]; y = p[[2]];
      m = x fy - y fx;
      AppendTo[cols, {fx, fy, m}],
      {j, 1, Length[dirs]}
    ],
    {i, 1, Length[positions]}
  ];
  Transpose[cols]
];

isForceClosure2D[positions_List, normals_List, mu_, eps_: 10^-4] := Module[
  {G, m, M, rankG, Aeq, beq, c, bounds, alpha, res},
  G = buildWrenchMatrix2D[positions, normals, mu];
  {m, M} = Dimensions[G];

  rankG = MatrixRank[G];
  If[rankG < 3, Return[False]];

  (* Aeq . alpha == beq: [G; 1^T] alpha == [0; 1] *)
  Aeq = Join[G, ConstantArray[1, {1, M}]];
  beq = Join[ConstantArray[0, m], {1}];

  c = ConstantArray[0, M];

  (* LinearProgramming in Mathematica solves:
     Minimize[ c . alpha, A alpha >= b, alpha >= 0 ]
     To emulate equality, we can solve for null space and normalization,
     or use FindInstance. For simplicity, use FindInstance: *)
  alpha = FindInstance[
    And[
      Aeq . Array[a, M] == beq,
      And @@ Thread[Array[a, M] >= eps]
    ],
    Array[a, M],
    Reals
  ];

  alpha = Array[a, M] /. alpha;
  alpha = Flatten[alpha];
  If[alpha === {}, False, True]
];

(* Example usage *)
positions = { {1.0, 0.0}, {-0.5, Sqrt[3]/2.0}, {-0.5, -Sqrt[3]/2.0} };
normals = Map[#/Norm[#] &, positions];
mu = 0.8;
isForceClosure2D[positions, normals, mu]
      

Mathematica is particularly useful when exploring symbolic conditions for form and force closure for simple shapes (e.g., polygons, ellipses) before implementing numeric tests in other languages.

Problem 1 (Necessary Conditions for Planar Form Closure). Consider a rigid body in the plane with frictionless point contacts modeled as unilateral constraints. Show that at least four contacts in general position are required to achieve first-order form closure.

Solution. In the planar case, the configuration space of the object has dimension \( n = 3 \). Each active unilateral constraint contributes an inequality \( \mathbf{a}_i^\mathsf{T}\dot{q} \ge 0 \). Suppose we have only three contacts. Then \( A \in \mathbb{R}^{3\times 3} \). If the three rows are linearly independent, the system \( A\dot{q} \ge 0 \) defines a pointed cone in \( \mathbb{R}^3 \) with nonempty interior containing nonzero velocities (e.g., small motions along an extreme ray). Hence \( \mathcal{V} \neq \{\mathbf{0}\} \), and form closure is impossible. To make \( \mathcal{V} = \{\mathbf{0}\} \), we must enforce enough inequalities so that every nonzero direction violates at least one constraint. In general position, this requires at least four inequalities in \( \mathbb{R}^3 \), corresponding to four contacts. More formally, the polar cone of \( \mathcal{V} \) is generated by the normals \( \mathbf{a}_i \). To make \( \mathcal{V} = \{\mathbf{0}\} \), the polar cone must be full-dimensional and contain a strictly positive combination of the normals summing to zero, which generically requires at least \( n+1 = 4 \) generators.

Problem 2 (Constructing a Form-Closure Grasp). Consider a convex planar object with four frictionless contacts placed at distinct points on its boundary. Give a geometric condition on the outward normals that guarantees first-order form closure and justify it.

Solution. Let outward unit normals at the four contacts be \( \mathbf{n}_1,\dots,\mathbf{n}_4 \in \mathbb{R}^2 \), and let the corresponding twist-space normals be \( \mathbf{a}_i \in \mathbb{R}^3 \). A sufficient condition for form closure is that the convex cone generated by \( \{\mathbf{a}_i\} \) contains a nondegenerate balanced combination:

\[ \exists\,\boldsymbol{\lambda} \in \mathbb{R}^4_{\gt 0} \ \text{s.t.}\ \sum_{i=1}^4 \lambda_i \mathbf{a}_i = \mathbf{0}. \]

Geometrically, this holds when the contact normals “surround” the object so that no line in twist space can separate them into a strictly positive and strictly negative half-space. In practice, one chooses contacts so that the outward normals interleave around the boundary and their corresponding support lines in the plane form a closed polygon containing the object. Under this condition, every nonzero twist violates at least one unilateral constraint, giving form closure.

Problem 3 (Force Closure via Wrench Cone). Let \( G \in \mathbb{R}^{3\times M} \) be the wrench matrix of a planar grasp with primitive wrenches \( \mathbf{w}_j \) as columns. Show that if there exist coefficients \( \boldsymbol{\alpha} \in \mathbb{R}^M_{\gt 0} \) such that \( G\boldsymbol{\alpha} = \mathbf{0} \) and \( \operatorname{rank}(G) = 3 \), then the grasp is in force closure.

Solution. The condition \( \operatorname{rank}(G) = 3 \) implies that the cone \( \mathcal{C} = \{ G\boldsymbol{\beta} \mid \boldsymbol{\beta} \ge 0\} \) spans the entire \( \mathbb{R}^3 \). The existence of \( \boldsymbol{\alpha} \gt \mathbf{0} \) with \( G\boldsymbol{\alpha} = \mathbf{0} \) implies that the origin lies in the interior of \( \mathcal{C} \): any supporting hyperplane at the origin would have nonnegative inner product with all generators, contradicting the strictly positive combination summing to zero. Because \( \mathcal{C} \) is a full-dimensional cone containing the origin in its interior, its negative \( -\mathcal{C} \) is also full-dimensional and contains a neighborhood of the origin. Given any external wrench \( \mathbf{w}_{\text{ext}} \), we can scale it so that \( -\mathbf{w}_{\text{ext}} \in \mathcal{C} \), and hence find \( \boldsymbol{\beta} \ge 0 \) with \( G\boldsymbol{\beta} = -\mathbf{w}_{\text{ext}} \). This is precisely the force-closure condition.

Problem 4 (Checking Force Closure of a Three-Finger Grasp). In the plane, consider three fingers in an equilateral arrangement on a circle of radius 1, with contact positions \( \mathbf{p}_1 = (1,0)^\top \), \( \mathbf{p}_2 = (-\tfrac{1}{2},\tfrac{\sqrt{3}}{2})^\top \), and \( \mathbf{p}_3 = (-\tfrac{1}{2},-\tfrac{\sqrt{3}}{2})^\top \). Normals point radially inward, and all contacts share friction coefficient \( \mu = 0.5 \). Argue (without solving an LP) that this grasp is a good candidate for force closure.

Solution. The three contact normals are at angles separated by \( 120^\circ \), symmetrically placed around the circle. The linearized friction cones at each contact expand the coverage in force direction space, providing multiple tangent directions. The resulting primitive wrenches (forces plus moments) include both roughly opposing pairs and moment-generating directions because the contact positions are noncollinear. Symmetry suggests that the convex cone generated by these wrenches is full-dimensional and surrounds the origin. A rigorous check would build \( G \) and verify rank 3. Because each contact contributes at least two linearly independent wrench directions and the geometry is symmetric, it is extremely unlikely that all wrenches lie in a proper subspace of \( \mathbb{R}^3 \). Thus the grasp is a strong candidate for force closure, confirmed by explicit computation (e.g., with the Python or MATLAB functions above).

Problem 5 (Comparing Form and Force Closure). Consider the same three-finger planar grasp from Problem 4, but assume the contacts are frictionless. Does the grasp have form closure? Does it have force closure? Explain qualitatively in terms of the normals and friction cones.

Solution. With frictionless contacts, only normal forces are allowed: each contact supports force along its inward normal, and there is no tangential component. The three inward normals are separated by \( 120^\circ \). The convex cone generated by these three normal forces in force space is two-dimensional and does not contain directions corresponding to pure torque or certain lateral forces; hence the wrench cone in \( \mathbb{R}^3 \) is not full-dimensional and cannot be force-closure. However, the three normals may still constrain translational motion of the center of mass; the remaining degree of freedom corresponds roughly to a rotation that rolls the object around the fingers without interpenetrating the contacts. Thus the grasp fails both force closure and form closure in the frictionless case, but becomes a good candidate for force closure when friction is included, as in Problem 4. This highlights the distinction between purely geometric immobilization (form closure) and friction-assisted immobilization (force closure).

In this lesson we formalized form closure as the absence of admissible nonzero object velocities under linearized unilateral constraints and force closure as the ability of feasible contact forces to generate a full-dimensional wrench cone containing the origin in its interior. Using contact kinematics, we expressed form closure in twist space via inequalities \( A\dot{q} \ge 0 \) and dual certificates \( A^\mathsf{T}\boldsymbol{\lambda} = \mathbf{0} \) with positive multipliers, while force closure was expressed via the grasp map \( \mathbf{w} = G\boldsymbol{\alpha} \) and the conic geometry of \( \mathcal{C} = \{G\boldsymbol{\alpha} \mid \boldsymbol{\alpha} \ge 0\} \). We developed a practical planar test for force closure using linearized friction cones and linear programming, and implemented it in Python, C++, Java, MATLAB, Simulink, and Mathematica. These constructions provide the mathematical backbone for the grasp wrench spaces and quantitative quality metrics studied in the next lesson.