1use dive_eval::{ConstBinding, Scope, SlotView, St};
7use dive_ir::{
8 Arg, ConstId, DefId, DefScope, Effects, Expr, ExprId, JunctionKind, Level, OpRef, QuantKind,
9 StdOp,
10};
11use dive_model::{Model, Pred};
12use dive_value::Value;
13
14use crate::State;
15use crate::enabled::enabled;
16
17#[derive(Clone, Debug, PartialEq, Eq)]
19#[non_exhaustive]
20pub enum TemporalError {
21 Interrupted(dive_eval::EvalError),
23 Invalid(String),
25 Unsupported(String),
27}
28
29impl std::fmt::Display for TemporalError {
30 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
31 match self {
32 Self::Invalid(s) => write!(f, "invalid temporal word: {s}"),
33 Self::Unsupported(s) => write!(f, "unsupported temporal validation: {s}"),
34 Self::Interrupted(error) => error.fmt(f),
35 }
36 }
37}
38
39impl std::error::Error for TemporalError {}
40
41impl From<dive_eval::EvalError> for TemporalError {
42 fn from(error: dive_eval::EvalError) -> Self {
43 Self::evaluation(error, "")
44 }
45}
46
47impl TemporalError {
48 fn evaluation(error: dive_eval::EvalError, context: &str) -> Self {
49 if error.class() == dive_eval::ErrorClass::Interrupted {
50 Self::Interrupted(error)
51 } else {
52 Self::Unsupported(format!("{context}{error}"))
53 }
54 }
55}
56
57pub fn evaluate_lasso(
88 model: &Model,
89 formula: &Pred,
90 states: &[State],
91 back_to: usize,
92) -> Result<Vec<bool>, TemporalError> {
93 model
94 .evaluator
95 .validate_model_context(&model.ir, &model.names)
96 .map_err(|error| TemporalError::Unsupported(error.to_string()))?;
97 model
98 .evaluator
99 .validate_predicate(&formula.scope, formula.expr)
100 .map_err(TemporalError::from)?;
101 if model.has_runtime_names() {
102 return Err(TemporalError::Unsupported(
103 crate::RUNTIME_NAMES_UNSUPPORTED.to_owned(),
104 ));
105 }
106 if states.is_empty() || back_to >= states.len() {
107 return Err(TemporalError::Invalid("invalid lasso back edge".into()));
108 }
109 if states
110 .iter()
111 .any(|s| s.len() != model.ir.vars().len() || s.iter().any(Option::is_none))
112 {
113 return Err(TemporalError::Invalid(
114 "a lasso state does not assign every variable".into(),
115 ));
116 }
117 for state in states {
118 crate::trace::validate_state_names(model, state).map_err(TemporalError::Unsupported)?;
119 }
120 let guard = crate::enabled::ComposeGuard::install(model);
121 let mut cx = Word {
122 model,
123 states,
124 back_to,
125 cells: 0,
126 };
127 let truth = cx.eval(formula.expr, &formula.scope, 0);
128 if matches!(truth, Err(TemporalError::Interrupted(_))) {
129 return truth;
130 }
131 if guard.composed() {
132 return Err(TemporalError::Unsupported(
133 crate::COMPOSITION_UNSUPPORTED.to_owned(),
134 ));
135 }
136 if model.has_runtime_names() {
137 return Err(TemporalError::Unsupported(
138 crate::RUNTIME_NAMES_UNSUPPORTED.to_owned(),
139 ));
140 }
141 truth
142}
143
144pub(crate) fn check_periodic_context(model: &Model, pred: &Pred) -> Result<(), TemporalError> {
147 model
148 .evaluator
149 .validate_model_context(&model.ir, &model.names)
150 .map_err(|error| TemporalError::Unsupported(error.to_string()))?;
151 model
152 .evaluator
153 .validate_predicate(&pred.scope, pred.expr)
154 .map_err(TemporalError::from)?;
155 let node = model.ir.nodes().get(pred.expr.index()).ok_or_else(|| {
156 TemporalError::Unsupported("missing periodic predicate expression".into())
157 })?;
158 if node.effects.intersects(Effects::IMPURE)
159 || model.evaluator.scope_shares_side_effects(&pred.scope)
160 {
161 return Err(TemporalError::Unsupported(
162 "side effects, dynamic bindings or ENABLED in periodic behavior validation".into(),
163 ));
164 }
165 Word {
166 model,
167 states: &[],
168 back_to: 0,
169 cells: 0,
170 }
171 .check_atom_context(pred.expr, &pred.scope)
172}
173
174fn enabled_refusal(e: &crate::enabled::EnabledError, context: &str) -> TemporalError {
178 match e {
179 crate::enabled::EnabledError::Interrupted(error) => {
180 TemporalError::Interrupted(error.clone())
181 }
182 crate::enabled::EnabledError::Unsupported(feature)
183 if feature == crate::COMPOSITION_UNSUPPORTED =>
184 {
185 TemporalError::Unsupported(feature.clone())
186 }
187 _ => TemporalError::Unsupported(format!("{context}{e}")),
188 }
189}
190
191fn substitution_is_pure(
196 model: &Model,
197 scope: &Scope,
198 bindings: &[dive_ir::SubstBinding],
199) -> Result<(), TemporalError> {
200 let ev = &model.evaluator;
201 let pure = ev.validate_scope(scope).is_ok()
202 && bindings.iter().all(|binding| {
203 model.ir.decls().get(binding.decl.index()).is_some()
204 && match binding.value {
205 Arg::Expr { expr, .. } => {
206 ev.validate_predicate(scope, expr).is_ok()
207 && model
208 .ir
209 .nodes()
210 .get(expr.index())
211 .is_some_and(|n| !n.effects.intersects(Effects::IMPURE))
212 }
213 Arg::Op { .. } => true,
214 }
215 });
216 if pure {
217 Ok(())
218 } else {
219 Err(TemporalError::Unsupported(
220 "INSTANCE substitution with side effects or a foreign context".into(),
221 ))
222 }
223}
224
225struct Word<'a> {
226 model: &'a Model,
227 states: &'a [State],
228 back_to: usize,
229 cells: usize,
230}
231
232impl Word<'_> {
233 #[allow(
234 clippy::too_many_lines,
235 reason = "one explicit arm per supported temporal constructor"
236 )]
237 fn eval(
238 &mut self,
239 expr: ExprId,
240 scope: &Scope,
241 depth: usize,
242 ) -> Result<Vec<bool>, TemporalError> {
243 self.cells = self.cells.saturating_add(self.states.len());
244 if depth > 256 || self.cells > 1_000_000 {
245 return Err(TemporalError::Unsupported(
246 "temporal validation resource bound".into(),
247 ));
248 }
249 let ev = &self.model.evaluator;
250 let node = self
251 .model
252 .ir
253 .nodes()
254 .get(expr.index())
255 .ok_or_else(|| TemporalError::Unsupported("missing temporal expression".into()))?;
256 if node.effects.intersects(Effects::IMPURE) || ev.scope_shares_side_effects(scope) {
257 return Err(TemporalError::Unsupported(
258 "side effects or dynamically bound constants in temporal validation".into(),
259 ));
260 }
261 if let Expr::Subst { body, bindings } = &node.expr {
262 substitution_is_pure(self.model, scope, bindings)?;
263 let sc = ev.scope_subst(scope, expr).map_err(TemporalError::from)?;
264 return self.eval(*body, &sc, depth + 1);
265 }
266 if let Expr::SubstRef {
267 decl,
268 primed: false,
269 } = &node.expr
270 && let SlotView::Lazy(body, sc) = ev.scope_subst_slot(scope, *decl)
271 {
272 return self.eval(body, &sc, depth + 1);
273 }
274 if let Expr::Let { body, .. } = &node.expr {
275 let sc = ev.scope_let(scope, expr).map_err(TemporalError::from)?;
276 return self.eval(*body, &sc, depth + 1);
277 }
278 if let Expr::Local(r) = &node.expr
279 && let SlotView::Lazy(body, sc) = ev.scope_slot(scope, *r)
280 {
281 return self.eval(body, &sc, depth + 1);
282 }
283 if let Expr::Apply {
284 callee: OpRef::Def(d),
285 args,
286 } = &node.expr
287 {
288 let leaf = self.recursive_leaf(scope, *d);
289 let d = self.checked_definition(*d)?;
290 if self.model.ir.def(d).std.is_none() && !ev.is_value_override(d) && !leaf {
292 let sc = self.scoped_call(scope, d, args, depth + 1, &mut 0)?;
293 return self.eval(self.model.ir.def(d).body, &sc, depth + 1);
294 }
295 }
296 if let Expr::Apply {
297 callee: OpRef::Param(local),
298 args,
299 } = &node.expr
300 {
301 if self
302 .native_parameter(scope, *local, args, depth + 1, &mut 0)?
303 .is_some()
304 {
305 return self.atom(expr, scope);
306 }
307 let (def, called) = self.parameter_call(scope, *local, args, depth + 1, &mut 0)?;
308 return self.eval(self.model.ir.def(def).body, &called, depth + 1);
309 }
310 if let Expr::StepAngle { action, sub } | Expr::StepBox { action, sub } = &node.expr {
311 return self.temporal_action(
312 *action,
313 *sub,
314 scope,
315 matches!(node.expr, Expr::StepBox { .. }),
316 );
317 }
318 let level = self.scoped_level(expr, scope, depth, &mut 0)?;
319 if level <= Level::Action
323 && !node.effects.intersects(Effects::TEMPORAL)
324 && (!node.effects.contains(Effects::USES_ENABLED)
325 || self.scoped_level_mode(expr, scope, depth, &mut 0, true)? == Level::Action)
326 {
327 return self.atom(expr, scope);
328 }
329 let child = depth + 1;
330 match &node.expr {
331 Expr::Enabled(action) => self
332 .states
333 .iter()
334 .map(|state| {
335 enabled(self.model, &Pred::new(*action, scope.clone()), None, state)
336 .map_err(|e| enabled_refusal(&e, ""))
337 })
338 .collect(),
339 Expr::Always(e) | Expr::Eventually(e) => {
340 let always = matches!(node.expr, Expr::Always(_));
341 let values = self.eval(*e, scope, child)?;
342 Ok(self.future(values, always))
343 }
344 Expr::Not(e) => Ok(self
345 .eval(*e, scope, child)?
346 .into_iter()
347 .map(|b| !b)
348 .collect()),
349 Expr::Implies(a, b) | Expr::Equiv(a, b) | Expr::LeadsTo(a, b) => {
350 let a = self.eval(*a, scope, child)?;
351 let b = self.eval(*b, scope, child)?;
352 let equivalent = matches!(node.expr, Expr::Equiv(..));
353 let leads = matches!(node.expr, Expr::LeadsTo(..));
354 let b = if leads { self.future(b, false) } else { b };
355 let values = a
356 .into_iter()
357 .zip(b)
358 .map(|(a, b)| if equivalent { a == b } else { !a || b })
359 .collect();
360 Ok(if leads {
361 self.future(values, true)
362 } else {
363 values
364 })
365 }
366 Expr::Junction { kind, items, .. } => {
367 let conjunction = matches!(kind, JunctionKind::And);
368 let mut values = vec![conjunction; self.states.len()];
369 for item in items {
370 let rhs = self.eval(*item, scope, child)?;
371 for (a, b) in values.iter_mut().zip(rhs) {
372 *a = if conjunction { *a && b } else { *a || b };
373 }
374 }
375 Ok(values)
376 }
377 Expr::Quant { kind, body, .. } if *kind != QuantKind::Choose => {
378 let scopes = self.finite_scopes(expr, scope, child, &mut 0)?;
379 let conjunction = *kind == QuantKind::Forall;
380 let mut values = vec![conjunction; self.states.len()];
381 for scope in scopes {
382 let rhs = self.eval(*body, &scope, child)?;
383 for (a, b) in values.iter_mut().zip(rhs) {
384 *a = if conjunction { *a && b } else { *a || b };
385 }
386 }
387 Ok(values)
388 }
389 Expr::If { cond, then, other } => {
390 if self.scoped_level(*cond, scope, child, &mut 0)? == Level::Action {
391 return Err(TemporalError::Unsupported(
392 "TLC liveness rejects action-level conditional guards".into(),
393 ));
394 }
395 let guards = self.eval(*cond, scope, child)?;
396 let yes = self.eval(*then, scope, child)?;
397 let no = self.eval(*other, scope, child)?;
398 Ok(guards
399 .into_iter()
400 .zip(yes)
401 .zip(no)
402 .map(|((guard, yes), no)| if guard { yes } else { no })
403 .collect())
404 }
405 Expr::Apply {
406 callee: OpRef::Def(d),
407 args,
408 } => {
409 let d = self.checked_definition(*d)?;
410 let scope = self.scoped_call(scope, d, args, child, &mut 0)?;
411 self.eval(self.model.ir.def(d).body, &scope, child)
412 }
413 Expr::Def(d) => {
414 let d = self.checked_definition(*d)?;
415 if ev.is_value_override(d) || self.model.ir.def(d).recursive {
416 return Err(TemporalError::Unsupported(
417 "overridden or recursive temporal definition".into(),
418 ));
419 }
420 let scope = ev.scope_enter(scope, d).map_err(TemporalError::from)?;
421 self.eval(self.model.ir.def(d).body, &scope, child)
422 }
423 Expr::Selected(e) | Expr::Label { body: e, .. } => self.eval(*e, scope, child),
424 Expr::Wf { sub, action } | Expr::Sf { sub, action } => {
425 self.fairness(*action, *sub, scope, matches!(node.expr, Expr::Sf { .. }))
426 }
427 other => Err(TemporalError::Unsupported(format!(
428 "temporal constructor {}",
429 other.tag()
430 ))),
431 }
432 }
433
434 fn fairness(
438 &self,
439 action: ExprId,
440 sub: ExprId,
441 scope: &Scope,
442 strong: bool,
443 ) -> Result<Vec<bool>, TemporalError> {
444 let occurrences = self.temporal_action(action, sub, scope, false)?;
445 let recurrent = occurrences[self.back_to..].iter().any(|occurs| *occurs);
446 if recurrent {
447 Ok(vec![true; self.states.len()])
448 } else {
449 let action = Pred::new(action, scope.clone());
450 let disabled: Vec<bool> = self.states[self.back_to..]
451 .iter()
452 .map(|state| {
453 enabled(self.model, &action, Some(sub), state)
454 .map(|enabled| !enabled)
455 .map_err(|e| enabled_refusal(&e, "fairness "))
456 })
457 .collect::<Result<_, _>>()?;
458 let holds = if strong {
461 disabled.iter().all(|b| *b)
462 } else {
463 disabled.iter().any(|b| *b)
464 };
465 Ok(vec![holds; self.states.len()])
466 }
467 }
468
469 fn temporal_action(
472 &self,
473 action: ExprId,
474 sub: ExprId,
475 scope: &Scope,
476 boxed: bool,
477 ) -> Result<Vec<bool>, TemporalError> {
478 self.check_atom_context(action, scope)?;
479 self.check_scoped_context_mode(sub, scope, 0, &mut 0, false)?;
480 if self.scoped_level(sub, scope, 0, &mut 0)? > Level::State {
481 return Err(TemporalError::Unsupported(
482 "action-level temporal subscript".into(),
483 ));
484 }
485 let ev = &self.model.evaluator;
486 let mut out = Vec::with_capacity(self.states.len());
487 for (i, state) in self.states.iter().enumerate() {
488 let next = if i + 1 == self.states.len() {
489 self.back_to
490 } else {
491 i + 1
492 };
493 let read = |at: usize| ev.eval_scoped(scope, sub, &St::state(self.states[at].clone()));
494 let same = (|| {
495 let before = read(i)?;
496 let after = read(next)?;
497 ev.equal_values(&before, &after)
498 })()
499 .map_err(|e: dive_eval::EvalError| {
500 TemporalError::evaluation(e, &format!("temporal subscript at position {i}: "))
501 })?;
502 if same {
503 out.push(boxed);
504 continue;
505 }
506 let st = St::action(state.clone(), self.states[next].clone());
507 match ev.eval_scoped(scope, action, &st) {
508 Ok(Value::Bool(b)) => out.push(b),
509 Ok(v) => {
510 return Err(TemporalError::Invalid(format!(
511 "temporal action at position {i} is {}, not boolean",
512 v.kind_name()
513 )));
514 }
515 Err(e) => {
516 return Err(TemporalError::evaluation(
517 e,
518 &format!("temporal action at position {i}: "),
519 ));
520 }
521 }
522 }
523 Ok(out)
524 }
525
526 fn atom(&self, expr: ExprId, scope: &Scope) -> Result<Vec<bool>, TemporalError> {
527 self.check_atom_context(expr, scope)?;
528 let mut out = Vec::with_capacity(self.states.len());
529 for (i, state) in self.states.iter().enumerate() {
530 let next = if i + 1 == self.states.len() {
531 self.back_to
532 } else {
533 i + 1
534 };
535 let st = St::action(state.clone(), self.states[next].clone());
536 match self.model.evaluator.eval_scoped(scope, expr, &st) {
537 Ok(Value::Bool(b)) => out.push(b),
538 Ok(v) => {
539 return Err(TemporalError::Invalid(format!(
540 "temporal atom at position {i} is {}, not boolean",
541 v.kind_name()
542 )));
543 }
544 Err(e) => {
545 return Err(TemporalError::evaluation(
546 e,
547 &format!("temporal atom at position {i}: "),
548 ));
549 }
550 }
551 }
552 Ok(out)
553 }
554
555 fn declaration_fallback(
558 &self,
559 scope: &Scope,
560 decl: dive_ir::DeclId,
561 ) -> Result<Option<Pred>, TemporalError> {
562 let declaration = self.model.ir.decl(decl);
563 if declaration.variable {
564 return Ok(None);
565 }
566 let constant = declaration.constant.ok_or_else(|| {
567 TemporalError::Unsupported("missing original substitution declaration".into())
568 })?;
569 self.constant_context(scope, constant)
570 }
571
572 fn constant_context(
573 &self,
574 scope: &Scope,
575 constant: ConstId,
576 ) -> Result<Option<Pred>, TemporalError> {
577 let ev = &self.model.evaluator;
578 match ev.constant_binding(constant) {
579 Some(ConstBinding::Value(_)) => Ok(None),
580 Some(ConstBinding::Def(def)) => {
581 let def = self.checked_definition(def)?;
582 let target = self.model.ir.def(def);
583 if target.level != Level::Constant || target.recursive || !target.params.is_empty()
584 {
585 return Err(TemporalError::Unsupported(
586 "nonconstant/recursive/parameterized constant override".into(),
587 ));
588 }
589 if !ev.is_value_override(def) {
590 Self::check_native(target.std)?;
591 }
592 let scope = ev.scope_enter(scope, def).map_err(TemporalError::from)?;
593 Ok(Some(Pred::new(target.body, scope)))
594 }
595 None => Err(TemporalError::Unsupported(
596 "unbound temporal constant".into(),
597 )),
598 }
599 }
600
601 fn recursive_leaf(&self, scope: &Scope, def: DefId) -> bool {
606 !scope.has_substitutions() && self.model.evaluator.recursive_leaf(def)
607 }
608
609 fn checked_definition(&self, def: DefId) -> Result<DefId, TemporalError> {
610 if self.model.ir.defs().get(def.index()).is_none() {
611 return Err(TemporalError::Unsupported(
612 "missing scoped temporal definition".into(),
613 ));
614 }
615 let target = self.model.evaluator.redirected(def);
616 if self.model.ir.defs().get(target.index()).is_none() {
617 return Err(TemporalError::Unsupported(
618 "missing redirected temporal definition".into(),
619 ));
620 }
621 Ok(target)
622 }
623
624 fn configured_call(
627 &self,
628 expr: ExprId,
629 scope: &Scope,
630 constant: ConstId,
631 args: &[Arg],
632 depth: usize,
633 steps: &mut usize,
634 ) -> Result<(DefId, Scope), TemporalError> {
635 *steps = steps.saturating_add(1);
636 if depth > 256 || *steps > 100_000 || args.len() > 4096 {
637 return Err(TemporalError::Unsupported(
638 "configured temporal call bound".into(),
639 ));
640 }
641 let ev = &self.model.evaluator;
642 ev.validate_model_context(&self.model.ir, &self.model.names)
643 .map_err(|error| TemporalError::Unsupported(error.to_string()))?;
644 ev.validate_predicate(scope, expr)
645 .map_err(TemporalError::from)?;
646 let Some(ConstBinding::Def(def)) = ev.constant_binding(constant) else {
647 return Err(TemporalError::Unsupported(
648 "unbound/value-bound temporal atom operator".into(),
649 ));
650 };
651 let def = self.checked_definition(def)?;
652 let target = self.model.ir.def(def);
653 if self
654 .model
655 .ir
656 .node(target.body)
657 .effects
658 .contains(Effects::USES_ENABLED)
659 {
660 return Err(TemporalError::Unsupported(
661 "configured ENABLED target".into(),
662 ));
663 }
664 if target.scope != DefScope::TopLevel
665 || target.recursive
666 || target.std.is_some()
667 || ev.is_value_override(def)
668 || target.level > Level::Action
669 || target.params.iter().any(|p| p.arity != 0)
670 {
671 return Err(TemporalError::Unsupported(
672 "configured temporal atom operator target".into(),
673 ));
674 }
675 let called = ev
676 .scope_apply(scope, def, args)
677 .map_err(TemporalError::from)?;
678 for arg in args {
679 let Arg::Expr { expr: actual, .. } = arg else {
680 return Err(TemporalError::Unsupported(
681 "higher-order configured temporal argument".into(),
682 ));
683 };
684 self.check_scoped_context_mode(*actual, scope, depth + 1, steps, true)?;
685 }
686 self.check_scoped_context_mode(target.body, &called, depth + 1, steps, true)?;
689 Ok((def, called))
690 }
691
692 fn scoped_call(
693 &self,
694 scope: &Scope,
695 def: DefId,
696 args: &[Arg],
697 depth: usize,
698 steps: &mut usize,
699 ) -> Result<Scope, TemporalError> {
700 let ev = &self.model.evaluator;
701 let def = self.checked_definition(def)?;
702 let d = self.model.ir.def(def);
703 if depth > 256
704 || args.len() > 4096
705 || d.recursive
706 || d.std.is_some()
707 || ev.is_value_override(def)
708 {
709 return Err(TemporalError::Unsupported(
710 "recursive/overridden/higher-order or bounded temporal call".into(),
711 ));
712 }
713 let mut constant = true;
714 for arg in args {
715 let Arg::Expr { expr, .. } = arg else {
716 if let Arg::Op { op, .. } = arg {
717 self.operator_context(op, scope, depth + 1, steps)?;
718 }
719 constant = false;
720 continue;
721 };
722 let level = self.scoped_level(*expr, scope, depth + 1, steps)?;
723 let maximum = if d.level == Level::Temporal {
724 Level::State
725 } else {
726 Level::Action
727 };
728 if level == Level::Temporal {
729 if scope.has_substitutions() {
730 return Err(TemporalError::Unsupported(
731 "temporal argument inside INSTANCE context".into(),
732 ));
733 }
734 self.forwarded_context_mode(*expr, scope, depth + 1, steps, true)?;
735 } else {
736 if level > maximum {
737 return Err(TemporalError::Unsupported(
738 "action/temporal operator argument".into(),
739 ));
740 }
741 self.check_scoped_context(*expr, scope, depth + 1, steps)?;
742 }
743 constant &= level == Level::Constant;
744 }
745 if constant {
746 let mut values = Vec::with_capacity(args.len());
747 for arg in args {
748 let Arg::Expr { expr, .. } = arg else {
749 return Err(TemporalError::Unsupported(
750 "operator temporal argument".into(),
751 ));
752 };
753 match ev.eval_scoped(scope, *expr, &St::constant()) {
754 Ok(value) => values.push(value),
755 Err(e) if e.is_analysis_only() => {
756 return ev
757 .scope_apply(scope, def, args)
758 .map_err(TemporalError::from);
759 }
760 Err(e) => {
761 return Err(TemporalError::evaluation(e, "constant temporal argument: "));
762 }
763 }
764 }
765 ev.scope_call_values(scope, def, values)
766 .map_err(TemporalError::from)
767 } else {
768 ev.scope_apply(scope, def, args)
769 .map_err(TemporalError::from)
770 }
771 }
772
773 fn operator_context(
774 &self,
775 operator: &OpRef,
776 scope: &Scope,
777 depth: usize,
778 steps: &mut usize,
779 ) -> Result<(), TemporalError> {
780 *steps = steps.saturating_add(1);
781 let mut remaining = 100_000_usize.saturating_sub(*steps);
782 let native =
783 self.model
784 .evaluator
785 .scope_native_operator_analysis(scope, operator, &mut remaining);
786 *steps = 100_000 - remaining;
787 let (def, analysis) = if native.map_err(TemporalError::from)?.is_some() {
788 (None, scope.clone())
789 } else {
790 let (def, analysis) = self
791 .model
792 .evaluator
793 .scope_operator_analysis(scope, operator)
794 .map_err(TemporalError::from)?
795 .ok_or_else(|| {
796 TemporalError::Unsupported(
797 "opaque/recursive/higher-order operator capture".into(),
798 )
799 })?;
800 (Some(def), analysis)
801 };
802 let mut remaining = 100_000_usize.saturating_sub(*steps);
803 let captures = self
804 .model
805 .evaluator
806 .scope_operator_captures(&analysis, &mut remaining);
807 *steps = 100_000 - remaining;
808 let captures = captures
809 .map_err(TemporalError::from)?
810 .ok_or_else(|| TemporalError::Unsupported("opaque captured operator context".into()))?;
811 for (body, captured) in captures {
812 self.forwarded_context(body, &captured, depth + 1, steps)?;
813 }
814 if let Some(def) = def {
815 self.forwarded_context(self.model.ir.def(def).body, &analysis, depth + 1, steps)?;
816 }
817 Ok(())
818 }
819
820 fn native_parameter(
823 &self,
824 scope: &Scope,
825 local: dive_ir::LocalRef,
826 args: &[Arg],
827 depth: usize,
828 steps: &mut usize,
829 ) -> Result<Option<Level>, TemporalError> {
830 let mut remaining = 100_000_usize.saturating_sub(*steps);
831 let native = self.model.evaluator.scope_native_operator_analysis(
832 scope,
833 &OpRef::Param(local),
834 &mut remaining,
835 );
836 *steps = 100_000 - remaining;
837 let Some(native) = native.map_err(TemporalError::from)? else {
838 return Ok(None);
839 };
840 if i32::try_from(args.len()).ok() != Some(native.java_arity()) {
841 return Err(TemporalError::Unsupported(
842 "native operator argument arity".into(),
843 ));
844 }
845 self.operator_context(&OpRef::Param(local), scope, depth + 1, steps)?;
846 let mut level = Level::Constant;
847 for arg in args {
848 let Arg::Expr { expr, .. } = arg else {
849 return Err(TemporalError::Unsupported(
850 "native higher-order argument".into(),
851 ));
852 };
853 self.forwarded_context(*expr, scope, depth + 1, steps)?;
854 let actual = self.scoped_level(*expr, scope, depth + 1, steps)?;
855 if actual > Level::State {
856 return Err(TemporalError::Unsupported(
857 "native action/temporal argument".into(),
858 ));
859 }
860 level = level.max(actual);
861 }
862 Ok(Some(level))
863 }
864
865 fn parameter_call(
866 &self,
867 scope: &Scope,
868 local: dive_ir::LocalRef,
869 args: &[Arg],
870 depth: usize,
871 steps: &mut usize,
872 ) -> Result<(DefId, Scope), TemporalError> {
873 self.operator_context(&OpRef::Param(local), scope, depth + 1, steps)?;
874 for arg in args {
875 let Arg::Expr { expr, .. } = arg else {
876 return Err(TemporalError::Unsupported(
877 "higher-order operator actual".into(),
878 ));
879 };
880 self.forwarded_context(*expr, scope, depth + 1, steps)?;
881 }
882 self.model
883 .evaluator
884 .scope_apply_param(scope, local, args)
885 .ok_or_else(|| TemporalError::Unsupported("opaque operator parameter".into()))?
886 .map_err(TemporalError::from)
887 }
888
889 fn forwarded_context(
890 &self,
891 expr: ExprId,
892 scope: &Scope,
893 depth: usize,
894 steps: &mut usize,
895 ) -> Result<(), TemporalError> {
896 self.forwarded_context_mode(expr, scope, depth, steps, false)
897 }
898
899 #[allow(
906 clippy::too_many_lines,
907 reason = "explicit retained temporal context admission and refusal paths"
908 )]
909 fn forwarded_context_mode(
910 &self,
911 expr: ExprId,
912 scope: &Scope,
913 depth: usize,
914 steps: &mut usize,
915 temporal_actual: bool,
916 ) -> Result<(), TemporalError> {
917 let mut todo = vec![(expr, scope.clone(), depth)];
918 while let Some((e, sc, depth)) = todo.pop() {
919 *steps = steps.saturating_add(1);
920 if depth > 256 || *steps > 100_000 {
921 return Err(TemporalError::Unsupported(
922 "forwarded temporal context resource bound".into(),
923 ));
924 }
925 let ir = &self.model.ir;
926 let ev = &self.model.evaluator;
927 let n = ir.nodes().get(e.index()).ok_or_else(|| {
928 TemporalError::Unsupported("missing forwarded temporal expression".into())
929 })?;
930 if n.effects.intersects(Effects::IMPURE | Effects::LIVE_TLCGET)
931 || ev.scope_shares_side_effects(&sc)
932 {
933 return Err(TemporalError::Unsupported(
934 "effectful forwarded temporal context".into(),
935 ));
936 }
937 if !temporal_actual && n.effects.contains(Effects::USES_ENABLED) {
938 return Err(TemporalError::Unsupported(
939 "ENABLED in forwarded operator capture".into(),
940 ));
941 }
942 match &n.expr {
943 Expr::Unbound(_) | Expr::Unevaluable(_) => {
944 return Err(TemporalError::Unsupported(
945 "unbound/unevaluable operator capture".into(),
946 ));
947 }
948 Expr::Local(r) => match ev.scope_slot(&sc, *r) {
949 SlotView::Value(_) | SlotView::AnalysisBound | SlotView::AnalysisConstant => {
950 continue;
951 }
952 SlotView::Lazy(body, inner) => {
953 todo.push((body, inner, depth + 1));
954 continue;
955 }
956 _ => {
957 return Err(TemporalError::Unsupported(
958 "opaque forwarded temporal local".into(),
959 ));
960 }
961 },
962 Expr::SubstRef { decl, primed } => match ev
963 .scope_substitution(&sc, *decl, &St::constant(), *primed)
964 .map_err(TemporalError::from)?
965 {
966 Some(
967 SlotView::Value(_) | SlotView::AnalysisBound | SlotView::AnalysisConstant,
968 ) => continue,
969 Some(SlotView::Lazy(body, inner)) => {
970 todo.push((body, inner, depth + 1));
971 continue;
972 }
973 None => {
974 if let Some(pred) = self.declaration_fallback(&sc, *decl)? {
975 todo.push((pred.expr, pred.scope, depth + 1));
976 }
977 continue;
978 }
979 _ => {
980 return Err(TemporalError::Unsupported(
981 "opaque forwarded temporal substitution".into(),
982 ));
983 }
984 },
985 Expr::Let { body, .. } => {
986 todo.push((
987 *body,
988 ev.scope_let(&sc, e).map_err(TemporalError::from)?,
989 depth + 1,
990 ));
991 continue;
992 }
993 Expr::Subst { body, bindings } => {
994 substitution_is_pure(self.model, &sc, bindings)?;
995 todo.push((
996 *body,
997 ev.scope_subst(&sc, e).map_err(TemporalError::from)?,
998 depth + 1,
999 ));
1000 continue;
1001 }
1002 Expr::Quant { body, .. }
1003 | Expr::FcnCons { body, .. }
1004 | Expr::SetMap { expr: body, .. }
1005 | Expr::SetFilter { pred: body, .. } => {
1006 let inner = ev
1007 .scope_binder_analysis(&sc, e)
1008 .map_err(TemporalError::from)?;
1009 for c in n.expr.children() {
1010 todo.push((
1011 c,
1012 if c == *body {
1013 inner.clone()
1014 } else {
1015 sc.clone()
1016 },
1017 depth + 1,
1018 ));
1019 }
1020 continue;
1021 }
1022 _ => {}
1023 }
1024 let call = match &n.expr {
1025 Expr::Def(d) => Some((OpRef::Def(*d), &[][..])),
1026 Expr::Apply { callee, args } => Some((callee.clone(), args.as_ref())),
1027 _ => None,
1028 };
1029 if let Some((op, args)) = call {
1030 for arg in args {
1031 if let Arg::Op { op, .. } = arg {
1032 self.operator_context(op, &sc, depth + 1, steps)?;
1033 }
1034 }
1035 match op {
1036 OpRef::Param(local) => {
1037 if self
1038 .native_parameter(&sc, local, args, depth + 1, steps)?
1039 .is_some()
1040 {
1041 continue;
1042 }
1043 let (def, called) =
1044 self.parameter_call(&sc, local, args, depth + 1, steps)?;
1045 todo.push((ir.def(def).body, called, depth + 1));
1046 continue;
1047 }
1048 OpRef::Def(d) => {
1049 let d = self.checked_definition(d)?;
1050 let def = ir.def(d);
1051 if def.recursive || ev.is_value_override(d) {
1052 return Err(TemporalError::Unsupported(
1053 "recursive/overridden forwarded temporal call".into(),
1054 ));
1055 }
1056 if def.std.is_none() {
1057 todo.push((
1058 def.body,
1059 ev.scope_apply(&sc, d, args).map_err(TemporalError::from)?,
1060 depth + 1,
1061 ));
1062 continue;
1063 }
1064 if def.std.is_some_and(|op| {
1065 op.impure()
1066 || matches!(
1067 op.support(),
1068 dive_ir::StdSupport::Io | dive_ir::StdSupport::Introspection
1069 )
1070 }) {
1071 return Err(TemporalError::Unsupported(
1072 "native callback operator capture".into(),
1073 ));
1074 }
1075 if def.std == Some(StdOp::TlcTLCGet) {
1076 return Err(TemporalError::Unsupported(
1077 "checker introspection in temporal argument".into(),
1078 ));
1079 }
1080 }
1081 OpRef::Std(op)
1082 if op.impure()
1083 || matches!(
1084 op.support(),
1085 dive_ir::StdSupport::Io | dive_ir::StdSupport::Introspection
1086 ) =>
1087 {
1088 return Err(TemporalError::Unsupported(
1089 "native callback operator capture".into(),
1090 ));
1091 }
1092 OpRef::Std(StdOp::TlcTLCGet) | OpRef::Const(_) | OpRef::Subst(_) => {
1093 return Err(TemporalError::Unsupported(
1094 "opaque/checker forwarded temporal operator".into(),
1095 ));
1096 }
1097 _ => {}
1098 }
1099 }
1100 todo.extend(
1101 n.expr
1102 .children()
1103 .into_iter()
1104 .map(|c| (c, sc.clone(), depth + 1)),
1105 );
1106 }
1107 Ok(())
1108 }
1109
1110 fn scoped_level(
1112 &self,
1113 expr: ExprId,
1114 scope: &Scope,
1115 depth: usize,
1116 steps: &mut usize,
1117 ) -> Result<Level, TemporalError> {
1118 self.scoped_level_mode(expr, scope, depth, steps, false)
1119 }
1120
1121 #[allow(
1122 clippy::too_many_lines,
1123 reason = "independent scoped level resolution and explicit refusal paths"
1124 )]
1125 fn scoped_level_mode(
1126 &self,
1127 expr: ExprId,
1128 scope: &Scope,
1129 depth: usize,
1130 steps: &mut usize,
1131 query_state: bool,
1132 ) -> Result<Level, TemporalError> {
1133 *steps = steps.saturating_add(1);
1134 if depth > 256 || *steps > 100_000 {
1135 return Err(TemporalError::Unsupported(
1136 "scoped temporal level resource bound".into(),
1137 ));
1138 }
1139 let ev = &self.model.evaluator;
1140 let ir = &self.model.ir;
1141 let node = ir.nodes().get(expr.index()).ok_or_else(|| {
1142 TemporalError::Unsupported("missing scoped temporal expression".into())
1143 })?;
1144 if query_state && matches!(node.expr, Expr::Enabled(_)) {
1147 return Ok(Level::State);
1148 }
1149 match &node.expr {
1150 Expr::Prime(body) => {
1151 return Ok(
1152 if self.scoped_level_mode(*body, scope, depth + 1, steps, query_state)?
1153 == Level::Constant
1154 {
1155 Level::Constant
1156 } else {
1157 Level::Action
1158 },
1159 );
1160 }
1161
1162 Expr::Builtin {
1163 op:
1164 dive_ir::BuiltinOp::Always
1165 | dive_ir::BuiltinOp::Eventually
1166 | dive_ir::BuiltinOp::LeadsTo,
1167 ..
1168 }
1169 | Expr::Always(_)
1170 | Expr::Eventually(_)
1171 | Expr::LeadsTo(_, _)
1172 | Expr::WhilePlus(_, _)
1173 | Expr::Wf { .. }
1174 | Expr::Sf { .. }
1175 | Expr::TemporalQuant { .. } => return Ok(Level::Temporal),
1176 Expr::Builtin {
1177 op: dive_ir::BuiltinOp::Prime | dive_ir::BuiltinOp::Unchanged,
1178 ..
1179 }
1180 | Expr::Var { primed: true, .. }
1181 | Expr::Unchanged(_)
1182 | Expr::StepAngle { .. }
1183 | Expr::StepBox { .. } => return Ok(Level::Action),
1184
1185 Expr::Apply {
1186 callee: OpRef::Const(constant),
1187 args,
1188 } => {
1189 let (def, called) =
1190 self.configured_call(expr, scope, *constant, args, depth + 1, steps)?;
1191 return self.scoped_level_mode(
1192 ir.def(def).body,
1193 &called,
1194 depth + 1,
1195 steps,
1196 query_state,
1197 );
1198 }
1199 Expr::Apply {
1200 callee: OpRef::Param(local),
1201 args,
1202 } => {
1203 if let Some(level) = self.native_parameter(scope, *local, args, depth + 1, steps)? {
1204 return Ok(level);
1205 }
1206 let (def, called) = self.parameter_call(scope, *local, args, depth + 1, steps)?;
1207 return self.scoped_level_mode(
1208 ir.def(def).body,
1209 &called,
1210 depth + 1,
1211 steps,
1212 query_state,
1213 );
1214 }
1215 Expr::Subst { body, bindings } => {
1216 substitution_is_pure(self.model, scope, bindings)?;
1217 let sc = ev.scope_subst(scope, expr).map_err(TemporalError::from)?;
1218 return self.scoped_level_mode(*body, &sc, depth + 1, steps, query_state);
1219 }
1220 Expr::SubstRef { decl, primed } => {
1221 let level = match ev
1222 .scope_substitution(scope, *decl, &St::constant(), *primed)
1223 .map_err(TemporalError::from)?
1224 {
1225 Some(SlotView::Value(_) | SlotView::AnalysisConstant) => Level::Constant,
1226 Some(SlotView::AnalysisBound) => Level::State,
1227 Some(SlotView::Lazy(e, sc)) => {
1228 self.scoped_level_mode(e, &sc, depth + 1, steps, query_state)?
1229 }
1230 None => match self.declaration_fallback(scope, *decl)? {
1231 Some(pred) => self.scoped_level_mode(
1232 pred.expr,
1233 &pred.scope,
1234 depth + 1,
1235 steps,
1236 query_state,
1237 )?,
1238 None if ir.decl(*decl).variable => Level::State,
1239 None => Level::Constant,
1240 },
1241 _ => {
1242 return Err(TemporalError::Unsupported(
1243 "opaque substituted level".into(),
1244 ));
1245 }
1246 };
1247 return Ok(if *primed && level != Level::Constant {
1248 Level::Action
1249 } else {
1250 level
1251 });
1252 }
1253 Expr::Let { body, .. } => {
1254 let sc = ev.scope_let(scope, expr).map_err(TemporalError::from)?;
1255 return self.scoped_level_mode(*body, &sc, depth + 1, steps, query_state);
1256 }
1257 Expr::Local(r) => {
1258 return match ev.scope_slot(scope, *r) {
1259 SlotView::Value(_) | SlotView::AnalysisConstant => Ok(Level::Constant),
1260 SlotView::AnalysisBound => Ok(Level::State),
1261 SlotView::Lazy(e, sc) => {
1262 self.scoped_level_mode(e, &sc, depth + 1, steps, query_state)
1263 }
1264 _ => Err(TemporalError::Unsupported(
1265 "opaque scoped temporal level".into(),
1266 )),
1267 };
1268 }
1269 Expr::Apply {
1270 callee: OpRef::Def(d),
1271 args,
1272 } => {
1273 let leaf = self.recursive_leaf(scope, *d);
1274 let d = self.checked_definition(*d)?;
1275 if leaf {
1276 let mut level = ir.def(d).level;
1279 for arg in args {
1280 let Arg::Expr { expr: actual, .. } = arg else {
1281 return Err(TemporalError::Unsupported(
1282 "operator argument in recursive call".into(),
1283 ));
1284 };
1285 level = level.max(self.scoped_level_mode(
1286 *actual,
1287 scope,
1288 depth + 1,
1289 steps,
1290 query_state,
1291 )?);
1292 }
1293 return Ok(level);
1294 }
1295 if ir.def(d).std.is_none() && !ev.is_value_override(d) {
1296 let sc = self.scoped_call(scope, d, args, depth + 1, steps)?;
1297 return self.scoped_level_mode(
1298 ir.def(d).body,
1299 &sc,
1300 depth + 1,
1301 steps,
1302 query_state,
1303 );
1304 }
1305 }
1306 Expr::Def(d) => {
1307 let leaf = self.recursive_leaf(scope, *d);
1308 let d = self.checked_definition(*d)?;
1309 if leaf {
1310 return Ok(ir.def(d).level);
1311 }
1312 if ir.def(d).std.is_none() && !ev.is_value_override(d) {
1313 let sc = self.scoped_call(scope, d, &[], depth + 1, steps)?;
1314 return self.scoped_level_mode(
1315 ir.def(d).body,
1316 &sc,
1317 depth + 1,
1318 steps,
1319 query_state,
1320 );
1321 }
1322 }
1323 Expr::Quant { body, .. } if node.level != Level::Temporal => {
1324 let (scopes, domain_level) =
1325 self.predicate_scopes(expr, scope, depth + 1, steps)?;
1326 let mut level = node.level.max(domain_level);
1327 for sc in scopes {
1328 level = level.max(self.scoped_level_mode(
1329 *body,
1330 &sc,
1331 depth + 1,
1332 steps,
1333 query_state,
1334 )?);
1335 }
1336 return Ok(level);
1337 }
1338 Expr::SetMap { expr: body, .. }
1339 | Expr::SetFilter { pred: body, .. }
1340 | Expr::FcnCons { body, .. }
1341 | Expr::RecFcn { body, .. } => {
1342 let (scopes, domain_level) =
1343 self.predicate_scopes(expr, scope, depth + 1, steps)?;
1344 let mut level = node.level.max(domain_level);
1345 for sc in scopes {
1346 level = level.max(self.scoped_level_mode(
1347 *body,
1348 &sc,
1349 depth + 1,
1350 steps,
1351 query_state,
1352 )?);
1353 }
1354 return Ok(level);
1355 }
1356 _ => {}
1357 }
1358 if node.level == Level::Temporal {
1359 return Ok(Level::Temporal);
1360 }
1361 if let Expr::Apply { callee, args } = &node.expr {
1362 let mut work = 100_000_usize.saturating_sub(*steps);
1363 if let Some((sequence, bodies)) = ev
1364 .scope_selectseq_call(scope, callee, args, &mut work)
1365 .map_err(TemporalError::from)?
1366 {
1367 *steps = 100_000 - work;
1368 let mut level = node.level.max(self.scoped_level_mode(
1369 sequence,
1370 scope,
1371 depth + 1,
1372 steps,
1373 query_state,
1374 )?);
1375 for (body, captured) in bodies {
1376 let callback_level =
1377 self.scoped_level_mode(body, &captured, depth + 1, steps, query_state)?;
1378 if callback_level > Level::State {
1379 return Err(TemporalError::Unsupported(
1380 "SelectSeq action/temporal callback".into(),
1381 ));
1382 }
1383 level = level.max(callback_level);
1384 }
1385 return Ok(level);
1386 }
1387 }
1388 let mut level = node.level;
1389 for child in node.expr.children() {
1390 level =
1391 level.max(self.scoped_level_mode(child, scope, depth + 1, steps, query_state)?);
1392 }
1393 Ok(level)
1394 }
1395
1396 fn predicate_scopes(
1398 &self,
1399 expr: ExprId,
1400 scope: &Scope,
1401 depth: usize,
1402 steps: &mut usize,
1403 ) -> Result<(Vec<Scope>, Level), TemporalError> {
1404 let bounds: &[dive_ir::Bound] = match self.model.ir.expr(expr) {
1405 Expr::Quant { bounds, .. }
1406 | Expr::SetMap { bounds, .. }
1407 | Expr::FcnCons { bounds, .. }
1408 | Expr::RecFcn { bounds, .. } => bounds,
1409 Expr::SetFilter { bound, .. } => std::slice::from_ref(bound),
1410 _ => {
1411 return Err(TemporalError::Unsupported(
1412 "predicate scopes require a binder".into(),
1413 ));
1414 }
1415 };
1416 let mut domain_level = Level::Constant;
1417 for bound in bounds {
1418 let dom = bound
1419 .domain
1420 .ok_or_else(|| TemporalError::Unsupported("unbounded predicate domain".into()))?;
1421 let level = self.scoped_level(dom, scope, depth + 1, steps)?;
1422 if level > Level::State {
1423 return Err(TemporalError::Unsupported(
1424 "action/temporal predicate domain".into(),
1425 ));
1426 }
1427 self.check_scoped_context(dom, scope, depth + 1, steps)?;
1428 domain_level = domain_level.max(level);
1429 }
1430 if domain_level == Level::Constant
1431 && !matches!(self.model.ir.expr(expr), Expr::RecFcn { .. })
1432 {
1433 return self
1434 .model
1435 .evaluator
1436 .scope_constant_binder_analysis(scope, expr)
1437 .map(|sc| (vec![sc], domain_level))
1438 .map_err(TemporalError::from);
1439 }
1440 if matches!(self.model.ir.expr(expr), Expr::RecFcn { .. }) {
1441 domain_level = domain_level.max(Level::State);
1442 }
1443 if let Expr::RecFcn { body, .. } = self.model.ir.expr(expr) {
1444 let analysis = self
1445 .model
1446 .evaluator
1447 .scope_binder_analysis(scope, expr)
1448 .map_err(TemporalError::from)?;
1449 if self.scoped_level(*body, &analysis, depth + 1, steps)? > Level::State {
1450 return Err(TemporalError::Unsupported(
1451 "action/temporal recursive function capture".into(),
1452 ));
1453 }
1454 }
1455 self.model
1456 .evaluator
1457 .scope_binder_analysis(scope, expr)
1458 .map(|sc| (vec![sc], domain_level))
1459 .map_err(TemporalError::from)
1460 }
1461
1462 fn finite_scopes(
1463 &self,
1464 expr: ExprId,
1465 scope: &Scope,
1466 depth: usize,
1467 steps: &mut usize,
1468 ) -> Result<Vec<Scope>, TemporalError> {
1469 let bounds: &[dive_ir::Bound] = match self.model.ir.expr(expr) {
1470 Expr::Quant { bounds, .. }
1471 | Expr::SetMap { bounds, .. }
1472 | Expr::FcnCons { bounds, .. }
1473 | Expr::RecFcn { bounds, .. } => bounds,
1474 Expr::SetFilter { bound, .. } => std::slice::from_ref(bound),
1475 _ => {
1476 return Err(TemporalError::Unsupported(
1477 "finite scopes require a finite binder".into(),
1478 ));
1479 }
1480 };
1481 for bound in bounds {
1482 let Some(dom) = bound.domain else {
1483 return Err(TemporalError::Unsupported(
1484 "unbounded predicate quantifier".into(),
1485 ));
1486 };
1487 if self.scoped_level(dom, scope, depth + 1, steps)? != Level::Constant {
1488 return Err(TemporalError::Unsupported(
1489 "nonconstant predicate quantifier domain".into(),
1490 ));
1491 }
1492 self.check_scoped_context(dom, scope, depth + 1, steps)?;
1493 }
1494 self.model
1495 .evaluator
1496 .scope_bindings_bounded(scope, expr, &St::constant(), 4096)
1497 .map_err(|e| TemporalError::evaluation(e, "temporal quantifier bindings: "))
1498 }
1499
1500 fn check_native(op: Option<StdOp>) -> Result<(), TemporalError> {
1501 if op == Some(StdOp::TlcTLCGet) {
1502 return Err(TemporalError::Unsupported(
1503 "TLCGet: checker introspection is not a function of a lasso".into(),
1504 ));
1505 }
1506 Ok(())
1507 }
1508
1509 fn check_atom_context(&self, expr: ExprId, scope: &Scope) -> Result<(), TemporalError> {
1510 self.check_scoped_context_mode(expr, scope, 0, &mut 0, false)
1511 }
1512
1513 fn check_scoped_context(
1514 &self,
1515 expr: ExprId,
1516 scope: &Scope,
1517 depth: usize,
1518 steps: &mut usize,
1519 ) -> Result<(), TemporalError> {
1520 self.check_scoped_context_mode(expr, scope, depth, steps, false)
1521 }
1522
1523 #[allow(
1524 clippy::too_many_lines,
1525 reason = "independent scoped walk; inspection mode never evaluates unused binder domains"
1526 )]
1527 fn check_scoped_context_mode(
1528 &self,
1529 expr: ExprId,
1530 scope: &Scope,
1531 depth: usize,
1532 steps: &mut usize,
1533 inspect_only: bool,
1534 ) -> Result<(), TemporalError> {
1535 let mut todo = vec![(expr, scope.clone(), depth)];
1537 while let Some((e, scope, depth)) = todo.pop() {
1538 *steps = steps.saturating_add(1);
1539 if depth > 256 || *steps > 100_000 {
1540 return Err(TemporalError::Unsupported(
1541 "scoped temporal purity resource bound".into(),
1542 ));
1543 }
1544 let ev = &self.model.evaluator;
1545 let ir = &self.model.ir;
1546 let meta = ir.nodes().get(e.index()).ok_or_else(|| {
1547 TemporalError::Unsupported("missing scoped periodic expression".into())
1548 })?;
1549 if meta.effects.intersects(Effects::IMPURE | Effects::TEMPORAL)
1550 || ev.scope_shares_side_effects(&scope)
1551 {
1552 return Err(TemporalError::Unsupported(
1553 "effectful/temporal operand in periodic predicate".into(),
1554 ));
1555 }
1556 match &meta.expr {
1557 Expr::StepBox { action, sub } | Expr::StepAngle { action, sub } => {
1558 todo.push((*action, scope.clone(), depth + 1));
1559 todo.push((*sub, scope.clone(), depth + 1));
1560 continue;
1561 }
1562 Expr::Enabled(action) => {
1563 todo.push((*action, scope.clone(), depth + 1));
1564 continue;
1565 }
1566 Expr::Not(body) | Expr::Selected(body) | Expr::Label { body, .. } => {
1567 todo.push((*body, scope.clone(), depth + 1));
1568 continue;
1569 }
1570 Expr::Junction { items, .. } => {
1571 todo.extend(items.iter().map(|item| (*item, scope.clone(), depth + 1)));
1572 continue;
1573 }
1574 Expr::Cdot(first, second) => {
1575 if ev.options().action_composition != dive_eval::ActionComposition::Tla {
1576 return Err(TemporalError::Unsupported(
1577 crate::COMPOSITION_UNSUPPORTED.to_owned(),
1578 ));
1579 }
1580 todo.push((*first, scope.clone(), depth + 1));
1581 todo.push((*second, scope.clone(), depth + 1));
1582 continue;
1583 }
1584 Expr::Let { body, .. } => {
1585 let sc = ev.scope_let(&scope, e).map_err(TemporalError::from)?;
1586 todo.push((*body, sc, depth + 1));
1587 continue;
1588 }
1589 Expr::Quant { body, .. }
1590 | Expr::SetMap { expr: body, .. }
1591 | Expr::SetFilter { pred: body, .. }
1592 | Expr::FcnCons { body, .. } => {
1593 if inspect_only {
1594 let sc = ev
1595 .scope_binder_analysis(&scope, e)
1596 .map_err(TemporalError::from)?;
1597 todo.extend(meta.expr.children().into_iter().map(|child| {
1598 (
1599 child,
1600 if child == *body {
1601 sc.clone()
1602 } else {
1603 scope.clone()
1604 },
1605 depth + 1,
1606 )
1607 }));
1608 } else {
1609 let (scopes, _) = self.predicate_scopes(e, &scope, depth + 1, steps)?;
1610 todo.extend(scopes.into_iter().map(|sc| (*body, sc, depth + 1)));
1611 }
1612 continue;
1613 }
1614 Expr::RecFcn { .. } if inspect_only => {
1615 return Err(TemporalError::Unsupported(
1616 "recursive function in configured temporal argument".into(),
1617 ));
1618 }
1619 Expr::RecFcn { body, .. } => {
1620 let (scopes, _) = self.predicate_scopes(e, &scope, depth + 1, steps)?;
1621 todo.extend(scopes.into_iter().map(|sc| (*body, sc, depth + 1)));
1622 continue;
1623 }
1624 Expr::Local(r) => match ev.scope_slot(&scope, *r) {
1625 SlotView::Function(_) if inspect_only => {
1626 return Err(TemporalError::Unsupported(
1627 "recursive function in configured temporal context".into(),
1628 ));
1629 }
1630 SlotView::Value(_) | SlotView::AnalysisBound | SlotView::AnalysisConstant => {}
1631 SlotView::Lazy(e, sc) => {
1632 todo.push((e, sc, depth + 1));
1633 continue;
1634 }
1635 _ => {
1636 return Err(TemporalError::Unsupported(
1637 "opaque scoped atom in temporal validation".into(),
1638 ));
1639 }
1640 },
1641 Expr::Subst { body, bindings } => {
1642 if inspect_only
1643 && bindings.iter().any(|binding| {
1644 matches!(
1645 binding.value,
1646 Arg::Expr {
1647 pass: dive_ir::Pass::Strict,
1648 ..
1649 }
1650 )
1651 })
1652 {
1653 return Err(TemporalError::Unsupported(
1654 "eager substitution in configured temporal argument".into(),
1655 ));
1656 }
1657 substitution_is_pure(self.model, &scope, bindings)?;
1658 let sc = ev.scope_subst(&scope, e).map_err(TemporalError::from)?;
1659 todo.push((*body, sc, depth + 1));
1660 continue;
1661 }
1662 Expr::SubstRef { decl, primed } => match ev
1663 .scope_substitution(&scope, *decl, &St::constant(), *primed)
1664 .map_err(TemporalError::from)?
1665 {
1666 Some(
1667 SlotView::Value(_) | SlotView::AnalysisBound | SlotView::AnalysisConstant,
1668 ) => {}
1669 Some(SlotView::Lazy(body, sc)) => {
1670 todo.push((body, sc, depth + 1));
1671 continue;
1672 }
1673 None => {
1674 if let Some(pred) = self.declaration_fallback(&scope, *decl)? {
1675 todo.push((pred.expr, pred.scope, depth + 1));
1676 }
1677 }
1678 _ => {
1679 return Err(TemporalError::Unsupported(
1680 "opaque substituted predicate atom".into(),
1681 ));
1682 }
1683 },
1684 Expr::Const(c) => {
1685 if let Some(pred) = self.constant_context(&scope, *c)? {
1686 todo.push((pred.expr, pred.scope, depth + 1));
1687 }
1688 }
1689 _ => {}
1690 }
1691 let call = match &meta.expr {
1692 Expr::Def(d) => Some((OpRef::Def(*d), &[][..])),
1693 Expr::Apply { callee, args } => Some((callee.clone(), args.as_ref())),
1694 _ => None,
1695 };
1696 if let Some((op, args)) = call {
1697 let standard = match op.clone() {
1698 OpRef::Std(s) => Some(s),
1699 OpRef::Def(d) => {
1700 let leaf = self.recursive_leaf(&scope, d);
1701 let d = self.checked_definition(d)?;
1702 let def = ir.def(d);
1703 if !ev.is_value_override(d) && def.std.is_none() {
1704 let sc = if inspect_only {
1705 if def.recursive
1706 || args.iter().any(|arg| matches!(arg, Arg::Op { .. }))
1707 {
1708 return Err(TemporalError::Unsupported(
1709 "recursive/higher-order configured argument".into(),
1710 ));
1711 }
1712 todo.extend(args.iter().filter_map(|arg| match arg {
1713 Arg::Expr { expr, .. } => {
1714 Some((*expr, scope.clone(), depth + 1))
1715 }
1716 Arg::Op { .. } => None,
1717 }));
1718 ev.scope_apply(&scope, d, args)
1719 .map_err(TemporalError::from)?
1720 } else if leaf {
1721 for arg in args {
1724 let Arg::Expr { expr, .. } = arg else {
1725 return Err(TemporalError::Unsupported(
1726 "operator argument in recursive call".into(),
1727 ));
1728 };
1729 todo.push((*expr, scope.clone(), depth + 1));
1730 }
1731 continue;
1732 } else {
1733 self.scoped_call(&scope, d, args, depth + 1, steps)?
1734 };
1735 todo.push((def.body, sc, depth + 1));
1736 continue;
1737 }
1738 if ev.is_value_override(d) {
1739 None
1740 } else {
1741 def.std
1742 }
1743 }
1744 OpRef::Param(local) => {
1745 if inspect_only {
1746 return Err(TemporalError::Unsupported(
1747 "operator parameter in configured temporal argument".into(),
1748 ));
1749 }
1750 if self
1751 .native_parameter(&scope, local, args, depth + 1, steps)?
1752 .is_some()
1753 {
1754 continue;
1755 }
1756 let (def, called) =
1757 self.parameter_call(&scope, local, args, depth + 1, steps)?;
1758 todo.push((ir.def(def).body, called, depth + 1));
1759 continue;
1760 }
1761 OpRef::Const(constant) => {
1762 let (def, called) =
1763 self.configured_call(e, &scope, constant, args, depth + 1, steps)?;
1764 todo.push((ir.def(def).body, called, depth + 1));
1765 continue;
1766 }
1767 OpRef::Subst(_) => {
1768 return Err(TemporalError::Unsupported(
1769 "dynamically bound temporal atom operator".into(),
1770 ));
1771 }
1772 _ => None,
1773 };
1774 Self::check_native(standard)?;
1775 if inspect_only && args.iter().any(|arg| matches!(arg, Arg::Op { .. })) {
1776 return Err(TemporalError::Unsupported(
1777 "higher-order configured temporal argument".into(),
1778 ));
1779 }
1780 if standard == Some(StdOp::SequencesSelectSeq) {
1781 let mut work = 100_000_usize.saturating_sub(*steps);
1782 let (sequence, bodies) = ev
1783 .scope_selectseq_call(&scope, &op, args, &mut work)
1784 .map_err(TemporalError::from)?
1785 .ok_or_else(|| {
1786 TemporalError::Unsupported("SelectSeq callback context/level".into())
1787 })?;
1788 *steps = 100_000 - work;
1789 for (body, captured) in bodies {
1790 if self.scoped_level(body, &captured, depth + 1, steps)? > Level::State {
1793 return Err(TemporalError::Unsupported(
1794 "SelectSeq callback context/level".into(),
1795 ));
1796 }
1797 todo.push((body, captured, depth + 1));
1798 }
1799 todo.push((sequence, scope.clone(), depth + 1));
1800 continue;
1801 }
1802 if args.iter().any(|a| matches!(a, Arg::Op { .. })) {
1803 return Err(TemporalError::Unsupported(
1804 "higher-order periodic predicate argument".into(),
1805 ));
1806 }
1807 }
1808 todo.extend(
1809 meta.expr
1810 .children()
1811 .into_iter()
1812 .map(|c| (c, scope.clone(), depth + 1)),
1813 );
1814 }
1815 Ok(())
1816 }
1817
1818 fn future(&self, mut values: Vec<bool>, always: bool) -> Vec<bool> {
1819 let cycle = if always {
1820 values[self.back_to..].iter().all(|b| *b)
1821 } else {
1822 values[self.back_to..].iter().any(|b| *b)
1823 };
1824 values[self.back_to..].fill(cycle);
1825 for i in (0..self.back_to).rev() {
1826 values[i] = if always {
1827 values[i] && values[i + 1]
1828 } else {
1829 values[i] || values[i + 1]
1830 };
1831 }
1832 values
1833 }
1834}