AFTD Auto-Formalizing Theoretical Domains

prioritized_borel_fork_exit_consistent

theoremverified

An excursion block is consistent when its last direction is the function's choice after the first two edges.

Statement

theorem prioritized_borel_fork_exit_consistent (choice : List PrioritizedBorelForkEdge → Bool)
    (pre : List PrioritizedBorelForkEdge) :
    prioritized_borel_fork_consistent choice pre
      (prioritized_borel_fork_three_step_block (choice (pre ++ prioritized_borel_fork_setup)) true)
Source
arXiv:2611.10136, Section 5.3.2; the three-state fork subarena
Verified
12 Nov 2026
Axioms
propext
Built on 4
Used by 1

The proof, explained

The theorem states that a three-step exit block is consistent with the decision function `choice` after an initial prefix `pre`. The first two edges of the exit block originate at states 0 and 1, so the consistency condition for state 2 is vacuously satisfied. For the third edge, which originates at state 2, the accumulated history equals `pre ++ prioritized_borel_fork_setup`, exactly matching the edge's direction choice.

  1. The three-step exit block is consistent with the decision function `choice` starting from prefix `pre`.

    Unfolding `prioritized_borel_fork_three_step_block` with `exit = true` yields a sequence of three edges: `⟨0, false, 1, 0⟩`, `⟨1, false, 2, 0⟩`, and `⟨2, b, 0, if b then 1 else 2⟩`, where `b = choice (pre ++ prioritized_borel_fork_setup)`. By definition, `prioritized_borel_fork_consistent` requires that whenever an edge has source state 2, its direction must equal the value of `choice` on the prefix accumulated prior to that edge. The first two edges originate at states 0 and 1, so the condition holds vacuously for both. After these two edges, the accumulated prefix is `(pre ++ [⟨0, false, 1, 0⟩]) ++ [⟨1, false, 2, 0⟩]`, which by list associativity (`List.append_assoc`) equals `pre ++ prioritized_borel_fork_setup`. The third edge originates at state 2 and its direction is precisely `b`, which matches the required value `choice (pre ++ prioritized_borel_fork_setup)`. The remaining list is empty and thus trivially consistent, so `simp` simplifies the entire conjunction to `True`.

    line 5

    uses List.append_assoc

      simp [prioritized_borel_fork_three_step_block, prioritized_borel_fork_consistent, prioritized_borel_fork_setup, List.append_assoc]
List.append_assoc
List concatenation is associative: `(as ++ bs) ++ cs = as ++ (bs ++ cs)`.

Written by a model (gemini-3.8-flash) from the Lean proof and the goal states Lean reported at each step. Lean verified the proof; this explanation is a reading aid and is not itself machine-checked.

Lean source view module on GitHub

theorem prioritized_borel_fork_exit_consistent (choice : List PrioritizedBorelForkEdge → Bool)    (pre : List PrioritizedBorelForkEdge) :    prioritized_borel_fork_consistent choice pre      (prioritized_borel_fork_three_step_block (choice (pre ++ prioritized_borel_fork_setup)) true) := by  simp [prioritized_borel_fork_three_step_block, prioritized_borel_fork_consistent, prioritized_borel_fork_setup, List.append_assoc]
See it in the graphDiscuss this resultChallenge it