Struct BackwardEngine 

pub struct BackwardEngine { /* private fields */ }

Backward chaining engine for goal-driven reasoning

Implementations

impl BackwardEngine

pub fn new(kb: KnowledgeBase) -> Self

Create a new backward chaining engine

pub fn with_config(kb: KnowledgeBase, config: BackwardConfig) -> Self

Create with custom configuration

pub fn set_config(&mut self, config: BackwardConfig)

Update configuration

pub fn query( &mut self, query_str: &str, facts: &mut Facts, ) -> Result<QueryResult>

Query whether a goal can be proven

Example

let engine = BackwardEngine::new(kb);
let result = engine.query("User.IsVIP == true", &mut facts)?;

if result.provable {
    println!("User is VIP!");
}

pub fn query_with_rete_engine( &mut self, query_str: &str, facts: &mut Facts, rete_engine: Option<Arc<Mutex<IncrementalEngine>>>, ) -> Result<QueryResult>

Query with optional RETE IncrementalEngine for TMS integration

pub fn explain_why( &mut self, query_str: &str, facts: &mut Facts, ) -> Result<String>

Explain why a goal was proven (or not)

pub fn config(&self) -> &BackwardConfig

Get the configuration

pub fn knowledge_base(&self) -> &KnowledgeBase

Get the knowledge base

pub fn index_stats(&self) -> IndexStats

Get conclusion index statistics

pub fn rebuild_index(&mut self)

Rebuild the conclusion index (call after modifying knowledge base)

pub fn query_aggregate( &mut self, query: &str, facts: &mut Facts, ) -> Result<Value>

Query with aggregation functions

Supports: count, sum, avg, min, max, first, last

Example

// Count all employees
let count = engine.query_aggregate(
    "count(?x) WHERE employee(?x)",
    &mut facts
)?;

// Sum of salaries over 50000
let total = engine.query_aggregate(
    "sum(?salary) WHERE salary(?name, ?salary) AND ?salary > 50000",
    &mut facts
)?;

// Average price
let avg_price = engine.query_aggregate(
    "avg(?price) WHERE product(?name, ?price)",
    &mut facts
)?;