The closed-loop coupled-block field , once — TARGET G2 (infrastructure)

Seal

Rung rung-2 · Status interfaced — axiom-clean (#print axioms verbatim in 8. The machine seal; build 2643 jobs), with the operator hypotheses hMsa/hKsa/hMinv/hJadj as named interfaces. Discharges the g2 coordinate field that reduction_cascade and stiffness_residual had to leave un-formalized — as a constant-operator field; the moving-metric calculus (hreal/hfield) stays with the downstream lanes. See interfaces. Public definitions: CoupledState, g2Field, coupledEnergy.
Links: module index · interface ledger · related com_lasalle, coupled_dissipation, coupled_collapse, passivity_transport · source giordano2019coordinated · pin pin_g2_field.py

Sealed theorems

g2Field_origin

— the origin is an equilibrium of the coupled block.

coupledEnergy_origin

.

coupledEnergy_differentiable

The storage function is — the quadratic form of continuous operators is smooth.

coupledEnergy_fderiv

The reusable stone: for any direction .

coupledEnergy_fderiv_field

The frozen field form: — the state-space partial, not a stability claim.

What this seals, in one paragraph

Prop IV.1’s cascade (Giordano 2019 RA-L, §IV.D) proves stability in two steps: step 1 is the autonomous CoM driver (sealed in ComLaSalle), step 2 is the driven coupled block evaluated on the driver-zeroed manifold . Every downstream stability lane — the dissipation (hdec), the LaSalle collapse v̆≡0⇒x̃=0 (whose algebra StiffnessResidual already sealed) — differentiates the same storage function along the same field . This module defines that field and that storage function once, in Lean, with the well-formedness and the fderiv-friendly derivative lemma the downstream lanes consume. It makes no stability claim: the sign-definiteness is deliberately left to the hdec lane, because it is the total time derivative and needs the time-varying-inertia term plus the sealed passivity identity (§5). What is proved here is the field, its equilibrium at the origin, the energy’s smoothness, and the exact algebraic derivative — the shared substrate, frozen against a SymPy pin before a single Lean symbol was written.

The module is (/Code/vault/lean/CoupledField.lean), build copy ~/lean/leanpunov/Leanpunov/CoupledField.lean. SymPy pin (/Code/vault/lean/pin_g2_field.py).

1. The mathematical object

Work on a real inner-product space (the reduced coupled space; in the thesis — and are both -vectors — but nothing here fixes a dimension). Following the brief’s ordering the state is , so (the stacked outer-loop error) and (the stacked attitude+EE velocity). The seven operators are continuous linear maps (M C D K J Minv Jadj in the Lean).

The field. On the singularity-free region, with the CoM driver zeroed ( on , so the forcing of eq 4.10 vanishes), the coupled block

(current_sota.md eq 26 + eq 4.10 / Giordano eq 34b) is the first-order field

The storage function is the mechanical energy (eq 37 / eq 4.15)

Only the inverse and the adjoint enter the field (not itself); they are supplied operators carrying their defining identities as named hypotheses — hMinv: , and hJadj: . This is the exact ComLaSalle precedent (there was Minv + hMinv), and it keeps the module on a bare inner-product space with no CompleteSpace/adjoint machinery. For a concrete symmetric-PosDef matrix on EuclideanSpace, hMinv is Matrix.nonsingularInverse and hJadj is the standard via Matrix.toEuclideanCLM.

2. Choice of formulation, and why

The brief allows an abstract inner-product space or a concrete EuclideanSpace with matrix operators, “whichever lets the NEXT lane compute fderiv V along the field cleanly.” I chose the abstract inner-product-space formulation, byte-for-byte parallel to ComLaSalle (ComState H = H × H, comField, comEnergy). Reasons:

  1. The next lane’s core computation is , a Fréchet derivative of a bilinear form. Mathlib’s fderiv_inner_apply is stated on an inner-product space and there is a live in-repo precedent (ComLaSalle.com_dissipation) that this route closes cleanly. A matrix mulVec formulation would force the derivative through Matrix.toEuclideanCLM/WithLp bookkeeping (the rung-1 gotcha: EuclideanSpace elements are not defeq to n → ℝ).
  2. The stiffness algebra it eventually feeds — StiffnessResidual — is already sealed at matrix level, so nothing downstream needs to be matrix-shaped; the two meet at the interface, not inside this field.
  3. Dimension-freeness: the same field serves the -dim thesis block and any sub-block without re-statement.

State ordering follows the brief: , i.e. position first, velocity second — the transpose of ComLaSalle’s . So here the -block sits on the second projection and the -block on the first; every fst/snd in the Lean is swapped relative to ComLaSalle.

3. The SymPy pin (frozen before the Lean)

pin_g2_field.py verifies four facts; the field definition was frozen only after all four passed.

(1) Total-derivative identity (the house derivation, current_sota eq 38). With time-varying and symmetric,

Substituting the dynamics: (the collapse, symmetry-blind), and . The two stiffness cross terms and cancel because is symmetric and is the adjoint of — this is the “cross-term bookkeeping” the brief names. What remains is . Pinned symbolic (simplify → 0) and numeric (residual ).

(2) State-space partial — the exact Lean field lemma, no term:

Same cross-term cancellation, gradient with held constant. Pinned symbolic .

(3) (numeric, exact zero). (4) symmetry is load-bearing for the gradient’s half-term collapse : with the honest gradient , dropping symmetry leaves a residual that vanishes iff (symbolic , nonzero). Note the subtlety the pin exposed: the term in the field is symmetry-blind; symmetry is used only in collapsing the storage-form gradient, i.e. exactly where hMsa enters the Lean.

4. The Lean, theorem by theorem

g2Field_origin : . Pure linearity — map_zero on every operator, no hypotheses. The origin is an equilibrium of the coupled block, the target of the whole stability argument.

coupledEnergy_origin : , and coupledEnergy_differentiable : — the quadratic form of continuous operators is smooth (differentiableAt_fst/snd, ContinuousLinearMap.differentiableAt, .inner, .const_mul, .add), verbatim the comEnergy_differentiable pattern with the block projections swapped.

coupledEnergy_fderiv (the reusable stone). For symmetric and any direction ,

Route. splits as ; each block’s Fréchet derivative is fderiv_inner_apply composed through the continuous projections (hasFDerivAt_fst/snd) and the operators, assembled by fderiv_add/fderiv_const_mul. fderiv_inner_apply produces, per block, the symmetric pair ; the reversed term collapses by (hMsa/hKsa then real_inner_comm), and the two halves sum to drop the . This is the general-direction generalization of com_dissipation’s internal computation, kept direction-free so the hdec lane can instantiate it both at (below) and at the time-varying- correction direction that carries the term.

coupledEnergy_fderiv_field (the frozen field form). Instantiating and using hMinv + hJadj,

Route. (map_neg, hMinv, inner_neg_right, inner_add_right), and (hKsa, real_inner_comm, hJadj); the shared cancels and ring closes. This is the state-space partial the pin froze — not a stability claim: the surviving Coriolis term is sign-indefinite.

5. Interfaces, honestly (ponytail)

Proved outright: the field, its equilibrium, the energy’s smoothness, and both derivative lemmas (§4). The following are named, never sorry — the ComLaSalle/IsSolutionTo precedent:

  • The dissipation (eq 38) is the hdec lane’s, not this module’s. The field lemma gives the state-space partial . The total time derivative along a trajectory adds because is configuration-dependent. Giordano eq 23 passivity — the sealed Leanpunov.passivity_identity and Leanpunov.transported_passivity_identity (the latter producing the factorization by congruence transport) — gives , exactly cancelling the surviving Coriolis term to leave . Both the time-varying- curve and this cancellation are the hdec lane’s work, named here, mathematically pinned in §3(1).
  • hMinv, hJadj and as supplied operators with their defining identities. Discharged for a concrete SPD matrix on EuclideanSpace by Matrix.nonsingularInverse and the toEuclideanCLM adjoint fact.
  • hMsa, hKsa — symmetry of . For concrete SPD blocks these are theorems (Matrix.PosDef.isHermitian), not assumptions; pinned load-bearing in §3(4).
  • No flow / IsSolutionTo here. This module is a static vector field, so it needs no Flow/precompactness interface. Those enter only when the hdec and LaSalle lanes wire into the sealed lasalle engine — consuming coupledEnergy_fderiv_field (for the decrease), StiffnessResidual.stiffness_residual_injective' (for the collapse), and blockLyap_coercive (for boundedness).

6. Mathlib stones used

fderiv_inner_apply (derivative of an inner product), hasFDerivAt_fst/_snd, fderiv_add, fderiv_const_mul, ContinuousLinearMap.differentiableAt/.hasFDerivAt/.comp/.inner, ContinuousLinearMap.fst/snd/comp_apply/coe_fst'/coe_snd', real_inner_comm, inner_add_right, inner_neg_right, map_neg, map_zero. No sealed leanpunov stone is imported (this is upstream infrastructure); the §5 interfaces name the sealed stones that consume it (passivity_identity, transported_passivity_identity, stiffness_residual_injective', blockLyap_coercive) and the pattern it follows (ComLaSalle).

7. Cost feel

At the light end of an L2-scale push. Two of the five theorems (g2Field_origin, coupledEnergy_origin) are one-line simp; coupledEnergy_differentiable is a verbatim ComLaSalle transpose; coupledEnergy_fderiv is the direction-general lift of the com_dissipation computation; coupledEnergy_fderiv_field is a short corollary. One fix cycle (a single real_inner_comm argument order — the convention is , so the LHS carries the second argument first). Well inside the stall gate; the SymPy pin’s caught malformed symmetry test (§3(4)) was the only real thinking beyond transcription.

8. The machine seal

#print axioms on the five theorems, verbatim from the full-integration lake build (2643 jobs, 2026-07-06):

info: Leanpunov/CoupledField.lean:178:0: 'Leanpunov.g2Field_origin' depends on axioms: [propext, Classical.choice, Quot.sound]
info: Leanpunov/CoupledField.lean:179:0: 'Leanpunov.coupledEnergy_origin' depends on axioms: [propext, Classical.choice, Quot.sound]
info: Leanpunov/CoupledField.lean:180:0: 'Leanpunov.coupledEnergy_differentiable' depends on axioms: [propext, Classical.choice, Quot.sound]
info: Leanpunov/CoupledField.lean:181:0: 'Leanpunov.coupledEnergy_fderiv' depends on axioms: [propext, Classical.choice, Quot.sound]
info: Leanpunov/CoupledField.lean:182:0: 'Leanpunov.coupledEnergy_fderiv_field' depends on axioms: [propext, Classical.choice, Quot.sound]

Nothing beyond {propext, Classical.choice, Quot.sound}; no sorryAx. The full project (L1–L4a + TARGET 1 + rung-1 + G2, 29 public theorems) builds clean.