egglog 4.0.0__tar.gz → 5.0.0__tar.gz

{egglog-4.0.0 → egglog-5.0.0}/.pre-commit-config.yaml

@@ -5,7 +5,7 @@ ci:
   skip: [mypy, docs, stubtest]
 repos:
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.1.6
+    rev: v0.1.9
     hooks:
       - id: ruff
         args: [--fix, --exit-non-zero-on-fix]

{egglog-4.0.0 → egglog-5.0.0}/Cargo.lock

@@ -312,7 +312,7 @@ dependencies = [
 
 [[package]]
 name = "egglog-python"
-version = "4.0.0"
+version = "5.0.0"
 dependencies = [
  "egglog",
  "egraph-serialize",

{egglog-4.0.0 → egglog-5.0.0}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "egglog-python"
-version = "4.0.0"
+version = "5.0.0"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

{egglog-4.0.0 → egglog-5.0.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: egglog
-Version: 4.0.0
+Version: 5.0.0
 Classifier: Environment :: MacOS X
 Classifier: Environment :: Win32 (MS Windows)
 Classifier: Intended Audience :: Developers
@@ -26,11 +26,6 @@ Requires-Dist: egglog[array]; extra == 'test'
 Requires-Dist: scikit-learn; extra == 'array'
 Requires-Dist: array_api_compat; extra == 'array'
 Requires-Dist: numba; (python_version<"3.12") and extra == 'array'
-Requires-Dist: pre-commit; extra == 'dev'
-Requires-Dist: ruff; extra == 'dev'
-Requires-Dist: mypy; extra == 'dev'
-Requires-Dist: anywidget[dev]; extra == 'dev'
-Requires-Dist: egglog[docs,test]; extra == 'dev'
 Requires-Dist: pydata-sphinx-theme; extra == 'docs'
 Requires-Dist: myst-nb; extra == 'docs'
 Requires-Dist: sphinx-autodoc-typehints; extra == 'docs'
@@ -43,10 +38,15 @@ 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: pre-commit; extra == 'dev'
+Requires-Dist: ruff; extra == 'dev'
+Requires-Dist: mypy; extra == 'dev'
+Requires-Dist: anywidget[dev]; extra == 'dev'
+Requires-Dist: egglog[docs,test]; extra == 'dev'
 Provides-Extra: test
 Provides-Extra: array
-Provides-Extra: dev
 Provides-Extra: docs
+Provides-Extra: dev
 License-File: LICENSE
 Summary: e-graphs in Python built around the the egglog rust library
 License: MIT
@@ -60,7 +60,7 @@ Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
 `egglog` is a Python package that provides bindings to the Rust library [`egglog`](https://github.com/egraphs-good/egglog/),
 allowing you to use e-graphs in Python for optimization, symbolic computation, and analysis.
 
-Please see the [documentation](https://egglog-python.readthedocs.io/en/latest/?badge=latest) for more information.
+Please see the [documentation](https://egglog-python.readthedocs.io/) for more information.
 
 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)!
 

{egglog-4.0.0 → egglog-5.0.0}/README.md

@@ -5,6 +5,6 @@
 `egglog` is a Python package that provides bindings to the Rust library [`egglog`](https://github.com/egraphs-good/egglog/),
 allowing you to use e-graphs in Python for optimization, symbolic computation, and analysis.
 
-Please see the [documentation](https://egglog-python.readthedocs.io/en/latest/?badge=latest) for more information.
+Please see the [documentation](https://egglog-python.readthedocs.io/) for more information.
 
 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)!

{egglog-4.0.0 → egglog-5.0.0}/docs/changelog.md

@@ -2,7 +2,16 @@
 
 _This project uses semantic versioning_
 
-## Unreleased
+## UNRELEASED
+
+## 5.0.0 (2024-01-16)
+
+- Move egglog `!=` function to be called with `ne(x).to(y)` instead of `x != y` so that user defined expressions
+  can
+
+## 4.0.1 (2023-11-27)
+
+- Fix keyword args for `__init__` methods (#96)[https://github.com/metadsl/egglog-python/pull/96].
 
 ## 4.0.0 (2023-11-24)
 

egglog-5.0.0/docs/explanation/2023_12_02_congruence_closure.md

@@ -0,0 +1,188 @@
+---
+file_format: mystnb
+---
+
+```{post} 2023-12-02
+
+```
+
+# Original Congruence Closure Paper
+
+_In this post, I re-create the examples from the original 1980 paper defining the "congruence closure" of a graph in Python._
+
+## Background
+
+Over the past few days, I have been learning more about the differences in egglog between equality based types
+and primitive values (see [issue](https://github.com/egraphs-good/egglog/issues/298) and [pr](https://github.com/egraphs-good/egglog/pull/309)).
+
+It got me thinking more about the core e-graph data structures and so I spent today finally taking a look at
+some of the papers [Talia Ringer reccomended](https://github.com/saulshanabrook/saulshanabrook/discussions/27#:~:text=Licata%20at%20Wesleyan-,Talia%20Ringer,-I%20was%20talking)
+from the [e-graph week of their proof automation class](https://dependenttyp.es/classes/fa2022/readings/17-egraphs.html), which include:
+
+- ["Congruence Closure in Intensional Type Theory" by Daniel Selsam and Leonardo de Moura in 2016](https://arxiv.org/pdf/1701.04391.pdf) on congruence close with dependent types.
+- ["Congruence Closure in Cubical Type Theory" by Emil Holm Gjørup and Bas Spitters](https://cs.au.dk/~spitters/Emil.pdf) as a follow up on the above to adapt it to cubical type theory.
+- ["Cubical methods in homotopy type theory and univalent foundations" by Anders Mörtberg in 2021](https://www.cambridge.org/core/journals/mathematical-structures-in-computer-science/article/cubical-methods-in-homotopy-type-theory-and-univalent-foundations/ECB3FE6B4A0B19AED2D3A2D785C38AF9) as an introduction to cubical type theory.
+
+In the first sentance of the intro of the first paper it introduces the concept of "congruence closure" as important for program verification:
+
+> Congruence closure procedures are used extensively in automated reasoning,
+> since almost all proofs in both program verification and formalized mathematics
+> require reasoning about equalities [23].
+
+I went to follow that citation and read the original paper [**"Fast decision procedures based on congruence closure"** by Nelson and Oppen in 1980](https://dl.acm.org/doi/10.1145/322186.322198).
+
+It was fun to see the original definitions of the congruence closure and to see what problems they were using it to solve.
+
+In this post, I thought it would be cool to re-create the examples using the `egglog` library in Python. We won't get into the looking at how to implement the core algorithms, feel free to refer to the paper for those, but just to use the library
+to help give us a visual and tactile feel for how the structures work.
+
+It's nice to see that the concepts from the paper map very closely to the interface of the library, which I think is a testamont to the design of the abstractions in the underlying [`egglog` rust library](https://github.com/egraphs-good/egglog).
+
+## "3. The Quantifier-Free Theory of Equality"
+
+Again, if take a look at just the first sentance of the paper, it gets straight to the point:
+
+![](./2023_12_02_congruence_closure-1.png)
+
+Let's see if we can encode this in `egglog`. Since it is strongly typed, we have to defined a dummy type `T` to represent the type of all terms. Since all functions need a fixed number of args, we have to define two functions `f` which takes
+two args and `f1` which takes one arg:
+
+```{code-cell} python
+from egglog import *
+
+egraph = EGraph()
+
+@egraph.class_
+class T: pass
+
+a = egraph.constant("a", T)
+b = egraph.constant("b", T)
+
+@egraph.function
+def f(x: T, y: T) -> T: pass
+
+@egraph.function
+def f1(x: T) -> T: pass
+```
+
+Now we can get started trying to prove the examples.
+
+First, we can start by trying to prove that `f(a, b) = a` implies `f(f(a, b), b) = a`:
+
+```{code-cell} python
+
+with egraph:
+    # start with our initial assumption
+    egraph.register(
+        union(f(a, b)).with_(a)
+    )
+    # Verify that we can prove the result
+    egraph.check(
+        eq(f(f(a, b), b)).to(a)
+    )
+    egraph.display()
+```
+
+One way to visually prove this is to see that `a` is in the same equivalence class (shows up as a cluster around multiple nodes in the graph) as `f(f(a, b), b)`, if we follow the arguments of `f`, the first is self referential to the same e-class, so we can follow it once more to get to a `f(f(a, b), b)` node.
+
+The second example is a bit more interesting. We can display the e-graph twice. Once after adding the first assumption `f(f(f(a)))` and then again after adding the second assumption `f(f(f(f(f(a)))))`:
+
+```{code-cell} python
+
+with egraph:
+    egraph.register(
+        union(f1(f1(f1(a)))).with_(a),
+    )
+    egraph.display()
+    egraph.register(
+        union(f1(f1(f1(f1(f1(a)))))).with_(a),
+    )
+    egraph.check(eq(f1(a)).to(a))
+```
+
+We see that now `f(a)` is in the same e-class as `a` and so we can prove that `f(a) = a`.
+
+I really enjoy how by converting these equivalence into these graphical forms makes proving equivalences about them intuitive and visual.
+
+## "4. Extension to Theories of List Structure"
+
+Now lets take a look at the second use case it outlines, which is to be able to prove properties about lists:
+
+![](./2023_12_02_congruence_closure-2.png)
+
+Again we start be definying our required functions:
+
+```{code-cell} python
+@egraph.function
+def cons(x: T, y: T) -> T: pass
+
+@egraph.function
+def car(x: T) -> T: pass
+
+@egraph.function
+def cdr(x: T) -> T: pass
+
+@egraph.function(default=Unit())
+def not_atom(x: T) -> Unit: pass
+```
+
+The funny one out of the bunch is the `not_atom` function. In `egglog` we represent a function that is just a fact
+as one that returns the `Unit` type. We can also call it a "relation". It doesn't return anything meaningful, but just its existinace in the graph gives us information about its arguments.
+
+In this case, we also have certain axioms about our functions:
+
+```{code-cell} python
+@egraph.register
+def _list_axioms(x: T, y: T, z: T):
+    # CAR(CONS(x, y)) = x
+    yield rewrite(car(cons(x, y))).to(x)
+    # CDR(CONS(x, y)) = y
+    yield rewrite(cdr(cons(x, y))).to(y)
+    # ¬ATOM(x) ⊃ CONS(CAR(x), CDR(x)) = x
+    yield rule(not_atom(x)).then(union(cons(car(x), cdr(x))).with_(x))
+    # ¬ATOM(CONS(x, y))
+    yield rule(eq(z).to(cons(x, y))).then(not_atom(z))
+```
+
+The first two are quite simple, we can rewrite a more complex term into a simpler one.
+
+The third, requires us to the more powerful `rule` construct (which `rewrite` ends up compiling into) to say that if we know that `x` is not an atom, then we can add the fact that `x` is a `cons` of its `car` and `cdr`.
+
+The fourth is similar, saying that if we find term that is a `cons` of two terms, then we know that term is not an atom.
+
+Now we can actually try to prove the example theorum. First we start with its assumptions:
+
+```{code-cell} python
+x = egraph.constant("x", T)
+y = egraph.constant("y", T)
+
+egraph.register(
+    # CAR(x) = CAR(y)
+    union(car(x)).with_(car(y)),
+    # CDR(x) = CDR(y)
+    union(cdr(x)).with_(cdr(y)),
+    # ¬ATOM(x)
+    not_atom(x),
+    # ¬ATOM(y)
+    not_atom(y),
+)
+```
+
+Then we can step-by-step run the rules until we can check for our result and prove it:
+
+```{code-cell} python
+egraph.display()
+egraph.run(1)
+egraph.display()
+egraph.run(1)
+egraph.display()
+egraph.check(eq(x).to(y))
+```
+
+We can see that it start by running the rule `¬ATOM(x) ⊃ CONS(CAR(x), CDR(x)) = x` on both `x` and `y` since both are not atoms. It unions each with the `cons` of their `car` and `cdr`.
+
+Then it runs the `CAR(CONS(x, y)) = x` and `CDR(CONS(x, y)) = y` rules to unify x and y!
+
+## Conclusion
+
+I had fun translating these examples into `egglog`. I also took a look over the other paper mentioned in the begining and might write about those in a future post. They were obviously more complex, and I understand less of them, since they are about dependent types and cubical type theory. However, it was interesting to see the connetion between things like the theory of the univalance axiom and questions like formalizing the equivalence of different programming languages abstractions. I really enjoyed [Voevodsky's lectures on the foundation of mathematics](https://www.math.ias.edu/vladimir/lectures#:~:text=Foundations%20of%20mathematics%20%2D%20their%20past%2C%20present%20and%20future) intuitiavely it seems like the perspective of treating equivalence as a path seems like an interesting approach. Also, I can see how it relates to open questions of storing proofs of equivalences in egglog as well as how to think about the "directionality" of a equality relational more intentionally, as the addition of features like `merge` functions in `egglog` allow.

{egglog-4.0.0 → egglog-5.0.0}/docs/reference/egglog-translation.md

@@ -52,14 +52,14 @@ Rational(1, 2) / Rational(2, 1)
 
 ### `!=` Operator
 
-The `!=` function in egglog works on any two types with the same sort. In Python, this is supported by overloading the `__ne__` operator, which is done by default in all builtin and custom sorts:
+The `!=` function in egglog works on any two types with the same sort. In Python, this is mapped to the `ne` function:
 
 ```{code-cell} python
 # egg: (!= 10 2)
-i64(10) != i64(2)
+ne(i64(10)).to(i64(2))
 ```
 
-This is checked statically, based on the `__ne__` definition in `Expr`, so that only sorts that have the same sort can be compared.
+This is a two part function so that we can statically check both sides are the same type.
 
 ## Declaring Sorts
 

{egglog-4.0.0 → egglog-5.0.0}/docs/reference/python-integration.md

@@ -208,6 +208,7 @@ Most of the Python special dunder (= "double under") methods are supported as we
 - `__le__`
 - `__eq__`
 - `__ne__`
+- `__ne__`
 - `__gt__`
 - `__ge__`
 - `__add__`
@@ -231,7 +232,7 @@ Most of the Python special dunder (= "double under") methods are supported as we
 - `__setitem__`
 - `__delitem__`
 
-Currently `__divmod__` is not supported, since it returns multiple results and `__ne__` will shadow the builtin `!=` egglog operator.
+Currently `__divmod__` is not supported, since it returns multiple results.
 
 Also these methods are currently used in the runtime class and cannot be overridden currently, although we could change this
 if the need arises:

{egglog-4.0.0 → egglog-5.0.0}/python/egglog/declarations.py

@@ -269,7 +269,7 @@ class ModuleDeclarations:
                 return decls.get_egg_fn(ref)
             except KeyError:
                 pass
-        raise KeyError(f"Callable ref {ref} not found")
+        raise KeyError(f"Callable ref {ref!r} not found")
 
     def get_egg_sort(self, ref: JustTypeRef) -> str:
         for decls in self.all_decls:
@@ -770,9 +770,6 @@ class CallDecl:
         if self in context.names:
             return context.names[self]
         ref, args = self.callable, [a.expr for a in self.args]
-        # Special case != since it doesn't have a decl
-        if isinstance(ref, MethodRef) and ref.method_name == "__ne__":
-            return f"{args[0].pretty(context)} != {args[1].pretty(context)}"
         function_decl = context.mod_decls.get_function_decl(ref)
         # Determine how many of the last arguments are defaults, by iterating from the end and comparing the arg with the default
         n_defaults = 0

{egglog-4.0.0 → egglog-5.0.0}/python/egglog/egraph.py

@@ -54,6 +54,7 @@ __all__ = [
     "rewrite",
     "birewrite",
     "eq",
+    "ne",
     "panic",
     "let",
     "delete",
@@ -258,8 +259,6 @@ class _BaseModule(ABC):
                 unextractable=unextractable,
             )
 
-        # Register != as a method so we can print it as a string
-        self._mod_decls._decl.register_callable_ref(MethodRef(cls_name, "__ne__"), "!=")
         return RuntimeClass(self._mod_decls, cls_name)
 
     # We seperate the function and method overloads to make it simpler to know if we are modifying a function or method,
@@ -663,6 +662,8 @@ class _Builtins(_BaseModule):
             msg = "Builtins already initialized"
             raise RuntimeError(msg)
         _BUILTIN_DECLS = self._mod_decls._decl
+        # Register != operator
+        _BUILTIN_DECLS.register_callable_ref(FunctionRef("!="), "!=")
 
     def _process_commands(self, cmds: Iterable[bindings._Command]) -> None:
         """
@@ -1152,22 +1153,10 @@ class Expr(metaclass=_ExprMetaclass):
     Expression base class, which adds suport for != to all expression types.
     """
 
-    def __ne__(self: EXPR, other_expr: EXPR) -> Unit:  # type: ignore[override, empty-body]
-        """
-        Compare whether to expressions are not equal.
-
-        :param self: The expression to compare.
-        :param other_expr: The other expression to compare to, which must be of the same type.
-        :meta public:
-        """
+    def __ne__(self, other: NoReturn) -> NoReturn:  # type: ignore[override, empty-body]
         ...
 
     def __eq__(self, other: NoReturn) -> NoReturn:  # type: ignore[override, empty-body]
-        """
-        Equality is currently not supported.
-
-        We only add this method so that if you try to use it MyPy will warn you.
-        """
         ...
 
 
@@ -1492,6 +1481,11 @@ def eq(expr: EXPR) -> _EqBuilder[EXPR]:
     return _EqBuilder(expr)
 
 
+def ne(expr: EXPR) -> _NeBuilder[EXPR]:
+    """Check if the given expression is not equal to the given value."""
+    return _NeBuilder(expr)
+
+
 def panic(message: str) -> Action:
     """Raise an error with the given message."""
     return Panic(message)
@@ -1596,6 +1590,30 @@ class _EqBuilder(Generic[EXPR]):
         return f"eq({self.expr})"
 
 
+@dataclass
+class _NeBuilder(Generic[EXPR]):
+    expr: EXPR
+
+    def to(self, expr: EXPR) -> Unit:
+        l_expr = cast(RuntimeExpr, self.expr)
+        return cast(
+            Unit,
+            RuntimeExpr(
+                BUILTINS._mod_decls,
+                TypedExprDecl(
+                    JustTypeRef("Unit"),
+                    CallDecl(
+                        FunctionRef("!="),
+                        (l_expr.__egg_typed_expr__, convert_to_same_type(expr, l_expr).__egg_typed_expr__),
+                    ),
+                ),
+            ),
+        )
+
+    def __str__(self) -> str:
+        return f"ne({self.expr})"
+
+
 @dataclass
 class _SetBuilder(Generic[EXPR]):
     lhs: Expr

{egglog-4.0.0 → egglog-5.0.0}/python/egglog/examples/bool.py

@@ -13,7 +13,7 @@ egraph = EGraph()
 egraph.check(eq(T & T).to(T))
 egraph.check(eq(T & F).to(F))
 egraph.check(eq(T | F).to(T))
-egraph.check((T | F) != F)
+egraph.check(ne(T | F).to(F))
 
 egraph.check(eq(i64(1).bool_lt(2)).to(T))
 egraph.check(eq(i64(2).bool_lt(1)).to(F))

{egglog-4.0.0 → egglog-5.0.0}/python/egglog/examples/lambda_.py

@@ -117,7 +117,7 @@ egraph.register(
         union(t.eval()).with_(Val(i1 + i2))
     ),
     rule(eq(t).to(t1 == t2), eq(t1.eval()).to(t2.eval())).then(union(t.eval()).with_(Val.TRUE)),
-    rule(eq(t).to(t1 == t2), eq(t1.eval()).to(v1), eq(t2.eval()).to(v2), v1 != v2).then(
+    rule(eq(t).to(t1 == t2), eq(t1.eval()).to(v1), eq(t2.eval()).to(v2), ne(v1).to(v2)).then(
         union(t.eval()).with_(Val.FALSE)
     ),
     rule(eq(v).to(t.eval())).then(union(t).with_(Term.val(v))),
@@ -154,12 +154,12 @@ egraph.register(
     # let-var-same
     rewrite(let_(x, t, Term.var(x))).to(t),
     # let-var-diff
-    rewrite(let_(x, t, Term.var(y))).to(Term.var(y), x != y),
+    rewrite(let_(x, t, Term.var(y))).to(Term.var(y), ne(x).to(y)),
     # let-lam-same
     rewrite(let_(x, t, lam(x, t1))).to(lam(x, t1)),
     # let-lam-diff
-    rewrite(let_(x, t, lam(y, t1))).to(lam(y, let_(x, t, t1)), x != y, eq(fv).to(freer(t)), fv.not_contains(y)),
-    rule(eq(t).to(let_(x, t1, lam(y, t2))), x != y, eq(fv).to(freer(t1)), fv.contains(y)).then(
+    rewrite(let_(x, t, lam(y, t1))).to(lam(y, let_(x, t, t1)), ne(x).to(y), eq(fv).to(freer(t)), fv.not_contains(y)),
+    rule(eq(t).to(let_(x, t1, lam(y, t2))), ne(x).to(y), eq(fv).to(freer(t1)), fv.contains(y)).then(
         union(t).with_(lam(t.v(), let_(x, t1, let_(y, Term.var(t.v()), t2))))
     ),
 )

{egglog-4.0.0 → egglog-5.0.0}/python/egglog/examples/resolution.py

@@ -78,7 +78,7 @@ egraph.register(
     union(~p0 | (~p1 | (p2 | F))).with_(T),
 )
 egraph.run(10)
-egraph.check(T != F)
+egraph.check(ne(T).to(F))
 egraph.check(eq(p0).to(F))
 egraph.check(eq(p2).to(F))
 egraph

{egglog-4.0.0 → egglog-5.0.0}/python/egglog/exp/array_api.py

@@ -278,7 +278,7 @@ class Int(Expr):
 @array_api_module.register
 def _int(i: i64, j: i64, r: Boolean, o: Int):
     yield rewrite(Int(i) == Int(i)).to(TRUE)
-    yield rule(eq(r).to(Int(i) == Int(j)), i != j).then(union(r).with_(FALSE))
+    yield rule(eq(r).to(Int(i) == Int(j)), ne(i).to(j)).then(union(r).with_(FALSE))
 
     yield rewrite(Int(i) >= Int(i)).to(TRUE)
     yield rule(eq(r).to(Int(i) >= Int(j)), i > j).then(union(r).with_(TRUE))
@@ -666,7 +666,7 @@ def _tuple_value(
         # Includes
         rewrite(TupleValue.EMPTY.includes(v)).to(FALSE),
         rewrite(TupleValue(v).includes(v)).to(TRUE),
-        rewrite(TupleValue(v).includes(v2)).to(FALSE, v != v2),
+        rewrite(TupleValue(v).includes(v2)).to(FALSE, ne(v).to(v2)),
         rewrite((ti + ti2).includes(v)).to(ti.includes(v) | ti2.includes(v)),
     ]
 
@@ -1503,7 +1503,7 @@ def _assume_value_one_of(x: NDArray, v: Value, vs: TupleValue, idx: TupleInt):
 def _ndarray_value_isfinite(arr: NDArray, x: Value, xs: TupleValue, i: Int, f: f64, b: Boolean):
     yield rewrite(Value.int(i).isfinite()).to(TRUE)
     yield rewrite(Value.bool(b).isfinite()).to(TRUE)
-    yield rewrite(Value.float(Float(f)).isfinite()).to(TRUE, f != f64(math.nan))
+    yield rewrite(Value.float(Float(f)).isfinite()).to(TRUE, ne(f).to(f64(math.nan)))
 
     # a sum of an array is finite if all the values are finite
     yield rewrite(isfinite(sum(arr))).to(NDArray.scalar(Value.bool(arr.index(ALL_INDICES).isfinite())))

{egglog-4.0.0 → egglog-5.0.0}/python/egglog/exp/array_api_program_gen.py

@@ -126,7 +126,8 @@ def _float_program(f: Float, g: Float, f64_: f64, i: Int, r: Rational):
     yield rewrite(float_program(f * g)).to(Program("(") + float_program(f) + " * " + float_program(g) + ")")
     yield rewrite(float_program(f / g)).to(Program("(") + float_program(f) + " / " + float_program(g) + ")")
     yield rewrite(float_program(Float.rational(r))).to(
-        Program("float(") + Program(r.numer.to_string()) + " / " + Program(r.denom.to_string()) + ")", r.denom != i64(1)
+        Program("float(") + Program(r.numer.to_string()) + " / " + Program(r.denom.to_string()) + ")",
+        ne(r.denom).to(i64(1)),
     )
     yield rewrite(float_program(Float.rational(r))).to(
         Program("float(") + Program(r.numer.to_string()) + ")", eq(r.denom).to(i64(1))

{egglog-4.0.0 → egglog-5.0.0}/python/egglog/exp/program_gen.py

@@ -182,7 +182,7 @@ def _compile(
     yield rule(
         stmt,
         p.compile(i),
-        p1.parent != p,
+        ne(p1.parent).to(p),
         eq(s1).to(p1.expr),
     ).then(
         set_(p.statements).to(join(s1, "\n")),
@@ -214,7 +214,7 @@ def _compile(
     # Otherwise, if its not equal to either input, its not an identifier
     yield rule(program_add, eq(p.expr).to(p1.expr), eq(b).to(p1.is_identifer)).then(set_(p.is_identifer).to(b))
     yield rule(program_add, eq(p.expr).to(p2.expr), eq(b).to(p2.is_identifer)).then(set_(p.is_identifer).to(b))
-    yield rule(program_add, p.expr != p1.expr, p.expr != p2.expr).then(set_(p.is_identifer).to(Bool(False)))
+    yield rule(program_add, ne(p.expr).to(p1.expr), ne(p.expr).to(p2.expr)).then(set_(p.is_identifer).to(Bool(False)))
 
     # Set parent of p1
     yield rule(program_add, p.compile(i)).then(
@@ -228,7 +228,7 @@ def _compile(
     yield rule(program_add, p.compile(i), p1.next_sym).then(set_(p2.parent).to(p))
 
     # Compile p2, if p1 parent not equal, but p2 parent equal
-    yield rule(program_add, p.compile(i), p1.parent != p, eq(p2.parent).to(p)).then(p2.compile(i))
+    yield rule(program_add, p.compile(i), ne(p1.parent).to(p), eq(p2.parent).to(p)).then(p2.compile(i))
 
     # Compile p2, if p1 parent eqal
     yield rule(program_add, p.compile(i2), eq(p1.parent).to(p), eq(i).to(p1.next_sym), eq(p2.parent).to(p)).then(
@@ -259,8 +259,8 @@ def _compile(
     yield rule(
         program_add,
         p.compile(i),
-        p1.parent != p,
-        p2.parent != p,
+        ne(p1.parent).to(p),
+        ne(p2.parent).to(p),
     ).then(
         set_(p.statements).to(String("")),
         set_(p.next_sym).to(i),
@@ -269,7 +269,7 @@ def _compile(
     yield rule(
         program_add,
         eq(p1.parent).to(p),
-        p2.parent != p,
+        ne(p2.parent).to(p),
         eq(s1).to(p1.statements),
         eq(i).to(p1.next_sym),
     ).then(
@@ -280,7 +280,7 @@ def _compile(
     yield rule(
         program_add,
         eq(p2.parent).to(p),
-        p1.parent != p,
+        ne(p1.parent).to(p),
         eq(s2).to(p2.statements),
         eq(i).to(p2.next_sym),
     ).then(
@@ -319,7 +319,7 @@ def _compile(
     # 1. b. If p1 parent is not p, then just use assign as statement, next sym of i
     yield rule(
         program_assign,
-        p1.parent != p,
+        ne(p1.parent).to(p),
         p.compile(i),
         eq(s2).to(p1.expr),
         eq(p1.is_identifer).to(Bool(False)),
@@ -347,7 +347,7 @@ def _compile(
     # 1. b. If p1 parent is not p, then just use assign as statement, next sym of i
     yield rule(
         program_assign,
-        p1.parent != p,
+        ne(p1.parent).to(p),
         p.compile(i),
         eq(s2).to(p1.expr),
         eq(p1.is_identifer).to(Bool(True)),

{egglog-4.0.0 → egglog-5.0.0}/python/egglog/runtime.py

@@ -206,7 +206,7 @@ class RuntimeClass:
     __egg_decls__: ModuleDeclarations
     __egg_name__: str
 
-    def __call__(self, *args: object) -> RuntimeExpr | None:
+    def __call__(self, *args: object, **kwargs: object) -> RuntimeExpr | None:
         """
         Create an instance of this kind by calling the __init__ classmethod
         """
@@ -222,7 +222,7 @@ class RuntimeClass:
             assert len(args) == 0
             return RuntimeExpr(self.__egg_decls__, TypedExprDecl(JustTypeRef(self.__egg_name__), LitDecl(None)))
 
-        return RuntimeClassMethod(self.__egg_decls__, self.__egg_name__, "__init__")(*args)
+        return RuntimeClassMethod(self.__egg_decls__, self.__egg_name__, "__init__")(*args, **kwargs)
 
     def __dir__(self) -> list[str]:
         cls_decl = self.__egg_decls__.get_class_decl(self.__egg_name__)
@@ -435,15 +435,13 @@ class RuntimeMethod:
             self.__egg_callable_ref__ = PropertyRef(self.class_name, self.__egg_method_name__)
         else:
             self.__egg_callable_ref__ = MethodRef(self.class_name, self.__egg_method_name__)
-        # Special case for __ne__ which does not have a normal function defintion since
-        # it relies of type parameters
-        if self.__egg_method_name__ == "__ne__":
-            self.__egg_fn_decl__ = None
-        else:
-            try:
-                self.__egg_fn_decl__ = self.__egg_self__.__egg_decls__.get_function_decl(self.__egg_callable_ref__)
-            except KeyError as e:
-                raise AttributeError(f"Class {self.class_name} does not have method {self.__egg_method_name__}") from e
+        try:
+            self.__egg_fn_decl__ = self.__egg_self__.__egg_decls__.get_function_decl(self.__egg_callable_ref__)
+        except KeyError as e:
+            msg = f"Class {self.class_name} does not have method {self.__egg_method_name__}"
+            if self.__egg_method_name__ == "__ne__":
+                msg += ". Did you mean to use the ne(...).to(...)?"
+            raise AttributeError(msg) from e
 
     def __call__(self, *args: object, **kwargs) -> RuntimeExpr | None:
         args = (self.__egg_self__, *args)
@@ -527,7 +525,12 @@ class RuntimeExpr:
 # Define each of the special methods, since we have already declared them for pretty printing
 for name in list(BINARY_METHODS) + list(UNARY_METHODS) + ["__getitem__", "__call__", "__setitem__", "__delitem__"]:
 
-    def _special_method(self: RuntimeExpr, *args: object, __name: str = name) -> RuntimeExpr | None:
+    def _special_method(
+        self: RuntimeExpr,
+        *args: object,
+        __name: str = name,
+        **kwargs: object,
+    ) -> RuntimeExpr | None:
         # First, try to resolve as preserved method
         try:
             method = self.__egg_decls__.get_class_decl(self.__egg_typed_expr__.tp.name).preserved_methods[__name]
@@ -541,9 +544,9 @@ for name in list(BINARY_METHODS) + list(UNARY_METHODS) + ["__getitem__", "__call
                     return call_method_min_conversion(self, args[0], __name)
                 except ConvertError:
                     return NotImplemented
-            return RuntimeMethod(self, __name)(*args)
+            return RuntimeMethod(self, __name)(*args, **kwargs)
         else:
-            return method(self, *args)
+            return method(self, *args, **kwargs)
 
     setattr(RuntimeExpr, name, _special_method)
 

{egglog-4.0.0 → egglog-5.0.0}/python/tests/test_array_api.py

@@ -1,4 +1,3 @@
-# import pytest
 from egglog.exp.array_api import *
 from egglog.exp.array_api_numba import array_api_numba_module
 from egglog.exp.array_api_program_gen import *

{egglog-4.0.0 → egglog-5.0.0}/python/tests/test_high_level.py

@@ -234,6 +234,19 @@ def test_keyword_args():
     assert expr_parts(foo(y=i64(2), x=i64(1))) == pos
 
 
+def test_keyword_args_init():
+    egraph = EGraph()
+
+    @egraph.class_
+    class Foo(Expr):
+        def __init__(self, x: i64Like) -> None:
+            ...
+
+
+    assert expr_parts(Foo(1)) == expr_parts(Foo(x=1))
+
+
+
 def test_modules() -> None:
     m = Module()
 
@@ -346,8 +359,32 @@ def test_f64_negation() -> None:
 
 def test_not_equals():
     egraph = EGraph()
-    egraph.check(i64(10) != i64(2))
+    egraph.check(ne(i64(10)).to(i64(2)))
+
+
+def test_custom_equality():
+    egraph = EGraph()
+
+    @egraph.class_
+    class Boolean(Expr):
+        def __init__(self, value: BoolLike) -> None:
+            ...
 
+        def __eq__(self, other: Boolean) -> Boolean: # type: ignore[override]
+            ...
+
+        def __ne__(self, other: Boolean) -> Boolean: # type: ignore[override]
+            ...
+
+    egraph.register(rewrite(Boolean(True) == Boolean(True)).to(Boolean(False)))
+    egraph.register(rewrite(Boolean(True) != Boolean(True)).to(Boolean(True)))
+
+    should_be_true = Boolean(True) == Boolean(True)
+    should_be_false = Boolean(True) != Boolean(True)
+    egraph.register(should_be_true, should_be_false)
+    egraph.run(10)
+    egraph.check(eq(should_be_true).to(Boolean(False)))
+    egraph.check(eq(should_be_false).to(Boolean(True)))
 
 class TestMutate:
     def test_setitem_defaults(self):

{egglog-4.0.0 → egglog-5.0.0}/test-data/unit/check-high-level.test

@@ -2,9 +2,9 @@
 from egglog import *
 _ = i64(0) == i64(0)  # E: Unsupported operand types for == ("i64" and "i64")
 
-[case notEqAllowed]
+[case notEqNotAllowed]
 from egglog import *
-_ = i64(0) != i64(0)  # type: Unit
+_ = i64(0) != i64(0)  # E: Unsupported operand types for != ("i64" and "i64")
 
 [case eqToAllowed]
 from egglog import *