Skip to main content

dive_trace/
temporal.rs

1//! Direct temporal semantics on an ultimately periodic word.
2//!
3//! This module has no tableau, graph search, or successor enumerator. Each
4//! subformula yields a truth value at every position of the given word.
5
6use 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/// Why temporal evaluation cannot establish a truth value.
18#[derive(Clone, Debug, PartialEq, Eq)]
19#[non_exhaustive]
20pub enum TemporalError {
21    /// A typed cooperative interruption, never a temporal truth value/refusal.
22    Interrupted(dive_eval::EvalError),
23    /// The word or a predicate is malformed.
24    Invalid(String),
25    /// A named feature cannot be decided independently yet.
26    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
57/// Evaluates `formula` at every position of an ultimately periodic word.
58/// The last position is followed by `back_to`; setting it to the last
59/// position describes infinite stuttering. This evaluates the formula only:
60/// callers must separately check initial states, transitions and constraints.
61///
62/// ```
63/// use std::sync::Arc;
64/// use dive_trace::temporal::evaluate_lasso;
65/// use dive_model::Pred;
66/// use dive_value::Value;
67/// let src = "---- MODULE M ----\nVARIABLE x\nInit == x = TRUE\n\
68///            Next == x' = ~x\nP == []<>x\n====\n";
69/// let analysis = dive_sema::analyze_source("M.tla", src, &Default::default());
70/// let ir = Arc::new(dive_ir::lower(&analysis)?);
71/// let cfg = dive_config::parse("INIT Init\nNEXT Next\n").into_config().unwrap();
72/// let model = dive_model::bind(ir, &cfg, &dive_model::BindOptions::tlc())?;
73/// let p = model.ir.root_def("P").unwrap();
74/// let pred = Pred::new(model.ir.def(p).body, model.evaluator.scope(p).expect("valid scope"));
75/// let states = vec![Arc::from([Some(Value::Bool(true))]),
76///                   Arc::from([Some(Value::Bool(false))])];
77/// assert_eq!(evaluate_lasso(&model, &pred, &states, 0)?, vec![true, true]);
78/// # Ok::<(), Box<dyn std::error::Error>>(())
79/// ```
80///
81/// # Errors
82/// Invalid words or nonboolean atoms; side effects, unbounded/dynamic
83/// temporal quantification, opaque scoped atoms, checker introspection,
84/// resource bounds, or an `ENABLED` the dive-eval evaluator cannot decide. A
85/// string or model value created after binding under encounter order
86/// refuses ([`crate::RUNTIME_NAMES_UNSUPPORTED`]), whatever the truth.
87pub 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
144/// Preflight for finite predicates used to certify a periodic behavior.
145/// Refuse search-dependent or opaque reads before evaluating anything.
146pub(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
174/// An `ENABLED` refusal as a temporal refusal. Action composition keeps its
175/// feature name, so `ENABLED A` and `[][A]_x` refuse the same composition
176/// alike ([`crate::COMPOSITION_UNSUPPORTED`]).
177fn 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
191/// Entering `INSTANCE ... WITH` evaluates its strict bindings eagerly:
192/// refuse a binding from another model's context or with side effects
193/// before entering. Names it creates are refused after evaluation
194/// ([`crate::RUNTIME_NAMES_UNSUPPORTED`]).
195fn 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            // A state-level recursive leaf is an atom below, as in TLC.
291            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        // Keep established state-level temporal lowering (including direct
320        // queries through INSTANCE scopes). Only action-level Boolean bodies
321        // need one atom to preserve reached nested-query error ordering.
322        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    // GF <<A>>_v implies both WF_v(A) and SF_v(A). This sufficient
435    // condition needs no ENABLED search or witness. Checking only the finite
436    // prefix would be unsound: the occurrence must be on the repeated cycle.
437    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            // WF = GF(~enabled) OR GF(occurs); SF = FG(~enabled) OR GF(occurs).
459            // On this repeated finite cycle GF and FG reduce to any and all.
460            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    // Independent LNAction semantics: a subscript stutter determines the
470    // value before the body is evaluated, including the actual closing edge.
471    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    // The original declaration is reachable only when substitution lookup is
556    // absent, never for an explicitly unset or opaque binding.
557    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    /// Whether a call of `def` in `scope` is a state-level recursive leaf
602    /// ([`dive_eval::Evaluator::recursive_leaf`]) outside any INSTANCE
603    /// substitution: TLC leaves such a call to evaluation
604    /// (`Liveness.astToLive`), so only its actuals carry the caller's context.
605    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    // Resolve the original direct declaration independently of the planner.
625    // Return only its lazy call scope; no analysis result is execution authority.
626    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        // Independently inspect the configured target before any domain evaluation;
687        // ordinary recursive-source analysis must not erase this call origin.
688        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    // Independently prove the original scoped native call, never a planner
821    // annotation or an invented native user body.
822    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    // Independently retain queries only in a first-order temporal expression
900    // actual. Captures/native/provider paths keep query-free inspection, and
901    // actual query or data leaves still pass their original independent guards.
902    // Admission proof for a temporal expression argument. Keep its lexical
903    // scope; do not force it as a constant or trust a formal's static level.
904    // This walk does not interpret temporal truth or materialize binders.
905    #[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    // Check actual argument contexts independently of planner annotations.
1111    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        // Routing only: the query operand is an inner successor namespace.
1145        // Existing level callers keep their original conservative traversal.
1146        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                    // Its body reaches no substitution, so its own level is
1277                    // static; the actuals carry the caller's context.
1278                    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    // Analysis binds pure unknowns; evaluation always uses the original scope.
1397    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        // ExprId alone is not a context: inspect each distinct application.
1536        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                                // A state-level recursive operator is an
1722                                // evaluation leaf; only its actuals are checked.
1723                                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                        // Each original captured body is checked for its actual
1791                        // level and queued for the ordinary pure-source walk.
1792                        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}