internlm/Lean-Github · Datasets at Hugging Face

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/CanonicalModel.lean	canonicalSatisfaction	[172, 1]	[235, 39]	let Δ : Th := ⟨▲{f}, generatedFormal {f}⟩	case h t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t ⊢ False	case h t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } ⊢ False
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/CanonicalModel.lean	canonicalSatisfaction	[172, 1]	[235, 39]	have l₁ : ¬(g ∈ (formalApplicationFunction t Δ).val) := by intros h₃ have ⟨q,⟨prf₁⟩,l₂⟩ := h₃ have ⟨prf₂⟩ := t.property.mp l₂ have prf₃ := BProof.mp prf₂ (BTheorem.hs prf₁.toTheorem BTheorem.taut) exact h₂ $ t.property.mpr ⟨prf₃⟩	case h t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } ⊢ False	case h t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } l₁ : ¬g ∈ ↑(formalApplicationFunction t Δ) ⊢ False
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/CanonicalModel.lean	canonicalSatisfaction	[172, 1]	[235, 39]	have l₂ : Δ ⊨ f := canonicalSatisfaction.mpr ⟨BProof.ax rfl⟩	case h t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } l₁ : ¬g ∈ ↑(formalApplicationFunction t Δ) ⊢ False	case h t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } l₁ : ¬g ∈ ↑(formalApplicationFunction t Δ) l₂ : Δ⊨f ⊢ False
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/CanonicalModel.lean	canonicalSatisfaction	[172, 1]	[235, 39]	exact l₁ $ canonicalSatisfaction.mp (h₁ l₂)	case h t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } l₁ : ¬g ∈ ↑(formalApplicationFunction t Δ) l₂ : Δ⊨f ⊢ False	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/CanonicalModel.lean	canonicalSatisfaction	[172, 1]	[235, 39]	intros h₃	t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } ⊢ ¬g ∈ ↑(formalApplicationFunction t Δ)	t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) ⊢ False
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/CanonicalModel.lean	canonicalSatisfaction	[172, 1]	[235, 39]	have ⟨q,⟨prf₁⟩,l₂⟩ := h₃	t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) ⊢ False	t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) q : Form prf₁ : BProof {f} q l₂ : q⊃g ∈ ↑t ⊢ False
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/CanonicalModel.lean	canonicalSatisfaction	[172, 1]	[235, 39]	have ⟨prf₂⟩ := t.property.mp l₂	t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) q : Form prf₁ : BProof {f} q l₂ : q⊃g ∈ ↑t ⊢ False	t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) q : Form prf₁ : BProof {f} q l₂ : q⊃g ∈ ↑t prf₂ : BProof (↑t) (q⊃g) ⊢ False
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/CanonicalModel.lean	canonicalSatisfaction	[172, 1]	[235, 39]	have prf₃ := BProof.mp prf₂ (BTheorem.hs prf₁.toTheorem BTheorem.taut)	t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) q : Form prf₁ : BProof {f} q l₂ : q⊃g ∈ ↑t prf₂ : BProof (↑t) (q⊃g) ⊢ False	t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) q : Form prf₁ : BProof {f} q l₂ : q⊃g ∈ ↑t prf₂ : BProof (↑t) (q⊃g) prf₃ : BProof (↑t) (f⊃g) ⊢ False
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/CanonicalModel.lean	canonicalSatisfaction	[172, 1]	[235, 39]	exact h₂ $ t.property.mpr ⟨prf₃⟩	t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) q : Form prf₁ : BProof {f} q l₂ : q⊃g ∈ ↑t prf₂ : BProof (↑t) (q⊃g) prf₃ : BProof (↑t) (f⊃g) ⊢ False	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/CanonicalModel.lean	canonicalSatisfaction	[172, 1]	[235, 39]	intros r h₂	t : Th f g : Form h₁ : f⊃g ∈ ↑t ⊢ t⊨f⊃g	t : Th f g : Form h₁ : f⊃g ∈ ↑t r : Th h₂ : r⊨f ⊢ t∙r⊨g
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/CanonicalModel.lean	canonicalSatisfaction	[172, 1]	[235, 39]	have l₁ := canonicalSatisfaction.mp h₂	t : Th f g : Form h₁ : f⊃g ∈ ↑t r : Th h₂ : r⊨f ⊢ t∙r⊨g	t : Th f g : Form h₁ : f⊃g ∈ ↑t r : Th h₂ : r⊨f l₁ : f ∈ ↑r ⊢ t∙r⊨g
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/CanonicalModel.lean	canonicalSatisfaction	[172, 1]	[235, 39]	have l₂ : g ∈ (formalApplicationFunction t r).val := ⟨f, l₁, h₁⟩	t : Th f g : Form h₁ : f⊃g ∈ ↑t r : Th h₂ : r⊨f l₁ : f ∈ ↑r ⊢ t∙r⊨g	t : Th f g : Form h₁ : f⊃g ∈ ↑t r : Th h₂ : r⊨f l₁ : f ∈ ↑r l₂ : g ∈ ↑(formalApplicationFunction t r) ⊢ t∙r⊨g
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/CanonicalModel.lean	canonicalSatisfaction	[172, 1]	[235, 39]	exact canonicalSatisfaction.mpr l₂	t : Th f g : Form h₁ : f⊃g ∈ ↑t r : Th h₂ : r⊨f l₁ : f ∈ ↑r l₂ : g ∈ ↑(formalApplicationFunction t r) ⊢ t∙r⊨g	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	intros b	t : Th Δ : Ctx ⊢ ∀ (b a : Lex (ℕ × ℕ)), a ≤ b → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ b	t : Th Δ : Ctx b : Lex (ℕ × ℕ) ⊢ ∀ (a : Lex (ℕ × ℕ)), a ≤ b → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ b
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	match b with \| ⟨0, 0⟩ => intros a h₁ cases h₁ case left a₁ _ h₂ => exact False.elim $ Nat.not_lt_zero a₁ h₂ case right b₁ h₂ => rw [Nat.le_zero_eq b₁] at h₂ rw [h₂] \| ⟨i + 1, 0⟩ => intros a h₁ cases h₁ case left a₁ b₁ h₂ => have l₁ : a₁ < i ∨ a₁ = i := Nat.lt_or_eq_of_le $ Nat.lt_succ.mp h₂ have l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ := by cases l₁ case inl h₂ => exact Or.inl h₂ case inr h₂ => exact Or.inr ⟨h₂, le_refl b₁⟩ have l₃ := (Prod.Lex.le_iff (a₁, b₁) (i,b₁)).mpr l₂ have l₄ := @lindenbaumSequenceMonotone' t Δ (i,b₁) (a₁, b₁) l₃ apply le_trans l₄ intros f h₂ exact ⟨b₁,h₂⟩ case right b₁ h₂ => rw [Nat.le_zero_eq b₁] at h₂ rw [h₂] \| ⟨i, j + 1⟩ => have lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) := by intros f h₃ unfold lindenbaumSequence split case h_1 _ heq \| h_2 _ heq => injection heq; contradiction case h_3 i' j' heq => injection heq with heq₁ heq₂ injection heq₂ with heq₂ have heq₃ : j = j' := heq₂ rw [←heq₁, ←heq₃] change let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev intros prev l r split case inl => split case inl \| inr => apply Or.inl h₃ case inr => exact h₃ intros a h₁ cases h₁ case left a₁ b₁ h₂ => have l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j := Or.inl h₂ have l₂ := (Prod.Lex.le_iff (a₁, b₁) (i,j)).mpr l₁ have l₃ := @lindenbaumSequenceMonotone' t Δ (i,j) (a₁, b₁) l₂ apply le_trans l₃ exact lem case right b₁ h₂ => cases h₂ case refl => intros _ h₁; assumption case step h₂ => have l₁ : i < i ∨ i = i ∧ b₁ ≤ j := Or.inr ⟨rfl, h₂⟩ have l₂ := (Prod.Lex.le_iff (i, b₁) (i,j)).mpr l₁ have l₃ := @lindenbaumSequenceMonotone' t Δ (i,j) (i, b₁) l₂ apply le_trans l₃ exact lem	t : Th Δ : Ctx b : Lex (ℕ × ℕ) ⊢ ∀ (a : Lex (ℕ × ℕ)), a ≤ b → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ b	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	intros a h₁	t : Th Δ : Ctx b : Lex (ℕ × ℕ) ⊢ ∀ (a : Lex (ℕ × ℕ)), a ≤ (0, 0) → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (0, 0)	t : Th Δ : Ctx b a : Lex (ℕ × ℕ) h₁ : a ≤ (0, 0) ⊢ lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (0, 0)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	cases h₁	t : Th Δ : Ctx b a : Lex (ℕ × ℕ) h₁ : a ≤ (0, 0) ⊢ lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (0, 0)	case left t : Th Δ : Ctx b : Lex (ℕ × ℕ) a₁✝ b₁✝ : ℕ h✝ : a₁✝ < 0 ⊢ lindenbaumSequence t Δ (a₁✝, b₁✝) ⊆ lindenbaumSequence t Δ (0, 0) case right t : Th Δ : Ctx b : Lex (ℕ × ℕ) b₁✝ : ℕ h✝ : b₁✝ ≤ 0 ⊢ lindenbaumSequence t Δ (0, b₁✝) ⊆ lindenbaumSequence t Δ (0, 0)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case left a₁ _ h₂ => exact False.elim $ Nat.not_lt_zero a₁ h₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) a₁ b₁✝ : ℕ h₂ : a₁ < 0 ⊢ lindenbaumSequence t Δ (a₁, b₁✝) ⊆ lindenbaumSequence t Δ (0, 0)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case right b₁ h₂ => rw [Nat.le_zero_eq b₁] at h₂ rw [h₂]	t : Th Δ : Ctx b : Lex (ℕ × ℕ) b₁ : ℕ h₂ : b₁ ≤ 0 ⊢ lindenbaumSequence t Δ (0, b₁) ⊆ lindenbaumSequence t Δ (0, 0)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	exact False.elim $ Nat.not_lt_zero a₁ h₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) a₁ b₁✝ : ℕ h₂ : a₁ < 0 ⊢ lindenbaumSequence t Δ (a₁, b₁✝) ⊆ lindenbaumSequence t Δ (0, 0)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	rw [Nat.le_zero_eq b₁] at h₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) b₁ : ℕ h₂ : b₁ ≤ 0 ⊢ lindenbaumSequence t Δ (0, b₁) ⊆ lindenbaumSequence t Δ (0, 0)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) b₁ : ℕ h₂ : b₁ = 0 ⊢ lindenbaumSequence t Δ (0, b₁) ⊆ lindenbaumSequence t Δ (0, 0)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	rw [h₂]	t : Th Δ : Ctx b : Lex (ℕ × ℕ) b₁ : ℕ h₂ : b₁ = 0 ⊢ lindenbaumSequence t Δ (0, b₁) ⊆ lindenbaumSequence t Δ (0, 0)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	intros a h₁	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i : ℕ ⊢ ∀ (a : Lex (ℕ × ℕ)), a ≤ (i + 1, 0) → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i + 1, 0)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i : ℕ a : Lex (ℕ × ℕ) h₁ : a ≤ (i + 1, 0) ⊢ lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i + 1, 0)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	cases h₁	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i : ℕ a : Lex (ℕ × ℕ) h₁ : a ≤ (i + 1, 0) ⊢ lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i + 1, 0)	case left t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁✝ b₁✝ : ℕ h✝ : a₁✝ < i + 1 ⊢ lindenbaumSequence t Δ (a₁✝, b₁✝) ⊆ lindenbaumSequence t Δ (i + 1, 0) case right t : Th Δ : Ctx b : Lex (ℕ × ℕ) i b₁✝ : ℕ h✝ : b₁✝ ≤ 0 ⊢ lindenbaumSequence t Δ (i + 1, b₁✝) ⊆ lindenbaumSequence t Δ (i + 1, 0)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case left a₁ b₁ h₂ => have l₁ : a₁ < i ∨ a₁ = i := Nat.lt_or_eq_of_le $ Nat.lt_succ.mp h₂ have l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ := by cases l₁ case inl h₂ => exact Or.inl h₂ case inr h₂ => exact Or.inr ⟨h₂, le_refl b₁⟩ have l₃ := (Prod.Lex.le_iff (a₁, b₁) (i,b₁)).mpr l₂ have l₄ := @lindenbaumSequenceMonotone' t Δ (i,b₁) (a₁, b₁) l₃ apply le_trans l₄ intros f h₂ exact ⟨b₁,h₂⟩	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case right b₁ h₂ => rw [Nat.le_zero_eq b₁] at h₂ rw [h₂]	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i b₁ : ℕ h₂ : b₁ ≤ 0 ⊢ lindenbaumSequence t Δ (i + 1, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	have l₁ : a₁ < i ∨ a₁ = i := Nat.lt_or_eq_of_le $ Nat.lt_succ.mp h₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	have l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ := by cases l₁ case inl h₂ => exact Or.inl h₂ case inr h₂ => exact Or.inr ⟨h₂, le_refl b₁⟩	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	have l₃ := (Prod.Lex.le_iff (a₁, b₁) (i,b₁)).mpr l₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	have l₄ := @lindenbaumSequenceMonotone' t Δ (i,b₁) (a₁, b₁) l₃	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) l₄ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, b₁) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	apply le_trans l₄	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) l₄ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, b₁) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) l₄ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, b₁) ⊢ lindenbaumSequence t Δ (i, b₁) ≤ lindenbaumSequence t Δ (i + 1, 0)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	intros f h₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) l₄ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, b₁) ⊢ lindenbaumSequence t Δ (i, b₁) ≤ lindenbaumSequence t Δ (i + 1, 0)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂✝ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) l₄ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, b₁) f : Form h₂ : f ∈ lindenbaumSequence t Δ (i, b₁) ⊢ f ∈ lindenbaumSequence t Δ (i + 1, 0)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	exact ⟨b₁,h₂⟩	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂✝ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) l₄ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, b₁) f : Form h₂ : f ∈ lindenbaumSequence t Δ (i, b₁) ⊢ f ∈ lindenbaumSequence t Δ (i + 1, 0)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	cases l₁	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i ⊢ a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁	case inl t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 h✝ : a₁ < i ⊢ a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ case inr t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 h✝ : a₁ = i ⊢ a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case inl h₂ => exact Or.inl h₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂✝ : a₁ < i + 1 h₂ : a₁ < i ⊢ a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case inr h₂ => exact Or.inr ⟨h₂, le_refl b₁⟩	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂✝ : a₁ < i + 1 h₂ : a₁ = i ⊢ a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	exact Or.inl h₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂✝ : a₁ < i + 1 h₂ : a₁ < i ⊢ a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	exact Or.inr ⟨h₂, le_refl b₁⟩	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂✝ : a₁ < i + 1 h₂ : a₁ = i ⊢ a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	rw [Nat.le_zero_eq b₁] at h₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i b₁ : ℕ h₂ : b₁ ≤ 0 ⊢ lindenbaumSequence t Δ (i + 1, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i b₁ : ℕ h₂ : b₁ = 0 ⊢ lindenbaumSequence t Δ (i + 1, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	rw [h₂]	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i b₁ : ℕ h₂ : b₁ = 0 ⊢ lindenbaumSequence t Δ (i + 1, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	have lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) := by intros f h₃ unfold lindenbaumSequence split case h_1 _ heq \| h_2 _ heq => injection heq; contradiction case h_3 i' j' heq => injection heq with heq₁ heq₂ injection heq₂ with heq₂ have heq₃ : j = j' := heq₂ rw [←heq₁, ←heq₃] change let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev intros prev l r split case inl => split case inl \| inr => apply Or.inl h₃ case inr => exact h₃	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ ⊢ ∀ (a : Lex (ℕ × ℕ)), a ≤ (i, j + 1) → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i, j + 1)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) ⊢ ∀ (a : Lex (ℕ × ℕ)), a ≤ (i, j + 1) → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i, j + 1)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	intros a h₁	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) ⊢ ∀ (a : Lex (ℕ × ℕ)), a ≤ (i, j + 1) → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i, j + 1)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a : Lex (ℕ × ℕ) h₁ : a ≤ (i, j + 1) ⊢ lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i, j + 1)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	cases h₁	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a : Lex (ℕ × ℕ) h₁ : a ≤ (i, j + 1) ⊢ lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i, j + 1)	case left t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁✝ b₁✝ : ℕ h✝ : a₁✝ < i ⊢ lindenbaumSequence t Δ (a₁✝, b₁✝) ⊆ lindenbaumSequence t Δ (i, j + 1) case right t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁✝ : ℕ h✝ : b₁✝ ≤ j + 1 ⊢ lindenbaumSequence t Δ (i, b₁✝) ⊆ lindenbaumSequence t Δ (i, j + 1)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case left a₁ b₁ h₂ => have l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j := Or.inl h₂ have l₂ := (Prod.Lex.le_iff (a₁, b₁) (i,j)).mpr l₁ have l₃ := @lindenbaumSequenceMonotone' t Δ (i,j) (a₁, b₁) l₂ apply le_trans l₃ exact lem	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case right b₁ h₂ => cases h₂ case refl => intros _ h₁; assumption case step h₂ => have l₁ : i < i ∨ i = i ∧ b₁ ≤ j := Or.inr ⟨rfl, h₂⟩ have l₂ := (Prod.Lex.le_iff (i, b₁) (i,j)).mpr l₁ have l₃ := @lindenbaumSequenceMonotone' t Δ (i,j) (i, b₁) l₂ apply le_trans l₃ exact lem	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : b₁ ≤ j + 1 ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	intros f h₃	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ ⊢ lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) ⊢ f ∈ lindenbaumSequence t Δ (i, j + 1)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	unfold lindenbaumSequence	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) ⊢ f ∈ lindenbaumSequence t Δ (i, j + 1)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) ⊢ f ∈ match (i, j + 1) with \| (0, 0) => ↑t \| (Nat.succ i, 0) => { f \| ∃ j, f ∈ lindenbaumSequence t Δ (i, j) } \| (i, Nat.succ j) => let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	split	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) ⊢ f ∈ match (i, j + 1) with \| (0, 0) => ↑t \| (Nat.succ i, 0) => { f \| ∃ j, f ∈ lindenbaumSequence t Δ (i, j) } \| (i, Nat.succ j) => let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev	case h_1 t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) heq✝ : (i, j + 1) = (0, 0) ⊢ f ∈ ↑t case h_2 t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i✝ : ℕ heq✝ : (i, j + 1) = (Nat.succ i✝, 0) ⊢ f ∈ { f \| ∃ j, f ∈ lindenbaumSequence t Δ (i✝, j) } case h_3 t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i✝ j✝ : ℕ heq✝ : (i, j + 1) = (i✝, Nat.succ j✝) ⊢ f ∈ let prev := lindenbaumSequence t Δ (i✝, j✝); let l := (Denumerable.ofNat (Form × Form) j✝).fst; let r := (Denumerable.ofNat (Form × Form) j✝).snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case h_1 _ heq \| h_2 _ heq => injection heq; contradiction	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i✝ : ℕ heq : (i, j + 1) = (Nat.succ i✝, 0) ⊢ f ∈ { f \| ∃ j, f ∈ lindenbaumSequence t Δ (i✝, j) }	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case h_3 i' j' heq => injection heq with heq₁ heq₂ injection heq₂ with heq₂ have heq₃ : j = j' := heq₂ rw [←heq₁, ←heq₃] change let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev intros prev l r split case inl => split case inl \| inr => apply Or.inl h₃ case inr => exact h₃	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq : (i, j + 1) = (i', Nat.succ j') ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	injection heq	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i✝ : ℕ heq : (i, j + 1) = (Nat.succ i✝, 0) ⊢ f ∈ { f \| ∃ j, f ∈ lindenbaumSequence t Δ (i✝, j) }	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i✝ : ℕ fst_eq✝ : i = Nat.succ i✝ snd_eq✝ : j + 1 = 0 ⊢ f ∈ { f \| ∃ j, f ∈ lindenbaumSequence t Δ (i✝, j) }
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	contradiction	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i✝ : ℕ fst_eq✝ : i = Nat.succ i✝ snd_eq✝ : j + 1 = 0 ⊢ f ∈ { f \| ∃ j, f ∈ lindenbaumSequence t Δ (i✝, j) }	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	injection heq with heq₁ heq₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq : (i, j + 1) = (i', Nat.succ j') ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : j + 1 = Nat.succ j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	injection heq₂ with heq₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : j + 1 = Nat.succ j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	have heq₃ : j = j' := heq₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	rw [←heq₁, ←heq₃]	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	change let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' ⊢ let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	intros prev l r	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' ⊢ let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd ⊢ f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	split	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd ⊢ f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev	case inl t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝ : l¦r ∈ ▲prev ⊢ f ∈ if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} case inr t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝ : ¬l¦r ∈ ▲prev ⊢ f ∈ prev
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case inl => split case inl \| inr => apply Or.inl h₃	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝ : l¦r ∈ ▲prev ⊢ f ∈ if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r}	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case inr => exact h₃	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝ : ¬l¦r ∈ ▲prev ⊢ f ∈ prev	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	split	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝ : l¦r ∈ ▲prev ⊢ f ∈ if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r}	case inl t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝¹ : l¦r ∈ ▲prev h✝ : ▲(prev ∪ {l}) ∩ Δ = ∅ ⊢ f ∈ prev ∪ {l} case inr t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝¹ : l¦r ∈ ▲prev h✝ : ¬▲(prev ∪ {l}) ∩ Δ = ∅ ⊢ f ∈ prev ∪ {r}
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case inl \| inr => apply Or.inl h₃	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝¹ : l¦r ∈ ▲prev h✝ : ¬▲(prev ∪ {l}) ∩ Δ = ∅ ⊢ f ∈ prev ∪ {r}	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	apply Or.inl h₃	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝¹ : l¦r ∈ ▲prev h✝ : ¬▲(prev ∪ {l}) ∩ Δ = ∅ ⊢ f ∈ prev ∪ {r}	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	exact h₃	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝ : ¬l¦r ∈ ▲prev ⊢ f ∈ prev	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	have l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j := Or.inl h₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	have l₂ := (Prod.Lex.le_iff (a₁, b₁) (i,j)).mpr l₁	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j l₂ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, j) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	have l₃ := @lindenbaumSequenceMonotone' t Δ (i,j) (a₁, b₁) l₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j l₂ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, j) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j l₂ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	apply le_trans l₃	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j l₂ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j l₂ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	exact lem	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j l₂ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	cases h₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : b₁ ≤ j + 1 ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)	case refl t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) ⊢ lindenbaumSequence t Δ (i, j + 1) ⊆ lindenbaumSequence t Δ (i, j + 1) case step t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ a✝ : Nat.le b₁ (Nat.add j 0) ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case refl => intros _ h₁; assumption	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) ⊢ lindenbaumSequence t Δ (i, j + 1) ⊆ lindenbaumSequence t Δ (i, j + 1)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	case step h₂ => have l₁ : i < i ∨ i = i ∧ b₁ ≤ j := Or.inr ⟨rfl, h₂⟩ have l₂ := (Prod.Lex.le_iff (i, b₁) (i,j)).mpr l₁ have l₃ := @lindenbaumSequenceMonotone' t Δ (i,j) (i, b₁) l₂ apply le_trans l₃ exact lem	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	intros _ h₁	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) ⊢ lindenbaumSequence t Δ (i, j + 1) ⊆ lindenbaumSequence t Δ (i, j + 1)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a✝ : Form h₁ : a✝ ∈ lindenbaumSequence t Δ (i, j + 1) ⊢ a✝ ∈ lindenbaumSequence t Δ (i, j + 1)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	assumption	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a✝ : Form h₁ : a✝ ∈ lindenbaumSequence t Δ (i, j + 1) ⊢ a✝ ∈ lindenbaumSequence t Δ (i, j + 1)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	have l₁ : i < i ∨ i = i ∧ b₁ ≤ j := Or.inr ⟨rfl, h₂⟩	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	have l₂ := (Prod.Lex.le_iff (i, b₁) (i,j)).mpr l₁	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j l₂ : ↑toLex (i, b₁) ≤ ↑toLex (i, j) ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	have l₃ := @lindenbaumSequenceMonotone' t Δ (i,j) (i, b₁) l₂	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j l₂ : ↑toLex (i, b₁) ≤ ↑toLex (i, j) ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j l₂ : ↑toLex (i, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	apply le_trans l₃	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j l₂ : ↑toLex (i, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j l₂ : ↑toLex (i, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone'	[21, 1]	[88, 69]	exact lem	t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j l₂ : ↑toLex (i, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone	[90, 1]	[92, 40]	intros a b	t : Th Δ : Ctx ⊢ Monotone (lindenbaumSequence t Δ)	t : Th Δ : Ctx a b : Lex (ℕ × ℕ) ⊢ a ≤ b → lindenbaumSequence t Δ a ≤ lindenbaumSequence t Δ b
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumSequenceMonotone	[90, 1]	[92, 40]	exact lindenbaumSequenceMonotone' b a	t : Th Δ : Ctx a b : Lex (ℕ × ℕ) ⊢ a ≤ b → lindenbaumSequence t Δ a ≤ lindenbaumSequence t Δ b	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumStageMonotone	[96, 1]	[100, 51]	intros a b h₁	t : Th Δ : Ctx i : ℕ ⊢ Monotone fun j => lindenbaumSequence t Δ (i, j)	t : Th Δ : Ctx i a b : ℕ h₁ : a ≤ b ⊢ (fun j => lindenbaumSequence t Δ (i, j)) a ≤ (fun j => lindenbaumSequence t Δ (i, j)) b
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumStageMonotone	[96, 1]	[100, 51]	change lindenbaumSequence t Δ (i, a) ≤ lindenbaumSequence t Δ (i, b)	t : Th Δ : Ctx i a b : ℕ h₁ : a ≤ b ⊢ (fun j => lindenbaumSequence t Δ (i, j)) a ≤ (fun j => lindenbaumSequence t Δ (i, j)) b	t : Th Δ : Ctx i a b : ℕ h₁ : a ≤ b ⊢ lindenbaumSequence t Δ (i, a) ≤ lindenbaumSequence t Δ (i, b)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumStageMonotone	[96, 1]	[100, 51]	have l₂ := (Prod.Lex.le_iff (i, a) (i,b)).mpr $ Or.inr ⟨rfl,h₁⟩	t : Th Δ : Ctx i a b : ℕ h₁ : a ≤ b ⊢ lindenbaumSequence t Δ (i, a) ≤ lindenbaumSequence t Δ (i, b)	t : Th Δ : Ctx i a b : ℕ h₁ : a ≤ b l₂ : ↑toLex (i, a) ≤ ↑toLex (i, b) ⊢ lindenbaumSequence t Δ (i, a) ≤ lindenbaumSequence t Δ (i, b)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumStageMonotone	[96, 1]	[100, 51]	exact lindenbaumSequenceMonotone' (i,b) (i,a) l₂	t : Th Δ : Ctx i a b : ℕ h₁ : a ≤ b l₂ : ↑toLex (i, a) ≤ ↑toLex (i, b) ⊢ lindenbaumSequence t Δ (i, a) ≤ lindenbaumSequence t Δ (i, b)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumExtensionExtends	[102, 1]	[105, 13]	intros f h₁	t : Th Δ : Ctx ⊢ ↑t ⊆ lindenbaumExtension t Δ	t : Th Δ : Ctx f : Form h₁ : f ∈ ↑t ⊢ f ∈ lindenbaumExtension t Δ
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumExtensionExtends	[102, 1]	[105, 13]	refine ⟨⟨0,0⟩,?_⟩	t : Th Δ : Ctx f : Form h₁ : f ∈ ↑t ⊢ f ∈ lindenbaumExtension t Δ	t : Th Δ : Ctx f : Form h₁ : f ∈ ↑t ⊢ f ∈ lindenbaumSequence t Δ (0, 0)
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumExtensionExtends	[102, 1]	[105, 13]	assumption	t : Th Δ : Ctx f : Form h₁ : f ∈ ↑t ⊢ f ∈ lindenbaumSequence t Δ (0, 0)	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumIsFormal	[107, 1]	[148, 52]	intros f	t : Th Δ : Ctx ⊢ formalTheory (lindenbaumExtension t Δ)	t : Th Δ : Ctx f : Form ⊢ f ∈ lindenbaumExtension t Δ ↔ lindenbaumExtension t Δ⊢f
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumIsFormal	[107, 1]	[148, 52]	apply Iff.intro	t : Th Δ : Ctx f : Form ⊢ f ∈ lindenbaumExtension t Δ ↔ lindenbaumExtension t Δ⊢f	case mp t : Th Δ : Ctx f : Form ⊢ f ∈ lindenbaumExtension t Δ → lindenbaumExtension t Δ⊢f case mpr t : Th Δ : Ctx f : Form ⊢ lindenbaumExtension t Δ⊢f → f ∈ lindenbaumExtension t Δ
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumIsFormal	[107, 1]	[148, 52]	case mp => intro h₁ exact ⟨BProof.ax h₁⟩	t : Th Δ : Ctx f : Form ⊢ f ∈ lindenbaumExtension t Δ → lindenbaumExtension t Δ⊢f	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumIsFormal	[107, 1]	[148, 52]	case mpr => intro h₁ have ⟨prf₁⟩ := h₁ have ⟨s, l₁, fprf⟩ := BProof.compactness prf₁ have ⟨⟨i,j⟩,l₂⟩ := finiteExhaustion lindenbaumSequenceMonotone l₁ have l₃ : lindenbaumSequence t Δ ⟨i,j⟩ ⊆ lindenbaumSequence t Δ ⟨i + 1,Encodable.encode (f,f)⟩ := by apply lindenbaumSequenceMonotone apply (Prod.Lex.le_iff (i,j) (i + 1,Encodable.encode (f,f))).mpr $ Or.inl $ Nat.lt_succ_self i have prf₂ := BProof.monotone (le_trans l₂ l₃) fprf have prf₃ : BProof (lindenbaumSequence t Δ ⟨i+1,Encodable.encode (f,f)⟩) (f ¦ f) := BProof.mp prf₂ BTheorem.orI₁ clear s h₁ l₁ l₂ l₃ fprf prf₁ prf₂ have l₄ : f ∈ lindenbaumSequence t Δ ⟨i + 1, Encodable.encode (f,f) + 1⟩ := by unfold lindenbaumSequence change let prev := lindenbaumSequence t Δ (i + 1, Encodable.encode (f,f)); let l := (Denumerable.ofNat (Form × Form) (Encodable.encode (f,f))).fst; let r := (Denumerable.ofNat (Form × Form) (Encodable.encode (f,f))).snd; f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev intros prev l r have l₅ : l = f := by change (Denumerable.ofNat (Form × Form) (Encodable.encode (f, f))).fst = f rw [Denumerable.ofNat_encode (f,f)] have l₆ : r = f := by change (Denumerable.ofNat (Form × Form) (Encodable.encode (f, f))).snd = f rw [Denumerable.ofNat_encode (f,f)] split case inl h₂ => split . rw [l₅]; exact Or.inr rfl . rw [l₆]; exact Or.inr rfl case inr h₂ => apply False.elim have l₇ : f¦f ∈ ▲prev := ⟨prf₃⟩ rw [l₅,l₆] at h₂ exact h₂ l₇ exact ⟨⟨i + 1, Encodable.encode (f,f) + 1⟩, l₄⟩	t : Th Δ : Ctx f : Form ⊢ lindenbaumExtension t Δ⊢f → f ∈ lindenbaumExtension t Δ	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumIsFormal	[107, 1]	[148, 52]	intro h₁	t : Th Δ : Ctx f : Form ⊢ f ∈ lindenbaumExtension t Δ → lindenbaumExtension t Δ⊢f	t : Th Δ : Ctx f : Form h₁ : f ∈ lindenbaumExtension t Δ ⊢ lindenbaumExtension t Δ⊢f
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumIsFormal	[107, 1]	[148, 52]	exact ⟨BProof.ax h₁⟩	t : Th Δ : Ctx f : Form h₁ : f ∈ lindenbaumExtension t Δ ⊢ lindenbaumExtension t Δ⊢f	no goals
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumIsFormal	[107, 1]	[148, 52]	intro h₁	t : Th Δ : Ctx f : Form ⊢ lindenbaumExtension t Δ⊢f → f ∈ lindenbaumExtension t Δ	t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f ⊢ f ∈ lindenbaumExtension t Δ
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumIsFormal	[107, 1]	[148, 52]	have ⟨prf₁⟩ := h₁	t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f ⊢ f ∈ lindenbaumExtension t Δ	t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f prf₁ : BProof (lindenbaumExtension t Δ) f ⊢ f ∈ lindenbaumExtension t Δ
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumIsFormal	[107, 1]	[148, 52]	have ⟨s, l₁, fprf⟩ := BProof.compactness prf₁	t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f prf₁ : BProof (lindenbaumExtension t Δ) f ⊢ f ∈ lindenbaumExtension t Δ	t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f prf₁ : BProof (lindenbaumExtension t Δ) f s : Finset Form l₁ : ↑s ⊆ lindenbaumExtension t Δ fprf : BProof (↑s) f ⊢ f ∈ lindenbaumExtension t Δ
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumIsFormal	[107, 1]	[148, 52]	have ⟨⟨i,j⟩,l₂⟩ := finiteExhaustion lindenbaumSequenceMonotone l₁	t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f prf₁ : BProof (lindenbaumExtension t Δ) f s : Finset Form l₁ : ↑s ⊆ lindenbaumExtension t Δ fprf : BProof (↑s) f ⊢ f ∈ lindenbaumExtension t Δ	t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f prf₁ : BProof (lindenbaumExtension t Δ) f s : Finset Form l₁ : ↑s ⊆ lindenbaumExtension t Δ fprf : BProof (↑s) f i j : ℕ l₂ : ↑s ⊆ lindenbaumSequence t Δ (i, j) ⊢ f ∈ lindenbaumExtension t Δ
https://github.com/gleachkr/Completeness-For-Fine-Semantics.git	0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f	Fine/SystemB/Lindenbaum.lean	lindenbaumIsFormal	[107, 1]	[148, 52]	have l₃ : lindenbaumSequence t Δ ⟨i,j⟩ ⊆ lindenbaumSequence t Δ ⟨i + 1,Encodable.encode (f,f)⟩ := by apply lindenbaumSequenceMonotone apply (Prod.Lex.le_iff (i,j) (i + 1,Encodable.encode (f,f))).mpr $ Or.inl $ Nat.lt_succ_self i	t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f prf₁ : BProof (lindenbaumExtension t Δ) f s : Finset Form l₁ : ↑s ⊆ lindenbaumExtension t Δ fprf : BProof (↑s) f i j : ℕ l₂ : ↑s ⊆ lindenbaumSequence t Δ (i, j) ⊢ f ∈ lindenbaumExtension t Δ	t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f prf₁ : BProof (lindenbaumExtension t Δ) f s : Finset Form l₁ : ↑s ⊆ lindenbaumExtension t Δ fprf : BProof (↑s) f i j : ℕ l₂ : ↑s ⊆ lindenbaumSequence t Δ (i, j) l₃ : lindenbaumSequence t Δ (i, j) ⊆ lindenbaumSequence t Δ (i + 1, Encodable.encode (f, f)) ⊢ f ∈ lindenbaumExtension t Δ

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/CanonicalModel.lean

canonicalSatisfaction

[172, 1]

[235, 39]

let Δ : Th := ⟨▲{f}, generatedFormal {f}⟩

case h t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t ⊢ False

case h t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } ⊢ False

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/CanonicalModel.lean

canonicalSatisfaction

[172, 1]

[235, 39]

have l₁ : ¬(g ∈ (formalApplicationFunction t Δ).val) := by intros h₃ have ⟨q,⟨prf₁⟩,l₂⟩ := h₃ have ⟨prf₂⟩ := t.property.mp l₂ have prf₃ := BProof.mp prf₂ (BTheorem.hs prf₁.toTheorem BTheorem.taut) exact h₂ $ t.property.mpr ⟨prf₃⟩

case h t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } ⊢ False

case h t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } l₁ : ¬g ∈ ↑(formalApplicationFunction t Δ) ⊢ False

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/CanonicalModel.lean

canonicalSatisfaction

[172, 1]

[235, 39]

have l₂ : Δ ⊨ f := canonicalSatisfaction.mpr ⟨BProof.ax rfl⟩

case h t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } l₁ : ¬g ∈ ↑(formalApplicationFunction t Δ) ⊢ False

case h t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } l₁ : ¬g ∈ ↑(formalApplicationFunction t Δ) l₂ : Δ⊨f ⊢ False

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/CanonicalModel.lean

canonicalSatisfaction

[172, 1]

[235, 39]

exact l₁ $ canonicalSatisfaction.mp (h₁ l₂)

case h t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } l₁ : ¬g ∈ ↑(formalApplicationFunction t Δ) l₂ : Δ⊨f ⊢ False

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/CanonicalModel.lean

canonicalSatisfaction

[172, 1]

[235, 39]

intros h₃

t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } ⊢ ¬g ∈ ↑(formalApplicationFunction t Δ)

t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) ⊢ False

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/CanonicalModel.lean

canonicalSatisfaction

[172, 1]

[235, 39]

have ⟨q,⟨prf₁⟩,l₂⟩ := h₃

t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) ⊢ False

t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) q : Form prf₁ : BProof {f} q l₂ : q⊃g ∈ ↑t ⊢ False

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/CanonicalModel.lean

canonicalSatisfaction

[172, 1]

[235, 39]

have ⟨prf₂⟩ := t.property.mp l₂

t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) q : Form prf₁ : BProof {f} q l₂ : q⊃g ∈ ↑t ⊢ False

t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) q : Form prf₁ : BProof {f} q l₂ : q⊃g ∈ ↑t prf₂ : BProof (↑t) (q⊃g) ⊢ False

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/CanonicalModel.lean

canonicalSatisfaction

[172, 1]

[235, 39]

have prf₃ := BProof.mp prf₂ (BTheorem.hs prf₁.toTheorem BTheorem.taut)

t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) q : Form prf₁ : BProof {f} q l₂ : q⊃g ∈ ↑t prf₂ : BProof (↑t) (q⊃g) ⊢ False

t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) q : Form prf₁ : BProof {f} q l₂ : q⊃g ∈ ↑t prf₂ : BProof (↑t) (q⊃g) prf₃ : BProof (↑t) (f⊃g) ⊢ False

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/CanonicalModel.lean

canonicalSatisfaction

[172, 1]

[235, 39]

exact h₂ $ t.property.mpr ⟨prf₃⟩

t : Th f g : Form h₁ : t⊨f⊃g h₂ : ¬f⊃g ∈ ↑t Δ : Th := { val := ▲{f}, property := (_ : ∀ {f_1 : Form}, f_1 ∈ ▲{f} ↔ ▲{f}⊢f_1) } h₃ : g ∈ ↑(formalApplicationFunction t Δ) q : Form prf₁ : BProof {f} q l₂ : q⊃g ∈ ↑t prf₂ : BProof (↑t) (q⊃g) prf₃ : BProof (↑t) (f⊃g) ⊢ False

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/CanonicalModel.lean

canonicalSatisfaction

[172, 1]

[235, 39]

intros r h₂

t : Th f g : Form h₁ : f⊃g ∈ ↑t ⊢ t⊨f⊃g

t : Th f g : Form h₁ : f⊃g ∈ ↑t r : Th h₂ : r⊨f ⊢ t∙r⊨g

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/CanonicalModel.lean

canonicalSatisfaction

[172, 1]

[235, 39]

have l₁ := canonicalSatisfaction.mp h₂

t : Th f g : Form h₁ : f⊃g ∈ ↑t r : Th h₂ : r⊨f ⊢ t∙r⊨g

t : Th f g : Form h₁ : f⊃g ∈ ↑t r : Th h₂ : r⊨f l₁ : f ∈ ↑r ⊢ t∙r⊨g

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/CanonicalModel.lean

canonicalSatisfaction

[172, 1]

[235, 39]

have l₂ : g ∈ (formalApplicationFunction t r).val := ⟨f, l₁, h₁⟩

t : Th f g : Form h₁ : f⊃g ∈ ↑t r : Th h₂ : r⊨f l₁ : f ∈ ↑r ⊢ t∙r⊨g

t : Th f g : Form h₁ : f⊃g ∈ ↑t r : Th h₂ : r⊨f l₁ : f ∈ ↑r l₂ : g ∈ ↑(formalApplicationFunction t r) ⊢ t∙r⊨g

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/CanonicalModel.lean

canonicalSatisfaction

[172, 1]

[235, 39]

exact canonicalSatisfaction.mpr l₂

t : Th f g : Form h₁ : f⊃g ∈ ↑t r : Th h₂ : r⊨f l₁ : f ∈ ↑r l₂ : g ∈ ↑(formalApplicationFunction t r) ⊢ t∙r⊨g

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

intros b

t : Th Δ : Ctx ⊢ ∀ (b a : Lex (ℕ × ℕ)), a ≤ b → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ b

t : Th Δ : Ctx b : Lex (ℕ × ℕ) ⊢ ∀ (a : Lex (ℕ × ℕ)), a ≤ b → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ b

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

match b with | ⟨0, 0⟩ => intros a h₁ cases h₁ case left a₁ _ h₂ => exact False.elim $ Nat.not_lt_zero a₁ h₂ case right b₁ h₂ => rw [Nat.le_zero_eq b₁] at h₂ rw [h₂] | ⟨i + 1, 0⟩ => intros a h₁ cases h₁ case left a₁ b₁ h₂ => have l₁ : a₁ < i ∨ a₁ = i := Nat.lt_or_eq_of_le $ Nat.lt_succ.mp h₂ have l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ := by cases l₁ case inl h₂ => exact Or.inl h₂ case inr h₂ => exact Or.inr ⟨h₂, le_refl b₁⟩ have l₃ := (Prod.Lex.le_iff (a₁, b₁) (i,b₁)).mpr l₂ have l₄ := @lindenbaumSequenceMonotone' t Δ (i,b₁) (a₁, b₁) l₃ apply le_trans l₄ intros f h₂ exact ⟨b₁,h₂⟩ case right b₁ h₂ => rw [Nat.le_zero_eq b₁] at h₂ rw [h₂] | ⟨i, j + 1⟩ => have lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) := by intros f h₃ unfold lindenbaumSequence split case h_1 _ heq | h_2 _ heq => injection heq; contradiction case h_3 i' j' heq => injection heq with heq₁ heq₂ injection heq₂ with heq₂ have heq₃ : j = j' := heq₂ rw [←heq₁, ←heq₃] change let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev intros prev l r split case inl => split case inl | inr => apply Or.inl h₃ case inr => exact h₃ intros a h₁ cases h₁ case left a₁ b₁ h₂ => have l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j := Or.inl h₂ have l₂ := (Prod.Lex.le_iff (a₁, b₁) (i,j)).mpr l₁ have l₃ := @lindenbaumSequenceMonotone' t Δ (i,j) (a₁, b₁) l₂ apply le_trans l₃ exact lem case right b₁ h₂ => cases h₂ case refl => intros _ h₁; assumption case step h₂ => have l₁ : i < i ∨ i = i ∧ b₁ ≤ j := Or.inr ⟨rfl, h₂⟩ have l₂ := (Prod.Lex.le_iff (i, b₁) (i,j)).mpr l₁ have l₃ := @lindenbaumSequenceMonotone' t Δ (i,j) (i, b₁) l₂ apply le_trans l₃ exact lem

t : Th Δ : Ctx b : Lex (ℕ × ℕ) ⊢ ∀ (a : Lex (ℕ × ℕ)), a ≤ b → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ b

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

intros a h₁

t : Th Δ : Ctx b : Lex (ℕ × ℕ) ⊢ ∀ (a : Lex (ℕ × ℕ)), a ≤ (0, 0) → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (0, 0)

t : Th Δ : Ctx b a : Lex (ℕ × ℕ) h₁ : a ≤ (0, 0) ⊢ lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (0, 0)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

cases h₁

t : Th Δ : Ctx b a : Lex (ℕ × ℕ) h₁ : a ≤ (0, 0) ⊢ lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (0, 0)

case left t : Th Δ : Ctx b : Lex (ℕ × ℕ) a₁✝ b₁✝ : ℕ h✝ : a₁✝ < 0 ⊢ lindenbaumSequence t Δ (a₁✝, b₁✝) ⊆ lindenbaumSequence t Δ (0, 0) case right t : Th Δ : Ctx b : Lex (ℕ × ℕ) b₁✝ : ℕ h✝ : b₁✝ ≤ 0 ⊢ lindenbaumSequence t Δ (0, b₁✝) ⊆ lindenbaumSequence t Δ (0, 0)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case left a₁ _ h₂ => exact False.elim $ Nat.not_lt_zero a₁ h₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) a₁ b₁✝ : ℕ h₂ : a₁ < 0 ⊢ lindenbaumSequence t Δ (a₁, b₁✝) ⊆ lindenbaumSequence t Δ (0, 0)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case right b₁ h₂ => rw [Nat.le_zero_eq b₁] at h₂ rw [h₂]

t : Th Δ : Ctx b : Lex (ℕ × ℕ) b₁ : ℕ h₂ : b₁ ≤ 0 ⊢ lindenbaumSequence t Δ (0, b₁) ⊆ lindenbaumSequence t Δ (0, 0)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

exact False.elim $ Nat.not_lt_zero a₁ h₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) a₁ b₁✝ : ℕ h₂ : a₁ < 0 ⊢ lindenbaumSequence t Δ (a₁, b₁✝) ⊆ lindenbaumSequence t Δ (0, 0)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

rw [Nat.le_zero_eq b₁] at h₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) b₁ : ℕ h₂ : b₁ ≤ 0 ⊢ lindenbaumSequence t Δ (0, b₁) ⊆ lindenbaumSequence t Δ (0, 0)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) b₁ : ℕ h₂ : b₁ = 0 ⊢ lindenbaumSequence t Δ (0, b₁) ⊆ lindenbaumSequence t Δ (0, 0)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

rw [h₂]

t : Th Δ : Ctx b : Lex (ℕ × ℕ) b₁ : ℕ h₂ : b₁ = 0 ⊢ lindenbaumSequence t Δ (0, b₁) ⊆ lindenbaumSequence t Δ (0, 0)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

intros a h₁

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i : ℕ ⊢ ∀ (a : Lex (ℕ × ℕ)), a ≤ (i + 1, 0) → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i + 1, 0)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i : ℕ a : Lex (ℕ × ℕ) h₁ : a ≤ (i + 1, 0) ⊢ lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i + 1, 0)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

cases h₁

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i : ℕ a : Lex (ℕ × ℕ) h₁ : a ≤ (i + 1, 0) ⊢ lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i + 1, 0)

case left t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁✝ b₁✝ : ℕ h✝ : a₁✝ < i + 1 ⊢ lindenbaumSequence t Δ (a₁✝, b₁✝) ⊆ lindenbaumSequence t Δ (i + 1, 0) case right t : Th Δ : Ctx b : Lex (ℕ × ℕ) i b₁✝ : ℕ h✝ : b₁✝ ≤ 0 ⊢ lindenbaumSequence t Δ (i + 1, b₁✝) ⊆ lindenbaumSequence t Δ (i + 1, 0)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case left a₁ b₁ h₂ => have l₁ : a₁ < i ∨ a₁ = i := Nat.lt_or_eq_of_le $ Nat.lt_succ.mp h₂ have l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ := by cases l₁ case inl h₂ => exact Or.inl h₂ case inr h₂ => exact Or.inr ⟨h₂, le_refl b₁⟩ have l₃ := (Prod.Lex.le_iff (a₁, b₁) (i,b₁)).mpr l₂ have l₄ := @lindenbaumSequenceMonotone' t Δ (i,b₁) (a₁, b₁) l₃ apply le_trans l₄ intros f h₂ exact ⟨b₁,h₂⟩

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case right b₁ h₂ => rw [Nat.le_zero_eq b₁] at h₂ rw [h₂]

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i b₁ : ℕ h₂ : b₁ ≤ 0 ⊢ lindenbaumSequence t Δ (i + 1, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

have l₁ : a₁ < i ∨ a₁ = i := Nat.lt_or_eq_of_le $ Nat.lt_succ.mp h₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

have l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ := by cases l₁ case inl h₂ => exact Or.inl h₂ case inr h₂ => exact Or.inr ⟨h₂, le_refl b₁⟩

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

have l₃ := (Prod.Lex.le_iff (a₁, b₁) (i,b₁)).mpr l₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

have l₄ := @lindenbaumSequenceMonotone' t Δ (i,b₁) (a₁, b₁) l₃

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) l₄ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, b₁) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

apply le_trans l₄

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) l₄ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, b₁) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) l₄ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, b₁) ⊢ lindenbaumSequence t Δ (i, b₁) ≤ lindenbaumSequence t Δ (i + 1, 0)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

intros f h₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) l₄ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, b₁) ⊢ lindenbaumSequence t Δ (i, b₁) ≤ lindenbaumSequence t Δ (i + 1, 0)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂✝ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) l₄ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, b₁) f : Form h₂ : f ∈ lindenbaumSequence t Δ (i, b₁) ⊢ f ∈ lindenbaumSequence t Δ (i + 1, 0)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

exact ⟨b₁,h₂⟩

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂✝ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i l₂ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ l₃ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, b₁) l₄ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, b₁) f : Form h₂ : f ∈ lindenbaumSequence t Δ (i, b₁) ⊢ f ∈ lindenbaumSequence t Δ (i + 1, 0)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

cases l₁

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 l₁ : a₁ < i ∨ a₁ = i ⊢ a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁

case inl t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 h✝ : a₁ < i ⊢ a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁ case inr t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂ : a₁ < i + 1 h✝ : a₁ = i ⊢ a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case inl h₂ => exact Or.inl h₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂✝ : a₁ < i + 1 h₂ : a₁ < i ⊢ a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case inr h₂ => exact Or.inr ⟨h₂, le_refl b₁⟩

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂✝ : a₁ < i + 1 h₂ : a₁ = i ⊢ a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

exact Or.inl h₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂✝ : a₁ < i + 1 h₂ : a₁ < i ⊢ a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

exact Or.inr ⟨h₂, le_refl b₁⟩

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i a₁ b₁ : ℕ h₂✝ : a₁ < i + 1 h₂ : a₁ = i ⊢ a₁ < i ∨ a₁ = i ∧ b₁ ≤ b₁

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

rw [Nat.le_zero_eq b₁] at h₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i b₁ : ℕ h₂ : b₁ ≤ 0 ⊢ lindenbaumSequence t Δ (i + 1, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i b₁ : ℕ h₂ : b₁ = 0 ⊢ lindenbaumSequence t Δ (i + 1, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

rw [h₂]

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i b₁ : ℕ h₂ : b₁ = 0 ⊢ lindenbaumSequence t Δ (i + 1, b₁) ⊆ lindenbaumSequence t Δ (i + 1, 0)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

have lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) := by intros f h₃ unfold lindenbaumSequence split case h_1 _ heq | h_2 _ heq => injection heq; contradiction case h_3 i' j' heq => injection heq with heq₁ heq₂ injection heq₂ with heq₂ have heq₃ : j = j' := heq₂ rw [←heq₁, ←heq₃] change let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev intros prev l r split case inl => split case inl | inr => apply Or.inl h₃ case inr => exact h₃

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ ⊢ ∀ (a : Lex (ℕ × ℕ)), a ≤ (i, j + 1) → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i, j + 1)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) ⊢ ∀ (a : Lex (ℕ × ℕ)), a ≤ (i, j + 1) → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i, j + 1)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

intros a h₁

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) ⊢ ∀ (a : Lex (ℕ × ℕ)), a ≤ (i, j + 1) → lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i, j + 1)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a : Lex (ℕ × ℕ) h₁ : a ≤ (i, j + 1) ⊢ lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i, j + 1)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

cases h₁

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a : Lex (ℕ × ℕ) h₁ : a ≤ (i, j + 1) ⊢ lindenbaumSequence t Δ a ⊆ lindenbaumSequence t Δ (i, j + 1)

case left t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁✝ b₁✝ : ℕ h✝ : a₁✝ < i ⊢ lindenbaumSequence t Δ (a₁✝, b₁✝) ⊆ lindenbaumSequence t Δ (i, j + 1) case right t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁✝ : ℕ h✝ : b₁✝ ≤ j + 1 ⊢ lindenbaumSequence t Δ (i, b₁✝) ⊆ lindenbaumSequence t Δ (i, j + 1)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case left a₁ b₁ h₂ => have l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j := Or.inl h₂ have l₂ := (Prod.Lex.le_iff (a₁, b₁) (i,j)).mpr l₁ have l₃ := @lindenbaumSequenceMonotone' t Δ (i,j) (a₁, b₁) l₂ apply le_trans l₃ exact lem

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case right b₁ h₂ => cases h₂ case refl => intros _ h₁; assumption case step h₂ => have l₁ : i < i ∨ i = i ∧ b₁ ≤ j := Or.inr ⟨rfl, h₂⟩ have l₂ := (Prod.Lex.le_iff (i, b₁) (i,j)).mpr l₁ have l₃ := @lindenbaumSequenceMonotone' t Δ (i,j) (i, b₁) l₂ apply le_trans l₃ exact lem

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : b₁ ≤ j + 1 ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

intros f h₃

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ ⊢ lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) ⊢ f ∈ lindenbaumSequence t Δ (i, j + 1)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

unfold lindenbaumSequence

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) ⊢ f ∈ lindenbaumSequence t Δ (i, j + 1)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) ⊢ f ∈ match (i, j + 1) with | (0, 0) => ↑t | (Nat.succ i, 0) => { f | ∃ j, f ∈ lindenbaumSequence t Δ (i, j) } | (i, Nat.succ j) => let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

split

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) ⊢ f ∈ match (i, j + 1) with | (0, 0) => ↑t | (Nat.succ i, 0) => { f | ∃ j, f ∈ lindenbaumSequence t Δ (i, j) } | (i, Nat.succ j) => let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

case h_1 t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) heq✝ : (i, j + 1) = (0, 0) ⊢ f ∈ ↑t case h_2 t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i✝ : ℕ heq✝ : (i, j + 1) = (Nat.succ i✝, 0) ⊢ f ∈ { f | ∃ j, f ∈ lindenbaumSequence t Δ (i✝, j) } case h_3 t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i✝ j✝ : ℕ heq✝ : (i, j + 1) = (i✝, Nat.succ j✝) ⊢ f ∈ let prev := lindenbaumSequence t Δ (i✝, j✝); let l := (Denumerable.ofNat (Form × Form) j✝).fst; let r := (Denumerable.ofNat (Form × Form) j✝).snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case h_1 _ heq | h_2 _ heq => injection heq; contradiction

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i✝ : ℕ heq : (i, j + 1) = (Nat.succ i✝, 0) ⊢ f ∈ { f | ∃ j, f ∈ lindenbaumSequence t Δ (i✝, j) }

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case h_3 i' j' heq => injection heq with heq₁ heq₂ injection heq₂ with heq₂ have heq₃ : j = j' := heq₂ rw [←heq₁, ←heq₃] change let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev intros prev l r split case inl => split case inl | inr => apply Or.inl h₃ case inr => exact h₃

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq : (i, j + 1) = (i', Nat.succ j') ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

injection heq

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i✝ : ℕ heq : (i, j + 1) = (Nat.succ i✝, 0) ⊢ f ∈ { f | ∃ j, f ∈ lindenbaumSequence t Δ (i✝, j) }

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i✝ : ℕ fst_eq✝ : i = Nat.succ i✝ snd_eq✝ : j + 1 = 0 ⊢ f ∈ { f | ∃ j, f ∈ lindenbaumSequence t Δ (i✝, j) }

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

contradiction

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i✝ : ℕ fst_eq✝ : i = Nat.succ i✝ snd_eq✝ : j + 1 = 0 ⊢ f ∈ { f | ∃ j, f ∈ lindenbaumSequence t Δ (i✝, j) }

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

injection heq with heq₁ heq₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq : (i, j + 1) = (i', Nat.succ j') ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : j + 1 = Nat.succ j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

injection heq₂ with heq₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : j + 1 = Nat.succ j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

have heq₃ : j = j' := heq₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

rw [←heq₁, ←heq₃]

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i', j'); let l := (Denumerable.ofNat (Form × Form) j').fst; let r := (Denumerable.ofNat (Form × Form) j').snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

change let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' ⊢ f ∈ let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' ⊢ let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

intros prev l r

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' ⊢ let prev := lindenbaumSequence t Δ (i, j); let l := (Denumerable.ofNat (Form × Form) j).fst; let r := (Denumerable.ofNat (Form × Form) j).snd; f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd ⊢ f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

split

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd ⊢ f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev

case inl t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝ : l¦r ∈ ▲prev ⊢ f ∈ if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} case inr t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝ : ¬l¦r ∈ ▲prev ⊢ f ∈ prev

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case inl => split case inl | inr => apply Or.inl h₃

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝ : l¦r ∈ ▲prev ⊢ f ∈ if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r}

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case inr => exact h₃

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝ : ¬l¦r ∈ ▲prev ⊢ f ∈ prev

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

split

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝ : l¦r ∈ ▲prev ⊢ f ∈ if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r}

case inl t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝¹ : l¦r ∈ ▲prev h✝ : ▲(prev ∪ {l}) ∩ Δ = ∅ ⊢ f ∈ prev ∪ {l} case inr t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝¹ : l¦r ∈ ▲prev h✝ : ¬▲(prev ∪ {l}) ∩ Δ = ∅ ⊢ f ∈ prev ∪ {r}

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case inl | inr => apply Or.inl h₃

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝¹ : l¦r ∈ ▲prev h✝ : ¬▲(prev ∪ {l}) ∩ Δ = ∅ ⊢ f ∈ prev ∪ {r}

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

apply Or.inl h₃

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝¹ : l¦r ∈ ▲prev h✝ : ¬▲(prev ∪ {l}) ∩ Δ = ∅ ⊢ f ∈ prev ∪ {r}

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

exact h₃

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ f : Form h₃ : f ∈ lindenbaumSequence t Δ (i, j) x✝ : Lex (ℕ × ℕ) i' j' : ℕ heq₁ : i = i' heq₂ : Nat.add j 0 = j' heq₃ : j = j' prev : Ctx := lindenbaumSequence t Δ (i, j) l : Form := (Denumerable.ofNat (Form × Form) j).fst r : Form := (Denumerable.ofNat (Form × Form) j).snd h✝ : ¬l¦r ∈ ▲prev ⊢ f ∈ prev

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

have l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j := Or.inl h₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

have l₂ := (Prod.Lex.le_iff (a₁, b₁) (i,j)).mpr l₁

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j l₂ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, j) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

have l₃ := @lindenbaumSequenceMonotone' t Δ (i,j) (a₁, b₁) l₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j l₂ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, j) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j l₂ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

apply le_trans l₃

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j l₂ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j l₂ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

exact lem

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a₁ b₁ : ℕ h₂ : a₁ < i l₁ : a₁ < i ∨ a₁ = i ∧ b₁ ≤ j l₂ : ↑toLex (a₁, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (a₁, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

cases h₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : b₁ ≤ j + 1 ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

case refl t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) ⊢ lindenbaumSequence t Δ (i, j + 1) ⊆ lindenbaumSequence t Δ (i, j + 1) case step t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ a✝ : Nat.le b₁ (Nat.add j 0) ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case refl => intros _ h₁; assumption

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) ⊢ lindenbaumSequence t Δ (i, j + 1) ⊆ lindenbaumSequence t Δ (i, j + 1)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

case step h₂ => have l₁ : i < i ∨ i = i ∧ b₁ ≤ j := Or.inr ⟨rfl, h₂⟩ have l₂ := (Prod.Lex.le_iff (i, b₁) (i,j)).mpr l₁ have l₃ := @lindenbaumSequenceMonotone' t Δ (i,j) (i, b₁) l₂ apply le_trans l₃ exact lem

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

intros _ h₁

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) ⊢ lindenbaumSequence t Δ (i, j + 1) ⊆ lindenbaumSequence t Δ (i, j + 1)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a✝ : Form h₁ : a✝ ∈ lindenbaumSequence t Δ (i, j + 1) ⊢ a✝ ∈ lindenbaumSequence t Δ (i, j + 1)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

assumption

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) a✝ : Form h₁ : a✝ ∈ lindenbaumSequence t Δ (i, j + 1) ⊢ a✝ ∈ lindenbaumSequence t Δ (i, j + 1)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

have l₁ : i < i ∨ i = i ∧ b₁ ≤ j := Or.inr ⟨rfl, h₂⟩

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

have l₂ := (Prod.Lex.le_iff (i, b₁) (i,j)).mpr l₁

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j l₂ : ↑toLex (i, b₁) ≤ ↑toLex (i, j) ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

have l₃ := @lindenbaumSequenceMonotone' t Δ (i,j) (i, b₁) l₂

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j l₂ : ↑toLex (i, b₁) ≤ ↑toLex (i, j) ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j l₂ : ↑toLex (i, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

apply le_trans l₃

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j l₂ : ↑toLex (i, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j + 1)

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j l₂ : ↑toLex (i, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone'

[21, 1]

[88, 69]

exact lem

t : Th Δ : Ctx b : Lex (ℕ × ℕ) i j : ℕ lem : lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1) b₁ : ℕ h₂ : Nat.le b₁ (Nat.add j 0) l₁ : i < i ∨ i = i ∧ b₁ ≤ j l₂ : ↑toLex (i, b₁) ≤ ↑toLex (i, j) l₃ : lindenbaumSequence t Δ (i, b₁) ⊆ lindenbaumSequence t Δ (i, j) ⊢ lindenbaumSequence t Δ (i, j) ≤ lindenbaumSequence t Δ (i, j + 1)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone

[90, 1]

[92, 40]

intros a b

t : Th Δ : Ctx ⊢ Monotone (lindenbaumSequence t Δ)

t : Th Δ : Ctx a b : Lex (ℕ × ℕ) ⊢ a ≤ b → lindenbaumSequence t Δ a ≤ lindenbaumSequence t Δ b

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumSequenceMonotone

[90, 1]

[92, 40]

exact lindenbaumSequenceMonotone' b a

t : Th Δ : Ctx a b : Lex (ℕ × ℕ) ⊢ a ≤ b → lindenbaumSequence t Δ a ≤ lindenbaumSequence t Δ b

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumStageMonotone

[96, 1]

[100, 51]

intros a b h₁

t : Th Δ : Ctx i : ℕ ⊢ Monotone fun j => lindenbaumSequence t Δ (i, j)

t : Th Δ : Ctx i a b : ℕ h₁ : a ≤ b ⊢ (fun j => lindenbaumSequence t Δ (i, j)) a ≤ (fun j => lindenbaumSequence t Δ (i, j)) b

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumStageMonotone

[96, 1]

[100, 51]

change lindenbaumSequence t Δ (i, a) ≤ lindenbaumSequence t Δ (i, b)

t : Th Δ : Ctx i a b : ℕ h₁ : a ≤ b ⊢ (fun j => lindenbaumSequence t Δ (i, j)) a ≤ (fun j => lindenbaumSequence t Δ (i, j)) b

t : Th Δ : Ctx i a b : ℕ h₁ : a ≤ b ⊢ lindenbaumSequence t Δ (i, a) ≤ lindenbaumSequence t Δ (i, b)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumStageMonotone

[96, 1]

[100, 51]

have l₂ := (Prod.Lex.le_iff (i, a) (i,b)).mpr $ Or.inr ⟨rfl,h₁⟩

t : Th Δ : Ctx i a b : ℕ h₁ : a ≤ b ⊢ lindenbaumSequence t Δ (i, a) ≤ lindenbaumSequence t Δ (i, b)

t : Th Δ : Ctx i a b : ℕ h₁ : a ≤ b l₂ : ↑toLex (i, a) ≤ ↑toLex (i, b) ⊢ lindenbaumSequence t Δ (i, a) ≤ lindenbaumSequence t Δ (i, b)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumStageMonotone

[96, 1]

[100, 51]

exact lindenbaumSequenceMonotone' (i,b) (i,a) l₂

t : Th Δ : Ctx i a b : ℕ h₁ : a ≤ b l₂ : ↑toLex (i, a) ≤ ↑toLex (i, b) ⊢ lindenbaumSequence t Δ (i, a) ≤ lindenbaumSequence t Δ (i, b)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumExtensionExtends

[102, 1]

[105, 13]

intros f h₁

t : Th Δ : Ctx ⊢ ↑t ⊆ lindenbaumExtension t Δ

t : Th Δ : Ctx f : Form h₁ : f ∈ ↑t ⊢ f ∈ lindenbaumExtension t Δ

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumExtensionExtends

[102, 1]

[105, 13]

refine ⟨⟨0,0⟩,?_⟩

t : Th Δ : Ctx f : Form h₁ : f ∈ ↑t ⊢ f ∈ lindenbaumExtension t Δ

t : Th Δ : Ctx f : Form h₁ : f ∈ ↑t ⊢ f ∈ lindenbaumSequence t Δ (0, 0)

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumExtensionExtends

[102, 1]

[105, 13]

assumption

t : Th Δ : Ctx f : Form h₁ : f ∈ ↑t ⊢ f ∈ lindenbaumSequence t Δ (0, 0)

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumIsFormal

[107, 1]

[148, 52]

intros f

t : Th Δ : Ctx ⊢ formalTheory (lindenbaumExtension t Δ)

t : Th Δ : Ctx f : Form ⊢ f ∈ lindenbaumExtension t Δ ↔ lindenbaumExtension t Δ⊢f

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumIsFormal

[107, 1]

[148, 52]

apply Iff.intro

t : Th Δ : Ctx f : Form ⊢ f ∈ lindenbaumExtension t Δ ↔ lindenbaumExtension t Δ⊢f

case mp t : Th Δ : Ctx f : Form ⊢ f ∈ lindenbaumExtension t Δ → lindenbaumExtension t Δ⊢f case mpr t : Th Δ : Ctx f : Form ⊢ lindenbaumExtension t Δ⊢f → f ∈ lindenbaumExtension t Δ

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumIsFormal

[107, 1]

[148, 52]

case mp => intro h₁ exact ⟨BProof.ax h₁⟩

t : Th Δ : Ctx f : Form ⊢ f ∈ lindenbaumExtension t Δ → lindenbaumExtension t Δ⊢f

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumIsFormal

[107, 1]

[148, 52]

case mpr => intro h₁ have ⟨prf₁⟩ := h₁ have ⟨s, l₁, fprf⟩ := BProof.compactness prf₁ have ⟨⟨i,j⟩,l₂⟩ := finiteExhaustion lindenbaumSequenceMonotone l₁ have l₃ : lindenbaumSequence t Δ ⟨i,j⟩ ⊆ lindenbaumSequence t Δ ⟨i + 1,Encodable.encode (f,f)⟩ := by apply lindenbaumSequenceMonotone apply (Prod.Lex.le_iff (i,j) (i + 1,Encodable.encode (f,f))).mpr $ Or.inl $ Nat.lt_succ_self i have prf₂ := BProof.monotone (le_trans l₂ l₃) fprf have prf₃ : BProof (lindenbaumSequence t Δ ⟨i+1,Encodable.encode (f,f)⟩) (f ¦ f) := BProof.mp prf₂ BTheorem.orI₁ clear s h₁ l₁ l₂ l₃ fprf prf₁ prf₂ have l₄ : f ∈ lindenbaumSequence t Δ ⟨i + 1, Encodable.encode (f,f) + 1⟩ := by unfold lindenbaumSequence change let prev := lindenbaumSequence t Δ (i + 1, Encodable.encode (f,f)); let l := (Denumerable.ofNat (Form × Form) (Encodable.encode (f,f))).fst; let r := (Denumerable.ofNat (Form × Form) (Encodable.encode (f,f))).snd; f ∈ if l¦r ∈ ▲prev then if ▲(prev ∪ {l}) ∩ Δ = ∅ then prev ∪ {l} else prev ∪ {r} else prev intros prev l r have l₅ : l = f := by change (Denumerable.ofNat (Form × Form) (Encodable.encode (f, f))).fst = f rw [Denumerable.ofNat_encode (f,f)] have l₆ : r = f := by change (Denumerable.ofNat (Form × Form) (Encodable.encode (f, f))).snd = f rw [Denumerable.ofNat_encode (f,f)] split case inl h₂ => split . rw [l₅]; exact Or.inr rfl . rw [l₆]; exact Or.inr rfl case inr h₂ => apply False.elim have l₇ : f¦f ∈ ▲prev := ⟨prf₃⟩ rw [l₅,l₆] at h₂ exact h₂ l₇ exact ⟨⟨i + 1, Encodable.encode (f,f) + 1⟩, l₄⟩

t : Th Δ : Ctx f : Form ⊢ lindenbaumExtension t Δ⊢f → f ∈ lindenbaumExtension t Δ

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumIsFormal

[107, 1]

[148, 52]

intro h₁

t : Th Δ : Ctx f : Form ⊢ f ∈ lindenbaumExtension t Δ → lindenbaumExtension t Δ⊢f

t : Th Δ : Ctx f : Form h₁ : f ∈ lindenbaumExtension t Δ ⊢ lindenbaumExtension t Δ⊢f

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumIsFormal

[107, 1]

[148, 52]

exact ⟨BProof.ax h₁⟩

t : Th Δ : Ctx f : Form h₁ : f ∈ lindenbaumExtension t Δ ⊢ lindenbaumExtension t Δ⊢f

no goals

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumIsFormal

[107, 1]

[148, 52]

intro h₁

t : Th Δ : Ctx f : Form ⊢ lindenbaumExtension t Δ⊢f → f ∈ lindenbaumExtension t Δ

t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f ⊢ f ∈ lindenbaumExtension t Δ

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumIsFormal

[107, 1]

[148, 52]

have ⟨prf₁⟩ := h₁

t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f ⊢ f ∈ lindenbaumExtension t Δ

t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f prf₁ : BProof (lindenbaumExtension t Δ) f ⊢ f ∈ lindenbaumExtension t Δ

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumIsFormal

[107, 1]

[148, 52]

have ⟨s, l₁, fprf⟩ := BProof.compactness prf₁

t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f prf₁ : BProof (lindenbaumExtension t Δ) f ⊢ f ∈ lindenbaumExtension t Δ

t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f prf₁ : BProof (lindenbaumExtension t Δ) f s : Finset Form l₁ : ↑s ⊆ lindenbaumExtension t Δ fprf : BProof (↑s) f ⊢ f ∈ lindenbaumExtension t Δ

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumIsFormal

[107, 1]

[148, 52]

have ⟨⟨i,j⟩,l₂⟩ := finiteExhaustion lindenbaumSequenceMonotone l₁

t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f prf₁ : BProof (lindenbaumExtension t Δ) f s : Finset Form l₁ : ↑s ⊆ lindenbaumExtension t Δ fprf : BProof (↑s) f ⊢ f ∈ lindenbaumExtension t Δ

t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f prf₁ : BProof (lindenbaumExtension t Δ) f s : Finset Form l₁ : ↑s ⊆ lindenbaumExtension t Δ fprf : BProof (↑s) f i j : ℕ l₂ : ↑s ⊆ lindenbaumSequence t Δ (i, j) ⊢ f ∈ lindenbaumExtension t Δ

https://github.com/gleachkr/Completeness-For-Fine-Semantics.git

0d8cc9a4c9c53181a2bf1541d2ed5a39c2593f0f

Fine/SystemB/Lindenbaum.lean

lindenbaumIsFormal

[107, 1]

[148, 52]

have l₃ : lindenbaumSequence t Δ ⟨i,j⟩ ⊆ lindenbaumSequence t Δ ⟨i + 1,Encodable.encode (f,f)⟩ := by apply lindenbaumSequenceMonotone apply (Prod.Lex.le_iff (i,j) (i + 1,Encodable.encode (f,f))).mpr $ Or.inl $ Nat.lt_succ_self i

t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f prf₁ : BProof (lindenbaumExtension t Δ) f s : Finset Form l₁ : ↑s ⊆ lindenbaumExtension t Δ fprf : BProof (↑s) f i j : ℕ l₂ : ↑s ⊆ lindenbaumSequence t Δ (i, j) ⊢ f ∈ lindenbaumExtension t Δ

t : Th Δ : Ctx f : Form h₁ : lindenbaumExtension t Δ⊢f prf₁ : BProof (lindenbaumExtension t Δ) f s : Finset Form l₁ : ↑s ⊆ lindenbaumExtension t Δ fprf : BProof (↑s) f i j : ℕ l₂ : ↑s ⊆ lindenbaumSequence t Δ (i, j) l₃ : lindenbaumSequence t Δ (i, j) ⊆ lindenbaumSequence t Δ (i + 1, Encodable.encode (f, f)) ⊢ f ∈ lindenbaumExtension t Δ