| import Mathlib |
| import OAI.SetTheory.PartitionConsistency.Forcing.AtomicForcing |
| import OAI.SetTheory.PartitionConsistency.Forcing.ForcingQuotient |
|
|
| namespace OAI |
|
|
| namespace PartitionConsistency.ForcingQuotient.AtomicData |
|
|
| variable {P N : Type*} [Preorder P] (A : AtomicData P N) |
|
|
| /-- Induction through the defined logical forcing relation propagates a |
| condition/name automorphism from the atomic cases to each fixed formula. |
| The existential clause remains density of local witnesses. -/ |
| theorem force_symmetry (e : P ≃o P) (f : N ≃ N) |
| (heq : ∀ p a b, A.EqF p a b ↔ A.EqF (e p) (f a) (f b)) |
| (hmem : ∀ p a b, A.MemF p a b ↔ A.MemF (e p) (f a) (f b)) |
| {n} (φ : BasicFormula n) (v : Fin n → N) (p : P) : |
| A.Force v p φ ↔ A.Force (f ∘ v) (e p) φ := by |
| induction φ generalizing p with |
| | bot => rfl |
| | mem a b => exact hmem p (v a) (v b) |
| | equal a b => exact heq p (v a) (v b) |
| | conj φ ψ ihφ ihψ => exact and_congr (ihφ v p) (ihψ v p) |
| | neg φ ih => |
| constructor |
| · intro h q hqp hq |
| obtain ⟨q, rfl⟩ := e.surjective q |
| exact h q (e.le_iff_le.mp hqp) ((ih v q).mpr hq) |
| · intro h q hqp hq |
| exact h (e q) (e.monotone hqp) ((ih v q).mp hq) |
| | ex φ ih => |
| constructor |
| · intro h q hqp |
| obtain ⟨q, rfl⟩ := e.surjective q |
| obtain ⟨r, hrq, x, hx⟩ := h q (e.le_iff_le.mp hqp) |
| refine ⟨e r, e.monotone hrq, f x, ?_⟩ |
| simpa only [Fin.comp_snoc] using (ih (Fin.snoc v x) r).mp hx |
| · intro h q hqp |
| obtain ⟨r, hrq, x, hx⟩ := h (e q) (e.monotone hqp) |
| obtain ⟨r, rfl⟩ := e.surjective r |
| obtain ⟨x, rfl⟩ := f.surjective x |
| refine ⟨r, e.le_iff_le.mp hrq, x, (ih (Fin.snoc v x) r).mpr ?_⟩ |
| simpa only [Fin.comp_snoc] using hx |
|
|
| end PartitionConsistency.ForcingQuotient.AtomicData |
|
|
|
|
|
|
| namespace PartitionConsistency.ForcingQuotient.AtomicData |
| variable {P N : Type*} [Preorder P] (A : AtomicData P N) |
|
|
| /-- The ordinary forcing relation is regular: density of atomic forcing below |
| `p` already implies forcing at `p`. This property is separately verified by the |
| actual name recursion, not assumed for any target axiom. -/ |
| def Regular : Prop := |
| (∀ p a b, (∀ q, q ≤ p → ∃ r, r ≤ q ∧ A.EqF r a b) → A.EqF p a b) ∧ |
| (∀ p a b, (∀ q, q ≤ p → ∃ r, r ≤ q ∧ A.MemF r a b) → A.MemF p a b) |
|
|
| /-- Dense closure extends from the atomic relations to every fixed formula. -/ |
| theorem force_of_dense (hA : A.Regular) {n} (φ : BasicFormula n) (v : Fin n → N) |
| (p : P) (h : ∀ q, q ≤ p → ∃ r, r ≤ q ∧ A.Force v r φ) : A.Force v p φ := by |
| induction φ generalizing p with |
| | bot => obtain ⟨r, _, hr⟩ := h p le_rfl; exact hr |
| | mem x y => exact hA.2 p (v x) (v y) h |
| | equal x y => exact hA.1 p (v x) (v y) h |
| | conj φ ψ ihφ ihψ => |
| refine ⟨ihφ v p ?_, ihψ v p ?_⟩ |
| · intro q hq |
| obtain ⟨r, hrq, hr⟩ := h q hq |
| exact ⟨r, hrq, hr.1⟩ |
| · intro q hq |
| obtain ⟨r, hrq, hr⟩ := h q hq |
| exact ⟨r, hrq, hr.2⟩ |
| | neg φ _ => |
| intro q hqp hq |
| obtain ⟨r, hrq, hr⟩ := h q hqp |
| exact hr r le_rfl (A.force_mono φ v hrq hq) |
| | ex φ _ => |
| intro q hqp |
| obtain ⟨r, hrq, hr⟩ := h q hqp |
| obtain ⟨s, hsr, hs⟩ := hr r le_rfl |
| exact ⟨s, hsr.trans hrq, hs⟩ |
|
|
| theorem exists_force_neg (hA : A.Regular) {n} (φ : BasicFormula n) (v : Fin n → N) |
| {p : P} (h : ¬ A.Force v p φ) : ∃ q, q ≤ p ∧ A.Force v q (.neg φ) := by |
| classical |
| by_contra! hn |
| apply h |
| apply A.force_of_dense hA φ v |
| intro q hqp |
| have hnot := hn q hqp |
| change ¬ (∀ r, r ≤ q → ¬ A.Force v r φ) at hnot |
| push Not at hnot |
| exact hnot |
|
|
| /-- Forcing in the full syntax of the statement is the previously defined |
| Boolean/existential-basis forcing, with no change of quantifier domain. -/ |
| def ForceFormula {n} (v : Fin n → N) (p : P) (φ : Formula n) : Prop := |
| A.Force v p φ.toBasic |
|
|
| theorem forceFormula_mono {n} {v : Fin n → N} {p q : P} {φ : Formula n} |
| (hqp : q ≤ p) (h : A.ForceFormula v p φ) : A.ForceFormula v q φ := |
| A.force_mono φ.toBasic v hqp h |
|
|
| theorem forceFormula_of_dense (hA : A.Regular) {n} {v : Fin n → N} {p : P} |
| {φ : Formula n} (h : ∀ q, q ≤ p → ∃ r, r ≤ q ∧ A.ForceFormula v r φ) : |
| A.ForceFormula v p φ := A.force_of_dense hA φ.toBasic v p h |
|
|
| @[simp] theorem forceFormula_bot {n} (v : Fin n → N) (p : P) : |
| A.ForceFormula v p .bot ↔ False := Iff.rfl |
|
|
| @[simp] theorem forceFormula_mem {n} (v : Fin n → N) (p : P) (x y : Fin n) : |
| A.ForceFormula v p (.mem x y) ↔ A.MemF p (v x) (v y) := Iff.rfl |
|
|
| @[simp] theorem forceFormula_equal {n} (v : Fin n → N) (p : P) (x y : Fin n) : |
| A.ForceFormula v p (.equal x y) ↔ A.EqF p (v x) (v y) := Iff.rfl |
|
|
| @[simp] theorem forceFormula_conj {n} (v : Fin n → N) (p : P) (φ ψ : Formula n) : |
| A.ForceFormula v p (.conj φ ψ) ↔ A.ForceFormula v p φ ∧ A.ForceFormula v p ψ := Iff.rfl |
|
|
| theorem forceFormula_imp (hA : A.Regular) {n} (v : Fin n → N) (p : P) (φ ψ : Formula n) : |
| A.ForceFormula v p (.imp φ ψ) ↔ |
| ∀ q, q ≤ p → A.ForceFormula v q φ → A.ForceFormula v q ψ := by |
| constructor |
| · intro h q hqp hq |
| by_contra! hn |
| obtain ⟨r, hrq, hr⟩ := A.exists_force_neg hA ψ.toBasic v hn |
| exact h r (hrq.trans hqp) ⟨A.forceFormula_mono hrq hq, hr⟩ |
| · intro h q hqp hq |
| exact hq.2 q le_rfl (h q hqp hq.1) |
|
|
| theorem forceFormula_neg (hA : A.Regular) {n} (v : Fin n → N) (p : P) (φ : Formula n) : |
| A.ForceFormula v p φ.neg ↔ ∀ q, q ≤ p → ¬ A.ForceFormula v q φ := |
| A.forceFormula_imp hA v p φ .bot |
|
|
| theorem forceFormula_disj {n} (v : Fin n → N) (p : P) (φ ψ : Formula n) : |
| A.ForceFormula v p (.disj φ ψ) ↔ |
| ∀ q, q ≤ p → ∃ r, r ≤ q ∧ (A.ForceFormula v r φ ∨ A.ForceFormula v r ψ) := by |
| classical |
| constructor |
| · intro h q hqp |
| by_contra! hn |
| apply h q hqp |
| exact ⟨fun r hrq hr => (hn r hrq).1 hr, fun r hrq hr => (hn r hrq).2 hr⟩ |
| · intro h q hqp hq |
| obtain ⟨r, hrq, hr | hr⟩ := h q hqp |
| · exact hq.1 r hrq hr |
| · exact hq.2 r hrq hr |
|
|
| @[simp] theorem forceFormula_ex {n} (v : Fin n → N) (p : P) (φ : Formula (n+1)) : |
| A.ForceFormula v p (.ex φ) ↔ |
| ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ x, A.ForceFormula (Fin.snoc v x) r φ := Iff.rfl |
|
|
| theorem forceFormula_all (hA : A.Regular) {n} (v : Fin n → N) (p : P) |
| (φ : Formula (n+1)) : A.ForceFormula v p (.all φ) ↔ |
| ∀ x, A.ForceFormula (Fin.snoc v x) p φ := by |
| constructor |
| · intro h x |
| by_contra! hn |
| obtain ⟨q, hqp, hq⟩ := A.exists_force_neg hA φ.toBasic (Fin.snoc v x) hn |
| apply h q hqp |
| intro r hrq |
| exact ⟨r, le_rfl, x, A.force_mono (.neg φ.toBasic) (Fin.snoc v x) hrq hq⟩ |
| · intro h q hqp hq |
| obtain ⟨r, hrq, x, hr⟩ := hq q le_rfl |
| exact hr r le_rfl (A.forceFormula_mono (hrq.trans hqp) (h x)) |
|
|
| theorem forceFormula_rename (hA : A.Regular) {n m} (φ : Formula n) (r : Fin n → Fin m) |
| (v : Fin m → N) (p : P) : |
| A.ForceFormula v p (φ.rename r) ↔ A.ForceFormula (v ∘ r) p φ := by |
| induction φ generalizing m p with |
| | bot => rfl |
| | mem => rfl |
| | equal => rfl |
| | imp φ ψ ihφ ihψ => |
| simp only [Formula.rename, A.forceFormula_imp hA, ihφ, ihψ] |
| | conj φ ψ ihφ ihψ => |
| simp only [Formula.rename, forceFormula_conj, ihφ, ihψ] |
| | disj φ ψ ihφ ihψ => |
| simp only [Formula.rename, forceFormula_disj, ihφ, ihψ] |
| | all φ ih => |
| simp only [Formula.rename, A.forceFormula_all hA, ih, Formula.snoc_comp_liftRen] |
| | ex φ ih => |
| simp only [Formula.rename, forceFormula_ex, ih, Formula.snoc_comp_liftRen] |
|
|
| theorem forceFormula_raise (hA : A.Regular) {n} (φ : Formula n) (v : Fin n → N) |
| (x : N) (p : P) : |
| A.ForceFormula (Fin.snoc v x) p φ.raise ↔ A.ForceFormula v p φ := by |
| rw [A.forceFormula_rename hA] |
| have h : Fin.snoc v x ∘ Fin.castSucc = v := by funext i; simp |
| rw [h] |
|
|
| theorem forceFormula_instantiate (hA : A.Regular) {n} (φ : Formula (n+1)) |
| (t : Fin n) (v : Fin n → N) (p : P) : |
| A.ForceFormula v p (φ.instantiate t) ↔ A.ForceFormula (Fin.snoc v (v t)) p φ := by |
| rw [Formula.instantiate, A.forceFormula_rename hA] |
| have h : v ∘ Fin.lastCases t id = Fin.snoc v (v t) := by |
| funext i |
| refine Fin.lastCases ?_ (fun j => ?_) i <;> simp |
| rw [h] |
|
|
| /-- Equality substitution for all formulas follows from the atomic laws. -/ |
| theorem force_tuple_congr {n} (φ : BasicFormula n) (v w : Fin n → N) (p : P) |
| (hvw : ∀ i, A.EqF p (v i) (w i)) : A.Force v p φ ↔ A.Force w p φ := by |
| induction φ generalizing p with |
| | bot => rfl |
| | mem x y => exact A.mem_congr (hvw x) (hvw y) |
| | equal x y => |
| constructor |
| · intro h |
| exact A.eq_trans (A.eq_symm (hvw x)) (A.eq_trans h (hvw y)) |
| · intro h |
| exact A.eq_trans (hvw x) (A.eq_trans h (A.eq_symm (hvw y))) |
| | conj φ ψ ihφ ihψ => exact and_congr (ihφ v w p hvw) (ihψ v w p hvw) |
| | neg φ ih => |
| constructor |
| · intro h q hqp hq |
| exact h q hqp ((ih v w q (fun i => A.eq_mono hqp (hvw i))).mpr hq) |
| · intro h q hqp hq |
| exact h q hqp ((ih v w q (fun i => A.eq_mono hqp (hvw i))).mp hq) |
| | @ex n φ ih => |
| have step : ∀ v w : Fin n → N, (∀ i, A.EqF p (v i) (w i)) → |
| A.Force v p (.ex φ) → A.Force w p (.ex φ) := by |
| intro v w he h q hqp |
| obtain ⟨r, hrq, x, hr⟩ := h q hqp |
| refine ⟨r, hrq, x, (ih (Fin.snoc v x) (Fin.snoc w x) r ?_).mp hr⟩ |
| intro i |
| refine Fin.lastCases ?_ (fun j => ?_) i |
| · simpa using A.eq_refl r x |
| · simpa using A.eq_mono (hrq.trans hqp) (he j) |
| exact ⟨step v w hvw, step w v (fun i => A.eq_symm (hvw i))⟩ |
|
|
| theorem forceFormula_tuple_congr {n} (φ : Formula n) (v w : Fin n → N) (p : P) |
| (hvw : ∀ i, A.EqF p (v i) (w i)) : |
| A.ForceFormula v p φ ↔ A.ForceFormula w p φ := A.force_tuple_congr φ.toBasic v w p hvw |
|
|
| /-- Soundness for the actual classical calculus in forcing semantics. Unlike |
| the quotient-model argument this needs no countability assumption on the full |
| collection of names and constructs no generic over all names. -/ |
| theorem forcing_sound (hA : A.Regular) {n} {Γ : Set (Formula n)} {φ : Formula n} |
| (h : Derives Γ φ) (v : Fin n → N) (p : P) |
| (hΓ : ∀ ψ ∈ Γ, A.ForceFormula v p ψ) : A.ForceFormula v p φ := by |
| induction h generalizing p with |
| | hyp hp => exact hΓ _ hp |
| | weaken hsub _ ih => exact ih v p (fun ψ hψ => hΓ ψ (hsub hψ)) |
| | impI _ ih => |
| apply (A.forceFormula_imp hA _ _ _ _).mpr |
| intro q hqp hq |
| exact ih v q (fun ψ hψ => by |
| rcases hψ with rfl | hψ |
| · exact hq |
| · exact A.forceFormula_mono hqp (hΓ _ hψ)) |
| | impE _ _ ih₁ ih₂ => |
| exact (A.forceFormula_imp hA _ _ _ _).mp (ih₁ v p hΓ) p le_rfl (ih₂ v p hΓ) |
| | botE _ ih => exact (ih v p hΓ).elim |
| | @classical n Γ φ _ ih => |
| apply A.forceFormula_of_dense hA |
| intro q hqp |
| by_contra! hn |
| have hneg : A.ForceFormula v q φ.neg := |
| (A.forceFormula_neg hA _ _ _).mpr hn |
| exact ih v q (fun ψ hψ => by |
| rcases hψ with rfl | hψ |
| · exact hneg |
| · exact A.forceFormula_mono hqp (hΓ _ hψ)) |
| | conjI _ _ ih₁ ih₂ => exact ⟨ih₁ v p hΓ, ih₂ v p hΓ⟩ |
| | conjL _ ih => exact (ih v p hΓ).1 |
| | conjR _ ih => exact (ih v p hΓ).2 |
| | disjL _ ih => |
| apply (A.forceFormula_disj _ _ _ _).mpr |
| intro q hqp |
| exact ⟨q, le_rfl, Or.inl (A.forceFormula_mono hqp (ih v p hΓ))⟩ |
| | disjR _ ih => |
| apply (A.forceFormula_disj _ _ _ _).mpr |
| intro q hqp |
| exact ⟨q, le_rfl, Or.inr (A.forceFormula_mono hqp (ih v p hΓ))⟩ |
| | disjE _ _ _ ih₁ ih₂ ih₃ => |
| apply A.forceFormula_of_dense hA |
| intro q hqp |
| obtain ⟨r, hrq, hr | hr⟩ := (A.forceFormula_disj _ _ _ _).mp (ih₁ v p hΓ) q hqp |
| · exact ⟨r, hrq, ih₂ v r (fun ψ hψ => by |
| rcases hψ with rfl | hψ |
| · exact hr |
| · exact A.forceFormula_mono (hrq.trans hqp) (hΓ _ hψ))⟩ |
| · exact ⟨r, hrq, ih₃ v r (fun ψ hψ => by |
| rcases hψ with rfl | hψ |
| · exact hr |
| · exact A.forceFormula_mono (hrq.trans hqp) (hΓ _ hψ))⟩ |
| | allI _ ih => |
| apply (A.forceFormula_all hA _ _ _).mpr |
| intro x |
| apply ih (Fin.snoc v x) p |
| rintro ψ ⟨χ, hχ, rfl⟩ |
| exact (A.forceFormula_raise hA _ _ _ _).mpr (hΓ _ hχ) |
| | allE t _ ih => |
| exact (A.forceFormula_instantiate hA _ _ _ _).mpr |
| ((A.forceFormula_all hA _ _ _).mp (ih v p hΓ) (v t)) |
| | exI t _ ih => |
| intro q hqp |
| exact ⟨q, le_rfl, v t, A.forceFormula_mono hqp |
| ((A.forceFormula_instantiate hA _ _ _ _).mp (ih v p hΓ))⟩ |
| | exE _ _ ih₁ ih₂ => |
| apply A.forceFormula_of_dense hA |
| intro q hqp |
| obtain ⟨r, hrq, x, hr⟩ := ih₁ v p hΓ q hqp |
| refine ⟨r, hrq, (A.forceFormula_raise hA _ _ _ _).mp (ih₂ (Fin.snoc v x) r ?_)⟩ |
| intro ψ hψ |
| rcases hψ with rfl | hψ |
| · exact hr |
| · obtain ⟨χ, hχ, rfl⟩ := hψ |
| exact (A.forceFormula_raise hA _ _ _ _).mpr |
| (A.forceFormula_mono (hrq.trans hqp) (hΓ _ hχ)) |
| | eqRefl t => exact A.eq_refl p (v t) |
| | eqSubst ψ _ _ ih₁ ih₂ => |
| apply (A.forceFormula_instantiate hA _ _ _ _).mpr |
| apply (A.forceFormula_tuple_congr ψ _ _ p ?_).mp |
| ((A.forceFormula_instantiate hA _ _ _ _).mp (ih₂ v p hΓ)) |
| intro i |
| refine Fin.lastCases ?_ (fun j => ?_) i |
| · simpa using ih₁ v p hΓ |
| · simpa using A.eq_refl p (v j) |
| | rename r _ ih => |
| apply (A.forceFormula_rename hA _ _ _ _).mpr |
| apply ih (v ∘ r) p |
| intro ψ hψ |
| exact (A.forceFormula_rename hA _ _ _ _).mp (hΓ _ ⟨ψ,hψ,rfl⟩) |
|
|
| /-- A nonempty regular forcing semantics yields ordinary syntactic consistency |
| for any theory whose axioms are all forced. Neither an externally generic |
| filter nor a countable class of names is needed. This is not an assertion that |
| the target axioms are forced in the constructed symmetric system. -/ |
| theorem consistent_of_regular_forcing (hA : A.Regular) [Nonempty N] (p : P) |
| {T : Theory} (hT : ∀ φ ∈ T, A.ForceFormula Fin.elim0 p φ) : Consistent T := by |
| intro n hcontra |
| let v : Fin n → N := fun _ => Classical.choice (inferInstance : Nonempty N) |
| apply A.forcing_sound hA hcontra v p |
| rintro _ ⟨φ,hφ,rfl⟩ |
| apply (A.forceFormula_rename hA _ _ _ _).mpr |
| have hv : v ∘ (Fin.elim0 : Fin 0 → Fin n) = (Fin.elim0 : Fin 0 → N) := Subsingleton.elim _ _ |
| rw [hv] |
| exact hT φ hφ |
|
|
| end PartitionConsistency.ForcingQuotient.AtomicData |
|
|
| namespace PartitionConsistency.SetForcingNames.AtomicForcing |
| universe u v |
| variable {P : Type v} [Preorder P] |
|
|
| /-- Actual name forcing has all the regularity needed for classical logical |
| soundness, as a theorem of the recursion on sets. -/ |
| theorem data_regular (code : P → ZFSet.{u}) (N : Set ZFSet.{u}) : (data code N).Regular := by |
| constructor |
| · intro p a b h |
| exact eq_of_dense h |
| · intro p a b h |
| exact mem_of_dense h |
|
|
| end PartitionConsistency.SetForcingNames.AtomicForcing |
|
|
| end OAI |
|
|
