url
stringclasses 147
values | commit
stringclasses 147
values | file_path
stringlengths 7
101
| full_name
stringlengths 1
94
| start
stringlengths 6
10
| end
stringlengths 6
11
| tactic
stringlengths 1
11.2k
| state_before
stringlengths 3
2.09M
| state_after
stringlengths 6
2.09M
|
|---|---|---|---|---|---|---|---|---|
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | case inl h₄ =>
split at l₁
case inl h₅ => exact (Set.not_nonempty_iff_eq_empty.mpr h₅) ⟨w₁, l₁, l₂⟩
case inr h₅ =>
have ⟨prf₁⟩ := l₁
have ⟨w₂,⟨⟨prf₂⟩,l₄⟩⟩ := Set.nonempty_iff_ne_empty.mpr h₅
have l₅ : w₁¦w₂ ∈ Δ := h₂ ⟨l₂, l₄⟩
clear l₁ l₂ l₄ h₅
have ⟨lst₁,l₆,prf₃⟩ := BProof.sentenceCompactness (Set.union_singleton ▸ prf₁)
have ⟨lst₂,l₇,prf₄⟩ := BProof.sentenceCompactness (Set.union_singleton ▸ prf₂)
have thm₁ := BTheorem.transitivity prf₃.toTheorem (BTheorem.orI₁ : BTheorem (w₁ ⊃ w₁ ¦ w₂))
have thm₂ := BTheorem.transitivity prf₄.toTheorem (BTheorem.orI₂ : BTheorem (w₂ ⊃ w₁ ¦ w₂))
have thm₃ := BTheorem.mp (BTheorem.adj thm₂ thm₁) BTheorem.orE
have ⟨prf₅⟩ := h₄
clear h₄ thm₁ thm₂ prf₁ prf₂ prf₃ prf₄
cases lst₁
all_goals
cases lst₂
case' nil.nil =>
have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp prf₅ thm₃⟩, l₅⟩
exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩
case' nil.cons head tail =>
have := BProof.proveList l₇
have := BProof.mp (BProof.adj prf₅ this) BTheorem.distRight
have := BProof.mp this (BTheorem.orFunctor BTheorem.taut BTheorem.andE₁)
have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp this thm₃⟩, l₅⟩
exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩
case' cons.nil head tail =>
have := BProof.proveList l₆
have := BProof.mp (BProof.adj prf₅ this) BTheorem.distRight
have := BProof.mp this (BTheorem.orFunctor BTheorem.andE₁ BTheorem.taut)
have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp this thm₃⟩, l₅⟩
exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩
case' cons.cons head tail head' tail'=>
have prf₆ := BProof.proveList l₆
have prf₇ := BProof.proveList l₇
have := BProof.mp (BProof.adj prf₅ prf₇) BTheorem.distRight
have prf₈ := BProof.mp this (BTheorem.orFunctor BTheorem.taut BTheorem.andE₁)
have := BProof.mp (BProof.adj prf₈ prf₆) BTheorem.distRight
have prf₉ := BProof.mp this (BTheorem.orFunctor BTheorem.andE₁ BTheorem.taut)
have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp prf₉ thm₃⟩, l₅⟩
exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
l₁ :
w₁ ∈
▲if ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) ∩ Δ = ∅ then
lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}
else lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}
⊢ False | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁, l₁, l₂⟩ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
¬(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
l₁ : w₁ ∈ ▲lindenbaumSequence t Δ (i, j + 0)
⊢ False | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | split at l₁ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
l₁ :
w₁ ∈
▲if ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) ∩ Δ = ∅ then
lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}
else lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}
⊢ False | case inl
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
h✝ : ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) ∩ Δ = ∅
l₁ : w₁ ∈ ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst})
⊢ False
case inr
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
h✝ : ¬▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) ∩ Δ = ∅
l₁ : w₁ ∈ ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd})
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | case inl h₅ => exact (Set.not_nonempty_iff_eq_empty.mpr h₅) ⟨w₁, l₁, l₂⟩ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
h₅ : ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) ∩ Δ = ∅
l₁ : w₁ ∈ ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst})
⊢ False | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | case inr h₅ =>
have ⟨prf₁⟩ := l₁
have ⟨w₂,⟨⟨prf₂⟩,l₄⟩⟩ := Set.nonempty_iff_ne_empty.mpr h₅
have l₅ : w₁¦w₂ ∈ Δ := h₂ ⟨l₂, l₄⟩
clear l₁ l₂ l₄ h₅
have ⟨lst₁,l₆,prf₃⟩ := BProof.sentenceCompactness (Set.union_singleton ▸ prf₁)
have ⟨lst₂,l₇,prf₄⟩ := BProof.sentenceCompactness (Set.union_singleton ▸ prf₂)
have thm₁ := BTheorem.transitivity prf₃.toTheorem (BTheorem.orI₁ : BTheorem (w₁ ⊃ w₁ ¦ w₂))
have thm₂ := BTheorem.transitivity prf₄.toTheorem (BTheorem.orI₂ : BTheorem (w₂ ⊃ w₁ ¦ w₂))
have thm₃ := BTheorem.mp (BTheorem.adj thm₂ thm₁) BTheorem.orE
have ⟨prf₅⟩ := h₄
clear h₄ thm₁ thm₂ prf₁ prf₂ prf₃ prf₄
cases lst₁
all_goals
cases lst₂
case' nil.nil =>
have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp prf₅ thm₃⟩, l₅⟩
exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩
case' nil.cons head tail =>
have := BProof.proveList l₇
have := BProof.mp (BProof.adj prf₅ this) BTheorem.distRight
have := BProof.mp this (BTheorem.orFunctor BTheorem.taut BTheorem.andE₁)
have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp this thm₃⟩, l₅⟩
exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩
case' cons.nil head tail =>
have := BProof.proveList l₆
have := BProof.mp (BProof.adj prf₅ this) BTheorem.distRight
have := BProof.mp this (BTheorem.orFunctor BTheorem.andE₁ BTheorem.taut)
have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp this thm₃⟩, l₅⟩
exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩
case' cons.cons head tail head' tail'=>
have prf₆ := BProof.proveList l₆
have prf₇ := BProof.proveList l₇
have := BProof.mp (BProof.adj prf₅ prf₇) BTheorem.distRight
have prf₈ := BProof.mp this (BTheorem.orFunctor BTheorem.taut BTheorem.andE₁)
have := BProof.mp (BProof.adj prf₈ prf₆) BTheorem.distRight
have prf₉ := BProof.mp this (BTheorem.orFunctor BTheorem.andE₁ BTheorem.taut)
have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp prf₉ thm₃⟩, l₅⟩
exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
h₅ : ¬▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) ∩ Δ = ∅
l₁ : w₁ ∈ ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd})
⊢ False | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | exact (Set.not_nonempty_iff_eq_empty.mpr h₅) ⟨w₁, l₁, l₂⟩ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
h₅ : ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) ∩ Δ = ∅
l₁ : w₁ ∈ ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst})
⊢ False | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have ⟨prf₁⟩ := l₁ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
h₅ : ¬▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) ∩ Δ = ∅
l₁ : w₁ ∈ ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd})
⊢ False | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
h₅ : ¬▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) ∩ Δ = ∅
l₁ : w₁ ∈ ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd})
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have ⟨w₂,⟨⟨prf₂⟩,l₄⟩⟩ := Set.nonempty_iff_ne_empty.mpr h₅ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
h₅ : ¬▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) ∩ Δ = ∅
l₁ : w₁ ∈ ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd})
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
⊢ False | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
h₅ : ¬▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) ∩ Δ = ∅
l₁ : w₁ ∈ ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd})
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₄ : w₂ ∈ Δ
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have l₅ : w₁¦w₂ ∈ Δ := h₂ ⟨l₂, l₄⟩ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
h₅ : ¬▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) ∩ Δ = ∅
l₁ : w₁ ∈ ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd})
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₄ : w₂ ∈ Δ
⊢ False | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
h₅ : ¬▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) ∩ Δ = ∅
l₁ : w₁ ∈ ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd})
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₄ : w₂ ∈ Δ
l₅ : w₁¦w₂ ∈ Δ
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | clear l₁ l₂ l₄ h₅ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₂ : w₁ ∈ Δ
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
h₅ : ¬▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) ∩ Δ = ∅
l₁ : w₁ ∈ ▲(lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd})
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₄ : w₂ ∈ Δ
l₅ : w₁¦w₂ ∈ Δ
⊢ False | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₅ : w₁¦w₂ ∈ Δ
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have ⟨lst₁,l₆,prf₃⟩ := BProof.sentenceCompactness (Set.union_singleton ▸ prf₁) | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₅ : w₁¦w₂ ∈ Δ
⊢ False | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₅ : w₁¦w₂ ∈ Δ
lst₁ : List Form
l₆ : { x | x ∈ lst₁ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₃ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁} w₁
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have ⟨lst₂,l₇,prf₄⟩ := BProof.sentenceCompactness (Set.union_singleton ▸ prf₂) | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₅ : w₁¦w₂ ∈ Δ
lst₁ : List Form
l₆ : { x | x ∈ lst₁ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₃ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁} w₁
⊢ False | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₅ : w₁¦w₂ ∈ Δ
lst₁ : List Form
l₆ : { x | x ∈ lst₁ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₃ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁} w₁
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₄ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂} w₂
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have thm₁ := BTheorem.transitivity prf₃.toTheorem (BTheorem.orI₁ : BTheorem (w₁ ⊃ w₁ ¦ w₂)) | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₅ : w₁¦w₂ ∈ Δ
lst₁ : List Form
l₆ : { x | x ∈ lst₁ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₃ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁} w₁
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₄ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂} w₂
⊢ False | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₅ : w₁¦w₂ ∈ Δ
lst₁ : List Form
l₆ : { x | x ∈ lst₁ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₃ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁} w₁
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₄ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂} w₂
thm₁ : BTheorem (Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁⊃w₁¦w₂)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have thm₂ := BTheorem.transitivity prf₄.toTheorem (BTheorem.orI₂ : BTheorem (w₂ ⊃ w₁ ¦ w₂)) | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₅ : w₁¦w₂ ∈ Δ
lst₁ : List Form
l₆ : { x | x ∈ lst₁ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₃ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁} w₁
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₄ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂} w₂
thm₁ : BTheorem (Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁⊃w₁¦w₂)
⊢ False | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₅ : w₁¦w₂ ∈ Δ
lst₁ : List Form
l₆ : { x | x ∈ lst₁ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₃ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁} w₁
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₄ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂} w₂
thm₁ : BTheorem (Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁⊃w₁¦w₂)
thm₂ : BTheorem (Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂⊃w₁¦w₂)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have thm₃ := BTheorem.mp (BTheorem.adj thm₂ thm₁) BTheorem.orE | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₅ : w₁¦w₂ ∈ Δ
lst₁ : List Form
l₆ : { x | x ∈ lst₁ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₃ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁} w₁
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₄ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂} w₂
thm₁ : BTheorem (Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁⊃w₁¦w₂)
thm₂ : BTheorem (Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂⊃w₁¦w₂)
⊢ False | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₅ : w₁¦w₂ ∈ Δ
lst₁ : List Form
l₆ : { x | x ∈ lst₁ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₃ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁} w₁
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₄ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂} w₂
thm₁ : BTheorem (Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁⊃w₁¦w₂)
thm₂ : BTheorem (Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂⊃w₁¦w₂)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
lst₂¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁⊃w₁¦w₂)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have ⟨prf₅⟩ := h₄ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₅ : w₁¦w₂ ∈ Δ
lst₁ : List Form
l₆ : { x | x ∈ lst₁ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₃ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁} w₁
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₄ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂} w₂
thm₁ : BTheorem (Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁⊃w₁¦w₂)
thm₂ : BTheorem (Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂⊃w₁¦w₂)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
lst₂¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁⊃w₁¦w₂)
⊢ False | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₅ : w₁¦w₂ ∈ Δ
lst₁ : List Form
l₆ : { x | x ∈ lst₁ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₃ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁} w₁
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₄ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂} w₂
thm₁ : BTheorem (Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁⊃w₁¦w₂)
thm₂ : BTheorem (Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂⊃w₁¦w₂)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
lst₂¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁⊃w₁¦w₂)
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | clear h₄ thm₁ thm₂ prf₁ prf₂ prf₃ prf₄ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
h₄ :
(Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd ∈
▲lindenbaumSequence t Δ (i, j + 0)
prf₁ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).snd}) w₁
w₂ : Form
prf₂ : BProof (lindenbaumSequence t Δ (i, j + 0) ∪ {(Denumerable.ofNat (Form × Form) (j + 0)).fst}) w₂
l₅ : w₁¦w₂ ∈ Δ
lst₁ : List Form
l₆ : { x | x ∈ lst₁ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₃ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁} w₁
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₄ : BProof {Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂} w₂
thm₁ : BTheorem (Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁⊃w₁¦w₂)
thm₂ : BTheorem (Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst lst₂⊃w₁¦w₂)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
lst₂¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁⊃w₁¦w₂)
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
⊢ False | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
lst₁ : List Form
l₆ : { x | x ∈ lst₁ } ⊆ lindenbaumSequence t Δ (i, j + 0)
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
lst₂¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁⊃w₁¦w₂)
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | cases lst₁ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
lst₁ : List Form
l₆ : { x | x ∈ lst₁ } ⊆ lindenbaumSequence t Δ (i, j + 0)
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
lst₂¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd lst₁⊃w₁¦w₂)
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
⊢ False | case nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
lst₂¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
⊢ False
case cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝ : Form
tail✝ : List Form
l₆ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
lst₂¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝ :: tail✝)⊃w₁¦w₂)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | all_goals
cases lst₂ | case nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
lst₂¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
⊢ False
case cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝ : Form
tail✝ : List Form
l₆ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
lst₂¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝ :: tail✝)⊃w₁¦w₂)
⊢ False | case nil.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
⊢ False
case nil.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
head✝ : Form
tail✝ : List Form
l₇ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head✝ :: tail✝)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
⊢ False
case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝ : Form
tail✝ : List Form
l₆ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝ :: tail✝)⊃w₁¦w₂)
⊢ False
case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝¹ : Form
tail✝¹ : List Form
l₆ : { x | x ∈ head✝¹ :: tail✝¹ } ⊆ lindenbaumSequence t Δ (i, j + 0)
head✝ : Form
tail✝ : List Form
l₇ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head✝ :: tail✝)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝¹ :: tail✝¹)⊃w₁¦w₂)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | case' nil.nil =>
have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp prf₅ thm₃⟩, l₅⟩
exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩ | case nil.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
⊢ False
case nil.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
head✝ : Form
tail✝ : List Form
l₇ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head✝ :: tail✝)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
⊢ False
case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝ : Form
tail✝ : List Form
l₆ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝ :: tail✝)⊃w₁¦w₂)
⊢ False
case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝¹ : Form
tail✝¹ : List Form
l₆ : { x | x ∈ head✝¹ :: tail✝¹ } ⊆ lindenbaumSequence t Δ (i, j + 0)
head✝ : Form
tail✝ : List Form
l₇ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head✝ :: tail✝)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝¹ :: tail✝¹)⊃w₁¦w₂)
⊢ False | case nil.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
head✝ : Form
tail✝ : List Form
l₇ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head✝ :: tail✝)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
⊢ False
case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝ : Form
tail✝ : List Form
l₆ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝ :: tail✝)⊃w₁¦w₂)
⊢ False
case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝¹ : Form
tail✝¹ : List Form
l₆ : { x | x ∈ head✝¹ :: tail✝¹ } ⊆ lindenbaumSequence t Δ (i, j + 0)
head✝ : Form
tail✝ : List Form
l₇ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head✝ :: tail✝)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝¹ :: tail✝¹)⊃w₁¦w₂)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | case' nil.cons head tail =>
have := BProof.proveList l₇
have := BProof.mp (BProof.adj prf₅ this) BTheorem.distRight
have := BProof.mp this (BTheorem.orFunctor BTheorem.taut BTheorem.andE₁)
have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp this thm₃⟩, l₅⟩
exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩ | case nil.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
head✝ : Form
tail✝ : List Form
l₇ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head✝ :: tail✝)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
⊢ False
case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝ : Form
tail✝ : List Form
l₆ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝ :: tail✝)⊃w₁¦w₂)
⊢ False
case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝¹ : Form
tail✝¹ : List Form
l₆ : { x | x ∈ head✝¹ :: tail✝¹ } ⊆ lindenbaumSequence t Δ (i, j + 0)
head✝ : Form
tail✝ : List Form
l₇ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head✝ :: tail✝)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝¹ :: tail✝¹)⊃w₁¦w₂)
⊢ False | case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝ : Form
tail✝ : List Form
l₆ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝ :: tail✝)⊃w₁¦w₂)
⊢ False
case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝¹ : Form
tail✝¹ : List Form
l₆ : { x | x ∈ head✝¹ :: tail✝¹ } ⊆ lindenbaumSequence t Δ (i, j + 0)
head✝ : Form
tail✝ : List Form
l₇ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head✝ :: tail✝)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝¹ :: tail✝¹)⊃w₁¦w₂)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | case' cons.nil head tail =>
have := BProof.proveList l₆
have := BProof.mp (BProof.adj prf₅ this) BTheorem.distRight
have := BProof.mp this (BTheorem.orFunctor BTheorem.andE₁ BTheorem.taut)
have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp this thm₃⟩, l₅⟩
exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩ | case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝ : Form
tail✝ : List Form
l₆ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝ :: tail✝)⊃w₁¦w₂)
⊢ False
case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝¹ : Form
tail✝¹ : List Form
l₆ : { x | x ∈ head✝¹ :: tail✝¹ } ⊆ lindenbaumSequence t Δ (i, j + 0)
head✝ : Form
tail✝ : List Form
l₇ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head✝ :: tail✝)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝¹ :: tail✝¹)⊃w₁¦w₂)
⊢ False | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝¹ : Form
tail✝¹ : List Form
l₆ : { x | x ∈ head✝¹ :: tail✝¹ } ⊆ lindenbaumSequence t Δ (i, j + 0)
head✝ : Form
tail✝ : List Form
l₇ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head✝ :: tail✝)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝¹ :: tail✝¹)⊃w₁¦w₂)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | case' cons.cons head tail head' tail'=>
have prf₆ := BProof.proveList l₆
have prf₇ := BProof.proveList l₇
have := BProof.mp (BProof.adj prf₅ prf₇) BTheorem.distRight
have prf₈ := BProof.mp this (BTheorem.orFunctor BTheorem.taut BTheorem.andE₁)
have := BProof.mp (BProof.adj prf₈ prf₆) BTheorem.distRight
have prf₉ := BProof.mp this (BTheorem.orFunctor BTheorem.andE₁ BTheorem.taut)
have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp prf₉ thm₃⟩, l₅⟩
exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩ | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝¹ : Form
tail✝¹ : List Form
l₆ : { x | x ∈ head✝¹ :: tail✝¹ } ⊆ lindenbaumSequence t Δ (i, j + 0)
head✝ : Form
tail✝ : List Form
l₇ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head✝ :: tail✝)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝¹ :: tail✝¹)⊃w₁¦w₂)
⊢ False | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | cases lst₂ | case cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
lst₂ : List Form
l₇ : { x | x ∈ lst₂ } ⊆ lindenbaumSequence t Δ (i, j + 0)
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝ : Form
tail✝ : List Form
l₆ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
lst₂¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝ :: tail✝)⊃w₁¦w₂)
⊢ False | case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝ : Form
tail✝ : List Form
l₆ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝ :: tail✝)⊃w₁¦w₂)
⊢ False
case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head✝¹ : Form
tail✝¹ : List Form
l₆ : { x | x ∈ head✝¹ :: tail✝¹ } ⊆ lindenbaumSequence t Δ (i, j + 0)
head✝ : Form
tail✝ : List Form
l₇ : { x | x ∈ head✝ :: tail✝ } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head✝ :: tail✝)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head✝¹ :: tail✝¹)⊃w₁¦w₂)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp prf₅ thm₃⟩, l₅⟩ | case nil.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
⊢ False | case nil.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
this : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩ | case nil.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
this : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ
⊢ False | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have := BProof.proveList l₇ | case nil.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
head : Form
tail : List Form
l₇ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head :: tail)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
⊢ False | case nil.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
head : Form
tail : List Form
l₇ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head :: tail)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
this : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have := BProof.mp (BProof.adj prf₅ this) BTheorem.distRight | case nil.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
head : Form
tail : List Form
l₇ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head :: tail)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
this : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
⊢ False | case nil.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
head : Form
tail : List Form
l₇ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head :: tail)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
this✝ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head
tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have := BProof.mp this (BTheorem.orFunctor BTheorem.taut BTheorem.andE₁) | case nil.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
head : Form
tail : List Form
l₇ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head :: tail)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
this✝ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head
tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
⊢ False | case nil.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
head : Form
tail : List Form
l₇ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head :: tail)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
this✝¹ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
this✝ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head
tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j + 0)).fst&Form.conjoinList head tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp this thm₃⟩, l₅⟩ | case nil.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
head : Form
tail : List Form
l₇ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head :: tail)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
this✝¹ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
this✝ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head
tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j + 0)).fst&Form.conjoinList head tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
⊢ False | case nil.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
head : Form
tail : List Form
l₇ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head :: tail)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
this✝² : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
this✝¹ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head
tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
this✝ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j + 0)).fst&Form.conjoinList head tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
this : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩ | case nil.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
l₆ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
head : Form
tail : List Form
l₇ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head :: tail)¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd []⊃w₁¦w₂)
this✝² : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
this✝¹ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head
tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
this✝ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j + 0)).fst&Form.conjoinList head tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
this : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ
⊢ False | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have := BProof.proveList l₆ | case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
⊢ False | case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
this : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have := BProof.mp (BProof.adj prf₅ this) BTheorem.distRight | case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
this : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
⊢ False | case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
this✝ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head
tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have := BProof.mp this (BTheorem.orFunctor BTheorem.andE₁ BTheorem.taut) | case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
this✝ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head
tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
⊢ False | case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
this✝¹ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
this✝ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head
tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form)
(j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp this thm₃⟩, l₅⟩ | case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
this✝¹ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
this✝ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head
tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form)
(j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
⊢ False | case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
this✝² : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
this✝¹ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head
tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
this✝ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form)
(j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
this : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩ | case cons.nil
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
l₇ : { x | x ∈ [] } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
[]¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
this✝² : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
this✝¹ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head
tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
this✝ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form)
(j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
this : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ
⊢ False | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have prf₆ := BProof.proveList l₆ | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
⊢ False | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
prf₆ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have prf₇ := BProof.proveList l₇ | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
prf₆ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
⊢ False | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
prf₆ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
prf₇ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head' tail')
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have := BProof.mp (BProof.adj prf₅ prf₇) BTheorem.distRight | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
prf₆ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
prf₇ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head' tail')
⊢ False | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
prf₆ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
prf₇ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head' tail')
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head' tail')
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have prf₈ := BProof.mp this (BTheorem.orFunctor BTheorem.taut BTheorem.andE₁) | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
prf₆ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
prf₇ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head' tail')
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head' tail')
⊢ False | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
prf₆ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
prf₇ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head' tail')
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head' tail')
prf₈ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j + 0)).fst&Form.conjoinList head' tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have := BProof.mp (BProof.adj prf₈ prf₆) BTheorem.distRight | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
prf₆ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
prf₇ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head' tail')
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head' tail')
prf₈ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j + 0)).fst&Form.conjoinList head' tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
⊢ False | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
prf₆ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
prf₇ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head' tail')
this✝ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head' tail')
prf₈ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j + 0)).fst&Form.conjoinList head' tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
((((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')&Form.conjoinList head tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have prf₉ := BProof.mp this (BTheorem.orFunctor BTheorem.andE₁ BTheorem.taut) | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
prf₆ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
prf₇ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head' tail')
this✝ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head' tail')
prf₈ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j + 0)).fst&Form.conjoinList head' tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
((((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')&Form.conjoinList head tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
⊢ False | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
prf₆ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
prf₇ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head' tail')
this✝ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head' tail')
prf₈ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j + 0)).fst&Form.conjoinList head' tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
((((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')&Form.conjoinList head tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
prf₉ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | have : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ := ⟨⟨BProof.mp prf₉ thm₃⟩, l₅⟩ | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
prf₆ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
prf₇ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head' tail')
this✝ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head' tail')
prf₈ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j + 0)).fst&Form.conjoinList head' tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
this :
BProof (lindenbaumSequence t Δ (i, j + 0))
((((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')&Form.conjoinList head tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
prf₉ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
⊢ False | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
prf₆ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
prf₇ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head' tail')
this✝¹ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head' tail')
prf₈ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j + 0)).fst&Form.conjoinList head' tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
this✝ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')&Form.conjoinList head tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
prf₉ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
this : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumAvoids | [188, 1] | [265, 62] | exact (Set.not_nonempty_iff_eq_empty.mpr l₃) ⟨w₁¦w₂, this⟩ | case cons.cons
t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
i j : ℕ
w₁ : Form
l₃ : ▲lindenbaumSequence t Δ (i, j) ∩ Δ = ∅
w₂ : Form
l₅ : w₁¦w₂ ∈ Δ
prf₅ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((Denumerable.ofNat (Form × Form) (j + 0)).fst¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
head : Form
tail : List Form
l₆ : { x | x ∈ head :: tail } ⊆ lindenbaumSequence t Δ (i, j + 0)
head' : Form
tail' : List Form
l₇ : { x | x ∈ head' :: tail' } ⊆ lindenbaumSequence t Δ (i, j + 0)
thm₃ :
BTheorem
(Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).fst
(head' :: tail')¦Form.conjoinList (Denumerable.ofNat (Form × Form) (j + 0)).snd (head :: tail)⊃w₁¦w₂)
prf₆ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head tail)
prf₇ : BProof (lindenbaumSequence t Δ (i, j + 0)) (Form.conjoinList head' tail')
this✝¹ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head' tail')
prf₈ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j + 0)).fst&Form.conjoinList head' tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd)
this✝ :
BProof (lindenbaumSequence t Δ (i, j + 0))
((((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')&Form.conjoinList head tail)¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
prf₉ :
BProof (lindenbaumSequence t Δ (i, j + 0))
(((Denumerable.ofNat (Form × Form)
(j +
0)).fst&Form.conjoinList head'
tail')¦(Denumerable.ofNat (Form × Form) (j + 0)).snd&Form.conjoinList head tail)
this : w₁¦w₂ ∈ ▲lindenbaumSequence t Δ (i, j) ∩ Δ
⊢ False | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumTheorem | [267, 1] | [274, 59] | unfold lindenbaumExtension | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
⊢ lindenbaumExtension t Δ ∩ Δ = ∅ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
⊢ { f | ∃ ij, f ∈ lindenbaumSequence t Δ ij } ∩ Δ = ∅ |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumTheorem | [267, 1] | [274, 59] | apply Set.not_nonempty_iff_eq_empty.mp | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
⊢ { f | ∃ ij, f ∈ lindenbaumSequence t Δ ij } ∩ Δ = ∅ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
⊢ ¬Set.Nonempty ({ f | ∃ ij, f ∈ lindenbaumSequence t Δ ij } ∩ Δ) |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumTheorem | [267, 1] | [274, 59] | intros h₃ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
⊢ ¬Set.Nonempty ({ f | ∃ ij, f ∈ lindenbaumSequence t Δ ij } ∩ Δ) | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
h₃ : Set.Nonempty ({ f | ∃ ij, f ∈ lindenbaumSequence t Δ ij } ∩ Δ)
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumTheorem | [267, 1] | [274, 59] | have ⟨f, ⟨ij, h₄⟩, h₅⟩ := h₃ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
h₃ : Set.Nonempty ({ f | ∃ ij, f ∈ lindenbaumSequence t Δ ij } ∩ Δ)
⊢ False | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
h₃ : Set.Nonempty ({ f | ∃ ij, f ∈ lindenbaumSequence t Δ ij } ∩ Δ)
f : Form
ij : ℕ × ℕ
h₄ : f ∈ lindenbaumSequence t Δ ij
h₅ : f ∈ Δ
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumTheorem | [267, 1] | [274, 59] | have l₁ := lindenbaumAvoids h₁ h₂ ij | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
h₃ : Set.Nonempty ({ f | ∃ ij, f ∈ lindenbaumSequence t Δ ij } ∩ Δ)
f : Form
ij : ℕ × ℕ
h₄ : f ∈ lindenbaumSequence t Δ ij
h₅ : f ∈ Δ
⊢ False | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
h₃ : Set.Nonempty ({ f | ∃ ij, f ∈ lindenbaumSequence t Δ ij } ∩ Δ)
f : Form
ij : ℕ × ℕ
h₄ : f ∈ lindenbaumSequence t Δ ij
h₅ : f ∈ Δ
l₁ : ▲lindenbaumSequence t Δ ij ∩ Δ = ∅
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumTheorem | [267, 1] | [274, 59] | have l₂ : f ∈ ▲lindenbaumSequence t Δ ij := ⟨BProof.ax h₄⟩ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
h₃ : Set.Nonempty ({ f | ∃ ij, f ∈ lindenbaumSequence t Δ ij } ∩ Δ)
f : Form
ij : ℕ × ℕ
h₄ : f ∈ lindenbaumSequence t Δ ij
h₅ : f ∈ Δ
l₁ : ▲lindenbaumSequence t Δ ij ∩ Δ = ∅
⊢ False | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
h₃ : Set.Nonempty ({ f | ∃ ij, f ∈ lindenbaumSequence t Δ ij } ∩ Δ)
f : Form
ij : ℕ × ℕ
h₄ : f ∈ lindenbaumSequence t Δ ij
h₅ : f ∈ Δ
l₁ : ▲lindenbaumSequence t Δ ij ∩ Δ = ∅
l₂ : f ∈ ▲lindenbaumSequence t Δ ij
⊢ False |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Lindenbaum.lean | lindenbaumTheorem | [267, 1] | [274, 59] | exact Set.not_nonempty_iff_eq_empty.mpr l₁ $ ⟨f, l₂, h₅⟩ | t : Th
Δ : Ctx
h₁ : ↑t ∩ Δ = ∅
h₂ : isDisjunctionClosed Δ
h₃ : Set.Nonempty ({ f | ∃ ij, f ∈ lindenbaumSequence t Δ ij } ∩ Δ)
f : Form
ij : ℕ × ℕ
h₄ : f ∈ lindenbaumSequence t Δ ij
h₅ : f ∈ Δ
l₁ : ▲lindenbaumSequence t Δ ij ∩ Δ = ∅
l₂ : f ∈ ▲lindenbaumSequence t Δ ij
⊢ False | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/PropositionalLanguage.lean | Form.toConsExp_injective | [26, 1] | [28, 64] | intros f1 f2 | ⊢ Function.Injective toConsExp | f1 f2 : Form
⊢ toConsExp f1 = toConsExp f2 → f1 = f2 |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/PropositionalLanguage.lean | Form.toConsExp_injective | [26, 1] | [28, 64] | induction f1 generalizing f2 <;> cases f2 <;> simp! <;> aesop | f1 f2 : Form
⊢ toConsExp f1 = toConsExp f2 → f1 = f2 | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/PropositionalLanguage.lean | Form.nat_injection | [30, 1] | [33, 15] | unfold Function.Injective | ⊢ Function.Injective atom | ⊢ ∀ ⦃a₁ a₂ : ℕ⦄, #a₁ = #a₂ → a₁ = a₂ |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/PropositionalLanguage.lean | Form.nat_injection | [30, 1] | [33, 15] | intros n m h₁ | ⊢ ∀ ⦃a₁ a₂ : ℕ⦄, #a₁ = #a₂ → a₁ = a₂ | n m : ℕ
h₁ : #n = #m
⊢ n = m |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/PropositionalLanguage.lean | Form.nat_injection | [30, 1] | [33, 15] | injection h₁ | n m : ℕ
h₁ : #n = #m
⊢ n = m | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/PropositionalLanguage.lean | toForm_toConsExp_eq | [52, 1] | [53, 28] | induction f <;> simp! [*] | f : Form
⊢ ConsExp.toForm (Form.toConsExp f) = some f | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | intros prf₁ | Γ : Ctx
f : Form
⊢ BProof Γ f → (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) f | Γ : Ctx
f : Form
prf₁ : BProof Γ f
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) f |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | induction prf₁ | Γ : Ctx
f : Form
prf₁ : BProof Γ f
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) f | case ax
Γ : Ctx
f p✝ : Form
h✝ : p✝ ∈ Γ
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) p✝
case mp
Γ : Ctx
f p✝ q✝ : Form
h₁✝ : BProof Γ p✝
h₂✝ : BTheorem (p✝⊃q✝)
h₁_ih✝ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) p✝
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) q✝
case adj
Γ : Ctx
f p✝ q✝ : Form
h₁✝ : BProof Γ p✝
h₂✝ : BProof Γ q✝
h₁_ih✝ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) p✝
h₂_ih✝ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) q✝
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (p✝&q✝) |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | case ax g h₁ =>
let Gsing : Finset Form := {g}
have l₁ : g ∈ {g} := Finset.mem_singleton.mpr rfl
have l₂ : Gsing = ({g} : Ctx) := Finset.coe_singleton g
have l₃ : ↑Gsing ⊆ Γ := by
intros g' h₂
rw [l₂] at h₂
rw [h₂]
assumption
have prf₂ : BProof ↑{g} g := by
rw [←l₂]
apply ax l₁
rw [←l₂] at prf₂
exact ⟨Gsing, l₃, prf₂⟩ | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) g | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | case mp P Q _ h₂ ih =>
have ⟨fin, h₁, prf⟩ := ih
exact ⟨fin, h₁, mp prf h₂⟩ | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂ : BTheorem (P⊃Q)
ih : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | case adj P Q _ _ ih₁ ih₂ =>
have ⟨fin₁, h₁, prf₁⟩ := ih₁
have ⟨fin₂, h₂, prf₂⟩ := ih₂
have prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P := BProof.monotone (Set.subset_union_left ↑fin₁ ↑fin₂) prf₁
have prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q := BProof.monotone (Set.subset_union_right ↑fin₁ ↑fin₂) prf₂
have prf₅ := adj prf₃ prf₄
have l₁ : ↑(fin₁ ∪ fin₂) ⊆ Γ := by
intros f h₃
rw [Finset.coe_union] at h₃
cases h₃
case inl h₄ => exact h₁ h₄
case inr h₄ => exact h₂ h₄
rw [←Finset.coe_union] at prf₅
exact ⟨↑(fin₁ ∪ fin₂), l₁, prf₅⟩ | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | let Gsing : Finset Form := {g} | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) g | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) g |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | have l₁ : g ∈ {g} := Finset.mem_singleton.mpr rfl | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) g | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) g |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | have l₂ : Gsing = ({g} : Ctx) := Finset.coe_singleton g | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) g | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) g |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | have l₃ : ↑Gsing ⊆ Γ := by
intros g' h₂
rw [l₂] at h₂
rw [h₂]
assumption | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) g | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
l₃ : ↑Gsing ⊆ Γ
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) g |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | have prf₂ : BProof ↑{g} g := by
rw [←l₂]
apply ax l₁ | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
l₃ : ↑Gsing ⊆ Γ
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) g | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
l₃ : ↑Gsing ⊆ Γ
prf₂ : BProof {g} g
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) g |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | rw [←l₂] at prf₂ | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
l₃ : ↑Gsing ⊆ Γ
prf₂ : BProof {g} g
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) g | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
l₃ : ↑Gsing ⊆ Γ
prf₂ : BProof (↑Gsing) g
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) g |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | exact ⟨Gsing, l₃, prf₂⟩ | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
l₃ : ↑Gsing ⊆ Γ
prf₂ : BProof (↑Gsing) g
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) g | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | intros g' h₂ | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
⊢ ↑Gsing ⊆ Γ | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
g' : Form
h₂ : g' ∈ ↑Gsing
⊢ g' ∈ Γ |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | rw [l₂] at h₂ | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
g' : Form
h₂ : g' ∈ ↑Gsing
⊢ g' ∈ Γ | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
g' : Form
h₂ : g' ∈ {g}
⊢ g' ∈ Γ |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | rw [h₂] | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
g' : Form
h₂ : g' ∈ {g}
⊢ g' ∈ Γ | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
g' : Form
h₂ : g' ∈ {g}
⊢ g ∈ Γ |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | assumption | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
g' : Form
h₂ : g' ∈ {g}
⊢ g ∈ Γ | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | rw [←l₂] | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
l₃ : ↑Gsing ⊆ Γ
⊢ BProof {g} g | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
l₃ : ↑Gsing ⊆ Γ
⊢ BProof (↑Gsing) g |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | apply ax l₁ | Γ : Ctx
f g : Form
h₁ : g ∈ Γ
Gsing : Finset Form := {g}
l₁ : g ∈ {g}
l₂ : ↑Gsing = {g}
l₃ : ↑Gsing ⊆ Γ
⊢ BProof (↑Gsing) g | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | have ⟨fin, h₁, prf⟩ := ih | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂ : BTheorem (P⊃Q)
ih : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂ : BTheorem (P⊃Q)
ih : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
fin : Finset Form
h₁ : ↑fin ⊆ Γ
prf : BProof (↑fin) P
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | exact ⟨fin, h₁, mp prf h₂⟩ | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂ : BTheorem (P⊃Q)
ih : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
fin : Finset Form
h₁ : ↑fin ⊆ Γ
prf : BProof (↑fin) P
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | have ⟨fin₁, h₁, prf₁⟩ := ih₁ | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | have ⟨fin₂, h₂, prf₂⟩ := ih₂ | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | have prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P := BProof.monotone (Set.subset_union_left ↑fin₁ ↑fin₂) prf₁ | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | have prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q := BProof.monotone (Set.subset_union_right ↑fin₁ ↑fin₂) prf₂ | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | have prf₅ := adj prf₃ prf₄ | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | have l₁ : ↑(fin₁ ∪ fin₂) ⊆ Γ := by
intros f h₃
rw [Finset.coe_union] at h₃
cases h₃
case inl h₄ => exact h₁ h₄
case inr h₄ => exact h₂ h₄ | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
l₁ : ↑(fin₁ ∪ fin₂) ⊆ Γ
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | rw [←Finset.coe_union] at prf₅ | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
l₁ : ↑(fin₁ ∪ fin₂) ⊆ Γ
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅✝ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
prf₅ : BProof (↑(fin₁ ∪ fin₂)) (P&Q)
l₁ : ↑(fin₁ ∪ fin₂) ⊆ Γ
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | exact ⟨↑(fin₁ ∪ fin₂), l₁, prf₅⟩ | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅✝ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
prf₅ : BProof (↑(fin₁ ∪ fin₂)) (P&Q)
l₁ : ↑(fin₁ ∪ fin₂) ⊆ Γ
⊢ (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) (P&Q) | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | intros f h₃ | Γ : Ctx
f P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
⊢ ↑(fin₁ ∪ fin₂) ⊆ Γ | Γ : Ctx
f✝ P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
f : Form
h₃ : f ∈ ↑(fin₁ ∪ fin₂)
⊢ f ∈ Γ |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | rw [Finset.coe_union] at h₃ | Γ : Ctx
f✝ P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
f : Form
h₃ : f ∈ ↑(fin₁ ∪ fin₂)
⊢ f ∈ Γ | Γ : Ctx
f✝ P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
f : Form
h₃ : f ∈ ↑fin₁ ∪ ↑fin₂
⊢ f ∈ Γ |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | cases h₃ | Γ : Ctx
f✝ P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
f : Form
h₃ : f ∈ ↑fin₁ ∪ ↑fin₂
⊢ f ∈ Γ | case inl
Γ : Ctx
f✝ P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
f : Form
h✝ : f ∈ ↑fin₁
⊢ f ∈ Γ
case inr
Γ : Ctx
f✝ P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
f : Form
h✝ : f ∈ ↑fin₂
⊢ f ∈ Γ |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | case inl h₄ => exact h₁ h₄ | Γ : Ctx
f✝ P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
f : Form
h₄ : f ∈ ↑fin₁
⊢ f ∈ Γ | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | case inr h₄ => exact h₂ h₄ | Γ : Ctx
f✝ P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
f : Form
h₄ : f ∈ ↑fin₂
⊢ f ∈ Γ | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | exact h₁ h₄ | Γ : Ctx
f✝ P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
f : Form
h₄ : f ∈ ↑fin₁
⊢ f ∈ Γ | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.compactness | [169, 1] | [201, 37] | exact h₂ h₄ | Γ : Ctx
f✝ P Q : Form
h₁✝ : BProof Γ P
h₂✝ : BProof Γ Q
ih₁ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) P
ih₂ : (s : Finset Form) × (_ : ↑s ⊆ Γ) ×' BProof (↑s) Q
fin₁ : Finset Form
h₁ : ↑fin₁ ⊆ Γ
prf₁ : BProof (↑fin₁) P
fin₂ : Finset Form
h₂ : ↑fin₂ ⊆ Γ
prf₂ : BProof (↑fin₂) Q
prf₃ : BProof (↑fin₁ ∪ ↑fin₂) P
prf₄ : BProof (↑fin₁ ∪ ↑fin₂) Q
prf₅ : BProof (↑fin₁ ∪ ↑fin₂) (P&Q)
f : Form
h₄ : f ∈ ↑fin₂
⊢ f ∈ Γ | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.listCompression | [203, 1] | [207, 60] | intros prf₁ | l : List Form
f g : Form
⊢ BProof { h | h = f ∨ h ∈ l } g → BProof {Form.conjoinList f l} g | l : List Form
f g : Form
prf₁ : BProof { h | h = f ∨ h ∈ l } g
⊢ BProof {Form.conjoinList f l} g |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.listCompression | [203, 1] | [207, 60] | induction prf₁ | l : List Form
f g : Form
prf₁ : BProof { h | h = f ∨ h ∈ l } g
⊢ BProof {Form.conjoinList f l} g | case ax
l : List Form
f g p✝ : Form
h✝ : p✝ ∈ { h | h = f ∨ h ∈ l }
⊢ BProof {Form.conjoinList f l} p✝
case mp
l : List Form
f g p✝ q✝ : Form
h₁✝ : BProof { h | h = f ∨ h ∈ l } p✝
h₂✝ : BTheorem (p✝⊃q✝)
h₁_ih✝ : BProof {Form.conjoinList f l} p✝
⊢ BProof {Form.conjoinList f l} q✝
case adj
l : List Form
f g p✝ q✝ : Form
h₁✝ : BProof { h | h = f ∨ h ∈ l } p✝
h₂✝ : BProof { h | h = f ∨ h ∈ l } q✝
h₁_ih✝ : BProof {Form.conjoinList f l} p✝
h₂_ih✝ : BProof {Form.conjoinList f l} q✝
⊢ BProof {Form.conjoinList f l} (p✝&q✝) |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.listCompression | [203, 1] | [207, 60] | case ax p h₁ => exact BProof.proveFromList $ List.mem_cons.mpr h₁ | l : List Form
f g p : Form
h₁ : p ∈ { h | h = f ∨ h ∈ l }
⊢ BProof {Form.conjoinList f l} p | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.listCompression | [203, 1] | [207, 60] | case mp p q _ prf₂ ih => exact BProof.mp ih prf₂ | l : List Form
f g p q : Form
h₁✝ : BProof { h | h = f ∨ h ∈ l } p
prf₂ : BTheorem (p⊃q)
ih : BProof {Form.conjoinList f l} p
⊢ BProof {Form.conjoinList f l} q | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.listCompression | [203, 1] | [207, 60] | case adj p q _ _ prf₁ prf₂ => exact BProof.adj prf₁ prf₂ | l : List Form
f g p q : Form
h₁✝ : BProof { h | h = f ∨ h ∈ l } p
h₂✝ : BProof { h | h = f ∨ h ∈ l } q
prf₁ : BProof {Form.conjoinList f l} p
prf₂ : BProof {Form.conjoinList f l} q
⊢ BProof {Form.conjoinList f l} (p&q) | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.listCompression | [203, 1] | [207, 60] | exact BProof.proveFromList $ List.mem_cons.mpr h₁ | l : List Form
f g p : Form
h₁ : p ∈ { h | h = f ∨ h ∈ l }
⊢ BProof {Form.conjoinList f l} p | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.listCompression | [203, 1] | [207, 60] | exact BProof.mp ih prf₂ | l : List Form
f g p q : Form
h₁✝ : BProof { h | h = f ∨ h ∈ l } p
prf₂ : BTheorem (p⊃q)
ih : BProof {Form.conjoinList f l} p
⊢ BProof {Form.conjoinList f l} q | no goals |
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git | 0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f | Fine/SystemB/Hilbert.lean | BProof.listCompression | [203, 1] | [207, 60] | exact BProof.adj prf₁ prf₂ | l : List Form
f g p q : Form
h₁✝ : BProof { h | h = f ∨ h ∈ l } p
h₂✝ : BProof { h | h = f ∨ h ∈ l } q
prf₁ : BProof {Form.conjoinList f l} p
prf₂ : BProof {Form.conjoinList f l} q
⊢ BProof {Form.conjoinList f l} (p&q) | no goals |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.