3.0 Release

[0x0f0f0f]

Release 3.0 when merged

[codecov-commenter]

⚠️ Please install the to ensure uploads and comments are reliably processed by Codecov.

Codecov Report

Attention: Patch coverage is 88.15126% with 141 lines in your changes missing coverage. Please review.

Project coverage is 81.42%. Comparing base (a8331d6) to head (32786c0).
Report is 536 commits behind head on master.

Files with missing lines	Patch %	Lines
src/EGraphs/Schedulers.jl	43.47%	26 Missing ⚠️
src/EGraphs/egraph.jl	88.78%	25 Missing ⚠️
src/utils.jl	11.11%	16 Missing ⚠️
src/Patterns.jl	72.54%	14 Missing ⚠️
src/Syntax.jl	91.83%	12 Missing ⚠️
src/Rules.jl	83.72%	7 Missing ⚠️
ext/Plotting.jl	0.00%	6 Missing ⚠️
src/EGraphs/saturation.jl	95.65%	6 Missing ⚠️
src/Rewriters.jl	53.84%	6 Missing ⚠️
src/ematch_compiler.jl	96.07%	6 Missing ⚠️
... and 6 more

❗ Your organization needs to install the Codecov GitHub app to enable full functionality.

Additional details and impacted files

@@             Coverage Diff             @@
##           master     #185       +/-   ##
===========================================
+ Coverage   69.17%   81.42%   +12.24%     
===========================================
  Files          16       19        +3     
  Lines        1353     1491      +138     
===========================================
+ Hits          936     1214      +278     
+ Misses        417      277      -140     

☔ View full report in Codecov by Sentry.
📢 Have feedback on the report? Share it here.

[github-actions]

Benchmark Results

	egg-sym	egg-cust	MT@32786c06710...	MT@46f2c2fd53e...	egg-sym/MT@327...	egg-cust/MT@32...	MT@46f2c2fd53e...
egraph_addexpr	1.4 ms		5.18 ms	13.8 ms	0.271		2.67
basic_maths_simpl2	14.8 ms	5.33 ms	23.3 ms	758 ms	0.637	0.229	32.5
prop_logic_freges_theorem	2.53 ms	1.57 ms	2.37 ms	36.4 ms	1.07	0.663	15.4
calc_logic_demorgan	61.6 μs	34.4 μs	78.5 μs	523 μs	0.785	0.438	6.67
calc_logic_freges_theorem	22.1 ms	11.5 ms	42.3 ms	1.59e+04 ms	0.523	0.272	376
basic_maths_simpl1	6.76 ms	2.9 ms	4.86 ms	49.6 ms	1.39	0.595	10.2
egraph_constructor	0.0839 μs		0.0961 μs	0.108 μs	0.873		1.12
prop_logic_prove1	35.3 ms	14.1 ms	39.7 ms	8.29e+03 ms	0.891	0.354	209
prop_logic_demorgan	80.7 μs	45.7 μs	93.7 μs	756 μs	0.862	0.488	8.07
while_superinterpreter_while_10			19 ms	92.3 ms			4.87
prop_logic_rewrite			111 μs	111 μs			1.01
time_to_load			118 ms	168 ms			1.42

Benchmark Plots

A plot of the benchmark results have been uploaded as an artifact to the workflow run for this PR.
Go to "Actions"->"Benchmark a pull request"->[the most recent run]->"Artifacts" (at the bottom).

[0x0f0f0f]

This is 14.5 times faster than egg in rust!

Julia Code

using Metatheory, BenchmarkTools

t = @theory a b begin
  a + b --> b + a
  a * b --> b * a
  a + 0 --> a
  a * 0 --> 0
  a * 1 --> a
end

using BenchmarkTools

p = SaturationParams(; timer = false)

function simpl(ex)
  g = EGraph(ex)
  saturate!(g, t, p)
  extract!(g, astsize)
end

ex = :(0 + (1 * foo) * 0 + (a * 0) + a)

simpl(ex)

@btime simpl(ex)

94.462 μs (1412 allocations: 66.08 KiB)

Rust code

use egg::{rewrite as rw, *};
//use std::time::Duration;
fn main() {
    env_logger::init();
    use egg::*;

    define_language! {
        enum SimpleLanguage {
            Num(i32),
            "+" = Add([Id; 2]),
            "*" = Mul([Id; 2]),
            Symbol(Symbol),
        }
    }

    fn make_rules() -> Vec<Rewrite<SimpleLanguage, ()>> {
        vec![
            rewrite!("commute-add"; "(+ ?a ?b)" => "(+ ?b ?a)"),
            rewrite!("commute-mul"; "(* ?a ?b)" => "(* ?b ?a)"),
            rewrite!("add-0"; "(+ ?a 0)" => "?a"),
            rewrite!("mul-0"; "(* ?a 0)" => "0"),
            rewrite!("mul-1"; "(* ?a 1)" => "?a"),
        ]
    }

    /// parse an expression, simplify it using egg, and pretty print it back out
    fn simplify(s: &str) -> String {
        // parse the expression, the type annotation tells it which Language to use
        let expr: RecExpr<SimpleLanguage> = s.parse().unwrap();

        // simplify the expression using a Runner, which creates an e-graph with
        // the given expression and runs the given rules over it
        let runner = Runner::default().with_expr(&expr).run(&make_rules());

        // the Runner knows which e-class the expression given with `with_expr` is in
        let root = runner.roots[0];

        // use an Extractor to pick the best element of the root eclass
        let extractor = Extractor::new(&runner.egraph, AstSize);
        let (best_cost, best) = extractor.find_best(root);
        println!("Simplified {} to {} with cost {}", expr, best, best_cost);
        best.to_string()
    }

    // assert_eq!(simplify("(* 0 42)"), "0");
    let apply_time: std::time::Instant = instant::Instant::now();
    // assert_eq!(simplify("(+ 0 (* 1 foo))"), "foo");
    assert_eq!(simplify("(+ (+ (+ 0 (* (* 1 foo) 0)) (* a 0)) a)"), "a");
    let apply_time = apply_time.elapsed().as_secs_f64();
    println!("simplification time {}", apply_time);
}

simplification time 0.001375786 seconds which is 1375.786microseconds

1375.786 / 94.462 = 14.56x faster

well

[0x0f0f0f]

@gkronber I have just updated this branch to include the latest release of https://github.com/JuliaSymbolics/TermInterface.jl - the interface for custom types has changed, please let me know if you encounter any issue

[gkronber]

@gkronber I have just updated this branch to include the latest release of https://github.com/JuliaSymbolics/TermInterface.jl - the interface for custom types has changed, please let me know if you encounter any issue

Thanks for the heads up. I only had to make minor changes because of the changed names for functions in VecExpr.

[shashi]

@0x0f0f0f Can you summarize the changes in this PR? What's the huge number of deletions from? And what's the huge performance gain from? This is awesome.

[0x0f0f0f]

@0x0f0f0f Can you summarize the changes in this PR? What's the huge number of deletions from? And what's the huge performance gain from? This is awesome.

@shashi I removed some unnecessary parts of the codebase, and basically changed the core types used for rewriting. The trick for performance was basically packing e-nodes in Vector{UInt64} such that loops (which happens hundreds of thousands of times) can be vectorized. Instead of having a struct with operation, hash, flags... fields, I just encode and pack everything into UInt64.

https://github.com/JuliaSymbolics/Metatheory.jl/blob/8f228fd0f8a5e1f97fd0ed986cb1c7e94cbce5c8/src/vecexpr.jl

Also some algorithms were updated, as the egg repo now has more efficient versions of parts of equality saturation (rebuilding) that were in the original paper

[0x0f0f0f]

I will hold a 5 min lightning talk on thursday 6 pm CET https://egraphs.org/ if interested

[oameye]

@0x0f0f0f just wanted to let you know I am very excited to see movement here 😊