Documentation

PolyFun.Interaction.Concurrent.Run

Finite prefixes and infinite runs of dynamic concurrent processes #

This file extends finite executions in the two directions needed for semantic reasoning about ongoing concurrent behavior.

The closed-world Process API is recovered as a specialization of these generic definitions.

@[reducible, inline]
abbrev Interaction.Concurrent.ProcessOver.Prefix {Γ : TypeTree.Node.Context} {P : Type v} (process : ProcessOver P Γ) :
process.Proc → ℕ → Type (max v w)

Prefix process p n is a finite prefix of length n of an execution starting from the residual process state p: the dynamical-system Prefix at the step polynomial, where each step records one complete sequential path of the current process step.

Unlike ProcessOver.Trace, a Prefix may stop at any residual state. This makes it the correct finite prefix object for later infinite-run semantics.

Equations
Instances For
    def Interaction.Concurrent.ProcessOver.Prefix.currentControllers {Γ : TypeTree.Node.Context} {Party : Type u} {P : Type v} {process : ProcessOver P Γ} (resolve : TypeTree.Node.ContextHom Γ (StepContext Party)) {p : process.Proc} {n : ℕ} :
    process.Prefix p n → List (Option Party)

    The sequence of current controlling parties exposed by a finite prefix after projecting the generic context into StepContext.

    Equations
    Instances For
      def Interaction.Concurrent.ProcessOver.Prefix.controllerPaths {Γ : TypeTree.Node.Context} {Party : Type u} {P : Type v} {process : ProcessOver P Γ} (resolve : TypeTree.Node.ContextHom Γ (StepContext Party)) {p : process.Proc} {n : ℕ} :
      process.Prefix p n → List (List Party)

      The sequence of full controller paths exposed by a finite prefix after projecting the generic context into StepContext.

      Equations
      Instances For
        @[reducible, inline]
        abbrev Interaction.Concurrent.ProcessOver.Prefix.events {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} {Event : Type w₃} (eventMap : process.EventMap Event) {p : process.Proc} {n : ℕ} :
        process.Prefix p n → List Event

        The stable event labels attached to the executed steps of a finite prefix.

        Equations
        Instances For
          @[reducible, inline]
          abbrev Interaction.Concurrent.ProcessOver.Prefix.tickets {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} {Ticket : Type w₃} (ticketMap : process.TicketMap Ticket) {p : process.Proc} {n : ℕ} :
          process.Prefix p n → List Ticket

          The stable tickets attached to the executed steps of a finite prefix.

          Equations
          Instances For
            def Interaction.Concurrent.ProcessOver.Prefix.ofTrace {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} {p : process.Proc} (trace : process.Trace p) :
            process.Prefix p trace.length

            Forget the quiescence proof of a finite Trace and keep only its executed prefix.

            Equations
            Instances For
              @[simp]
              theorem Interaction.Concurrent.ProcessOver.Prefix.events_nil {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} {Event : Type w₃} (eventMap : process.EventMap Event) {p : process.Proc} :
              @[simp]
              theorem Interaction.Concurrent.ProcessOver.Prefix.tickets_nil {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} {Ticket : Type w₃} (ticketMap : process.TicketMap Ticket) {p : process.Proc} :
              @[reducible, inline]
              abbrev Interaction.Concurrent.ProcessOver.Run {Γ : TypeTree.Node.Context} {P : Type v} (process : ProcessOver P Γ) :
              Type (max v w)

              Run process is an infinite execution of the dynamic process process: the dynamical-system Run at the step polynomial.

              It is represented by:

              • state n, the residual process state after n complete process steps;
              • path n (the generic dir field), the concrete path chosen for step n;
              • next_state, which states that the residual state stream follows the process continuation exactly.

              This is a continuation-based infinite semantics: the run does not introduce a new operational state space of its own. It simply records how the residual process state evolves when one complete process step is chosen at each time.

              Equations
              Instances For
                @[reducible, inline]
                abbrev Interaction.Concurrent.ProcessOver.Run.path {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} (run : process.Run) (n : ℕ) :
                (process.step (run.state n)).tree.Path

                The concrete path chosen for step n: the run's generic direction choice, read at the step-polynomial interface.

                Equations
                Instances For
                  @[reducible, inline]
                  abbrev Interaction.Concurrent.ProcessOver.Run.initial {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} (run : process.Run) :
                  process.Proc

                  The initial residual process state of a run.

                  Equations
                  Instances For
                    @[reducible, inline]
                    abbrev Interaction.Concurrent.ProcessOver.Run.head {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} (run : process.Run) :
                    (process.step run.initial).tree.Path

                    The first complete process-step path of the run.

                    Equations
                    Instances For
                      @[reducible, inline]
                      abbrev Interaction.Concurrent.ProcessOver.Run.tail {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} (run : process.Run) :
                      process.Run

                      The tail of a run after its first process step.

                      Equations
                      Instances For
                        theorem Interaction.Concurrent.ProcessOver.Run.tail_initial {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} (run : process.Run) :
                        run.tail.initial = (process.step run.initial).next run.head

                        The initial state of run.tail is exactly the residual state obtained by executing run.head.

                        @[reducible, inline]
                        abbrev Interaction.Concurrent.ProcessOver.Run.take {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} (run : process.Run) (n : ℕ) :
                        process.Prefix run.initial n

                        take run n is the length-n finite execution prefix of the infinite run run.

                        Equations
                        Instances For
                          def Interaction.Concurrent.ProcessOver.Run.currentController? {Γ : TypeTree.Node.Context} {Party : Type u} {P : Type v} {process : ProcessOver P Γ} (resolve : TypeTree.Node.ContextHom Γ (StepContext Party)) (run : process.Run) (n : ℕ) :
                          Option Party

                          The current controlling party of step n of a run, if any, after projecting the generic context into StepContext.

                          Equations
                          Instances For
                            def Interaction.Concurrent.ProcessOver.Run.currentControllersUpTo {Γ : TypeTree.Node.Context} {Party : Type u} {P : Type v} {process : ProcessOver P Γ} (resolve : TypeTree.Node.ContextHom Γ (StepContext Party)) (run : process.Run) :
                            ℕ → List (Option Party)

                            The current controlling parties exposed along the first n executed steps of the run run.

                            Equations
                            Instances For
                              def Interaction.Concurrent.ProcessOver.Run.controllerPath {Γ : TypeTree.Node.Context} {Party : Type u} {P : Type v} {process : ProcessOver P Γ} (resolve : TypeTree.Node.ContextHom Γ (StepContext Party)) (run : process.Run) (n : ℕ) :
                              List Party

                              The full controller path recorded by step n of a run after projecting the generic context into StepContext.

                              Equations
                              Instances For
                                def Interaction.Concurrent.ProcessOver.Run.controllerPathsUpTo {Γ : TypeTree.Node.Context} {Party : Type u} {P : Type v} {process : ProcessOver P Γ} (resolve : TypeTree.Node.ContextHom Γ (StepContext Party)) (run : process.Run) :
                                ℕ → List (List Party)

                                The full controller paths exposed along the first n executed steps of the run run.

                                Equations
                                Instances For
                                  @[reducible, inline]
                                  abbrev Interaction.Concurrent.ProcessOver.Run.event {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} {Event : Type w₃} (eventMap : process.EventMap Event) (run : process.Run) (n : ℕ) :
                                  Event

                                  The stable event label attached to step n of a run.

                                  Equations
                                  Instances For
                                    @[reducible, inline]
                                    abbrev Interaction.Concurrent.ProcessOver.Run.eventsUpTo {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} {Event : Type w₃} (eventMap : process.EventMap Event) (run : process.Run) :
                                    ℕ → List Event

                                    The stable event labels attached to the first n executed steps of the run run.

                                    Equations
                                    Instances For
                                      @[reducible, inline]
                                      abbrev Interaction.Concurrent.ProcessOver.Run.ticket {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} {Ticket : Type w₃} (ticketMap : process.TicketMap Ticket) (run : process.Run) (n : ℕ) :
                                      Ticket

                                      The stable ticket attached to step n of a run.

                                      Equations
                                      Instances For
                                        @[reducible, inline]
                                        abbrev Interaction.Concurrent.ProcessOver.Run.ticketsUpTo {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} {Ticket : Type w₃} (ticketMap : process.TicketMap Ticket) (run : process.Run) :
                                        ℕ → List Ticket

                                        The stable tickets attached to the first n executed steps of the run run.

                                        Equations
                                        Instances For
                                          @[reducible, inline]
                                          abbrev Interaction.Concurrent.ProcessOver.Run.RelUpTo {Γ : TypeTree.Node.Context} {Δ : TypeTree.Node.Context} {P₁ : Type v} {left : ProcessOver P₁ Γ} {P₂ : Type v} {right : ProcessOver P₂ Δ} (rel : left.StepRel right) (leftRun : left.Run) (rightRun : right.Run) :
                                          ℕ → Prop

                                          RelUpTo rel left right n states that the first n executed steps of the runs left and right match step-by-step according to rel.

                                          Equations
                                          Instances For
                                            @[reducible, inline]
                                            abbrev Interaction.Concurrent.ProcessOver.Run.Rel {Γ : TypeTree.Node.Context} {Δ : TypeTree.Node.Context} {P₁ : Type v} {left : ProcessOver P₁ Γ} {P₂ : Type v} {right : ProcessOver P₂ Δ} (rel : left.StepRel right) (leftRun : left.Run) (rightRun : right.Run) :

                                            Rel rel left right states that every finite prefix of the runs left and right matches according to rel.

                                            Equations
                                            Instances For
                                              theorem Interaction.Concurrent.ProcessOver.Run.relUpTo_of_pointwise {Γ : TypeTree.Node.Context} {Δ : TypeTree.Node.Context} {P₁ : Type v} {left : ProcessOver P₁ Γ} {P₂ : Type v} {right : ProcessOver P₂ Δ} (rel : left.StepRel right) (leftRun : left.Run) (rightRun : right.Run) (hrel : ∀ (n : ℕ), rel ⟨leftRun.state n, leftRun.path n⟩ ⟨rightRun.state n, rightRun.path n⟩) (n : ℕ) :
                                              RelUpTo rel leftRun rightRun n

                                              Pointwise step matching implies prefix matching of the first n steps.

                                              theorem Interaction.Concurrent.ProcessOver.Run.rel_of_pointwise {Γ : TypeTree.Node.Context} {Δ : TypeTree.Node.Context} {P₁ : Type v} {left : ProcessOver P₁ Γ} {P₂ : Type v} {right : ProcessOver P₂ Δ} (rel : left.StepRel right) (leftRun : left.Run) (rightRun : right.Run) (hrel : ∀ (n : ℕ), rel ⟨leftRun.state n, leftRun.path n⟩ ⟨rightRun.state n, rightRun.path n⟩) :
                                              Rel rel leftRun rightRun

                                              Pointwise step matching implies full run matching.

                                              @[simp]
                                              theorem Interaction.Concurrent.ProcessOver.Run.take_succ {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} (run : process.Run) (n : ℕ) :
                                              @[simp]
                                              theorem Interaction.Concurrent.ProcessOver.Run.currentControllersUpTo_zero {Γ : TypeTree.Node.Context} {Party : Type u} {P : Type v} {process : ProcessOver P Γ} (resolve : TypeTree.Node.ContextHom Γ (StepContext Party)) (run : process.Run) :
                                              @[simp]
                                              theorem Interaction.Concurrent.ProcessOver.Run.controllerPathsUpTo_zero {Γ : TypeTree.Node.Context} {Party : Type u} {P : Type v} {process : ProcessOver P Γ} (resolve : TypeTree.Node.ContextHom Γ (StepContext Party)) (run : process.Run) :
                                              controllerPathsUpTo resolve run 0 = []
                                              @[simp]
                                              theorem Interaction.Concurrent.ProcessOver.Run.eventsUpTo_zero {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} {Event : Type w₃} (eventMap : process.EventMap Event) (run : process.Run) :
                                              eventsUpTo eventMap run 0 = []
                                              @[simp]
                                              theorem Interaction.Concurrent.ProcessOver.Run.ticketsUpTo_zero {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} {Ticket : Type w₃} (ticketMap : process.TicketMap Ticket) (run : process.Run) :
                                              ticketsUpTo ticketMap run 0 = []
                                              @[simp]
                                              theorem Interaction.Concurrent.ProcessOver.Run.currentControllersUpTo_succ {Γ : TypeTree.Node.Context} {Party : Type u} {P : Type v} {process : ProcessOver P Γ} (resolve : TypeTree.Node.ContextHom Γ (StepContext Party)) (run : process.Run) (n : ℕ) :
                                              currentControllersUpTo resolve run (n + 1) = currentController? resolve run 0 :: currentControllersUpTo resolve run.tail n
                                              @[simp]
                                              theorem Interaction.Concurrent.ProcessOver.Run.controllerPathsUpTo_succ {Γ : TypeTree.Node.Context} {Party : Type u} {P : Type v} {process : ProcessOver P Γ} (resolve : TypeTree.Node.ContextHom Γ (StepContext Party)) (run : process.Run) (n : ℕ) :
                                              controllerPathsUpTo resolve run (n + 1) = controllerPath resolve run 0 :: controllerPathsUpTo resolve run.tail n
                                              @[simp]
                                              theorem Interaction.Concurrent.ProcessOver.Run.eventsUpTo_succ {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} {Event : Type w₃} (eventMap : process.EventMap Event) (run : process.Run) (n : ℕ) :
                                              eventsUpTo eventMap run (n + 1) = event eventMap run 0 :: eventsUpTo eventMap run.tail n
                                              @[simp]
                                              theorem Interaction.Concurrent.ProcessOver.Run.ticketsUpTo_succ {Γ : TypeTree.Node.Context} {P : Type v} {process : ProcessOver P Γ} {Ticket : Type w₃} (ticketMap : process.TicketMap Ticket) (run : process.Run) (n : ℕ) :
                                              ticketsUpTo ticketMap run (n + 1) = ticket ticketMap run 0 :: ticketsUpTo ticketMap run.tail n
                                              @[reducible, inline]
                                              abbrev Interaction.Concurrent.Process.Prefix {Party : Type u} {P : Type v} (process : Process P Party) :
                                              ProcessOver.Proc process → ℕ → Type (max v u_1)

                                              The closed-world specialization of ProcessOver.Prefix.

                                              Equations
                                              Instances For
                                                def Interaction.Concurrent.Process.Prefix.currentControllers {Party : Type u} {P : Type v} {process : Process P Party} {p : ProcessOver.Proc process} {n : ℕ} :
                                                process.Prefix p n → List (Option Party)

                                                The sequence of current controlling parties exposed by a finite closed-world prefix.

                                                Equations
                                                Instances For
                                                  def Interaction.Concurrent.Process.Prefix.controllerPaths {Party : Type u} {P : Type v} {process : Process P Party} {p : ProcessOver.Proc process} {n : ℕ} :
                                                  process.Prefix p n → List (List Party)

                                                  The sequence of full controller paths exposed by a finite closed-world prefix.

                                                  Equations
                                                  Instances For
                                                    @[reducible, inline]
                                                    abbrev Interaction.Concurrent.Process.Prefix.events {Party : Type u} {P : Type v} {process : Process P Party} {Event : Type w₃} (eventMap : process.EventMap Event) {p : ProcessOver.Proc process} {n : ℕ} :
                                                    process.Prefix p n → List Event

                                                    The stable event labels attached to the executed steps of a finite closed-world prefix.

                                                    Equations
                                                    Instances For
                                                      @[reducible, inline]
                                                      abbrev Interaction.Concurrent.Process.Prefix.tickets {Party : Type u} {P : Type v} {process : Process P Party} {Ticket : Type w₃} (ticketMap : process.TicketMap Ticket) {p : ProcessOver.Proc process} {n : ℕ} :
                                                      process.Prefix p n → List Ticket

                                                      The stable tickets attached to the executed steps of a finite closed-world prefix.

                                                      Equations
                                                      Instances For
                                                        @[reducible, inline]
                                                        abbrev Interaction.Concurrent.Process.Prefix.ofTrace {Party : Type u} {P : Type v} {process : Process P Party} {p : ProcessOver.Proc process} (trace : process.Trace p) :
                                                        process.Prefix p trace.length

                                                        Forget the quiescence proof of a finite closed-world trace and keep only its executed prefix.

                                                        Equations
                                                        Instances For
                                                          @[simp]
                                                          theorem Interaction.Concurrent.Process.Prefix.events_nil {Party : Type u} {P : Type v} {process : Process P Party} {Event : Type w₃} (eventMap : process.EventMap Event) {p : ProcessOver.Proc process} :
                                                          @[simp]
                                                          theorem Interaction.Concurrent.Process.Prefix.tickets_nil {Party : Type u} {P : Type v} {process : Process P Party} {Ticket : Type w₃} (ticketMap : process.TicketMap Ticket) {p : ProcessOver.Proc process} :
                                                          @[reducible, inline]
                                                          abbrev Interaction.Concurrent.Process.Run {Party : Type u} {P : Type v} (process : Process P Party) :
                                                          Type (max v u_1)

                                                          The closed-world specialization of ProcessOver.Run.

                                                          Equations
                                                          Instances For
                                                            @[reducible, inline]
                                                            abbrev Interaction.Concurrent.Process.Run.initial {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) :

                                                            The initial residual process state of a closed-world run.

                                                            Equations
                                                            Instances For
                                                              @[reducible, inline]
                                                              abbrev Interaction.Concurrent.Process.Run.head {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) :

                                                              The first complete process-step path of a closed-world run.

                                                              Equations
                                                              Instances For
                                                                @[reducible, inline]
                                                                abbrev Interaction.Concurrent.Process.Run.tail {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) :
                                                                process.Run

                                                                The tail of a closed-world run after its first process step.

                                                                Equations
                                                                Instances For
                                                                  theorem Interaction.Concurrent.Process.Run.tail_initial {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) :
                                                                  @[reducible, inline]
                                                                  abbrev Interaction.Concurrent.Process.Run.take {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) (n : ℕ) :
                                                                  process.Prefix run.initial n

                                                                  The length-n finite prefix of a closed-world run.

                                                                  Equations
                                                                  Instances For
                                                                    def Interaction.Concurrent.Process.Run.currentController? {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) (n : ℕ) :
                                                                    Option Party

                                                                    The current controlling party of step n of a closed-world run, if any.

                                                                    Equations
                                                                    Instances For
                                                                      def Interaction.Concurrent.Process.Run.currentControllersUpTo {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) :
                                                                      ℕ → List (Option Party)

                                                                      The current controlling parties exposed along the first n executed steps of a closed-world run.

                                                                      Equations
                                                                      Instances For
                                                                        def Interaction.Concurrent.Process.Run.controllerPath {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) (n : ℕ) :
                                                                        List Party

                                                                        The full controller path recorded by step n of a closed-world run.

                                                                        Equations
                                                                        Instances For
                                                                          def Interaction.Concurrent.Process.Run.controllerPathsUpTo {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) :
                                                                          ℕ → List (List Party)

                                                                          The full controller paths exposed along the first n executed steps of a closed-world run.

                                                                          Equations
                                                                          Instances For
                                                                            @[reducible, inline]
                                                                            abbrev Interaction.Concurrent.Process.Run.event {Party : Type u} {P : Type v} {process : Process P Party} {Event : Type w₃} (eventMap : process.EventMap Event) (run : process.Run) (n : ℕ) :
                                                                            Event

                                                                            The stable event label attached to step n of a closed-world run.

                                                                            Equations
                                                                            Instances For
                                                                              @[reducible, inline]
                                                                              abbrev Interaction.Concurrent.Process.Run.eventsUpTo {Party : Type u} {P : Type v} {process : Process P Party} {Event : Type w₃} (eventMap : process.EventMap Event) (run : process.Run) :
                                                                              ℕ → List Event

                                                                              The stable event labels attached to the first n executed steps of a closed-world run.

                                                                              Equations
                                                                              Instances For
                                                                                @[reducible, inline]
                                                                                abbrev Interaction.Concurrent.Process.Run.ticket {Party : Type u} {P : Type v} {process : Process P Party} {Ticket : Type w₃} (ticketMap : process.TicketMap Ticket) (run : process.Run) (n : ℕ) :
                                                                                Ticket

                                                                                The stable ticket attached to step n of a closed-world run.

                                                                                Equations
                                                                                Instances For
                                                                                  @[reducible, inline]
                                                                                  abbrev Interaction.Concurrent.Process.Run.ticketsUpTo {Party : Type u} {P : Type v} {process : Process P Party} {Ticket : Type w₃} (ticketMap : process.TicketMap Ticket) (run : process.Run) :
                                                                                  ℕ → List Ticket

                                                                                  The stable tickets attached to the first n executed steps of a closed-world run.

                                                                                  Equations
                                                                                  Instances For
                                                                                    @[simp]
                                                                                    theorem Interaction.Concurrent.Process.Run.take_zero {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) :
                                                                                    @[simp]
                                                                                    theorem Interaction.Concurrent.Process.Run.take_succ {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) (n : ℕ) :
                                                                                    @[simp]
                                                                                    theorem Interaction.Concurrent.Process.Run.currentControllersUpTo_zero {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) :
                                                                                    @[simp]
                                                                                    theorem Interaction.Concurrent.Process.Run.controllerPathsUpTo_zero {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) :
                                                                                    @[simp]
                                                                                    theorem Interaction.Concurrent.Process.Run.eventsUpTo_zero {Party : Type u} {P : Type v} {process : Process P Party} {Event : Type w₃} (eventMap : process.EventMap Event) (run : process.Run) :
                                                                                    eventsUpTo eventMap run 0 = []
                                                                                    @[simp]
                                                                                    theorem Interaction.Concurrent.Process.Run.ticketsUpTo_zero {Party : Type u} {P : Type v} {process : Process P Party} {Ticket : Type w₃} (ticketMap : process.TicketMap Ticket) (run : process.Run) :
                                                                                    ticketsUpTo ticketMap run 0 = []
                                                                                    @[simp]
                                                                                    theorem Interaction.Concurrent.Process.Run.currentControllersUpTo_succ {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) (n : ℕ) :
                                                                                    @[simp]
                                                                                    theorem Interaction.Concurrent.Process.Run.controllerPathsUpTo_succ {Party : Type u} {P : Type v} {process : Process P Party} (run : process.Run) (n : ℕ) :
                                                                                    @[simp]
                                                                                    theorem Interaction.Concurrent.Process.Run.eventsUpTo_succ {Party : Type u} {P : Type v} {process : Process P Party} {Event : Type w₃} (eventMap : process.EventMap Event) (run : process.Run) (n : ℕ) :
                                                                                    eventsUpTo eventMap run (n + 1) = event eventMap run 0 :: eventsUpTo eventMap run.tail n
                                                                                    @[simp]
                                                                                    theorem Interaction.Concurrent.Process.Run.ticketsUpTo_succ {Party : Type u} {P : Type v} {process : Process P Party} {Ticket : Type w₃} (ticketMap : process.TicketMap Ticket) (run : process.Run) (n : ℕ) :
                                                                                    ticketsUpTo ticketMap run (n + 1) = ticket ticketMap run 0 :: ticketsUpTo ticketMap run.tail n