Documentation

PetriNet.ReversibleOccurrence

Standard variable for types/general structures #

TransitionType indicates the direction of a transition in a reversible net, which can be forward or backward in a net.

Instances For
    @[simp]
    @[reducible, inline]
    Equations
    Instances For
      Equations
      Instances For
        Equations
        Instances For
          theorem ReversibleNet.ne_of_fwd_bwd {β : Type} {t t' : Transition β} :
          ▷t → ◁t' → t ≠ t'
          Equations
          Instances For

            all_forward states that all elements in the list are forward.

            Equations
            Instances For

              all_backward states that all elements in the list are backward.

              Equations
              Instances For
                theorem ReversibleNet.all_bwd_of_append {β : Type} {s₁ s₂ : List (Transition β)} :
                ◁◁s₁ ++ s₂ ↔ ◁◁s₁ ∧ ◁◁s₂
                theorem ReversibleNet.all_fwd_of_append {β : Type} {s₁ s₂ : List (Transition β)} :
                ▷▷s₁ ++ s₂ ↔ ▷▷s₁ ∧ ▷▷s₂
                theorem ReversibleNet.rev_congr {β : Type} {t t' : Transition β} :
                t = t' → ↽t = ↽t'
                @[simp]
                def ReversibleNet.inverse {β : Type} (t t' : Transition β) :
                Equations
                Instances For
                  theorem ReversibleNet.eq_of_reverse {β : Type} {t t' : Transition β} :
                  t = t' ↔ ↽t = ↽t'
                  theorem ReversibleNet.ne_fwd_iff_ne_reverse {β : Type} {t t' : Transition β} :
                  ▷t → ▷t' → (t ≠ t' ↔ ↽t ≠ ↽t')
                  @[simp]
                  theorem ReversibleNet.inverse_symm {β : Type} {t t' : Transition β} :
                  t ↽⇀ t' ↔ t' ↽⇀ t
                  @[simp]
                  theorem ReversibleNet.inverse_unique {β : Type} {t t' t'' : Transition β} :
                  t ↽⇀ t' → t ↽⇀ t'' → t' = t''

                  Reversible #

                  For each t, t' ∈ Transition β then •t = t'• if t and t' are reversing.

                  Instances For
                    theorem ReversibleNet.Reversible.ext_iff {α β : Type} {x y : Reversible α β} :
                    x = y ↔ (↑x).pre = (↑y).pre ∧ (↑x).post = (↑y).post
                    theorem ReversibleNet.Reversible.ext {α β : Type} {x y : Reversible α β} (pre : (↑x).pre = (↑y).pre) (post : (↑x).post = (↑y).post) :
                    x = y
                    @[implicit_reducible]
                    Equations
                    @[simp]
                    theorem ReversibleNet.eq_pre_post_of_inverse {α β : Type} {t t' : Transition β} (R : Reversible α β) (i : t ↽⇀ t') :
                    def ReversibleNet.fwd_subnet {α β : Type} (N : Nets.Net α (Transition β)) :
                    Nets.Net α β
                    Equations
                    Instances For
                      theorem ReversibleNet.mem_pre_of_mem_pre {α β : Type} {a : α} {t : Transition β} {R : Reversible α β} (ft : ▷t) (h : a ∈ •⦃R⦄t) :
                      theorem ReversibleNet.mem_post_of_mem_post {α β : Type} {a : α} {t : Transition β} {R : Reversible α β} (ft : ▷t) (h : a ∈ t•⦃R⦄) :
                      @[simp]
                      theorem ReversibleNet.mem_pre_fwd_iff_mem_post_bwd {α β : Type} {a : α} {t t' : Transition β} {R : Reversible α β} (i : t ↽⇀ t') :
                      @[simp]
                      theorem ReversibleNet.in_post_bwd_iff_in_pre_fwd {α β : Type} {a : α} {t t' : Transition β} {R : Reversible α β} (i : t ↽⇀ t') :
                      @[simp]
                      theorem ReversibleNet.firing_rev_iff_firing_fwd_subnet {α β : Type} {R : Reversible α β} [DecidableEq α] {m m' : Multiset α} {t : Transition β} {et : m 〚(t.1, TransitionType.fwd)〛⦃R⦄} {et' : Nets.is_enabled (fwd_subnet ↑R) m t.1} :
                      Nets.is_firing (fwd_subnet ↑R) m et m' ↔ m 〚et'⟩⦃R⦄ m'
                      theorem ReversibleNet.inverse_enabled_after_firing {α β : Type} {t : Transition β} {R : Reversible α β} [DecidableEq α] {m m' : Multiset α} (e : m 〚t〛⦃R⦄) (f : m 〚e⟩⦃R⦄ m') :
                      ∃ (t' : Transition β), t' ↽⇀ t ∧ m' 〚t'〛⦃R⦄
                      theorem ReversibleNet.cancelation {α β : Type} {t t' : Transition β} {R : Reversible α β} [DecidableEq α] {m m' : Multiset α} (i : t ↽⇀ t') {e : m 〚t〛⦃R⦄} (f : m 〚e⟩⦃R⦄ m') (h' : m' 〚t'〛⦃R⦄) :
                      m' 〚h'⟩⦃R⦄ m
                      Equations
                      Instances For
                        Equations
                        • ⋯ = ⋯
                        Instances For
                          Equations
                          Instances For

                            Reversible occurrence #

                            A reversible occurrence is defined as a reversible net and an occurrence net. Given a reversible net denoted as Reversible α β, and provided that we have a proof of its occurrence, we can conclude that it constitutes a reversible occurrence net.

                            Instances For
                              theorem ReversibleOcc.ReversibleOccurrence.ext {α β : Type} {x y : ReversibleOccurrence α β} (pre : (↑↑x).pre = (↑↑y).pre) (post : (↑↑x).post = (↑↑y).post) :
                              x = y
                              theorem ReversibleOcc.ReversibleOccurrence.ext_iff {α β : Type} {x y : ReversibleOccurrence α β} :
                              x = y ↔ (↑↑x).pre = (↑↑y).pre ∧ (↑↑x).post = (↑↑y).post
                              Instances For
                                Equations
                                • ↑MO = { toNet := ↑↑MO, m₀ := MO.m₀ }
                                Instances For
                                  Equations
                                  • ↑MO = { toReversible := ↑MO, isOccurrence := ⋯ }
                                  Instances For
                                    theorem ReversibleOcc.reversible_occ_net_safe {α β : Type} [DecidableEq α] (MO : MarkedReversibleOccurrence α β) :
                                    Nets.safe { toNet := ↑↑MO, m₀ := MO.m₀ }
                                    theorem ReversibleOcc.forward_disjoint_postset {α β : Type} {t t' : ReversibleNet.Transition β} (R : ReversibleOccurrence α β) (ft : ▷t) (ft' : ▷t') :
                                    t ≠ t' → Disjoint t•⦃↑R⦄ t'•⦃↑R⦄
                                    theorem ReversibleOcc.backward_disjoint_preset {α β : Type} {t t' : ReversibleNet.Transition β} (R : ReversibleOccurrence α β) (bt : ◁t) (bt' : ◁t') (ne : t ≠ t') :
                                    theorem ReversibleOcc.neq_fwd_disjoint_bwd_preset {α β : Type} {t t' : ReversibleNet.Transition β} (R : ReversibleOccurrence α β) (ft : ▷t) (ft' : ▷t') (ne : t ≠ t') :
                                    theorem ReversibleOcc.fwd_bwd_disjoint_post_pre {α β : Type} {t t' : ReversibleNet.Transition β} (R : ReversibleOccurrence α β) (ft : ▷t) (bt' : ◁t') (ne : t ≠ ↽t') :
                                    theorem ReversibleOcc.loop {α β : Type} {t t' : ReversibleNet.Transition β} {m m' : Multiset α} {RO : ReversibleOccurrence α β} [DecidableEq α] (i : t ↽⇀ t') :
                                    (∃ (e : m 〚t〛⦃↑RO⦄), m 〚e⟩⦃↑RO⦄ m') ↔ ∃ (e : m' 〚t'〛⦃↑RO⦄), m' 〚e⟩⦃↑RO⦄ m
                                    theorem ReversibleOcc.backtracking {α β : Type} {m m' : Multiset α} {RO : ReversibleOccurrence α β} [DecidableEq α] :
                                    (∃ (s : List (ReversibleNet.Transition β)), m 〚s⟩⟩⦃↑RO⦄ m') → ∃ (s : List (ReversibleNet.Transition β)), m' 〚s⟩⟩⦃↑RO⦄ m