Skills DirectorySkills Directory
SkillsLearnSecurityCategoriesDocsBlogPro
Sign InSubmit Skill
Skills Directory

Security-tested agent skills for Claude, coding agents, and AI workflows.

Directory

  • Browse Skills
  • All Skills A–Z
  • Claude Skills
  • Claude Code Skills
  • Agent Skills
  • Categories
  • Authors
  • Submit a Skill

Learn

  • Learn Hub
  • Install Claude Skills
  • Write SKILL.md
  • Skills vs MCP
  • Directories Compared

Security

  • Security
  • Methodology
  • Secure Claude Skills
  • Security Badges
  • Chrome Extension
  • Skill Manager

Company

  • About
  • Community
  • Blog
  • API Docs
  • Advertise

2026 Skills Directory. All rights reserved.

ProTermsPrivacyRefunds
Back to skills

Reciprocity Mechanical Network Learning Floor

ASecurity

Symmetry sets untrainable error floors in physical nets.

3 stars
0 votes
0 copies
0 views
Added 10/3/2026
ai-agentsgonodespring

Works with

terminal

Security Analysis

A100/100

Scanned 10/3/2026

$npx -y skills add hiyenwong/ai_collection --skill reciprocity-mechanical-network-learning-floor --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of Reciprocity Mechanical Network Learning Floor?

Add the live security badge to your README — it updates automatically with every re-scan.

Security grade badge for Reciprocity Mechanical Network Learning Floor
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/hiyenwong-reciprocity-mechanical-network-learning-floor/badge)](https://www.skillsdirectory.com/skills/hiyenwong-reciprocity-mechanical-network-learning-floor)

More formats (shields.io, HTML) on the badges page. Keep it an A: scan every change in CI with Pro.

Download with Pro
Files
SKILL.md
---
name: reciprocity-mechanical-network-learning-floor
description: Symmetry sets untrainable error floors in physical nets.
category: ai_collection
trigger_words: reciprocity, Maxwell-Betti, mechanical network learning, physical learning, error floor, trainable metamaterial, spring network, compliance matrix, non-reciprocal coupling, odd coupling, wedge selection, sensor-actuator layout, directed response, robotic metamaterial
---

# Reciprocity Can Halve What a Mechanical Network Can Learn

Methodology from "Reciprocity can halve what a mechanical network can learn" (arXiv:2609.04169v4, cond-mat.soft, 25 Sep 2026; Thai-Son Vu, Hoang-Giang Nguyen, Quoc-Bao Nguyen, Sengaloun Keoalounxay, Bao-Viet Tran — Hanoi University of Civil Engineering et al.).

## When to Use
- Designing or analyzing trainable physical networks (spring/elastic, resistor, flow networks) where input and output terminals OVERLAP — predicting achievable vs impossible targets BEFORE training
- Computing error floors for in-material/physical learning hardware (directed aging, contrastive local rules, in-situ backprop, robotic metamaterials)
- Deciding sensor-actuator layout (full vs partial overlap) and whether non-reciprocal (odd-coupling/gyrator-like) elements are needed
- Theoretical analysis of learnability limits under symmetry constraints (applies to any symmetric response operator perturbed symmetrically — 2D/3D elasticity, resistor networks, flow networks, complex-symmetric operators)

## Core Law (Theorem 1: Capacity under Maxwell-Betti)
A passive, reciprocal, linear network (symmetric invertible K_f) driven by forces/currents at S (m_S terminals) and read at T (m_T terminals), with p = |S ∩ T| SHARED degrees of freedom, has its reachable response blocks inside a linear subspace of codimension **p(p−1)/2** — regardless of size, topology, or parameter count:
```
rank ∂R/∂k ≤ min( n_b ,  m_T·m_S − p(p−1)/2 )
```
- Full overlap (T=S, p=m): reachable dimension ≤ m(m+1)/2, so a fraction (m−1)/(2m) → **1/2 of the target space is unreachable** — hence "halve"
- The containment is GLOBAL and derivative-free: R(k) ∈ S_P for every admissible k (not just tangent space)
- Adding bonds CANNOT repair the symmetry branch (unlike the n_b bond-count branch)
- Holds with only symmetry + invertibility; positive definiteness not needed for Theorems 1-2

## Error Floor (Theorem 2 — compute BEFORE training)
For target response block R*, every training run satisfies:
```
‖R(k) − R*‖_F  ≥  ‖½(B − Bᵀ)‖_F
```
where B = R* restricted to the shared degrees of freedom. **The floor is the antisymmetric part of the target's shared block** — a number from the target alone.

Theorem 3 (with passivity, K_f ≻ 0): floor = √[ ¼‖B−Bᵀ‖²_F + Σᵢ min(λᵢ, 0)² ] where λᵢ are eigenvalues of the symmetric part B_s — passivity adds a PSD-cone term (shared block must be symmetric positive-definite).

## Verified: Learning Rules Stop ON the Floor
- Levenberg–Marquardt on log-stiffnesses, exact Jacobian, random independent starts: reaches within 0.1% of floor in **142/144** runs (forbidden targets with reachable symmetric part)
- **Contrastive coupled learning** (bond-local update: Δk_b ∝ Σⱼ[(e^free_b)² − (e^nudged_b)²], no Jacobian/no global loss gradient): median error/floor = 1.000001, **22/24** within 0.1% — a material could plausibly implement it, and it still cannot beat the floor
- Controls: allowed (SP ∩ reachable) perturbations → error → 0; odd couplings ON → error → 0 (floor disappears)

## Escape Route: Odd (Non-Reciprocal) Couplings (Theorem 16)
Odd couplings a_b on bonds add antisymmetric stiffness contributions. Each bond contributes a **wedge** z_b|_P ∧ w_b|_P (2-form in Λ²R^p) where w_b = Cq_b, z_b = Cs_b are passive response fields:
```
Π_AP im ∂R/∂(k,a) = span{ z_b ∧ w_b : b } ⊆ Λ²R^p
```
- Odd branch recovers ALL lost directions ⟺ the n_b wedges span Λ²R^p
- **Minimum count: p(p−1)/2 odd bonds** must contribute (wedges are single 2-form elements); at fixed k, three odd bonds can beat the count (at 40-node, m=p=5: 3 bonds realize 10⁻² relative antisymmetric block in 9/9 pairs, but not every triple works)
- **Selection BEFORE building**: vectorize each wedge's strictly-upper entries → wedge matrix W → **pivoted QR** selects p(p−1)/2 best-conditioned bonds (σ_min reports conditioning; rank-greedy is insufficient — near-parallel wedges fool it). Pivoted QR hits the optimal σ_min in median ratio 0.93 vs brute force
- 2D cancellation: bond direction/length drop out (SO(2) acts trivially on Λ²R²) — only which node pair a bond joins matters, conjugated by the compliance C; in 3D the transverse direction sweeps a 2-form family

## Price of Non-Reciprocity (Prop 18, Cor 19)
Any network realizing target B has non-reciprocity η(K) ≥ η(B) (ratio of odd to even parts, congruence-normalized) — the target itself bounds from below how non-reciprocal the hardware must be. Least-norm odd coupling: ‖a*‖₂ ≤ √2·‖B_a‖_F / σ_min(W) — maximizing σ_min of selected wedges = column-subset selection (strong rank-revealing QR approximates the optimum).

## Imposed-Displacement Drive (Theorem 10-11 — weaker law for the common hardware mode)
Most physical-learning hardware prescribes displacements, not forces. Reciprocity survives as:
- Exact balance: forward transmission / driving-point compliance at input = reverse transmission / its driving-point compliance (4 measurable scalars, testable on a black box)
- Rank cap on off-diagonal entries: ≤ min(n_b, ½(p−1)(p+2)) — at least (p−1)(p−2)/2 below the p(p−1) free entries
- Spectral inequality (Thm 11): **no symmetric positive-definite chain can meet both targets** of the published Du et al. robotic metamaterial (imposed-angle task) — their DOF count misses this entirely

## Layout Law (Prop 21)
- Fixed number of accessed DOF (each drivable AND readable), bond count not binding: **full overlap is optimal**, approaching factor 2
- Fixed sensor+actuator budget: full overlap is NOT best — split the terminals

## Task-List Form (Sec 3.4, Cor 8 — for labs, not idealized blocks)
Reciprocity charges a list of single drive–read tasks **only for pairs instrumented in BOTH directions**. A shared terminal alone costs nothing; a reversed pair is what pays. All 19 published physical-learning layouts tabulated: p = 0, deficit = 0 — no published force/current-driven in-place layout pays the price; a force-driven layout asking one pair to respond differently in two directions will.

## Decision Procedure (apply this pipeline)
```
1. Identify shared terminals P = S ∩ T, count p
2. Extract target's shared block B; floor₁ = ½‖B−Bᵀ‖_F (antisymmetric part)
3. If passive: add passivity term from negative eigenvalues of sym(B)
4. floor > tolerance? → need p(p−1)/2 odd couplings:
   a. Solve passive network: C = K_f⁻¹, compute w_b = Cq_b, z_b = Cs_b per bond
   b. Build wedge matrix W (vec of strictly-upper 2-form entries per bond)
   c. Pivoted QR on W → select bonds; check σ_min conditioning
   d. Budget: η(K) ≥ η(B) — check hardware can deliver required non-reciprocity
5. Imposed-displacement drive? Use Thm 10 balance test (4 terminal scalars) instead of block codimension
6. Task list only charges reversed pairs — audit which pairs you actually instrument bidirectionally
```

## Concrete Scale
16-node network, 3-task list + ONE reversed task → floor = 9.9% of target norm; one odd bond chosen in advance (rank test) removes it. Exact realization: Newton from a=0 at fixed k reaches prescribed antisymmetric block (10⁻⁴→10⁻¹ relative) in 336/336 configurations, ‖a‖/‖k₀‖ ≈ 2ε median.

## Scope & Limits
- Linear response regime (tangent response about finitely deformed states included via Sec 3.3)
- Floor is a LOWER bound; tight only when target's symmetric part is reachable (Sec 6 measures the gap; on arbitrary targets the passivity term accounts for most of it)
- Joint (k,a) solve outside a=0 neighborhood: symmetric part of K can lose positive definiteness at large odd coupling (115/336 at ε=10⁻¹) — Remark 11 governs the safe neighborhood
- Wedge-spanning is MEASURED (251/251 spanning configs), not proved generically; rationalization argument plausible but unverified

## Related Skills
- `mechanical-field-networks` — MFN learning (this skill explains WHY some MFN targets are unreachable)
- `kirchhoff-inspired-neural-networks` — KINN state-variable physical networks
- `thermodynamic-networks-computation` — autonomous physical learning systems
- `physics-guided-neural-network` — adjacent physical-learning theory

Attribution

hiyenwonghiyenwong
View sourceSee grades on GitHubMore from hiyenwong →
SSkills DirectorySkills Directory

Ship a skill? Prove it's safe.

Free 120-pattern security scan, letter grade, and an embeddable README badge.

Submit a skill

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

Comments (0)

No comments yet. Be the first to comment!

SSkills DirectorySkills Directory

Ship a skill? Prove it's safe.

Free 120-pattern security scan, letter grade, and an embeddable README badge.

Submit a skill

Related Skills

Caveman

Terse caveman voice: answer first, fluff gone, every technical fact kept. Use for /caveman, "caveman mode", "talk like caveman", "be brief", "less tokens". Stays on until "stop caveman" or "normal mode".

1100021 votes

Hyperplan

Adversarial multi-agent planning skill. Self-orchestrates 5 hostile category members (unspecified-low, unspecified-high, deep, ultrabrain, artistry) via team-mode for ruthless cross-critique debate, distills only the defensible insights, then MANDATORILY hands the distilled insight bundle to the `plan` agent for executable plan formalization. Use when planning needs maximum rigor and surfacing of weak assumptions, blind spots, and over-engineering. Triggers: 'hyperplan', 'hpp', '/hyperplan', ...

698461 votes

Writing Skills

Create and manage Claude Code skills in HASH repository following Anthropic best practices. Use when creating new skills, modifying skill-rules.json, understanding trigger patterns, working with hooks, debugging skill activation, or implementing progressive disclosure. Covers skill structure, YAML frontmatter, trigger types (keywords, intent patterns), UserPromptSubmit hook, and the 500-line rule. Includes validation and debugging with SKILL_DEBUG. Examples include rust-error-stack, cargo-dep...

3931 votes

Mcp Code Execution

Routes multi-tool workflows through MCP servers for large datasets and pipelines. Use when Bash tool overhead is limiting throughput on data-heavy tasks.

3421 votes

catchup

Recovers the conversation and failed tool calls of a previous Codex, Amp, Claude Code, Antigravity, Cline, Copilot CLI, Cursor, DeepSeek Harness, Grok Build, Kimi, OpenCode, Pi Agent, or ZCode session. Use when the user says "catch up", "what did the last session do", "get me up to speed", "I switched agents", asks to recover/summarize a previous session before continuing, or asks to diagnose or report a catchup failure. Do NOT use for the current conversation, git history, or any non-agent log.

741 votes
View all in ai-agents →