Algebraic tearing is equation-order sensitive with no user control; connect-statement reordering flips a model from solvable to InitialFailure

[baggepinnen]

Summary

Algebraic tearing is equation-order sensitive, and there is currently no user-facing mechanism to control it: state_priority is consulted only by dummy-derivative (continuous state) selection, not by the tearing of algebraic loops.

Minimal observed consequence (multibody suspension model, 11 states after mtkcompile): reordering four semantically-identical connect statements inside one component (moving two frame connections after two rotational-flange connections; connection sets unchanged) flips the model from solves reliably to InitialFailure for every initialization random seed tried (12/12).

Mechanism

Diffing the two orderings via missing_guess_value = MissingGuessValue.Error() shows the cyclic-guess (tear-variable) sets differ by exactly one variable:

• working ordering tears body_upright.frame_b.f[3] (a cut force),
• failing ordering tears excited_suspension.suspension.b1.frame_a.tau[2] (a cut torque).

Everything else is identical. The tearing matching made a different (order-driven) tie-break, and the default HashedRandom guess for the alternative tear variable lands the initialization in an infeasible basin.

Why there is no workaround today

1. state_priority has no effect: it is only used in dummy_derivative_graph! (StateSelection partial_state_selection.jl); grep state_priority over ModelingToolkitTearing finds nothing. The flipped variables are algebraic connector flows, not state candidates.
2. Guesses do not influence simplification, only the numeric start point — and the tear-variable set itself moves with equation order (we observed a third variable, r2.frame_b.tau[3], appear after providing guesses for the first two), so guess-based hardening chases a moving target.
3. Model authors cannot, in general, control equation ordering: it is produced by code generators / graphical front-ends, and reordering statements with identical semantics must not change solvability.

Request

Priority-aware tie-breaking in algebraic tearing: when the tearing matching has freedom in which variable an equation is solved for (equivalently, which variables remain as tear/iteration variables), consult variable priorities (either state_priority or a dedicated tearing_priority metadata) so that model libraries can express e.g. "prefer joint coordinates, avoid cut forces/torques as tear variables". This would make simplification results deterministic under semantically-neutral equation reordering whenever the modeler has expressed a preference.

We are attempting a local prototype of such a tie-break and can report results / open a PR if it works out.

Versions

Julia 1.12.6, ModelingToolkit v11.26.8, ModelingToolkitBase v1.43.1, ModelingToolkitTearing v1.14.1, StateSelection v1.9.3.

Related context: #4237, JuliaComputing/StateSelection.jl#95 (same model family).

[baggepinnen]

Follow-up after prototyping priority-aware tearing locally (tie-breaks added to CarpanzanoTearing's heuristics 1 & 2, reading structure.state_priorities, ascending-priority candidate ordering so high-priority variables remain tear variables; behavior-identical on uniform priorities):

Priorities turn out to be fundamentally insufficient for this class of order-sensitivity. Dumping the torn (unassigned) sets for the two connect orderings shows they differ in exactly two variables, and both flips are between metadata-indistinguishable candidates:

• wheeljoint.v_0[3] vs wheeljoint.v_0[1] — components of the same array variable. build_state_priorities assigns priorities per parent array (get(sps, arr, 0)), so array components are always tied.
• b1.frame_a.tau[3] vs r2.frame_b.tau[3] — aliases of the same connection set (those frames are directly connected); symmetric by construction, no principled priority distinction exists.

So even with priority-aware tie-breaking, these choices remain decided by graph/insertion order. For determinism (same result under semantically-neutral equation reordering), tearing tie-breaks need a canonical rule — e.g. lowest array index, then lexicographically-smallest variable name — applied after priorities. Priorities remain valuable for steering among distinguishable candidates, but canonical ordering is what removes the order-dependence.

One more empirical nuance: at the initialization guess, both orderings produce the same pathology (one ±Inf residual row through an observed torque chain, identical finite-residual norm) — yet one converges and the other doesn't. The flip changes which variables receive the (Hashed)Random missing guesses, i.e. it moves the NLS starting point between basins. This is why no guess-set we tried at the model level could robustly compensate: the guess-needing set itself is order-dependent.

Happy to share the (small) priority tie-break patch for CarpanzanoTearing regardless — it implements the mechanism cleanly for the distinguishable-candidate case — but the canonical tie-break is the part that addresses this issue's title.

[baggepinnen]

Prototype implementing the requested mechanism is up as a draft: JuliaComputing/StateSelection.jl#96 — priority-aware tear-variable selection + a canonical (name-rank) tie-break. Empirically on the repro model: the torn reaction choice now converges to the same variable under both connect orderings (deterministic); the remaining order-divergence is a within-array component choice (v_0[1] vs v_0[3]) decided in the initial maximal matching / single-solvable-equation cascade (equation-order driven), which needs equation-level canonicalization — plus AtomicArrayDict currently rejects per-component priority keys, blocking user-level component-granular steering.