Quelle  TLA.thy

(*  Title:      HOL/TLA/TLA.thy
    Author:     Stephan Merz
    Copyright:  1998 University of Munich
*)

section java.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "macro" is null

theory TLA
imports Init
begin

consts
  (** abstract syntax **)
  Box        :: "('w::world) form ==> temporal"
  Dmd        :: "('w::world) form ==> temporal"
  leadsto    :: "['w::world form, 'v::world form] ==> temporal"
  Stable     :: "stpred ==> temporal"
  WF         :: "[action, 'a stfun] ==> temporal"
  SF         :: "[action, 'a stfun] \tfun

  (* Quantification over (flexible) state variables *)
  EEx :: "('a stfun<> temporal) ==> ‹
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  (** concrete syntax **)
syntax
  "_Box"     :: "lift \<Rightarrow" ∀x. F"    <= "_AAll x F sigma"
  "_Dmd"     :"ift \Rightarrow"                        (<open( [40] 40)
  "_leadsto" :: "[lift,lift] ==>
  "stableliftRightarrowlift" (‹(stable/ _)›)
  "_WF": "[liftlift] <Rightarrow (WF'(_')'_(_))› [0,60] 55)
  "_SF"      :: "[lift,lift] ==> lift"                 (‹ == TEMP ◻

  "_EEx"     :: "[idts, lift] \<Rightarrow> lift"                (\<open>(3\<exists>\<exists> _./ _)\<close> [0,10] 10)
  "_AAll"    :: "[idts, lift] \<Rightarrow> lift"                (\<open>(3\<forall>\<forall> _./ _)\<close> [0,10] 10)

translations
  "_Box"      ==   "CONST Box"
  "_Dmd"      ==   "CONST Dmd"
  "_leadsto"  ==   "CONST leadsto"
  "_stable"   ==   "CONST Stable"
  "_WF"       ==   "CONST WF"
  "_SF"       ==   "CONST SF"
  "_EEx v A"  ==   "Eex v. A"
  "_AAll v A" ==   "Aall v. A"

  "sigma \<Turnstile> \<box>F"         <= "_Box F sigma"
  "sigma \<Turnstile> \<diamond>F"         <= "_Dmd F sigma"
  "sigma \<Turnstile> F \<leadsto> G"      <= "_leadsto F G sigma"
 "sigma \<urnstile> stable P"    <= "_stable P sigma"
  "sigma \<Turnstile> WF(A)_v"     <= "_WF A v sigma"
  "sigma \<Turnstile> SF(A)_v"     < _SF A v sigma"
  "
  "sigma \<Turnstile> \<forall>\<forall>x. F"    <= "_AAll x F sigma"

axiomatization where
  (* Definitions of derived operators *)
  dmd_def:      "∧F. TEMP ♢F == TEMP ¬◻¬F"

axiomatization where
  boxInit:      "∧F. TEMP ◻F == TEMP ◻Init F" and
  leadsto_def:  "\And F \>TEM \box F \longrightarrowd>G)" and
  stable_def:     "\And>P. ⊨ ◻P ⟶ Init P`" and
  WF_def(A_v  ==TEMP◻♢
  SF_def:       "TEMP SF(A)_v == TEMP ◻
  aall_def: "TEMP (∀ F x ⟶∃" and

axiomatization where
(* Base axioms for raw TLA. *)
  normalT: "∧F G. ⊨ ◻(F ⟶ G) ⟶ (◻F ⟶ ◻G)" and (* polymorphic *)
  reflT: "∧F. ⊨java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
  transT:     "∧F. ⊨ ◻F ⟶ ◻◻F" and     (* polymorphic *) allT, symmetric
  linT:       "∧F G. ⊨
  T\F ♢F)) ⟶ ◻F)" and
  primeI:     "∧P. ⊨ ◻P ⟶ Init P`" and
  primeE< \ (F\longrightarrow> ◻F)" and
  indT: "∧P F. ⊨◻ ¬F ⟶ P` ∧ Init>◻
  allT:       "∧F. ⊨ (∀x. ◻(F x)) = (◻(∀

axiomatization where
  ecT "<And>F. ⊨ ⊨F" (* polymorphic *)

axiomatization where
(* Flexible quantification: refinement mappings, history variables *)done
  eexI: "⊨
  eexE:       "[
                 (∧turnstile> \\<box>F ∧ ♢G ⟶ ♢(◻F ∧ G)"
              ] ==> G sigma" and
  history: "⊨ ∃∃h. Init(h = ha) ∧ ◻(∀x. $h = #x ⟶ h` = hb x)"


(* Specialize intensional introduction/elimination rules for temporal formulas *)unfold dmd_def)

lemmatempI[int!]: "(<>. ⊨
  apply (rule intI)
  apply (erule meta_spec)
  done

lemma tempD [dest]: "⊨ (F::ox
  by (erule intD)


(* ======== Functions to "unlift" temporal theorems ====== *)

ML ‹
(* The following functions are specialized versions of the corresponding
   functions defi in theory Intensional in that they introduce a
   " " parameter of type "behavior".
*)
fun temp_unlift ctxt th =
  (rewrite_rule ctxt @{thms action_rews} (th RS @{thm tempD}))
    handle THM _ => action_unlift ctxt th;

(* Turn  \<turnstile> F = G  into meta-level rewrite rule  F == G *)
val = int_rewrite

fun temp_use ctxt th =
  case Thm.concl_of th
    Const _ $ (Const (<^   F ∧ ♢
            ((flatten (temp_unlift unfold)
  | _ => th;

fun try_rewrite
›

attribute_setup
  ‹
attribute_setup temp_rewrite =
  \<open>Scan.succeed (Thm.rule_attribute [] (temp_rewrite o Context.proof_of))\<close>
attribute_setup temp_use =
  \<open>Scan.succeed (Thm.rule_attribute [] (temp_use o Context.proof_of))\<close>
attribute_setup try_rewrite =
  \<open>Scan.succeed (Thm.rule_attribute [] (try_rewrite o Context.proof_of))<close>


(* ------------------------------------------------------------------------- *)
(***           "Simple temporal logic": only \<box> and \<diamond>                     ***)
(* ------------------------------------------------------------------------- *)
section "Simple temporal logic"

(* \<box>\<not>F == \<box>\<not>Init F *)
lemmas boxNotInit = boxInit [of "LIFT ¬F", unfolded Init_simps] for F

lemma dmdInit: "TEMP ♢F == TEMP ♢ Init F"
  apply (unfold dmd_def)
  apply (unfold boxInit [of "LIFT ¬F"])
  apply (simp) add Init_simps)
  done

lemmas = dmdInit " ¬

(* boxInit and dmdInit cannot be used as rewrites, because they loop.
   Non-looping instances for state predicates and actions are occasionally useful.
*)
lemmas boxInit_stp = boxInit [whapply (rle Boxm)
lemmas boxInit_act = boxInit [where 'a = "statemdImplE
lemmas dmdInit_stp applyo
lemmas dmdInit_actapplyrulejava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

(* The symmetric equations can be used to get rid of Init *)
lemmas
lemmas dmdInitD = dmdInit [symmetric]
lemmas boxNotInitD = boxNotInit [symmetric]
lemmas dmdNotInitD = dmdNotInit [symmetric]

lemmas Init_simps = Init_simps boxInitD dmdInitD boxNotInitD dmdNotInitD

(* ------------------------ STL2 ------------------------------------------- *)
lemmas STL2 = reflT

(* The "polymorphic" (generic) variant *)
lemma STL2_gen: "⊨ ◻F ⟶ Init F"
  apply (unfold boxInit [of F])
  apply (rule STL2)
  done

(* see also STL2_pr below: "\<turnstile> \<box>P \<longrightarrow> Init P & Init (P`)" *)


(* Dual versions for \<diamond> *)
lemma InitDmd: java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
  apply (unfold
  apply (auto dest!: STL2 [temp_use]lemmastemp_simpsewrite dConst
  done

lemma InitDmd_gen
  apply clarsimp
  apply (drule InitDmd [temp_use])
  apply ( add: dmdInitD
  done


(* ------------------------ STL3 ------------------------------------------- *): "<(<>\>>\<>F)"
lemma STL3: "⊨ (◻◻F) = (◻b (simp add: md_def)
  by (auto elim:le NotDmd: "<> ♢¬

(* corresponding elimination rule introduces double boxes:by(mp d d_def
   \<lbrakk> (sigma \<Turnstile> \<box>F); (sigma(
*)
lemmas dup_boxE = STL3 [temp_unlift, THEN iffD2, elim_format]
lemmas dup_boxD = STL3 [temp_unlift, THEN iffD1  STL3iterewriteewriterewrite

(* dual versions for \<diamond> *)\diamond *)
lemma DmdDmd: "⊨
  by (auto simp add: dmd_def [try_rewrite] STL

lemmas dup_ddE = DmdDmd [temp_unlift, THEN iffD2, elim_format]
lemmas dup_dmdD = DmdDmd [temp_unlift, THEN iffD1]


(* ------------------------ STL4 ------------------------------------------- *) au dest!: STL2 [temp_use])
lemma STL4:
  assumes "<>F<> Gjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
  shows "⊨F ⟶ ◻
  apply clarsimp
  apply (rule normalT [temp_use])
   apply (rule assms [TH apply(eln)
  apply assumption
  done

(* Unlifted version as an elimination rule *)
lemma STL4E: "<lbrakkion
  apply

lemma <>  Init\Longrightarrow <turnstile◻F ⟶ ◻
  apply (drule STL4
  apply (simp add: boxInitD)
  done

lemma STL4E_gen: "[
  by (erule (1) STL4_gen [temp_use])

(* see also STL4Edup below, which allows an auxiliary boxed formula:
       ◻
--
     ◻A /
*)

(* The dual versions for \<diamond> *)
lemma DmdImpl:
   pe:"turnstile ⟶
  shows "
lemma:An>sigma. \<> F \<G (F ∨
  apply (fastforce intro!: prem [temp_use] elim!: STL4E [temp_use])
  done

lemma DmdImplE: "<ce[
  by (erule (1) DmdImpl [temp_use])

(* ------------------------ STL5 ------------------------------------------- *)
lemma STL5d ore_temp_simps2
  apply auto
  applyubgoal_tac <>  (F ∧
     apply (erule normalT [temp_use])
     apply (fastforce elim!: STL4E [temp_use])+
  done

(* rewrite rule to split conjunctions under boxes *)
lemmas split_box_conj = STL5 [temp_unlift, symmetric]


(* the corresponding elimination rule allows to combine boxes in the hypotheses
   (NB: F and G must have the same type, i.e., both actions or temporals.)
   Use "addSE2" etc. if you want to add this to asetet herwisewillllloop
*)
lemma box_conjE:
  assumes java.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "macro" is null
     di_c)
  and "sigmaapply)
  showsSTL2_pr[_]
  by (rule assms STL5 [temp_unlift, THEN iffD1] conjI)+

(* Instances of box_conjE for state predicates, actions, and temporals
   in case the general rule is "too polymorphic".
*)
lemmas box_conjE_temp = box_conjE [where 'a = behavior]
lemmas box_conjE_stp = box_conjE [where 'a = state]
lemmas = box_conjE[where 'a = state]

(* Define a tactic that tries to merge all boxes in an antecedent. The definition is
   a bit kludgy in order to simulate "double elim-resolution".
*)

lemma box_thin: "[

ML ‹P)"
fun merge_box_tac ctxt i =
   REPEAT_DETERM (EVERY [eresolve_tac ctxctxt @{thms box_conjE} i, assum ctxt i,
    eresolve_tac ctxt @{thms box_thin} i])

fun merge_temp_box_tac ctxt i =
  REPEAT_DETERM (EVERY [eresolve_tac ctxt @{thms box_conjE_temp} i, assume_tac ctxt i,
    Rule_Insts.eres_inst_tac ctxt [(((" a", 0), Position.none), "behavior")] [] @{thm box_thin} i])

  merge_stp_box_tac ctxt i =
 REPEAT_DETERM (EVERY [eresolve_tac ctx
 Rule_Insts.eres_inst_tac ctxt [((("'a", 0), Position.none), "state")] [] @{thm box_thin} i])

  merge_act_box_tac ctxt i =
 REPEAT_DETERM (EVERY [eresolve_tac ctxt @{thms box_conjE_act} i, assume_tac ctxt i,
 Rule_Insts.eres_inst_tac ctxt [((("'a", 0), Position.none), "state * state")] [] @{thm box_thin
 ›

method_setup merge_box = ‹Scan.succeed (SIMPLE_METHOD' o merge_box_tac)›
method_setup merge_temp_box = ‹Scan.succeed (SIMPLE_METHOD' o merge_temp_box_tac)›
method_setup merge_stp_box = ‹Scan.succeed (SIMPLE_METHOD' o merge_stp_box_tac)›
ct_box = ‹

 
 (sigma \<Turnstile)
*)
lemmas all_box =  <> P)"

a D: "<turnstile \or> G)=(<diamond>F ∨ ♢G)"
  apply (auto simp add: dmd_def split_box_conj [try_rewrite])
  apply (erule contrapos_np, merge_box, fastforce elim!: STL4E [temp_use])+
  done

lemma exT: "⊨ (∃x. ♢(F x)) = (♢(∃x. F x))"
  by (auto simp: dmd_ef Not_ [try_] all_box [try_rewrite])

lemmas ex_dmd = exT [temp_unlift, symmetric]

lemma STL4Edup: "∧
  apply(erule)
  apply merge_box
  apply
  apply assumption
  done

lemma DmdImpl2:
    "∧sigma. [ sigma ⊨ ♢
  apply (unfold dmd_def)
  apply auto
  apply (erule notE)
  apply merge_box
  apply (fastforce elim!: STL4E
  done

lemma InfImpl:
  assumes 1: "sigma ⊨ ◻♢F"
    and 2: "sigma <    "able_def
    and 3: "⊨ F ∧
  showslemma Stabl: "<lbrakk sigma ⊨A; ⊨ A ⟶ P<> <Longrightarrow  stable P"
  apply (insert 1 2)
 up_boxE
  apply merge_box
  apply (fastforce elim!: STL4E [temp_use] DmdImpl2 [temp_use] intro!: 3 [temp_use])
  done

(* ------------------------ STL6 ------------------------------------------- *)
(* Used in the proof of STL6, but useful in itself. *)
lemma BoxDmd: "⊨
  apply dmd_def
  apply clarsimp
  apply (erule dup_boxE)
  apply merge_box
  apply ( contrapos_np
  apply (fastforce
  done

(* weaker than BoxDmd, but more polymorphic (and often just right) *)
lemma BoxDmd_simple: "⊨ ◻F ∧ add: dmdInitD)
  apply (unfold dmd_def)
  apply clarsimp
  apply merge_box
  apply (fastforce elim!: notE STL4E [temp_use])
  done

lemma BoxDmd2_simple: "⊨ ◻F ∧ ♢G ⟶ ♢(G ∧ F)"
  apply (unfold dmd_def)
  apply clarsimp
  apply merge_box
  apply (fastforce elim!: notE STL4E [temp_use])
  done

 DmdImpldup:
  assumes 1: "sigma java.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "brackoff" is null
    and 2: "sigma ⊨ ♢F"
    and 3: "⊨ ◻A ∧ F ⟶ G"
  shows "sigma ⊨ ♢G"
  apply (rule 2 [THEN 1 [THEN BoxDmd [temp_use]], THEN late
  apply (rule auto_inv_tac ctxt
  done

lemmaSTL6:"\>◻<nd> \diamond>◻G \\<box>(F \> G)"
  apply (auto simp: STL5 Init_stp@thm}]) [] @thm}])))java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
  apply (drule linT [temp_use])
   apply assumption
  apply (erule thin_rl)
  apply (ruleDmdDmd,THEN])
  apply (erule disjE)
   apply (erule DmdImplE)
   apply (rule BoxDmd)
  apply (erule DmdImplE)
  apply auto
  apply (drule BoxDmd [temp_use])
   apply assumption
  apply (erule thin_rl)
  apply (fastforce elim!: DmdImplE [temp_use])
  done


(* ------------------------ True / False ----------------------------------------- *) Clasimp> (K(SIMPLE_METHOD))
section "Simplification of constants"

lemma BoxConst: "⊨
  apply (rule tempI)
  apply (cases P)
   apply (auto intro!: necT [temp_use] dest: STL2_gen [temp_use] simp: Init_simps)
  done

lemma DmdConst: "⊨turnstile> ◻`∨<> 
  apply (unfold dmd_def)
  apply (cases P)
  apply (simp_all add: BoxConst [try_rewrite])
  done

lemmas temp_simps [temp_rewrite, simp] = BoxConst DmdConst


(* ------------------------ Further rewrites ----------------------------------------- *)
section"Further rew"

lemma NotBox: "⊨ (¬◻F) = (♢
  by (simp add: dmd_def)

lemma NotDmd: "⊨ (¬♢F) = (◻¬
  by (java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

(* These are not declared by default, because they could be harmful,
   e.g. \<box>F & \<not>\<box>F becomes \<box>F & \<diamond>\<not>F !! *)
lemmas more_temp_simps1 =
  STL3 [temp_rewriteDmde tBoxtete
  NotBox [temp_unlift, THEN eq_reflection]
  NotDmd [temp_unlift, THEN eq_reflection

lemma BoxDmdBox: "⊨
  apply (auto dest!: STL2 [temp_use])
  apply (rule ccontr)
  apply (subgoal_tac "sigma ⊨ ♢◻ dmd_def [temp_rewrite
   apply (erule thin_rl)
   apply auto
    apply (drule STL6 [temp_use])
     apply assumption
    apply simp
   apply (simp_all add: more_temp_simps1)
  done

 DmdBoxDmd\turnstile> (<>\♢
  apply (unfold dmd_def)
  apply (auto simp: BoxDmdBox [unfolded dmd_def, try_rewrite])
  done

lemmas more_temp_simps2 = more_temp_simps1 BoxDmdBox [temp_rewritelemma InfinitePrime<turnstile (<ox\


(* ------------------------ Miscellaneous ----------------------------------- *)

lemma BoxOr: "∧ temp_use] TLA2E [temp_use])
  by (fastforce elim!: STL4E [temp_use])

(* "persistently implies infinitely often" *)
lemma DBImplBD: "⊨ ♢orcemp_use
  apply clarsimp
  apply (rule ccontr)
  apply (simp add: more_temp_simps2)
  apply (drule STL6 [temp_use])
   apply assumption
  apply simp
  done

lemma BoxDmdDmdBox: "⊨r
  apply clarsimp
  apply (rule ccontr)
  apply (unfold more_temp_simps2)
  apply (drule STL6 [temp_use])
   apply assumption
  apply (subgoal_tac "sigma ⊨ ♢
   apply (force simp: dmd_def)
  apply (fastforce elim: DmdImplE [temp_use] STL4E [temp_use])
  done


(* ------------------------------------------------------------------------- *)
(***          TLA-specific theorems: primed formulas                       ***)
(* ------------------------------------------------------------------------- *)
section "priming"

(* ------------------------ TLA2 ------------------------------------------- *)
lemma STL2_pr: "⊨ ◻P ⟶
  by (fastforce intro!: STL2_gen [temp_use] primeI [temp_use])

(* Auxiliary lemma allows priming of boxed actions *)
lemma BoxPrime: "java.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "brackoff" is null
  apply clarsimp
  apply (erule dup_boxE)
  apply (unfold boxInit_act)
  apply (erule
  apply (auto simp: Init_simps dest!: STL2_pr [temp_use
  done

lemma TLA2:
  assumes "⊨ $P ∧ P$ ⟶ A"
  shows "⊨ ◻P ⟶ ◻A"
  apply clarsimp
  apply (drule BoxPrime [temp_use])
  apply (auto simp: Init_stp_act_rev [try_rewrite] intro!: assms [temp_use]
    elim!: STL4E [temp_use
  lemmasmore_temp_simps  more_temp_simps3 WF_Box [temp_rewrite [temp_rewrite]

lemma TLA2E: "\ <tu> SF(A)_v ⟶
  by (erule (1) TLA2 [temp_use])

lemma DmdPrime: "⊨
  apply (unfold dmd_def)
  apply (fastforce!: TLA2E[emp_use
  done

imeDmd= InitDmd_gen [temp_use, THEN DmdPrime [temp_use]]

(* ------------------------ INV1, stable --------------------------------------- *) ctxt =
section "stable, invariant"

lemma ind_rule:
   "[ sigma ⊨
    ==> sigma ⊨
  apply (rle indT [temp_use])java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
   apply (erule (2) STL4E)
  done

lemma box_stp_act: "⊨>(Init F) ∧(F <eadsto 
  by (simp add: boxInit_act Init_simps)

lemmas box_stp_actI = box_stp_act [temp_use, THEN iffD2]
lemmas box_stp_actD = box_stp_act streett_leadsto<> (<>\><diamond>G) = (♢>G))"

lemmas more_temp_simps3 = box_stp_act [temp_rewrite] apply ((unfold leadsto_def)

lemma INV1:
  "⊨)
  apply (unfold stable_def boxInit_stp boxInit_act)
  apply clarsimp
  apply (erule ind_rule)
   apply (auto simp: Init_simps elim: ind_rule)
  done

lemma StableT:
    "\apply
  apply (unfold stable_def)
]
  done

lemma Stable: "[ sigma\turnstile\box><>F ∧ G) ⟶ ◻G"
  by (erule (1) StableT [temp_use])

(* Generalization of INV1 *)
lemma StableBox: "⊨done
  apply (unfold stable_def)
  apply clarsimp
  apply (erule dup_boxE)
  apply ( simp STL4E[])
  done

lemma DmdStable: "⊨ (stable P) ∧ ♢P ⟶ ♢◻P"
  apply clarsimp
  apply (rule DmdImpl2)
   prefer 2
   apply*)
  apply (simp add: dmdInitD)
  done

(* ---------------- (Semi-)automatic invariant tactics ---------------------- *)

ML ‹
(* inv_tac reduces goals of the form ... \<Longrightarrow> sigma \<Turnstile> \<box>P *)
fun inv_tac ctxt =
  SELECT_GOAL
    (EVERY
     [auto_tac ctxt,
      TRY (merge_box_tac ctxt 1),
      resolve_tactemp_use1} 1 * fail ot
      TRYALL (eresolve_tac ctxt @{thms Stable})]);

(* auto_inv_tac applies inv_tac and then tries to attack the subgoals
   in simple cases it may be able to handle goals like \<turnstile> MyProg \<longrightarrow> \<box>Inv.
   In   \<box>I \<longrightarrow <leadsto> Q)  =  (P /\  <leadsto> Q))
   auto-tactic, which applies too much propositional logic and simplifies
   too late.
*)
fun auto_inv_tac ctxt =
  SELECT_GOAL
    (inv_tac ctxt 1 THEN
      (TRYALL (action_simp_tac
        (ctxt addsimps [@{thm Init_stp}, @{thm Init_act}]) [] [@{thm squareE}])));
›

method_setup invariant = ‹ dmd
  Method.sections Clasimp.clasimp_modifiers >> (K (SIMPLE_METHOD' o inv_tac))
\<close>

method_setup auto_invariant = \<open>
  Method.sections Clasimp.clasimp_modifiers >> (K (SIMPLE_METHOD' o auto_inv_tac))
\<close>

lemma unless: "\<turnstile> \<box>($P \<longrightarrow> P` \<or> Q`) \<longrightarrow> (stable P)   done
  apply (unfold dmd_def)
  apply (clarsimp dest!: BoxPrime [temp_use])
  apply merge_box
  apply (erule contrapos_np)
  apply (fastforce elim!: Stable [temp_use])
  one


(* --------------------- Recursive expansions --------------------------------------- *)
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 30

(* Recursive expansions of \<box> and \<diamond> for state predicates *)
lemma BoxRec: "⊨ (◻P) = (Ini by (aut (auto simp: Init_def intro!: ImplLeadsto_gen [temp_use] necT [temp_use])
  apply (auto intro!: STL2_gen [temp_use])
   apply fastforce elim!: TLA2E [temp_use])
  apply (auto si: stable_def elim!: INV1 [temp_use] STL4E [te])
  done

lemma DmdRec: "⊨)
  applyunfold BoxRec])
  apply (auto simp: Init_simps)
  done

lemma DmdRec2: "∧
  apply (force simp: DmdRec [temp_rewrite] dmd_def)
  done

lemma InfinitePrime: "java.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "brackoff" is null
  apply auto
   apply ( classical
  shows"<\box ◻P ⟶A) ⟶ Q)"
   apply (subgoal_tacsigma ♢P")
    apply (fastforce elim!: DmdImplE [temp_use] TLA2E [temp_use])
   apply (subgoal_tac "sigma <applyule
    apply   orce
     !emp_usep_use
   apply (force intro!: STL6 [temp_use] simp: more_temp_simps3)
  apply (fastforce intro: DmdPrimeelim
  done

lemma InfiniteEnsures:
  "[ ⊨ N ⟶ Q`;
  apply (unfold InfinitePrime [temp])
  apply (rule InfImpl)
     +
  done

(* ------------------------ fairness ------------------------------------------- *)
section "fairness

(* alternative definitions of fairness *)
lemma WF_alt: "\< : ◻P; sigma ⊨A; ⊨ $P ⟶ Q` ]==> ◻Q"
   unfold)
  apply fastforce
  done

lemma SF_alt
  apply
  apply fastforce
  done

(* theorems to "box" fairness conditions *)
lemma BoxWFI: "⊨<>WF(A)_v"
  by (auto simp unfold

lemma WF_Box: "⊨
  by (fastforce intro!: BoxWFI [temp_use] dest!: STL2 [l Lattic: "turnstileleadstoH) ∧ (F ↝ G) ⟶<eadstoH)"

lemma BoxSFI: "⊨boxE<box◻ H) *)
  by (auto simp: SF_alt [try_rewrite] more_temp_simps3 intro!: BoxOr

lemma SF_Box: "⊨ (◻SF(A)_ apply (rule dudup_dd)
  by (fastforce intro!: BoxSFI [temp_us] dest!: STL2 [temp_use])

lemmas more_temp_simps = more_temp_simps3 WF_Box [temp_rewrite] SF_B [temp_rewrite]

lemma SFImplWF: "⊨>WF(A)_v"
  apply (unfold SF_def WF_def)
  apply (fastforce dest!: !: DBImplBD [temp_use])
  done

(* A tactic that "boxes" all fairness conditions. Apply more_temp_simps to "unbox". *)
ML ‹
fun box_fair_tac ctxt =
  SELECT_GOAL (REPEAT (dresolve_tac ctxt [@{thm BoxWFI}, @{thm BoxSFI}] 1))
\<close>


(* ------------------------------ leads-to ------------------------------ *)

section " ↝"

  leadsto_init: "⊨ (Ilapply(auto si: Init_simps elim!: STL4E [temp_use]])
 apply (unfold leadsto_def)
 apply (auto
 done

(* \<turnstile> F & (F \<leadsto> G) \<longrightarrow> \<diamond>G *)
lemmas leadsto_init_temp = leadsto_init [where 'a = behavior, unfolded Init_simps]

lemma streett_leadsto: "⊨ (◻
  apply (unfold leadsto_def)
  apply auto
    apply (simp add: more_temp_simps)
    apply (fastforce elim!: DmdImplE [temp_use] STL4E [temp_use])
   apply (fastforce intro!: InitDmd [temp_use] elim!: STL4E [temp_use])
  apply (subgoal_tac " ⊨♢G")
   apply (simp add: more_temp_simps)
  apply (drule BoxDmdDmdBox [temp_use])
   apply assumption
  apply (fastforce elim!: DmdImplE [temp_use] STL4E [temp_use])
  done

lemma leadsto_infinite: "⊨
  apply clarsimp
  apply (eruletDmdett_leadsto HEN)
  apply (simp add: dmdInitD)
  done

(* In particular, strong fairness is a Streett condition. The following
   rules are sometimes easier to use than WF2 or SF2 below.
*)
lemma leadsto_SF: "⊨ (Enabled(< clri
  apply (unfold SF_def)
  apply (clarsimp elim!: leadsto_in [tem
  done

lemmaleadsto_WF: "<>( WF(A)v"
  by (clarsimp intro!: SFImplWF [temp_use] leadsto_SF [temp_use])

(* introduce an invariant into the proof of a leadsto assertion.
   \> ((P ↝l> Q))
*)
lemma INV_leadsto: "⊨ ◻
  apply (unfold
  apply clarsimp
  apply (erule STL4Edup)
   apply assumption
  apply (auto
  done

lemmaleadsto_classical: "\turnstileInit F ∧¬<> G) <long> (F \<> 
  apply (unfold leadsto_def dmd_def)
  apply (force simp: Init_simps elim!: STL4E [temp_use])
  done

lemma leadsto_false: "⊨
  apply (unfold leadsto_def)
  apply (simp add: boxNotInitD)
  done

lemma leadsto_exists: "\> (\exists>x. F x) \<leadsto x. (F x ↝
  apply ufol eds_e)
  apply (auto simp: allT [try_rewrite] Init_simps elim!: STL4E [temp_use])
  done

(* basic leadsto properties, cf. Unity *)

lemma ImplLeadsto_gen: "⊨ java.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "brackoff" is null
  apply (unfold leadsto_def)
  apply (auto intro!: InitDmd_gen [temp_useo
    elim! STL4E_gen [temp_use: Init_simps
  done

lemmas ImplLeadsto =
  ImplLeadsto_gen =havioror]

emmaAnd G. ⊨ F ⟶Longrightarrow⊨ F ↝
by t_defemp_use

lemma EnsuresLeadsto:
  assumes "⊨ (rue2[HENDdIml em_s])
  shows "⊨ ◻A ⟶ (P ↝ Q)"
  apply (unfold leadsto_def)
  apply (clarsimp elim!: INV_leadsto [temp_use])
  apply (erule STL4E_gen)
  apply (auto simp: Init_defs intrapply ( (ul lasical
  done (rule STL [tem_se]

lemma EnsuresLeadsto2: "⊨
  apply (unfold leadsto_def)
  apply clarsimp
  apply (apply erule
  apply (auto simp: Init_simps introDmd
  done

lemma ensures:
  assumes 1: "⊨ ($P ∧ \and Q`;
    and 2: "⊨ ◻ ◻ ◻longrightarrow ♢(<A>_v)]
  shows "⊨ ◻N ∧ ◻(◻P ⟶ ♢A) ⟶ (P ↝ Q)"
  apply (unfold leadsto_def)
  apply clarsimp
  apply (erule STL4Edup)
   applyassumption
  apply clarsimp
  apply (subgoal_tac "sigmaa ⊨ ◻ dup_boxE
   apply (drule unless [temp_use])
   apply (clarsimp dest!: INV1 [temp_use])
  apply (rule 2 [THEN DmdImpl, temp_use, THEN DmdPrime [temp_use]])
   apply (force intro!: BoxDmd_simp [temp_use]
     simp: split_box_conj [try_rewrite] box_stp_act [try_rewrite])
  apply (force elim: STL4E [temp_use] dest: 1 [temp_use])
  done

 ensures_simple:
  "[turnstile$P ∧ P` ∧ <N ∧ A>_f ⟶ B"
      ⊨ ($P ∧ N) ∧> PP ∧ Enabled(<M>_g) ⟶_f)
   ] ⊨N ∧ ◻A ⟶(P \<leadsto 
  apply clarsimp
  apply (erule (2) ensures [temp_use])
  apply (force elim!: STL4E [temp_use])
  

lemma EnsuresInfinite:
    \>T> ◻P; sigma \<urnstile 
   leadsto_infinite [temp_use])
  apply (erule EnsuresLeadsto [temp_use])
  apply assumption
  done


(*** Gronning's lattice rules (taken from TLP) ***)
section "Lattice rulesoxDmd_simpleDmdDmdte

lemma LatticeReflexivity: "⊨ F ↝ F"
  apply (unfold leadsto_def (e4p_use
  apply (rulele
  done

lemma LatticeTransitivity\turnstile> (G ↝ G) ⟶ H)"
  apply (unfold leadsto_def)
  apply clar
  apply (erule dup_boxE) (* ◻apply (drule BoxWFI [temp_use])
  apply merge_box
  apply (clarsimp elim!: STL4E [temp_use])
  apply (rule dup_dmdD)
  apply (subgoal_tac "sigmaa ♢Init G"
   apply (erule DmdImpl2)
   apply assumption
  apply (simp add: dmdInitD)
  done

lemma LatticeDisjunctionElim1: "⊨ (F ∨ G ↝ H) <longrightarrow  
  apply (unfold leadsto_def)
  apply (auto nit_simps elim!: STL4E [temp_use])
  done

lemmaeDisjunctionElim2⊨ (F ∨leadsto H ⟶ (G ↝ H)"
  apply (unfold leadsto_def)
  apply (auto simp: Init_simps elim!: STL4E [temp_use])
  done

lemma LatticeDisjunctionIntro: "⊨ (F ↝ H) ∧ (G ↝ H) ⟶1"⊨ <B>_f ⟶ <M>_g"
  apply (unfold leadsto_def)
  apply clarsimp
  apply merge_box
  apply (auto simpInit_simps elimSTL4E [temp_use])
  done

lemma LatticeDisjunction: "⊨ (F ∨ G ↝ H) = ((F ↝ H) ∧ (G ↝ H))"
  by (auto intro: LatticeDisjunctionIntro [temp_use]
    LatticeDisjunctionElim1 [temp_use]
    LatticeDisjunctionElim2 [temp_use])

lemma LatticeDiamond: "⊨ ◻ SF(A)_f ∧F ⟶M)_g"
  apply clarsimp
  apply (subgoal_tac "sigma ⊨ (B ∨ C) ↝(cl dest!: BoxSFI [temp_use] si: 2 [try_ SF_ [where A = M])
  apply (erule_tac G = "LIFT (B ∨
   apply (fastforce intro!:applymerge_temp_box
  done

lemma:<>  (B ↝longrightarrow (A ↝
  apply clarsimp
  apply (subgoal_tac "sigma ⊨ (D ∨apply ((rule classclassical)
   apply (erule_tac G = "LIFT (D ∨ LatticeTransitivity [])
   assumption
  apply (auto intro: LatticeDisjunctionIntro [temp_use] LatticeReflexivity ( BoxDmd_simple [THEN DmdImpl DmdDmdtemp_rewrite], temp_use
  

lemma LatticeTriangle2: "⊨a (frul 4 [temp_use])
  apply clarsimp
  apply (subgoal_tac "sigma (erule_tac V = "sigmaa <> ◻
_G "LIFT<> 
   apply
  apply (auto intro: LatticeDisjunctionIntro [temp_use (rule_tacN<> 
  done

(*** Lamport's fairness rules ***)
section "Fairness rules"

lemma WF1:
  "[ F_Box [try_rewrite] box_stp_act [try_rewrite])
      \turnstileand> N) <and <A>_v ⟶ Q`;
      ⊨ $P ∧ N ⟶ $(Enabled(<A>_v)) ] rule STL2 [temp_use])
  ==> ⊨ ◻[t intro!: 3 [temp])
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  apply (erule (2) ensures [temp_use])
  apply (erule (1) STL4Edup)
  apply (clarsimp simp: WF_def)
  apply (rule STL2 [temp_use])
  apply (clarsimp elim!: mp intro!: InitDmd [temp_use])
  apply (erule STL4 [temp_use, THEN box_stp_actD [temp_use]])
  apply (simp add: split_box_conj box_stp_actI)
  done

(* Sometimes easier to use; designed for action B rather than state predicate Q *)
lemma WF_leadsto:
  assumes 1: "⊨ LatticeTriangletemp_use]
    andrule
    and 3: "⊨ ◻(N ∧ [¬: leadsto_ex [try_rewrite])
  shows "⊨ ◻
   ( leadsto_def
  apply (clarsimp dest!: BoxWFI [temp_use])
  apply (erule (1) STL4Edup)
  apply clarsimp
  apply (rule 2 [THEN DmdImpl, temp_use])
  apply ( BoxDmd_simpletemp_use
   apply assumption
  apply (rule classical)
  apply (rule STL2 [temp_use])
  apply (clarsimp simp: WF_def elim!: mp intro!: InitDmd [temp_use])
  apply (rule 1 [THEN STL4, temp_use, THEN box_stp_actD])apply(le,HEN
  apply (simp (no_asm_simp) add clarsimpy_rewritee]_uare[ry_rewrite
  apply (erule INV1 [temp_use])
  apply (rule 3 [temp_use])
  apply (simp add: split_box_conj [try_rewrite
  done

lemma SF1:
  "\ 
      ⊨
      ⊨ ◻
  \\>box>\<>(♢ #r>_v"
  apply (clarsimp dest java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
  apply (erule (2) ensures [temp_use])
  apply erule_tacin)
  apply merge_temp_box
  apply (erule STL4Edup)
  apply assumption
  apply (clarsimp simp: SF_def)
  apply (ruleapply force
  apply (erule (eSTL4E
  apply (erule STL4 [temp_use])
  apply (simp add: split_box_conj [try_rewrite] STL3 [try_rewrite])
  done

lemma WF2:
  assumes 1: "⊨ N ∧
   \>$ \and P \>< A>_f \longrightarrow
    and 3: "⊨
    and 4: "⊨(N ∧ [\not_f) \and WF(AA)_f ∧ ◻F ∧ ♢Enabled(<M>_g) ⟶◻P"
  shows "⊨ ◻N ∧ WF(A)_f ∧ ◻erule thin_rl)
  apply (clarsimp dest!: BoxWFI [temp_use] BoxDmdBox [temp_use, THEN iffD2]
    simp: WF_def [where A = M])
  apply (erule_tac F = F in dup_boxE)
  apply merge_temp_box
  apply (erule STL4Edup)
   apply assumption
  apply (clarsim intro!: !: BoxDmd_simple[temp_use, THEN 1 [THEN DmdImpl temp_use]])
  apply (rule classical)
  apply (subgoal_tac "sigmaa ⊨
   apply (force simp: angle_def intro!: 2 [temp_use] elim!: DmdImplE [temp_use])
  apply (rule BoxDmd_simple [THEN DmdImpl, unfolded DmdDmd [temp_rewrite](
  applysimp: NotDmd] not_angle])
  apply merge_act_box
  apply (frule 4 [temp_use])
     apply assumption+
  apply (drule STL6 [temp_use])
  pplyion
  apply (erule_tac V = "sigmaa ⊨ ♢◻P shows"<> (∀x. F x)"
  apply (erule_tac V = "sigmaa
  apply lemma aallE\turnstile>(<>\
  apply (erule_tac F = "ACT N \apply
  apply merge_temp_box
  apply (erule DmdImpldup)
   apply assumption
  apply (auto simp: split_box_conj [try_rewrite] STL3 [try_rewrite]
    WF_Box [try_rewrite] box_stp_act [try_rewrite])
   apply (force elim!: TLA2E [where P = P, temp_use])
  apply (rule STL2 [temp_use])
  apply (force simp: WF_def split_box_conj [try_rewrite]
    elim!: mp intassumes 1 sigma \Turnstile ∃x. F x"
  done

lemma SF2:
  assumes 1: "⊨ ∃>x. G x"
    and 2: "⊨rule unitbase [THEN 1 [THEN eexE]])
    and 3: "<> longrightarrow> Enabled(<A>_f)"
    and 4: "⊨ ◻(N ∧ [¬B]_f) ∧ SF(A)_f ∧ ◻F ∧ ◻♢Enabledapplyerule 2  , THEN mp]
  shows "⊨ aall_mono:
  apply (clarsimp dest!: BoxSFI [temp_use] simp: 2 [try_rewrite] SF_def [hre A M])
  apply (erule_tac F = F in dup_boxE)
  apply (erule_tac F = "TEMP <diamondEnabled
  apply merge_temp_box
  apply (erule STL4Edup)
   apply assumption
  apply(clarsimp!: BoxDmd_simple,THEN THEN, temp_use
rule)
  apply (subgoal_tac "sigmaa \<(ule Init I"
   apply (force simp: angle_def intro!: 2 [temp_useandsigmaTurnstile◻N"
  apply (rule BoxDmd_simple [THEN DmdImpl nd 3: " vs"
  apply (simp add: NotDmd [temp_use] not_angle [try_rewrite])
  apply merge_act_box
  apply (frule 4 [temp_use])
     apply assumption+
  apply (erule_tac V = "sigmaa> ◻in
  apply (drule BoxSFI [temp_use])
  apply (erule_tac "EMP <>Enabled (<M>_g)" in up_boxE
  apply (erule_tac F = "ACT N ∧ [¬
  apply merge_temp_box
  apply (erule DmdImpldup)
   apply assumption
  apply(rue ojI)
    SF_Box [try_rewrite] box_stp_act [try_rewrite])
   apply (force elim!: TLA2E [where P = P, temp_use])
  apply (rule STL2 [temp_use])
  apply (force simp: SF_def split_box_conj [try_rewrite]
    elim!: mp InfImpl [temp_use] intro!: 3 [temp_use])
  done

(* ------------------------------------------------------------------------- *)
(***           Liveness proofs by well-founded orderings                   ***)
(* ------------------------------------------------------------------------- *)
section "Well-founded orderings"

lemma wf_leadsto:
  assumes 1: "wfr"
    and 2: "∧ tempI
  shows<Turnstile> F xjava.lang.NullPointerException: Cannot invoke "String.equals(Object)" because "brackoff" is null
  apply (rule 1 [THEN wf_induct])
  apply (rule LatticeTriangle [temp_use])
   apply (rule 2)
  apply (auto simp: leadsto_exists [try_rewrite])
  apply (case_tac "(y,x) ∈ r")
   apply force
  apply (force simp: leadsto_def Init_simps intro!: necT [temp_use])
  done

(* If r is well-founded, state function v cannot decrease forever *)
lemma wf_not_box_decrease: "∧r. wf r ==> ⊨ ◻[ (v`, $v) ∈ #r ]_v ⟶ ♢◻[#False]_v"
  apply clarsimp
  apply (rule ccontr)
  apply (subgoal_tac "sigma ⊨ (∃x. v=#x) ↝ #False")
   apply (drule leadsto_false [temp_use, THEN iffD1, THEN STL2_gen [temp_use]])
   apply (force simp: Init_defs)
  apply (clarsimp simp: leadsto_exists [try_rewrite] not_square [try_rewrite] more_temp_simps)
  apply (erule wf_leadsto)
  apply (rule ensures_simple [temp_use])
   apply (auto simp: square_def angle_def)
  done

(* "wf r  \<Longrightarrow>  \<turnstile> \<diamond>\<box>[ (v`, $v) : #r ]_v \<longrightarrow> \<diamond>\<box>[#False]_v" *)
lemmas wf_not_dmd_box_decrease =
  wf_not_box_decrease [THEN DmdImpl, unfolded more_temp_simps]

(* If there are infinitely many steps where v decreases, then there
   have to be infinitely many non-stuttering steps where v doesn't decrease.
*)
lemma wf_box_dmd_decrease:
  assumes 1: "wf r"
  shows "⊨ ◻♢((v`, $v) ∈ #r) ⟶ ◻♢<(v`, $v) ∉ #r>_v"
  apply clarsimp
  apply (rule ccontr)
  apply (simp add: not_angle [try_rewrite] more_temp_simps)
  apply (drule 1 [THEN wf_not_dmd_box_decrease [temp_use]])
  apply (drule BoxDmdDmdBox [temp_use])
   apply assumption
  apply (subgoal_tac "sigma ⊨ ◻♢ ((#False) ::action)")
   apply force
  apply (erule STL4E)
  apply (rule DmdImpl)
  apply (force intro: 1 [THEN wf_irrefl, temp_use])
  done

(* In particular, for natural numbers, if n decreases infinitely often
   then it has to increase infinitely often.
*)
lemma nat_box_dmd_decrease: "∧n::nat stfun. ⊨ ◻♢(n` < $n) ⟶ ◻♢($n < n`)"
  apply clarsimp
  apply (subgoal_tac "sigma ⊨ ◻♢<¬ ((n`,$n) ∈ #less_than)>_n")
   apply (erule thin_rl)
   apply (erule STL4E)
   apply (rule DmdImpl)
   apply (clarsimp simp: angle_def [try_rewrite])
  apply (rule wf_box_dmd_decrease [temp_use])
   apply (auto elim!: STL4E [temp_use] DmdImplE [temp_use])
  done


(* ------------------------------------------------------------------------- *)
(***           Flexible quantification over state variables                ***)
(* ------------------------------------------------------------------------- *)
section "Flexible quantification"

lemma aallI:
  assumes 1: "basevars vs"
    and 2: "(∧x. basevars (x,vs) ==> sigma ⊨ F x)"
  shows "sigma ⊨ (∀∀x. F x)"
  by (auto simp: aall_def elim!: eexE [temp_use] intro!: 1 dest!: 2 [temp_use])

lemma aallE: "⊨ (∀∀x. F x) ⟶ F x"
  apply (unfold aall_def)
  apply clarsimp
  apply (erule contrapos_np)
  apply (force intro!: eexI [temp_use])
  done

(* monotonicity of quantification *)
lemma eex_mono:
  assumes 1: "sigma ⊨ ∃∃x. F x"
    and 2: "∧x. sigma ⊨ F x ⟶ G x"
  shows "sigma ⊨ ∃∃x. G x"
  apply (rule unit_base [THEN 1 [THEN eexE]])
  apply (rule eexI [temp_use])
  apply (erule 2 [unfolded intensional_rews, THEN mp])
  done

lemma aall_mono:
  assumes 1: "sigma ⊨ ∀∀x. F(x)"
    and 2: "∧x. sigma ⊨ F(x) ⟶ G(x)"
  shows "sigma ⊨ ∀∀x. G(x)"
  apply (rule unit_base [THEN aallI])
  apply (rule 2 [unfolded intensional_rews, THEN mp])
  apply (rule 1 [THEN aallE [temp_use]])
  done

(* Derived history introduction rule *)
lemma historyI:
  assumes 1: "sigma ⊨ Init I"
    and 2: "sigma ⊨ ◻N"
    and 3: "basevars vs"
    and 4: "∧h. basevars(h,vs) ==> ⊨ I ∧ h = ha ⟶ HI h"
    and 5: "∧h s t. [ basevars(h,vs); N (s,t); h t = hb (h s) (s,t) ] ==> HN h (s,t)"
  shows "sigma ⊨ ∃∃h. Init (HI h) ∧ ◻(HN h)"
  apply (rule history [temp_use, THEN eexE])
  apply (rule 3)
  apply (rule eexI [temp_use])
  apply clarsimp
  apply (rule conjI)
   prefer 2
   apply (insert 2)
   apply merge_box
   apply (force elim!: STL4E [temp_use] 5 [temp_use])
  apply (insert 1)
  apply (force simp: Init_defs elim!: 4 [temp_use])
  done

(* ----------------------------------------------------------------------
   example of a history variable: existence of a clock
*)

lemma "⊨ ∃∃h. Init(h = #True) ∧ ◻(h` = (¬$h))"
  apply (rule tempI)
  apply (rule historyI)
  apply (force simp: Init_defs intro!: unit_base [temp_use] necT [temp_use])+
  done

end