egglog 11.3.0__cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 11.4.0__cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

egglog/bindings.pyi

@@ -1,6 +1,8 @@
+from collections.abc import Callable
 from datetime import timedelta
+from fractions import Fraction
 from pathlib import Path
-from typing import TypeAlias
+from typing import Any, Generic, Protocol, TypeAlias, TypeVar
 
 from typing_extensions import final
 
@@ -14,6 +16,7 @@ __all__ = [
     "Change",
     "Check",
     "Constructor",
+    "CostModel",
     "Datatype",
     "Datatypes",
     "DefaultPrintFunctionMode",
@@ -26,6 +29,7 @@ __all__ = [
     "Extract",
     "ExtractBest",
     "ExtractVariants",
+    "Extractor",
     "Fact",
     "Fail",
     "Float",
@@ -83,6 +87,7 @@ __all__ = [
     "UserDefined",
     "UserDefinedCommandOutput",
     "UserDefinedOutput",
+    "Value",
     "Var",
     "Variant",
 ]
@@ -128,6 +133,31 @@ class EGraph:
         max_calls_per_function: int | None = None,
         include_temporary_functions: bool = False,
     ) -> SerializedEGraph: ...
+    def lookup_function(self, name: str, key: list[Value]) -> Value | None: ...
+    def eval_expr(self, expr: _Expr) -> tuple[str, Value]: ...
+    def value_to_i64(self, v: Value) -> int: ...
+    def value_to_f64(self, v: Value) -> float: ...
+    def value_to_string(self, v: Value) -> str: ...
+    def value_to_bool(self, v: Value) -> bool: ...
+    def value_to_rational(self, v: Value) -> Fraction: ...
+    def value_to_bigint(self, v: Value) -> int: ...
+    def value_to_bigrat(self, v: Value) -> Fraction: ...
+    def value_to_pyobject(self, py_object_sort: PyObjectSort, v: Value) -> object: ...
+    def value_to_map(self, v: Value) -> dict[Value, Value]: ...
+    def value_to_multiset(self, v: Value) -> list[Value]: ...
+    def value_to_vec(self, v: Value) -> list[Value]: ...
+    def value_to_function(self, v: Value) -> tuple[str, list[Value]]: ...
+    def value_to_set(self, v: Value) -> set[Value]: ...
+    # def dynamic_cost_model_enode_cost(self, func: str, args: list[Value]) -> int: ...
+
+@final
+class Value:
+    def __hash__(self) -> int: ...
+    def __eq__(self, value: object) -> bool: ...
+    def __lt__(self, other: object) -> bool: ...
+    def __le__(self, other: object) -> bool: ...
+    def __gt__(self, other: object) -> bool: ...
+    def __ge__(self, other: object) -> bool: ...
 
 @final
 class EggSmolError(Exception):
@@ -732,3 +762,34 @@ class TermDag:
     def expr_to_term(self, expr: _Expr) -> _Term: ...
     def term_to_expr(self, term: _Term, span: _Span) -> _Expr: ...
     def to_string(self, term: _Term) -> str: ...
+
+##
+# Extraction
+##
+class _Cost(Protocol):
+    def __lt__(self, other: _Cost) -> bool: ...
+    def __le__(self, other: _Cost) -> bool: ...
+    def __gt__(self, other: _Cost) -> bool: ...
+    def __ge__(self, other: _Cost) -> bool: ...
+
+_COST = TypeVar("_COST", bound=_Cost)
+
+_ENODE_COST = TypeVar("_ENODE_COST")
+
+@final
+class CostModel(Generic[_COST, _ENODE_COST]):
+    def __init__(
+        self,
+        fold: Callable[[str, _ENODE_COST, list[_COST]], _COST],
+        enode_cost: Callable[[str, list[Value]], _ENODE_COST],
+        container_cost: Callable[[str, Value, list[_COST]], _COST],
+        base_value_cost: Callable[[str, Value], _COST],
+    ) -> None: ...
+
+@final
+class Extractor(Generic[_COST]):
+    def __init__(self, rootsorts: list[str] | None, egraph: EGraph, cost_model: CostModel[_COST, Any]) -> None: ...
+    def extract_best(self, egraph: EGraph, termdag: TermDag, value: Value, sort: str) -> tuple[_COST, _Term]: ...
+    def extract_variants(
+        self, egraph: EGraph, termdag: TermDag, value: Value, nvariants: int, sort: str
+    ) -> list[tuple[_COST, _Term]]: ...

egglog/builtins.py

@@ -33,10 +33,12 @@ __all__ = [
     "BigRatLike",
     "Bool",
     "BoolLike",
+    "Container",
     "ExprValueError",
     "Map",
     "MapLike",
     "MultiSet",
+    "Primitive",
     "PyObject",
     "Rational",
     "Set",
@@ -1135,3 +1137,7 @@ def _convert_function(fn: FunctionType) -> UnstableFn:
 
 
 converter(FunctionType, UnstableFn, _convert_function)
+
+
+Container: TypeAlias = Map | Set | MultiSet | Vec | UnstableFn
+Primitive: TypeAlias = String | Bool | i64 | f64 | Rational | BigInt | BigRat | PyObject | Unit

egglog/declarations.py

@@ -14,6 +14,8 @@ from weakref import WeakValueDictionary
 
 from typing_extensions import Self, assert_never
 
+from .bindings import Value
+
 if TYPE_CHECKING:
     from collections.abc import Callable, Iterable, Mapping
 
@@ -49,6 +51,7 @@ __all__ = [
     "FunctionDecl",
     "FunctionRef",
     "FunctionSignature",
+    "GetCostDecl",
     "HasDeclerations",
     "InitRef",
     "JustTypeRef",
@@ -82,6 +85,7 @@ __all__ = [
     "UnboundVarDecl",
     "UnionDecl",
     "UnnamedFunctionRef",
+    "ValueDecl",
     "collect_unbound_vars",
     "replace_typed_expr",
     "upcast_declerations",
@@ -639,7 +643,7 @@ class CallDecl:
     args: tuple[TypedExprDecl, ...] = ()
     # type parameters that were bound to the callable, if it is a classmethod
     # Used for pretty printing classmethod calls with type parameters
-    bound_tp_params: tuple[JustTypeRef, ...] | None = None
+    bound_tp_params: tuple[JustTypeRef, ...] = ()
 
     # pool objects for faster __eq__
     _args_to_value: ClassVar[WeakValueDictionary[tuple[object, ...], CallDecl]] = WeakValueDictionary({})
@@ -654,7 +658,7 @@ class CallDecl:
         # normalize the args/kwargs to a tuple so that they can be compared
         callable = args[0] if args else kwargs["callable"]
         args_ = args[1] if len(args) > 1 else kwargs.get("args", ())
-        bound_tp_params = args[2] if len(args) > 2 else kwargs.get("bound_tp_params")
+        bound_tp_params = args[2] if len(args) > 2 else kwargs.get("bound_tp_params", ())
 
         normalized_args = (callable, args_, bound_tp_params)
         try:
@@ -696,7 +700,20 @@ class PartialCallDecl:
     call: CallDecl
 
 
-ExprDecl: TypeAlias = UnboundVarDecl | LetRefDecl | LitDecl | CallDecl | PyObjectDecl | PartialCallDecl
+@dataclass(frozen=True)
+class GetCostDecl:
+    callable: CallableRef
+    args: tuple[TypedExprDecl, ...]
+
+
+@dataclass(frozen=True)
+class ValueDecl:
+    value: Value
+
+
+ExprDecl: TypeAlias = (
+    UnboundVarDecl | LetRefDecl | LitDecl | CallDecl | PyObjectDecl | PartialCallDecl | ValueDecl | GetCostDecl
+)
 
 
 @dataclass(frozen=True)

egglog/deconstruct.py

@@ -11,7 +11,7 @@ from typing import TYPE_CHECKING, TypeVar, overload
 from typing_extensions import TypeVarTuple, Unpack
 
 from .declarations import *
-from .egraph import BaseExpr
+from .egraph import BaseExpr, Expr
 from .runtime import *
 from .thunk import *
 
@@ -49,7 +49,11 @@ def get_literal_value(x: PyObject) -> object: ...
 def get_literal_value(x: UnstableFn[T, Unpack[TS]]) -> Callable[[Unpack[TS]], T] | None: ...
 
 
-def get_literal_value(x: String | Bool | i64 | f64 | PyObject | UnstableFn) -> object:
+@overload
+def get_literal_value(x: Expr) -> None: ...
+
+
+def get_literal_value(x: object) -> object:
     """
     Returns the literal value of an expression if it is a literal.
     If it is not a literal, returns None.
@@ -95,12 +99,9 @@ def get_var_name(x: BaseExpr) -> str | None:
     return None
 
 
-def get_callable_fn(x: T) -> Callable[..., T] | None:
+def get_callable_fn(x: T) -> Callable[..., T] | T | None:
     """
-    Gets the function of an expression if it is a call expression.
-    If it is not a call expression (a property, a primitive value, constants, classvars, a let value), return None.
-    For those values, you can check them by comparing them directly with equality or for primitives calling `.eval()`
-    to return the Python value.
+    Gets the function of an expression, or if it's a constant or classvar, return that.
     """
     if not isinstance(x, RuntimeExpr):
         raise TypeError(f"Expected Expression, got {type(x).__name__}")
@@ -159,6 +160,7 @@ def _deconstruct_call_decl(
     """
     args = call.args
     arg_exprs = tuple(RuntimeExpr(decls_thunk, Thunk.value(a)) for a in args)
+    # TODO: handle values? Like constants
     if isinstance(call.callable, InitRef):
         return RuntimeClass(
             decls_thunk,

egglog/egraph.py

@@ -16,6 +16,7 @@ from typing import (
     ClassVar,
     Generic,
     Literal,
+    Protocol,
     TypeAlias,
     TypedDict,
     TypeVar,
@@ -41,7 +42,7 @@ from .thunk import *
 from .version_compat import *
 
 if TYPE_CHECKING:
-    from .builtins import String, Unit, i64Like
+    from .builtins import String, Unit, i64, i64Like
 
 
 __all__ = [
@@ -51,11 +52,14 @@ __all__ = [
     "BuiltinExpr",
     "Command",
     "Command",
+    "CostModel",
     "EGraph",
     "Expr",
+    "ExprCallable",
     "Fact",
     "Fact",
     "GraphvizKwargs",
+    "GreedyDagCost",
     "RewriteOrRule",
     "Ruleset",
     "Schedule",
@@ -70,12 +74,15 @@ __all__ = [
     "check",
     "check_eq",
     "constant",
+    "default_cost_model",
     "delete",
     "eq",
     "expr_action",
     "expr_fact",
     "expr_parts",
     "function",
+    "get_cost",
+    "greedy_dag_cost_model",
     "let",
     "method",
     "ne",
@@ -88,6 +95,7 @@ __all__ = [
     "seq",
     "set_",
     "set_cost",
+    "set_current_ruleset",
     "subsume",
     "union",
     "unstable_combine_rulesets",
@@ -452,7 +460,7 @@ def _generate_class_decls(  # noqa: C901,PLR0912
             continue
         locals = frame.f_locals
         ref: ClassMethodRef | MethodRef | PropertyRef | InitRef
-        # TODO: Store deprecated message so we can print at runtime
+        # TODO: Store deprecated message so we can get at runtime
         if (getattr(fn, "__deprecated__", None)) is not None:
             fn = fn.__wrapped__  # type: ignore[attr-defined]
         match fn:
@@ -953,22 +961,45 @@ class EGraph:
         return bindings.Check(span(2), egg_facts)
 
     @overload
-    def extract(self, expr: BASE_EXPR, /, include_cost: Literal[False] = False) -> BASE_EXPR: ...
+    def extract(
+        self, expr: BASE_EXPR, /, include_cost: Literal[False] = False, cost_model: CostModel | None = None
+    ) -> BASE_EXPR: ...
 
     @overload
-    def extract(self, expr: BASE_EXPR, /, include_cost: Literal[True]) -> tuple[BASE_EXPR, int]: ...
+    def extract(
+        self, expr: BASE_EXPR, /, include_cost: Literal[True], cost_model: None = None
+    ) -> tuple[BASE_EXPR, int]: ...
 
-    def extract(self, expr: BASE_EXPR, include_cost: bool = False) -> BASE_EXPR | tuple[BASE_EXPR, int]:
+    @overload
+    def extract(
+        self, expr: BASE_EXPR, /, include_cost: Literal[True], cost_model: CostModel[COST]
+    ) -> tuple[BASE_EXPR, COST]: ...
+
+    def extract(
+        self, expr: BASE_EXPR, /, include_cost: bool = False, cost_model: CostModel[COST] | None = None
+    ) -> BASE_EXPR | tuple[BASE_EXPR, COST]:
         """
         Extract the lowest cost expression from the egraph.
         """
         runtime_expr = to_runtime_expr(expr)
-        extract_report = self._run_extract(runtime_expr, 0)
-        assert isinstance(extract_report, bindings.ExtractBest)
-        res = self._from_termdag(extract_report.termdag, extract_report.term, runtime_expr.__egg_typed_expr__.tp)
-        if include_cost:
-            return res, extract_report.cost
-        return res
+        self._add_decls(runtime_expr)
+        tp = runtime_expr.__egg_typed_expr__.tp
+        if cost_model is None:
+            extract_report = self._run_extract(runtime_expr, 0)
+            assert isinstance(extract_report, bindings.ExtractBest)
+            res = self._from_termdag(extract_report.termdag, extract_report.term, tp)
+            cost = cast("COST", extract_report.cost)
+        else:
+            # TODO: For some reason we need this or else it wont be registered. Not sure why
+            self.register(expr)
+            egg_cost_model = _CostModel(cost_model, self).to_bindings_cost_model()
+            egg_sort = self._state.type_ref_to_egg(tp)
+            extractor = bindings.Extractor([egg_sort], self._state.egraph, egg_cost_model)
+            termdag = bindings.TermDag()
+            value = self._state.typed_expr_to_value(runtime_expr.__egg_typed_expr__)
+            cost, term = extractor.extract_best(self._state.egraph, termdag, value, egg_sort)
+            res = self._from_termdag(termdag, term, tp)
+        return (res, cost) if include_cost else res
 
     def _from_termdag(self, termdag: bindings.TermDag, term: bindings._Term, tp: JustTypeRef) -> Any:
         (new_typed_expr,) = self._state.exprs_from_egg(termdag, [term], tp)
@@ -979,6 +1010,7 @@ class EGraph:
         Extract multiple expressions from the egraph.
         """
         runtime_expr = to_runtime_expr(expr)
+        self._add_decls(runtime_expr)
         extract_report = self._run_extract(runtime_expr, n)
         assert isinstance(extract_report, bindings.ExtractVariants)
         new_exprs = self._state.exprs_from_egg(
@@ -987,7 +1019,6 @@ class EGraph:
         return [cast("BASE_EXPR", RuntimeExpr.__from_values__(self.__egg_decls__, expr)) for expr in new_exprs]
 
     def _run_extract(self, expr: RuntimeExpr, n: int) -> bindings._CommandOutput:
-        self._add_decls(expr)
         expr = self._state.typed_expr_to_egg(expr.__egg_typed_expr__)
         # If we have defined any cost tables use the custom extraction
         args = (expr, bindings.Lit(span(2), bindings.Int(n)))
@@ -1212,16 +1243,12 @@ class EGraph:
         """
         (output,) = self._egraph.run_program(bindings.PrintSize(span(1), None))
         assert isinstance(output, bindings.PrintAllFunctionsSize)
+        return [(callables[0], size) for (name, size) in output.sizes if (callables := self._egg_fn_to_callables(name))]
+
+    def _egg_fn_to_callables(self, egg_fn: str) -> list[ExprCallable]:
         return [
-            (
-                cast(
-                    "ExprCallable",
-                    create_callable(self._state.__egg_decls__, next(iter(refs))),
-                ),
-                size,
-            )
-            for (name, size) in output.sizes
-            if (refs := self._state.egg_fn_to_callable_refs[name])
+            cast("ExprCallable", create_callable(self._state.__egg_decls__, ref))
+            for ref in self._state.egg_fn_to_callable_refs[egg_fn]
         ]
 
     def function_values(
@@ -1245,6 +1272,33 @@ class EGraph:
             for (call, res) in output.terms
         }
 
+    def lookup_function_value(self, expr: BASE_EXPR) -> BASE_EXPR | None:
+        """
+        Given an expression that is a function call, looks up the value of the function call if it exists.
+        """
+        runtime_expr = to_runtime_expr(expr)
+        typed_expr = runtime_expr.__egg_typed_expr__
+        assert isinstance(typed_expr.expr, CallDecl | GetCostDecl)
+        egg_fn, typed_args = self._state.translate_call(typed_expr.expr)
+        values_args = [self._state.typed_expr_to_value(a) for a in typed_args]
+        possible_value = self._egraph.lookup_function(egg_fn, values_args)
+        if possible_value is None:
+            return None
+        return cast(
+            "BASE_EXPR",
+            RuntimeExpr.__from_values__(
+                self.__egg_decls__,
+                TypedExprDecl(typed_expr.tp, self._state.value_to_expr(typed_expr.tp, possible_value)),
+            ),
+        )
+
+    def has_custom_cost(self, fn: ExprCallable) -> bool:
+        """
+        Checks if the any custom costs have been set for this expression callable.
+        """
+        resolved, _ = resolve_callable(fn)
+        return resolved in self._state.cost_callables
+
 
 # Either a constant or a function.
 ExprCallable: TypeAlias = Callable[..., BaseExpr] | BaseExpr
@@ -1910,3 +1964,246 @@ def set_current_ruleset(r: Ruleset | None) -> Generator[None, None, None]:
         yield
     finally:
         _CURRENT_RULESET.reset(token)
+
+
+def get_cost(expr: BaseExpr) -> i64:
+    """
+    Return a lookup of the cost of an expression. If not set, won't match.
+    """
+    assert isinstance(expr, RuntimeExpr)
+    expr_decl = expr.__egg_typed_expr__.expr
+    if not isinstance(expr_decl, CallDecl):
+        msg = "Can only get cost of function calls, not literals or variables"
+        raise TypeError(msg)
+    return RuntimeExpr.__from_values__(
+        expr.__egg_decls__,
+        TypedExprDecl(JustTypeRef("i64"), GetCostDecl(expr_decl.callable, expr_decl.args)),
+    )
+
+
+class Comparable(Protocol):
+    def __lt__(self, other: Self) -> bool: ...
+    def __le__(self, other: Self) -> bool: ...
+    def __gt__(self, other: Self) -> bool: ...
+    def __ge__(self, other: Self) -> bool: ...
+
+
+COST = TypeVar("COST", bound=Comparable)
+
+
+class CostModel(Protocol, Generic[COST]):
+    """
+    A cost model for an e-graph. Used to determine the cost of an expression based on its structure and the costs of its sub-expressions.
+
+    Called with an expression and the costs of its children, returns the total cost of the expression.
+
+    Additionally, the cost model should guarantee that a term has a no-smaller cost
+    than its subterms to avoid cycles in the extracted terms for common case usages.
+    For more niche usages, a term can have a cost less than its subterms.
+    As long as there is no negative cost cycle, the default extractor is guaranteed to terminate in computing the costs.
+    However, the user needs to be careful to guarantee acyclicity in the extracted terms.
+    """
+
+    def __call__(self, egraph: EGraph, expr: BaseExpr, children_costs: list[COST]) -> COST:
+        """
+        The total cost of a term given the cost of the root e-node and its immediate children's total costs.
+        """
+        raise NotImplementedError
+
+
+def default_cost_model(egraph: EGraph, expr: BaseExpr, children_costs: list[int]) -> int:
+    """
+    A default cost model for an e-graph, which looks up costs set on function calls, or uses 1 as the default cost.
+    """
+    from .builtins import Container  # noqa: PLC0415
+    from .deconstruct import get_callable_fn  # noqa: PLC0415
+
+    # 1. First prefer if the expr has a custom cost set on it
+    if (
+        (callable_fn := get_callable_fn(expr)) is not None
+        and egraph.has_custom_cost(callable_fn)
+        and (i := egraph.lookup_function_value(get_cost(expr))) is not None
+    ):
+        self_cost = int(i)
+    # 2. Else, check if this is a callable and it has a cost set on its declaration
+    elif callable_fn is not None and (callable_cost := get_callable_cost(callable_fn)) is not None:
+        self_cost = callable_cost
+    # 3. Else, if this is a container, it has no cost, otherwise it has a cost of 1
+    else:
+        # By default, all nodes have a cost of 1 except for containers which have a cost of 0
+        self_cost = 0 if isinstance(expr, Container) else 1
+    # Sum up the costs of the children and our own cost
+    return sum(children_costs, start=self_cost)
+
+
+class ComparableAddSub(Comparable, Protocol):
+    def __add__(self, other: Self) -> Self: ...
+    def __sub__(self, other: Self) -> Self: ...
+
+
+DAG_COST = TypeVar("DAG_COST", bound=ComparableAddSub)
+
+
+@dataclass
+class GreedyDagCost(Generic[DAG_COST]):
+    """
+    Cost of a DAG, which stores children costs. Use `.total` to get the underlying cost.
+    """
+
+    total: DAG_COST
+    _costs: dict[TypedExprDecl, DAG_COST] = field(repr=False)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, GreedyDagCost):
+            return NotImplemented
+        return self.total == other.total
+
+    def __lt__(self, other: Self) -> bool:
+        return self.total < other.total
+
+    def __le__(self, other: Self) -> bool:
+        return self.total <= other.total
+
+    def __gt__(self, other: Self) -> bool:
+        return self.total > other.total
+
+    def __ge__(self, other: Self) -> bool:
+        return self.total >= other.total
+
+    def __hash__(self) -> int:
+        return hash(self.total)
+
+
+@dataclass
+class GreedyDagCostModel(CostModel[GreedyDagCost[DAG_COST]]):
+    """
+    A cost model which will count duplicate nodes only once.
+
+    Should have similar behavior as https://github.com/egraphs-good/extraction-gym/blob/main/src/extract/greedy_dag.rs
+    but implemented as a cost model that will be used with the default extractor.
+    """
+
+    base: CostModel[DAG_COST]
+
+    def __call__(
+        self, egraph: EGraph, expr: BaseExpr, children_costs: list[GreedyDagCost[DAG_COST]]
+    ) -> GreedyDagCost[DAG_COST]:
+        cost = self.base(egraph, expr, [c.total for c in children_costs])
+        for c in children_costs:
+            cost -= c.total
+        costs = {}
+        for c in children_costs:
+            costs.update(c._costs)
+        total = sum(costs.values(), start=cost)
+        costs[to_runtime_expr(expr).__egg_typed_expr__] = cost
+        return GreedyDagCost(total, costs)
+
+
+@overload
+def greedy_dag_cost_model() -> CostModel[GreedyDagCost[int]]: ...
+
+
+@overload
+def greedy_dag_cost_model(base: CostModel[DAG_COST]) -> CostModel[GreedyDagCost[DAG_COST]]: ...
+
+
+def greedy_dag_cost_model(base: CostModel[Any] = default_cost_model) -> CostModel[GreedyDagCost[Any]]:
+    """
+    Creates a greedy dag cost model from a base cost model.
+    """
+    return GreedyDagCostModel(base or default_cost_model)
+
+
+def get_callable_cost(fn: ExprCallable) -> int | None:
+    """
+    Returns the cost of a callable, if it has one set. Otherwise returns None.
+    """
+    callable_ref, decls = resolve_callable(fn)
+    callable_decl = decls.get_callable_decl(callable_ref)
+    return callable_decl.cost if isinstance(callable_decl, ConstructorDecl) else 1
+
+
+@dataclass
+class _CostModel(Generic[COST]):
+    """
+    Implements the methods compatible with the bindings for the cost model.
+    """
+
+    model: CostModel[COST]
+    egraph: EGraph
+    enode_cost_results: dict[tuple[str, tuple[bindings.Value, ...]], int] = field(default_factory=dict)
+    enode_cost_expressions: list[RuntimeExpr] = field(default_factory=list)
+    fold_results: dict[tuple[int, tuple[COST, ...]], COST] = field(default_factory=dict)
+    base_value_cost_results: dict[tuple[str, bindings.Value], COST] = field(default_factory=dict)
+    container_cost_results: dict[tuple[str, bindings.Value, tuple[COST, ...]], COST] = field(default_factory=dict)
+
+    def call_model(self, expr: RuntimeExpr, children_costs: list[COST]) -> COST:
+        return self.model(self.egraph, cast("BaseExpr", expr), children_costs)
+        # if __debug__:
+        #     for c in children_costs:
+        #         if res <= c:
+        #             msg = f"Cost model {self.model} produced a cost {res} less than or equal to a child cost {c} for {expr}"
+        #             raise ValueError(msg)
+
+    def fold(self, _fn: str, index: int, children_costs: list[COST]) -> COST:
+        try:
+            return self.fold_results[(index, tuple(children_costs))]
+        except KeyError:
+            pass
+
+        expr = self.enode_cost_expressions[index]
+        return self.call_model(expr, children_costs)
+
+    # enode cost is only ever called right before fold, for the head_cost
+    def enode_cost(self, name: str, args: list[bindings.Value]) -> int:
+        try:
+            return self.enode_cost_results[(name, tuple(args))]
+        except KeyError:
+            pass
+        (callable_ref,) = self.egraph._state.egg_fn_to_callable_refs[name]
+        signature = self.egraph.__egg_decls__.get_callable_decl(callable_ref).signature
+        assert isinstance(signature, FunctionSignature)
+        arg_exprs = [
+            TypedExprDecl(tp.to_just(), self.egraph._state.value_to_expr(tp.to_just(), arg))
+            for (arg, tp) in zip(args, signature.arg_types, strict=True)
+        ]
+        res_type = signature.semantic_return_type.to_just()
+        res = RuntimeExpr.__from_values__(
+            self.egraph.__egg_decls__,
+            TypedExprDecl(res_type, CallDecl(callable_ref, tuple(arg_exprs))),
+        )
+        index = len(self.enode_cost_expressions)
+        self.enode_cost_expressions.append(res)
+        self.enode_cost_results[(name, tuple(args))] = index
+        return index
+
+    def base_value_cost(self, tp: str, value: bindings.Value) -> COST:
+        try:
+            return self.base_value_cost_results[(tp, value)]
+        except KeyError:
+            pass
+        type_ref = self.egraph._state.egg_sort_to_type_ref[tp]
+        expr = RuntimeExpr.__from_values__(
+            self.egraph.__egg_decls__,
+            TypedExprDecl(type_ref, self.egraph._state.value_to_expr(type_ref, value)),
+        )
+        res = self.call_model(expr, [])
+        self.base_value_cost_results[(tp, value)] = res
+        return res
+
+    def container_cost(self, tp: str, value: bindings.Value, element_costs: list[COST]) -> COST:
+        try:
+            return self.container_cost_results[(tp, value, tuple(element_costs))]
+        except KeyError:
+            pass
+        type_ref = self.egraph._state.egg_sort_to_type_ref[tp]
+        expr = RuntimeExpr.__from_values__(
+            self.egraph.__egg_decls__,
+            TypedExprDecl(type_ref, self.egraph._state.value_to_expr(type_ref, value)),
+        )
+        res = self.call_model(expr, element_costs)
+        self.container_cost_results[(tp, value, tuple(element_costs))] = res
+        return res
+
+    def to_bindings_cost_model(self) -> bindings.CostModel[COST, int]:
+        return bindings.CostModel(self.fold, self.enode_cost, self.container_cost, self.base_value_cost)

egglog/egraph_state.py

@@ -68,6 +68,7 @@ class EGraphState:
 
     # Bidirectional mapping between egg sort names and python type references.
     type_ref_to_egg_sort: dict[JustTypeRef, str] = field(default_factory=dict)
+    egg_sort_to_type_ref: dict[str, JustTypeRef] = field(default_factory=dict)
 
     # Cache of egg expressions for converting to egg
     expr_to_egg_cache: dict[ExprDecl, bindings._Expr] = field(default_factory=dict)
@@ -86,6 +87,7 @@ class EGraphState:
             egg_fn_to_callable_refs=defaultdict(set, {k: v.copy() for k, v in self.egg_fn_to_callable_refs.items()}),
             callable_ref_to_egg_fn=self.callable_ref_to_egg_fn.copy(),
             type_ref_to_egg_sort=self.type_ref_to_egg_sort.copy(),
+            egg_sort_to_type_ref=self.egg_sort_to_type_ref.copy(),
             expr_to_egg_cache=self.expr_to_egg_cache.copy(),
             cost_callables=self.cost_callables.copy(),
         )
@@ -352,6 +354,7 @@ class EGraphState:
         Creates the egg cost table if needed and gets the name of the table.
         """
         name = self.cost_table_name(ref)
+        print(name, self.cost_callables)
         if ref not in self.cost_callables:
             self.cost_callables.add(ref)
             signature = self.__egg_decls__.get_callable_decl(ref).signature
@@ -455,10 +458,14 @@ class EGraphState:
             pass
         decl = self.__egg_decls__._classes[ref.name]
         self.type_ref_to_egg_sort[ref] = egg_name = decl.egg_name or _generate_type_egg_name(ref)
+        self.egg_sort_to_type_ref[egg_name] = ref
         if not decl.builtin or ref.args:
             if ref.args:
                 if ref.name == "UnstableFn":
                     # UnstableFn is a special case, where the rest of args are collected into a call
+                    if len(ref.args) < 2:
+                        msg = "Zero argument higher order functions not supported"
+                        raise NotImplementedError(msg)
                     type_args: list[bindings._Expr] = [
                         bindings.Call(
                             span(),
@@ -589,11 +596,9 @@ class EGraphState:
                     case _:
                         assert_never(value)
                 res = bindings.Lit(span(), l)
-            case CallDecl(ref, args, _):
-                egg_fn, reverse_args = self.callable_ref_to_egg(ref)
-                egg_args = [self.typed_expr_to_egg(a, False) for a in args]
-                if reverse_args:
-                    egg_args.reverse()
+            case CallDecl() | GetCostDecl():
+                egg_fn, typed_args = self.translate_call(expr_decl)
+                egg_args = [self.typed_expr_to_egg(a, False) for a in typed_args]
                 res = bindings.Call(span(), egg_fn, egg_args)
             case PyObjectDecl(value):
                 res = GLOBAL_PY_OBJECT_SORT.store(value)
@@ -604,11 +609,31 @@ class EGraphState:
                     "unstable-fn",
                     [bindings.Lit(span(), bindings.String(egg_fn_call.name)), *egg_fn_call.args],
                 )
+            case ValueDecl():
+                msg = "Cannot turn a Value into an expression"
+                raise ValueError(msg)
             case _:
                 assert_never(expr_decl.expr)
         self.expr_to_egg_cache[expr_decl] = res
         return res
 
+    def translate_call(self, expr: CallDecl | GetCostDecl) -> tuple[str, list[TypedExprDecl]]:
+        """
+        Handle get cost and call decl, turn into egg table name and typed expr decls.
+        """
+        match expr:
+            case CallDecl(ref, args, _):
+                egg_fn, reverse_args = self.callable_ref_to_egg(ref)
+                args_list = list(args)
+                if reverse_args:
+                    args_list.reverse()
+                return egg_fn, args_list
+            case GetCostDecl(ref, args):
+                cost_table = self.create_cost_table(ref)
+                return cost_table, list(args)
+            case _:
+                assert_never(expr)
+
     def exprs_from_egg(
         self, termdag: bindings.TermDag, terms: list[bindings._Term], tp: JustTypeRef
     ) -> Iterable[TypedExprDecl]:
@@ -652,6 +677,129 @@ class EGraphState:
             case _:
                 assert_never(ref)
 
+    def typed_expr_to_value(self, typed_expr: TypedExprDecl) -> bindings.Value:
+        egg_expr = self.typed_expr_to_egg(typed_expr, False)
+        return self.egraph.eval_expr(egg_expr)[1]
+
+    def value_to_expr(self, tp: JustTypeRef, value: bindings.Value) -> ExprDecl:  # noqa: C901, PLR0911, PLR0912
+        match tp.name:
+            # Should match list in egraph bindings
+            case "i64":
+                return LitDecl(self.egraph.value_to_i64(value))
+            case "f64":
+                return LitDecl(self.egraph.value_to_f64(value))
+            case "Bool":
+                return LitDecl(self.egraph.value_to_bool(value))
+            case "String":
+                return LitDecl(self.egraph.value_to_string(value))
+            case "Unit":
+                return LitDecl(None)
+            case "PyObject":
+                return PyObjectDecl(self.egraph.value_to_pyobject(GLOBAL_PY_OBJECT_SORT, value))
+            case "Rational":
+                fraction = self.egraph.value_to_rational(value)
+                return CallDecl(
+                    InitRef("Rational"),
+                    (
+                        TypedExprDecl(JustTypeRef("i64"), LitDecl(fraction.numerator)),
+                        TypedExprDecl(JustTypeRef("i64"), LitDecl(fraction.denominator)),
+                    ),
+                )
+            case "BigInt":
+                i = self.egraph.value_to_bigint(value)
+                return CallDecl(
+                    ClassMethodRef("BigInt", "from_string"),
+                    (TypedExprDecl(JustTypeRef("String"), LitDecl(str(i))),),
+                )
+            case "BigRat":
+                fraction = self.egraph.value_to_bigrat(value)
+                return CallDecl(
+                    InitRef("BigRat"),
+                    (
+                        TypedExprDecl(
+                            JustTypeRef("BigInt"),
+                            CallDecl(
+                                ClassMethodRef("BigInt", "from_string"),
+                                (TypedExprDecl(JustTypeRef("String"), LitDecl(str(fraction.numerator))),),
+                            ),
+                        ),
+                        TypedExprDecl(
+                            JustTypeRef("BigInt"),
+                            CallDecl(
+                                ClassMethodRef("BigInt", "from_string"),
+                                (TypedExprDecl(JustTypeRef("String"), LitDecl(str(fraction.denominator))),),
+                            ),
+                        ),
+                    ),
+                )
+            case "Map":
+                k_tp, v_tp = tp.args
+                expr = CallDecl(ClassMethodRef("Map", "empty"), (), (k_tp, v_tp))
+                for k, v in self.egraph.value_to_map(value).items():
+                    expr = CallDecl(
+                        MethodRef("Map", "insert"),
+                        (
+                            TypedExprDecl(tp, expr),
+                            TypedExprDecl(k_tp, self.value_to_expr(k_tp, k)),
+                            TypedExprDecl(v_tp, self.value_to_expr(v_tp, v)),
+                        ),
+                    )
+                return expr
+            case "Set":
+                xs_ = self.egraph.value_to_set(value)
+                (v_tp,) = tp.args
+                return CallDecl(
+                    InitRef("Set"), tuple(TypedExprDecl(v_tp, self.value_to_expr(v_tp, x)) for x in xs_), (v_tp,)
+                )
+            case "Vec":
+                xs = self.egraph.value_to_vec(value)
+                (v_tp,) = tp.args
+                return CallDecl(
+                    InitRef("Vec"), tuple(TypedExprDecl(v_tp, self.value_to_expr(v_tp, x)) for x in xs), (v_tp,)
+                )
+            case "MultiSet":
+                xs = self.egraph.value_to_multiset(value)
+                (v_tp,) = tp.args
+                return CallDecl(
+                    InitRef("MultiSet"), tuple(TypedExprDecl(v_tp, self.value_to_expr(v_tp, x)) for x in xs), (v_tp,)
+                )
+            case "UnstableFn":
+                _names, _args = self.egraph.value_to_function(value)
+                return_tp, *arg_types = tp.args
+                return self._unstable_fn_value_to_expr(_names, _args, return_tp, arg_types)
+        return ValueDecl(value)
+
+    def _unstable_fn_value_to_expr(
+        self, name: str, partial_args: list[bindings.Value], return_tp: JustTypeRef, _arg_types: list[JustTypeRef]
+    ) -> PartialCallDecl:
+        # Similar to FromEggState::from_call but accepts partial list of args and returns in values
+        # Find first callable ref whose return type matches and fill in arg types.
+        for callable_ref in self.egg_fn_to_callable_refs[name]:
+            signature = self.__egg_decls__.get_callable_decl(callable_ref).signature
+            if not isinstance(signature, FunctionSignature):
+                continue
+            if signature.semantic_return_type.name != return_tp.name:
+                continue
+            tcs = TypeConstraintSolver(self.__egg_decls__)
+
+            arg_types, bound_tp_params = tcs.infer_arg_types(
+                signature.arg_types, signature.semantic_return_type, signature.var_arg_type, return_tp, None
+            )
+
+            args = tuple(
+                TypedExprDecl(tp, self.value_to_expr(tp, v)) for tp, v in zip(arg_types, partial_args, strict=False)
+            )
+
+            call_decl = CallDecl(
+                callable_ref,
+                args,
+                # Don't include bound type params if this is just a method, we only needed them for type resolution
+                # but dont need to store them
+                bound_tp_params if isinstance(callable_ref, ClassMethodRef | InitRef) else (),
+            )
+            return PartialCallDecl(call_decl)
+        raise ValueError(f"Function '{name}' not found")
+
 
 # https://chatgpt.com/share/9ab899b4-4e17-4426-a3f2-79d67a5ec456
 _EGGLOG_INVALID_IDENT = re.compile(r"[^\w\-+*/?!=<>&|^/%]")
@@ -789,7 +937,7 @@ class FromEggState:
                     args,
                     # Don't include bound type params if this is just a method, we only needed them for type resolution
                     # but dont need to store them
-                    bound_tp_params if isinstance(callable_ref, ClassMethodRef | InitRef) else None,
+                    bound_tp_params if isinstance(callable_ref, ClassMethodRef | InitRef) else (),
                 )
         raise ValueError(
             f"Could not find callable ref for call {term}. None of these refs matched the types: {self.state.egg_fn_to_callable_refs[term.name]}"

egglog/exp/array_api_jit.py

@@ -4,7 +4,7 @@ from typing import TypeVar, cast
 
 import numpy as np
 
-from egglog import EGraph
+from egglog import EGraph, greedy_dag_cost_model
 from egglog.exp.array_api import NDArray, set_array_api_egraph, try_evaling
 from egglog.exp.array_api_numba import array_api_numba_schedule
 from egglog.exp.array_api_program_gen import EvalProgram, array_api_program_gen_schedule, ndarray_function_two_program
@@ -41,7 +41,7 @@ def function_to_program(fn: Callable, save_egglog_string: bool) -> tuple[EGraph,
             res = fn(NDArray.var(arg1), NDArray.var(arg2))
         egraph.register(res)
         egraph.run(array_api_numba_schedule)
-        res_optimized = egraph.extract(res)
+        res_optimized = egraph.extract(res, cost_model=greedy_dag_cost_model())
 
     return (
         egraph,

egglog/pretty.py

@@ -183,7 +183,7 @@ class TraverseContext:
                     if isinstance(de, DefaultRewriteDecl):
                         continue
                     self(de)
-            case CallDecl(ref, exprs, _):
+            case CallDecl(ref, exprs, _) | GetCostDecl(ref, exprs):
                 match ref:
                     case FunctionRef(UnnamedFunctionRef(_, res)):
                         self(res.expr)
@@ -205,12 +205,13 @@ class TraverseContext:
             case SetCostDecl(_, e, c):
                 self(e)
                 self(c)
-            case BackOffDecl():
+            case BackOffDecl() | ValueDecl():
                 pass
             case LetSchedulerDecl(scheduler, schedule):
                 self(scheduler)
                 self(schedule)
-
+            case GetCostDecl(ref, args):
+                self(CallDecl(ref, args))
             case _:
                 assert_never(decl)
 
@@ -353,6 +354,10 @@ class PrettyContext:
                 if ban_length is not None:
                     list_args.append(f"ban_length={ban_length}")
                 return f"back_off({', '.join(list_args)})", "scheduler"
+            case ValueDecl(value):
+                return str(value), "value"
+            case GetCostDecl(ref, args):
+                return f"get_cost({self(CallDecl(ref, args))})", "get_cost"
         assert_never(decl)
 
     def _call(

egglog/runtime.py

@@ -457,7 +457,7 @@ class RuntimeFunction(DelayedDeclerations):
         arg_exprs = tuple(arg.__egg_typed_expr__ for arg in upcasted_args)
         return_tp = tcs.substitute_typevars(signature.semantic_return_type, cls_name)
         bound_params = (
-            cast("JustTypeRef", bound_tp).args if isinstance(self.__egg_ref__, ClassMethodRef | InitRef) else None
+            cast("JustTypeRef", bound_tp).args if isinstance(self.__egg_ref__, ClassMethodRef | InitRef) else ()
         )
         # If we were using unstable-app to call a funciton, add that function back as the first arg.
         if function_value:
@@ -584,11 +584,17 @@ class RuntimeExpr(DelayedDeclerations):
         if (method := _get_expr_method(self, "__eq__")) is not None:
             return method(other)
 
-        # TODO: Check if two objects can be upcasted to be the same. If not, then return NotImplemented so other
-        # expr gets a chance to resolve __eq__ which could be a preserved method.
-        from .egraph import BaseExpr, eq  # noqa: PLC0415
+        if not (isinstance(self, RuntimeExpr) and isinstance(other, RuntimeExpr)):
+            return NotImplemented
+        if self.__egg_typed_expr__.tp != other.__egg_typed_expr__.tp:
+            return NotImplemented
 
-        return eq(cast("BaseExpr", self)).to(cast("BaseExpr", other))
+        from .egraph import Fact  # noqa: PLC0415
+
+        return Fact(
+            Declarations.create(self, other),
+            EqDecl(self.__egg_typed_expr__.tp, self.__egg_typed_expr__.expr, other.__egg_typed_expr__.expr),
+        )
 
     def __ne__(self, other: object) -> object:  # type: ignore[override]
         if (method := _get_expr_method(self, "__ne__")) is not None:

egglog/type_constraint_solver.py

@@ -54,7 +54,7 @@ class TypeConstraintSolver:
         fn_var_args: TypeOrVarRef | None,
         return_: JustTypeRef,
         cls_name: str | None,
-    ) -> tuple[Iterable[JustTypeRef], tuple[JustTypeRef, ...] | None]:
+    ) -> tuple[Iterable[JustTypeRef], tuple[JustTypeRef, ...]]:
         """
         Given a return type, infer the argument types. If there is a variable arg, it returns an infinite iterable.
 
@@ -75,7 +75,7 @@ class TypeConstraintSolver:
                 )
             )
             if cls_name
-            else None
+            else ()
         )
         return arg_types, bound_typevars
 

{egglog-11.3.0.dist-info → egglog-11.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: egglog
-Version: 11.3.0
+Version: 11.4.0
 Classifier: Environment :: MacOS X
 Classifier: Environment :: Win32 (MS Windows)
 Classifier: Intended Audience :: Developers

{egglog-11.3.0.dist-info → egglog-11.4.0.dist-info}/RECORD

@@ -1,16 +1,16 @@
-egglog-11.3.0.dist-info/METADATA,sha256=_7z3OUAk7vWdO7bwhHHUwhirFqvbHsguTnkGY9qvidQ,4554
-egglog-11.3.0.dist-info/WHEEL,sha256=Xci0wQUn185O40gd7BpQOd6FhkCRTTECoTx1iWoeZos,131
-egglog-11.3.0.dist-info/licenses/LICENSE,sha256=w7VlVv5O_FPZRo8Z-4Zb_q7D5ac3YDs8JUkMZ4Gq9CE,1070
+egglog-11.4.0.dist-info/METADATA,sha256=QIRn-wS4KchOL4lLxMhdsJKD8Z-7ikr467ysgLww_jM,4554
+egglog-11.4.0.dist-info/WHEEL,sha256=Xci0wQUn185O40gd7BpQOd6FhkCRTTECoTx1iWoeZos,131
+egglog-11.4.0.dist-info/licenses/LICENSE,sha256=w7VlVv5O_FPZRo8Z-4Zb_q7D5ac3YDs8JUkMZ4Gq9CE,1070
 egglog/__init__.py,sha256=0r3MzQbU-9U0fSCeAoJ3deVhZ77tI-1tf8A_WFOhbJs,344
-egglog/bindings.cpython-310-aarch64-linux-gnu.so,sha256=7bRwR1m-c25hqH9s5kumX6FlJw5a73yGfhZ17Y2-AuA,165375536
-egglog/bindings.pyi,sha256=Y_YpdAKmVHZ0nIHTTPeg0sigBEPiS8z_U-Z161zKSK4,15330
-egglog/builtins.py,sha256=qXbBOtT1qwgR9uQu9yb1gUp4dm2L6BgvJIWYU4zCzuw,30317
+egglog/bindings.cpython-310-aarch64-linux-gnu.so,sha256=gYDZxkrNtHtSH3cfbVoPmFupRnYCoVhr4F-ormRcwgo,169197376
+egglog/bindings.pyi,sha256=ntbf2xtpeiabQzUUzx0EdKzu0COXh7sX0_qaUdtB0BY,17874
+egglog/builtins.py,sha256=OSK-JUCKDhpacwPhezPUI9KEru_XIcnA9u9drEyuJi4,30512
 egglog/config.py,sha256=yM3FIcVCKnhWZmHD0pxkzx7ah7t5PxZx3WUqKtA9tjU,168
 egglog/conversion.py,sha256=DO76lxRbbTqHs6hRo_Lckvtwu0c6LaKoX7k5_B2AfuY,11238
-egglog/declarations.py,sha256=pc2KEYwyKNQXuKndbBCC6iuVROgHkaSKJJf_s9liZi8,26260
-egglog/deconstruct.py,sha256=CovORrpROMIwOLgERPUw8doqRUDUehj6LJEB5FMbpmI,5635
-egglog/egraph.py,sha256=zJpAoC6JXXqnRsp24CvQN5M5EZ0PrOj93R9U4w6bqlw,65417
-egglog/egraph_state.py,sha256=3VLwkAsR3oCydHLx_BXmFw4UHXgdZ9jooQdWUcQeUD0,36375
+egglog/declarations.py,sha256=9gFcg0mc86JuJ4DDE_8qm8d324JiTJZxyLMnx59P3qs,26521
+egglog/deconstruct.py,sha256=b7D5uCaLII-JtlMWcOK8s6LWB8nJe2N879iOIio3-ak,5455
+egglog/egraph.py,sha256=nqL6idjBkURnL3gJ7V-EwhyM5pmfo9-CG19TUO6b9f8,77397
+egglog/egraph_state.py,sha256=UOjcY242GZ0E-4lDt_taKihgxdVgVFX4YCWaDW0_AQs,43394
 egglog/examples/README.rst,sha256=ztTvpofR0eotSqGoCy_C1fPLDPCncjvcqDanXtLHNNU,232
 egglog/examples/__init__.py,sha256=wm9evUbMPfbtylXIjbDdRTAVMLH4OjT4Z77PCBFyaPU,31
 egglog/examples/bignum.py,sha256=jfL57XXpQqIqizQQ3sSUCCjTrkdjtB71BmjrQIQorQk,535
@@ -27,20 +27,20 @@ egglog/examples/resolution.py,sha256=BJd5JClA3DBVGfiVRa-H0gbbFvIqeP3uYbhCXHblSQc
 egglog/examples/schedule_demo.py,sha256=JbXdPII7_adxtgyKVAiqCyV2sj88VZ-DhomYrdn8vuc,618
 egglog/exp/__init__.py,sha256=nPtzrH1bz1LVZhZCuS0S9Qild8m5gEikjOVqWAFIa88,49
 egglog/exp/array_api.py,sha256=dKgEufUIyoT7J_RvnyGtOkg_DK25ZnxIgt7olVygaH8,65547
-egglog/exp/array_api_jit.py,sha256=Ak4QhmfYLKimjPf8ffUvPv62OhxOneJ9NEWQJuMxKJc,1680
+egglog/exp/array_api_jit.py,sha256=S5XGWT8a_bFNHUXbQZi6U2cmy__xjvDMNl1eUgvRDyw,1739
 egglog/exp/array_api_loopnest.py,sha256=-kbyorlGxvlaNsLx1nmLfEZHQM7VMEBwSKtV0l-bs0g,2444
 egglog/exp/array_api_numba.py,sha256=X3H1TnCjPL92uVm6OvcWMJ11IeorAE58zWiOX6huPv4,2696
 egglog/exp/array_api_program_gen.py,sha256=qnve8iqklRQVyGChllG8ZAjAffRpezmdxc3IdaWytoQ,21779
 egglog/exp/program_gen.py,sha256=CavsD70x0ERS87V4OU9zkgMvLXswGEpb1ZZFK0WyN_g,13033
 egglog/exp/siu_examples.py,sha256=yZ-sgH2Y12iTdwBUumP7D2OtCGL83M6pPW7PMobVFXc,719
 egglog/ipython_magic.py,sha256=2hs3g2cSiyDmbCvE2t1OINmu17Bb8MWV--2DpEWwO7I,1189
-egglog/pretty.py,sha256=Sv3H9e0CJcZv3-ylijP58ApCQ5w1BOdXl2VDw6Hst4Y,22061
+egglog/pretty.py,sha256=gVq3zHkvyCeVZ_u1uqxICy_2srD1-oRzpP5WqFiGFmY,22378
 egglog/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-egglog/runtime.py,sha256=NUA0O-_urneP54RqXRcPLQIlFzNwPacPKIMxGpwAkus,29672
+egglog/runtime.py,sha256=VatMZWUqMbo_tc6RkdsEhnSuEZbUbropiYZdppn7S4Y,29805
 egglog/thunk.py,sha256=MrAlPoGK36VQrUrq8PWSaJFu42sPL0yupwiH18lNips,2271
-egglog/type_constraint_solver.py,sha256=U2GjLgbebTLv5QY8_TU0As5wMKL5_NxkHLen9rpfMwI,4518
+egglog/type_constraint_solver.py,sha256=jivNkqjRTm38miaoxQoUzTntZbx1yYJO7FhuZWik3lg,4509
 egglog/version_compat.py,sha256=EaKRMIOPcatrx9XjCofxZD6Nr5WOooiWNdoapkKleww,3512
 egglog/visualizer.css,sha256=eL0POoThQRc0P4OYnDT-d808ln9O5Qy6DizH9Z5LgWc,259398
 egglog/visualizer.js,sha256=2qZZ-9W_INJx4gZMYjnVXl27IjT_JNuQyEeI2dbjWoU,3753315
 egglog/visualizer_widget.py,sha256=LtVfzOtv2WeKtNuILQQ_9SOHWvRr8YdBYQDKQSgry_s,1319
-egglog-11.3.0.dist-info/RECORD,,
+egglog-11.4.0.dist-info/RECORD,,