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 87.56303% with 148 lines in your changes missing coverage. Please review.

Project coverage is 81.06%. Comparing base (a8331d6) to head (dab995c).
Report is 533 commits behind head on master.

Files with missing lines	Patch %	Lines
src/EGraphs/Schedulers.jl	43.47%	26 Missing ⚠️
src/utils.jl	7.69%	24 Missing ⚠️
src/EGraphs/egraph.jl	89.95%	22 Missing ⚠️
src/Syntax.jl	88.66%	17 Missing ⚠️
src/Patterns.jl	74.46%	12 Missing ⚠️
src/EGraphs/saturation.jl	95.20%	7 Missing ⚠️
src/Rules.jl	83.33%	7 Missing ⚠️
ext/Plotting.jl	0.00%	6 Missing ⚠️
src/Rewriters.jl	53.84%	6 Missing ⚠️
src/ematch_compiler.jl	95.83%	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.06%   +11.88%     
===========================================
  Files          16       19        +3     
  Lines        1353     1500      +147     
===========================================
+ Hits          936     1216      +280     
+ Misses        417      284      -133     

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

[github-actions]

Benchmark Results

	egg-sym	egg-cust	MT@dab995c5597...	MT@ca867735988...	egg-sym/MT@dab...	egg-cust/MT@da...	MT@ca867735988...
egraph_addexpr	1.47 ms		5 ms	14.3 ms	0.294		2.87
basic_maths_simpl2	12.6 ms	5.09 ms	19.6 ms	806 ms	0.641	0.26	41.1
prop_logic_freges_theorem	2.51 ms	1.54 ms	1.06 ms	34.8 ms	2.37	1.45	32.9
calc_logic_demorgan	60.4 μs	35 μs	77.5 μs	503 μs	0.78	0.452	6.5
calc_logic_freges_theorem	21.9 ms	12.2 ms	41 ms	3.11e+03 ms	0.534	0.298	75.7
basic_maths_simpl1	6.03 ms	2.79 ms	4.68 ms	48.4 ms	1.29	0.596	10.3
egraph_constructor	0.0838 μs		0.092 μs	0.101 μs	0.912		1.1
prop_logic_prove1	35.2 ms	13.9 ms	40.6 ms	8.38e+03 ms	0.865	0.341	206
prop_logic_demorgan	79 μs	44.7 μs	97.9 μs	732 μs	0.807	0.457	7.48
while_superinterpreter_while_10			18.2 ms	92.1 ms			5.07
prop_logic_rewrite			121 μs	119 μs			0.99
time_to_load			500 ms	524 ms			1.05

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