Will Anderson
1009 lines
39 KiB
Rust
1009 lines
39 KiB
Rust
/// ReasoningEngine — graph-native inference over the Engram knowledge graph.
|
||
///
|
||
/// # The Core Insight
|
||
///
|
||
/// Language models conflate reasoning and generation: transformer weights encode
|
||
/// both the inference logic and the ability to verbalize conclusions. You cannot
|
||
/// separate them — the same matrix multiplication does both.
|
||
///
|
||
/// This engine separates them deliberately:
|
||
///
|
||
/// 1. **Reasoning** — `ReasoningEngine::reason()` traverses the knowledge graph
|
||
/// via spreading activation, classifies activated nodes as evidence, builds
|
||
/// typed inference chains, and computes a confidence-weighted verdict.
|
||
/// No language model is involved. The reasoning IS the graph traversal.
|
||
///
|
||
/// 2. **Generation** — A separate codec (not in this crate) converts the
|
||
/// `ReasoningResult` into natural language. It renders the evidence chains
|
||
/// and verdict into prose; it does not alter the logical content.
|
||
///
|
||
/// The verdict is determined by the graph structure, not by which tokens were
|
||
/// sampled. This is what makes it "not an LLM."
|
||
///
|
||
/// # Algorithm
|
||
///
|
||
/// 1. Embed the hypothesis text (caller provides embedding)
|
||
/// 2. Find seed nodes via vector similarity search
|
||
/// 3. Run spreading activation from seeds (EngramDb::activate)
|
||
/// 4. Classify each activated node as evidence (support/refute/context)
|
||
/// 5. Build evidence chains by following typed edges through activated subgraph
|
||
/// 6. Propagate confidence through chains
|
||
/// 7. Compute verdict from support vs. refutation mass
|
||
use std::collections::{HashMap, HashSet};
|
||
use std::sync::{Arc, Mutex};
|
||
|
||
use engram_core::{EngramDb, EngramResult};
|
||
use engram_core::types::{Node, NodeType, RelationType};
|
||
use uuid::Uuid;
|
||
|
||
use crate::types::{
|
||
CausalDirection, ChainType, Conclusion, EvidenceChain, EvidenceNode, EvidenceType,
|
||
Hypothesis, HypothesisType, InferenceEdge, InferenceEdgeType, ReasoningConfig,
|
||
ReasoningResult, Verdict,
|
||
};
|
||
|
||
// ── Cosine similarity (inlined — no dep on private engram_core::vector) ───────
|
||
|
||
/// Cosine similarity between two embedding vectors, clamped to [0.0, 1.0].
|
||
fn cosine_sim(a: &[f32], b: &[f32]) -> f32 {
|
||
if a.is_empty() || b.is_empty() || a.len() != b.len() {
|
||
return 0.0;
|
||
}
|
||
let dot: f32 = a.iter().zip(b.iter()).map(|(x, y)| x * y).sum();
|
||
let norm_a: f32 = a.iter().map(|x| x * x).sum::<f32>().sqrt();
|
||
let norm_b: f32 = b.iter().map(|x| x * x).sum::<f32>().sqrt();
|
||
if norm_a == 0.0 || norm_b == 0.0 {
|
||
return 0.0;
|
||
}
|
||
(dot / (norm_a * norm_b)).clamp(0.0, 1.0)
|
||
}
|
||
|
||
/// Simple negation detection: does the content contain negation markers
|
||
/// near keywords from the hypothesis?
|
||
fn has_negation_signals(content: &str) -> bool {
|
||
let lower = content.to_lowercase();
|
||
let negation_words = ["not", "never", "no ", "false", "incorrect", "wrong",
|
||
"cannot", "can't", "doesn't", "isn't", "aren't",
|
||
"wasn't", "weren't", "won't", "wouldn't", "shouldn't",
|
||
"couldn't", "invalid", "disproves", "refutes", "contra"];
|
||
negation_words.iter().any(|w| lower.contains(w))
|
||
}
|
||
|
||
// ── ReasoningEngine ───────────────────────────────────────────────────────────
|
||
|
||
pub struct ReasoningEngine {
|
||
db: Arc<Mutex<EngramDb>>,
|
||
pub config: ReasoningConfig,
|
||
}
|
||
|
||
impl ReasoningEngine {
|
||
pub fn new(db: Arc<Mutex<EngramDb>>, config: ReasoningConfig) -> Self {
|
||
Self { db, config }
|
||
}
|
||
|
||
pub fn with_default_config(db: Arc<Mutex<EngramDb>>) -> Self {
|
||
Self::new(db, ReasoningConfig::default())
|
||
}
|
||
|
||
// ── Core reasoning pass ───────────────────────────────────────────────────
|
||
|
||
/// Evaluate a hypothesis against the knowledge graph.
|
||
///
|
||
/// Returns a full `ReasoningResult` including verdict, evidence chains,
|
||
/// and confidence scores. This is the primary entry point.
|
||
pub fn reason(&mut self, hypothesis: &Hypothesis) -> EngramResult<ReasoningResult> {
|
||
let mut reasoning_steps = 0u32;
|
||
|
||
// Step 1: Find seed nodes via vector search
|
||
let seeds: Vec<Uuid> = {
|
||
let db = self.db.lock().map_err(|_| {
|
||
engram_core::EngramError::InvalidParam("db lock poisoned".into())
|
||
})?;
|
||
let scored = db.search_embedding(
|
||
&hypothesis.embedding,
|
||
10.min(self.config.max_evidence_nodes as usize),
|
||
)?;
|
||
reasoning_steps += 1;
|
||
scored.into_iter().map(|s| s.node.id).collect()
|
||
};
|
||
|
||
if seeds.is_empty() {
|
||
// Graph is empty — cannot reason
|
||
return Ok(ReasoningResult {
|
||
hypothesis: hypothesis.clone(),
|
||
conclusion: Conclusion {
|
||
verdict: Verdict::Insufficient,
|
||
summary: "No relevant nodes found in the knowledge graph.".into(),
|
||
confidence: 0.0,
|
||
primary_evidence: vec![],
|
||
},
|
||
evidence_chains: vec![],
|
||
confidence: 0.0,
|
||
reasoning_steps,
|
||
nodes_visited: 0,
|
||
});
|
||
}
|
||
|
||
// Step 2: Spreading activation from seeds
|
||
let activated: Vec<engram_core::types::ActivatedNode> = {
|
||
let db = self.db.lock().map_err(|_| {
|
||
engram_core::EngramError::InvalidParam("db lock poisoned".into())
|
||
})?;
|
||
db.activate(
|
||
&seeds,
|
||
&hypothesis.embedding,
|
||
self.config.max_depth.min(u8::MAX as u32) as u8,
|
||
self.config.max_evidence_nodes as usize,
|
||
)?
|
||
};
|
||
reasoning_steps += 1;
|
||
let nodes_visited = activated.len() as u32 + seeds.len() as u32;
|
||
|
||
// Step 3: Classify each activated node as evidence
|
||
let mut evidence_nodes: Vec<EvidenceNode> = activated
|
||
.iter()
|
||
.filter(|a| a.activation_strength >= self.config.min_confidence)
|
||
.map(|a| self.classify_evidence(&a.node, hypothesis, a.activation_strength, a.hops))
|
||
.collect();
|
||
|
||
// Also include the seed nodes themselves as evidence
|
||
{
|
||
let db = self.db.lock().map_err(|_| {
|
||
engram_core::EngramError::InvalidParam("db lock poisoned".into())
|
||
})?;
|
||
for seed_id in &seeds {
|
||
if let Some(node) = db.get_node(*seed_id)? {
|
||
let ev = self.classify_evidence(&node, hypothesis, 1.0, 0);
|
||
evidence_nodes.push(ev);
|
||
}
|
||
}
|
||
}
|
||
reasoning_steps += evidence_nodes.len() as u32;
|
||
|
||
// Step 4: Build inference edges from the activated subgraph
|
||
let activated_ids: HashSet<Uuid> = evidence_nodes
|
||
.iter()
|
||
.map(|e| e.engram_node_id)
|
||
.collect();
|
||
|
||
let inference_edges = self.build_inference_edges(&activated_ids, hypothesis)?;
|
||
reasoning_steps += 1;
|
||
|
||
// Step 5: Propagate confidence through nodes
|
||
self.propagate_confidence(&mut evidence_nodes, &inference_edges);
|
||
reasoning_steps += 1;
|
||
|
||
// Step 6: Build evidence chains
|
||
let evidence_chains = self.build_chains(&evidence_nodes, &inference_edges, hypothesis);
|
||
reasoning_steps += 1;
|
||
|
||
// Step 7: Compute verdict
|
||
let (verdict, confidence) = self.compute_verdict(&evidence_nodes, hypothesis);
|
||
reasoning_steps += 1;
|
||
|
||
// Collect primary evidence (strongest items for/against)
|
||
let mut primary_evidence: Vec<EvidenceNode> = evidence_nodes
|
||
.iter()
|
||
.filter(|e| {
|
||
matches!(
|
||
e.evidence_type,
|
||
EvidenceType::DirectSupport
|
||
| EvidenceType::DirectRefutation
|
||
| EvidenceType::IndirectSupport
|
||
| EvidenceType::IndirectRefutation
|
||
)
|
||
})
|
||
.cloned()
|
||
.collect();
|
||
primary_evidence.sort_by(|a, b| {
|
||
b.confidence
|
||
.partial_cmp(&a.confidence)
|
||
.unwrap_or(std::cmp::Ordering::Equal)
|
||
});
|
||
primary_evidence.truncate(5);
|
||
|
||
let summary = self.build_summary(&verdict, &primary_evidence, hypothesis);
|
||
|
||
Ok(ReasoningResult {
|
||
hypothesis: hypothesis.clone(),
|
||
conclusion: Conclusion {
|
||
verdict,
|
||
summary,
|
||
confidence,
|
||
primary_evidence,
|
||
},
|
||
evidence_chains,
|
||
confidence,
|
||
reasoning_steps,
|
||
nodes_visited,
|
||
})
|
||
}
|
||
|
||
// ── Causal chain ──────────────────────────────────────────────────────────
|
||
|
||
/// Find causal chains: what causes a concept, or what a concept causes.
|
||
///
|
||
/// Traverses the graph following `RelationType::Causes` edges in the
|
||
/// requested direction.
|
||
pub fn causal_chain(
|
||
&mut self,
|
||
concept_embedding: &[f32],
|
||
direction: CausalDirection,
|
||
) -> EngramResult<Vec<EvidenceChain>> {
|
||
// Find seed nodes close to the concept
|
||
let seeds: Vec<Node> = {
|
||
let db = self.db.lock().map_err(|_| {
|
||
engram_core::EngramError::InvalidParam("db lock poisoned".into())
|
||
})?;
|
||
db.search_embedding(concept_embedding, 5)?
|
||
.into_iter()
|
||
.map(|s| s.node)
|
||
.collect()
|
||
};
|
||
|
||
if seeds.is_empty() {
|
||
return Ok(vec![]);
|
||
}
|
||
|
||
let mut chains: Vec<EvidenceChain> = Vec::new();
|
||
|
||
for seed in &seeds {
|
||
let traversal_nodes: Vec<Node> = {
|
||
let db = self.db.lock().map_err(|_| {
|
||
engram_core::EngramError::InvalidParam("db lock poisoned".into())
|
||
})?;
|
||
db.traverse(seed.id, Some(RelationType::Causes), self.config.max_depth as u8)?
|
||
};
|
||
|
||
// Build evidence nodes — always start with the seed as the first node
|
||
let seed_sim = cosine_sim(concept_embedding, &seed.embedding);
|
||
let seed_ev = EvidenceNode {
|
||
engram_node_id: seed.id,
|
||
content: String::from_utf8_lossy(&seed.content).into_owned(),
|
||
evidence_type: EvidenceType::CausalAntecedent,
|
||
confidence: (seed.importance * seed.salience.clamp(0.0, 1.0)).clamp(0.0, 1.0),
|
||
activation_strength: seed_sim,
|
||
hops_from_seed: 0,
|
||
};
|
||
|
||
let mut ev_nodes: Vec<EvidenceNode> = vec![seed_ev];
|
||
|
||
for (i, node) in traversal_nodes.iter().enumerate() {
|
||
let sim = cosine_sim(concept_embedding, &node.embedding);
|
||
let ev_type = match direction {
|
||
CausalDirection::Backward => EvidenceType::CausalAntecedent,
|
||
CausalDirection::Forward | CausalDirection::Both => {
|
||
EvidenceType::CausalConsequent
|
||
}
|
||
};
|
||
ev_nodes.push(EvidenceNode {
|
||
engram_node_id: node.id,
|
||
content: String::from_utf8_lossy(&node.content).into_owned(),
|
||
evidence_type: ev_type,
|
||
confidence: (node.importance * node.salience.clamp(0.0, 1.0)).clamp(0.0, 1.0),
|
||
activation_strength: sim,
|
||
hops_from_seed: (i + 1) as u32,
|
||
});
|
||
}
|
||
|
||
// Need at least two nodes to form a chain
|
||
if ev_nodes.len() < 2 {
|
||
continue;
|
||
}
|
||
|
||
// Build inference edges along the chain
|
||
let ev_edges: Vec<InferenceEdge> = ev_nodes
|
||
.windows(2)
|
||
.map(|w| InferenceEdge {
|
||
from_node: w[0].engram_node_id,
|
||
to_node: w[1].engram_node_id,
|
||
edge_type: InferenceEdgeType::Causes,
|
||
strength: (w[0].confidence + w[1].confidence) / 2.0,
|
||
engram_edge_id: None,
|
||
})
|
||
.collect();
|
||
|
||
let chain_confidence = EvidenceChain::compute_confidence(&ev_edges);
|
||
|
||
chains.push(EvidenceChain {
|
||
nodes: ev_nodes,
|
||
edges: ev_edges,
|
||
chain_confidence,
|
||
chain_type: ChainType::CausalChain,
|
||
});
|
||
}
|
||
|
||
// Sort by chain confidence descending
|
||
chains.sort_by(|a, b| {
|
||
b.chain_confidence
|
||
.partial_cmp(&a.chain_confidence)
|
||
.unwrap_or(std::cmp::Ordering::Equal)
|
||
});
|
||
Ok(chains)
|
||
}
|
||
|
||
// ── Procedural chain ──────────────────────────────────────────────────────
|
||
|
||
/// Find ordered steps for a HowTo query.
|
||
///
|
||
/// Traverses `RelationType::Causes` and `RelationType::Contains` edges
|
||
/// from Process/Procedural nodes matching the goal embedding.
|
||
pub fn procedural_chain(&mut self, goal_embedding: &[f32]) -> EngramResult<Vec<String>> {
|
||
let process_nodes: Vec<Node> = {
|
||
let db = self.db.lock().map_err(|_| {
|
||
engram_core::EngramError::InvalidParam("db lock poisoned".into())
|
||
})?;
|
||
// Search for nodes relevant to the goal
|
||
let scored = db.search_embedding(goal_embedding, 10)?;
|
||
scored
|
||
.into_iter()
|
||
.filter(|s| {
|
||
matches!(s.node.node_type, NodeType::Process)
|
||
&& s.score > 0.3
|
||
})
|
||
.map(|s| s.node)
|
||
.collect()
|
||
};
|
||
|
||
if process_nodes.is_empty() {
|
||
// Fallback: use any activated nodes sorted by hop/salience
|
||
let db = self.db.lock().map_err(|_| {
|
||
engram_core::EngramError::InvalidParam("db lock poisoned".into())
|
||
})?;
|
||
let scored = db.search_embedding(goal_embedding, 5)?;
|
||
return Ok(scored
|
||
.into_iter()
|
||
.map(|s| String::from_utf8_lossy(&s.node.content).into_owned())
|
||
.collect());
|
||
}
|
||
|
||
// Follow the process chain from the best matching node
|
||
let best_process = &process_nodes[0];
|
||
let steps: Vec<Node> = {
|
||
let db = self.db.lock().map_err(|_| {
|
||
engram_core::EngramError::InvalidParam("db lock poisoned".into())
|
||
})?;
|
||
db.traverse(best_process.id, Some(RelationType::Causes), self.config.max_depth as u8)?
|
||
};
|
||
|
||
let mut ordered_steps: Vec<String> = Vec::new();
|
||
// The best process node itself is step 0
|
||
ordered_steps.push(String::from_utf8_lossy(&best_process.content).into_owned());
|
||
for node in steps {
|
||
ordered_steps.push(String::from_utf8_lossy(&node.content).into_owned());
|
||
}
|
||
Ok(ordered_steps)
|
||
}
|
||
|
||
// ── Contradiction detection ───────────────────────────────────────────────
|
||
|
||
/// Find pairs of nodes in the graph that contradict each other relative
|
||
/// to the given topic embedding.
|
||
///
|
||
/// Returns pairs `(supporting_node, refuting_node)` where both nodes are
|
||
/// activated by the topic, but one has negation signals and the other does not.
|
||
pub fn find_contradictions(
|
||
&mut self,
|
||
topic_embedding: &[f32],
|
||
) -> EngramResult<Vec<(EvidenceNode, EvidenceNode)>> {
|
||
// Activate the graph around the topic
|
||
let seeds: Vec<Uuid> = {
|
||
let db = self.db.lock().map_err(|_| {
|
||
engram_core::EngramError::InvalidParam("db lock poisoned".into())
|
||
})?;
|
||
db.search_embedding(topic_embedding, 10)?
|
||
.into_iter()
|
||
.map(|s| s.node.id)
|
||
.collect()
|
||
};
|
||
|
||
if seeds.is_empty() {
|
||
return Ok(vec![]);
|
||
}
|
||
|
||
let activated = {
|
||
let db = self.db.lock().map_err(|_| {
|
||
engram_core::EngramError::InvalidParam("db lock poisoned".into())
|
||
})?;
|
||
db.activate(&seeds, topic_embedding, 3, 30)?
|
||
};
|
||
|
||
// Check explicit Contradicts edges from both seed nodes and activated nodes
|
||
let mut contradicts_pairs: Vec<(EvidenceNode, EvidenceNode)> = Vec::new();
|
||
{
|
||
let db = self.db.lock().map_err(|_| {
|
||
engram_core::EngramError::InvalidParam("db lock poisoned".into())
|
||
})?;
|
||
|
||
// Build combined candidate list: seed nodes + activated nodes
|
||
let seed_nodes: Vec<(Uuid, f32, u8)> = seeds
|
||
.iter()
|
||
.filter_map(|&id| {
|
||
db.get_node(id).ok().flatten().map(|n| {
|
||
let sim = cosine_sim(topic_embedding, &n.embedding);
|
||
(id, sim, 0u8)
|
||
})
|
||
})
|
||
.collect();
|
||
|
||
let all_candidates: Vec<(Uuid, f32, u8)> = seed_nodes
|
||
.into_iter()
|
||
.chain(activated.iter().map(|an| {
|
||
(an.node.id, an.activation_strength, an.hops)
|
||
}))
|
||
.collect();
|
||
|
||
for (node_id, activation_strength, hops) in &all_candidates {
|
||
if let Some(from_node) = db.get_node(*node_id)? {
|
||
let edges = db.get_edges_from(*node_id)?;
|
||
for edge in edges {
|
||
if edge.relation == RelationType::Contradicts {
|
||
if let Some(target) = db.get_node(edge.to_id)? {
|
||
let sim_a = cosine_sim(topic_embedding, &from_node.embedding);
|
||
let sim_b = cosine_sim(topic_embedding, &target.embedding);
|
||
if sim_a > 0.3 && sim_b > 0.3 {
|
||
let ev_a = EvidenceNode {
|
||
engram_node_id: from_node.id,
|
||
content: String::from_utf8_lossy(&from_node.content)
|
||
.into_owned(),
|
||
evidence_type: EvidenceType::DirectSupport,
|
||
confidence: from_node.importance.clamp(0.0, 1.0),
|
||
activation_strength: *activation_strength,
|
||
hops_from_seed: *hops as u32,
|
||
};
|
||
let ev_b = EvidenceNode {
|
||
engram_node_id: target.id,
|
||
content: String::from_utf8_lossy(&target.content)
|
||
.into_owned(),
|
||
evidence_type: EvidenceType::DirectRefutation,
|
||
confidence: target.importance.clamp(0.0, 1.0),
|
||
activation_strength: sim_b,
|
||
hops_from_seed: *hops as u32 + 1,
|
||
};
|
||
contradicts_pairs.push((ev_a, ev_b));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Also find pairs where one node has negation signals and shares high
|
||
// semantic similarity with another node that does not
|
||
let mut support_nodes: Vec<&engram_core::types::ActivatedNode> = Vec::new();
|
||
let mut refutation_nodes: Vec<&engram_core::types::ActivatedNode> = Vec::new();
|
||
|
||
for an in &activated {
|
||
let sim = cosine_sim(topic_embedding, &an.node.embedding);
|
||
if sim < 0.4 {
|
||
continue;
|
||
}
|
||
let content = String::from_utf8_lossy(&an.node.content);
|
||
if has_negation_signals(&content) {
|
||
refutation_nodes.push(an);
|
||
} else {
|
||
support_nodes.push(an);
|
||
}
|
||
}
|
||
|
||
for sup in &support_nodes {
|
||
for ref_node in &refutation_nodes {
|
||
let mutual_sim = cosine_sim(&sup.node.embedding, &ref_node.node.embedding);
|
||
if mutual_sim > 0.6 {
|
||
// These two nodes are about the same thing but one negates
|
||
let ev_sup = EvidenceNode {
|
||
engram_node_id: sup.node.id,
|
||
content: String::from_utf8_lossy(&sup.node.content).into_owned(),
|
||
evidence_type: EvidenceType::DirectSupport,
|
||
confidence: sup.node.importance.clamp(0.0, 1.0),
|
||
activation_strength: sup.activation_strength,
|
||
hops_from_seed: sup.hops as u32,
|
||
};
|
||
let ev_ref = EvidenceNode {
|
||
engram_node_id: ref_node.node.id,
|
||
content: String::from_utf8_lossy(&ref_node.node.content).into_owned(),
|
||
evidence_type: EvidenceType::DirectRefutation,
|
||
confidence: ref_node.node.importance.clamp(0.0, 1.0),
|
||
activation_strength: ref_node.activation_strength,
|
||
hops_from_seed: ref_node.hops as u32,
|
||
};
|
||
// Avoid duplicates from the Contradicts edge scan
|
||
let already = contradicts_pairs.iter().any(|(a, b)| {
|
||
a.engram_node_id == ev_sup.engram_node_id
|
||
&& b.engram_node_id == ev_ref.engram_node_id
|
||
});
|
||
if !already {
|
||
contradicts_pairs.push((ev_sup, ev_ref));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
Ok(contradicts_pairs)
|
||
}
|
||
|
||
// ── Internal helpers ──────────────────────────────────────────────────────
|
||
|
||
/// Classify an activated Engram node as an evidence node relative to the hypothesis.
|
||
pub(crate) fn classify_evidence(
|
||
&self,
|
||
node: &Node,
|
||
hypothesis: &Hypothesis,
|
||
activation_strength: f32,
|
||
hops: u8,
|
||
) -> EvidenceNode {
|
||
let content = String::from_utf8_lossy(&node.content).into_owned();
|
||
let sim = cosine_sim(&hypothesis.embedding, &node.embedding);
|
||
let negation = has_negation_signals(&content);
|
||
|
||
let evidence_type = self.classify_evidence_type(node, hypothesis, sim, negation);
|
||
let confidence = self.compute_node_confidence(node, sim, activation_strength);
|
||
|
||
EvidenceNode {
|
||
engram_node_id: node.id,
|
||
content,
|
||
evidence_type,
|
||
confidence,
|
||
activation_strength,
|
||
hops_from_seed: hops as u32,
|
||
}
|
||
}
|
||
|
||
fn classify_evidence_type(
|
||
&self,
|
||
node: &Node,
|
||
hypothesis: &Hypothesis,
|
||
sim: f32,
|
||
negation: bool,
|
||
) -> EvidenceType {
|
||
// Process nodes → procedural steps for HowTo queries
|
||
if node.node_type == NodeType::Process
|
||
&& hypothesis.hypothesis_type == HypothesisType::HowTo
|
||
{
|
||
return EvidenceType::ProceduralStep;
|
||
}
|
||
|
||
// High similarity — direct evidence
|
||
if sim > 0.8 {
|
||
if negation {
|
||
return EvidenceType::DirectRefutation;
|
||
} else {
|
||
return EvidenceType::DirectSupport;
|
||
}
|
||
}
|
||
|
||
// Medium similarity — indirect evidence
|
||
if sim >= 0.5 {
|
||
if negation {
|
||
return EvidenceType::IndirectRefutation;
|
||
} else {
|
||
return EvidenceType::IndirectSupport;
|
||
}
|
||
}
|
||
|
||
// Below threshold — contextual
|
||
EvidenceType::ContextualFact
|
||
}
|
||
|
||
fn compute_node_confidence(&self, node: &Node, sim: f32, activation_strength: f32) -> f32 {
|
||
// Blend: semantic relevance × node importance × capped salience × activation
|
||
let salience_factor = node.salience.clamp(0.0, 1.0);
|
||
(sim * node.importance * salience_factor * activation_strength).clamp(0.0, 1.0)
|
||
}
|
||
|
||
/// Build inference edges between activated nodes using stored Engram edges.
|
||
fn build_inference_edges(
|
||
&self,
|
||
activated_ids: &HashSet<Uuid>,
|
||
_hypothesis: &Hypothesis,
|
||
) -> EngramResult<Vec<InferenceEdge>> {
|
||
let db = self.db.lock().map_err(|_| {
|
||
engram_core::EngramError::InvalidParam("db lock poisoned".into())
|
||
})?;
|
||
|
||
let mut edges: Vec<InferenceEdge> = Vec::new();
|
||
let mut seen: HashSet<(Uuid, Uuid)> = HashSet::new();
|
||
|
||
for &node_id in activated_ids {
|
||
let engram_edges = db.get_edges_from(node_id)?;
|
||
for ee in engram_edges {
|
||
if !activated_ids.contains(&ee.to_id) {
|
||
continue;
|
||
}
|
||
let pair = (ee.from_id, ee.to_id);
|
||
if seen.contains(&pair) {
|
||
continue;
|
||
}
|
||
seen.insert(pair);
|
||
|
||
let edge_type = relation_to_inference_edge(&ee.relation);
|
||
edges.push(InferenceEdge {
|
||
from_node: ee.from_id,
|
||
to_node: ee.to_id,
|
||
edge_type,
|
||
strength: ee.weight,
|
||
engram_edge_id: Some(ee.id),
|
||
});
|
||
}
|
||
}
|
||
Ok(edges)
|
||
}
|
||
|
||
/// Propagate confidence through the evidence graph via inference edges.
|
||
///
|
||
/// For each node, find all incoming edges from other evidence nodes and
|
||
/// blend in the confidence carried by those edges. This models how a strong
|
||
/// chain of reasoning can increase confidence in downstream nodes even if
|
||
/// those nodes have weak intrinsic importance.
|
||
pub(crate) fn propagate_confidence(
|
||
&self,
|
||
nodes: &mut Vec<EvidenceNode>,
|
||
edges: &[InferenceEdge],
|
||
) {
|
||
// Build a map: to_node → [(from_node, strength, edge_type)]
|
||
let mut incoming: HashMap<Uuid, Vec<(Uuid, f32, &InferenceEdgeType)>> = HashMap::new();
|
||
for edge in edges {
|
||
incoming
|
||
.entry(edge.to_node)
|
||
.or_default()
|
||
.push((edge.from_node, edge.strength, &edge.edge_type));
|
||
}
|
||
|
||
// Build lookup for quick confidence retrieval
|
||
let conf_map: HashMap<Uuid, f32> = nodes
|
||
.iter()
|
||
.map(|n| (n.engram_node_id, n.confidence))
|
||
.collect();
|
||
|
||
// Apply one pass of confidence propagation
|
||
for node in nodes.iter_mut() {
|
||
if let Some(incomers) = incoming.get(&node.engram_node_id) {
|
||
let mut boost = 0.0f32;
|
||
for (from_id, strength, edge_type) in incomers {
|
||
if let Some(&from_conf) = conf_map.get(from_id) {
|
||
// Supportive edges boost confidence; refuting edges reduce it
|
||
let signed_boost = match edge_type {
|
||
InferenceEdgeType::Supports
|
||
| InferenceEdgeType::Implies
|
||
| InferenceEdgeType::Causes => from_conf * strength * 0.3,
|
||
InferenceEdgeType::Refutes | InferenceEdgeType::Contradicts => {
|
||
-(from_conf * strength * 0.3)
|
||
}
|
||
_ => from_conf * strength * 0.1,
|
||
};
|
||
boost += signed_boost;
|
||
}
|
||
}
|
||
node.confidence = (node.confidence + boost).clamp(0.0, 1.0);
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Build evidence chains from the classified evidence nodes and inference edges.
|
||
fn build_chains(
|
||
&self,
|
||
nodes: &[EvidenceNode],
|
||
edges: &[InferenceEdge],
|
||
hypothesis: &Hypothesis,
|
||
) -> Vec<EvidenceChain> {
|
||
let mut chains: Vec<EvidenceChain> = Vec::new();
|
||
|
||
// Build adjacency map for chain construction
|
||
let mut adj: HashMap<Uuid, Vec<&InferenceEdge>> = HashMap::new();
|
||
for edge in edges {
|
||
adj.entry(edge.from_node).or_default().push(edge);
|
||
}
|
||
|
||
let node_map: HashMap<Uuid, &EvidenceNode> =
|
||
nodes.iter().map(|n| (n.engram_node_id, n)).collect();
|
||
|
||
// Support chain: follow Supports/Implies edges from direct support nodes
|
||
let support_starts: Vec<Uuid> = nodes
|
||
.iter()
|
||
.filter(|n| n.evidence_type == EvidenceType::DirectSupport && n.hops_from_seed == 0)
|
||
.map(|n| n.engram_node_id)
|
||
.collect();
|
||
|
||
for start in support_starts {
|
||
if let Some(chain) = self.trace_chain(
|
||
start,
|
||
&adj,
|
||
&node_map,
|
||
ChainType::SupportChain,
|
||
5,
|
||
hypothesis,
|
||
) {
|
||
if chain.nodes.len() > 1 {
|
||
chains.push(chain);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Refutation chain: follow Refutes/Contradicts edges from direct refutation nodes
|
||
let refutation_starts: Vec<Uuid> = nodes
|
||
.iter()
|
||
.filter(|n| {
|
||
n.evidence_type == EvidenceType::DirectRefutation && n.hops_from_seed == 0
|
||
})
|
||
.map(|n| n.engram_node_id)
|
||
.collect();
|
||
|
||
for start in refutation_starts {
|
||
if let Some(chain) = self.trace_chain(
|
||
start,
|
||
&adj,
|
||
&node_map,
|
||
ChainType::RefutationChain,
|
||
5,
|
||
hypothesis,
|
||
) {
|
||
if chain.nodes.len() > 1 {
|
||
chains.push(chain);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Causal chain: follow Causes edges
|
||
let causal_starts: Vec<Uuid> = nodes
|
||
.iter()
|
||
.filter(|n| n.evidence_type == EvidenceType::CausalAntecedent)
|
||
.map(|n| n.engram_node_id)
|
||
.collect();
|
||
|
||
for start in causal_starts {
|
||
if let Some(chain) = self.trace_chain(
|
||
start,
|
||
&adj,
|
||
&node_map,
|
||
ChainType::CausalChain,
|
||
5,
|
||
hypothesis,
|
||
) {
|
||
if chain.nodes.len() > 1 {
|
||
chains.push(chain);
|
||
}
|
||
}
|
||
}
|
||
|
||
// Process chain: follow edges from procedural step nodes
|
||
if hypothesis.hypothesis_type == HypothesisType::HowTo {
|
||
let process_starts: Vec<Uuid> = nodes
|
||
.iter()
|
||
.filter(|n| n.evidence_type == EvidenceType::ProceduralStep)
|
||
.map(|n| n.engram_node_id)
|
||
.collect();
|
||
|
||
for start in process_starts {
|
||
if let Some(chain) = self.trace_chain(
|
||
start,
|
||
&adj,
|
||
&node_map,
|
||
ChainType::ProcessChain,
|
||
8,
|
||
hypothesis,
|
||
) {
|
||
if chain.nodes.len() > 1 {
|
||
chains.push(chain);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Sort by chain confidence
|
||
chains.sort_by(|a, b| {
|
||
b.chain_confidence
|
||
.partial_cmp(&a.chain_confidence)
|
||
.unwrap_or(std::cmp::Ordering::Equal)
|
||
});
|
||
chains
|
||
}
|
||
|
||
/// DFS trace from a start node, following edges appropriate for the chain type.
|
||
fn trace_chain(
|
||
&self,
|
||
start: Uuid,
|
||
adj: &HashMap<Uuid, Vec<&InferenceEdge>>,
|
||
node_map: &HashMap<Uuid, &EvidenceNode>,
|
||
chain_type: ChainType,
|
||
max_len: usize,
|
||
_hypothesis: &Hypothesis,
|
||
) -> Option<EvidenceChain> {
|
||
let start_node = node_map.get(&start)?;
|
||
let mut chain_nodes: Vec<EvidenceNode> = vec![(*start_node).clone()];
|
||
let mut chain_edges: Vec<InferenceEdge> = Vec::new();
|
||
let mut visited: HashSet<Uuid> = HashSet::from([start]);
|
||
let mut current = start;
|
||
|
||
for _ in 0..max_len {
|
||
let Some(outgoing) = adj.get(¤t) else {
|
||
break;
|
||
};
|
||
|
||
// Find the best edge for this chain type
|
||
let best_edge = outgoing.iter().filter(|e| {
|
||
!visited.contains(&e.to_node)
|
||
&& edge_fits_chain_type(&e.edge_type, &chain_type)
|
||
}).max_by(|a, b| {
|
||
a.strength
|
||
.partial_cmp(&b.strength)
|
||
.unwrap_or(std::cmp::Ordering::Equal)
|
||
});
|
||
|
||
let Some(edge) = best_edge else {
|
||
break;
|
||
};
|
||
|
||
let next = edge.to_node;
|
||
let Some(next_node) = node_map.get(&next) else {
|
||
break;
|
||
};
|
||
|
||
visited.insert(next);
|
||
chain_nodes.push((*next_node).clone());
|
||
chain_edges.push((*edge).clone());
|
||
current = next;
|
||
}
|
||
|
||
let chain_confidence = EvidenceChain::compute_confidence(&chain_edges);
|
||
Some(EvidenceChain {
|
||
nodes: chain_nodes,
|
||
edges: chain_edges,
|
||
chain_confidence,
|
||
chain_type,
|
||
})
|
||
}
|
||
|
||
/// Compute the overall verdict from the evidence node set.
|
||
fn compute_verdict(
|
||
&self,
|
||
nodes: &[EvidenceNode],
|
||
hypothesis: &Hypothesis,
|
||
) -> (Verdict, f32) {
|
||
// Handle HowTo specially — return procedural steps
|
||
if hypothesis.hypothesis_type == HypothesisType::HowTo {
|
||
let steps: Vec<String> = nodes
|
||
.iter()
|
||
.filter(|n| n.evidence_type == EvidenceType::ProceduralStep)
|
||
.map(|n| n.content.clone())
|
||
.collect();
|
||
if !steps.is_empty() {
|
||
return (Verdict::Procedural(steps), 0.9);
|
||
}
|
||
}
|
||
|
||
let mut support_mass = 0.0f32;
|
||
let mut refute_mass = 0.0f32;
|
||
|
||
for node in nodes {
|
||
match node.evidence_type {
|
||
EvidenceType::DirectSupport => support_mass += node.confidence * 1.0,
|
||
EvidenceType::IndirectSupport => support_mass += node.confidence * 0.6,
|
||
EvidenceType::DirectRefutation => refute_mass += node.confidence * 1.0,
|
||
EvidenceType::IndirectRefutation => refute_mass += node.confidence * 0.6,
|
||
EvidenceType::CausalAntecedent | EvidenceType::CausalConsequent => {
|
||
// Causal evidence weakly supports the hypothesis
|
||
support_mass += node.confidence * 0.3;
|
||
}
|
||
_ => {}
|
||
}
|
||
}
|
||
|
||
let total = support_mass + refute_mass;
|
||
|
||
if total < 0.01 {
|
||
return (Verdict::Insufficient, 0.0);
|
||
}
|
||
|
||
let support_fraction = support_mass / total;
|
||
let refute_fraction = refute_mass / total;
|
||
|
||
// Both sides have substantial mass → Contradictory
|
||
if support_fraction >= self.config.contradiction_threshold
|
||
&& refute_fraction >= self.config.contradiction_threshold
|
||
{
|
||
return (Verdict::Contradictory, 0.5);
|
||
}
|
||
|
||
let confidence = support_fraction.clamp(0.0, 1.0);
|
||
|
||
if confidence > 0.6 {
|
||
(Verdict::Supported(confidence), confidence)
|
||
} else if confidence < 0.4 {
|
||
let refute_conf = refute_fraction.clamp(0.0, 1.0);
|
||
(Verdict::Refuted(refute_conf), refute_conf)
|
||
} else {
|
||
// Between 0.4 and 0.6 — insufficient evidence to commit
|
||
if nodes.len() < 3 {
|
||
(Verdict::Insufficient, confidence)
|
||
} else {
|
||
(Verdict::Contradictory, confidence)
|
||
}
|
||
}
|
||
}
|
||
|
||
/// Generate a natural language summary of the reasoning result.
|
||
fn build_summary(
|
||
&self,
|
||
verdict: &Verdict,
|
||
primary_evidence: &[EvidenceNode],
|
||
hypothesis: &Hypothesis,
|
||
) -> String {
|
||
let evidence_snippet: String = primary_evidence
|
||
.iter()
|
||
.take(3)
|
||
.map(|e| format!("\"{}\"", e.content.chars().take(80).collect::<String>()))
|
||
.collect::<Vec<_>>()
|
||
.join("; ");
|
||
|
||
match verdict {
|
||
Verdict::Supported(conf) => format!(
|
||
"Hypothesis \"{}\" is supported with {:.0}% confidence. \
|
||
Key evidence: {}.",
|
||
hypothesis.text,
|
||
conf * 100.0,
|
||
if evidence_snippet.is_empty() { "graph activation patterns".into() } else { evidence_snippet }
|
||
),
|
||
Verdict::Refuted(conf) => format!(
|
||
"Hypothesis \"{}\" is refuted with {:.0}% confidence. \
|
||
Contradicting evidence: {}.",
|
||
hypothesis.text,
|
||
conf * 100.0,
|
||
if evidence_snippet.is_empty() { "graph activation patterns".into() } else { evidence_snippet }
|
||
),
|
||
Verdict::Insufficient => format!(
|
||
"Insufficient evidence in the graph to evaluate: \"{}\". \
|
||
More nodes covering this topic are needed.",
|
||
hypothesis.text
|
||
),
|
||
Verdict::Contradictory => format!(
|
||
"Contradictory evidence found for: \"{}\". \
|
||
The graph contains conflicting information: {}.",
|
||
hypothesis.text,
|
||
if evidence_snippet.is_empty() { "multiple conflicting nodes".into() } else { evidence_snippet }
|
||
),
|
||
Verdict::Procedural(steps) => format!(
|
||
"Procedural steps for \"{}\": {}.",
|
||
hypothesis.text,
|
||
steps.iter().enumerate()
|
||
.map(|(i, s)| format!("{}. {}", i + 1, s))
|
||
.collect::<Vec<_>>()
|
||
.join(" ")
|
||
),
|
||
}
|
||
}
|
||
}
|
||
|
||
// ── Edge mapping helpers ──────────────────────────────────────────────────────
|
||
|
||
fn relation_to_inference_edge(relation: &RelationType) -> InferenceEdgeType {
|
||
match relation {
|
||
RelationType::Causes => InferenceEdgeType::Causes,
|
||
RelationType::Contradicts => InferenceEdgeType::Contradicts,
|
||
RelationType::Supersedes => InferenceEdgeType::Implies,
|
||
RelationType::Contains => InferenceEdgeType::Requires,
|
||
RelationType::References => InferenceEdgeType::SimilarTo,
|
||
RelationType::Exemplifies => InferenceEdgeType::InstanceOf,
|
||
RelationType::Activates => InferenceEdgeType::Supports,
|
||
RelationType::TemporallyPrecedes => InferenceEdgeType::Causes,
|
||
}
|
||
}
|
||
|
||
fn edge_fits_chain_type(edge_type: &InferenceEdgeType, chain_type: &ChainType) -> bool {
|
||
match chain_type {
|
||
ChainType::SupportChain => matches!(
|
||
edge_type,
|
||
InferenceEdgeType::Supports | InferenceEdgeType::Implies | InferenceEdgeType::SimilarTo
|
||
),
|
||
ChainType::RefutationChain => matches!(
|
||
edge_type,
|
||
InferenceEdgeType::Refutes | InferenceEdgeType::Contradicts
|
||
),
|
||
ChainType::CausalChain => matches!(edge_type, InferenceEdgeType::Causes),
|
||
ChainType::ProcessChain => matches!(
|
||
edge_type,
|
||
InferenceEdgeType::Causes | InferenceEdgeType::Requires | InferenceEdgeType::Implies
|
||
),
|
||
}
|
||
}
|