rust-rule-engine 1.20.2

A blazing-fast Rust rule engine with RETE algorithm, backward chaining inference, and GRL (Grule Rule Language) syntax. Features: forward/backward chaining, pattern matching, unification, O(1) rule indexing, TMS, expression evaluation, method calls, streaming with Redis state backend, watermarking, and custom functions. Production-ready for business rules, expert systems, real-time stream processing, and decision automation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

# Benchmarks

Comprehensive performance benchmarks for rust-rule-engine.

## 📊 Available Benchmarks

### 1. **engine_comparison_benchmark.rs** ⭐ (Main)
Complete comparison across all engine types and optimization levels:
- Native Rust (baseline)
- Basic Rule Engine
- RETE (basic)
- Alpha Memory Indexing
- Beta Memory Indexing

**Run:**
```bash
cargo bench --bench engine_comparison_benchmark
```

### 2. **alpha_indexing_benchmark.rs**
Detailed benchmarks for Alpha Memory Indexing:
- Linear scan vs indexed lookup
- Insert performance (no index, single, multiple)
- High selectivity scenarios (1% match)
- Auto-tuning overhead

**Run:**
```bash
cargo bench --bench alpha_indexing_benchmark
```

### 3. **rete_optimization_benchmark.rs**
Beta Memory Indexing performance:
- Indexed vs non-indexed joins
- Different fact counts
- Join performance

**Run:**
```bash
cargo bench --bench rete_optimization_benchmark
```

### 4. **parallel_benchmarks.rs**
Parallel execution benchmarks:
- Multi-threaded rule evaluation
- Scalability with core count

**Run:**
```bash
cargo bench --bench parallel_benchmarks
```

### 5. **backward_chaining_benchmarks.rs**
Backward chaining inference:
- Query resolution
- Unification performance

**Run:**
```bash
cargo bench --bench backward_chaining_benchmarks --features backward-chaining
```

### 6. **backward_chaining_index_benchmark.rs**
Backward chaining with indexing:
- Indexed vs non-indexed queries
- Aggregation performance

**Run:**
```bash
cargo bench --bench backward_chaining_index_benchmark --features backward-chaining
```

## 🚀 Quick Start

Run all benchmarks:
```bash
make ci  # Runs all tests and benchmarks
```

Run specific benchmark:
```bash
cargo bench --bench engine_comparison_benchmark
```

Run with features:
```bash
cargo bench --bench backward_chaining_benchmarks --features backward-chaining
```

## 📈 Expected Results

### Alpha Memory Indexing
- **10K facts, 1% selectivity**: ~800x speedup (310µs → 393ns)
- **Insert overhead**: <20% with single index

### Beta Memory Indexing
- **1K x 1K join**: ~169x speedup
- **O(n²) → O(n)** with hash indexing

### Native vs RETE
- Native Rust: Fastest for simple rules
- RETE: Scales better with complex patterns (10+ conditions)

## 🧹 Benchmark Maintenance

Clean benchmark results:
```bash
rm -rf target/criterion
```

Generate HTML reports:
```bash
cargo bench
# Open target/criterion/report/index.html
```

## 📝 Notes

- All benchmarks use Criterion.rs for statistical analysis
- Results include warmup, outlier detection, and confidence intervals
- HTML reports generated in `target/criterion/`
- Use `--quiet` flag for summary output only