Theorem: combMo_preserves_truth_at_oldWOrld (Pdl/Soundness.lean)

State before:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
⊢ ∀ (f : Formula) (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
Tactic:
intro mF mR moW
State after:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
⊢ evaluate (combinedModel collection newVal).1 (Sum.inr ⟨mR, moW⟩) mF ↔ evaluate (collection mR).snd.2.1 moW mF

State before:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
⊢ ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) Formula.bottom ↔
      evaluate (collection R).snd.2.1 oldWorld Formula.bottom
Tactic:
simp
State after:
no goals

State before:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
⊢ ∀ (a : ℕ),
    (fun φ =>
        ∀ (R : β) (oldWorld : (collection R).fst),
          evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) φ ↔
            evaluate (collection R).snd.2.1 oldWorld φ)
      (·a)
Tactic:
aesop
State after:
no goals

State before:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
⊢ ∀ (a : Formula),
    (fun φ =>
          ∀ (R : β) (oldWorld : (collection R).fst),
            evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) φ ↔
              evaluate (collection R).snd.2.1 oldWorld φ)
        a →
      (fun φ =>
          ∀ (R : β) (oldWorld : (collection R).fst),
            evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) φ ↔
              evaluate (collection R).snd.2.1 oldWorld φ)
        (~a)
Tactic:
aesop
State after:
no goals

State before:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
⊢ ∀ (a a_1 : Formula),
    (fun φ =>
          ∀ (R : β) (oldWorld : (collection R).fst),
            evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) φ ↔
              evaluate (collection R).snd.2.1 oldWorld φ)
        a →
      (fun φ =>
            ∀ (R : β) (oldWorld : (collection R).fst),
              evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) φ ↔
                evaluate (collection R).snd.2.1 oldWorld φ)
          a_1 →
        (fun φ =>
            ∀ (R : β) (oldWorld : (collection R).fst),
              evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) φ ↔
                evaluate (collection R).snd.2.1 oldWorld φ)
          (a⋀a_1)
Tactic:
aesop
State after:
no goals

State before:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
⊢ ∀ (a : Program) (a_1 : Formula),
    (fun π =>
          (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
              relate (combinedModel collection newVal).1 π (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
                relate (collection R).snd.2.1 π oldWorld₁ oldWorld₂) ∧
            (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
                R₁ ≠ R₂ →
                  ¬relate (combinedModel collection newVal).1 π (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
              ∀ (R : β) (oldWorld : (collection R).fst),
                ¬relate (combinedModel collection newVal).1 π (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ()))
        a →
      (fun φ =>
            ∀ (R : β) (oldWorld : (collection R).fst),
              evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) φ ↔
                evaluate (collection R).snd.2.1 oldWorld φ)
          a_1 →
        (fun φ =>
            ∀ (R : β) (oldWorld : (collection R).fst),
              evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) φ ↔
                evaluate (collection R).snd.2.1 oldWorld φ)
          (⌈a⌉a_1)
Tactic:
intro α f IH_a IH_f R oldWorld
State after:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
⊢ evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) (⌈α⌉f) ↔
    evaluate (collection R).snd.2.1 oldWorld (⌈α⌉f)

State before:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
⊢ evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) (⌈α⌉f) ↔
    evaluate (collection R).snd.2.1 oldWorld (⌈α⌉f)
Tactic:
constructor
State after:
case mp
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
⊢ evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) (⌈α⌉f) →
    evaluate (collection R).snd.2.1 oldWorld (⌈α⌉f)

case mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
⊢ evaluate (collection R).snd.2.1 oldWorld (⌈α⌉f) →
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) (⌈α⌉f)

State before:
case mp
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
⊢ evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) (⌈α⌉f) →
    evaluate (collection R).snd.2.1 oldWorld (⌈α⌉f)
Tactic:
aesop
State after:
no goals

State before:
case mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
⊢ evaluate (collection R).snd.2.1 oldWorld (⌈α⌉f) →
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) (⌈α⌉f)
Tactic:
intro true_in_old
State after:
case mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old : evaluate (collection R).snd.2.1 oldWorld (⌈α⌉f)
⊢ evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) (⌈α⌉f)

State before:
case mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old : evaluate (collection R).snd.2.1 oldWorld (⌈α⌉f)
⊢ evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) (⌈α⌉f)
Tactic:
unfold evaluate at true_in_old
State after:
case mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
⊢ evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) (⌈α⌉f)

State before:
case mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
⊢ evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) (⌈α⌉f)
Tactic:
simp
State after:
case mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
⊢ (∀ (a : Unit),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl a) →
        evaluate (combinedModel collection newVal).1 (Sum.inl a) f) ∧
    ∀ (a : β) (b : (collection a).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨a, b⟩) →
        evaluate (combinedModel collection newVal).1 (Sum.inr ⟨a, b⟩) f

State before:
case mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
⊢ (∀ (a : Unit),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl a) →
        evaluate (combinedModel collection newVal).1 (Sum.inl a) f) ∧
    ∀ (a : β) (b : (collection a).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨a, b⟩) →
        evaluate (combinedModel collection newVal).1 (Sum.inr ⟨a, b⟩) f
Tactic:
constructor
State after:
case mpr.left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
⊢ ∀ (a : Unit),
    relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl a) →
      evaluate (combinedModel collection newVal).1 (Sum.inl a) f

case mpr.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
⊢ ∀ (a : β) (b : (collection a).fst),
    relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨a, b⟩) →
      evaluate (combinedModel collection newVal).1 (Sum.inr ⟨a, b⟩) f

State before:
case mpr.left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
⊢ ∀ (a : Unit),
    relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl a) →
      evaluate (combinedModel collection newVal).1 (Sum.inl a) f
Tactic:
intro newWorld
State after:
case mpr.left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
newWorld : Unit
⊢ relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl newWorld) →
    evaluate (combinedModel collection newVal).1 (Sum.inl newWorld) f

State before:
case mpr.left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
newWorld : Unit
⊢ relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl newWorld) →
    evaluate (combinedModel collection newVal).1 (Sum.inl newWorld) f
Tactic:
intro old_rel_new
State after:
case mpr.left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
newWorld : Unit
old_rel_new : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl newWorld)
⊢ evaluate (combinedModel collection newVal).1 (Sum.inl newWorld) f

State before:
case mpr.left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
newWorld : Unit
old_rel_new : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl newWorld)
⊢ evaluate (combinedModel collection newVal).1 (Sum.inl newWorld) f
Tactic:
absurd old_rel_new
State after:
case mpr.left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
newWorld : Unit
old_rel_new : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl newWorld)
⊢ ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl newWorld)

State before:
case mpr.left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
newWorld : Unit
old_rel_new : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl newWorld)
⊢ ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl newWorld)
Tactic:
rcases IH_a with ⟨IH_rel, sameR, noNewL⟩
State after:
case mpr.left.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
newWorld : Unit
old_rel_new : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl newWorld)
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl newWorld)

State before:
case mpr.left.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
newWorld : Unit
old_rel_new : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl newWorld)
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl newWorld)
Tactic:
apply noNewL
State after:
no goals

State before:
case mpr.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
⊢ ∀ (a : β) (b : (collection a).fst),
    relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨a, b⟩) →
      evaluate (combinedModel collection newVal).1 (Sum.inr ⟨a, b⟩) f
Tactic:
intro otherR otherWorld
State after:
case mpr.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
otherR : β
otherWorld : (collection otherR).fst
⊢ relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩) →
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f

State before:
case mpr.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
otherR : β
otherWorld : (collection otherR).fst
⊢ relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩) →
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f
Tactic:
intro rel_in_new_model
State after:
case mpr.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
otherR : β
otherWorld : (collection otherR).fst
rel_in_new_model : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩)
⊢ evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f

State before:
case mpr.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_f :
  ∀ (R : β) (oldWorld : (collection R).fst),
    evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, oldWorld⟩) f ↔ evaluate (collection R).snd.2.1 oldWorld f
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
otherR : β
otherWorld : (collection otherR).fst
rel_in_new_model : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩)
⊢ evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f
Tactic:
specialize IH_f otherR otherWorld
State after:
case mpr.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
otherR : β
otherWorld : (collection otherR).fst
rel_in_new_model : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩)
IH_f :
  evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f ↔
    evaluate (collection otherR).snd.2.1 otherWorld f
⊢ evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f

State before:
case mpr.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
otherR : β
otherWorld : (collection otherR).fst
rel_in_new_model : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩)
IH_f :
  evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f ↔
    evaluate (collection otherR).snd.2.1 otherWorld f
⊢ evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f
Tactic:
simp_all
State after:
case mpr.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
R : β
oldWorld : (collection R).fst
otherR : β
otherWorld : (collection otherR).fst
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        ¬R₁ = R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
rel_in_new_model : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩)
IH_f :
  evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f ↔
    evaluate (collection otherR).snd.2.1 otherWorld f
⊢ evaluate (collection otherR).snd.2.1 otherWorld f

State before:
case mpr.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
R : β
oldWorld : (collection R).fst
otherR : β
otherWorld : (collection otherR).fst
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        ¬R₁ = R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
rel_in_new_model : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩)
IH_f :
  evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f ↔
    evaluate (collection otherR).snd.2.1 otherWorld f
⊢ evaluate (collection otherR).snd.2.1 otherWorld f
Tactic:
rcases IH_a with ⟨IH_rel, sameR, noNewL⟩
State after:
case mpr.right.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
R : β
oldWorld : (collection R).fst
otherR : β
otherWorld : (collection otherR).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
rel_in_new_model : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩)
IH_f :
  evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f ↔
    evaluate (collection otherR).snd.2.1 otherWorld f
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    ¬R₁ = R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ evaluate (collection otherR).snd.2.1 otherWorld f

State before:
case mpr.right.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
R : β
oldWorld : (collection R).fst
otherR : β
otherWorld : (collection otherR).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
rel_in_new_model : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩)
IH_f :
  evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f ↔
    evaluate (collection otherR).snd.2.1 otherWorld f
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    ¬R₁ = R₂ → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ evaluate (collection otherR).snd.2.1 otherWorld f
Tactic:
specialize sameR R otherR oldWorld otherWorld
State after:
case mpr.right.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
R : β
oldWorld : (collection R).fst
otherR : β
otherWorld : (collection otherR).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
rel_in_new_model : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩)
IH_f :
  evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f ↔
    evaluate (collection otherR).snd.2.1 otherWorld f
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
sameR :
  ¬R = otherR → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩)
⊢ evaluate (collection otherR).snd.2.1 otherWorld f

State before:
case mpr.right.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
R : β
oldWorld : (collection R).fst
otherR : β
otherWorld : (collection otherR).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
rel_in_new_model : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩)
IH_f :
  evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f ↔
    evaluate (collection otherR).snd.2.1 otherWorld f
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
sameR :
  ¬R = otherR → ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩)
⊢ evaluate (collection otherR).snd.2.1 otherWorld f
Tactic:
simp_all
State after:
case mpr.right.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
R : β
oldWorld : (collection R).fst
otherR : β
otherWorld : (collection otherR).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
rel_in_new_model : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩)
IH_f :
  evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f ↔
    evaluate (collection otherR).snd.2.1 otherWorld f
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
sameR : R = otherR
⊢ evaluate (collection otherR).snd.2.1 otherWorld f

State before:
case mpr.right.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
R : β
oldWorld : (collection R).fst
otherR : β
otherWorld : (collection otherR).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
rel_in_new_model : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨otherR, otherWorld⟩)
IH_f :
  evaluate (combinedModel collection newVal).1 (Sum.inr ⟨otherR, otherWorld⟩) f ↔
    evaluate (collection otherR).snd.2.1 otherWorld f
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
sameR : R = otherR
⊢ evaluate (collection otherR).snd.2.1 otherWorld f
Tactic:
subst sameR
State after:
case mpr.right.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
otherWorld : (collection R).fst
rel_in_new_model : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨R, otherWorld⟩)
IH_f :
  evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, otherWorld⟩) f ↔
    evaluate (collection R).snd.2.1 otherWorld f
⊢ evaluate (collection R).snd.2.1 otherWorld f

State before:
case mpr.right.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
α : Program
f : Formula
R : β
oldWorld : (collection R).fst
true_in_old :
  ∀ (v : (collection R).fst), relate (collection R).snd.2.1 α oldWorld v → evaluate (collection R).snd.2.1 v f
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 α oldWorld₁ oldWorld₂
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
otherWorld : (collection R).fst
rel_in_new_model : relate (combinedModel collection newVal).1 α (Sum.inr ⟨R, oldWorld⟩) (Sum.inr ⟨R, otherWorld⟩)
IH_f :
  evaluate (combinedModel collection newVal).1 (Sum.inr ⟨R, otherWorld⟩) f ↔
    evaluate (collection R).snd.2.1 otherWorld f
⊢ evaluate (collection R).snd.2.1 otherWorld f
Tactic:
aesop
State after:
no goals

State before:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
⊢ ∀ (a : ℕ),
    (fun π =>
        (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
            relate (combinedModel collection newVal).1 π (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
              relate (collection R).snd.2.1 π oldWorld₁ oldWorld₂) ∧
          (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
              R₁ ≠ R₂ →
                ¬relate (combinedModel collection newVal).1 π (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
            ∀ (R : β) (oldWorld : (collection R).fst),
              ¬relate (combinedModel collection newVal).1 π (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ()))
      (·a)
Tactic:
intro a
State after:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
⊢ (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 (·a) oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ →
          ¬relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())

State before:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
⊢ (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 (·a) oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ →
          ¬relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
Tactic:
constructor
State after:
case left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
⊢ ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 (·a) oldWorld₁ oldWorld₂

case right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
⊢ (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
      R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
    ∀ (R : β) (oldWorld : (collection R).fst),
      ¬relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())

State before:
case left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
⊢ ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 (·a) oldWorld₁ oldWorld₂
Tactic:
intro R oldWorld₁ oldWorld₂
State after:
case left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
⊢ relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
    relate (collection R).snd.2.1 (·a) oldWorld₁ oldWorld₂

State before:
case left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
⊢ relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
    relate (collection R).snd.2.1 (·a) oldWorld₁ oldWorld₂
Tactic:
constructor <;>
( intro new_rel
  unfold relate at *
  unfold KripkeModel.Rel at *
  unfold combinedModel at *
  aesop
)
State after:
no goals

State before:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
⊢ relate (collection R).snd.2.1 (·a) oldWorld₁ oldWorld₂ →
    relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)
Tactic:
intro new_rel
State after:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
new_rel : relate (collection R).snd.2.1 (·a) oldWorld₁ oldWorld₂
⊢ relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)

State before:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
new_rel : relate (collection R).snd.2.1 (·a) oldWorld₁ oldWorld₂
⊢ relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)
Tactic:
unfold relate at *
State after:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
new_rel : (collection R).snd.2.1.Rel a oldWorld₁ oldWorld₂
⊢ (combinedModel collection newVal).1.Rel a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)

State before:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
new_rel : (collection R).snd.2.1.Rel a oldWorld₁ oldWorld₂
⊢ (combinedModel collection newVal).1.Rel a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)
Tactic:
unfold KripkeModel.Rel at *
State after:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
new_rel : (collection R).snd.2.1.2 a oldWorld₁ oldWorld₂
⊢ (combinedModel collection newVal).1.2 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)

State before:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
new_rel : (collection R).snd.2.1.2 a oldWorld₁ oldWorld₂
⊢ (combinedModel collection newVal).1.2 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)
Tactic:
unfold combinedModel at *
State after:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
new_rel : (collection R).snd.2.1.2 a oldWorld₁ oldWorld₂
⊢ ({
            val := fun world =>
              Sum.casesOn (motive := fun t => world = t → ℕ → Prop) world
                (fun val h => PUnit.casesOn (motive := fun t => val = t → ℕ → Prop) val (fun h => newVal) ⋯)
                (fun val h =>
                  Sigma.casesOn (motive := fun t => val = t → ℕ → Prop) val (fun R w h => (collection R).snd.2.1.val w)
                    ⋯)
                ⋯,
            Rel := fun prog worldOne worldTwo =>
              Sum.casesOn (motive := fun t => worldOne = t → Prop) worldOne
                (fun val h =>
                  Sum.casesOn (motive := fun t => worldTwo = t → Prop) worldTwo (fun val h => False)
                    (fun val h => HEq val.snd (collection val.fst).snd.2 ∧ HEq prog (collection val.fst).snd.1) ⋯)
                (fun val h =>
                  Sum.casesOn (motive := fun t => worldTwo = t → Prop) worldTwo (fun val h => False)
                    (fun val_1 h =>
                      Sigma.casesOn (motive := fun t => val = t → Prop) val
                        (fun kOne wOne h =>
                          Sigma.casesOn (motive := fun t => val_1 = t → Prop) val_1
                            (fun kTwo wTwo h =>
                              let_fun help := fun same =>
                                let_fun sameCol := ⋯;
                                (collection kOne).snd.2.1.Rel prog wOne (⋯.mp wTwo);
                              if same : kOne = kTwo then help same else False)
                            ⋯)
                        ⋯)
                    ⋯)
                ⋯ },
          Sum.inl ()).1.2
    a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)

State before:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
new_rel : (collection R).snd.2.1.2 a oldWorld₁ oldWorld₂
⊢ ({
            val := fun world =>
              Sum.casesOn (motive := fun t => world = t → ℕ → Prop) world
                (fun val h => PUnit.casesOn (motive := fun t => val = t → ℕ → Prop) val (fun h => newVal) ⋯)
                (fun val h =>
                  Sigma.casesOn (motive := fun t => val = t → ℕ → Prop) val (fun R w h => (collection R).snd.2.1.val w)
                    ⋯)
                ⋯,
            Rel := fun prog worldOne worldTwo =>
              Sum.casesOn (motive := fun t => worldOne = t → Prop) worldOne
                (fun val h =>
                  Sum.casesOn (motive := fun t => worldTwo = t → Prop) worldTwo (fun val h => False)
                    (fun val h => HEq val.snd (collection val.fst).snd.2 ∧ HEq prog (collection val.fst).snd.1) ⋯)
                (fun val h =>
                  Sum.casesOn (motive := fun t => worldTwo = t → Prop) worldTwo (fun val h => False)
                    (fun val_1 h =>
                      Sigma.casesOn (motive := fun t => val = t → Prop) val
                        (fun kOne wOne h =>
                          Sigma.casesOn (motive := fun t => val_1 = t → Prop) val_1
                            (fun kTwo wTwo h =>
                              let_fun help := fun same =>
                                let_fun sameCol := ⋯;
                                (collection kOne).snd.2.1.Rel prog wOne (⋯.mp wTwo);
                              if same : kOne = kTwo then help same else False)
                            ⋯)
                        ⋯)
                    ⋯)
                ⋯ },
          Sum.inl ()).1.2
    a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)
Tactic:
aesop
State after:
no goals

State before:
case right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
⊢ (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
      R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
    ∀ (R : β) (oldWorld : (collection R).fst),
      ¬relate (combinedModel collection newVal).1 (·a) (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
Tactic:
unfold combinedModel at *
State after:
case right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
⊢ (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
      R₁ ≠ R₂ →
        ¬relate
            ({
                  val := fun world =>
                    Sum.casesOn (motive := fun t => world = t → ℕ → Prop) world
                      (fun val h => PUnit.casesOn (motive := fun t => val = t → ℕ → Prop) val (fun h => newVal) ⋯)
                      (fun val h =>
                        Sigma.casesOn (motive := fun t => val = t → ℕ → Prop) val
                          (fun R w h => (collection R).snd.2.1.val w) ⋯)
                      ⋯,
                  Rel := fun prog worldOne worldTwo =>
                    Sum.casesOn (motive := fun t => worldOne = t → Prop) worldOne
                      (fun val h =>
                        Sum.casesOn (motive := fun t => worldTwo = t → Prop) worldTwo (fun val h => False)
                          (fun val h => HEq val.snd (collection val.fst).snd.2 ∧ HEq prog (collection val.fst).snd.1) ⋯)
                      (fun val h =>
                        Sum.casesOn (motive := fun t => worldTwo = t → Prop) worldTwo (fun val h => False)
                          (fun val_1 h =>
                            Sigma.casesOn (motive := fun t => val = t → Prop) val
                              (fun kOne wOne h =>
                                Sigma.casesOn (motive := fun t => val_1 = t → Prop) val_1
                                  (fun kTwo wTwo h =>
                                    let_fun help := fun same =>
                                      let_fun sameCol := ⋯;
                                      (collection kOne).snd.2.1.Rel prog wOne (⋯.mp wTwo);
                                    if same : kOne = kTwo then help same else False)
                                  ⋯)
                              ⋯)
                          ⋯)
                      ⋯ },
                Sum.inl ()).1
            (·a) (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
    ∀ (R : β) (oldWorld : (collection R).fst),
      ¬relate
          ({
                val := fun world =>
                  Sum.casesOn (motive := fun t => world = t → ℕ → Prop) world
                    (fun val h => PUnit.casesOn (motive := fun t => val = t → ℕ → Prop) val (fun h => newVal) ⋯)
                    (fun val h =>
                      Sigma.casesOn (motive := fun t => val = t → ℕ → Prop) val
                        (fun R w h => (collection R).snd.2.1.val w) ⋯)
                    ⋯,
                Rel := fun prog worldOne worldTwo =>
                  Sum.casesOn (motive := fun t => worldOne = t → Prop) worldOne
                    (fun val h =>
                      Sum.casesOn (motive := fun t => worldTwo = t → Prop) worldTwo (fun val h => False)
                        (fun val h => HEq val.snd (collection val.fst).snd.2 ∧ HEq prog (collection val.fst).snd.1) ⋯)
                    (fun val h =>
                      Sum.casesOn (motive := fun t => worldTwo = t → Prop) worldTwo (fun val h => False)
                        (fun val_1 h =>
                          Sigma.casesOn (motive := fun t => val = t → Prop) val
                            (fun kOne wOne h =>
                              Sigma.casesOn (motive := fun t => val_1 = t → Prop) val_1
                                (fun kTwo wTwo h =>
                                  let_fun help := fun same =>
                                    let_fun sameCol := ⋯;
                                    (collection kOne).snd.2.1.Rel prog wOne (⋯.mp wTwo);
                                  if same : kOne = kTwo then help same else False)
                                ⋯)
                            ⋯)
                        ⋯)
                    ⋯ },
              Sum.inl ()).1
          (·a) (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())

State before:
case right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a : ℕ
⊢ (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
      R₁ ≠ R₂ →
        ¬relate
            ({
                  val := fun world =>
                    Sum.casesOn (motive := fun t => world = t → ℕ → Prop) world
                      (fun val h => PUnit.casesOn (motive := fun t => val = t → ℕ → Prop) val (fun h => newVal) ⋯)
                      (fun val h =>
                        Sigma.casesOn (motive := fun t => val = t → ℕ → Prop) val
                          (fun R w h => (collection R).snd.2.1.val w) ⋯)
                      ⋯,
                  Rel := fun prog worldOne worldTwo =>
                    Sum.casesOn (motive := fun t => worldOne = t → Prop) worldOne
                      (fun val h =>
                        Sum.casesOn (motive := fun t => worldTwo = t → Prop) worldTwo (fun val h => False)
                          (fun val h => HEq val.snd (collection val.fst).snd.2 ∧ HEq prog (collection val.fst).snd.1) ⋯)
                      (fun val h =>
                        Sum.casesOn (motive := fun t => worldTwo = t → Prop) worldTwo (fun val h => False)
                          (fun val_1 h =>
                            Sigma.casesOn (motive := fun t => val = t → Prop) val
                              (fun kOne wOne h =>
                                Sigma.casesOn (motive := fun t => val_1 = t → Prop) val_1
                                  (fun kTwo wTwo h =>
                                    let_fun help := fun same =>
                                      let_fun sameCol := ⋯;
                                      (collection kOne).snd.2.1.Rel prog wOne (⋯.mp wTwo);
                                    if same : kOne = kTwo then help same else False)
                                  ⋯)
                              ⋯)
                          ⋯)
                      ⋯ },
                Sum.inl ()).1
            (·a) (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
    ∀ (R : β) (oldWorld : (collection R).fst),
      ¬relate
          ({
                val := fun world =>
                  Sum.casesOn (motive := fun t => world = t → ℕ → Prop) world
                    (fun val h => PUnit.casesOn (motive := fun t => val = t → ℕ → Prop) val (fun h => newVal) ⋯)
                    (fun val h =>
                      Sigma.casesOn (motive := fun t => val = t → ℕ → Prop) val
                        (fun R w h => (collection R).snd.2.1.val w) ⋯)
                    ⋯,
                Rel := fun prog worldOne worldTwo =>
                  Sum.casesOn (motive := fun t => worldOne = t → Prop) worldOne
                    (fun val h =>
                      Sum.casesOn (motive := fun t => worldTwo = t → Prop) worldTwo (fun val h => False)
                        (fun val h => HEq val.snd (collection val.fst).snd.2 ∧ HEq prog (collection val.fst).snd.1) ⋯)
                    (fun val h =>
                      Sum.casesOn (motive := fun t => worldTwo = t → Prop) worldTwo (fun val h => False)
                        (fun val_1 h =>
                          Sigma.casesOn (motive := fun t => val = t → Prop) val
                            (fun kOne wOne h =>
                              Sigma.casesOn (motive := fun t => val_1 = t → Prop) val_1
                                (fun kTwo wTwo h =>
                                  let_fun help := fun same =>
                                    let_fun sameCol := ⋯;
                                    (collection kOne).snd.2.1.Rel prog wOne (⋯.mp wTwo);
                                  if same : kOne = kTwo then help same else False)
                                ⋯)
                            ⋯)
                        ⋯)
                    ⋯ },
              Sum.inl ()).1
          (·a) (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
Tactic:
aesop
State after:
no goals

State before:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
⊢ ∀ (a a_1 : Program),
    (fun π =>
          (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
              relate (combinedModel collection newVal).1 π (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
                relate (collection R).snd.2.1 π oldWorld₁ oldWorld₂) ∧
            (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
                R₁ ≠ R₂ →
                  ¬relate (combinedModel collection newVal).1 π (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
              ∀ (R : β) (oldWorld : (collection R).fst),
                ¬relate (combinedModel collection newVal).1 π (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ()))
        a →
      (fun π =>
            (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
                relate (combinedModel collection newVal).1 π (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
                  relate (collection R).snd.2.1 π oldWorld₁ oldWorld₂) ∧
              (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
                  R₁ ≠ R₂ →
                    ¬relate (combinedModel collection newVal).1 π (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
                ∀ (R : β) (oldWorld : (collection R).fst),
                  ¬relate (combinedModel collection newVal).1 π (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ()))
          a_1 →
        (fun π =>
            (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
                relate (combinedModel collection newVal).1 π (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
                  relate (collection R).snd.2.1 π oldWorld₁ oldWorld₂) ∧
              (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
                  R₁ ≠ R₂ →
                    ¬relate (combinedModel collection newVal).1 π (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
                ∀ (R : β) (oldWorld : (collection R).fst),
                  ¬relate (combinedModel collection newVal).1 π (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ()))
          (a;'a_1)
Tactic:
intro a b IH_a IH_b
State after:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ →
          ¬relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())

State before:
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ →
          ¬relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
Tactic:
constructor
State after:
case left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂

case right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
      R₁ ≠ R₂ →
        ¬relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
    ∀ (R : β) (oldWorld : (collection R).fst),
      ¬relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())

State before:
case right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
      R₁ ≠ R₂ →
        ¬relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
    ∀ (R : β) (oldWorld : (collection R).fst),
      ¬relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
Tactic:
constructor
State after:
case right.left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)

case right.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())

State before:
case left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂
Tactic:
intro R oldWorld₁ oldWorld₂
State after:
case left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
⊢ relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
    relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂

State before:
case left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
⊢ relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
    relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂
Tactic:
constructor
State after:
case left.mp
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
⊢ relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) →
    relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂

case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂ →
    relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)

State before:
case left.mp
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
⊢ relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) →
    relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂
Tactic:
intro new_rel
State after:
case left.mp
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
new_rel : relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂

State before:
case left.mp
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
new_rel : relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂
Tactic:
unfold relate at new_rel
State after:
case left.mp
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
new_rel :
  ∃ y,
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) y ∧
      relate (combinedModel collection newVal).1 b y (Sum.inr ⟨R, oldWorld₂⟩)
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂

State before:
case left.mp
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
new_rel :
  ∃ y,
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) y ∧
      relate (combinedModel collection newVal).1 b y (Sum.inr ⟨R, oldWorld₂⟩)
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂
Tactic:
rcases new_rel with ⟨u, a_rel_u, u_rel_b⟩
State after:
case left.mp.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
u : Unit ⊕ (k : β) × (collection k).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) u
u_rel_b : relate (combinedModel collection newVal).1 b u (Sum.inr ⟨R, oldWorld₂⟩)
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂

State before:
case left.mp.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
u : Unit ⊕ (k : β) × (collection k).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) u
u_rel_b : relate (combinedModel collection newVal).1 b u (Sum.inr ⟨R, oldWorld₂⟩)
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂
Tactic:
rcases IH_a with ⟨IH_rel, sameR, noNewL⟩
State after:
case left.mp.intro.intro.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
u : Unit ⊕ (k : β) × (collection k).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) u
u_rel_b : relate (combinedModel collection newVal).1 b u (Sum.inr ⟨R, oldWorld₂⟩)
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂

State before:
case left.mp.intro.intro.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
u : Unit ⊕ (k : β) × (collection k).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) u
u_rel_b : relate (combinedModel collection newVal).1 b u (Sum.inr ⟨R, oldWorld₂⟩)
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂
Tactic:
cases' u with u_new u_old
State after:
case left.mp.intro.intro.intro.intro.inl
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
u_new : Unit
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inl u_new)
u_rel_b : relate (combinedModel collection newVal).1 b (Sum.inl u_new) (Sum.inr ⟨R, oldWorld₂⟩)
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂

case left.mp.intro.intro.intro.intro.inr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
u_old : (k : β) × (collection k).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr u_old)
u_rel_b : relate (combinedModel collection newVal).1 b (Sum.inr u_old) (Sum.inr ⟨R, oldWorld₂⟩)
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂

State before:
case left.mp.intro.intro.intro.intro.inl
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
u_new : Unit
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inl u_new)
u_rel_b : relate (combinedModel collection newVal).1 b (Sum.inl u_new) (Sum.inr ⟨R, oldWorld₂⟩)
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂
Tactic:
absurd a_rel_u
State after:
case left.mp.intro.intro.intro.intro.inl
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
u_new : Unit
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inl u_new)
u_rel_b : relate (combinedModel collection newVal).1 b (Sum.inl u_new) (Sum.inr ⟨R, oldWorld₂⟩)
⊢ ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inl u_new)

State before:
case left.mp.intro.intro.intro.intro.inl
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
u_new : Unit
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inl u_new)
u_rel_b : relate (combinedModel collection newVal).1 b (Sum.inl u_new) (Sum.inr ⟨R, oldWorld₂⟩)
⊢ ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inl u_new)
Tactic:
apply noNewL
State after:
no goals

State before:
case left.mp.intro.intro.intro.intro.inr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
u_old : (k : β) × (collection k).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr u_old)
u_rel_b : relate (combinedModel collection newVal).1 b (Sum.inr u_old) (Sum.inr ⟨R, oldWorld₂⟩)
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂
Tactic:
rcases u_old with ⟨otherR, otherWorld⟩
State after:
case left.mp.intro.intro.intro.intro.inr.mk
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
otherR : β
otherWorld : (collection otherR).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨otherR, otherWorld⟩)
u_rel_b : relate (combinedModel collection newVal).1 b (Sum.inr ⟨otherR, otherWorld⟩) (Sum.inr ⟨R, oldWorld₂⟩)
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂

State before:
case left.mp.intro.intro.intro.intro.inr.mk
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
otherR : β
otherWorld : (collection otherR).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨otherR, otherWorld⟩)
u_rel_b : relate (combinedModel collection newVal).1 b (Sum.inr ⟨otherR, otherWorld⟩) (Sum.inr ⟨R, oldWorld₂⟩)
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂
Tactic:
specialize sameR R otherR oldWorld₁ otherWorld
State after:
case left.mp.intro.intro.intro.intro.inr.mk
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
otherR : β
otherWorld : (collection otherR).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨otherR, otherWorld⟩)
u_rel_b : relate (combinedModel collection newVal).1 b (Sum.inr ⟨otherR, otherWorld⟩) (Sum.inr ⟨R, oldWorld₂⟩)
sameR :
  R ≠ otherR → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨otherR, otherWorld⟩)
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂

State before:
case left.mp.intro.intro.intro.intro.inr.mk
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
otherR : β
otherWorld : (collection otherR).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨otherR, otherWorld⟩)
u_rel_b : relate (combinedModel collection newVal).1 b (Sum.inr ⟨otherR, otherWorld⟩) (Sum.inr ⟨R, oldWorld₂⟩)
sameR :
  R ≠ otherR → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨otherR, otherWorld⟩)
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂
Tactic:
simp_all
State after:
case left.mp.intro.intro.intro.intro.inr.mk
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
otherR : β
otherWorld : (collection otherR).fst
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        ¬R₁ = R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨otherR, otherWorld⟩)
u_rel_b : relate (combinedModel collection newVal).1 b (Sum.inr ⟨otherR, otherWorld⟩) (Sum.inr ⟨R, oldWorld₂⟩)
sameR : R = otherR
⊢ ∃ y, relate (collection R).snd.2.1 a oldWorld₁ y ∧ relate (collection R).snd.2.1 b y oldWorld₂

State before:
case left.mp.intro.intro.intro.intro.inr.mk
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
otherR : β
otherWorld : (collection otherR).fst
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        ¬R₁ = R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨otherR, otherWorld⟩)
u_rel_b : relate (combinedModel collection newVal).1 b (Sum.inr ⟨otherR, otherWorld⟩) (Sum.inr ⟨R, oldWorld₂⟩)
sameR : R = otherR
⊢ ∃ y, relate (collection R).snd.2.1 a oldWorld₁ y ∧ relate (collection R).snd.2.1 b y oldWorld₂
Tactic:
subst sameR
State after:
case left.mp.intro.intro.intro.intro.inr.mk
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        ¬R₁ = R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
otherWorld : (collection R).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, otherWorld⟩)
u_rel_b : relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, otherWorld⟩) (Sum.inr ⟨R, oldWorld₂⟩)
⊢ ∃ y, relate (collection R).snd.2.1 a oldWorld₁ y ∧ relate (collection R).snd.2.1 b y oldWorld₂

State before:
case left.mp.intro.intro.intro.intro.inr.mk
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        ¬R₁ = R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
otherWorld : (collection R).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, otherWorld⟩)
u_rel_b : relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, otherWorld⟩) (Sum.inr ⟨R, oldWorld₂⟩)
⊢ ∃ y, relate (collection R).snd.2.1 a oldWorld₁ y ∧ relate (collection R).snd.2.1 b y oldWorld₂
Tactic:
aesop
State after:
no goals

State before:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
⊢ relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂ →
    relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)
Tactic:
intro old_rel
State after:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
old_rel : relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂
⊢ relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)

State before:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
old_rel : relate (collection R).snd.2.1 (a;'b) oldWorld₁ oldWorld₂
⊢ relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)
Tactic:
unfold relate at old_rel
State after:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
old_rel : ∃ y, relate (collection R).snd.2.1 a oldWorld₁ y ∧ relate (collection R).snd.2.1 b y oldWorld₂
⊢ relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)

State before:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
old_rel : ∃ y, relate (collection R).snd.2.1 a oldWorld₁ y ∧ relate (collection R).snd.2.1 b y oldWorld₂
⊢ relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩)
Tactic:
unfold relate
State after:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
old_rel : ∃ y, relate (collection R).snd.2.1 a oldWorld₁ y ∧ relate (collection R).snd.2.1 b y oldWorld₂
⊢ ∃ y,
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) y ∧
      relate (combinedModel collection newVal).1 b y (Sum.inr ⟨R, oldWorld₂⟩)

State before:
case left.mpr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ : (collection R).fst
old_rel : ∃ y, relate (collection R).snd.2.1 a oldWorld₁ y ∧ relate (collection R).snd.2.1 b y oldWorld₂
⊢ ∃ y,
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) y ∧
      relate (combinedModel collection newVal).1 b y (Sum.inr ⟨R, oldWorld₂⟩)
Tactic:
rcases old_rel with ⟨u, a_rel_u, u_rel_b⟩
State after:
case left.mpr.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ u : (collection R).fst
a_rel_u : relate (collection R).snd.2.1 a oldWorld₁ u
u_rel_b : relate (collection R).snd.2.1 b u oldWorld₂
⊢ ∃ y,
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) y ∧
      relate (combinedModel collection newVal).1 b y (Sum.inr ⟨R, oldWorld₂⟩)

State before:
case left.mpr.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ u : (collection R).fst
a_rel_u : relate (collection R).snd.2.1 a oldWorld₁ u
u_rel_b : relate (collection R).snd.2.1 b u oldWorld₂
⊢ ∃ y,
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) y ∧
      relate (combinedModel collection newVal).1 b y (Sum.inr ⟨R, oldWorld₂⟩)
Tactic:
use (Sum.inr ⟨R, u⟩)
State after:
case h
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ u : (collection R).fst
a_rel_u : relate (collection R).snd.2.1 a oldWorld₁ u
u_rel_b : relate (collection R).snd.2.1 b u oldWorld₂
⊢ relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, u⟩) ∧
    relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, u⟩) (Sum.inr ⟨R, oldWorld₂⟩)

State before:
case h
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld₁ oldWorld₂ u : (collection R).fst
a_rel_u : relate (collection R).snd.2.1 a oldWorld₁ u
u_rel_b : relate (collection R).snd.2.1 b u oldWorld₂
⊢ relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, u⟩) ∧
    relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, u⟩) (Sum.inr ⟨R, oldWorld₂⟩)
Tactic:
aesop
State after:
no goals

State before:
case right.left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
Tactic:
intro R₁ R₂ oldWorld₁ oldWorld₂ hneq hrel
State after:
case right.left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
hrel : relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
⊢ False

State before:
case right.left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
hrel : relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
⊢ False
Tactic:
unfold relate at hrel
State after:
case right.left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
hrel :
  ∃ y,
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) y ∧
      relate (combinedModel collection newVal).1 b y (Sum.inr ⟨R₂, oldWorld₂⟩)
⊢ False

State before:
case right.left
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
hrel :
  ∃ y,
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) y ∧
      relate (combinedModel collection newVal).1 b y (Sum.inr ⟨R₂, oldWorld₂⟩)
⊢ False
Tactic:
rcases hrel with ⟨u, a_rel_u, _⟩
State after:
case right.left.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
u : Unit ⊕ (k : β) × (collection k).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) u
right✝ : relate (combinedModel collection newVal).1 b u (Sum.inr ⟨R₂, oldWorld₂⟩)
⊢ False

State before:
case right.left.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
u : Unit ⊕ (k : β) × (collection k).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) u
right✝ : relate (combinedModel collection newVal).1 b u (Sum.inr ⟨R₂, oldWorld₂⟩)
⊢ False
Tactic:
rcases IH_a with ⟨IH_rel, sameR, noNewL⟩
State after:
case right.left.intro.intro.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
u : Unit ⊕ (k : β) × (collection k).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) u
right✝ : relate (combinedModel collection newVal).1 b u (Sum.inr ⟨R₂, oldWorld₂⟩)
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ False

State before:
case right.left.intro.intro.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
u : Unit ⊕ (k : β) × (collection k).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) u
right✝ : relate (combinedModel collection newVal).1 b u (Sum.inr ⟨R₂, oldWorld₂⟩)
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ False
Tactic:
cases' u with u_new u_old
State after:
case right.left.intro.intro.intro.intro.inl
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
u_new : Unit
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inl u_new)
right✝ : relate (combinedModel collection newVal).1 b (Sum.inl u_new) (Sum.inr ⟨R₂, oldWorld₂⟩)
⊢ False

case right.left.intro.intro.intro.intro.inr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
u_old : (k : β) × (collection k).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr u_old)
right✝ : relate (combinedModel collection newVal).1 b (Sum.inr u_old) (Sum.inr ⟨R₂, oldWorld₂⟩)
⊢ False

State before:
case right.left.intro.intro.intro.intro.inl
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
u_new : Unit
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inl u_new)
right✝ : relate (combinedModel collection newVal).1 b (Sum.inl u_new) (Sum.inr ⟨R₂, oldWorld₂⟩)
⊢ False
Tactic:
absurd a_rel_u
State after:
case right.left.intro.intro.intro.intro.inl
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
u_new : Unit
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inl u_new)
right✝ : relate (combinedModel collection newVal).1 b (Sum.inl u_new) (Sum.inr ⟨R₂, oldWorld₂⟩)
⊢ ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inl u_new)

State before:
case right.left.intro.intro.intro.intro.inl
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
u_new : Unit
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inl u_new)
right✝ : relate (combinedModel collection newVal).1 b (Sum.inl u_new) (Sum.inr ⟨R₂, oldWorld₂⟩)
⊢ ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inl u_new)
Tactic:
apply noNewL
State after:
no goals

State before:
case right.left.intro.intro.intro.intro.inr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
u_old : (k : β) × (collection k).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr u_old)
right✝ : relate (combinedModel collection newVal).1 b (Sum.inr u_old) (Sum.inr ⟨R₂, oldWorld₂⟩)
⊢ False
Tactic:
rcases u_old with ⟨otherR, otherWorld⟩
State after:
case right.left.intro.intro.intro.intro.inr.mk
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
otherR : β
otherWorld : (collection otherR).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨otherR, otherWorld⟩)
right✝ : relate (combinedModel collection newVal).1 b (Sum.inr ⟨otherR, otherWorld⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
⊢ False

State before:
case right.left.intro.intro.intro.intro.inr.mk
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
sameR :
  ∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
    R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
otherR : β
otherWorld : (collection otherR).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨otherR, otherWorld⟩)
right✝ : relate (combinedModel collection newVal).1 b (Sum.inr ⟨otherR, otherWorld⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
⊢ False
Tactic:
specialize sameR R₁ otherR oldWorld₁ otherWorld
State after:
case right.left.intro.intro.intro.intro.inr.mk
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
otherR : β
otherWorld : (collection otherR).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨otherR, otherWorld⟩)
right✝ : relate (combinedModel collection newVal).1 b (Sum.inr ⟨otherR, otherWorld⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
sameR :
  R₁ ≠ otherR → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨otherR, otherWorld⟩)
⊢ False

State before:
case right.left.intro.intro.intro.intro.inr.mk
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R₁ R₂ : β
oldWorld₁ : (collection R₁).fst
oldWorld₂ : (collection R₂).fst
hneq : R₁ ≠ R₂
IH_rel :
  ∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
    relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
      relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂
noNewL :
  ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
otherR : β
otherWorld : (collection otherR).fst
a_rel_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨otherR, otherWorld⟩)
right✝ : relate (combinedModel collection newVal).1 b (Sum.inr ⟨otherR, otherWorld⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)
sameR :
  R₁ ≠ otherR → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨otherR, otherWorld⟩)
⊢ False
Tactic:
simp_all
State after:
no goals

State before:
case right.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
⊢ ∀ (R : β) (oldWorld : (collection R).fst),
    ¬relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
Tactic:
intro R oldWorld
State after:
case right.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld : (collection R).fst
⊢ ¬relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())

State before:
case right.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld : (collection R).fst
⊢ ¬relate (combinedModel collection newVal).1 (a;'b) (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
Tactic:
unfold relate
State after:
case right.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld : (collection R).fst
⊢ ¬∃ y,
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) y ∧
        relate (combinedModel collection newVal).1 b y (Sum.inl ())

State before:
case right.right
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld : (collection R).fst
⊢ ¬∃ y,
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) y ∧
        relate (combinedModel collection newVal).1 b y (Sum.inl ())
Tactic:
rintro ⟨u, a_rel_to_u, b_rel_u_to⟩
State after:
case right.right.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld : (collection R).fst
u : Unit ⊕ (k : β) × (collection k).fst
a_rel_to_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) u
b_rel_u_to : relate (combinedModel collection newVal).1 b u (Sum.inl ())
⊢ False

State before:
case right.right.intro.intro
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld : (collection R).fst
u : Unit ⊕ (k : β) × (collection k).fst
a_rel_to_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) u
b_rel_u_to : relate (combinedModel collection newVal).1 b u (Sum.inl ())
⊢ False
Tactic:
cases u
State after:
case right.right.intro.intro.inl
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld : (collection R).fst
val✝ : Unit
a_rel_to_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl val✝)
b_rel_u_to : relate (combinedModel collection newVal).1 b (Sum.inl val✝) (Sum.inl ())
⊢ False

case right.right.intro.intro.inr
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld : (collection R).fst
val✝ : (k : β) × (collection k).fst
a_rel_to_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inr val✝)
b_rel_u_to : relate (combinedModel collection newVal).1 b (Sum.inr val✝) (Sum.inl ())
⊢ False

State before:
case right.right.intro.intro.inl
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld : (collection R).fst
val✝ : Unit
a_rel_to_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl val✝)
b_rel_u_to : relate (combinedModel collection newVal).1 b (Sum.inl val✝) (Sum.inl ())
⊢ False
Tactic:
absurd a_rel_to_u
State after:
case right.right.intro.intro.inl
β : Type
collection : β → (W : Type) × ℕ × KripkeModel W × W
newVal : ℕ → Prop
mF : Formula
mR : β
moW : (collection mR).fst
a b : Program
IH_a :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 a oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
IH_b :
  (∀ (R : β) (oldWorld₁ oldWorld₂ : (collection R).fst),
      relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld₁⟩) (Sum.inr ⟨R, oldWorld₂⟩) ↔
        relate (collection R).snd.2.1 b oldWorld₁ oldWorld₂) ∧
    (∀ (R₁ R₂ : β) (oldWorld₁ : (collection R₁).fst) (oldWorld₂ : (collection R₂).fst),
        R₁ ≠ R₂ → ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R₁, oldWorld₁⟩) (Sum.inr ⟨R₂, oldWorld₂⟩)) ∧
      ∀ (R : β) (oldWorld : (collection R).fst),
        ¬relate (combinedModel collection newVal).1 b (Sum.inr ⟨R, oldWorld⟩) (Sum.inl ())
R : β
oldWorld : (collection R).fst
val✝ : Unit
a_rel_to_u : relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl val✝)
b_rel_u_to : relate (combinedModel collection newVal).1 b (Sum.inl val✝) (Sum.inl ())
⊢ ¬relate (combinedModel collection newVal).1 a (Sum.inr ⟨R, oldWorld⟩) (Sum.inl val✝)