Skip to content

World's first open-source enterprise world 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.rs
index 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>) -> Derivation
out
}
+/// `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() {