The mechanism designer’s variant of CAD’s oldest scar: hide a connecting rod, the joint reference dies, the kinematic loop falls apart. NeuroCAD’s mechanism graph is bound to feature-graph IDs, not to topology — so the failure mode has nowhere to live.

The 60-second demo every mechanism designer has lived through

You have a four-bar linkage. Crank, coupler, rocker, ground. Four pin joints arranged in a closed loop. The whole point of the mechanism is that the loop closes — the input crank rotates, the coupler swings, the rocker oscillates, and the assembly traces out a Grashof or non-Grashof motion law that you spent the morning tuning.

Now do something that, on paper, is harmless. You want to study the linkage with the coupler hidden so you can see the rocker path more clearly. So you right-click the coupler in the feature tree and choose Suppress.

In a commercial CAD assembly — SolidWorks, Inventor, Creo, Onshape — what happens next is variations on a theme. The two pin joints that referenced edges on the coupler turn red. The mate dialog complains about “Missing entity” or “Reference invalid”. The motion study refuses to run, or runs against a degenerate kinematic graph and produces nonsense. If you unsuppress the coupler, depending on the package, the joints might rebind correctly, or they might rebind to the wrong cylindrical face on the new instance and silently start producing the wrong Grashof classification.

Mechanism designers have learned to live with this. The workaround is folklore: never suppress a part inside an active joint chain; if you must, freeze the assembly first; if the joints break, reattach them by hand and pray the kinematic solver still converges; never trust a motion study that survived a suppress/unsuppress cycle without re-validating it against a known closure case.

This is the mechanism-domain expression of the Topological Naming Problem. Same axiom, different domain. Joints are references. Bodies have topology. Topology changes when you suppress a body. Therefore joint references break.

Unless you decide that joints will not be bound to topology in the first place.

Why every B-rep mechanism kernel breaks under suppression

A pin joint, in a conventional CAD package, is stored as something like:

Take Body#A’s cylindrical face Face#17 and Body#B’s cylindrical face Face#08. Constrain them concentric and free in 1 rotational degree of freedom about their shared axis.

The joint’s identity, in the data model, is a tuple of (BodyId, FaceId) pairs. When you suppress Body#A, two things happen at once:

The body is removed from the assembly’s evaluation graph. Any face inside it — including Face#17 — no longer exists as a queryable entity.
The joint that referenced Face#17 becomes a dangling pointer.

The kernel then makes the same Hobson’s choice it makes for fillets-on-hole-edges: refuse the suppress, suppress and break the joint, or attempt heuristic reattachment when the body comes back. Heuristic reattachment in a kinematic context is strictly worse than in the geometric case, because a joint that rebinds to the wrong cylindrical face produces a mechanism graph that still solves — it just solves the wrong problem. The motion study runs. The Grashof classification comes out. It is silently incorrect.

This is the headline complaint in mechanism-CAD support forums. It is mathematically the same problem as the fillet/hole edge case, with one extra danger: kinematic results look plausible even when they are wrong, because the solver does not know it is operating on a corrupt graph.

NeuroCAD has no edges. NeuroCAD’s mechanisms have no body references either.

NeuroCAD’s signed distance field (SDF) representation removes the geometric form of the failure by construction: there are no edges, so there is nothing to name, so there is nothing to invalidate. The mechanism layer takes the same pattern up one level.

In NeuroCAD, a mechanism graph is built on top of the same hypergraph that holds the feature tree. Every part, joint, and constraint is a node in this graph, identified by a stable NodeId and exposed to the user as a stable feature_id string ("crank", "coupler", "pin_joint_1", etc.).

When you author a pin joint in NeuroCAD’s Mechanisms workbench, the joint does not store (BodyId, FaceId). The joint stores (crank_feature_id, coupler_feature_id, axis_parameter_id). The “where is the pin” question is answered not by pointing into the topology of a body, but by pointing at a parameter on the joint itself plus the two feature-graph nodes the joint connects.

When you suppress the coupler:

The coupler’s compose node is marked suppressed in the feature graph.
Its NodeId and feature_id remain valid — Hypergraph::suppress_node does not remove the node, it flags it.
The pin joints that reference coupler_feature_id still find their referent. The referent is a feature-graph identity, not a face on a B-rep body, and that identity is byte-stable across suppress/unsuppress.
The mechanism solver sees a graph where one body is flagged “not currently contributing geometry” and acts accordingly: it can either (a) hold the affected joints in their last-solved configuration and report a mobility-reduced sub-mechanism, or (b) treat the suppressed body as massless-but-present (a common engineering convenience for studying force flow with a part visually hidden).

What the solver cannot do is fail with InvalidEdgeReference or its mechanism-domain analogue, because there is no edge reference and no face reference in the joint at all.

The same axiom, restated for mechanisms

The SDF “never-fails” axiom for pure geometric features:

Suppress/unsuppress on the feature graph never invalidates any other feature’s topology reference, because there is no topology reference to invalidate.

The mechanism extension is a one-line corollary:

Suppress/unsuppress on the mechanism graph never invalidates any other joint’s body reference, because joints are bound to feature-graph IDs (byte-stable) and not to topology.

That is the entire claim of this post. Every property below — closed-loop kinematic survivability, slider-crank suppression survivability, planetary train suppression survivability — is a downstream test of the same axiom.

What we plan to test, and how

The publishable hole this post backs is Variable-Topology Mechanism Graphs Without Joint Reference Invalidation. It pins three concrete mechanism scenarios:

1. Four-bar suppress cycle

Build a Grashof crank-rocker. Suppress the coupler. Confirm:

the suppress call does not error;
the two pin joints that previously referenced the coupler still resolve their feature-graph IDs to the (now-suppressed) coupler node;
the mechanism solver reports the loop as temporarily open with the coupler removed, but does not raise a graph-invalidation error;
unsuppressing the coupler restores the original four-bar with byte-identical NodeId and feature_id values for every joint;
the post-cycle Grashof classification matches the pre-cycle Grashof classification exactly.

2. Slider-crank suppress cycle

Build a slider-crank, drive the crank one full revolution, capture the closure error trajectory. Suppress the connecting rod. Unsuppress the connecting rod. Re-run the same crank revolution. Closure error trajectory must be bit-identical to the pre-suppress run, modulo floating-point determinism guarantees we already pin in our reproducibility tests.

3. Planetary train suppress cycle

Build a planetary train (sun + 3 planets + ring + carrier). Suppress one of the three planets to study a degraded mode (a real engineering use case for fault-condition analysis). Confirm:

the AGMA 6123 reduction ratio of the remaining sun-2-planet sub-train computes correctly;
the suppressed planet’s joints remain valid feature-graph references;
unsuppressing returns the train to a configuration that matches the original ratio to machine precision.

What this is not

This is not a claim that NeuroCAD’s mechanism workbench is feature-complete. It is not. The workbench is a placeholder today; the joint-to-feature-graph-ID binding described above is proposed, not yet shipped. What is shipped is the underlying primitive: Hypergraph::{suppress_node, unsuppress_node} with byte-stable IDs (the variable-topology-holes regression pin proves it). The mechanism extension reuses that primitive; it does not need to invent a new one.

This is also not a claim that joint reference invalidation is the only source of mechanism-CAD pain. Singularities, mobility miscounts, IK divergence, energy drift in dynamics — these are all real, and each gets its own publishable hole in our catalogue. What this hole isolates is the specific failure mode that has been part of the mechanism designer’s daily folklore for three decades: the assembly works, then I suppressed something, and now my motion study is wrong.

The bigger point

Mechanism CAD has lived inside B-rep’s data model for so long that joint-reference brittleness reads as a fact of nature. It is not. It is a consequence of binding kinematic relationships to topology, and topology is the wrong thing to bind kinematic relationships to.

NeuroCAD binds joints to feature-graph identity, the same identity that survives every suppress/unsuppress operation in our kernel_graph layer by construction. The joint reference cannot break, because the thing it points at — a feature-graph node ID, not a face on a body — was never going to disappear in the first place.

That is the mechanism-domain extension of “by construction.” It is the same axiom we proved for geometry. The proof transfers up the stack with one substitution: replace edge with joint, and replace topology with feature-graph identity.

The result is the same. The class of error disappears.

References

[1] FreeCAD. Topological Naming Problem. Issue #8432, GitHub. https://github.com/FreeCAD/FreeCAD/issues/8432. [2] Ondsel. The Topological Naming Problem. https://www.ondsel.com/blog/freecad-topological-naming/. [3] Norton, R. L. Design of Machinery: An Introduction to the Synthesis and Analysis of Mechanisms and Machines. McGraw-Hill, 5th ed., 2011. [4] Wikipedia. Four-bar linkage. https://en.wikipedia.org/wiki/Four-bar_linkage. [5] AGMA 6123-C16. Design Manual for Enclosed Epicyclic Gear Drives. American Gear Manufacturers Association.

Status

Artifact	Status
`Hypergraph::{suppress_node, unsuppress_node, is_suppressed}` (the underlying primitive)	Shipped
Variable-topology holes contract test (parent regression pin)	Shipped — passes on `main`
Mechanisms workbench (4-bar, slider-crank, planetary, IK, Jacobian)	Placeholder — UI scaffolding present, kinematic solver and joint-binding API not yet implemented
Joint↔`feature_id` binding in mechanism graph (the architectural commitment of this post)	Proposed
Four-bar suppress/unsuppress regression pin	Proposed
Slider-crank closure-trajectory bit-equality test	Proposed, depends on Mechanisms workbench shipping the symplectic integrator
Planetary train degraded-mode ratio test	Proposed, depends on AGMA 6123 ratio kernel

Anything not marked shipped should be treated as plan, not product. The Mechanisms workbench is on the platform roadmap; this post sets the architectural axiom it will be built against.

Suppress a Part in Your Assembly. Watch Your 4-Bar Linkage Break. SDF Lets You Suppress Safely.