egglog 11.1.0__cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl → 11.3.0__cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

egglog/bindings.pyi

@@ -7,15 +7,16 @@ from typing_extensions import final
 __all__ = [
     "ActionCommand",
     "AddRuleset",
-    "Best",
     "BiRewriteCommand",
     "Bool",
+    "CSVPrintFunctionMode",
     "Call",
     "Change",
     "Check",
     "Constructor",
     "Datatype",
     "Datatypes",
+    "DefaultPrintFunctionMode",
     "Delete",
     "EGraph",
     "EggSmolError",
@@ -23,10 +24,13 @@ __all__ = [
     "Eq",
     "Expr_",
     "Extract",
+    "ExtractBest",
+    "ExtractVariants",
     "Fact",
     "Fail",
     "Float",
     "Function",
+    "FunctionCommand",
     "IdentSort",
     "Include",
     "Input",
@@ -35,10 +39,14 @@ __all__ = [
     "Lit",
     "NewSort",
     "Output",
+    "OverallStatistics",
     "Panic",
     "PanicSpan",
     "Pop",
+    "PrintAllFunctionsSize",
     "PrintFunction",
+    "PrintFunctionOutput",
+    "PrintFunctionSize",
     "PrintOverallStatistics",
     "PrintSize",
     "Push",
@@ -53,13 +61,13 @@ __all__ = [
     "RunConfig",
     "RunReport",
     "RunSchedule",
+    "RunScheduleOutput",
     "RustSpan",
     "Saturate",
     "Schema",
     "Sequence",
     "SerializedEGraph",
     "Set",
-    "SetOption",
     "Sort",
     "SrcFile",
     "String",
@@ -73,13 +81,18 @@ __all__ = [
     "Unit",
     "UnstableCombinedRuleset",
     "UserDefined",
+    "UserDefinedCommandOutput",
+    "UserDefinedOutput",
     "Var",
     "Variant",
-    "Variants",
 ]
 
 @final
 class SerializedEGraph:
+    @property
+    def truncated_functions(self) -> list[str]: ...
+    @property
+    def discarded_functions(self) -> list[str]: ...
     def inline_leaves(self) -> None: ...
     def saturate_inline_leaves(self) -> None: ...
     def to_dot(self) -> str: ...
@@ -106,9 +119,7 @@ class EGraph:
     ) -> None: ...
     def parse_program(self, __input: str, /, filename: str | None = None) -> list[_Command]: ...
     def commands(self) -> str | None: ...
-    def run_program(self, *commands: _Command) -> list[str]: ...
-    def extract_report(self) -> _ExtractReport | None: ...
-    def run_report(self) -> RunReport | None: ...
+    def run_program(self, *commands: _Command) -> list[_CommandOutput]: ...
     def serialize(
         self,
         root_eclasses: list[_Expr],
@@ -356,6 +367,13 @@ class IdentSort:
     sort: str
     def __init__(self, ident: str, sort: str) -> None: ...
 
+@final
+class UserDefinedCommandOutput: ...
+
+@final
+class Function:
+    name: str
+
 @final
 class RunReport:
     updated: bool
@@ -375,20 +393,80 @@ class RunReport:
         rebuild_time_per_ruleset: dict[str, timedelta],
     ) -> None: ...
 
+##
+# Command Outputs
+##
+
+@final
+class PrintFunctionSize:
+    size: int
+    def __init__(self, size: int) -> None: ...
+
+@final
+class PrintAllFunctionsSize:
+    sizes: list[tuple[str, int]]
+    def __init__(self, sizes: list[tuple[str, int]]) -> None: ...
+
 @final
-class Variants:
+class ExtractVariants:
     termdag: TermDag
     terms: list[_Term]
     def __init__(self, termdag: TermDag, terms: list[_Term]) -> None: ...
 
 @final
-class Best:
+class ExtractBest:
     termdag: TermDag
     cost: int
     term: _Term
     def __init__(self, termdag: TermDag, cost: int, term: _Term) -> None: ...
 
-_ExtractReport: TypeAlias = Variants | Best
+@final
+class OverallStatistics:
+    report: RunReport
+    def __init__(self, report: RunReport) -> None: ...
+
+@final
+class RunScheduleOutput:
+    report: RunReport
+    def __init__(self, report: RunReport) -> None: ...
+
+@final
+class PrintFunctionOutput:
+    function: Function
+    termdag: TermDag
+    terms: list[tuple[_Term, _Term]]
+    mode: _PrintFunctionMode
+    def __init__(
+        self, function: Function, termdag: TermDag, terms: list[tuple[_Term, _Term]], mode: _PrintFunctionMode
+    ) -> None: ...
+
+@final
+class UserDefinedOutput:
+    output: UserDefinedCommandOutput
+    def __init__(self, output: UserDefinedCommandOutput) -> None: ...
+
+_CommandOutput: TypeAlias = (
+    PrintFunctionSize
+    | PrintAllFunctionsSize
+    | ExtractVariants
+    | ExtractBest
+    | OverallStatistics
+    | RunScheduleOutput
+    | PrintFunctionOutput
+    | UserDefinedOutput
+)
+
+##
+# Print Function Modes
+##
+
+@final
+class DefaultPrintFunctionMode: ...
+
+@final
+class CSVPrintFunctionMode: ...
+
+_PrintFunctionMode: TypeAlias = DefaultPrintFunctionMode | CSVPrintFunctionMode
 
 ##
 # Schedules
@@ -442,12 +520,6 @@ _Subdatatypes: TypeAlias = SubVariants | NewSort
 # Commands
 ##
 
-@final
-class SetOption:
-    name: str
-    value: _Expr
-    def __init__(self, name: str, value: _Expr) -> None: ...
-
 @final
 class Datatype:
     span: _Span
@@ -469,7 +541,7 @@ class Sort:
     def __init__(self, span: _Span, name: str, presort_and_args: tuple[str, list[_Expr]] | None = None) -> None: ...
 
 @final
-class Function:
+class FunctionCommand:
     span: _Span
     name: str
     schema: Schema
@@ -531,8 +603,12 @@ class Check:
 class PrintFunction:
     span: _Span
     name: str
-    length: int
-    def __init__(self, span: _Span, name: str, length: int) -> None: ...
+    length: int | None
+    filename: str | None
+    mode: _PrintFunctionMode
+    def __init__(
+        self, span: _Span, name: str, length: int | None, filename: str | None, mode: _PrintFunctionMode
+    ) -> None: ...
 
 @final
 class PrintSize:
@@ -613,11 +689,10 @@ class UnstableCombinedRuleset:
     def __init__(self, span: _Span, name: str, rulesets: list[str]) -> None: ...
 
 _Command: TypeAlias = (
-    SetOption
-    | Datatype
+    Datatype
     | Datatypes
     | Sort
-    | Function
+    | FunctionCommand
     | AddRuleset
     | RuleCommand
     | RewriteCommand

egglog/builtins.py

@@ -103,6 +103,10 @@ class String(BuiltinExpr):
     @method(egg_fn="replace")
     def replace(self, old: StringLike, new: StringLike) -> String: ...
 
+    @method(preserve=True)
+    def __add__(self, other: StringLike) -> String:
+        return join(self, other)
+
 
 StringLike: TypeAlias = String | str
 

egglog/declarations.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from functools import cached_property
 from typing import TYPE_CHECKING, ClassVar, Literal, Protocol, TypeAlias, TypeVar, Union, cast, runtime_checkable
+from uuid import UUID
 from weakref import WeakValueDictionary
 
 from typing_extensions import Self, assert_never
@@ -20,6 +21,7 @@ if TYPE_CHECKING:
 __all__ = [
     "ActionCommandDecl",
     "ActionDecl",
+    "BackOffDecl",
     "BiRewriteDecl",
     "CallDecl",
     "CallableDecl",
@@ -52,6 +54,7 @@ __all__ = [
     "JustTypeRef",
     "LetDecl",
     "LetRefDecl",
+    "LetSchedulerDecl",
     "LitDecl",
     "LitType",
     "MethodRef",
@@ -69,6 +72,7 @@ __all__ = [
     "SaturateDecl",
     "ScheduleDecl",
     "SequenceDecl",
+    "SetCostDecl",
     "SetDecl",
     "SpecialFunctions",
     "TypeOrVarRef",
@@ -789,9 +793,24 @@ class SequenceDecl:
 class RunDecl:
     ruleset: str
     until: tuple[FactDecl, ...] | None
+    scheduler: BackOffDecl | None = None
 
 
-ScheduleDecl: TypeAlias = SaturateDecl | RepeatDecl | SequenceDecl | RunDecl
+@dataclass(frozen=True)
+class LetSchedulerDecl:
+    scheduler: BackOffDecl
+    inner: ScheduleDecl
+
+
+ScheduleDecl: TypeAlias = SaturateDecl | RepeatDecl | SequenceDecl | RunDecl | LetSchedulerDecl
+
+
+@dataclass(frozen=True)
+class BackOffDecl:
+    id: UUID
+    match_limit: int | None
+    ban_length: int | None
+
 
 ##
 # Facts
@@ -854,7 +873,14 @@ class PanicDecl:
     msg: str
 
 
-ActionDecl: TypeAlias = LetDecl | SetDecl | ExprActionDecl | ChangeDecl | UnionDecl | PanicDecl
+@dataclass(frozen=True)
+class SetCostDecl:
+    tp: JustTypeRef
+    expr: CallDecl
+    cost: ExprDecl
+
+
+ActionDecl: TypeAlias = LetDecl | SetDecl | ExprActionDecl | ChangeDecl | UnionDecl | PanicDecl | SetCostDecl
 
 
 ##

egglog/egraph.py

@@ -23,6 +23,8 @@ from typing import (
     get_type_hints,
     overload,
 )
+from uuid import uuid4
+from warnings import warn
 
 import graphviz
 from typing_extensions import Never, ParamSpec, Self, Unpack, assert_never
@@ -39,11 +41,12 @@ from .thunk import *
 from .version_compat import *
 
 if TYPE_CHECKING:
-    from .builtins import String, Unit
+    from .builtins import String, Unit, i64Like
 
 
 __all__ = [
     "Action",
+    "BackOff",
     "BaseExpr",
     "BuiltinExpr",
     "Command",
@@ -62,6 +65,7 @@ __all__ = [
     "_RewriteBuilder",
     "_SetBuilder",
     "_UnionBuilder",
+    "back_off",
     "birewrite",
     "check",
     "check_eq",
@@ -83,6 +87,7 @@ __all__ = [
     "run",
     "seq",
     "set_",
+    "set_cost",
     "subsume",
     "union",
     "unstable_combine_rulesets",
@@ -804,7 +809,7 @@ class GraphvizKwargs(TypedDict, total=False):
     max_calls_per_function: int | None
     n_inline_leaves: int
     split_primitive_outputs: bool
-    split_functions: list[object]
+    split_functions: list[ExprCallable]
     include_temporary_functions: bool
 
 
@@ -851,12 +856,12 @@ class EGraph:
         """
         Loads a CSV file and sets it as *input, output of the function.
         """
-        self._egraph.run_program(bindings.Input(span(1), self._callable_to_egg(fn), path))
+        self._egraph.run_program(bindings.Input(span(1), self._callable_to_egg(fn)[1], path))
 
-    def _callable_to_egg(self, fn: object) -> str:
+    def _callable_to_egg(self, fn: ExprCallable) -> tuple[CallableRef, str]:
         ref, decls = resolve_callable(fn)
         self._add_decls(decls)
-        return self._state.callable_ref_to_egg(ref)[0]
+        return ref, self._state.callable_ref_to_egg(ref)[0]
 
     # TODO: Change let to be action...
     def let(self, name: str, expr: BASE_EXPR) -> BASE_EXPR:
@@ -903,13 +908,18 @@ class EGraph:
 
     def _run_schedule(self, schedule: Schedule) -> bindings.RunReport:
         self._add_decls(schedule)
-        egg_schedule = self._state.schedule_to_egg(schedule.schedule)
-        self._egraph.run_program(bindings.RunSchedule(egg_schedule))
-        run_report = self._egraph.run_report()
-        if not run_report:
-            msg = "No run report saved"
-            raise ValueError(msg)
-        return run_report
+        cmd = self._state.run_schedule_to_egg(schedule.schedule)
+        (command_output,) = self._egraph.run_program(cmd)
+        assert isinstance(command_output, bindings.RunScheduleOutput)
+        return command_output.report
+
+    def stats(self) -> bindings.RunReport:
+        """
+        Returns the overall run report for the egraph.
+        """
+        (output,) = self._egraph.run_program(bindings.PrintOverallStatistics())
+        assert isinstance(output, bindings.OverallStatistics)
+        return output.report
 
     def check_bool(self, *facts: FactLike) -> bool:
         """
@@ -954,45 +964,41 @@ class EGraph:
         """
         runtime_expr = to_runtime_expr(expr)
         extract_report = self._run_extract(runtime_expr, 0)
-
-        if not isinstance(extract_report, bindings.Best):
-            msg = "No extract report saved"
-            raise ValueError(msg)  # noqa: TRY004
-        (new_typed_expr,) = self._state.exprs_from_egg(
-            extract_report.termdag, [extract_report.term], runtime_expr.__egg_typed_expr__.tp
-        )
-
-        res = cast("BASE_EXPR", RuntimeExpr.__from_values__(self.__egg_decls__, new_typed_expr))
+        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
 
+    def _from_termdag(self, termdag: bindings.TermDag, term: bindings._Term, tp: JustTypeRef) -> Any:
+        (new_typed_expr,) = self._state.exprs_from_egg(termdag, [term], tp)
+        return RuntimeExpr.__from_values__(self.__egg_decls__, new_typed_expr)
+
     def extract_multiple(self, expr: BASE_EXPR, n: int) -> list[BASE_EXPR]:
         """
         Extract multiple expressions from the egraph.
         """
         runtime_expr = to_runtime_expr(expr)
         extract_report = self._run_extract(runtime_expr, n)
-        if not isinstance(extract_report, bindings.Variants):
-            msg = "Wrong extract report type"
-            raise ValueError(msg)  # noqa: TRY004
+        assert isinstance(extract_report, bindings.ExtractVariants)
         new_exprs = self._state.exprs_from_egg(
             extract_report.termdag, extract_report.terms, runtime_expr.__egg_typed_expr__.tp
         )
         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._ExtractReport:
+    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)))
+        if self._state.cost_callables:
+            cmd: bindings._Command = bindings.UserDefined(span(2), "extract", list(args))
+        else:
+            cmd = bindings.Extract(span(2), *args)
         try:
-            self._egraph.run_program(bindings.Extract(span(2), expr, bindings.Lit(span(2), bindings.Int(n))))
+            return self._egraph.run_program(cmd)[0]
         except BaseException as e:
             raise add_note("Extracting: " + str(expr), e)  # noqa: B904
-        extract_report = self._egraph.extract_report()
-        if not extract_report:
-            msg = "No extract report saved"
-            raise ValueError(msg)
-        return extract_report
 
     def push(self) -> None:
         """
@@ -1030,15 +1036,21 @@ class EGraph:
         split_primitive_outputs = kwargs.pop("split_primitive_outputs", True)
         split_functions = kwargs.pop("split_functions", [])
         include_temporary_functions = kwargs.pop("include_temporary_functions", False)
-        n_inline_leaves = kwargs.pop("n_inline_leaves", 1)
+        n_inline_leaves = kwargs.pop("n_inline_leaves", 0)
         serialized = self._egraph.serialize(
             [],
             max_functions=max_functions,
             max_calls_per_function=max_calls_per_function,
             include_temporary_functions=include_temporary_functions,
         )
+        if serialized.discarded_functions:
+            msg = ", ".join(set(self._state.possible_egglog_functions(serialized.discarded_functions)))
+            warn(f"Omitted: {msg}", stacklevel=3)
+        if serialized.truncated_functions:
+            msg = ", ".join(set(self._state.possible_egglog_functions(serialized.truncated_functions)))
+            warn(f"Truncated: {msg}", stacklevel=3)
         if split_primitive_outputs or split_functions:
-            additional_ops = set(map(self._callable_to_egg, split_functions))
+            additional_ops = {self._callable_to_egg(f)[1] for f in split_functions}
             serialized.split_classes(self._egraph, additional_ops)
         serialized.map_ops(self._state.op_mapping())
 
@@ -1185,6 +1197,58 @@ class EGraph:
                 assert_never(cmd)
         return self._state.command_to_egg(cmd_decl, ruleset_name)
 
+    def function_size(self, fn: ExprCallable) -> int:
+        """
+        Returns the number of rows in a certain function
+        """
+        egg_name = self._callable_to_egg(fn)[1]
+        (output,) = self._egraph.run_program(bindings.PrintSize(span(1), egg_name))
+        assert isinstance(output, bindings.PrintFunctionSize)
+        return output.size
+
+    def all_function_sizes(self) -> list[tuple[ExprCallable, int]]:
+        """
+        Returns a list of all functions and their sizes.
+        """
+        (output,) = self._egraph.run_program(bindings.PrintSize(span(1), None))
+        assert isinstance(output, bindings.PrintAllFunctionsSize)
+        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])
+        ]
+
+    def function_values(
+        self, fn: Callable[..., BASE_EXPR] | BASE_EXPR, length: int | None = None
+    ) -> dict[BASE_EXPR, BASE_EXPR]:
+        """
+        Given a callable that is a "function", meaning it returns a primitive or has a merge set,
+        returns a mapping of the function applied with its arguments to its values
+
+        If length is specified, only the first `length` values will be returned.
+        """
+        ref, egg_name = self._callable_to_egg(fn)
+        cmd = bindings.PrintFunction(span(1), egg_name, length, None, bindings.DefaultPrintFunctionMode())
+        (output,) = self._egraph.run_program(cmd)
+        assert isinstance(output, bindings.PrintFunctionOutput)
+        signature = self.__egg_decls__.get_callable_decl(ref).signature
+        assert isinstance(signature, FunctionSignature)
+        tp = signature.semantic_return_type.to_just()
+        return {
+            self._from_termdag(output.termdag, call, tp): self._from_termdag(output.termdag, res, tp)
+            for (call, res) in output.terms
+        }
+
+
+# Either a constant or a function.
+ExprCallable: TypeAlias = Callable[..., BaseExpr] | BaseExpr
+
 
 @dataclass(frozen=True)
 class _WrappedMethod:
@@ -1406,10 +1470,13 @@ class Fact:
         """
         Returns True if the two sides of an equality are structurally equal.
         """
-        if not isinstance(self.fact, EqDecl):
-            msg = "Can only check equality facts"
-            raise TypeError(msg)
-        return self.fact.left == self.fact.right
+        match self.fact:
+            case EqDecl(_, left, right):
+                return left == right
+            case ExprFactDecl(TypedExprDecl(_, CallDecl(FunctionRef("!="), (left_tp, right_tp)))):
+                return left_tp != right_tp
+        msg = f"Can only check equality for == or != not {self}"
+        raise ValueError(msg)
 
 
 @dataclass
@@ -1457,6 +1524,18 @@ def panic(message: str) -> Action:
     return Action(Declarations(), PanicDecl(message))
 
 
+def set_cost(expr: BaseExpr, cost: i64Like) -> Action:
+    """Set the cost of the given expression."""
+    from .builtins import i64  # noqa: PLC0415
+
+    expr_runtime = to_runtime_expr(expr)
+    typed_expr_decl = expr_runtime.__egg_typed_expr__
+    expr_decl = typed_expr_decl.expr
+    assert isinstance(expr_decl, CallDecl), "Can only set cost of calls, not literals or vars"
+    cost_decl = to_runtime_expr(convert(cost, i64)).__egg_typed_expr__.expr
+    return Action(expr_runtime.__egg_decls__, SetCostDecl(typed_expr_decl.tp, expr_decl, cost_decl))
+
+
 def let(name: str, expr: BaseExpr) -> Action:
     """Create a let binding."""
     runtime_expr = to_runtime_expr(expr)
@@ -1710,17 +1789,51 @@ def to_runtime_expr(expr: BaseExpr) -> RuntimeExpr:
     return expr
 
 
-def run(ruleset: Ruleset | None = None, *until: FactLike) -> Schedule:
+def run(ruleset: Ruleset | None = None, *until: FactLike, scheduler: BackOff | None = None) -> Schedule:
     """
     Create a run configuration.
     """
     facts = _fact_likes(until)
     return Schedule(
         Thunk.fn(Declarations.create, ruleset, *facts),
-        RunDecl(ruleset.__egg_name__ if ruleset else "", tuple(f.fact for f in facts) or None),
+        RunDecl(
+            ruleset.__egg_name__ if ruleset else "",
+            tuple(f.fact for f in facts) or None,
+            scheduler.scheduler if scheduler else None,
+        ),
     )
 
 
+def back_off(match_limit: None | int = None, ban_length: None | int = None) -> BackOff:
+    """
+    Create a backoff scheduler configuration.
+
+    ```python
+    schedule = run(analysis_ruleset).saturate() + run(ruleset, scheduler=back_off(match_limit=1000, ban_length=5)) * 10
+    ```
+    This will run the `analysis_ruleset` until saturation, then run `ruleset` 10 times, using a backoff scheduler.
+    """
+    return BackOff(BackOffDecl(id=uuid4(), match_limit=match_limit, ban_length=ban_length))
+
+
+@dataclass(frozen=True)
+class BackOff:
+    scheduler: BackOffDecl
+
+    def scope(self, schedule: Schedule) -> Schedule:
+        """
+        Defines the scheduler to be created directly before the inner schedule, instead of the default which is at the
+        most outer scope.
+        """
+        return Schedule(schedule.__egg_decls_thunk__, LetSchedulerDecl(self.scheduler, schedule.schedule))
+
+    def __str__(self) -> str:
+        return pretty_decl(Declarations(), self.scheduler)
+
+    def __repr__(self) -> str:
+        return str(self)
+
+
 def seq(*schedules: Schedule) -> Schedule:
     """
     Run a sequence of schedules.

egglog/egraph_state.py

@@ -6,8 +6,9 @@ from __future__ import annotations
 
 import re
 from collections import defaultdict
-from dataclasses import dataclass, field
+from dataclasses import dataclass, field, replace
 from typing import TYPE_CHECKING, Literal, overload
+from uuid import UUID
 
 from typing_extensions import assert_never
 
@@ -71,6 +72,9 @@ class EGraphState:
     # Cache of egg expressions for converting to egg
     expr_to_egg_cache: dict[ExprDecl, bindings._Expr] = field(default_factory=dict)
 
+    # Callables which have cost tables associated with them
+    cost_callables: set[CallableRef] = field(default_factory=set)
+
     def copy(self) -> EGraphState:
         """
         Returns a copy of the state. Th egraph reference is kept the same. Used for pushing/popping.
@@ -83,20 +87,143 @@ class EGraphState:
             callable_ref_to_egg_fn=self.callable_ref_to_egg_fn.copy(),
             type_ref_to_egg_sort=self.type_ref_to_egg_sort.copy(),
             expr_to_egg_cache=self.expr_to_egg_cache.copy(),
+            cost_callables=self.cost_callables.copy(),
         )
 
-    def schedule_to_egg(self, schedule: ScheduleDecl) -> bindings._Schedule:
+    def run_schedule_to_egg(self, schedule: ScheduleDecl) -> bindings._Command:
+        """
+        Turn a run schedule into an egg command.
+
+        If there exists any custom schedulers in the schedule, it will be turned into a custom extract command otherwise
+        will be a normal run command.
+        """
+        processed_schedule = self._process_schedule(schedule)
+        if processed_schedule is None:
+            return bindings.RunSchedule(self._schedule_to_egg(schedule))
+        top_level_schedules = self._schedule_with_scheduler_to_egg(processed_schedule, [])
+        if len(top_level_schedules) == 1:
+            schedule_expr = top_level_schedules[0]
+        else:
+            schedule_expr = bindings.Call(span(), "seq", top_level_schedules)
+        return bindings.UserDefined(span(), "run-schedule", [schedule_expr])
+
+    def _process_schedule(self, schedule: ScheduleDecl) -> ScheduleDecl | None:
+        """
+        Processes a schedule to determine if it contains any custom schedulers.
+
+        If it does, it returns a new schedule with all the required let bindings added to the other scope.
+        If not, returns none.
+
+        Also processes all rulesets in the schedule to make sure they are registered.
+        """
+        bound_schedulers: list[UUID] = []
+        unbound_schedulers: list[BackOffDecl] = []
+
+        def helper(s: ScheduleDecl) -> None:
+            match s:
+                case LetSchedulerDecl(scheduler, inner):
+                    bound_schedulers.append(scheduler.id)
+                    return helper(inner)
+                case RunDecl(ruleset_name, _, scheduler):
+                    self.ruleset_to_egg(ruleset_name)
+                    if scheduler and scheduler.id not in bound_schedulers:
+                        unbound_schedulers.append(scheduler)
+                case SaturateDecl(inner) | RepeatDecl(inner, _):
+                    return helper(inner)
+                case SequenceDecl(schedules):
+                    for sc in schedules:
+                        helper(sc)
+                case _:
+                    assert_never(s)
+            return None
+
+        helper(schedule)
+        if not bound_schedulers and not unbound_schedulers:
+            return None
+        for scheduler in unbound_schedulers:
+            schedule = LetSchedulerDecl(scheduler, schedule)
+        return schedule
+
+    def _schedule_to_egg(self, schedule: ScheduleDecl) -> bindings._Schedule:
+        msg = "Should never reach this, let schedulers should be handled by custom scheduler"
         match schedule:
             case SaturateDecl(schedule):
-                return bindings.Saturate(span(), self.schedule_to_egg(schedule))
+                return bindings.Saturate(span(), self._schedule_to_egg(schedule))
             case RepeatDecl(schedule, times):
-                return bindings.Repeat(span(), times, self.schedule_to_egg(schedule))
+                return bindings.Repeat(span(), times, self._schedule_to_egg(schedule))
             case SequenceDecl(schedules):
-                return bindings.Sequence(span(), [self.schedule_to_egg(s) for s in schedules])
-            case RunDecl(ruleset_name, until):
-                self.ruleset_to_egg(ruleset_name)
+                return bindings.Sequence(span(), [self._schedule_to_egg(s) for s in schedules])
+            case RunDecl(ruleset_name, until, scheduler):
+                if scheduler is not None:
+                    raise ValueError(msg)
                 config = bindings.RunConfig(ruleset_name, None if not until else list(map(self.fact_to_egg, until)))
                 return bindings.Run(span(), config)
+            case LetSchedulerDecl():
+                raise ValueError(msg)
+            case _:
+                assert_never(schedule)
+
+    def _schedule_with_scheduler_to_egg(  # noqa: C901, PLR0912
+        self, schedule: ScheduleDecl, bound_schedulers: list[UUID]
+    ) -> list[bindings._Expr]:
+        """
+        Turns a scheduler into an egg expression, to be used with a custom extract command.
+
+        The bound_schedulers is a list of all the schedulers that have been bound. We can lookup their name as `_scheduler_{index}`.
+        """
+        match schedule:
+            case LetSchedulerDecl(BackOffDecl(id, match_limit, ban_length), inner):
+                name = f"_scheduler_{len(bound_schedulers)}"
+                bound_schedulers.append(id)
+                args: list[bindings._Expr] = []
+                if match_limit is not None:
+                    args.append(bindings.Var(span(), ":match-limit"))
+                    args.append(bindings.Lit(span(), bindings.Int(match_limit)))
+                if ban_length is not None:
+                    args.append(bindings.Var(span(), ":ban-length"))
+                    args.append(bindings.Lit(span(), bindings.Int(ban_length)))
+                back_off_decl = bindings.Call(span(), "back-off", args)
+                let_decl = bindings.Call(span(), "let-scheduler", [bindings.Var(span(), name), back_off_decl])
+                return [let_decl, *self._schedule_with_scheduler_to_egg(inner, bound_schedulers)]
+            case RunDecl(ruleset_name, until, scheduler):
+                args = [bindings.Var(span(), ruleset_name)]
+                if scheduler:
+                    name = "run-with"
+                    scheduler_name = f"_scheduler_{bound_schedulers.index(scheduler.id)}"
+                    args.insert(0, bindings.Var(span(), scheduler_name))
+                else:
+                    name = "run"
+                if until:
+                    if len(until) > 1:
+                        msg = "Can only have one until fact with custom scheduler"
+                        raise ValueError(msg)
+                    args.append(bindings.Var(span(), ":until"))
+                    fact_egg = self.fact_to_egg(until[0])
+                    if isinstance(fact_egg, bindings.Eq):
+                        msg = "Cannot use equality fact with custom scheduler"
+                        raise ValueError(msg)
+                    args.append(fact_egg.expr)
+                return [bindings.Call(span(), name, args)]
+            case SaturateDecl(inner):
+                return [
+                    bindings.Call(span(), "saturate", self._schedule_with_scheduler_to_egg(inner, bound_schedulers))
+                ]
+            case RepeatDecl(inner, times):
+                return [
+                    bindings.Call(
+                        span(),
+                        "repeat",
+                        [
+                            bindings.Lit(span(), bindings.Int(times)),
+                            *self._schedule_with_scheduler_to_egg(inner, bound_schedulers),
+                        ],
+                    )
+                ]
+            case SequenceDecl(schedules):
+                res = []
+                for s in schedules:
+                    res.extend(self._schedule_with_scheduler_to_egg(s, bound_schedulers))
+                return res
             case _:
                 assert_never(schedule)
 
@@ -212,9 +339,32 @@ class EGraphState:
                 return bindings.Union(span(), self._expr_to_egg(lhs), self._expr_to_egg(rhs))
             case PanicDecl(name):
                 return bindings.Panic(span(), name)
+            case SetCostDecl(tp, expr, cost):
+                self.type_ref_to_egg(tp)
+                cost_table = self.create_cost_table(expr.callable)
+                args_egg = [self.typed_expr_to_egg(x, False) for x in expr.args]
+                return bindings.Set(span(), cost_table, args_egg, self._expr_to_egg(cost))
             case _:
                 assert_never(action)
 
+    def create_cost_table(self, ref: CallableRef) -> str:
+        """
+        Creates the egg cost table if needed and gets the name of the table.
+        """
+        name = self.cost_table_name(ref)
+        if ref not in self.cost_callables:
+            self.cost_callables.add(ref)
+            signature = self.__egg_decls__.get_callable_decl(ref).signature
+            assert isinstance(signature, FunctionSignature), "Can only add cost tables for functions"
+            signature = replace(signature, return_type=TypeRefWithVars("i64"))
+            self.egraph.run_program(
+                bindings.FunctionCommand(span(), name, self._signature_to_egg_schema(signature), None)
+            )
+        return name
+
+    def cost_table_name(self, ref: CallableRef) -> str:
+        return f"cost_table_{self.callable_ref_to_egg(ref)[0]}"
+
     def fact_to_egg(self, fact: FactDecl) -> bindings._Fact:
         match fact:
             case EqDecl(tp, left, right):
@@ -225,7 +375,7 @@ class EGraphState:
             case _:
                 assert_never(fact)
 
-    def callable_ref_to_egg(self, ref: CallableRef) -> tuple[str, bool]:
+    def callable_ref_to_egg(self, ref: CallableRef) -> tuple[str, bool]:  # noqa: C901, PLR0912
         """
         Returns the egg function name for a callable reference, registering it if it is not already registered.
 
@@ -245,9 +395,12 @@ class EGraphState:
             case ConstantDecl(tp, _):
                 # Use constructor decleration instead of constant b/c constants cannot be extracted
                 # https://github.com/egraphs-good/egglog/issues/334
-                self.egraph.run_program(
-                    bindings.Constructor(span(), egg_name, bindings.Schema([], self.type_ref_to_egg(tp)), None, False)
-                )
+                is_function = self.__egg_decls__._classes[tp.name].builtin
+                schema = bindings.Schema([], self.type_ref_to_egg(tp))
+                if is_function:
+                    self.egraph.run_program(bindings.FunctionCommand(span(), egg_name, schema, None))
+                else:
+                    self.egraph.run_program(bindings.Constructor(span(), egg_name, schema, None, False))
             case FunctionDecl(signature, builtin, _, merge):
                 if isinstance(signature, FunctionSignature):
                     reverse_args = signature.reverse_args
@@ -263,7 +416,7 @@ class EGraphState:
                         self.egraph.run_program(bindings.Relation(span(), egg_name, schema.input))
                     else:
                         self.egraph.run_program(
-                            bindings.Function(
+                            bindings.FunctionCommand(
                                 span(),
                                 egg_name,
                                 self._signature_to_egg_schema(signature),
@@ -347,13 +500,26 @@ class EGraphState:
         """
         Create a mapping of egglog function name to Python function name, for use in the serialized format
         for better visualization.
+
+        Includes cost tables
         """
         return {
             k: pretty_callable_ref(self.__egg_decls__, next(iter(v)))
             for k, v in self.egg_fn_to_callable_refs.items()
             if len(v) == 1
+        } | {
+            self.cost_table_name(ref): f"cost({pretty_callable_ref(self.__egg_decls__, ref, include_all_args=True)})"
+            for ref in self.cost_callables
         }
 
+    def possible_egglog_functions(self, names: list[str]) -> Iterable[str]:
+        """
+        Given a list of egglog functions, returns all the possible Python function strings
+        """
+        for name in names:
+            for c in self.egg_fn_to_callable_refs[name]:
+                yield pretty_callable_ref(self.__egg_decls__, c)
+
     def typed_expr_to_egg(self, typed_expr_decl: TypedExprDecl, transform_let: bool = True) -> bindings._Expr:
         # transform all expressions with multiple parents into a let binding, so that less expressions
         # are sent to egglog. Only for performance reasons.

egglog/examples/jointree.py

@@ -0,0 +1,64 @@
+# mypy: disable-error-code="empty-body"
+
+"""
+Join Tree (custom costs)
+========================
+
+Example of using custom cost functions for jointree.
+
+From https://egraphs.zulipchat.com/#narrow/stream/328972-general/topic/How.20can.20I.20find.20the.20tree.20associated.20with.20an.20extraction.3F
+"""
+
+from __future__ import annotations
+
+from egglog import *
+
+
+class JoinTree(Expr):
+    def __init__(self, name: StringLike) -> None: ...
+
+    def join(self, other: JoinTree) -> JoinTree: ...
+
+    @method(merge=lambda old, new: old.min(new))  # type:ignore[prop-decorator]
+    @property
+    def size(self) -> i64: ...
+
+
+ra = JoinTree("a")
+rb = JoinTree("b")
+rc = JoinTree("c")
+rd = JoinTree("d")
+re = JoinTree("e")
+rf = JoinTree("f")
+
+query = ra.join(rb).join(rc).join(rd).join(re).join(rf)
+
+egraph = EGraph()
+egraph.register(
+    set_(ra.size).to(50),
+    set_(rb.size).to(200),
+    set_(rc.size).to(10),
+    set_(rd.size).to(123),
+    set_(re.size).to(10000),
+    set_(rf.size).to(1),
+)
+
+
+@egraph.register
+def _rules(s: String, a: JoinTree, b: JoinTree, c: JoinTree, asize: i64, bsize: i64):
+    # cost of relation is its size minus 1, since the string arg will have a cost of 1 as well
+    yield rule(JoinTree(s).size == asize).then(set_cost(JoinTree(s), asize - 1))
+    # cost/size of join is product of sizes
+    yield rule(a.join(b), a.size == asize, b.size == bsize).then(
+        set_(a.join(b).size).to(asize * bsize), set_cost(a.join(b), asize * bsize)
+    )
+    # associativity
+    yield rewrite(a.join(b)).to(b.join(a))
+    # commutativity
+    yield rewrite(a.join(b).join(c)).to(a.join(b.join(c)))
+
+
+egraph.register(query)
+egraph.run(1000)
+print(egraph.extract(query))
+print(egraph.extract(query.size))

egglog/exp/array_api.py

@@ -729,7 +729,7 @@ int64 = DType.int64
 _DTYPES = [float64, float32, int32, int64, DType.object]
 
 converter(type, DType, lambda x: convert(np.dtype(x), DType))
-converter(type(np.dtype), DType, lambda x: getattr(DType, x.name))  # type: ignore[call-overload]
+converter(type(np.dtype), DType, lambda x: getattr(DType, x.name))  # type:ignore[call-overload]
 
 
 @array_api_ruleset.register

egglog/pretty.py

@@ -67,7 +67,9 @@ UNARY_METHODS = {
     "__invert__": "~",
 }
 
-AllDecls: TypeAlias = RulesetDecl | CombinedRulesetDecl | CommandDecl | ActionDecl | FactDecl | ExprDecl | ScheduleDecl
+AllDecls: TypeAlias = (
+    RulesetDecl | CombinedRulesetDecl | CommandDecl | ActionDecl | FactDecl | ExprDecl | ScheduleDecl | BackOffDecl
+)
 
 
 def pretty_decl(
@@ -98,6 +100,7 @@ def pretty_callable_ref(
     ref: CallableRef,
     first_arg: ExprDecl | None = None,
     bound_tp_params: tuple[JustTypeRef, ...] | None = None,
+    include_all_args: bool = False,
 ) -> str:
     """
     Pretty print a callable reference, using a dummy value for
@@ -115,6 +118,13 @@ def pretty_callable_ref(
     # Either returns a function or a function with args. If args are provided, they would just be called,
     # on the function, so return them, because they are dummies
     if isinstance(res, tuple):
+        # If we want to include all args as ARG_STR, then we need to figure out how many to use
+        # used for set_cost so that `cost(E(...))` will show up as a call
+        if include_all_args:
+            signature = decls.get_callable_decl(ref).signature
+            assert isinstance(signature, FunctionSignature)
+            correct_args: list[ExprDecl] = [UnboundVarDecl(ARG_STR)] * len(signature.arg_types)
+            return f"{res[0]}({', '.join(context(a, parens=False, unwrap_lit=True) for a in correct_args)})"
         return res[0]
     return res
 
@@ -180,16 +190,27 @@ class TraverseContext:
                     case _:
                         for e in exprs:
                             self(e.expr)
-            case RunDecl(_, until):
+            case RunDecl(_, until, scheduler):
                 if until:
                     for f in until:
                         self(f)
+                if scheduler:
+                    self(scheduler)
             case PartialCallDecl(c):
                 self(c)
             case CombinedRulesetDecl(_):
                 pass
             case DefaultRewriteDecl():
                 pass
+            case SetCostDecl(_, e, c):
+                self(e)
+                self(c)
+            case BackOffDecl():
+                pass
+            case LetSchedulerDecl(scheduler, schedule):
+                self(scheduler)
+                self(schedule)
+
             case _:
                 assert_never(decl)
 
@@ -227,7 +248,11 @@ class PrettyContext:
         # it would take up is > than some constant (~ line length).
         line_diff: int = len(expr) - LINE_DIFFERENCE
         n_parents = self.parents[decl]
-        if n_parents > 1 and n_parents * line_diff > MAX_LINE_LENGTH:
+        if n_parents > 1 and (
+            n_parents * line_diff > MAX_LINE_LENGTH
+            # Schedulers with multiple parents need to be the same object, b/c are created with hidden UUIDs
+            or tp_name == "scheduler"
+        ):
             self.names[decl] = expr_name = self._name_expr(tp_name, expr, copy_identifier=False)
             return expr_name
         return expr
@@ -285,6 +310,8 @@ class PrettyContext:
                 return f"{change}({self(expr)})", "action"
             case PanicDecl(s):
                 return f"panic({s!r})", "action"
+            case SetCostDecl(_, expr, cost):
+                return f"set_cost({self(expr)}, {self(cost, unwrap_lit=True)})", "action"
             case EqDecl(_, left, right):
                 return f"eq({self(left)}).to({self(right)})", "fact"
             case RulesetDecl(rules):
@@ -305,16 +332,27 @@ class PrettyContext:
                     return f"{self(schedules[0], parens=True)} + {self(schedules[1], parens=True)}", "schedule"
                 args = ", ".join(map(self, schedules))
                 return f"seq({args})", "schedule"
-            case RunDecl(ruleset_name, until):
+            case LetSchedulerDecl(scheduler, schedule):
+                return f"{self(scheduler, parens=True)}.scope({self(schedule, parens=True)})", "schedule"
+            case RunDecl(ruleset_name, until, scheduler):
                 ruleset = self.decls._rulesets[ruleset_name]
                 ruleset_str = self(ruleset, ruleset_name=ruleset_name)
-                if not until:
+                if not until and not scheduler:
                     return ruleset_str, "schedule"
-                args = ", ".join(map(self, until))
-                return f"run({ruleset_str}, {args})", "schedule"
+                arg_lst = list(map(self, until or []))
+                if scheduler:
+                    arg_lst.append(f"scheduler={self(scheduler)}")
+                return f"run({ruleset_str}, {', '.join(arg_lst)})", "schedule"
             case DefaultRewriteDecl():
                 msg = "default rewrites should not be pretty printed"
                 raise TypeError(msg)
+            case BackOffDecl(_, match_limit, ban_length):
+                list_args: list[str] = []
+                if match_limit is not None:
+                    list_args.append(f"match_limit={match_limit}")
+                if ban_length is not None:
+                    list_args.append(f"ban_length={ban_length}")
+                return f"back_off({', '.join(list_args)})", "scheduler"
         assert_never(decl)
 
     def _call(

egglog/runtime.py

@@ -20,6 +20,8 @@ from inspect import Parameter, Signature
 from itertools import zip_longest
 from typing import TYPE_CHECKING, Any, TypeVar, Union, cast, get_args, get_origin
 
+from typing_extensions import assert_never
+
 from .declarations import *
 from .pretty import *
 from .thunk import Thunk
@@ -36,6 +38,7 @@ __all__ = [
     "RuntimeClass",
     "RuntimeExpr",
     "RuntimeFunction",
+    "create_callable",
     "define_expr_method",
     "resolve_callable",
     "resolve_type_annotation",
@@ -340,7 +343,7 @@ class RuntimeClass(DelayedDeclerations, metaclass=ClassFactory):
 
     # Make hashable so can go in Union
     def __hash__(self) -> int:
-        return hash((id(self.__egg_decls_thunk__), self.__egg_tp__))
+        return hash(self.__egg_tp__)
 
     def __eq__(self, other: object) -> bool:
         """
@@ -478,6 +481,9 @@ class RuntimeFunction(DelayedDeclerations):
                 bound_tp_params = args
         return pretty_callable_ref(self.__egg_decls__, self.__egg_ref__, first_arg, bound_tp_params)
 
+    def __repr__(self) -> str:
+        return str(self)
+
 
 def to_py_signature(sig: FunctionSignature, decls: Declarations, optional_args: bool) -> Signature:
     """
@@ -629,14 +635,22 @@ for name in TYPE_DEFINED_METHODS:
 
 
 for name, r_method in itertools.product(NUMERIC_BINARY_METHODS, (False, True)):
+    method_name = f"__r{name[2:]}" if r_method else name
 
-    def _numeric_binary_method(self: object, other: object, name: str = name, r_method: bool = r_method) -> object:
+    def _numeric_binary_method(
+        self: object, other: object, name: str = name, r_method: bool = r_method, method_name: str = method_name
+    ) -> object:
         """
         Implements numeric binary operations.
 
         Tries to find the minimum cost conversion of either the LHS or the RHS, by finding all methods with either
         the LHS or the RHS as exactly the right type and then upcasting the other to that type.
         """
+        # First check if we have a preserved method for this:
+        if isinstance(self, RuntimeExpr) and (
+            (preserved_method := self.__egg_class_decl__.preserved_methods.get(method_name)) is not None
+        ):
+            return preserved_method.__get__(self)(other)
         # 1. switch if reversed method
         if r_method:
             self, other = other, self
@@ -662,7 +676,6 @@ for name, r_method in itertools.product(NUMERIC_BINARY_METHODS, (False, True)):
         fn = RuntimeFunction(Thunk.value(self.__egg_decls__), Thunk.value(method_ref), self)
         return fn(other)
 
-    method_name = f"__r{name[2:]}" if r_method else name
     setattr(RuntimeExpr, method_name, _numeric_binary_method)
 
 
@@ -670,16 +683,39 @@ def resolve_callable(callable: object) -> tuple[CallableRef, Declarations]:
     """
     Resolves a runtime callable into a ref
     """
+    # TODO: Make runtime class work with __match_args__
+    if isinstance(callable, RuntimeClass):
+        return InitRef(callable.__egg_tp__.name), callable.__egg_decls__
     match callable:
         case RuntimeFunction(decls, ref, _):
             return ref(), decls()
-        case RuntimeClass(thunk, tp):
-            return InitRef(tp.name), thunk()
         case RuntimeExpr(decl_thunk, expr_thunk):
             if not isinstance((expr := expr_thunk().expr), CallDecl) or not isinstance(
                 expr.callable, ConstantRef | ClassVariableRef
             ):
                 raise NotImplementedError(f"Can only turn constants or classvars into callable refs, not {expr}")
             return expr.callable, decl_thunk()
+        case types.MethodWrapperType() if isinstance((slf := callable.__self__), RuntimeClass):
+            return MethodRef(slf.__egg_tp__.name, callable.__name__), slf.__egg_decls__
         case _:
             raise NotImplementedError(f"Cannot turn {callable} of type {type(callable)} into a callable ref")
+
+
+def create_callable(decls: Declarations, ref: CallableRef) -> RuntimeClass | RuntimeFunction | RuntimeExpr:
+    """
+    Creates a callable object from a callable ref. This might not actually be callable, if the ref is a constant
+    or classvar then it is a value
+    """
+    match ref:
+        case InitRef(name):
+            return RuntimeClass(Thunk.value(decls), TypeRefWithVars(name))
+        case FunctionRef() | MethodRef() | ClassMethodRef() | PropertyRef() | UnnamedFunctionRef():
+            bound = JustTypeRef(ref.class_name) if isinstance(ref, ClassMethodRef) else None
+            return RuntimeFunction(Thunk.value(decls), Thunk.value(ref), bound)
+        case ConstantRef(name):
+            tp = decls._constants[name].type_ref
+        case ClassVariableRef(cls_name, var_name):
+            tp = decls._classes[cls_name].class_variables[var_name].type_ref
+        case _:
+            assert_never(ref)
+    return RuntimeExpr.__from_values__(decls, TypedExprDecl(tp, CallDecl(ref)))

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: egglog
-Version: 11.1.0
+Version: 11.3.0
 Classifier: Environment :: MacOS X
 Classifier: Environment :: Win32 (MS Windows)
 Classifier: Intended Audience :: Developers
@@ -51,6 +51,7 @@ Requires-Dist: egglog[array] ; extra == 'docs'
 Requires-Dist: line-profiler ; extra == 'docs'
 Requires-Dist: sphinxcontrib-mermaid ; extra == 'docs'
 Requires-Dist: ablog ; extra == 'docs'
+Requires-Dist: jupytext ; extra == 'docs'
 Provides-Extra: array
 Provides-Extra: dev
 Provides-Extra: test
@@ -72,3 +73,20 @@ Please see the [documentation](https://egglog-python.readthedocs.io/) for more i
 
 Come say hello [on the e-graphs Zulip](https://egraphs.zulipchat.com/#narrow/stream/375765-egglog/) or [open an issue](https://github.com/egraphs-good/egglog-python/issues/new/choose)!
 
+## How to cite
+
+If you use **egglog-python** in academic work, please cite the paper:
+
+```bibtex
+@misc{Shanabrook2023EgglogPython,
+  title         = {Egglog Python: A Pythonic Library for E-graphs},
+  author        = {Saul Shanabrook},
+  year          = {2023},
+  eprint        = {2305.04311},
+  archivePrefix = {arXiv},
+  primaryClass  = {cs.PL},
+  doi           = {10.48550/arXiv.2305.04311},
+  url           = {https://arxiv.org/abs/2305.04311},
+  note          = {Presented at EGRAPHS@PLDI 2023}
+}
+

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

@@ -1,16 +1,16 @@
-egglog-11.1.0.dist-info/METADATA,sha256=u53IcPcs6w0Rry3b4tw2IDFN0qwIOIgbGmj_3Op0FPo,4009
-egglog-11.1.0.dist-info/WHEEL,sha256=WOapvHFWH1O3Q1AEWvOQCTKe4qD8FOigaaTy_ttZRwc,131
-egglog-11.1.0.dist-info/licenses/LICENSE,sha256=w7VlVv5O_FPZRo8Z-4Zb_q7D5ac3YDs8JUkMZ4Gq9CE,1070
+egglog-11.3.0.dist-info/METADATA,sha256=_7z3OUAk7vWdO7bwhHHUwhirFqvbHsguTnkGY9qvidQ,4554
+egglog-11.3.0.dist-info/WHEEL,sha256=3R3DgP37R_2MILtHtgWmnXDQzWI-RVLBA9j43Bjy2wA,131
+egglog-11.3.0.dist-info/licenses/LICENSE,sha256=w7VlVv5O_FPZRo8Z-4Zb_q7D5ac3YDs8JUkMZ4Gq9CE,1070
 egglog/__init__.py,sha256=0r3MzQbU-9U0fSCeAoJ3deVhZ77tI-1tf8A_WFOhbJs,344
-egglog/bindings.cpython-312-aarch64-linux-gnu.so,sha256=jC1zDwvBpqo6suSYMI_kNO9ABDCyBd42HET5CtjTxfg,201889224
-egglog/bindings.pyi,sha256=QDgs0hKl2xl4Q6f7hXjfDANoMADRrGTYTdGYdri7Vqg,13642
-egglog/builtins.py,sha256=bF3GanSmsrIIutvuMUmr4SnSNF0zAEwjmDYWbPEEayo,30204
+egglog/bindings.cpython-312-aarch64-linux-gnu.so,sha256=D1GskDcmJlVOWtx0AsiGEod40edait_m6CGffyTXrWc,165872672
+egglog/bindings.pyi,sha256=Y_YpdAKmVHZ0nIHTTPeg0sigBEPiS8z_U-Z161zKSK4,15330
+egglog/builtins.py,sha256=qXbBOtT1qwgR9uQu9yb1gUp4dm2L6BgvJIWYU4zCzuw,30317
 egglog/config.py,sha256=yM3FIcVCKnhWZmHD0pxkzx7ah7t5PxZx3WUqKtA9tjU,168
 egglog/conversion.py,sha256=DO76lxRbbTqHs6hRo_Lckvtwu0c6LaKoX7k5_B2AfuY,11238
-egglog/declarations.py,sha256=CA8gWolJChVt6-xDL7XvV5ORjNj3O8PREobYCzVFxDI,25784
+egglog/declarations.py,sha256=pc2KEYwyKNQXuKndbBCC6iuVROgHkaSKJJf_s9liZi8,26260
 egglog/deconstruct.py,sha256=CovORrpROMIwOLgERPUw8doqRUDUehj6LJEB5FMbpmI,5635
-egglog/egraph.py,sha256=niBx_EAbQhzjupJs_wZ9oIbjF7W_ttx9D0u1iB059HM,60601
-egglog/egraph_state.py,sha256=8-u0BLAHlWgoo_KiyW_aqC6nj_X0XgMFRlXWIyPjF64,28356
+egglog/egraph.py,sha256=zJpAoC6JXXqnRsp24CvQN5M5EZ0PrOj93R9U4w6bqlw,65417
+egglog/egraph_state.py,sha256=3VLwkAsR3oCydHLx_BXmFw4UHXgdZ9jooQdWUcQeUD0,36375
 egglog/examples/README.rst,sha256=ztTvpofR0eotSqGoCy_C1fPLDPCncjvcqDanXtLHNNU,232
 egglog/examples/__init__.py,sha256=wm9evUbMPfbtylXIjbDdRTAVMLH4OjT4Z77PCBFyaPU,31
 egglog/examples/bignum.py,sha256=jfL57XXpQqIqizQQ3sSUCCjTrkdjtB71BmjrQIQorQk,535
@@ -18,6 +18,7 @@ egglog/examples/bool.py,sha256=e0z2YoYJsLlhpSADZK1yRYHzilyxSZWGiYAaM0DQ_Gw,695
 egglog/examples/eqsat_basic.py,sha256=2xtM81gG9Br72mr58N-2BUeksR7C_UXnZJ4MvzSPplc,869
 egglog/examples/fib.py,sha256=BOHxKWA7jGx4FURBmfmuZKfLo6xq9-uXAwAXjYid7LU,492
 egglog/examples/higher_order_functions.py,sha256=DNLIQfPJCX_DOLbHNiaYsfvcFIYCYOsRUqp99r9bpc8,1063
+egglog/examples/jointree.py,sha256=TLlH7TsQzWfadqDo7qeTprFhLdQmj59AQaGse81RIKk,1714
 egglog/examples/lambda_.py,sha256=iQvwaXVhp2VNOMS7j1WwceZaiq3dqqilwUkMcW5GFBE,8194
 egglog/examples/matrix.py,sha256=7_mPcMcgE-t_GJDyf76-nv3xhPIeN2mvFkc_p_Gnr8g,4961
 egglog/examples/multiset.py,sha256=IBOsB80DkXQ07dYnk1odi27q77LH80Z8zysuLE-Q8F8,1445
@@ -25,7 +26,7 @@ egglog/examples/ndarrays.py,sha256=mfr410eletH8gfdg-P8L90vlF6TUifvYV_-ryOwvZZE,4
 egglog/examples/resolution.py,sha256=BJd5JClA3DBVGfiVRa-H0gbbFvIqeP3uYbhCXHblSQc,2119
 egglog/examples/schedule_demo.py,sha256=JbXdPII7_adxtgyKVAiqCyV2sj88VZ-DhomYrdn8vuc,618
 egglog/exp/__init__.py,sha256=nPtzrH1bz1LVZhZCuS0S9Qild8m5gEikjOVqWAFIa88,49
-egglog/exp/array_api.py,sha256=B4tr5DyC8jkKxdax7k98LK-iXOrsBceSaijwYTEnG-Q,65548
+egglog/exp/array_api.py,sha256=dKgEufUIyoT7J_RvnyGtOkg_DK25ZnxIgt7olVygaH8,65547
 egglog/exp/array_api_jit.py,sha256=Ak4QhmfYLKimjPf8ffUvPv62OhxOneJ9NEWQJuMxKJc,1680
 egglog/exp/array_api_loopnest.py,sha256=-kbyorlGxvlaNsLx1nmLfEZHQM7VMEBwSKtV0l-bs0g,2444
 egglog/exp/array_api_numba.py,sha256=X3H1TnCjPL92uVm6OvcWMJ11IeorAE58zWiOX6huPv4,2696
@@ -33,13 +34,13 @@ egglog/exp/array_api_program_gen.py,sha256=qnve8iqklRQVyGChllG8ZAjAffRpezmdxc3Id
 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=TCkwZIecdFT5eMIy0GGAZuKvPUt0fQeh5K1srgnCJLo,20136
+egglog/pretty.py,sha256=Sv3H9e0CJcZv3-ylijP58ApCQ5w1BOdXl2VDw6Hst4Y,22061
 egglog/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-egglog/runtime.py,sha256=8y1YQ5vFuoHr9B8LGTeQBHZin7S8LYHlsR93LlNl2uo,27979
+egglog/runtime.py,sha256=NUA0O-_urneP54RqXRcPLQIlFzNwPacPKIMxGpwAkus,29672
 egglog/thunk.py,sha256=MrAlPoGK36VQrUrq8PWSaJFu42sPL0yupwiH18lNips,2271
 egglog/type_constraint_solver.py,sha256=U2GjLgbebTLv5QY8_TU0As5wMKL5_NxkHLen9rpfMwI,4518
 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.1.0.dist-info/RECORD,,
+egglog-11.3.0.dist-info/RECORD,,

{egglog-11.1.0.dist-info → egglog-11.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: maturin (1.9.3)
+Generator: maturin (1.9.4)
 Root-Is-Purelib: false
 Tag: cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64