Theorem: LO.FirstOrder.Derivation.ProofList.isProper_append (Logic/FirstOrder/Computability/Calculus.lean)

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₁ l₂ : ProofList L
h₁ : l₁.isProper = true
h₂ : l₂.isProper = true
⊢ (l₁ ++ l₂).isProper = true
Tactic:
induction' l₁ with c l₁ ih
State after:
case nil
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
h₁ : isProper [] = true
⊢ ([] ++ l₂).isProper = true

case cons
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
c : Code L × List (SyntacticFormula L)
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
h₁ : isProper (c :: l₁) = true
⊢ (c :: l₁ ++ l₂).isProper = true

State before:
case nil
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
h₁ : isProper [] = true
⊢ ([] ++ l₂).isProper = true
Tactic:
simpa
State after:
no goals

State before:
case cons
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
c : Code L × List (SyntacticFormula L)
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
h₁ : isProper (c :: l₁) = true
⊢ (c :: l₁ ++ l₂).isProper = true
Tactic:
simp
State after:
case cons
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
c : Code L × List (SyntacticFormula L)
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
h₁ : isProper (c :: l₁) = true
⊢ isProper (c :: (l₁ ++ l₂)) = true

State before:
case cons
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
c : Code L × List (SyntacticFormula L)
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
h₁ : isProper (c :: l₁) = true
⊢ isProper (c :: (l₁ ++ l₂)) = true
Tactic:
rcases c with ⟨⟨⟩, Γ⟩ <;> simp[isProper] at h₁ ⊢
State after:
case cons.mk.axL
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
k✝ : ℕ
r✝ : L.Rel k✝
v✝ : Fin k✝ → SyntacticTerm L
h₁ : (isProper l₁ = true ∧ Semiformula.rel r✝ v✝ ∈ Γ) ∧ Semiformula.nrel r✝ v✝ ∈ Γ
⊢ (isProper (l₁ ++ l₂) = true ∧ Semiformula.rel r✝ v✝ ∈ Γ) ∧ Semiformula.nrel r✝ v✝ ∈ Γ

case cons.mk.verum
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
h₁ : isProper l₁ = true ∧ ⊤ ∈ Γ
⊢ isProper (l₁ ++ l₂) = true ∧ ⊤ ∈ Γ

case cons.mk.and
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
a✝¹ a✝ : SyntacticFormula L
h₁ : ((isProper l₁ = true ∧ a✝¹ ⋏ a✝ ∈ Γ) ∧ a✝¹ :: Γ ∈ sequents l₁) ∧ a✝ :: Γ ∈ sequents l₁
⊢ ((isProper (l₁ ++ l₂) = true ∧ a✝¹ ⋏ a✝ ∈ Γ) ∧ (a✝¹ :: Γ ∈ sequents l₁ ∨ a✝¹ :: Γ ∈ l₂.sequents)) ∧
    (a✝ :: Γ ∈ sequents l₁ ∨ a✝ :: Γ ∈ l₂.sequents)

case cons.mk.or
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
a✝¹ a✝ : SyntacticFormula L
h₁ : (isProper l₁ = true ∧ a✝¹ ⋎ a✝ ∈ Γ) ∧ a✝¹ :: a✝ :: Γ ∈ sequents l₁
⊢ (isProper (l₁ ++ l₂) = true ∧ a✝¹ ⋎ a✝ ∈ Γ) ∧ (a✝¹ :: a✝ :: Γ ∈ sequents l₁ ∨ a✝¹ :: a✝ :: Γ ∈ l₂.sequents)

case cons.mk.all
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
a✝ : SyntacticSemiformula L 1
h₁ : (isProper l₁ = true ∧ ∀' a✝ ∈ Γ) ∧ (Rew.hom Rew.free) a✝ :: List.map (⇑(Rew.hom ⇑)) Γ ∈ sequents l₁
⊢ (isProper (l₁ ++ l₂) = true ∧ ∀' a✝ ∈ Γ) ∧
    ((Rew.hom Rew.free) a✝ :: List.map (⇑(Rew.hom ⇑)) Γ ∈ sequents l₁ ∨
      (Rew.hom Rew.free) a✝ :: List.map (⇑(Rew.hom ⇑)) Γ ∈ l₂.sequents)

case cons.mk.ex
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
a✝¹ : SyntacticSemiformula L 1
a✝ : SyntacticTerm L
h₁ : (isProper l₁ = true ∧ ∃' a✝¹ ∈ Γ) ∧ [→ a✝].hom a✝¹ :: Γ ∈ sequents l₁
⊢ (isProper (l₁ ++ l₂) = true ∧ ∃' a✝¹ ∈ Γ) ∧ ([→ a✝].hom a✝¹ :: Γ ∈ sequents l₁ ∨ [→ a✝].hom a✝¹ :: Γ ∈ l₂.sequents)

case cons.mk.wk
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ a✝ : List (SyntacticFormula L)
h₁ : (isProper l₁ = true ∧ a✝ ⊆ Γ) ∧ a✝ ∈ sequents l₁
⊢ (isProper (l₁ ++ l₂) = true ∧ a✝ ⊆ Γ) ∧ (a✝ ∈ sequents l₁ ∨ a✝ ∈ l₂.sequents)

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
k : ℕ
r : L.Rel k
v : Fin k → SyntacticTerm L
h₁ : (isProper l₁ = true ∧ Semiformula.rel r v ∈ Γ) ∧ Semiformula.nrel r v ∈ Γ
⊢ (isProper (l₁ ++ l₂) = true ∧ Semiformula.rel r v ∈ Γ) ∧ Semiformula.nrel r v ∈ Γ
Tactic:
case axL k r v => exact ⟨⟨ih h₁.1.1, h₁.1.2⟩, h₁.2⟩
State after:
no goals

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
h₁ : isProper l₁ = true ∧ ⊤ ∈ Γ
⊢ isProper (l₁ ++ l₂) = true ∧ ⊤ ∈ Γ
Tactic:
case verum => exact ⟨ih h₁.1, h₁.2⟩
State after:
no goals

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
p q : SyntacticFormula L
h₁ : ((isProper l₁ = true ∧ p ⋏ q ∈ Γ) ∧ p :: Γ ∈ sequents l₁) ∧ q :: Γ ∈ sequents l₁
⊢ ((isProper (l₁ ++ l₂) = true ∧ p ⋏ q ∈ Γ) ∧ (p :: Γ ∈ sequents l₁ ∨ p :: Γ ∈ l₂.sequents)) ∧
    (q :: Γ ∈ sequents l₁ ∨ q :: Γ ∈ l₂.sequents)
Tactic:
case and p q => exact ⟨⟨⟨ih h₁.1.1.1, h₁.1.1.2⟩, Or.inl h₁.1.2⟩, Or.inl h₁.2⟩
State after:
no goals

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
p q : SyntacticFormula L
h₁ : (isProper l₁ = true ∧ p ⋎ q ∈ Γ) ∧ p :: q :: Γ ∈ sequents l₁
⊢ (isProper (l₁ ++ l₂) = true ∧ p ⋎ q ∈ Γ) ∧ (p :: q :: Γ ∈ sequents l₁ ∨ p :: q :: Γ ∈ l₂.sequents)
Tactic:
case or p q => exact ⟨⟨ih h₁.1.1, h₁.1.2⟩, Or.inl h₁.2⟩
State after:
no goals

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
a✝ : SyntacticSemiformula L 1
h₁ : (isProper l₁ = true ∧ ∀' a✝ ∈ Γ) ∧ (Rew.hom Rew.free) a✝ :: List.map (⇑(Rew.hom ⇑)) Γ ∈ sequents l₁
⊢ (isProper (l₁ ++ l₂) = true ∧ ∀' a✝ ∈ Γ) ∧
    ((Rew.hom Rew.free) a✝ :: List.map (⇑(Rew.hom ⇑)) Γ ∈ sequents l₁ ∨
      (Rew.hom Rew.free) a✝ :: List.map (⇑(Rew.hom ⇑)) Γ ∈ l₂.sequents)
Tactic:
case all => exact ⟨⟨ih h₁.1.1, h₁.1.2⟩, Or.inl h₁.2⟩
State after:
no goals

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
a✝¹ : SyntacticSemiformula L 1
a✝ : SyntacticTerm L
h₁ : (isProper l₁ = true ∧ ∃' a✝¹ ∈ Γ) ∧ [→ a✝].hom a✝¹ :: Γ ∈ sequents l₁
⊢ (isProper (l₁ ++ l₂) = true ∧ ∃' a✝¹ ∈ Γ) ∧ ([→ a✝].hom a✝¹ :: Γ ∈ sequents l₁ ∨ [→ a✝].hom a✝¹ :: Γ ∈ l₂.sequents)
Tactic:
case ex => exact ⟨⟨ih h₁.1.1, h₁.1.2⟩, Or.inl h₁.2⟩
State after:
no goals

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ a✝ : List (SyntacticFormula L)
h₁ : (isProper l₁ = true ∧ a✝ ⊆ Γ) ∧ a✝ ∈ sequents l₁
⊢ (isProper (l₁ ++ l₂) = true ∧ a✝ ⊆ Γ) ∧ (a✝ ∈ sequents l₁ ∨ a✝ ∈ l₂.sequents)
Tactic:
case wk => exact ⟨⟨ih h₁.1.1, h₁.1.2⟩, Or.inl h₁.2⟩
State after:
no goals

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
k : ℕ
r : L.Rel k
v : Fin k → SyntacticTerm L
h₁ : (isProper l₁ = true ∧ Semiformula.rel r v ∈ Γ) ∧ Semiformula.nrel r v ∈ Γ
⊢ (isProper (l₁ ++ l₂) = true ∧ Semiformula.rel r v ∈ Γ) ∧ Semiformula.nrel r v ∈ Γ
Tactic:
exact ⟨⟨ih h₁.1.1, h₁.1.2⟩, h₁.2⟩
State after:
no goals

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
h₁ : isProper l₁ = true ∧ ⊤ ∈ Γ
⊢ isProper (l₁ ++ l₂) = true ∧ ⊤ ∈ Γ
Tactic:
exact ⟨ih h₁.1, h₁.2⟩
State after:
no goals

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
p q : SyntacticFormula L
h₁ : ((isProper l₁ = true ∧ p ⋏ q ∈ Γ) ∧ p :: Γ ∈ sequents l₁) ∧ q :: Γ ∈ sequents l₁
⊢ ((isProper (l₁ ++ l₂) = true ∧ p ⋏ q ∈ Γ) ∧ (p :: Γ ∈ sequents l₁ ∨ p :: Γ ∈ l₂.sequents)) ∧
    (q :: Γ ∈ sequents l₁ ∨ q :: Γ ∈ l₂.sequents)
Tactic:
exact ⟨⟨⟨ih h₁.1.1.1, h₁.1.1.2⟩, Or.inl h₁.1.2⟩, Or.inl h₁.2⟩
State after:
no goals

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
p q : SyntacticFormula L
h₁ : (isProper l₁ = true ∧ p ⋎ q ∈ Γ) ∧ p :: q :: Γ ∈ sequents l₁
⊢ (isProper (l₁ ++ l₂) = true ∧ p ⋎ q ∈ Γ) ∧ (p :: q :: Γ ∈ sequents l₁ ∨ p :: q :: Γ ∈ l₂.sequents)
Tactic:
exact ⟨⟨ih h₁.1.1, h₁.1.2⟩, Or.inl h₁.2⟩
State after:
no goals

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
a✝ : SyntacticSemiformula L 1
h₁ : (isProper l₁ = true ∧ ∀' a✝ ∈ Γ) ∧ (Rew.hom Rew.free) a✝ :: List.map (⇑(Rew.hom ⇑)) Γ ∈ sequents l₁
⊢ (isProper (l₁ ++ l₂) = true ∧ ∀' a✝ ∈ Γ) ∧
    ((Rew.hom Rew.free) a✝ :: List.map (⇑(Rew.hom ⇑)) Γ ∈ sequents l₁ ∨
      (Rew.hom Rew.free) a✝ :: List.map (⇑(Rew.hom ⇑)) Γ ∈ l₂.sequents)
Tactic:
exact ⟨⟨ih h₁.1.1, h₁.1.2⟩, Or.inl h₁.2⟩
State after:
no goals

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ : List (SyntacticFormula L)
a✝¹ : SyntacticSemiformula L 1
a✝ : SyntacticTerm L
h₁ : (isProper l₁ = true ∧ ∃' a✝¹ ∈ Γ) ∧ [→ a✝].hom a✝¹ :: Γ ∈ sequents l₁
⊢ (isProper (l₁ ++ l₂) = true ∧ ∃' a✝¹ ∈ Γ) ∧ ([→ a✝].hom a✝¹ :: Γ ∈ sequents l₁ ∨ [→ a✝].hom a✝¹ :: Γ ∈ l₂.sequents)
Tactic:
exact ⟨⟨ih h₁.1.1, h₁.1.2⟩, Or.inl h₁.2⟩
State after:
no goals

State before:
μ : Type ?u.466511
L : Language
inst✝⁶ : (k : ℕ) → DecidableEq (L.Func k)
inst✝⁵ : (k : ℕ) → DecidableEq (L.Rel k)
inst✝⁴ : (k : ℕ) → Primcodable (L.Func k)
inst✝³ : (k : ℕ) → Primcodable (L.Rel k)
inst✝² : UniformlyPrimcodable L.Func
inst✝¹ : UniformlyPrimcodable L.Rel
inst✝ : Primcodable μ
l₂ : ProofList L
h₂ : l₂.isProper = true
l₁ : List (Code L × List (SyntacticFormula L))
ih : isProper l₁ = true → (l₁ ++ l₂).isProper = true
Γ a✝ : List (SyntacticFormula L)
h₁ : (isProper l₁ = true ∧ a✝ ⊆ Γ) ∧ a✝ ∈ sequents l₁
⊢ (isProper (l₁ ++ l₂) = true ∧ a✝ ⊆ Γ) ∧ (a✝ ∈ sequents l₁ ∨ a✝ ∈ l₂.sequents)
Tactic:
exact ⟨⟨ih h₁.1.1, h₁.1.2⟩, Or.inl h₁.2⟩
State after:
no goals