World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
Keep every interval of a triple alive through axiom steps (#1040)
Coderfu82e3fa4c9aa8
diff --git a/crates/utopia-reason/src/derive.rs b/crates/utopia-reason/src/derive.rsindex ceb2cd82..050ede2a 100644--- a/crates/utopia-reason/src/derive.rs+++ b/crates/utopia-reason/src/derive.rs@@ -135,6 +135,9 @@ pub fn overlap(/// 前提,而 `validity` 只对留下来的那几条求交集,于是结论的有效期比实际宽。type Hop = (Uuid, Option<i64>, Option<i64>, Vec<Uuid>);+/// 半开区间 `[from, to)`,两端可空。+type Span = (Option<i64>, Option<i64>);+/// 派生的中间态:一个 (主语, 宾语) 对是怎么来的。#[derive(Clone)]struct Reached {@@ -151,6 +154,8 @@ struct Reached {/// 规则就无处安放。type Triple = (Uuid, Uuid, Uuid);+// 同一个 triple 可以有几段互不包含的有效期;被更宽区间完全覆盖的那段不再另留一份。+/// 拿公理推一遍这批边。////// **全局不动点,不再按谓词分组。** 三条规则会串起来:@@ -167,15 +172,19 @@ type Triple = (Uuid, Uuid, Uuid);pub fn derive(edges: &[TimedEdge], axioms: &HashMap<Uuid, Axioms>) -> Derivation {let mut out = Derivation::default();- // 断言过的三元组。**派生撞上它就让路**——asserted > derived 是硬性的- let asserted: HashSet<Triple> = edges- .iter()- .map(|e| (e.edge.predicate, e.edge.subject, e.edge.object))- .collect();+ // 断言过的时序三元组。**派生撞上它就让路**——asserted > derived 是硬性的;+ // 判断的是区间覆盖,不只是等值,所以无时间/更宽的一段也能挡住窄的派生。+ let mut asserted: HashMap<Triple, Vec<Span>> = HashMap::new();+ for e in edges {+ asserted+ .entry((e.edge.predicate, e.edge.subject, e.edge.object))+ .or_default()+ .push((e.from, e.to));+ }- // 已经推出来的 → 怎么来的。同一条只留第一条证明:多条路径都能推出同一件事- // 时,展示哪一条对用户没有区别,而全存下来会让证明树的规模跟着路径数走- let mut reached: HashMap<Triple, Reached> = HashMap::new();+ // 已经推出来的 → 怎么来的。同一个 triple 只保留互不包含的区间;一个区间被+ // 已有证明覆盖时,展示哪一条对用户没有区别,而全存下来会让证明树跟路径数走+ let mut reached: HashMap<Triple, Vec<(Span, Reached)>> = HashMap::new();// **封顶仍按谓词计**:那个常量的含义没变(一个谓词最多推两万条),// 而 `Derivation::capped` 回的也是谓词列表。跨谓词之后若改成全局一个数,// 界面上「哪个谓词太密」就答不出来了@@ -204,9 +213,9 @@ pub fn derive(edges: &[TimedEdge], axioms: &HashMap<Uuid, Axioms>) -> Derivation)}).collect();- // 起始 frontier 的顺序跟着入参走,而入参顺序不保证——排一次,+ // 起始 frontier 的顺序跟着入参走,而入参顺序不保证——按完整事实身份排一次,// 同一个库两次推导才给得出同一份结果- frontier.sort_by_key(|(t, _)| *t);+ frontier.sort_by_key(|(t, acc)| (*t, acc.from, acc.to));// 轮数上限是**兜底**,真正的界在下面那条 `premises.len() >= MAX_DEPTH`:// 常量的含义是「路径最长 12」,按前提条数算才对得上。轮数只防病态输入@@ -292,7 +301,7 @@ pub fn derive(edges: &[TimedEdge], axioms: &HashMap<Uuid, Axioms>) -> Derivation}}}- next.sort_by_key(|(t, _)| *t);+ next.sort_by_key(|(t, acc)| (*t, acc.from, acc.to));frontier = next;}@@ -302,6 +311,16 @@ pub fn derive(edges: &[TimedEdge], axioms: &HashMap<Uuid, Axioms>) -> Derivationout}+/// `outer` 是否覆盖 `inner`。两端都为 `None` 表示无界,因此能覆盖任何同向区间。+fn span_contains(outer: Span, inner: Span) -> bool {+ outer+ .0+ .is_none_or(|outer| inner.0.is_some_and(|inner| outer <= inner))+ && outer+ .1+ .is_none_or(|outer| inner.1.is_some_and(|inner| outer >= inner))+}+/// 落一条派生,并把它接进邻接表供后续传递使用。返回 true = 这个谓词封顶了。////// 参数多得难看,但把它抽出来是必要的:四条规则各自的落地动作一模一样@@ -318,8 +337,8 @@ fn emit(to: Option<i64>,// 传递多用掉的那一条边所依赖的全部前提;一跳规则没有extra_premises: Option<&[Uuid]>,- asserted: &HashSet<Triple>,- reached: &mut HashMap<Triple, Reached>,+ asserted: &HashMap<Triple, Vec<Span>>,+ reached: &mut HashMap<Triple, Vec<(Span, Reached)>>,per_pred: &mut HashMap<Uuid, usize>,capped: &mut HashSet<Uuid>,out: &mut Derivation,@@ -331,9 +350,18 @@ fn emit(if subj == obj {return false;}- // 断言优先;已经推过的不重复推——**逆的互指靠这一条收敛**:- // `p⁻¹ = q` 且 `q⁻¹ = p` 时,第二轮推回来的那条已经在 reached 里- if asserted.contains(&t) || reached.contains_key(&t) {+ // 断言优先;同一个 triple 上已有更宽区间时也不重复推——**逆的互指靠这一条+ // 收敛**:`p⁻¹ = q` 且 `q⁻¹ = p` 时,第二轮推回来的那条已经被 reached 覆盖。+ // 不能只比等值:无时间断言应覆盖日期的派生,较宽的原子区间也应覆盖交集。+ let span = (from, to);+ let covered = asserted+ .get(&t)+ .into_iter()+ .flatten()+ .copied()+ .chain(reached.get(&t).into_iter().flatten().map(|(span, _)| *span))+ .any(|outer| span_contains(outer, span));+ if covered {return false;}let mut premises = acc.premises.clone();@@ -359,7 +387,7 @@ fn emit(to,premises: premises.clone(),};- reached.insert(t, r.clone());+ reached.entry(t).or_default().push((span, r.clone()));// 派生出来的边也能被后续传递接上。**整份证明都要带上**:邻接表里的这一项// 以后会被当作前提拼进下一条派生,只留首条会让链上的证明越拼越短if !premises.is_empty() {@@ -423,8 +451,6 @@ pub struct RuleClash {pub pairs: Vec<(usize, usize)>,}-/// 半开区间 `[from, to)`,两端可空-type Span = (Option<i64>, Option<i64>);/// (谓词, 一端) → 另一端的边:(另一端, 事实, 区间)。functional 两个方向各一份type ByEnd = HashMap<(Uuid, Uuid), Vec<(Uuid, Uuid, Span)>>;/// 一条规则的身份:声明所在的谓词 + 规则种类@@ -1062,6 +1088,130 @@ mod tests {);}+ /// 同一个 triple 可以有几段时间都成立。第二段不能被第一段挡在传递之外,+ /// 而且输入顺序怎么排,时间闭包都要一样。+ #[test]+ fn distinct_intervals_for_one_triple_survive_axiom_steps_in_any_order() {+ let ax = HashMap::from([+ (+ P,+ Axioms {+ inverse_of: Some(Q),+ ..Default::default()+ },+ ),+ (+ Q,+ Axioms {+ transitive: true,+ ..Default::default()+ },+ ),+ ]);+ let early = tep(P, 1, 1, 2, Some(0), Some(10));+ let late = tep(P, 2, 1, 2, Some(20), Some(30));+ let cb = tep(Q, 3, 3, 2, Some(20), Some(30));+ let spans = HashMap::from([+ (f(1), (Some(0), Some(10))),+ (f(2), (Some(20), Some(30))),+ (f(3), (Some(20), Some(30))),+ ]);+ let closure = |edges: [TimedEdge; 3]| {+ let d = derive(&edges, &ax);+ let mut closure: Vec<_> = d+ .facts+ .iter()+ .map(|x| {+ let (from, to) = validity(&x.premises, &spans).expect("派生区间应当可求");+ (x.predicate, x.subject, x.object, from, to)+ })+ .collect();+ closure.sort();+ closure+ };++ let early_first = closure([early, late, cb]);+ let late_first = closure([late, early, cb]);++ assert_eq!(early_first, late_first, "闭包不能随 fact 输入顺序改变");+ assert!(+ early_first.contains(&(Q, n(2), n(1), Some(0), Some(10))),+ "第一段 B q A 也要保留"+ );+ assert!(+ early_first.contains(&(Q, n(2), n(1), Some(20), Some(30))),+ "第二段 B q A 要保留"+ );+ assert!(+ early_first.contains(&(Q, n(3), n(1), Some(20), Some(30))),+ "第二段 B q A 必须还能和 C q B 接成 C q A"+ );+ }++ /// 断言的一段区间如果覆盖了派生出来的更窄区间,就不再留下第二条同 triple 的事实。+ #[test]+ fn an_asserted_interval_covers_a_narrower_derivation() {+ let edges = [+ te(1, 1, 2, Some(10), Some(20)),+ te(2, 2, 3, Some(10), Some(20)),+ te(3, 1, 3, Some(0), Some(100)),+ ];+ let d = derive(&edges, &transitive());+ assert!(+ d.facts.is_empty(),+ "断言 [0,100) 已覆盖推出来的 [10,20),不该再派生一份"+ );+ }++ /// 无时间断言表示一直成立,也覆盖有日期的同 triple 派生。+ #[test]+ fn an_undated_assertion_covers_a_dated_derivation() {+ let edges = [+ te(1, 1, 2, Some(10), Some(20)),+ te(2, 2, 3, Some(10), Some(20)),+ te(3, 1, 3, None, None),+ ];+ let d = derive(&edges, &transitive());+ assert!(+ d.facts.is_empty(),+ "无时间断言覆盖 [10,20),不该推出一条说得更少的同 triple 事实"+ );+ }++ /// 两条路径分别推出 [0,100) 与 [10,20):宽的保留,窄的丢掉;输入反序也一样。+ #[test]+ fn a_wider_route_suppresses_a_narrower_derivation() {+ let edges = [+ te(1, 1, 2, Some(0), Some(100)),+ te(2, 2, 4, Some(0), Some(100)),+ te(3, 1, 3, Some(10), Some(20)),+ te(4, 3, 4, Some(10), Some(20)),+ ];+ let by_fact: HashMap<_, _> = edges+ .iter()+ .map(|e| (e.edge.fact, (e.from, e.to)))+ .collect();+ let spans = |edges: [TimedEdge; 4]| {+ let d = derive(&edges, &transitive());+ let mut spans: Vec<_> = d+ .facts+ .iter()+ .filter(|x| x.subject == n(1) && x.object == n(4))+ .map(|x| validity(&x.premises, &by_fact).expect("派生区间应当可求"))+ .collect();+ spans.sort();+ spans+ };++ let broad = (Some(0), Some(100));+ assert_eq!(spans(edges), vec![broad], "只留下覆盖更宽的 [0,100)");+ assert_eq!(+ spans([edges[3], edges[2], edges[1], edges[0]]),+ vec![broad],+ "输入反序不能把被覆盖的窄区间又放回来"+ );+ }+/// 区间照旧取交集,跨谓词也一样。#[test]fn the_inverse_carries_the_same_span() {