Struct AbductiveReasoningEngine 

pub struct AbductiveReasoningEngine { /* private fields */ }

Production-quality abductive reasoning engine.

Example

use ipfrs_tensorlogic::{AbductiveReasoningEngine, AbrTerm, AbrEngineConfig};

let mut eng = AbductiveReasoningEngine::new(AbrEngineConfig::default());
let wet    = AbrTerm::prop("wet_grass");
let rain   = AbrTerm::prop("rain");
eng.add_observation(wet.clone());
let _hid = eng.add_hypothesis(rain, 1.0, true);
let expls = eng.abduce();
assert!(!expls.is_empty());

Implementations

impl AbductiveReasoningEngine

pub fn new(config: AbrEngineConfig) -> Self

Create a new engine with the given configuration.

pub fn default_engine() -> Self

Create an engine with default configuration.

pub fn add_hypothesis( &mut self, term: AbrTerm, cost: f64, is_abducible: bool, ) -> HypothesisId

Register a hypothesis and return its stable id.

pub fn add_rule(&mut self, head: AbrTerm, body: Vec<AbrTerm>, confidence: f64)

Register a logical rule.

pub fn add_observation(&mut self, term: AbrTerm)

Add an observation to be explained.

pub fn clear_observations(&mut self)

Remove all observations.

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

Update the engine configuration.

pub fn remove_hypothesis(&mut self, id: HypothesisId) -> bool

Remove a hypothesis by id. Returns true if it existed.

pub fn abduce(&mut self) -> Vec<AbrExplanation>

Find all best explanations (hypothesis sets that cover all observations).

Uses branch-and-bound over the space of abducible hypothesis subsets, pruning branches that exceed the cost of the best complete explanation found so far.

pub fn best_explanation(&mut self) -> Option<AbrExplanation>

Return the single best explanation, if any.

pub fn covers(&self, hypothesis_set: &[HypothesisId]) -> Vec<AbrTerm>

Determine which observations a hypothesis set covers (directly or via rules).

pub fn is_consistent(&self, hypothesis_set: &[HypothesisId]) -> bool

Check that no two hypotheses in the set assert contradictory facts.

A contradiction is detected when one hypothesis asserts p(…) and another asserts not_p(…) (prefix "not_" convention) or explicitly "NOT:p(…)".

pub fn apply_rules(&self) -> Vec<AbrTerm>

Forward-chain all rules over the facts asserted by every hypothesis in the current hypothesis registry (not just a subset). Returns all newly derived facts as a fixed point.

pub fn reasoning_stats(&self) -> AbrReasoningStats

Runtime statistics snapshot.

pub fn hypothesis(&self, id: HypothesisId) -> Option<&AbrHypothesis>

Retrieve a hypothesis by id.

pub fn hypothesis_ids(&self) -> Vec<HypothesisId>

All hypothesis ids registered with the engine.

pub fn observations(&self) -> &[AbrTerm]

All observations currently registered.

pub fn rules(&self) -> &[AbrRule]

Borrow a slice of all rules.

pub fn history(&self) -> &VecDeque<AbrExplanationRecord>

Access the explanation history (most recent last).