Theorem: localDiamondTruth (Pdl/Unfold.lean)

State before:
γ : Program
ψ : Formula
⊢ (~⌈γ⌉ψ)≡dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H γ))
Tactic:
intro W M w
State after:
γ : Program
ψ : Formula
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w (~⌈γ⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H γ)))

State before:
γ : Program
ψ : Formula
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w (~⌈γ⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H γ)))
Tactic:
cases γ
State after:
case atom_prog
ψ : Formula
W : Type
M : KripkeModel W
w : W
a✝ : ℕ
⊢ evaluate M w (~⌈·a✝⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (·a✝))))

case sequence
ψ : Formula
W : Type
M : KripkeModel W
w : W
a✝¹ a✝ : Program
⊢ evaluate M w (~⌈a✝¹;'a✝⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (a✝¹;'a✝))))

case union
ψ : Formula
W : Type
M : KripkeModel W
w : W
a✝¹ a✝ : Program
⊢ evaluate M w (~⌈a✝¹⋓a✝⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (a✝¹⋓a✝))))

case star
ψ : Formula
W : Type
M : KripkeModel W
w : W
a✝ : Program
⊢ evaluate M w (~⌈∗a✝⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗a✝))))

case test
ψ : Formula
W : Type
M : KripkeModel W
w : W
a✝ : Formula
⊢ evaluate M w (~⌈?'a✝⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (?'a✝))))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
a : ℕ
⊢ evaluate M w (~⌈·a⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (·a))))
Tactic:
case atom_prog a =>
  simp [H]
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
τ : Formula
⊢ evaluate M w (~⌈?'τ⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (?'τ))))
Tactic:
case test τ =>
  simp [evaluate, H, Yset]
  rw [conEval]
  simp
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
a : ℕ
⊢ evaluate M w (~⌈·a⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (·a))))
Tactic:
simp [H]
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
τ : Formula
⊢ evaluate M w (~⌈?'τ⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (?'τ))))
Tactic:
simp [evaluate, H, Yset]
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
τ : Formula
⊢ evaluate M w τ ∧ ¬evaluate M w ψ ↔ evaluate M w (Con (List.insert τ [~ψ]))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
τ : Formula
⊢ evaluate M w τ ∧ ¬evaluate M w ψ ↔ evaluate M w (Con (List.insert τ [~ψ]))
Tactic:
rw [conEval]
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
τ : Formula
⊢ evaluate M w τ ∧ ¬evaluate M w ψ ↔ ∀ f ∈ List.insert τ [~ψ], evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
τ : Formula
⊢ evaluate M w τ ∧ ¬evaluate M w ψ ↔ ∀ f ∈ List.insert τ [~ψ], evaluate M w f
Tactic:
simp
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ evaluate M w (~⌈α⋓β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α⋓β))))
Tactic:
have IHα := localDiamondTruth α ψ W M w
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : evaluate M w (~⌈α⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H α)))
⊢ evaluate M w (~⌈α⋓β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α⋓β))))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : evaluate M w (~⌈α⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H α)))
⊢ evaluate M w (~⌈α⋓β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α⋓β))))
Tactic:
have IHβ := localDiamondTruth β ψ W M w
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : evaluate M w (~⌈α⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H α)))
IHβ : evaluate M w (~⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H β)))
⊢ evaluate M w (~⌈α⋓β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α⋓β))))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : evaluate M w (~⌈α⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H α)))
IHβ : evaluate M w (~⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H β)))
⊢ evaluate M w (~⌈α⋓β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α⋓β))))
Tactic:
simp [evaluate, H, Yset, disEval] at *
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
⊢ (∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ) ↔
    ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
⊢ (∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ) ↔
    ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
Tactic:
constructor
State after:
case mp
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
⊢ (∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ) →
    ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f

case mpr
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
⊢ (∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f) →
    ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ

State before:
case mp
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
⊢ (∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ) →
    ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
Tactic:
rintro ⟨v, v_claim⟩
State after:
case mp.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
v_claim : (relate M α w v ∨ relate M β w v) ∧ ¬evaluate M v ψ
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f

State before:
case mp.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
v_claim : (relate M α w v ∨ relate M β w v) ∧ ¬evaluate M v ψ
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
Tactic:
rw [or_and_right] at v_claim
State after:
case mp.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
v_claim : relate M α w v ∧ ¬evaluate M v ψ ∨ relate M β w v ∧ ¬evaluate M v ψ
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f

State before:
case mp.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
v_claim : relate M α w v ∧ ¬evaluate M v ψ ∨ relate M β w v ∧ ¬evaluate M v ψ
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
Tactic:
cases v_claim
State after:
case mp.intro.inl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
h✝ : relate M α w v ∧ ¬evaluate M v ψ
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f

case mp.intro.inr
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
h✝ : relate M β w v ∧ ¬evaluate M v ψ
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M α w v ∧ ¬evaluate M v ψ
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
Tactic:
case inl hyp =>
  have : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) := ⟨v, hyp⟩
  rw [IHα] at this
  rcases this with ⟨f, ⟨⟨a, b, ⟨ab_in, def_f⟩⟩, w_f⟩⟩
  exact ⟨f, ⟨⟨a, b, ⟨Or.inl ab_in, def_f⟩⟩, w_f⟩⟩
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M β w v ∧ ¬evaluate M v ψ
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
Tactic:
case inr hyp =>
  have : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) := ⟨v, hyp⟩
  rw [IHβ] at this
  rcases this with ⟨f, ⟨⟨a, b, ⟨ab_in, def_f⟩⟩, w_f⟩⟩
  exact ⟨f, ⟨⟨a, b, ⟨Or.inr ab_in, def_f⟩⟩, w_f⟩⟩
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M α w v ∧ ¬evaluate M v ψ
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
Tactic:
have : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) := ⟨v, hyp⟩
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M α w v ∧ ¬evaluate M v ψ
this : ∃ x, relate M α w x ∧ ¬evaluate M x ψ
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M α w v ∧ ¬evaluate M v ψ
this : ∃ x, relate M α w x ∧ ¬evaluate M x ψ
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
Tactic:
rw [IHα] at this
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M α w v ∧ ¬evaluate M v ψ
this : ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M α w v ∧ ¬evaluate M v ψ
this : ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
Tactic:
rcases this with ⟨f, ⟨⟨a, b, ⟨ab_in, def_f⟩⟩, w_f⟩⟩
State after:
case intro.intro.intro.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M α w v ∧ ¬evaluate M v ψ
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
ab_in : (a, b) ∈ H α
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f

State before:
case intro.intro.intro.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M α w v ∧ ¬evaluate M v ψ
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
ab_in : (a, b) ∈ H α
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
Tactic:
exact ⟨f, ⟨⟨a, b, ⟨Or.inl ab_in, def_f⟩⟩, w_f⟩⟩
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M β w v ∧ ¬evaluate M v ψ
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
Tactic:
have : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) := ⟨v, hyp⟩
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M β w v ∧ ¬evaluate M v ψ
this : ∃ x, relate M β w x ∧ ¬evaluate M x ψ
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M β w v ∧ ¬evaluate M v ψ
this : ∃ x, relate M β w x ∧ ¬evaluate M x ψ
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
Tactic:
rw [IHβ] at this
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M β w v ∧ ¬evaluate M v ψ
this : ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M β w v ∧ ¬evaluate M v ψ
this : ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
Tactic:
rcases this with ⟨f, ⟨⟨a, b, ⟨ab_in, def_f⟩⟩, w_f⟩⟩
State after:
case intro.intro.intro.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M β w v ∧ ¬evaluate M v ψ
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
ab_in : (a, b) ∈ H β
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f

State before:
case intro.intro.intro.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
v : W
hyp : relate M β w v ∧ ¬evaluate M v ψ
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
ab_in : (a, b) ∈ H β
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
⊢ ∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
Tactic:
exact ⟨f, ⟨⟨a, b, ⟨Or.inr ab_in, def_f⟩⟩, w_f⟩⟩
State after:
no goals

State before:
case mpr
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
⊢ (∃ f, (∃ a b, ((a, b) ∈ H α ∨ (a, b) ∈ H β) ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f) →
    ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ
Tactic:
rintro ⟨f, ⟨a, b, ⟨(ab_in_Hα|ab_in_Hβ), def_f⟩⟩, w_f⟩
State after:
case mpr.intro.intro.intro.intro.intro.inl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hα : (a, b) ∈ H α
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ

case mpr.intro.intro.intro.intro.intro.inr
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hβ : (a, b) ∈ H β
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ

State before:
case mpr.intro.intro.intro.intro.intro.inl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hα : (a, b) ∈ H α
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ
Tactic:
have : ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f :=
  ⟨f, ⟨⟨a, b, ⟨ab_in_Hα, def_f⟩⟩, w_f⟩⟩
State after:
case mpr.intro.intro.intro.intro.intro.inl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hα : (a, b) ∈ H α
this : ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ

State before:
case mpr.intro.intro.intro.intro.intro.inl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hα : (a, b) ∈ H α
this : ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ
Tactic:
rw [← IHα] at this
State after:
case mpr.intro.intro.intro.intro.intro.inl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hα : (a, b) ∈ H α
this : ∃ x, relate M α w x ∧ ¬evaluate M x ψ
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ

State before:
case mpr.intro.intro.intro.intro.intro.inl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hα : (a, b) ∈ H α
this : ∃ x, relate M α w x ∧ ¬evaluate M x ψ
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ
Tactic:
rcases this with ⟨x, ⟨w_α_x, x_Psi⟩⟩
State after:
case mpr.intro.intro.intro.intro.intro.inl.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hα : (a, b) ∈ H α
x : W
w_α_x : relate M α w x
x_Psi : ¬evaluate M x ψ
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ

State before:
case mpr.intro.intro.intro.intro.intro.inl.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hα : (a, b) ∈ H α
x : W
w_α_x : relate M α w x
x_Psi : ¬evaluate M x ψ
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ
Tactic:
exact ⟨x, ⟨Or.inl w_α_x, x_Psi⟩⟩
State after:
no goals

State before:
case mpr.intro.intro.intro.intro.intro.inr
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hβ : (a, b) ∈ H β
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ
Tactic:
have : ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f :=
  ⟨f, ⟨⟨a, b, ⟨ab_in_Hβ, def_f⟩⟩, w_f⟩⟩
State after:
case mpr.intro.intro.intro.intro.intro.inr
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hβ : (a, b) ∈ H β
this : ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ

State before:
case mpr.intro.intro.intro.intro.intro.inr
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hβ : (a, b) ∈ H β
this : ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ
Tactic:
rw [← IHβ] at this
State after:
case mpr.intro.intro.intro.intro.intro.inr
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hβ : (a, b) ∈ H β
this : ∃ x, relate M β w x ∧ ¬evaluate M x ψ
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ

State before:
case mpr.intro.intro.intro.intro.intro.inr
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hβ : (a, b) ∈ H β
this : ∃ x, relate M β w x ∧ ¬evaluate M x ψ
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ
Tactic:
rcases this with ⟨x, ⟨w_β_x, x_Psi⟩⟩
State after:
case mpr.intro.intro.intro.intro.intro.inr.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hβ : (a, b) ∈ H β
x : W
w_β_x : relate M β w x
x_Psi : ¬evaluate M x ψ
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ

State before:
case mpr.intro.intro.intro.intro.intro.inr.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : (∃ x, relate M α w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H α ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
IHβ : (∃ x, relate M β w x ∧ ¬evaluate M x ψ) ↔ ∃ f, (∃ a b, (a, b) ∈ H β ∧ Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f) ∧ evaluate M w f
f : Formula
w_f : evaluate M w f
a : List Formula
b : List Program
def_f : Con (a ∪ [~⌈⌈b⌉⌉ψ]) = f
ab_in_Hβ : (a, b) ∈ H β
x : W
w_β_x : relate M β w x
x_Psi : ¬evaluate M x ψ
⊢ ∃ x, (relate M α w x ∨ relate M β w x) ∧ ¬evaluate M x ψ
Tactic:
exact ⟨x, ⟨Or.inr w_β_x, x_Psi⟩⟩
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ evaluate M w (~⌈α;'β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))
Tactic:
have : evaluate M w (~⌈α;'β⌉ψ) ↔ evaluate M w (~⌈α⌉⌈β⌉ψ) := by aesop
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
this : evaluate M w (~⌈α;'β⌉ψ) ↔ evaluate M w (~⌈α⌉⌈β⌉ψ)
⊢ evaluate M w (~⌈α;'β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
this : evaluate M w (~⌈α;'β⌉ψ) ↔ evaluate M w (~⌈α⌉⌈β⌉ψ)
⊢ evaluate M w (~⌈α;'β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))
Tactic:
rw [this]
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
this : evaluate M w (~⌈α;'β⌉ψ) ↔ evaluate M w (~⌈α⌉⌈β⌉ψ)
⊢ evaluate M w (~⌈α⌉⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
this : evaluate M w (~⌈α;'β⌉ψ) ↔ evaluate M w (~⌈α⌉⌈β⌉ψ)
⊢ evaluate M w (~⌈α⌉⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))
Tactic:
clear this
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ evaluate M w (~⌈α⌉⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ evaluate M w (~⌈α⌉⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))
Tactic:
have IHα := localDiamondTruth α (⌈β⌉ψ) W M w
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : evaluate M w (~⌈α⌉⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ (⌈β⌉ψ))) (H α)))
⊢ evaluate M w (~⌈α⌉⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : evaluate M w (~⌈α⌉⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ (⌈β⌉ψ))) (H α)))
⊢ evaluate M w (~⌈α⌉⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))
Tactic:
rw [IHα]
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : evaluate M w (~⌈α⌉⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ (⌈β⌉ψ))) (H α)))
⊢ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ (⌈β⌉ψ))) (H α))) ↔
    evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
IHα : evaluate M w (~⌈α⌉⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ (⌈β⌉ψ))) (H α)))
⊢ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ (⌈β⌉ψ))) (H α))) ↔
    evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))
Tactic:
clear IHα
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ (⌈β⌉ψ))) (H α))) ↔
    evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ (⌈β⌉ψ))) (H α))) ↔
    evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))
Tactic:
rw [disEval]
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ (∃ f ∈ List.map (fun Fδ => Con (Yset Fδ (⌈β⌉ψ))) (H α), evaluate M w f) ↔
    evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ (∃ f ∈ List.map (fun Fδ => Con (Yset Fδ (⌈β⌉ψ))) (H α), evaluate M w f) ↔
    evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β))))
Tactic:
rw [disEval]
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ (∃ f ∈ List.map (fun Fδ => Con (Yset Fδ (⌈β⌉ψ))) (H α), evaluate M w f) ↔
    ∃ f ∈ List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β)), evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ (∃ f ∈ List.map (fun Fδ => Con (Yset Fδ (⌈β⌉ψ))) (H α), evaluate M w f) ↔
    ∃ f ∈ List.map (fun Fδ => Con (Yset Fδ ψ)) (H (α;'β)), evaluate M w f
Tactic:
rw [helper, helper]
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ (∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))) ↔ ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ (∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))) ↔ ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))
Tactic:
constructor
State after:
case mp
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ (∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))) → ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))

case mpr
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ (∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))) → ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ evaluate M w (~⌈α;'β⌉ψ) ↔ evaluate M w (~⌈α⌉⌈β⌉ψ)
Tactic:
aesop
State after:
no goals

State before:
case mp
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ (∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))) → ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))
Tactic:
rintro ⟨⟨Fs,δ⟩, ⟨Fδ_in, w_Con⟩⟩
State after:
case mp.intro.mk.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
⊢ ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))

State before:
case mp.intro.mk.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
⊢ ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))
Tactic:
cases em (δ = ε)
State after:
case mp.intro.mk.intro.inl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
h✝ : δ = ε
⊢ ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))

case mp.intro.mk.intro.inr
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
h✝ : ¬δ = ε
⊢ ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_is_ε : δ = ε
⊢ ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))
Tactic:
subst δ_is_ε
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
⊢ ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
⊢ ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))
Tactic:
have claim : ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ)) := by
  rw [conEval] at w_Con
  simp [Yset, Con] at w_Con
  have := w_Con (~⌈β⌉ψ)
  simp only [or_true, forall_true_left] at this
  have IHβ := localDiamondTruth β ψ W M w
  rw [IHβ] at this
  rw [disEval, helper] at this
  exact this
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
claim : ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))
⊢ ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
claim : ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))
⊢ ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))
Tactic:
rcases claim with ⟨⟨Gs,γ⟩, Gsγ_in, claim⟩
State after:
case intro.mk.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))

State before:
case intro.mk.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))
Tactic:
unfold H
State after:
case intro.mk.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ ∃
    Fδ ∈
      (List.map
          (fun x =>
            match x with
            | (F, δ) =>
              if δ = ε then
                (List.map
                    (fun x =>
                      match x with
                      | (G, δ') => [(F ∪ G, δ')])
                    (H β)).join
              else [(F, δ ++ [β])])
          (H α)).join,
    evaluate M w (Con (Yset Fδ ψ))

State before:
case intro.mk.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ ∃
    Fδ ∈
      (List.map
          (fun x =>
            match x with
            | (F, δ) =>
              if δ = ε then
                (List.map
                    (fun x =>
                      match x with
                      | (G, δ') => [(F ∪ G, δ')])
                    (H β)).join
              else [(F, δ ++ [β])])
          (H α)).join,
    evaluate M w (Con (Yset Fδ ψ))
Tactic:
use ⟨Fs ∪ Gs, γ⟩
State after:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ (Fs ∪ Gs, γ) ∈
      (List.map
          (fun x =>
            match x with
            | (F, δ) =>
              if δ = ε then
                (List.map
                    (fun x =>
                      match x with
                      | (G, δ') => [(F ∪ G, δ')])
                    (H β)).join
              else [(F, δ ++ [β])])
          (H α)).join ∧
    evaluate M w (Con (Yset (Fs ∪ Gs, γ) ψ))

State before:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ (Fs ∪ Gs, γ) ∈
      (List.map
          (fun x =>
            match x with
            | (F, δ) =>
              if δ = ε then
                (List.map
                    (fun x =>
                      match x with
                      | (G, δ') => [(F ∪ G, δ')])
                    (H β)).join
              else [(F, δ ++ [β])])
          (H α)).join ∧
    evaluate M w (Con (Yset (Fs ∪ Gs, γ) ψ))
Tactic:
constructor
State after:
case h.left
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ (Fs ∪ Gs, γ) ∈
    (List.map
        (fun x =>
          match x with
          | (F, δ) =>
            if δ = ε then
              (List.map
                  (fun x =>
                    match x with
                    | (G, δ') => [(F ∪ G, δ')])
                  (H β)).join
            else [(F, δ ++ [β])])
        (H α)).join

case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ evaluate M w (Con (Yset (Fs ∪ Gs, γ) ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))
Tactic:
rw [conEval] at w_Con
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : ∀ f ∈ Yset (Fs, ε) (⌈β⌉ψ), evaluate M w f
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : ∀ f ∈ Yset (Fs, ε) (⌈β⌉ψ), evaluate M w f
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))
Tactic:
simp [Yset, Con] at w_Con
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈β⌉ψ) → evaluate M w f
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈β⌉ψ) → evaluate M w f
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))
Tactic:
have := w_Con (~⌈β⌉ψ)
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈β⌉ψ) → evaluate M w f
this : (~⌈β⌉ψ) ∈ Fs ∨ (~⌈β⌉ψ) = (~⌈β⌉ψ) → evaluate M w (~⌈β⌉ψ)
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈β⌉ψ) → evaluate M w f
this : (~⌈β⌉ψ) ∈ Fs ∨ (~⌈β⌉ψ) = (~⌈β⌉ψ) → evaluate M w (~⌈β⌉ψ)
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))
Tactic:
simp only [or_true, forall_true_left] at this
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈β⌉ψ) → evaluate M w f
this : evaluate M w (~⌈β⌉ψ)
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈β⌉ψ) → evaluate M w f
this : evaluate M w (~⌈β⌉ψ)
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))
Tactic:
have IHβ := localDiamondTruth β ψ W M w
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈β⌉ψ) → evaluate M w f
this : evaluate M w (~⌈β⌉ψ)
IHβ : evaluate M w (~⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H β)))
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈β⌉ψ) → evaluate M w f
this : evaluate M w (~⌈β⌉ψ)
IHβ : evaluate M w (~⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H β)))
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))
Tactic:
rw [IHβ] at this
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈β⌉ψ) → evaluate M w f
this : evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H β)))
IHβ : evaluate M w (~⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H β)))
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈β⌉ψ) → evaluate M w f
this : evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H β)))
IHβ : evaluate M w (~⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H β)))
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))
Tactic:
rw [disEval, helper] at this
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈β⌉ψ) → evaluate M w f
this : ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ ψ))
IHβ : evaluate M w (~⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H β)))
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈β⌉ψ) → evaluate M w f
this : ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ ψ))
IHβ : evaluate M w (~⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H β)))
⊢ ∃ Gγ ∈ H β, evaluate M w (Con (Yset Gγ ψ))
Tactic:
exact this
State after:
no goals

State before:
case h.left
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ (Fs ∪ Gs, γ) ∈
    (List.map
        (fun x =>
          match x with
          | (F, δ) =>
            if δ = ε then
              (List.map
                  (fun x =>
                    match x with
                    | (G, δ') => [(F ∪ G, δ')])
                  (H β)).join
            else [(F, δ ++ [β])])
        (H α)).join
Tactic:
simp only [List.mem_join, List.mem_map, Prod.exists]
State after:
case h.left
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ ∃ l,
    (∃ a b, (a, b) ∈ H α ∧ (if b = ε then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) = l) ∧
      (Fs ∪ Gs, γ) ∈ l

State before:
case h.left
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ ∃ l,
    (∃ a b, (a, b) ∈ H α ∧ (if b = ε then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) = l) ∧
      (Fs ∪ Gs, γ) ∈ l
Tactic:
use ((H β).map (fun ⟨Gs',δ'⟩ => [⟨Fs ∪ Gs', δ'⟩])).join
State after:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ (∃ a b,
      (a, b) ∈ H α ∧
        (if b = ε then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) =
          (List.map
              (fun x =>
                match x with
                | (Gs', δ') => [(Fs ∪ Gs', δ')])
              (H β)).join) ∧
    (Fs ∪ Gs, γ) ∈
      (List.map
          (fun x =>
            match x with
            | (Gs', δ') => [(Fs ∪ Gs', δ')])
          (H β)).join

State before:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ (∃ a b,
      (a, b) ∈ H α ∧
        (if b = ε then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) =
          (List.map
              (fun x =>
                match x with
                | (Gs', δ') => [(Fs ∪ Gs', δ')])
              (H β)).join) ∧
    (Fs ∪ Gs, γ) ∈
      (List.map
          (fun x =>
            match x with
            | (Gs', δ') => [(Fs ∪ Gs', δ')])
          (H β)).join
Tactic:
simp only [List.mem_join, List.mem_map, Prod.exists]
State after:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ (∃ a b,
      (a, b) ∈ H α ∧
        (if b = ε then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) =
          (List.map (fun x => [(Fs ∪ x.1, x.2)]) (H β)).join) ∧
    ∃ l, (∃ a b, (a, b) ∈ H β ∧ [(Fs ∪ a, b)] = l) ∧ (Fs ∪ Gs, γ) ∈ l

State before:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ (∃ a b,
      (a, b) ∈ H α ∧
        (if b = ε then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) =
          (List.map (fun x => [(Fs ∪ x.1, x.2)]) (H β)).join) ∧
    ∃ l, (∃ a b, (a, b) ∈ H β ∧ [(Fs ∪ a, b)] = l) ∧ (Fs ∪ Gs, γ) ∈ l
Tactic:
constructor
State after:
case h.left
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ ∃ a b,
    (a, b) ∈ H α ∧
      (if b = ε then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) =
        (List.map (fun x => [(Fs ∪ x.1, x.2)]) (H β)).join

case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ ∃ l, (∃ a b, (a, b) ∈ H β ∧ [(Fs ∪ a, b)] = l) ∧ (Fs ∪ Gs, γ) ∈ l

State before:
case h.left
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ ∃ a b,
    (a, b) ∈ H α ∧
      (if b = ε then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) =
        (List.map (fun x => [(Fs ∪ x.1, x.2)]) (H β)).join
Tactic:
use Fs, ε
State after:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ (Fs, ε) ∈ H α ∧
    (if ε = ε then (List.map (fun x => [(Fs ∪ x.1, x.2)]) (H β)).join else [(Fs, ε ++ [β])]) =
      (List.map (fun x => [(Fs ∪ x.1, x.2)]) (H β)).join

State before:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ (Fs, ε) ∈ H α ∧
    (if ε = ε then (List.map (fun x => [(Fs ∪ x.1, x.2)]) (H β)).join else [(Fs, ε ++ [β])]) =
      (List.map (fun x => [(Fs ∪ x.1, x.2)]) (H β)).join
Tactic:
simp only [reduceIte, and_true]
State after:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ (Fs, ε) ∈ H α

State before:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ (Fs, ε) ∈ H α
Tactic:
exact Fδ_in
State after:
no goals

State before:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ ∃ l, (∃ a b, (a, b) ∈ H β ∧ [(Fs ∪ a, b)] = l) ∧ (Fs ∪ Gs, γ) ∈ l
Tactic:
tauto
State after:
no goals

State before:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, ε) (⌈β⌉ψ)))
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : evaluate M w (Con (Yset (Gs, γ) ψ))
⊢ evaluate M w (Con (Yset (Fs ∪ Gs, γ) ψ))
Tactic:
simp only [Yset, conEval, List.mem_union_iff, List.mem_singleton] at *
State after:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈ε⌉⌉⌈β⌉ψ) → evaluate M w f
claim : ∀ (f : Formula), f ∈ Gs ∨ f = (~⌈⌈γ⌉⌉ψ) → evaluate M w f
⊢ ∀ (f : Formula), (f ∈ Fs ∨ f ∈ Gs) ∨ f = (~⌈⌈γ⌉⌉ψ) → evaluate M w f

State before:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈ε⌉⌉⌈β⌉ψ) → evaluate M w f
claim : ∀ (f : Formula), f ∈ Gs ∨ f = (~⌈⌈γ⌉⌉ψ) → evaluate M w f
⊢ ∀ (f : Formula), (f ∈ Fs ∨ f ∈ Gs) ∨ f = (~⌈⌈γ⌉⌉ψ) → evaluate M w f
Tactic:
intro f f_in
State after:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈ε⌉⌉⌈β⌉ψ) → evaluate M w f
claim : ∀ (f : Formula), f ∈ Gs ∨ f = (~⌈⌈γ⌉⌉ψ) → evaluate M w f
f : Formula
f_in : (f ∈ Fs ∨ f ∈ Gs) ∨ f = (~⌈⌈γ⌉⌉ψ)
⊢ evaluate M w f

State before:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈ε⌉⌉⌈β⌉ψ) → evaluate M w f
claim : ∀ (f : Formula), f ∈ Gs ∨ f = (~⌈⌈γ⌉⌉ψ) → evaluate M w f
f : Formula
f_in : (f ∈ Fs ∨ f ∈ Gs) ∨ f = (~⌈⌈γ⌉⌉ψ)
⊢ evaluate M w f
Tactic:
specialize w_Con f
State after:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : ∀ (f : Formula), f ∈ Gs ∨ f = (~⌈⌈γ⌉⌉ψ) → evaluate M w f
f : Formula
f_in : (f ∈ Fs ∨ f ∈ Gs) ∨ f = (~⌈⌈γ⌉⌉ψ)
w_Con : f ∈ Fs ∨ f = (~⌈⌈ε⌉⌉⌈β⌉ψ) → evaluate M w f
⊢ evaluate M w f

State before:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
claim : ∀ (f : Formula), f ∈ Gs ∨ f = (~⌈⌈γ⌉⌉ψ) → evaluate M w f
f : Formula
f_in : (f ∈ Fs ∨ f ∈ Gs) ∨ f = (~⌈⌈γ⌉⌉ψ)
w_Con : f ∈ Fs ∨ f = (~⌈⌈ε⌉⌉⌈β⌉ψ) → evaluate M w f
⊢ evaluate M w f
Tactic:
specialize claim f
State after:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
f : Formula
f_in : (f ∈ Fs ∨ f ∈ Gs) ∨ f = (~⌈⌈γ⌉⌉ψ)
w_Con : f ∈ Fs ∨ f = (~⌈⌈ε⌉⌉⌈β⌉ψ) → evaluate M w f
claim : f ∈ Gs ∨ f = (~⌈⌈γ⌉⌉ψ) → evaluate M w f
⊢ evaluate M w f

State before:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H α
Gs : List Formula
γ : List Program
Gsγ_in : (Gs, γ) ∈ H β
f : Formula
f_in : (f ∈ Fs ∨ f ∈ Gs) ∨ f = (~⌈⌈γ⌉⌉ψ)
w_Con : f ∈ Fs ∨ f = (~⌈⌈ε⌉⌉⌈β⌉ψ) → evaluate M w f
claim : f ∈ Gs ∨ f = (~⌈⌈γ⌉⌉ψ) → evaluate M w f
⊢ evaluate M w f
Tactic:
tauto
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ ∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))
Tactic:
unfold H
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ ∃
    Fδ ∈
      (List.map
          (fun x =>
            match x with
            | (F, δ) =>
              if δ = ε then
                (List.map
                    (fun x =>
                      match x with
                      | (G, δ') => [(F ∪ G, δ')])
                    (H β)).join
              else [(F, δ ++ [β])])
          (H α)).join,
    evaluate M w (Con (Yset Fδ ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ ∃
    Fδ ∈
      (List.map
          (fun x =>
            match x with
            | (F, δ) =>
              if δ = ε then
                (List.map
                    (fun x =>
                      match x with
                      | (G, δ') => [(F ∪ G, δ')])
                    (H β)).join
              else [(F, δ ++ [β])])
          (H α)).join,
    evaluate M w (Con (Yset Fδ ψ))
Tactic:
use ⟨Fs, δ ++ [β]⟩
State after:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ (Fs, δ ++ [β]) ∈
      (List.map
          (fun x =>
            match x with
            | (F, δ) =>
              if δ = ε then
                (List.map
                    (fun x =>
                      match x with
                      | (G, δ') => [(F ∪ G, δ')])
                    (H β)).join
              else [(F, δ ++ [β])])
          (H α)).join ∧
    evaluate M w (Con (Yset (Fs, δ ++ [β]) ψ))

State before:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ (Fs, δ ++ [β]) ∈
      (List.map
          (fun x =>
            match x with
            | (F, δ) =>
              if δ = ε then
                (List.map
                    (fun x =>
                      match x with
                      | (G, δ') => [(F ∪ G, δ')])
                    (H β)).join
              else [(F, δ ++ [β])])
          (H α)).join ∧
    evaluate M w (Con (Yset (Fs, δ ++ [β]) ψ))
Tactic:
constructor
State after:
case h.left
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ (Fs, δ ++ [β]) ∈
    (List.map
        (fun x =>
          match x with
          | (F, δ) =>
            if δ = ε then
              (List.map
                  (fun x =>
                    match x with
                    | (G, δ') => [(F ∪ G, δ')])
                  (H β)).join
            else [(F, δ ++ [β])])
        (H α)).join

case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ evaluate M w (Con (Yset (Fs, δ ++ [β]) ψ))

State before:
case h.left
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ (Fs, δ ++ [β]) ∈
    (List.map
        (fun x =>
          match x with
          | (F, δ) =>
            if δ = ε then
              (List.map
                  (fun x =>
                    match x with
                    | (G, δ') => [(F ∪ G, δ')])
                  (H β)).join
            else [(F, δ ++ [β])])
        (H α)).join
Tactic:
simp
State after:
case h.left
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ ∃ l,
    (∃ a b,
        (a, b) ∈ H α ∧ (if b = [] then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) = l) ∧
      (Fs, δ ++ [β]) ∈ l

State before:
case h.left
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ ∃ l,
    (∃ a b,
        (a, b) ∈ H α ∧ (if b = [] then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) = l) ∧
      (Fs, δ ++ [β]) ∈ l
Tactic:
use [(Fs, δ ++ [β])]
State after:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ (∃ a b,
      (a, b) ∈ H α ∧
        (if b = [] then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) = [(Fs, δ ++ [β])]) ∧
    (Fs, δ ++ [β]) ∈ [(Fs, δ ++ [β])]

State before:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ (∃ a b,
      (a, b) ∈ H α ∧
        (if b = [] then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) = [(Fs, δ ++ [β])]) ∧
    (Fs, δ ++ [β]) ∈ [(Fs, δ ++ [β])]
Tactic:
constructor
State after:
case h.left
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ ∃ a b,
    (a, b) ∈ H α ∧
      (if b = [] then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) = [(Fs, δ ++ [β])]

case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ (Fs, δ ++ [β]) ∈ [(Fs, δ ++ [β])]

State before:
case h.left
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ ∃ a b,
    (a, b) ∈ H α ∧
      (if b = [] then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) = [(Fs, δ ++ [β])]
Tactic:
use Fs, δ
State after:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ (Fs, δ) ∈ H α ∧
    (if δ = [] then (List.map (fun x => [(Fs ∪ x.1, x.2)]) (H β)).join else [(Fs, δ ++ [β])]) = [(Fs, δ ++ [β])]

State before:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ (Fs, δ) ∈ H α ∧
    (if δ = [] then (List.map (fun x => [(Fs ∪ x.1, x.2)]) (H β)).join else [(Fs, δ ++ [β])]) = [(Fs, δ ++ [β])]
Tactic:
simp_all
State after:
no goals

State before:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ (Fs, δ ++ [β]) ∈ [(Fs, δ ++ [β])]
Tactic:
simp_all
State after:
no goals

State before:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
w_Con : evaluate M w (Con (Yset (Fs, δ) (⌈β⌉ψ)))
δ_not_ε : ¬δ = ε
⊢ evaluate M w (Con (Yset (Fs, δ ++ [β]) ψ))
Tactic:
simp [Yset, conEval, boxes_append] at *
State after:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
δ_not_ε : ¬δ = []
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉⌈β⌉ψ) → evaluate M w f
⊢ ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉⌈β⌉ψ) → evaluate M w f

State before:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
δ_not_ε : ¬δ = []
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉⌈β⌉ψ) → evaluate M w f
⊢ ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉⌈β⌉ψ) → evaluate M w f
Tactic:
intro f f_in
State after:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
δ_not_ε : ¬δ = []
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉⌈β⌉ψ) → evaluate M w f
f : Formula
f_in : f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉⌈β⌉ψ)
⊢ evaluate M w f

State before:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
δ_not_ε : ¬δ = []
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉⌈β⌉ψ) → evaluate M w f
f : Formula
f_in : f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉⌈β⌉ψ)
⊢ evaluate M w f
Tactic:
apply w_Con
State after:
case h.right.a
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
δ_not_ε : ¬δ = []
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉⌈β⌉ψ) → evaluate M w f
f : Formula
f_in : f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉⌈β⌉ψ)
⊢ f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉⌈β⌉ψ)

State before:
case h.right.a
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H α
δ_not_ε : ¬δ = []
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉⌈β⌉ψ) → evaluate M w f
f : Formula
f_in : f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉⌈β⌉ψ)
⊢ f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉⌈β⌉ψ)
Tactic:
tauto
State after:
no goals

State before:
case mpr
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
⊢ (∃ Fδ ∈ H (α;'β), evaluate M w (Con (Yset Fδ ψ))) → ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))
Tactic:
rintro ⟨⟨Fs,δ⟩, ⟨Fδ_in, w_Con⟩⟩
State after:
case mpr.intro.mk.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H (α;'β)
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))

State before:
case mpr.intro.mk.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H (α;'β)
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))
Tactic:
simp [H] at Fδ_in
State after:
case mpr.intro.mk.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Fδ_in :
  ∃ l,
    (∃ a b,
        (a, b) ∈ H α ∧ (if b = [] then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) = l) ∧
      (Fs, δ) ∈ l
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))

State before:
case mpr.intro.mk.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Fδ_in :
  ∃ l,
    (∃ a b,
        (a, b) ∈ H α ∧ (if b = [] then (List.map (fun x => [(a ∪ x.1, x.2)]) (H β)).join else [(a, b ++ [β])]) = l) ∧
      (Fs, δ) ∈ l
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))
Tactic:
rcases Fδ_in with ⟨l, ⟨Gs, γ, ⟨Gγ_in, def_l⟩⟩, Gγ_in_l⟩
State after:
case mpr.intro.mk.intro.intro.intro.intro.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
l : List (List Formula × List Program)
Gγ_in_l : (Fs, δ) ∈ l
Gs : List Formula
γ : List Program
Gγ_in : (Gs, γ) ∈ H α
def_l : (if γ = [] then (List.map (fun x => [(Gs ∪ x.1, x.2)]) (H β)).join else [(Gs, γ ++ [β])]) = l
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))

State before:
case mpr.intro.mk.intro.intro.intro.intro.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
l : List (List Formula × List Program)
Gγ_in_l : (Fs, δ) ∈ l
Gs : List Formula
γ : List Program
Gγ_in : (Gs, γ) ∈ H α
def_l : (if γ = [] then (List.map (fun x => [(Gs ∪ x.1, x.2)]) (H β)).join else [(Gs, γ ++ [β])]) = l
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))
Tactic:
subst def_l
State after:
case mpr.intro.mk.intro.intro.intro.intro.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
γ : List Program
Gγ_in : (Gs, γ) ∈ H α
Gγ_in_l : (Fs, δ) ∈ if γ = [] then (List.map (fun x => [(Gs ∪ x.1, x.2)]) (H β)).join else [(Gs, γ ++ [β])]
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))

State before:
case mpr.intro.mk.intro.intro.intro.intro.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
γ : List Program
Gγ_in : (Gs, γ) ∈ H α
Gγ_in_l : (Fs, δ) ∈ if γ = [] then (List.map (fun x => [(Gs ∪ x.1, x.2)]) (H β)).join else [(Gs, γ ++ [β])]
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))
Tactic:
cases em (γ = ε)
State after:
case mpr.intro.mk.intro.intro.intro.intro.intro.intro.inl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
γ : List Program
Gγ_in : (Gs, γ) ∈ H α
Gγ_in_l : (Fs, δ) ∈ if γ = [] then (List.map (fun x => [(Gs ∪ x.1, x.2)]) (H β)).join else [(Gs, γ ++ [β])]
h✝ : γ = ε
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))

case mpr.intro.mk.intro.intro.intro.intro.intro.intro.inr
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
γ : List Program
Gγ_in : (Gs, γ) ∈ H α
Gγ_in_l : (Fs, δ) ∈ if γ = [] then (List.map (fun x => [(Gs ∪ x.1, x.2)]) (H β)).join else [(Gs, γ ++ [β])]
h✝ : ¬γ = ε
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
γ : List Program
Gγ_in : (Gs, γ) ∈ H α
Gγ_in_l : (Fs, δ) ∈ if γ = [] then (List.map (fun x => [(Gs ∪ x.1, x.2)]) (H β)).join else [(Gs, γ ++ [β])]
δ_not_ε : ¬γ = ε
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))
Tactic:
case inr δ_not_ε => simp_all
  cases Gγ_in_l
  subst_eqs
  simp_all [Yset, conEval, boxes_append]
  use Fs, γ
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
γ : List Program
Gγ_in : (Gs, γ) ∈ H α
Gγ_in_l : (Fs, δ) ∈ if γ = [] then (List.map (fun x => [(Gs ∪ x.1, x.2)]) (H β)).join else [(Gs, γ ++ [β])]
δ_is_ε : γ = ε
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))
Tactic:
subst δ_is_ε
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
Gγ_in_l : (Fs, δ) ∈ if ε = [] then (List.map (fun x => [(Gs ∪ x.1, x.2)]) (H β)).join else [(Gs, ε ++ [β])]
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
Gγ_in_l : (Fs, δ) ∈ if ε = [] then (List.map (fun x => [(Gs ∪ x.1, x.2)]) (H β)).join else [(Gs, ε ++ [β])]
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))
Tactic:
simp at Gγ_in_l
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
Gγ_in_l : ∃ l, (∃ a b, (a, b) ∈ H β ∧ [(Gs ∪ a, b)] = l) ∧ (Fs, δ) ∈ l
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
Gγ_in_l : ∃ l, (∃ a b, (a, b) ∈ H β ∧ [(Gs ∪ a, b)] = l) ∧ (Fs, δ) ∈ l
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))
Tactic:
rcases Gγ_in_l with ⟨l, ⟨⟨aaa, bbb, ⟨_in_Hβ,def_l⟩ ⟩, Fsδ_in_l⟩ ⟩
State after:
case intro.intro.intro.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
l : List (List Formula × List Program)
Fsδ_in_l : (Fs, δ) ∈ l
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
def_l : [(Gs ∪ aaa, bbb)] = l
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))

State before:
case intro.intro.intro.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
l : List (List Formula × List Program)
Fsδ_in_l : (Fs, δ) ∈ l
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
def_l : [(Gs ∪ aaa, bbb)] = l
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))
Tactic:
subst def_l
State after:
case intro.intro.intro.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
Fsδ_in_l : (Fs, δ) ∈ [(Gs ∪ aaa, bbb)]
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))

State before:
case intro.intro.intro.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
Fsδ_in_l : (Fs, δ) ∈ [(Gs ∪ aaa, bbb)]
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))
Tactic:
simp
State after:
case intro.intro.intro.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
Fsδ_in_l : (Fs, δ) ∈ [(Gs ∪ aaa, bbb)]
⊢ ∃ a b, (a, b) ∈ H α ∧ evaluate M w (Con (Yset (a, b) (⌈β⌉ψ)))

State before:
case intro.intro.intro.intro.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
Fsδ_in_l : (Fs, δ) ∈ [(Gs ∪ aaa, bbb)]
⊢ ∃ a b, (a, b) ∈ H α ∧ evaluate M w (Con (Yset (a, b) (⌈β⌉ψ)))
Tactic:
use Gs, ε
State after:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
Fsδ_in_l : (Fs, δ) ∈ [(Gs ∪ aaa, bbb)]
⊢ (Gs, ε) ∈ H α ∧ evaluate M w (Con (Yset (Gs, ε) (⌈β⌉ψ)))

State before:
case h
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
Fsδ_in_l : (Fs, δ) ∈ [(Gs ∪ aaa, bbb)]
⊢ (Gs, ε) ∈ H α ∧ evaluate M w (Con (Yset (Gs, ε) (⌈β⌉ψ)))
Tactic:
constructor
State after:
case h.left
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
Fsδ_in_l : (Fs, δ) ∈ [(Gs ∪ aaa, bbb)]
⊢ (Gs, ε) ∈ H α

case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
Fsδ_in_l : (Fs, δ) ∈ [(Gs ∪ aaa, bbb)]
⊢ evaluate M w (Con (Yset (Gs, ε) (⌈β⌉ψ)))

State before:
case h.left
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
Fsδ_in_l : (Fs, δ) ∈ [(Gs ∪ aaa, bbb)]
⊢ (Gs, ε) ∈ H α
Tactic:
exact Gγ_in
State after:
no goals

State before:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
Fsδ_in_l : (Fs, δ) ∈ [(Gs ∪ aaa, bbb)]
⊢ evaluate M w (Con (Yset (Gs, ε) (⌈β⌉ψ)))
Tactic:
simp at Fsδ_in_l
State after:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
Fsδ_in_l : Fs = Gs ∪ aaa ∧ δ = bbb
⊢ evaluate M w (Con (Yset (Gs, ε) (⌈β⌉ψ)))

State before:
case h.right
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
Fsδ_in_l : Fs = Gs ∪ aaa ∧ δ = bbb
⊢ evaluate M w (Con (Yset (Gs, ε) (⌈β⌉ψ)))
Tactic:
cases Fsδ_in_l
State after:
case h.right.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
left✝ : Fs = Gs ∪ aaa
right✝ : δ = bbb
⊢ evaluate M w (Con (Yset (Gs, ε) (⌈β⌉ψ)))

State before:
case h.right.intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
bbb : List Program
_in_Hβ : (aaa, bbb) ∈ H β
left✝ : Fs = Gs ∪ aaa
right✝ : δ = bbb
⊢ evaluate M w (Con (Yset (Gs, ε) (⌈β⌉ψ)))
Tactic:
subst_eqs
State after:
case h.right.intro.refl.refl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
⊢ evaluate M w (Con (Yset (Gs, ε) (⌈β⌉ψ)))

State before:
case h.right.intro.refl.refl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
⊢ evaluate M w (Con (Yset (Gs, ε) (⌈β⌉ψ)))
Tactic:
simp [conEval, Yset]
State after:
case h.right.intro.refl.refl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
⊢ ∀ (f : Formula), f ∈ Gs ∨ f = (~⌈β⌉ψ) → evaluate M w f

State before:
case h.right.intro.refl.refl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
⊢ ∀ (f : Formula), f ∈ Gs ∨ f = (~⌈β⌉ψ) → evaluate M w f
Tactic:
intro f f_in
State after:
case h.right.intro.refl.refl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
f_in : f ∈ Gs ∨ f = (~⌈β⌉ψ)
⊢ evaluate M w f

State before:
case h.right.intro.refl.refl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
f_in : f ∈ Gs ∨ f = (~⌈β⌉ψ)
⊢ evaluate M w f
Tactic:
cases f_in
State after:
case h.right.intro.refl.refl.inl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
h✝ : f ∈ Gs
⊢ evaluate M w f

case h.right.intro.refl.refl.inr
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
h✝ : f = (~⌈β⌉ψ)
⊢ evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
f_in : f ∈ Gs
⊢ evaluate M w f
Tactic:
case inl f_in =>
  rw [conEval] at w_Con
  simp [Yset] at *
  specialize w_Con f
  tauto
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
f_def : f = (~⌈β⌉ψ)
⊢ evaluate M w f
Tactic:
case inr f_def =>
  subst f_def
  have IHβ := localDiamondTruth β ψ W M w
  rw [IHβ, disEval, helper]
  clear IHβ
  refine ⟨⟨aaa, δ⟩, ⟨_in_Hβ, ?_⟩⟩
  rw [conEval]
  rw [conEval] at w_Con
  simp [Yset] at *
  intro f
  specialize w_Con f
  tauto
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
f_in : f ∈ Gs
⊢ evaluate M w f
Tactic:
rw [conEval] at w_Con
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : ∀ f ∈ Yset (Gs ∪ aaa, δ) ψ, evaluate M w f
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
f_in : f ∈ Gs
⊢ evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : ∀ f ∈ Yset (Gs ∪ aaa, δ) ψ, evaluate M w f
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
f_in : f ∈ Gs
⊢ evaluate M w f
Tactic:
simp [Yset] at *
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, []) ∈ H α
aaa : List Formula
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
f_in : f ∈ Gs
w_Con : ∀ (f : Formula), (f ∈ Gs ∨ f ∈ aaa) ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f
⊢ evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, []) ∈ H α
aaa : List Formula
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
f_in : f ∈ Gs
w_Con : ∀ (f : Formula), (f ∈ Gs ∨ f ∈ aaa) ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f
⊢ evaluate M w f
Tactic:
specialize w_Con f
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, []) ∈ H α
aaa : List Formula
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
f_in : f ∈ Gs
w_Con : (f ∈ Gs ∨ f ∈ aaa) ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f
⊢ evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, []) ∈ H α
aaa : List Formula
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
f_in : f ∈ Gs
w_Con : (f ∈ Gs ∨ f ∈ aaa) ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f
⊢ evaluate M w f
Tactic:
tauto
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
f_def : f = (~⌈β⌉ψ)
⊢ evaluate M w f
Tactic:
subst f_def
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
⊢ evaluate M w (~⌈β⌉ψ)

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
⊢ evaluate M w (~⌈β⌉ψ)
Tactic:
have IHβ := localDiamondTruth β ψ W M w
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
IHβ : evaluate M w (~⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H β)))
⊢ evaluate M w (~⌈β⌉ψ)

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
IHβ : evaluate M w (~⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H β)))
⊢ evaluate M w (~⌈β⌉ψ)
Tactic:
rw [IHβ, disEval, helper]
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
IHβ : evaluate M w (~⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H β)))
⊢ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
IHβ : evaluate M w (~⌈β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H β)))
⊢ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ ψ))
Tactic:
clear IHβ
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
⊢ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
⊢ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ ψ))
Tactic:
refine ⟨⟨aaa, δ⟩, ⟨_in_Hβ, ?_⟩⟩
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
⊢ evaluate M w (Con (Yset (aaa, δ) ψ))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
⊢ evaluate M w (Con (Yset (aaa, δ) ψ))
Tactic:
rw [conEval]
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
⊢ ∀ f ∈ Yset (aaa, δ) ψ, evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : evaluate M w (Con (Yset (Gs ∪ aaa, δ) ψ))
_in_Hβ : (aaa, δ) ∈ H β
⊢ ∀ f ∈ Yset (aaa, δ) ψ, evaluate M w f
Tactic:
rw [conEval] at w_Con
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : ∀ f ∈ Yset (Gs ∪ aaa, δ) ψ, evaluate M w f
_in_Hβ : (aaa, δ) ∈ H β
⊢ ∀ f ∈ Yset (aaa, δ) ψ, evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, ε) ∈ H α
aaa : List Formula
w_Con : ∀ f ∈ Yset (Gs ∪ aaa, δ) ψ, evaluate M w f
_in_Hβ : (aaa, δ) ∈ H β
⊢ ∀ f ∈ Yset (aaa, δ) ψ, evaluate M w f
Tactic:
simp [Yset] at *
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, []) ∈ H α
aaa : List Formula
_in_Hβ : (aaa, δ) ∈ H β
w_Con : ∀ (f : Formula), (f ∈ Gs ∨ f ∈ aaa) ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f
⊢ ∀ (f : Formula), f ∈ aaa ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, []) ∈ H α
aaa : List Formula
_in_Hβ : (aaa, δ) ∈ H β
w_Con : ∀ (f : Formula), (f ∈ Gs ∨ f ∈ aaa) ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f
⊢ ∀ (f : Formula), f ∈ aaa ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f
Tactic:
intro f
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, []) ∈ H α
aaa : List Formula
_in_Hβ : (aaa, δ) ∈ H β
w_Con : ∀ (f : Formula), (f ∈ Gs ∨ f ∈ aaa) ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f
f : Formula
⊢ f ∈ aaa ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, []) ∈ H α
aaa : List Formula
_in_Hβ : (aaa, δ) ∈ H β
w_Con : ∀ (f : Formula), (f ∈ Gs ∨ f ∈ aaa) ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f
f : Formula
⊢ f ∈ aaa ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f
Tactic:
specialize w_Con f
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, []) ∈ H α
aaa : List Formula
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
w_Con : (f ∈ Gs ∨ f ∈ aaa) ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f
⊢ f ∈ aaa ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
δ : List Program
Gs : List Formula
Gγ_in : (Gs, []) ∈ H α
aaa : List Formula
_in_Hβ : (aaa, δ) ∈ H β
f : Formula
w_Con : (f ∈ Gs ∨ f ∈ aaa) ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f
⊢ f ∈ aaa ∨ f = (~⌈⌈δ⌉⌉ψ) → evaluate M w f
Tactic:
tauto
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
Gs : List Formula
γ : List Program
Gγ_in : (Gs, γ) ∈ H α
Gγ_in_l : (Fs, δ) ∈ if γ = [] then (List.map (fun x => [(Gs ∪ x.1, x.2)]) (H β)).join else [(Gs, γ ++ [β])]
δ_not_ε : ¬γ = ε
⊢ ∃ Fδ ∈ H α, evaluate M w (Con (Yset Fδ (⌈β⌉ψ)))
Tactic:
simp_all
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Gs : List Formula
γ : List Program
w_Con : evaluate M w (Con (Yset (Gs, γ ++ [β]) ψ))
Gγ_in : (Gs, γ) ∈ H α
Gγ_in_l : Fs = Gs ∧ δ = γ ++ [β]
δ_not_ε : ¬γ = []
⊢ ∃ a b, (a, b) ∈ H α ∧ evaluate M w (Con (Yset (a, b) (⌈β⌉ψ)))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Gs : List Formula
γ : List Program
w_Con : evaluate M w (Con (Yset (Gs, γ ++ [β]) ψ))
Gγ_in : (Gs, γ) ∈ H α
Gγ_in_l : Fs = Gs ∧ δ = γ ++ [β]
δ_not_ε : ¬γ = []
⊢ ∃ a b, (a, b) ∈ H α ∧ evaluate M w (Con (Yset (a, b) (⌈β⌉ψ)))
Tactic:
cases Gγ_in_l
State after:
case intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Gs : List Formula
γ : List Program
w_Con : evaluate M w (Con (Yset (Gs, γ ++ [β]) ψ))
Gγ_in : (Gs, γ) ∈ H α
δ_not_ε : ¬γ = []
left✝ : Fs = Gs
right✝ : δ = γ ++ [β]
⊢ ∃ a b, (a, b) ∈ H α ∧ evaluate M w (Con (Yset (a, b) (⌈β⌉ψ)))

State before:
case intro
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
δ : List Program
Gs : List Formula
γ : List Program
w_Con : evaluate M w (Con (Yset (Gs, γ ++ [β]) ψ))
Gγ_in : (Gs, γ) ∈ H α
δ_not_ε : ¬γ = []
left✝ : Fs = Gs
right✝ : δ = γ ++ [β]
⊢ ∃ a b, (a, b) ∈ H α ∧ evaluate M w (Con (Yset (a, b) (⌈β⌉ψ)))
Tactic:
subst_eqs
State after:
case intro.refl.refl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
γ : List Program
δ_not_ε : ¬γ = []
w_Con : evaluate M w (Con (Yset (Fs, γ ++ [β]) ψ))
Gγ_in : (Fs, γ) ∈ H α
⊢ ∃ a b, (a, b) ∈ H α ∧ evaluate M w (Con (Yset (a, b) (⌈β⌉ψ)))

State before:
case intro.refl.refl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
γ : List Program
δ_not_ε : ¬γ = []
w_Con : evaluate M w (Con (Yset (Fs, γ ++ [β]) ψ))
Gγ_in : (Fs, γ) ∈ H α
⊢ ∃ a b, (a, b) ∈ H α ∧ evaluate M w (Con (Yset (a, b) (⌈β⌉ψ)))
Tactic:
simp_all [Yset, conEval, boxes_append]
State after:
case intro.refl.refl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
γ : List Program
δ_not_ε : ¬γ = []
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ⌉⌉⌈β⌉ψ) → evaluate M w f
Gγ_in : (Fs, γ) ∈ H α
⊢ ∃ a b, (a, b) ∈ H α ∧ ∀ (f : Formula), f ∈ a ∨ f = (~⌈⌈b⌉⌉⌈β⌉ψ) → evaluate M w f

State before:
case intro.refl.refl
ψ : Formula
W : Type
M : KripkeModel W
w : W
α β : Program
Fs : List Formula
γ : List Program
δ_not_ε : ¬γ = []
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ⌉⌉⌈β⌉ψ) → evaluate M w f
Gγ_in : (Fs, γ) ∈ H α
⊢ ∃ a b, (a, b) ∈ H α ∧ ∀ (f : Formula), f ∈ a ∨ f = (~⌈⌈b⌉⌉⌈β⌉ψ) → evaluate M w f
Tactic:
use Fs, γ
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
β : Program
⊢ evaluate M w (~⌈∗β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β))))
Tactic:
let ρ := dis ((H (∗β)).map (fun Fδ => Con (Yset Fδ ψ)))
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
⊢ evaluate M w (~⌈∗β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β))))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
⊢ evaluate M w (~⌈∗β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β))))
Tactic:
suffices goal : (~⌈∗β⌉ψ) ≡ ρ by
  have := @equiv_iff _ _ goal W M w
  simp only [modelCanSemImplyForm, evaluatePoint] at this
  rw [this]
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
⊢ (~⌈∗β⌉ψ)≡ρ

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
⊢ (~⌈∗β⌉ψ)≡ρ
Tactic:
have right_to_left_claim : ∀ W M (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ) := by
  clear W M w; intro W M w
  unfold_let ρ
  rw [disEval, helper]
  rintro ⟨⟨Fs,δ⟩, ⟨Fδ_in, w_Con⟩⟩
  rw [conEval] at w_Con
  simp [H] at Fδ_in
  cases Fδ_in
  case inl hyp =>
    cases hyp
    subst_eqs
    simp_all [Yset]
    use w
  case inr hyp =>
    have : ∃ γ, δ = γ ++ [∗β] ∧ γ ≠ ε ∧ (Fs,γ) ∈ H β := by aesop
    rcases this with ⟨γ, ⟨δ_def, _, Fγ_in⟩⟩
    subst δ_def
    simp only [Yset, List.mem_union_iff, List.mem_singleton] at w_Con
    have := w_Con (~⌈⌈γ ++ [∗β]⌉⌉ψ)
    simp at this
    suffices evaluate M w (~⌈β⌉⌈∗β⌉ψ) by
      simp at *
      rcases this with ⟨v, ⟨w_β_v, ⟨u, ⟨v_Sβ_u, u_nPsi⟩⟩⟩⟩
      refine ⟨u, ?_, u_nPsi⟩
      exact Relation.ReflTransGen.head w_β_v v_Sβ_u
    have IHβ := localDiamondTruth β (⌈∗β⌉ψ) W M w
    rw [disEval, helper] at IHβ
    rw [IHβ]
    refine ⟨⟨Fs, γ⟩, ⟨Fγ_in, ?_⟩⟩
    simp_all [conEval, Yset, boxes_append]
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
⊢ (~⌈∗β⌉ψ)≡ρ

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
⊢ (~⌈∗β⌉ψ)≡ρ
Tactic:
clear W M w
State after:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
⊢ (~⌈∗β⌉ψ)≡ρ

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
⊢ (~⌈∗β⌉ψ)≡ρ
Tactic:
intro W M w
State after:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w (~⌈∗β⌉ψ) ↔ evaluate M w ρ

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w (~⌈∗β⌉ψ) ↔ evaluate M w ρ
Tactic:
constructor
State after:
case mp
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ

case mpr
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
goal : (~⌈∗β⌉ψ)≡ρ
⊢ evaluate M w (~⌈∗β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β))))
Tactic:
have := @equiv_iff _ _ goal W M w
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
goal : (~⌈∗β⌉ψ)≡ρ
this : (M, w)⊨(~⌈∗β⌉ψ) ↔ (M, w)⊨ρ
⊢ evaluate M w (~⌈∗β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β))))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
goal : (~⌈∗β⌉ψ)≡ρ
this : (M, w)⊨(~⌈∗β⌉ψ) ↔ (M, w)⊨ρ
⊢ evaluate M w (~⌈∗β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β))))
Tactic:
simp only [modelCanSemImplyForm, evaluatePoint] at this
State after:
ψ : Formula
W : Type
M : KripkeModel W
w : W
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
goal : (~⌈∗β⌉ψ)≡ρ
this : evaluate M w (~⌈∗β⌉ψ) ↔ evaluate M w ρ
⊢ evaluate M w (~⌈∗β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β))))

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
goal : (~⌈∗β⌉ψ)≡ρ
this : evaluate M w (~⌈∗β⌉ψ) ↔ evaluate M w ρ
⊢ evaluate M w (~⌈∗β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β))))
Tactic:
rw [this]
State after:
no goals

State before:
ψ : Formula
W : Type
M : KripkeModel W
w : W
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
⊢ ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
Tactic:
clear W M w
State after:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
⊢ ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
⊢ ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
Tactic:
intro W M w
State after:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
Tactic:
unfold_let ρ
State after:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))) → evaluate M w (~⌈∗β⌉ψ)

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))) → evaluate M w (~⌈∗β⌉ψ)
Tactic:
rw [disEval, helper]
State after:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
⊢ (∃ Fδ ∈ H (∗β), evaluate M w (Con (Yset Fδ ψ))) → evaluate M w (~⌈∗β⌉ψ)

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
⊢ (∃ Fδ ∈ H (∗β), evaluate M w (Con (Yset Fδ ψ))) → evaluate M w (~⌈∗β⌉ψ)
Tactic:
rintro ⟨⟨Fs,δ⟩, ⟨Fδ_in, w_Con⟩⟩
State after:
case intro.mk.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H (∗β)
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
⊢ evaluate M w (~⌈∗β⌉ψ)

State before:
case intro.mk.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H (∗β)
w_Con : evaluate M w (Con (Yset (Fs, δ) ψ))
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
rw [conEval] at w_Con
State after:
case intro.mk.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H (∗β)
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
⊢ evaluate M w (~⌈∗β⌉ψ)

State before:
case intro.mk.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H (∗β)
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
simp [H] at Fδ_in
State after:
case intro.mk.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
Fδ_in : Fs = [] ∧ δ = [] ∨ ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, δ) ∈ l
⊢ evaluate M w (~⌈∗β⌉ψ)

State before:
case intro.mk.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
Fδ_in : Fs = [] ∧ δ = [] ∨ ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, δ) ∈ l
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
cases Fδ_in
State after:
case intro.mk.intro.inl
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
h✝ : Fs = [] ∧ δ = []
⊢ evaluate M w (~⌈∗β⌉ψ)

case intro.mk.intro.inr
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
h✝ : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, δ) ∈ l
⊢ evaluate M w (~⌈∗β⌉ψ)

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
hyp : Fs = [] ∧ δ = []
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
case inl hyp =>
  cases hyp
  subst_eqs
  simp_all [Yset]
  use w
State after:
no goals

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, δ) ∈ l
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
case inr hyp =>
  have : ∃ γ, δ = γ ++ [∗β] ∧ γ ≠ ε ∧ (Fs,γ) ∈ H β := by aesop
  rcases this with ⟨γ, ⟨δ_def, _, Fγ_in⟩⟩
  subst δ_def
  simp only [Yset, List.mem_union_iff, List.mem_singleton] at w_Con
  have := w_Con (~⌈⌈γ ++ [∗β]⌉⌉ψ)
  simp at this
  suffices evaluate M w (~⌈β⌉⌈∗β⌉ψ) by
    simp at *
    rcases this with ⟨v, ⟨w_β_v, ⟨u, ⟨v_Sβ_u, u_nPsi⟩⟩⟩⟩
    refine ⟨u, ?_, u_nPsi⟩
    exact Relation.ReflTransGen.head w_β_v v_Sβ_u
  have IHβ := localDiamondTruth β (⌈∗β⌉ψ) W M w
  rw [disEval, helper] at IHβ
  rw [IHβ]
  refine ⟨⟨Fs, γ⟩, ⟨Fγ_in, ?_⟩⟩
  simp_all [conEval, Yset, boxes_append]
State after:
no goals

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
hyp : Fs = [] ∧ δ = []
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
cases hyp
State after:
case intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
left✝ : Fs = []
right✝ : δ = []
⊢ evaluate M w (~⌈∗β⌉ψ)

State before:
case intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
left✝ : Fs = []
right✝ : δ = []
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
subst_eqs
State after:
case intro.refl.refl
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
w_Con : ∀ f ∈ Yset ([], []) ψ, evaluate M w f
⊢ evaluate M w (~⌈∗β⌉ψ)

State before:
case intro.refl.refl
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
w_Con : ∀ f ∈ Yset ([], []) ψ, evaluate M w f
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
simp_all [Yset]
State after:
case intro.refl.refl
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
w_Con : ¬evaluate M w ψ
⊢ ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ

State before:
case intro.refl.refl
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
w_Con : ¬evaluate M w ψ
⊢ ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
Tactic:
use w
State after:
no goals

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, δ) ∈ l
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
have : ∃ γ, δ = γ ++ [∗β] ∧ γ ≠ ε ∧ (Fs,γ) ∈ H β := by aesop
State after:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, δ) ∈ l
this : ∃ γ, δ = γ ++ [∗β] ∧ γ ≠ ε ∧ (Fs, γ) ∈ H β
⊢ evaluate M w (~⌈∗β⌉ψ)

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, δ) ∈ l
this : ∃ γ, δ = γ ++ [∗β] ∧ γ ≠ ε ∧ (Fs, γ) ∈ H β
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
rcases this with ⟨γ, ⟨δ_def, _, Fγ_in⟩⟩
State after:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, δ) ∈ l
γ : List Program
δ_def : δ = γ ++ [∗β]
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
⊢ evaluate M w (~⌈∗β⌉ψ)

State before:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, δ) ∈ l
γ : List Program
δ_def : δ = γ ++ [∗β]
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
subst δ_def
State after:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
w_Con : ∀ f ∈ Yset (Fs, γ ++ [∗β]) ψ, evaluate M w f
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
⊢ evaluate M w (~⌈∗β⌉ψ)

State before:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
w_Con : ∀ f ∈ Yset (Fs, γ ++ [∗β]) ψ, evaluate M w f
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
simp only [Yset, List.mem_union_iff, List.mem_singleton] at w_Con
State after:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
⊢ evaluate M w (~⌈∗β⌉ψ)

State before:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
have := w_Con (~⌈⌈γ ++ [∗β]⌉⌉ψ)
State after:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : (~⌈⌈γ ++ [∗β]⌉⌉ψ) ∈ Fs ∨ (~⌈⌈γ ++ [∗β]⌉⌉ψ) = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w (~⌈⌈γ ++ [∗β]⌉⌉ψ)
⊢ evaluate M w (~⌈∗β⌉ψ)

State before:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : (~⌈⌈γ ++ [∗β]⌉⌉ψ) ∈ Fs ∨ (~⌈⌈γ ++ [∗β]⌉⌉ψ) = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w (~⌈⌈γ ++ [∗β]⌉⌉ψ)
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
simp at this
State after:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
⊢ evaluate M w (~⌈∗β⌉ψ)

State before:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
suffices evaluate M w (~⌈β⌉⌈∗β⌉ψ) by
  simp at *
  rcases this with ⟨v, ⟨w_β_v, ⟨u, ⟨v_Sβ_u, u_nPsi⟩⟩⟩⟩
  refine ⟨u, ?_, u_nPsi⟩
  exact Relation.ReflTransGen.head w_β_v v_Sβ_u
State after:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
⊢ evaluate M w (~⌈β⌉⌈∗β⌉ψ)

State before:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
⊢ evaluate M w (~⌈β⌉⌈∗β⌉ψ)
Tactic:
have IHβ := localDiamondTruth β (⌈∗β⌉ψ) W M w
State after:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
IHβ : evaluate M w (~⌈β⌉⌈∗β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ (⌈∗β⌉ψ))) (H β)))
⊢ evaluate M w (~⌈β⌉⌈∗β⌉ψ)

State before:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
IHβ : evaluate M w (~⌈β⌉⌈∗β⌉ψ) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ (⌈∗β⌉ψ))) (H β)))
⊢ evaluate M w (~⌈β⌉⌈∗β⌉ψ)
Tactic:
rw [disEval, helper] at IHβ
State after:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
IHβ : evaluate M w (~⌈β⌉⌈∗β⌉ψ) ↔ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (⌈∗β⌉ψ)))
⊢ evaluate M w (~⌈β⌉⌈∗β⌉ψ)

State before:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
IHβ : evaluate M w (~⌈β⌉⌈∗β⌉ψ) ↔ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (⌈∗β⌉ψ)))
⊢ evaluate M w (~⌈β⌉⌈∗β⌉ψ)
Tactic:
rw [IHβ]
State after:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
IHβ : evaluate M w (~⌈β⌉⌈∗β⌉ψ) ↔ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (⌈∗β⌉ψ)))
⊢ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (⌈∗β⌉ψ)))

State before:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
IHβ : evaluate M w (~⌈β⌉⌈∗β⌉ψ) ↔ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (⌈∗β⌉ψ)))
⊢ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (⌈∗β⌉ψ)))
Tactic:
refine ⟨⟨Fs, γ⟩, ⟨Fγ_in, ?_⟩⟩
State after:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
IHβ : evaluate M w (~⌈β⌉⌈∗β⌉ψ) ↔ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (⌈∗β⌉ψ)))
⊢ evaluate M w (Con (Yset (Fs, γ) (⌈∗β⌉ψ)))

State before:
case intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
IHβ : evaluate M w (~⌈β⌉⌈∗β⌉ψ) ↔ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (⌈∗β⌉ψ)))
⊢ evaluate M w (Con (Yset (Fs, γ) (⌈∗β⌉ψ)))
Tactic:
simp_all [conEval, Yset, boxes_append]
State after:
no goals

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
w_Con : ∀ f ∈ Yset (Fs, δ) ψ, evaluate M w f
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, δ) ∈ l
⊢ ∃ γ, δ = γ ++ [∗β] ∧ γ ≠ ε ∧ (Fs, γ) ∈ H β
Tactic:
aesop
State after:
no goals

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : γ ≠ ε
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this✝ : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
this : evaluate M w (~⌈β⌉⌈∗β⌉ψ)
⊢ evaluate M w (~⌈∗β⌉ψ)
Tactic:
simp at *
State after:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : ¬γ = []
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this✝ : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
this : ∃ x, relate M β w x ∧ ∃ x_1, Relation.ReflTransGen (relate M β) x x_1 ∧ ¬evaluate M x_1 ψ
⊢ ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : ¬γ = []
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this✝ : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
this : ∃ x, relate M β w x ∧ ∃ x_1, Relation.ReflTransGen (relate M β) x x_1 ∧ ¬evaluate M x_1 ψ
⊢ ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
Tactic:
rcases this with ⟨v, ⟨w_β_v, ⟨u, ⟨v_Sβ_u, u_nPsi⟩⟩⟩⟩
State after:
case intro.intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : ¬γ = []
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
v : W
w_β_v : relate M β w v
u : W
v_Sβ_u : Relation.ReflTransGen (relate M β) v u
u_nPsi : ¬evaluate M u ψ
⊢ ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ

State before:
case intro.intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : ¬γ = []
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
v : W
w_β_v : relate M β w v
u : W
v_Sβ_u : Relation.ReflTransGen (relate M β) v u
u_nPsi : ¬evaluate M u ψ
⊢ ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
Tactic:
refine ⟨u, ?_, u_nPsi⟩
State after:
case intro.intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : ¬γ = []
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
v : W
w_β_v : relate M β w v
u : W
v_Sβ_u : Relation.ReflTransGen (relate M β) v u
u_nPsi : ¬evaluate M u ψ
⊢ Relation.ReflTransGen (relate M β) w u

State before:
case intro.intro.intro.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
γ : List Program
left✝ : ¬γ = []
Fγ_in : (Fs, γ) ∈ H β
hyp : ∃ l, (∃ a b, (a, b) ∈ H β ∧ (if b = [] then [] else [(a, b ++ [∗β])]) = l) ∧ (Fs, γ ++ [∗β]) ∈ l
w_Con : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈γ ++ [∗β]⌉⌉ψ) → evaluate M w f
this : ¬evaluate M w (⌈⌈γ ++ [∗β]⌉⌉ψ)
v : W
w_β_v : relate M β w v
u : W
v_Sβ_u : Relation.ReflTransGen (relate M β) v u
u_nPsi : ¬evaluate M u ψ
⊢ Relation.ReflTransGen (relate M β) w u
Tactic:
exact Relation.ReflTransGen.head w_β_v v_Sβ_u
State after:
no goals

State before:
case mp
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ
Tactic:
let x : Nat := freshVarProg β
State after:
case mp
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
x : ℕ := freshVarProg β
⊢ evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ

State before:
case mp
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
x : ℕ := freshVarProg β
⊢ evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ
Tactic:
have x_not_in : x ∉ HasVocabulary.voc β := by apply freshVarProg_is_fresh
State after:
case mp
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
⊢ evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ

State before:
case mp
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
⊢ evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ
Tactic:
let σ0 : Formula := dis $
  (H β).map (fun (F,δ) => if δ = ε then Con F else ⊥)
State after:
case mp
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
⊢ evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ

State before:
case mp
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
⊢ evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ
Tactic:
have := @guardToStarDiamond β σ0 σ1 ρ ψ x x_not_in
State after:
case mp
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
this : (~⌈β⌉~·x)≡(·x)⋀σ0⋁σ1 → repl_in_F x ρ σ1⊨ρ → (~ψ)⊨ρ → (~⌈∗β⌉ψ)⊨ρ
⊢ evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ

State before:
case mp
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
this : (~⌈β⌉~·x)≡(·x)⋀σ0⋁σ1 → repl_in_F x ρ σ1⊨ρ → (~ψ)⊨ρ → (~⌈∗β⌉ψ)⊨ρ
⊢ evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ
Tactic:
simp only [formCanSemImplyForm, semImpliesLists, List.mem_singleton, forall_eq] at this
State after:
case mp
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
this :
  (~⌈β⌉~·x)≡(·x)⋀σ0⋁σ1 →
    (∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w (repl_in_F x ρ σ1) → evaluate M w ρ) →
      (∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w (~ψ) → evaluate M w ρ) →
        ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ
⊢ evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ

State before:
case mp
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
this :
  (~⌈β⌉~·x)≡(·x)⋀σ0⋁σ1 →
    (∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w (repl_in_F x ρ σ1) → evaluate M w ρ) →
      (∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w (~ψ) → evaluate M w ρ) →
        ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ
⊢ evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ
Tactic:
apply this <;> (clear this W M w; intro W M w)
State after:
case mp.beta_equiv
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w (~⌈β⌉~·x) ↔ evaluate M w ((·x)⋀σ0⋁σ1)

case mp.repl_imp_rho
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w (repl_in_F x ρ σ1) → evaluate M w ρ

case mp.notPsi_imp_rho
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w (~ψ) → evaluate M w ρ

State before:
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
x : ℕ := freshVarProg β
⊢ x ∉ voc β
Tactic:
apply freshVarProg_is_fresh
State after:
no goals

State before:
case mp.notPsi_imp_rho
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
W : Type
M : KripkeModel W
w : W
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
this :
  (~⌈β⌉~·x)≡(·x)⋀σ0⋁σ1 →
    (∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w (repl_in_F x ρ σ1) → evaluate M w ρ) →
      (∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w (~ψ) → evaluate M w ρ) →
        ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w (~⌈∗β⌉ψ) → evaluate M w ρ
⊢ ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w (~ψ) → evaluate M w ρ
Tactic:
clear this W M w
State after:
case mp.notPsi_imp_rho
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
⊢ ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w (~ψ) → evaluate M w ρ

State before:
case mp.notPsi_imp_rho
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
⊢ ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w (~ψ) → evaluate M w ρ
Tactic:
intro W M w
State after:
case mp.notPsi_imp_rho
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w (~ψ) → evaluate M w ρ

State before:
case mp.beta_equiv
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
IHβ : evaluate M w (~⌈β⌉~·x) ↔ evaluate M w (dis (List.map (fun Fδ => Con (Yset Fδ (~·x))) (H β)))
⊢ evaluate M w (~⌈β⌉~·x) ↔ evaluate M w ((·x)⋀σ0⋁σ1)
Tactic:
rw [disEval,helper] at IHβ
State after:
case mp.beta_equiv
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
IHβ : evaluate M w (~⌈β⌉~·x) ↔ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))
⊢ evaluate M w (~⌈β⌉~·x) ↔ evaluate M w ((·x)⋀σ0⋁σ1)

State before:
case mp.beta_equiv
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
IHβ : evaluate M w (~⌈β⌉~·x) ↔ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))
⊢ evaluate M w (~⌈β⌉~·x) ↔ evaluate M w ((·x)⋀σ0⋁σ1)
Tactic:
rw [IHβ]
State after:
case mp.beta_equiv
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
IHβ : evaluate M w (~⌈β⌉~·x) ↔ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))
⊢ (∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))) ↔ evaluate M w ((·x)⋀σ0⋁σ1)

State before:
case mp.beta_equiv
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
IHβ : evaluate M w (~⌈β⌉~·x) ↔ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))
⊢ (∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))) ↔ evaluate M w ((·x)⋀σ0⋁σ1)
Tactic:
clear IHβ
State after:
case mp.beta_equiv
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
⊢ (∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))) ↔ evaluate M w ((·x)⋀σ0⋁σ1)

State before:
case mp.beta_equiv
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
⊢ (∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))) ↔ evaluate M w ((·x)⋀σ0⋁σ1)
Tactic:
constructor
State after:
case mp.beta_equiv.mp
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
⊢ (∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))) → evaluate M w ((·x)⋀σ0⋁σ1)

case mp.beta_equiv.mpr
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w ((·x)⋀σ0⋁σ1) → ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))

State before:
case mp.beta_equiv.mp
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
⊢ (∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))) → evaluate M w ((·x)⋀σ0⋁σ1)
Tactic:
rintro ⟨⟨Fs, δ⟩, Fδ_in, w_⟩
State after:
case mp.beta_equiv.mp.intro.mk.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
w_ : evaluate M w (Con (Yset (Fs, δ) (~·x)))
⊢ evaluate M w ((·x)⋀σ0⋁σ1)

State before:
case mp.beta_equiv.mp.intro.mk.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
w_ : evaluate M w (Con (Yset (Fs, δ) (~·x)))
⊢ evaluate M w ((·x)⋀σ0⋁σ1)
Tactic:
simp only [evaluate, Formula.or]
State after:
case mp.beta_equiv.mp.intro.mk.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
w_ : evaluate M w (Con (Yset (Fs, δ) (~·x)))
⊢ ¬(¬(M.val w x ∧ evaluate M w σ0) ∧ ¬evaluate M w σ1)

State before:
case mp.beta_equiv.mp.intro.mk.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
w_ : evaluate M w (Con (Yset (Fs, δ) (~·x)))
⊢ ¬(¬(M.val w x ∧ evaluate M w σ0) ∧ ¬evaluate M w σ1)
Tactic:
rw [← or_iff_not_and_not]
State after:
case mp.beta_equiv.mp.intro.mk.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
w_ : evaluate M w (Con (Yset (Fs, δ) (~·x)))
⊢ M.val w x ∧ evaluate M w σ0 ∨ evaluate M w σ1

State before:
case mp.beta_equiv.mp.intro.mk.intro
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
w_ : evaluate M w (Con (Yset (Fs, δ) (~·x)))
⊢ M.val w x ∧ evaluate M w σ0 ∨ evaluate M w σ1
Tactic:
cases em (δ = ε)
State after:
case mp.beta_equiv.mp.intro.mk.intro.inl
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
w_ : evaluate M w (Con (Yset (Fs, δ) (~·x)))
h✝ : δ = ε
⊢ M.val w x ∧ evaluate M w σ0 ∨ evaluate M w σ1

case mp.beta_equiv.mp.intro.mk.intro.inr
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
w_ : evaluate M w (Con (Yset (Fs, δ) (~·x)))
h✝ : ¬δ = ε
⊢ M.val w x ∧ evaluate M w σ0 ∨ evaluate M w σ1

State before:
case mp.beta_equiv.mp.intro.mk.intro.inl
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
w_ : evaluate M w (Con (Yset (Fs, δ) (~·x)))
h✝ : δ = ε
⊢ M.val w x ∧ evaluate M w σ0 ∨ evaluate M w σ1
Tactic:
subst_eqs
State after:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H β
w_ : evaluate M w (Con (Yset (Fs, ε) (~·x)))
⊢ M.val w x ∧ evaluate M w σ0 ∨ evaluate M w σ1

State before:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H β
w_ : evaluate M w (Con (Yset (Fs, ε) (~·x)))
⊢ M.val w x ∧ evaluate M w σ0 ∨ evaluate M w σ1
Tactic:
simp [conEval, Yset] at w_
State after:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ M.val w x ∧ evaluate M w σ0 ∨ evaluate M w σ1

State before:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ M.val w x ∧ evaluate M w σ0 ∨ evaluate M w σ1
Tactic:
left
State after:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ M.val w x ∧ evaluate M w σ0

State before:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ M.val w x ∧ evaluate M w σ0
Tactic:
unfold_let σ0
State after:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ M.val w x ∧
    evaluate M w
      (dis
        (List.map
          (fun x =>
            match x with
            | (F, δ) => if δ = ε then Con F else ⊥)
          (H β)))

State before:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
Fδ_in : (Fs, ε) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ M.val w x ∧
    evaluate M w
      (dis
        (List.map
          (fun x =>
            match x with
            | (F, δ) => if δ = ε then Con F else ⊥)
          (H β)))
Tactic:
simp_all
State after:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ M.val w x ∧ evaluate M w (dis (List.map (fun x => if x.2 = [] then Con x.1 else Formula.bottom) (H β)))

State before:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ M.val w x ∧ evaluate M w (dis (List.map (fun x => if x.2 = [] then Con x.1 else Formula.bottom) (H β)))
Tactic:
rw [disEval, helper]
State after:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ M.val w x ∧ ∃ Fδ ∈ H β, evaluate M w (if Fδ.2 = [] then Con Fδ.1 else Formula.bottom)

State before:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ M.val w x ∧ ∃ Fδ ∈ H β, evaluate M w (if Fδ.2 = [] then Con Fδ.1 else Formula.bottom)
Tactic:
constructor
State after:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl.h.left
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ M.val w x

case mp.beta_equiv.mp.intro.mk.intro.inl.refl.h.right
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ ∃ Fδ ∈ H β, evaluate M w (if Fδ.2 = [] then Con Fδ.1 else Formula.bottom)

State before:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl.h.left
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
this : (~~·x) ∈ Fs ∨ (~~·x) = (~~·x) → evaluate M w (~~·x)
⊢ M.val w x
Tactic:
simp at this
State after:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl.h.left
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
this : M.val w x
⊢ M.val w x

State before:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl.h.left
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
this : M.val w x
⊢ M.val w x
Tactic:
exact this
State after:
no goals

State before:
case mp.beta_equiv.mp.intro.mk.intro.inl.refl.h.right
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ ∃ Fδ ∈ H β, evaluate M w (if Fδ.2 = [] then Con Fδ.1 else Formula.bottom)
Tactic:
use (Fs, ε)
State after:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ (Fs, ε) ∈ H β ∧ evaluate M w (if (Fs, ε).2 = [] then Con (Fs, ε).1 else Formula.bottom)

State before:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ (Fs, ε) ∈ H β ∧ evaluate M w (if (Fs, ε).2 = [] then Con (Fs, ε).1 else Formula.bottom)
Tactic:
simp_all
State after:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ evaluate M w (Con Fs)

State before:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ evaluate M w (Con Fs)
Tactic:
rw [conEval]
State after:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ ∀ f ∈ Fs, evaluate M w f

State before:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
⊢ ∀ f ∈ Fs, evaluate M w f
Tactic:
intro f f_in
State after:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
f : Formula
f_in : f ∈ Fs
⊢ evaluate M w f

State before:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
f : Formula
f_in : f ∈ Fs
⊢ evaluate M w f
Tactic:
apply w_
State after:
case h.a
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
f : Formula
f_in : f ∈ Fs
⊢ f ∈ Fs ∨ f = (~~·x)

State before:
case h.a
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
f : Formula
f_in : f ∈ Fs
⊢ f ∈ Fs ∨ f = (~~·x)
Tactic:
left
State after:
case h.a.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
f : Formula
f_in : f ∈ Fs
⊢ f ∈ Fs

State before:
case h.a.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, []) ∈ H β
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~~·x) → evaluate M w f
f : Formula
f_in : f ∈ Fs
⊢ f ∈ Fs
Tactic:
exact f_in
State after:
no goals

State before:
case mp.beta_equiv.mp.intro.mk.intro.inr
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
w_ : evaluate M w (Con (Yset (Fs, δ) (~·x)))
h✝ : ¬δ = ε
⊢ M.val w x ∧ evaluate M w σ0 ∨ evaluate M w σ1
Tactic:
simp [conEval, Yset] at w_
State after:
case mp.beta_equiv.mp.intro.mk.intro.inr
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = ε
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ M.val w x ∧ evaluate M w σ0 ∨ evaluate M w σ1

State before:
case mp.beta_equiv.mp.intro.mk.intro.inr
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = ε
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ M.val w x ∧ evaluate M w σ0 ∨ evaluate M w σ1
Tactic:
right
State after:
case mp.beta_equiv.mp.intro.mk.intro.inr.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = ε
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ evaluate M w σ1

State before:
case mp.beta_equiv.mp.intro.mk.intro.inr.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = ε
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ evaluate M w σ1
Tactic:
unfold_let σ1
State after:
case mp.beta_equiv.mp.intro.mk.intro.inr.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = ε
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ evaluate M w
    (dis
      (List.map
        (fun x_1 =>
          match x_1 with
          | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
        (H β)))

State before:
case mp.beta_equiv.mp.intro.mk.intro.inr.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = ε
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ evaluate M w
    (dis
      (List.map
        (fun x_1 =>
          match x_1 with
          | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
        (H β)))
Tactic:
simp_all
State after:
case mp.beta_equiv.mp.intro.mk.intro.inr.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ evaluate M w (dis (List.map (fun x_1 => if x_1.2 = [] then Formula.bottom else Con ((~⌈⌈x_1.2⌉⌉~·x) :: x_1.1)) (H β)))

State before:
case mp.beta_equiv.mp.intro.mk.intro.inr.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ evaluate M w (dis (List.map (fun x_1 => if x_1.2 = [] then Formula.bottom else Con ((~⌈⌈x_1.2⌉⌉~·x) :: x_1.1)) (H β)))
Tactic:
rw [disEval, helper]
State after:
case mp.beta_equiv.mp.intro.mk.intro.inr.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ ∃ Fδ ∈ H β, evaluate M w (if Fδ.2 = [] then Formula.bottom else Con ((~⌈⌈Fδ.2⌉⌉~·x) :: Fδ.1))

State before:
case mp.beta_equiv.mp.intro.mk.intro.inr.h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ ∃ Fδ ∈ H β, evaluate M w (if Fδ.2 = [] then Formula.bottom else Con ((~⌈⌈Fδ.2⌉⌉~·x) :: Fδ.1))
Tactic:
use (Fs, δ)
State after:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ (Fs, δ) ∈ H β ∧ evaluate M w (if (Fs, δ).2 = [] then Formula.bottom else Con ((~⌈⌈(Fs, δ).2⌉⌉~·x) :: (Fs, δ).1))

State before:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ (Fs, δ) ∈ H β ∧ evaluate M w (if (Fs, δ).2 = [] then Formula.bottom else Con ((~⌈⌈(Fs, δ).2⌉⌉~·x) :: (Fs, δ).1))
Tactic:
simp_all
State after:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ evaluate M w (Con ((~⌈⌈δ⌉⌉~·x) :: Fs))

State before:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ evaluate M w (Con ((~⌈⌈δ⌉⌉~·x) :: Fs))
Tactic:
rw [conEval]
State after:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ ∀ f ∈ (~⌈⌈δ⌉⌉~·x) :: Fs, evaluate M w f

State before:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
⊢ ∀ f ∈ (~⌈⌈δ⌉⌉~·x) :: Fs, evaluate M w f
Tactic:
intro f f_in
State after:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
f : Formula
f_in : f ∈ (~⌈⌈δ⌉⌉~·x) :: Fs
⊢ evaluate M w f

State before:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
f : Formula
f_in : f ∈ (~⌈⌈δ⌉⌉~·x) :: Fs
⊢ evaluate M w f
Tactic:
apply w_ f
State after:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
f : Formula
f_in : f ∈ (~⌈⌈δ⌉⌉~·x) :: Fs
⊢ f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x)

State before:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
f : Formula
f_in : f ∈ (~⌈⌈δ⌉⌉~·x) :: Fs
⊢ f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x)
Tactic:
simp at f_in
State after:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
f : Formula
f_in : f = (~⌈⌈δ⌉⌉~·x) ∨ f ∈ Fs
⊢ f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x)

State before:
case h
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
x : ℕ := freshVarProg β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
Fs : List Formula
δ : List Program
right_to_left_claim :
  ∀ (W : Type) (M : KripkeModel W) (w : W),
    evaluate M w ρ → ∃ x, Relation.ReflTransGen (relate M β) w x ∧ ¬evaluate M x ψ
x_not_in : x ∉ voc β
Fδ_in : (Fs, δ) ∈ H β
h✝ : ¬δ = []
w_ : ∀ (f : Formula), f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x) → evaluate M w f
f : Formula
f_in : f = (~⌈⌈δ⌉⌉~·x) ∨ f ∈ Fs
⊢ f ∈ Fs ∨ f = (~⌈⌈δ⌉⌉~·x)
Tactic:
tauto
State after:
no goals

State before:
case mp.beta_equiv.mpr
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
⊢ evaluate M w ((·x)⋀σ0⋁σ1) → ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))
Tactic:
intro rhs
State after:
case mp.beta_equiv.mpr
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
rhs : evaluate M w ((·x)⋀σ0⋁σ1)
⊢ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))

State before:
case mp.beta_equiv.mpr
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
rhs : evaluate M w ((·x)⋀σ0⋁σ1)
⊢ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))
Tactic:
simp only [evaluate, Formula.or] at rhs
State after:
case mp.beta_equiv.mpr
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
rhs : ¬(¬(M.val w x ∧ evaluate M w σ0) ∧ ¬evaluate M w σ1)
⊢ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))

State before:
case mp.beta_equiv.mpr
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
rhs : ¬(¬(M.val w x ∧ evaluate M w σ0) ∧ ¬evaluate M w σ1)
⊢ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))
Tactic:
rw [← or_iff_not_and_not] at rhs
State after:
case mp.beta_equiv.mpr
ψ : Formula
β : Program
ρ : Formula := dis (List.map (fun Fδ => Con (Yset Fδ ψ)) (H (∗β)))
right_to_left_claim : ∀ (W : Type) (M : KripkeModel W) (w : W), evaluate M w ρ → evaluate M w (~⌈∗β⌉ψ)
x : ℕ := freshVarProg β
x_not_in : x ∉ voc β
σ0 : Formula :=
  dis
    (List.map
      (fun x =>
        match x with
        | (F, δ) => if δ = ε then Con F else ⊥)
      (H β))
σ1 : Formula :=
  dis
    (List.map
      (fun x_1 =>
        match x_1 with
        | (F, δ) => if δ ≠ ε then Con ((~⌈⌈δ⌉⌉~·x) :: F) else ⊥)
      (H β))
W : Type
M : KripkeModel W
w : W
rhs : M.val w x ∧ evaluate M w σ0 ∨ evaluate M w σ1
⊢ ∃ Fδ ∈ H β, evaluate M w (Con (Yset Fδ (~·x)))