World's first open-source enterprise world model.
Rust agent-memorybitemporalgraphragknowledge-baseknowledge-graphllmontologypgvectorpostgresqlragrustself-hostedsemantic-searchtemporal-knowledge-graphworld-model
Remove covered derived intervals after propagation completes (#1073)
Daniel0197bd8f3552
diff --git a/crates/utopia-reason/src/derive.rs b/crates/utopia-reason/src/derive.rsindex bbc8463f..85cbc98f 100644--- a/crates/utopia-reason/src/derive.rs+++ b/crates/utopia-reason/src/derive.rs@@ -342,6 +342,14 @@ pub fn derive(edges: &[TimedEdge], axioms: &HashMap<Uuid, Axioms>) -> Derivationfrontier = next;}+ // 窄区间可能先输出、宽区间后到。等传播结束再清理输出:较窄但更短的证明+ // 仍可能是 MAX_DEPTH 内走完后续链的必要中间态,不能在传播时仅按区间删掉。+ let spans = edges+ .iter()+ .map(|edge| (edge.edge.fact, (edge.from, edge.to)))+ .collect();+ retain_widest_outputs(&mut out.facts, &spans);+let mut capped: Vec<Uuid> = capped.into_iter().collect();capped.sort();out.capped = capped;@@ -358,6 +366,37 @@ fn span_contains(outer: Span, inner: Span) -> bool {.is_none_or(|outer| inner.1.is_some_and(|inner| outer >= inner))}+fn retain_widest_outputs(facts: &mut Vec<Derived>, spans: &HashMap<Uuid, Span>) {+ let mut grouped: HashMap<Triple, Vec<(usize, Span)>> = HashMap::new();+ for (index, fact) in facts.iter().enumerate() {+ // 无法重算有效期的输出沿用调用方原有的处理,不在清理时引入新的失败语义。+ let Some(span) = validity(&fact.premises, spans) else {+ continue;+ };+ grouped+ .entry((fact.predicate, fact.subject, fact.object))+ .or_default()+ .push((index, span));+ }++ let mut keep = vec![true; facts.len()];+ for outputs in grouped.values() {+ for &(index, span) in outputs {+ keep[index] = !outputs.iter().any(|&(other, outer)| {+ // 相同区间只留先输出的一份,避免互相覆盖导致全部被删。+ other != index && span_contains(outer, span) && (outer != span || other < index)+ });+ }+ }+ // 保留原顺序与整份 Derived,证明、via 和 rule 不重新拼装。+ let mut index = 0;+ facts.retain(|_| {+ let retained = keep[index];+ index += 1;+ retained+ });+}+/// 落一条派生,并把它接进邻接表供后续传递使用。返回 true = 这个谓词封顶了。////// 参数多得难看,但把它抽出来是必要的:四条规则各自的落地动作一模一样@@ -1438,6 +1477,322 @@ mod tests {);}+ fn competing_routes(+ p: Uuid,+ q: Uuid,+ nodes: [Uuid; 4],+ narrow: Span,+ broad: Span,+ ) -> ([TimedEdge; 4], HashMap<Uuid, Axioms>) {+ let [a, b, c, d] = nodes;+ let edges = [+ (101, p, a, d, narrow),+ (102, q, a, b, broad),+ (103, q, b, c, broad),+ (104, q, c, d, broad),+ ]+ .map(|(fact, predicate, subject, object, (from, to))| TimedEdge {+ edge: Edge {+ fact: Uuid::from_u128(fact),+ predicate,+ subject,+ object,+ },+ from,+ to,+ });+ let axioms = HashMap::from([+ (+ p,+ Axioms {+ sub_property_of: Some(q),+ ..Default::default()+ },+ ),+ (+ q,+ Axioms {+ transitive: true,+ ..Default::default()+ },+ ),+ ]);+ (edges, axioms)+ }++ /// #1034 / #1040 留下的 follow-up:先输出子属性的窄区间,再输出传递的宽区间。+ #[test]+ fn a_later_wider_derivation_replaces_the_narrow_output_with_its_whole_proof() {+ let p = Uuid::from_u128(1);+ let q = Uuid::from_u128(2);+ let [a, b, c, d] = [10, 20, 30, 40].map(Uuid::from_u128);+ let (edges, axioms) = competing_routes(+ p,+ q,+ [a, b, c, d],+ (Some(10), Some(20)),+ (Some(0), Some(100)),+ );+ let result = derive(&edges, &axioms);+ let spans = spans_of(&edges);+ let outputs: Vec<_> = result+ .facts+ .iter()+ .filter(|fact| (fact.predicate, fact.subject, fact.object) == (q, a, d))+ .collect();+ assert_eq!(+ outputs+ .iter()+ .map(|fact| validity(&fact.premises, &spans).unwrap())+ .collect::<Vec<_>>(),+ vec![(Some(0), Some(100))],+ "后到的宽区间应移除先到的窄区间输出"+ );+ assert_eq!(+ outputs[0].premises,+ [102, 103, 104].map(Uuid::from_u128).to_vec()+ );+ assert_eq!(outputs[0].rule, Rule::Transitive);+ assert_eq!(outputs[0].via, q);+ assert!(result.capped.is_empty());+ }++ #[test]+ fn final_intervals_do_not_depend_on_input_or_uuid_order() {+ for (p, q) in [(1, 2), (2, 1)].map(|(p, q)| (Uuid::from_u128(p), Uuid::from_u128(q))) {+ for nodes in [[10, 20, 30, 40], [40, 30, 20, 10], [20, 40, 10, 30]] {+ let [a, b, c, d] = nodes.map(Uuid::from_u128);+ let (edges, axioms) = competing_routes(+ p,+ q,+ [a, b, c, d],+ (Some(10), Some(20)),+ (Some(0), Some(100)),+ );+ let spans = spans_of(&edges);+ let mut expected = vec![+ (q, a, c, Some(0), Some(100)),+ (q, a, d, Some(0), Some(100)),+ (q, b, d, Some(0), Some(100)),+ ];+ expected.sort();+ // 四条事实的全部 24 种排列;交换谓词排序时宽区间可以先到。+ for i in 0..4 {+ for j in 0..4 {+ for k in 0..4 {+ if i == j || i == k || j == k {+ continue;+ }+ let last = (0..4).find(|x| *x != i && *x != j && *x != k).unwrap();+ let result =+ derive(&[edges[i], edges[j], edges[k], edges[last]], &axioms);+ let mut actual: Vec<_> = result+ .facts+ .iter()+ .map(|fact| {+ let (from, to) = validity(&fact.premises, &spans).unwrap();+ (fact.predicate, fact.subject, fact.object, from, to)+ })+ .collect();+ actual.sort();+ assert_eq!(actual, expected);+ let wide = result+ .facts+ .iter()+ .find(|fact| fact.object == d && fact.subject == a)+ .unwrap();+ assert_eq!(+ wide.premises,+ [102, 103, 104].map(Uuid::from_u128).to_vec()+ );+ assert_eq!((wide.via, wide.rule), (q, Rule::Transitive));+ }+ }+ }+ }+ }+ }++ #[test]+ fn final_outputs_keep_incomparable_spans_and_one_equal_span() {+ let narrow = (Some(10), Some(20));+ let cases = [+ (narrow, (None, Some(100)), vec![(None, Some(100))]),+ (narrow, (Some(0), None), vec![(Some(0), None)]),+ (narrow, (None, None), vec![(None, None)]),+ ((None, Some(20)), (None, None), vec![(None, None)]),+ ((Some(10), None), (None, None), vec![(None, None)]),+ (narrow, narrow, vec![narrow]),+ ((None, None), (None, None), vec![(None, None)]),+ (+ narrow,+ (Some(15), Some(30)),+ vec![narrow, (Some(15), Some(30))],+ ),+ (+ narrow,+ (Some(20), Some(30)),+ vec![narrow, (Some(20), Some(30))],+ ),+ (+ narrow,+ (Some(30), Some(40)),+ vec![narrow, (Some(30), Some(40))],+ ),+ (+ (None, Some(20)),+ (Some(10), None),+ vec![(None, Some(20)), (Some(10), None)],+ ),+ ];+ for (narrow, broad, mut expected) in cases {+ let (edges, axioms) = competing_routes(P, Q, [n(1), n(2), n(3), n(4)], narrow, broad);+ let result = derive(&edges, &axioms);+ let spans = spans_of(&edges);+ let mut actual: Vec<_> = result+ .facts+ .iter()+ .filter(|fact| (fact.predicate, fact.subject, fact.object) == (Q, n(1), n(4)))+ .map(|fact| validity(&fact.premises, &spans).unwrap())+ .collect();+ actual.sort();+ expected.sort();+ assert_eq!(actual, expected, "区间 {narrow:?} 与 {broad:?}");+ }+ }++ #[test]+ fn a_union_of_outputs_does_not_cover_another_output() {+ let target = n(100);+ let intervals = [+ (Some(0), Some(60)),+ (Some(40), Some(100)),+ (Some(20), Some(80)),+ ];+ let edges = [P, Q, R]+ .into_iter()+ .zip(intervals)+ .enumerate()+ .map(|(i, (source, (from, to)))| tep(source, i as u8, 1, 2, from, to))+ .collect::<Vec<_>>();+ let axioms = [P, Q, R]+ .map(|source| {+ (+ source,+ Axioms {+ sub_property_of: Some(target),+ ..Default::default()+ },+ )+ })+ .into_iter()+ .collect();+ let result = derive(&edges, &axioms);+ let spans = spans_of(&edges);+ let mut actual: Vec<_> = result+ .facts+ .iter()+ .map(|fact| {+ assert_eq!(+ (fact.predicate, fact.subject, fact.object),+ (target, n(1), n(2))+ );+ assert_eq!(fact.premises.len(), 1);+ let source = edges+ .iter()+ .find(|edge| edge.edge.fact == fact.premises[0])+ .unwrap();+ assert_eq!(+ (fact.via, fact.rule),+ (source.edge.predicate, Rule::SubProperty)+ );+ validity(&fact.premises, &spans).unwrap()+ })+ .collect();+ actual.sort();+ let mut expected = intervals.to_vec();+ expected.sort();+ assert_eq!(actual, expected, "只能由单个区间覆盖,不能拿两段的并集替代");+ }++ #[test]+ fn final_cleanup_keeps_one_equal_output_and_its_original_proof() {+ let first = Derived {+ predicate: Q,+ subject: n(1),+ object: n(2),+ via: P,+ rule: Rule::SubProperty,+ premises: vec![f(1)],+ };+ let second = Derived {+ via: Q,+ rule: Rule::Transitive,+ premises: vec![f(2), f(3)],+ ..first.clone()+ };+ let other_triple = Derived {+ predicate: R,+ ..first.clone()+ };+ let spans = HashMap::from([+ (f(1), (Some(10), Some(20))),+ (f(2), (Some(0), Some(20))),+ (f(3), (Some(10), Some(30))),+ ]);+ let mut outputs = vec![first.clone(), other_triple.clone(), second];+ retain_widest_outputs(&mut outputs, &spans);+ assert_eq!(outputs, vec![first, other_triple]);+ }++ #[test]+ fn final_cleanup_does_not_change_outputs_with_an_empty_validity() {+ // 单跳规则原本允许此输入返回输出,由消费方用 validity 拒绝;清理不能改成 panic。+ for to in [10, 20] {+ let edges = [tep(P, 1, 1, 2, Some(20), Some(to))];+ let result = derive(&edges, &sub_property());+ assert_eq!(result.facts.len(), 1);+ assert_eq!(result.facts[0].premises, vec![f(1)]);+ assert_eq!(validity(&result.facts[0].premises, &spans_of(&edges)), None);+ }+ }++ #[test]+ fn a_narrower_shorter_proof_still_finishes_within_the_depth_limit() {+ let mut edges = edges_with_shortcuts();+ let shortcut = edges+ .iter_mut()+ .find(|edge| edge.edge.subject == n(21) && edge.edge.object == n(16))+ .unwrap();+ shortcut.from = Some(10);+ shortcut.to = Some(20);+ let shortcut_fact = shortcut.edge.fact;+ let result = derive(&edges, &transitive());+ let spans = spans_of(&edges);+ let chain = result+ .facts+ .iter()+ .find(|fact| fact.subject == n(11) && fact.object == n(20))+ .expect("较窄的捷径证明也要在 12 条前提内走完");+ assert_eq!(chain.premises.len(), MAX_DEPTH);+ assert!(chain.premises.contains(&shortcut_fact));+ assert_eq!(+ validity(&chain.premises, &spans),+ Some((Some(10), Some(20)))+ );+ let prefix = result+ .facts+ .iter()+ .filter(|fact| fact.subject == n(11) && fact.object == n(16))+ .collect::<Vec<_>>();+ assert_eq!(+ prefix.len(),+ 1,+ "窄的中间证明参与传播,但最终只展示宽的前缀"+ );+ assert_eq!(validity(&prefix[0].premises, &spans), Some((None, None)));+ }+/// 区间照旧取交集,跨谓词也一样。#[test]fn the_inverse_carries_the_same_span() {