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

Project coverage is 81.17%. Comparing base (a8331d6) to head (081a9e6).
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.63%	23 Missing ⚠️
src/Syntax.jl	89.33%	16 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.17%   +11.99%     
===========================================
  Files          16       19        +3     
  Lines        1353     1503      +150     
===========================================
+ Hits          936     1220      +284     
+ Misses        417      283      -134     

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

[github-actions]

Benchmark Results

	egg-sym	egg-cust	MT@081a9e6f07d...	MT@ca867735988...	egg-sym/MT@081...	egg-cust/MT@08...	MT@ca867735988...
egraph_addexpr	1.46 ms		4.97 ms	13.9 ms	0.294		2.8
basic_maths_simpl2	13.6 ms	4.94 ms	20.9 ms	779 ms	0.653	0.237	37.3
prop_logic_freges_theorem	2.53 ms	1.55 ms	1.12 ms	34.7 ms	2.26	1.38	31
calc_logic_demorgan	59.8 μs	35.7 μs	80.4 μs	510 μs	0.743	0.444	6.35
calc_logic_freges_theorem	22.3 ms	12.6 ms	41.8 ms	3.3e+03 ms	0.532	0.3	79
basic_maths_simpl1	6.35 ms	2.78 ms	5.02 ms	48.3 ms	1.26	0.554	9.62
egraph_constructor	0.0854 μs		0.091 μs	0.104 μs	0.938		1.14
prop_logic_prove1	35.3 ms	14 ms	43.4 ms	8.37e+03 ms	0.814	0.322	193
prop_logic_demorgan	78.8 μs	45.4 μs	99.4 μs	744 μs	0.793	0.457	7.48
while_superinterpreter_while_10			18.3 ms	93.4 ms			5.1
prop_logic_rewrite			121 μs	121 μs			1
time_to_load			496 ms	523 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

[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.