feat(core): add symbolic equation isolation engine for algebraic loop reduction

nachawati · nachawati · commit 3e661eb8dfb0 · 2026-03-30T19:43:41.000+03:00
diff --git a/packages/core/src/compiler/modelica/blt.ts b/packages/core/src/compiler/modelica/blt.ts
@@ -9,6 +9,7 @@ import {
   ModelicaRealVariable,
   ModelicaSimpleEquation,
 } from "./dae.js";
+import { isolateSymbolically } from "./symbolic.js";
 
 /**
  * Visitor that collects all variable names referenced in an expression/equation.
@@ -65,6 +66,21 @@ function isExplicitlySolvableFor(eq: ModelicaEquation, v: string): boolean {
   return false;
 }
 
+/**
+ * Attempt to symbolically isolate `v` from a `ModelicaSimpleEquation`.
+ * Returns a new explicit equation `v = expr` if successful, or null.
+ */
+function trySymbolicIsolation(eq: ModelicaEquation, v: string): ModelicaSimpleEquation | null {
+  if (!(eq instanceof ModelicaSimpleEquation)) return null;
+  if (!eq.expression1 || !eq.expression2) return null;
+
+  const result = isolateSymbolically(eq.expression1, eq.expression2, v);
+  if (!result) return null;
+
+  const nameExpr = new ModelicaNameExpression(v);
+  return new ModelicaSimpleEquation(nameExpr, result);
+}
+
 /**
  * Perform a full Block Lower Triangular (BLT) Transformation on the DAE equations.
  */
@@ -241,11 +257,20 @@ export function performBltTransformation(dae: ModelicaDAE): {
           const deps = eqDeps.get(eqIdx);
           if (deps?.has(v)) {
             // It's a single variable assigned to this equation. But is it a true loop?
-            // If it's a structural explicit assignment (v = ...), it's not an algebraic loop unless it's v = v + 1.
+            // If it's a structural explicit assignment (v = ...), it's not an algebraic loop.
             const matchingEq = equations[eqIdx];
             if (matchingEq && !isExplicitlySolvableFor(matchingEq, v)) {
-              // implicit single variable loop
-              algebraicLoops.push({ variables: scc, equations: sccEqs });
+              // Try symbolic isolation before giving up
+              const isolated = trySymbolicIsolation(matchingEq, v);
+              if (isolated) {
+                // Replace the implicit equation with the explicit one
+                const idx = sccEqs.indexOf(matchingEq);
+                if (idx >= 0) sccEqs[idx] = isolated;
+                equations[eqIdx] = isolated;
+              } else {
+                // implicit single variable loop — cannot isolate
+                algebraicLoops.push({ variables: scc, equations: sccEqs });
+              }
             }
           }
         }
diff --git a/packages/core/src/compiler/modelica/symbolic-diff.ts b/packages/core/src/compiler/modelica/symbolic-diff.ts
@@ -476,5 +476,8 @@ export function simplifyExpr(expr: ModelicaExpression): ModelicaExpression {
   return expr;
 }
 
-// Re-export for convenience
+// Re-export constants and builder utilities for use by symbolic.ts
+export { add, call, div, HALF, isOne, isZero, mul, NEG_ONE, ONE, pow, sub, TWO, ZERO };
+
+// Legacy re-exports
 export { HALF as DIFF_HALF, NEG_ONE as DIFF_NEG_ONE, ONE as DIFF_ONE, TWO as DIFF_TWO, ZERO as DIFF_ZERO };
diff --git a/packages/core/src/compiler/modelica/symbolic.ts b/packages/core/src/compiler/modelica/symbolic.ts

Original file line number	Diff line number	Diff line change
`@@ -476,5 +476,8 @@ export function simplifyExpr(expr: ModelicaExpression): ModelicaExpression {`
`476`	`476`	`return expr;`
`477`	`477`	`}`
`478`	`478`
`479`		`-// Re-export for convenience`
	`479`	`+// Re-export constants and builder utilities for use by symbolic.ts`
	`480`	`+export { add, call, div, HALF, isOne, isZero, mul, NEG_ONE, ONE, pow, sub, TWO, ZERO };`
	`481`	`+`
	`482`	`+// Legacy re-exports`
`480`	`483`	`export { HALF as DIFF_HALF, NEG_ONE as DIFF_NEG_ONE, ONE as DIFF_ONE, TWO as DIFF_TWO, ZERO as DIFF_ZERO };`