tmp

Author: saulshanabrook

AGENTS.md

@@ -38,6 +38,7 @@
   - in facts / antecedent-style use, undefined partial primitive calls cause the rule to skip rather than firing
   - in higher-order container ops, the container primitive should define the policy for undefined callback results, for example skipping those entries or failing the whole op
 - Use partial builtins in antecedent/lookup positions by default; do not materialize them in actions unless definedness has already been proven.
+- For Python helper wrappers around `catch`, prefer accepting the symbolic Egglog expression directly and wrapping it inside the helper, for example `try_match(expr, on_some, default)` should internally use `catch(lambda: expr)`. Python still evaluates arguments eagerly, but Egglog DSL expressions such as `map[key]` are symbolic construction, not runtime lookup execution; keep an explicit caller-side thunk only when constructing the expression itself can fail or has side effects.
 - In Python, only pass exact builtins or partials of exact builtins into higher-order container ops for this workflow.
 - Do not add Python-bodied primitive/container helpers or anonymous lambda callbacks for these paths.
 - Prefer `x == y` over `eq(x).to(y)` for ordinary equality facts, checks, and rule antecedents when the sort uses the default equality relation.

Cargo.lock

@@ -71,9 +71,11 @@
     "map_contains_key_swapped",
     "map_divide_all_values_by_f64",
     "map_drop_zero_values",
+    "map_factor_coef_for_integer_residual_split",
     "map_filter_defined_kv",
     "map_filter_kv",
     "map_fold_kv",
+    "map_integer_residual_split_candidate",
     "map_intersect_with",
     "map_keys",
     "map_map_values",
@@ -573,10 +575,7 @@ def value(self) -> dict[T, V]:
             items.append((k, v))
         if get_callable_args(self, Map.empty) is None:
             raise ExprValueError(self, "Map.empty or Map.insert")
-        d = {}
-        for k, v in reversed(items):
-            d[k] = v
-        return d
+        return dict(reversed(items))
 
     __match_args__ = ("value",)
 
@@ -714,6 +713,14 @@ def map_nonconst_nonunit_f64_values(xs: Map[Map[T, V], f64]) -> MultiSet[f64]: .
 def map_divide_all_values_by_f64(factor: f64, xs: Map[T, f64]) -> Map[T, f64]: ...
 
 
+@function(egg_fn="map-integer-residual-split-candidate", builtin=True)
+def map_integer_residual_split_candidate(xs: Map[Map[T, BigRat], f64]) -> Pair[Map[T, BigRat], Map[Map[T, BigRat], f64]]: ...
+
+
+@function(egg_fn="map-factor-coef-for-integer-residual-split", builtin=True)
+def map_factor_coef_for_integer_residual_split(xs: Map[Map[T, BigRat], f64]) -> f64: ...
+
+
 @function(egg_fn="map-shared-factor-atoms", builtin=True)
 def map_shared_factor_atoms(xs: Map[Map[T, BigRat], V]) -> Set[T]: ...
 

python/egglog/builtins.py

@@ -0,0 +1,16 @@
+_expr_1 = Value.var("q2") * Value.var("bp1") + Value.var("q5") * Value.var("bp2") + Value.var("q8") * Value.var("bp3") + Value.var("bp4") * Value.var("q11")
+_expr_2 = Value.var("bpp2") * Value.var("q6") + Value.var("q3") * Value.var("bpp1") + Value.var("bpp3") * Value.var("q9") + Value.var("bpp4") * Value.var("q12")
+_expr_3 = Value.var("bp1") * Value.var("q3") + Value.var("bp2") * Value.var("q6") + Value.var("q12") * Value.var("bp4") + Value.var("bp3") * Value.var("q9")
+_expr_4 = Value.var("bpp2") * Value.var("q5") + Value.var("q2") * Value.var("bpp1") + Value.var("bpp3") * Value.var("q8") + Value.var("bpp4") * Value.var("q11")
+_expr_5 = Value.var("q4") * Value.var("bpp2") + Value.var("q7") * Value.var("bpp3") + Value.var("q10") * Value.var("bpp4") + Value.var("bpp1") * Value.var("q1")
+_expr_6 = Value.var("q4") * Value.var("bp2") + Value.var("q7") * Value.var("bp3") + Value.var("bp1") * Value.var("q1") + Value.var("q10") * Value.var("bp4")
+NDArray(
+    RecursiveValue(
+        (
+            (_expr_1 * _expr_2 + Value.from_int(Int(-1)) * (_expr_3 * _expr_4)) ** Value.from_int(Int(2))
+            + (_expr_3 * _expr_5 + Value.from_int(Int(-1)) * (_expr_6 * _expr_2)) ** Value.from_int(Int(2))
+            + (_expr_6 * _expr_4 + Value.from_int(Int(-1)) * (_expr_1 * _expr_5)) ** Value.from_int(Int(2))
+        )
+        / (_expr_6 ** Value.from_int(Int(2)) + _expr_1 ** Value.from_int(Int(2)) + _expr_3 ** Value.from_int(Int(2))) ** Value.from_int(Int(3))
+    )
+)