| import Mathlib |
| import OAI.SetTheory.PartitionConsistency.Logic.Proofs |
| import OAI.SetTheory.PartitionConsistency.Logic.CountableModels |
|
|
| namespace OAI |
|
|
| namespace PartitionConsistency |
| /-! Countable Henkin completeness for the target proof calculus. -/ |
|
|
| deriving instance Countable for Formula |
|
|
| namespace Formula |
|
|
| @[simp] theorem liftRen_id (n : ℕ) : liftRen (id : Fin n → Fin n) = id := by |
| funext i |
| refine Fin.lastCases ?_ (fun j => ?_) i <;> simp [liftRen] |
|
|
| @[simp] theorem liftRen_comp {n m k : ℕ} (r : Fin n → Fin m) (s : Fin m → Fin k) : |
| liftRen (s ∘ r) = liftRen s ∘ liftRen r := by |
| funext i |
| refine Fin.lastCases ?_ (fun j => ?_) i <;> simp [liftRen] |
|
|
| @[simp] theorem rename_id {n} (φ : Formula n) : φ.rename id = φ := by |
| induction φ with |
| | bot => rfl |
| | mem => rfl |
| | equal => rfl |
| | imp φ ψ hφ hψ => simp [rename, hφ, hψ] |
| | conj φ ψ hφ hψ => simp [rename, hφ, hψ] |
| | disj φ ψ hφ hψ => simp [rename, hφ, hψ] |
| | all φ hφ => simp [rename, hφ] |
| | ex φ hφ => simp [rename, hφ] |
|
|
| @[simp] theorem rename_comp {n m k} (φ : Formula n) |
| (r : Fin n → Fin m) (s : Fin m → Fin k) : |
| (φ.rename r).rename s = φ.rename (s ∘ r) := by |
| induction φ generalizing m k with |
| | bot => rfl |
| | mem => rfl |
| | equal => rfl |
| | imp φ ψ hφ hψ => simp [rename, hφ, hψ] |
| | conj φ ψ hφ hψ => simp [rename, hφ, hψ] |
| | disj φ ψ hφ hψ => simp [rename, hφ, hψ] |
| | all φ hφ => simp [rename, hφ, liftRen_comp] |
| | ex φ hφ => simp [rename, hφ, liftRen_comp] |
|
|
| /-- Instantiation after renaming the free variables extends that renaming by |
| one chosen variable; this is the capture-avoidance identity for witnesses. -/ |
| @[simp] theorem instantiate_rename {n m} (φ : Formula (n + 1)) |
| (r : Fin n → Fin m) (t : Fin m) : |
| (φ.rename (liftRen r)).instantiate t = φ.rename (Fin.snoc r t) := by |
| rw [instantiate, rename_comp] |
| congr 1 |
| funext i |
| refine Fin.lastCases ?_ (fun j => ?_) i <;> simp [liftRen] |
|
|
| @[simp] theorem rename_snoc_castSucc_last {n} (φ : Formula (n + 1)) : |
| φ.rename (Fin.snoc Fin.castSucc (Fin.last n)) = φ := by |
| have h : Fin.snoc Fin.castSucc (Fin.last n) = (id : Fin (n+1) → Fin (n+1)) := by |
| funext i |
| refine Fin.lastCases ?_ (fun j => ?_) i <;> simp |
| rw [h, rename_id] |
|
|
| @[simp] theorem rename_instantiate {n m} (φ : Formula (n+1)) |
| (r : Fin n → Fin m) (t : Fin n) : |
| (φ.instantiate t).rename r = (φ.rename (liftRen r)).instantiate (r t) := by |
| rw [instantiate_rename, instantiate, rename_comp] |
| congr 1 |
| funext i |
| refine Fin.lastCases ?_ (fun j => ?_) i <;> simp |
|
|
| end Formula |
|
|
| namespace Derives |
|
|
| theorem eq_symm {n} {Γ : Set (Formula n)} {s t : Fin n} (h : Derives Γ (.equal s t)) : |
| Derives Γ (.equal t s) := by |
| have hp := Derives.eqSubst (.equal (Fin.last n) s.castSucc) h (by |
| simpa [Formula.instantiate, Formula.rename] using (Derives.eqRefl (Γ := Γ) s)) |
| simpa [Formula.instantiate, Formula.rename] using hp |
|
|
| theorem eq_trans {n} {Γ : Set (Formula n)} {s t u : Fin n} |
| (h : Derives Γ (.equal s t)) (h' : Derives Γ (.equal t u)) : |
| Derives Γ (.equal s u) := by |
| have hp := Derives.eqSubst (.equal s.castSucc (Fin.last n)) h' (by |
| simpa [Formula.instantiate, Formula.rename] using h) |
| simpa [Formula.instantiate, Formula.rename] using hp |
|
|
| theorem mem_congr {n} {Γ : Set (Formula n)} {s t s' t' : Fin n} |
| (hs : Derives Γ (.equal s s')) (ht : Derives Γ (.equal t t')) |
| (hm : Derives Γ (.mem s t)) : Derives Γ (.mem s' t') := by |
| have h₁ : Derives Γ (.mem s' t) := by |
| have hp := Derives.eqSubst (.mem (Fin.last n) t.castSucc) hs (by |
| simpa [Formula.instantiate, Formula.rename] using hm) |
| simpa [Formula.instantiate, Formula.rename] using hp |
| have hp := Derives.eqSubst (.mem s'.castSucc (Fin.last n)) ht (by |
| simpa [Formula.instantiate, Formula.rename] using h₁) |
| simpa [Formula.instantiate, Formula.rename] using hp |
|
|
| end Derives |
|
|
| namespace Completeness |
|
|
| /-- Consistency of an open context, with its displayed finite variable supply. -/ |
| def ContextConsistent {n} (Γ : Set (Formula n)) : Prop := ¬ Derives Γ .bot |
|
|
| /-- Enlarging the variable supply is conservative for a nonempty supply. |
| A retraction substitutes an existing variable for every extra variable. -/ |
| theorem lift_consistent {n m} {Γ : Set (Formula n)} (hn : 0 < n) (hnm : n ≤ m) |
| (hΓ : ContextConsistent Γ) : |
| ContextConsistent (Formula.rename (Fin.castLE hnm) '' Γ) := by |
| intro hd |
| let r : Fin m → Fin n := fun i => if h : i.val < n then ⟨i.val, h⟩ else ⟨0, hn⟩ |
| have hr : r ∘ Fin.castLE hnm = id := by |
| funext i |
| simp [r] |
| apply hΓ |
| have h := hd.rename r |
| simpa [Formula.rename, Set.image_image, hr] using h |
|
|
| /-- One of the two decisions can always be added without contradiction. -/ |
| theorem consistent_decision {n} {Γ : Set (Formula n)} (hΓ : ContextConsistent Γ) |
| (φ : Formula n) : |
| ContextConsistent (insert φ Γ) ∨ ContextConsistent (insert φ.neg Γ) := by |
| classical |
| by_cases hp : ContextConsistent (insert φ Γ) |
| · exact Or.inl hp |
| · right |
| intro hn |
| apply hΓ |
| exact Derives.impE (Derives.impI (not_not.mp hp)) (Derives.classical hn) |
|
|
| /-- Henkin conditions are genuine consistent first-order contexts. No |
| satisfiability or model-existence assertion occurs in their definition. -/ |
| structure Condition where |
| size : ℕ |
| positive : 0 < size |
| context : Set (Formula size) |
| consistent : ContextConsistent context |
|
|
| namespace Condition |
|
|
| /-- A stronger condition may have more variables and more assumptions. -/ |
| instance : Preorder Condition where |
| le q p := ∃ h : p.size ≤ q.size, |
| Formula.rename (Fin.castLE h) '' p.context ⊆ q.context |
| le_refl p := by |
| refine ⟨le_rfl, ?_⟩ |
| rintro _ ⟨φ, hφ, rfl⟩ |
| have h : (Fin.castLE (le_rfl : p.size ≤ p.size)) = id := rfl |
| simpa [h] using hφ |
| le_trans q p r hqp hpr := by |
| obtain ⟨hqp, hpq⟩ := hqp |
| obtain ⟨hpr, hrp⟩ := hpr |
| refine ⟨hpr.trans hqp, ?_⟩ |
| rintro _ ⟨φ, hφ, rfl⟩ |
| have hmiddle := hpq ⟨_, hrp ⟨φ, hφ, rfl⟩, rfl⟩ |
| simpa only [Formula.rename_comp, Function.comp_def, Fin.castLE_castLE] using hmiddle |
|
|
| /-- The canonical embedding of the old variables into a stronger condition. -/ |
| def emb {q p : Condition} (h : q ≤ p) : Fin p.size → Fin q.size := Fin.castLE h.choose |
|
|
| @[simp] theorem emb_val {q p : Condition} (h : q ≤ p) (i : Fin p.size) : |
| (emb h i).val = i.val := rfl |
|
|
| /-- Derivations are preserved by extension of conditions. -/ |
| theorem transport {q p : Condition} (h : q ≤ p) {φ : Formula p.size} |
| (hd : Derives p.context φ) : Derives q.context (φ.rename (emb h)) := |
| (hd.rename (emb h)).weaken h.choose_spec |
|
|
| def grow (p : Condition) (m : ℕ) (h : p.size ≤ m) : Condition := |
| ⟨m, p.positive.trans_le h, Formula.rename (Fin.castLE h) '' p.context, |
| lift_consistent p.positive h p.consistent⟩ |
|
|
| theorem grow_le (p : Condition) (m : ℕ) (h : p.size ≤ m) : p.grow m h ≤ p := |
| ⟨h, Set.Subset.rfl⟩ |
|
|
| def add (p : Condition) (φ : Formula p.size) |
| (h : ContextConsistent (insert φ p.context)) : Condition := |
| ⟨p.size, p.positive, insert φ p.context, h⟩ |
|
|
| theorem add_le (p : Condition) (φ : Formula p.size) |
| (h : ContextConsistent (insert φ p.context)) : p.add φ h ≤ p := by |
| refine ⟨le_rfl, ?_⟩ |
| rintro _ ⟨ψ, hψ, rfl⟩ |
| have hid : (Fin.castLE (le_rfl : p.size ≤ p.size)) = id := rfl |
| change ψ.rename (Fin.castLE (le_rfl : p.size ≤ p.size)) ∈ insert φ p.context |
| rw [hid, Formula.rename_id] |
| exact Set.mem_insert_of_mem φ hψ |
|
|
| /-- A condition can always accommodate a given finite tuple of variable codes. -/ |
| theorem bound (p : Condition) {n} (v : Fin n → ℕ) : |
| ∃ q : Condition, q ≤ p ∧ ∃ w : Fin n → Fin q.size, ∀ i, (w i).val = v i := by |
| let m := max p.size (Finset.univ.sup v + 1) |
| have hpm : p.size ≤ m := le_max_left _ _ |
| let q := p.grow m hpm |
| have hv : ∀ i, v i < q.size := by |
| intro i |
| exact (Nat.lt_succ_of_le (Finset.le_sup (Finset.mem_univ i))).trans_le (le_max_right _ _) |
| exact ⟨q, p.grow_le m hpm, fun i => ⟨v i, hv i⟩, fun _ => rfl⟩ |
|
|
| end Condition |
|
|
| /-- Extending the variable map by a new last variable is the binder lift. -/ |
| @[simp] theorem snoc_castSucc {n m} (w : Fin n → Fin m) : |
| Fin.snoc (Fin.castSucc ∘ w) (Fin.last m) = Formula.liftRen w := by |
| funext i |
| refine Fin.lastCases ?_ (fun j => ?_) i <;> simp [Formula.liftRen] |
|
|
| namespace Condition |
|
|
| /-- Adding a fresh local witness is consistent when existence is derivable. |
| This is justified by the eigenvariable rule, not by a model assumption. -/ |
| def exWitness (p : Condition) (φ : Formula (p.size + 1)) |
| (hφ : Derives p.context (.ex φ)) : Condition where |
| size := p.size + 1 |
| positive := Nat.zero_lt_succ _ |
| context := insert φ (Formula.raise '' p.context) |
| consistent := fun hc => p.consistent (Derives.exE hφ hc) |
|
|
| theorem exWitness_le (p : Condition) (φ : Formula (p.size + 1)) |
| (hφ : Derives p.context (.ex φ)) : p.exWitness φ hφ ≤ p := by |
| refine ⟨Nat.le_succ _, ?_⟩ |
| rintro _ ⟨ψ, hψ, rfl⟩ |
| exact Or.inr ⟨ψ, hψ, rfl⟩ |
|
|
| /-- A negated universal has a consistent fresh counterexample context. -/ |
| def allCounterexample (p : Condition) (φ : Formula (p.size + 1)) |
| (hφ : Derives p.context (Formula.all φ).neg) : Condition where |
| size := p.size + 1 |
| positive := Nat.zero_lt_succ _ |
| context := insert φ.neg (Formula.raise '' p.context) |
| consistent := fun hc => |
| p.consistent (Derives.impE hφ (Derives.allI (Derives.classical hc))) |
|
|
| theorem allCounterexample_le (p : Condition) (φ : Formula (p.size + 1)) |
| (hφ : Derives p.context (Formula.all φ).neg) : p.allCounterexample φ hφ ≤ p := by |
| refine ⟨Nat.le_succ _, ?_⟩ |
| rintro _ ⟨ψ, hψ, rfl⟩ |
| exact Or.inr ⟨ψ, hψ, rfl⟩ |
|
|
| end Condition |
|
|
| /-- All finite tuples are explicitly included, so this construction treats |
| all parameters, not just sentences or quantifier-free formulas. -/ |
| def decisions {n} (φ : Formula n) (v : Fin n → ℕ) : Set Condition := |
| {c | ∃ w : Fin n → Fin c.size, (∀ i, (w i).val = v i) ∧ |
| (Derives c.context (φ.rename w) ∨ Derives c.context (φ.neg.rename w))} |
|
|
| def exWitnesses {n} (φ : Formula (n+1)) (v : Fin n → ℕ) : Set Condition := |
| {c | ∃ w : Fin n → Fin c.size, (∀ i, (w i).val = v i) ∧ |
| (Derives c.context ((Formula.ex φ).neg.rename w) ∨ |
| ∃ a : Fin c.size, Derives c.context (φ.rename (Fin.snoc w a)))} |
|
|
| def allCounterexamples {n} (φ : Formula (n+1)) (v : Fin n → ℕ) : Set Condition := |
| {c | ∃ w : Fin n → Fin c.size, (∀ i, (w i).val = v i) ∧ |
| (Derives c.context ((Formula.all φ).rename w) ∨ |
| ∃ a : Fin c.size, Derives c.context (φ.neg.rename (Fin.snoc w a)))} |
|
|
| theorem decisions_dense {n} (φ : Formula n) (v : Fin n → ℕ) : |
| ForcingQuotient.Dense (decisions φ v) := by |
| intro p |
| obtain ⟨q, hqp, w, hw⟩ := p.bound v |
| rcases consistent_decision q.consistent (φ.rename w) with hpos | hneg |
| · exact ⟨q.add (φ.rename w) hpos, (q.add_le _ _).trans hqp, w, hw, |
| Or.inl (Derives.hyp (Set.mem_insert _ _))⟩ |
| · exact ⟨q.add (φ.rename w).neg hneg, (q.add_le _ _).trans hqp, w, hw, |
| Or.inr (Derives.hyp (Set.mem_insert _ _))⟩ |
|
|
| theorem exWitnesses_dense {n} (φ : Formula (n+1)) (v : Fin n → ℕ) : |
| ForcingQuotient.Dense (exWitnesses φ v) := by |
| intro p |
| obtain ⟨q, hqp, w, hw⟩ := p.bound v |
| let ψ := φ.rename (Formula.liftRen w) |
| rcases consistent_decision q.consistent (.ex ψ) with hpos | hneg |
| · let r := q.add (.ex ψ) hpos |
| have hex : Derives r.context (.ex ψ) := Derives.hyp (Set.mem_insert _ _) |
| let s := r.exWitness ψ hex |
| refine ⟨s, (r.exWitness_le ψ hex).trans ((q.add_le _ _).trans hqp), |
| Fin.castSucc ∘ w, hw, Or.inr ⟨Fin.last r.size, ?_⟩⟩ |
| dsimp only [s, r, Condition.exWitness, Condition.add] |
| rw [snoc_castSucc] |
| exact Derives.hyp (Set.mem_insert _ _) |
| · exact ⟨q.add (Formula.ex ψ).neg hneg, (q.add_le _ _).trans hqp, w, hw, |
| Or.inl (Derives.hyp (Set.mem_insert _ _))⟩ |
|
|
| theorem allCounterexamples_dense {n} (φ : Formula (n+1)) (v : Fin n → ℕ) : |
| ForcingQuotient.Dense (allCounterexamples φ v) := by |
| intro p |
| obtain ⟨q, hqp, w, hw⟩ := p.bound v |
| let ψ := φ.rename (Formula.liftRen w) |
| rcases consistent_decision q.consistent (.all ψ) with hpos | hneg |
| · exact ⟨q.add (.all ψ) hpos, (q.add_le _ _).trans hqp, w, hw, |
| Or.inl (Derives.hyp (Set.mem_insert _ _))⟩ |
| · let r := q.add (Formula.all ψ).neg hneg |
| have hn : Derives r.context (Formula.all ψ).neg := Derives.hyp (Set.mem_insert _ _) |
| let s := r.allCounterexample ψ hn |
| refine ⟨s, (r.allCounterexample_le ψ hn).trans ((q.add_le _ _).trans hqp), |
| Fin.castSucc ∘ w, hw, Or.inr ⟨Fin.last r.size, ?_⟩⟩ |
| dsimp only [s, r, Condition.allCounterexample, Condition.add] |
| rw [snoc_castSucc] |
| exact Derives.hyp (Set.mem_insert _ _) |
|
|
| abbrev GenericFilter := ForcingQuotient.GenericFilter Condition |
|
|
| /-- A filter meeting every decision and every local quantifier-witness request. -/ |
| def IsHenkin (G : GenericFilter) : Prop := |
| (∀ n (φ : Formula n) (v : Fin n → ℕ), ∃ p ∈ G, p ∈ decisions φ v) ∧ |
| (∀ n (φ : Formula (n+1)) (v : Fin n → ℕ), ∃ p ∈ G, p ∈ exWitnesses φ v) ∧ |
| (∀ n (φ : Formula (n+1)) (v : Fin n → ℕ), ∃ p ∈ G, p ∈ allCounterexamples φ v) |
|
|
| /-- The countable Henkin construction, using only syntactic consistency. -/ |
| theorem exists_henkin (p₀ : Condition) : |
| ∃ G : GenericFilter, p₀ ∈ G ∧ IsHenkin G := by |
| let Request (j : ℕ) := Σ n, Formula (n+j) × (Fin n → ℕ) |
| let D : Request 0 ⊕ (Request 1 ⊕ Request 1) → Set Condition := |
| fun i => match i with |
| | .inl ⟨_, φ, v⟩ => decisions φ v |
| | .inr (.inl ⟨_, φ, v⟩) => exWitnesses φ v |
| | .inr (.inr ⟨_, φ, v⟩) => allCounterexamples φ v |
| have hD : ∀ i, ForcingQuotient.Dense (D i) := by |
| rintro (⟨n, φ, v⟩ | ⟨n, φ, v⟩ | ⟨n, φ, v⟩) |
| · exact decisions_dense φ v |
| · exact exWitnesses_dense φ v |
| · exact allCounterexamples_dense φ v |
| obtain ⟨G, hp₀, hG⟩ := ForcingQuotient.exists_generic_through D hD p₀ |
| exact ⟨G, hp₀, (fun n φ v => hG (.inl ⟨n, φ, v⟩)), |
| (fun n φ v => hG (.inr (.inl ⟨n, φ, v⟩))), |
| (fun n φ v => hG (.inr (.inr ⟨n, φ, v⟩)))⟩ |
|
|
| /-- Eventual derivability in the directed filter, with all free variables |
| interpreted as natural-number constant codes. -/ |
| def Proven (G : GenericFilter) {n} (φ : Formula n) (v : Fin n → ℕ) : Prop := |
| ∃ p ∈ G, ∃ w : Fin n → Fin p.size, |
| (∀ i, (w i).val = v i) ∧ Derives p.context (φ.rename w) |
|
|
| namespace Proven |
|
|
| variable {G : GenericFilter} {n : ℕ} {φ ψ : Formula n} {v : Fin n → ℕ} |
|
|
| /-- Any existing representation of the tuple can be extended to one carrying |
| the given derivation. Directedness, not an assumed complete theory, is used. -/ |
| theorem at_condition (h : Proven G φ v) {p : Condition} (hp : p ∈ G) |
| (w : Fin n → Fin p.size) (hw : ∀ i, (w i).val = v i) : |
| ∃ q : Condition, q ∈ G ∧ ∃ hqp : q ≤ p, |
| Derives q.context (φ.rename (Condition.emb hqp ∘ w)) := by |
| obtain ⟨r, hr, u, hu, hd⟩ := h |
| obtain ⟨q, hq, hqr, hqp⟩ := G.directed _ hr _ hp |
| refine ⟨q, hq, hqp, ?_⟩ |
| have he : Condition.emb hqr ∘ u = Condition.emb hqp ∘ w := by |
| funext i |
| apply Fin.ext |
| exact (hu i).trans (hw i).symm |
| simpa only [Formula.rename_comp, he] using Condition.transport hqr hd |
|
|
| /-- Two eventual derivations with the same tuple can be put into a single |
| consistent context with exactly the same variable map. -/ |
| theorem joint (hφ : Proven G φ v) (hψ : Proven G ψ v) : |
| ∃ p ∈ G, ∃ w : Fin n → Fin p.size, (∀ i, (w i).val = v i) ∧ |
| Derives p.context (φ.rename w) ∧ Derives p.context (ψ.rename w) := by |
| obtain ⟨p, hp, w, hw, hdφ⟩ := hφ |
| obtain ⟨q, hq, hqp, hdψ⟩ := hψ.at_condition hp w hw |
| refine ⟨q, hq, Condition.emb hqp ∘ w, hw, ?_, hdψ⟩ |
| simpa only [Formula.rename_comp] using Condition.transport hqp hdφ |
|
|
| theorem not_bot : ¬ Proven G (Formula.bot : Formula n) v := by |
| rintro ⟨p, _, _, _, hd⟩ |
| exact p.consistent hd |
|
|
| theorem conjunction : Proven G (φ.conj ψ) v ↔ Proven G φ v ∧ Proven G ψ v := by |
| constructor |
| · rintro ⟨p, hp, w, hw, hd⟩ |
| exact ⟨⟨p, hp, w, hw, hd.conjL⟩, ⟨p, hp, w, hw, hd.conjR⟩⟩ |
| · rintro ⟨hφ, hψ⟩ |
| obtain ⟨p, hp, w, hw, hdφ, hdψ⟩ := hφ.joint hψ |
| exact ⟨p, hp, w, hw, Derives.conjI hdφ hdψ⟩ |
|
|
| theorem apply_imp (hpq : Proven G (φ.imp ψ) v) (hp : Proven G φ v) : Proven G ψ v := by |
| obtain ⟨p, hp, w, hw, hd₁, hd₂⟩ := hpq.joint hp |
| exact ⟨p, hp, w, hw, Derives.impE hd₁ hd₂⟩ |
|
|
| theorem contradict (hn : Proven G φ.neg v) (hp : Proven G φ v) : False := |
| not_bot (hn.apply_imp hp) |
|
|
| variable (hG : IsHenkin G) |
| include hG |
|
|
| /-- This also supplies a filter condition containing any prescribed finite |
| collection of constant codes, including codes not used by a formula. -/ |
| theorem tuple (v : Fin n → ℕ) : |
| ∃ p ∈ G, ∃ w : Fin n → Fin p.size, ∀ i, (w i).val = v i := by |
| obtain ⟨p, hp, w, hw, _⟩ := hG.1 n .bot v |
| exact ⟨p, hp, w, hw⟩ |
|
|
| theorem decision (φ : Formula n) (v : Fin n → ℕ) : |
| Proven G φ v ∨ Proven G φ.neg v := by |
| obtain ⟨p, hp, w, hw, hd | hd⟩ := hG.1 n φ v |
| · exact Or.inl ⟨p, hp, w, hw, hd⟩ |
| · exact Or.inr ⟨p, hp, w, hw, hd⟩ |
|
|
| theorem negation : Proven G φ.neg v ↔ ¬ Proven G φ v := by |
| constructor |
| · exact contradict |
| · intro hn |
| exact (decision hG φ v).resolve_left hn |
|
|
| /-- Full substitution of finite variable tuples, in both directions. The |
| reverse implication includes variables unused in the substituted formula. -/ |
| theorem rename_iff {m} (φ : Formula n) (r : Fin n → Fin m) (v : Fin m → ℕ) : |
| Proven G (φ.rename r) v ↔ Proven G φ (v ∘ r) := by |
| constructor |
| · rintro ⟨p, hp, w, hw, hd⟩ |
| refine ⟨p, hp, w ∘ r, (fun i => hw (r i)), ?_⟩ |
| simpa only [Formula.rename_comp] using hd |
| · intro hφ |
| obtain ⟨p, hp, w, hw⟩ := tuple hG v |
| obtain ⟨q, hq, hqp, hd⟩ := hφ.at_condition hp (w ∘ r) (fun i => hw (r i)) |
| refine ⟨q, hq, Condition.emb hqp ∘ w, hw, ?_⟩ |
| simpa only [Formula.rename_comp, Function.comp_assoc] using hd |
|
|
| theorem implication : Proven G (φ.imp ψ) v ↔ (Proven G φ v → Proven G ψ v) := by |
| constructor |
| · exact apply_imp |
| · intro h |
| classical |
| by_cases hφ : Proven G φ v |
| · obtain ⟨p, hp, w, hw, hd⟩ := h hφ |
| exact ⟨p, hp, w, hw, Derives.impI (hd.weaken (Set.subset_insert _ _))⟩ |
| · obtain ⟨p, hp, w, hw, hd⟩ := (negation hG).2 hφ |
| refine ⟨p, hp, w, hw, Derives.impI ?_⟩ |
| exact (Derives.impE (hd.weaken (Set.subset_insert _ _)) |
| (Derives.hyp (Set.mem_insert _ _))).botE |
|
|
| theorem disjunction : Proven G (φ.disj ψ) v ↔ Proven G φ v ∨ Proven G ψ v := by |
| constructor |
| · intro h |
| classical |
| by_cases hφ : Proven G φ v |
| · exact Or.inl hφ |
| · right |
| obtain ⟨p, hp, w, hw, hd, hn⟩ := h.joint ((negation hG).2 hφ) |
| refine ⟨p, hp, w, hw, Derives.disjE hd ?_ ?_⟩ |
| · exact (Derives.impE (hn.weaken (Set.subset_insert _ _)) |
| (Derives.hyp (Set.mem_insert _ _))).botE |
| · exact Derives.hyp (Set.mem_insert _ _) |
| · rintro (⟨p, hp, w, hw, hd⟩ | ⟨p, hp, w, hw, hd⟩) |
| · exact ⟨p, hp, w, hw, hd.disjL⟩ |
| · exact ⟨p, hp, w, hw, hd.disjR⟩ |
|
|
| omit hG in |
| /-- Universal elimination is a derivable operation on the eventual theory. -/ |
| theorem all_instance {φ : Formula (n+1)} (h : Proven G (.all φ) v) (t : Fin n) : |
| Proven G (φ.instantiate t) v := by |
| obtain ⟨p, hp, w, hw, hd⟩ := h |
| refine ⟨p, hp, w, hw, ?_⟩ |
| rw [Formula.rename_instantiate] |
| exact Derives.allE (w t) hd |
|
|
| /-- The Henkin requests turn existence into an actual constant-code witness. -/ |
| theorem exists_iff (φ : Formula (n+1)) (v : Fin n → ℕ) : |
| Proven G (.ex φ) v ↔ ∃ a : ℕ, Proven G φ (Fin.snoc v a) := by |
| constructor |
| · intro h |
| obtain ⟨p, hp, w, hw, hn | ⟨a, ha⟩⟩ := hG.2.1 n φ v |
| · exact (contradict ⟨p, hp, w, hw, hn⟩ h).elim |
| · refine ⟨a.val, p, hp, Fin.snoc w a, ?_, ha⟩ |
| intro i |
| refine Fin.lastCases ?_ (fun j => ?_) i <;> simp [hw] |
| · rintro ⟨a, p, hp, w, hw, hd⟩ |
| refine ⟨p, hp, Fin.init w, ?_, ?_⟩ |
| · intro i |
| simpa only [Fin.init, Fin.snoc_castSucc] using hw i.castSucc |
| · apply Derives.exI (w (Fin.last n)) |
| simpa only [Formula.instantiate_rename, Fin.snoc_init_self] using hd |
|
|
| /-- Universal truth is equivalent to truth for every constant code. The |
| counterexample requests are essential to the reverse implication. -/ |
| theorem all_iff (φ : Formula (n+1)) (v : Fin n → ℕ) : |
| Proven G (.all φ) v ↔ ∀ a : ℕ, Proven G φ (Fin.snoc v a) := by |
| constructor |
| · intro h a |
| have hr : Proven G (Formula.all φ).raise (Fin.snoc v a) := by |
| apply (rename_iff hG (.all φ) Fin.castSucc _).2 |
| simpa only [Fin.snoc_comp_castSucc] using h |
| have hi := all_instance hr (Fin.last n) |
| simpa only [Formula.raise, Formula.rename, Formula.instantiate_rename, |
| Formula.rename_snoc_castSucc_last] using hi |
| · intro h |
| obtain ⟨p, hp, w, hw, hall | ⟨a, ha⟩⟩ := hG.2.2 n φ v |
| · exact ⟨p, hp, w, hw, hall⟩ |
| · have hn : Proven G φ.neg (Fin.snoc v a.val) := by |
| refine ⟨p, hp, Fin.snoc w a, ?_, ha⟩ |
| intro i |
| refine Fin.lastCases ?_ (fun j => ?_) i <;> simp [hw] |
| exact (contradict hn (h a.val)).elim |
|
|
| end Proven |
|
|
| /-- Equality and membership of constant codes in the canonical term model. -/ |
| def EqRel (G : GenericFilter) (a b : ℕ) : Prop := |
| Proven G (.equal (0 : Fin 2) 1) ![a,b] |
|
|
| def MemRel (G : GenericFilter) (a b : ℕ) : Prop := |
| Proven G (.mem (0 : Fin 2) 1) ![a,b] |
|
|
| variable {G : GenericFilter} (hG : IsHenkin G) |
| include hG |
|
|
| theorem equal_iff {n} (i j : Fin n) (v : Fin n → ℕ) : |
| Proven G (.equal i j) v ↔ EqRel G (v i) (v j) := by |
| have h := Proven.rename_iff hG (.equal (0 : Fin 2) 1) ![i,j] v |
| have hv : v ∘ ![i,j] = ![v i, v j] := by |
| funext k |
| fin_cases k <;> rfl |
| rw [hv] at h |
| exact h |
|
|
| theorem mem_iff {n} (i j : Fin n) (v : Fin n → ℕ) : |
| Proven G (.mem i j) v ↔ MemRel G (v i) (v j) := by |
| have h := Proven.rename_iff hG (.mem (0 : Fin 2) 1) ![i,j] v |
| have hv : v ∘ ![i,j] = ![v i, v j] := by |
| funext k |
| fin_cases k <;> rfl |
| rw [hv] at h |
| exact h |
|
|
| theorem eqRel_refl (a : ℕ) : EqRel G a a := by |
| obtain ⟨p, hp, w, hw⟩ := Proven.tuple hG ![a,a] |
| refine ⟨p, hp, w, hw, ?_⟩ |
| have he : w 0 = w 1 := Fin.ext ((hw 0).trans (hw 1).symm) |
| change Derives p.context (.equal (w 0) (w 1)) |
| rw [he] |
| exact Derives.eqRefl _ |
|
|
| omit hG in |
| theorem eqRel_symm {a b : ℕ} (h : EqRel G a b) : EqRel G b a := by |
| obtain ⟨p, hp, w, hw, hd⟩ := h |
| refine ⟨p, hp, ![w 1, w 0], ?_, hd.eq_symm⟩ |
| intro i |
| fin_cases i <;> simp [hw] |
|
|
| theorem eqRel_trans {a b c : ℕ} (hab : EqRel G a b) (hbc : EqRel G b c) : |
| EqRel G a c := by |
| have h₁ := (equal_iff hG (0 : Fin 3) 1 ![a,b,c]).2 hab |
| have h₂ := (equal_iff hG (1 : Fin 3) 2 ![a,b,c]).2 hbc |
| obtain ⟨p, hp, w, hw, hd₁, hd₂⟩ := h₁.joint h₂ |
| have hc : Proven G (.equal (0 : Fin 3) 2) ![a,b,c] := |
| ⟨p, hp, w, hw, hd₁.eq_trans hd₂⟩ |
| exact (equal_iff hG (0 : Fin 3) 2 ![a,b,c]).1 hc |
|
|
| theorem memRel_congr {a b a' b' : ℕ} (ha : EqRel G a a') (hb : EqRel G b b') : |
| MemRel G a b ↔ MemRel G a' b' := by |
| have transport : ∀ {a b a' b' : ℕ}, EqRel G a a' → EqRel G b b' → |
| MemRel G a b → MemRel G a' b' := by |
| intro a b a' b' ha hb hm |
| have h₁ := (equal_iff hG (0 : Fin 4) 2 ![a,b,a',b']).2 ha |
| have h₂ := (equal_iff hG (1 : Fin 4) 3 ![a,b,a',b']).2 hb |
| have h₃ := (mem_iff hG (0 : Fin 4) 1 ![a,b,a',b']).2 hm |
| obtain ⟨p, hp, w, hw, hd₁₂, hd₃⟩ := ((Proven.conjunction).2 ⟨h₁,h₂⟩).joint h₃ |
| have h' : Proven G (.mem (2 : Fin 4) 3) ![a,b,a',b'] := |
| ⟨p, hp, w, hw, Derives.mem_congr hd₁₂.conjL hd₁₂.conjR hd₃⟩ |
| exact (mem_iff hG (2 : Fin 4) 3 ![a,b,a',b']).1 h' |
| exact ⟨transport ha hb, transport (eqRel_symm ha) (eqRel_symm hb)⟩ |
|
|
| /-- Quotient of the natural-number constant codes by their syntactically |
| provable equality. -/ |
| def termSetoid (G : GenericFilter) (hG : IsHenkin G) : Setoid ℕ where |
| r := EqRel G |
| iseqv := ⟨eqRel_refl hG, eqRel_symm, eqRel_trans hG⟩ |
|
|
| def TermModel (G : GenericFilter) (hG : IsHenkin G) : Type := Quotient (termSetoid G hG) |
|
|
| def termClass (G : GenericFilter) (hG : IsHenkin G) (a : ℕ) : TermModel G hG := |
| Quotient.mk _ a |
|
|
| instance termModel_nonempty : Nonempty (TermModel G hG) := ⟨termClass G hG 0⟩ |
| instance termModel_countable : Countable (TermModel G hG) := |
| inferInstanceAs (Countable (Quotient (termSetoid G hG))) |
|
|
| /-- Membership is independent of representatives because first-order equality |
| has its actual substitution rule. -/ |
| def termMem (G : GenericFilter) (hG : IsHenkin G) : |
| TermModel G hG → TermModel G hG → Prop := |
| Quotient.lift₂ (MemRel G) (fun _ _ _ _ ha hb => propext (memRel_congr hG ha hb)) |
|
|
| /-- Truth in the countable term model, for every formula and every tuple of |
| constant codes. This is syntactic completeness, not compactness assumed as a |
| premise or semantic consistency used as a definition. -/ |
| theorem term_truth {n} (φ : Formula n) (v : Fin n → ℕ) : |
| Formula.Realize (termMem G hG) (termClass G hG ∘ v) φ ↔ Proven G φ v := by |
| induction φ with |
| | bot => exact ⟨False.elim, Proven.not_bot⟩ |
| | mem i j => exact (mem_iff hG i j v).symm |
| | equal i j => exact Quotient.eq.trans (equal_iff hG i j v).symm |
| | conj φ ψ hφ hψ => |
| simp only [Formula.Realize, hφ v, hψ v, Proven.conjunction] |
| | imp φ ψ hφ hψ => |
| simp only [Formula.Realize, hφ v, hψ v, Proven.implication hG] |
| | disj φ ψ hφ hψ => |
| simp only [Formula.Realize, hφ v, hψ v, Proven.disjunction hG] |
| | all φ hφ => |
| rw [Proven.all_iff hG] |
| constructor |
| · intro h a |
| apply (hφ (Fin.snoc v a)).1 |
| simpa only [Fin.comp_snoc, termClass] using h (termClass G hG a) |
| · intro h x |
| obtain ⟨a, rfl⟩ := Quotient.exists_rep x |
| simpa only [Fin.comp_snoc, termClass] using (hφ (Fin.snoc v a)).2 (h a) |
| | ex φ hφ => |
| rw [Proven.exists_iff hG] |
| constructor |
| · rintro ⟨x, hx⟩ |
| obtain ⟨a, rfl⟩ := Quotient.exists_rep x |
| refine ⟨a, (hφ (Fin.snoc v a)).1 ?_⟩ |
| simpa only [Fin.comp_snoc, termClass] using hx |
| · rintro ⟨a, ha⟩ |
| refine ⟨termClass G hG a, ?_⟩ |
| simpa only [Fin.comp_snoc, termClass] using (hφ (Fin.snoc v a)).2 ha |
|
|
| omit hG in |
| /-- Countable-model completeness for the actual finite-derivation consistency |
| predicate used in the target. No transitive or externally well-founded model |
| is asserted. The domain is concretely a quotient of `ℕ`. -/ |
| theorem exists_countable_model {T : Theory} (hT : Consistent T) : |
| ∃ M : Type, Nonempty M ∧ Countable M ∧ ∃ E : M → M → Prop, Models E T := by |
| let p₀ : Condition := ⟨1, Nat.zero_lt_succ 0, T.at 1, hT 1⟩ |
| obtain ⟨G, hp₀, hG⟩ := exists_henkin p₀ |
| refine ⟨TermModel G hG, inferInstance, inferInstance, termMem G hG, ?_⟩ |
| intro φ hφ |
| have ht := term_truth hG φ Fin.elim0 |
| have hv : termClass G hG ∘ Fin.elim0 = (Fin.elim0 : Fin 0 → TermModel G hG) := |
| Subsingleton.elim _ _ |
| rw [hv] at ht |
| apply ht.2 |
| refine ⟨p₀, hp₀, Fin.elim0, (fun i => Fin.elim0 i), Derives.hyp ?_⟩ |
| exact ⟨φ, hφ, rfl⟩ |
|
|
| omit hG in |
| /-- Equivalence of syntactic consistency and countable nonempty models for |
| this first-order language. This does not perform the constructible or |
| symmetric-forcing interpretations required in `main_consistency`. -/ |
| theorem consistent_iff_has_countable_model (T : Theory) : |
| Consistent T ↔ |
| ∃ M : Type, Nonempty M ∧ Countable M ∧ ∃ E : M → M → Prop, Models E T := by |
| constructor |
| · exact exists_countable_model |
| · rintro ⟨M, hM, _, E, hE⟩ |
| let _ := hM |
| exact consistent_of_model E hE |
|
|
| end Completeness |
| end PartitionConsistency |
|
|
| end OAI |
|
|
