| import Mathlib |
| import OAI.SetTheory.PartitionConsistency.Models.GraphFusion |
| import OAI.SetTheory.PartitionConsistency.Forcing.EquivariantMixing |
|
|
| namespace OAI |
|
|
| /-! ## CodeSelection -/ |
|
|
| /-! Least-code selection at the level of forcing conditions. No generic |
| filter, regular ultrafilter, or selection of values in another universe is |
| assumed. The equivalence relation has a monotone truth value, and working |
| codes persist under refinement. -/ |
| namespace PartitionConsistency.ConditionCodeSelection |
| universe u v |
| noncomputable section |
| variable {P : Type u} [Preorder P] {A : Type v} |
| variable (W : P → A → Prop) (E : P → A → A → Prop) |
|
|
| /-- A working code and the assertion that no smaller code can ever become a |
| working representative of the same value. -/ |
| def Selected (a : A) (p : P) : Prop := |
| W p a ∧ ∀ q, q ≤ p → ∀ b, WellOrderingRel b a → ¬ (W q b ∧ E q a b) |
|
|
| variable (wmono : ∀ {p q a}, q ≤ p → W p a → W q a) |
| variable (emono : ∀ {p q a b}, q ≤ p → E p a b → E q a b) |
| variable (erefl : ∀ p a, E p a a) |
| variable (esymm : ∀ {p a b}, E p a b → E p b a) |
| variable (etrans : ∀ {p a b c}, E p a b → E p b c → E p a c) |
|
|
| include wmono in |
| theorem selected_mono {a : A} {p q : P} (hqp : q ≤ p) |
| (h : Selected W E a p) : Selected W E a q := |
| ⟨wmono hqp h.1,fun r hr => h.2 r (hr.trans hqp)⟩ |
|
|
| include esymm in |
| /-- Two persistent least codes agreeing at a condition are literally equal, |
| not merely equivalent. -/ |
| theorem selected_unique {a b : A} {p : P} |
| (ha : Selected W E a p) (hb : Selected W E b p) (hab : E p a b) : a = b := by |
| rcases (trichotomous_of WellOrderingRel a b) with h | h | h |
| · exact False.elim (hb.2 p le_rfl a h ⟨ha.1,esymm hab⟩) |
| · exact h |
| · exact False.elim (ha.2 p le_rfl b h ⟨hb.1,hab⟩) |
|
|
| include wmono emono erefl etrans in |
| /-- Every working code densely admits a selected representative. The |
| minimum is taken over the set of codes which can agree *somewhere below* |
| the starting condition; minimality therefore survives every refinement. -/ |
| theorem dense_selected (p : P) (a : A) (ha : W p a) : |
| ∃ q, q ≤ p ∧ ∃ b, Selected W E b q ∧ E q a b := by |
| let B : Set A := {b | ∃ q, q ≤ p ∧ W q b ∧ E q a b} |
| have hB : B.Nonempty := ⟨a,p,le_rfl,wmono le_rfl ha,erefl p a⟩ |
| let b := WellOrderingRel.isWellOrder.wf.min B hB |
| obtain ⟨q,hqp,hb,hab⟩ := WellOrderingRel.isWellOrder.wf.min_mem B hB |
| refine ⟨q,hqp,b,⟨hb,?_⟩,hab⟩ |
| intro r hrq c hcb hc |
| apply WellOrderingRel.isWellOrder.wf.not_lt_min B |
| (show c ∈ B from ⟨r,hrq.trans hqp,hc.1,etrans (emono hrq hab) hc.2⟩) |
| exact hcb |
|
|
| /-- A coordinate transformation acts on conditions but leaves each ground |
| code in place (the same-code covariance of the source). It therefore also |
| preserves the persistent least-code predicate. -/ |
| theorem selected_covariance (e : P ≃o P) |
| (hw : ∀ p a, W (e p) a ↔ W p a) |
| (he : ∀ p a b, E (e p) a b ↔ E p a b) (a : A) (p : P) : |
| Selected W E a (e p) ↔ Selected W E a p := by |
| constructor |
| · rintro ⟨ha,hb⟩ |
| refine ⟨(hw p a).mp ha,fun q hqp b hba h => ?_⟩ |
| exact hb (e q) (e.monotone hqp) b hba |
| ⟨(hw q b).mpr h.1,(he q a b).mpr h.2⟩ |
| · rintro ⟨ha,hb⟩ |
| refine ⟨(hw p a).mpr ha,fun q hqp b hba h => ?_⟩ |
| have hqp' : e.symm q ≤ p := by simpa only [e.symm_apply_apply] using e.symm.monotone hqp |
| exact hb (e.symm q) hqp' b hba |
| ⟨(hw (e.symm q) b).mp (by simpa only [e.apply_symm_apply] using h.1), |
| (he (e.symm q) a b).mp (by simpa only [e.apply_symm_apply] using h.2)⟩ |
|
|
| end |
| end PartitionConsistency.ConditionCodeSelection |
|
|
|
|
| /-! ## PrincipalCode -/ |
|
|
| /-! The least-code construction without an ambient fully generic filter. |
| The names and glued quotient values are the actual ones from the local |
| symbolic system. The principal filter at a condition is used only as a |
| convenient quotient notation for equality forced by that condition. -/ |
| namespace PartitionConsistency.ForcingQuotient |
| universe u |
| variable {P : Type u} [Preorder P] |
|
|
| @[simp] theorem principalFilter_move (p : P) (e : P ≃o P) : |
| (principalFilter p).move e = principalFilter (e p) := by |
| apply Order.Ideal.ext |
| ext q |
| change (p ≤ e.symm q) ↔ (e p ≤ q) |
| exact (e.to_galoisConnection _ _).symm |
|
|
| end PartitionConsistency.ForcingQuotient |
|
|
| namespace PartitionConsistency.ProductForcing.ChainCode |
| universe u |
| open SetForcingNames SetForcingNames.SymmetricSystem DiagramForcing ForcingQuotient |
| open LocalDiagramSystem |
| noncomputable section |
| variable {M I κ : Type u} [LeftCancelMonoid M] [DiagramOrder.IsConical M] |
| variable {μ : Cardinal.{u}} (hμ : Cardinal.aleph0 ≤ μ) (c : κ → ZFSet.{u}) |
| variable [Infinite M] [Infinite I] |
| variable (hcard : Cardinal.mk M ≤ μ) (hsize : Cardinal.mk M < Cardinal.mk I) |
| variable (hmerger : HasFiniteMergers M) |
| variable (hj : DiagramOrder.HasConditionalJoins (DiagramOrder.LeftDivOrder M)) |
| variable {q : Diagram M I} (E : (system (M := M) (I := I) (κ := κ) hμ).Name) |
| variable (hE : ∀ π ∈ SupportFilter.Fix q.range, π • E = E) |
| variable {v : Vertex q} (C : Vertex.Chain v) |
| local notation "D[" F "]" => eligibleSystem hμ c hcard hsize hmerger F q E hE |
|
|
| /-- A code keeps representing a genuine exact-fiber value at every stronger |
| Cohen condition. This is a predicate on the already defined name collection, |
| not an extra mathematical hypothesis about that collection. -/ |
| def Works (d : CohenForcing.Condition I κ) (a : ChainCode hμ c C) : Prop := |
| ∀ e, e ≤ d → ∃ b : (D[principalFilter e]).Glued hj v, |
| Represents hμ c hcard hsize hmerger hj E hE C (principalFilter e) a b |
|
|
| /-- Eventual equality forced by one Cohen condition. Every comparison is of |
| actual names at their chain diagrams. -/ |
| def Same (d : CohenForcing.Condition I κ) (a b : ChainCode hμ c C) : Prop := |
| ∃ N, ∀ i, N ≤ i → (localAtomic hμ (C.vertex i).diagram).EqF d (a i).name (b i).name |
|
|
| variable {hμ c hcard hsize hmerger hj E hE C} |
|
|
| theorem works_mono {d e : CohenForcing.Condition I κ} {a : ChainCode hμ c C} |
| (hed : e ≤ d) (ha : Works hμ c hcard hsize hmerger hj E hE C d a) : |
| Works hμ c hcard hsize hmerger hj E hE C e a := |
| fun f hfe => ha f (hfe.trans hed) |
|
|
| omit [Infinite M] [Infinite I] in |
| theorem same_refl (d : CohenForcing.Condition I κ) (a : ChainCode hμ c C) : |
| Same hμ c C d a a := ⟨0,fun i _ => (localAtomic hμ (C.vertex i).diagram).eq_refl d _⟩ |
|
|
| omit [Infinite M] [Infinite I] in |
| theorem same_symm {d : CohenForcing.Condition I κ} {a b : ChainCode hμ c C} |
| (h : Same hμ c C d a b) : Same hμ c C d b a := by |
| obtain ⟨N,hN⟩ := h |
| exact ⟨N,fun i hi => (localAtomic hμ (C.vertex i).diagram).eq_symm (hN i hi)⟩ |
|
|
| omit [Infinite M] [Infinite I] in |
| theorem same_trans {d : CohenForcing.Condition I κ} {a b f : ChainCode hμ c C} |
| (h : Same hμ c C d a b) (h' : Same hμ c C d b f) : Same hμ c C d a f := by |
| obtain ⟨N,hN⟩ := h |
| obtain ⟨L,hL⟩ := h' |
| exact ⟨max N L,fun i hi => (localAtomic hμ (C.vertex i).diagram).eq_trans |
| (hN i ((le_max_left _ _).trans hi)) (hL i ((le_max_right _ _).trans hi))⟩ |
|
|
| omit [Infinite M] [Infinite I] in |
| theorem same_mono {d e : CohenForcing.Condition I κ} {a b : ChainCode hμ c C} |
| (hed : e ≤ d) (h : Same hμ c C d a b) : Same hμ c C e a b := by |
| obtain ⟨N,hN⟩ := h |
| exact ⟨N,fun i hi => (localAtomic hμ (C.vertex i).diagram).eq_mono hed (hN i hi)⟩ |
|
|
| /-- At one vertex, equality of the glued points is precisely equality of |
| the local symbolic quotient values. -/ |
| theorem at_eq_iff {F : GenericFilter (CohenForcing.Condition I κ)} {w : Vertex q} |
| {τ σ : (system (M := M) (I := I) (κ := κ) hμ).Name} |
| {b b' : (D[F]).Glued hj v} |
| (hb : At hμ c hcard hsize hmerger hj E hE F w τ b) |
| (hb' : At hμ c hcard hsize hmerger hj E hE F w σ b') : |
| b = b' ↔ (localAtomic hμ w.diagram).EqG F τ σ := by |
| obtain ⟨hw,x,ρ,hρ,hx,rfl⟩ := hb |
| obtain ⟨hw',y,ν,hν,hy,rfl⟩ := hb' |
| rw [← hρ,← hν] |
| rw [← LocalQuotient.ofName_eq F ρ ν,hx,hy] |
| constructor |
| · intro h |
| exact congrArg (fun z : (D[F]).vertexFiber w => z.val.val) |
| ((D[F]).toGlued_injective hj v w hw h) |
| · intro h |
| have he : x = y := Subtype.ext (Subtype.ext h) |
| subst y |
| rfl |
| |
| /-- Eventual forced equality detects equality of genuinely represented |
| points. This theorem applies to each principal quotient, without assuming |
| that the filter meets ANY dense sets. -/ |
| theorem same_iff_represents_eq {d : CohenForcing.Condition I κ} {a b : ChainCode hμ c C} |
| {x y : (D[principalFilter d]).Glued hj v} |
| (ha : Represents hμ c hcard hsize hmerger hj E hE C (principalFilter d) a x) |
| (hb : Represents hμ c hcard hsize hmerger hj E hE C (principalFilter d) b y) : |
| Same hμ c C d a b ↔ x = y := by |
| obtain ⟨N,hN⟩ := ha |
| obtain ⟨L,hL⟩ := hb |
| have hiff (i : ℕ) (hn : N ≤ i) (hl : L ≤ i) : |
| x = y ↔ (localAtomic hμ (C.vertex i).diagram).EqF d (a i).name (b i).name := |
| (at_eq_iff (hN i hn) (hL i hl)).trans |
| ((localAtomic hμ (C.vertex i).diagram).eqG_principal d _ _) |
| constructor |
| · rintro ⟨K,hK⟩ |
| exact (hiff (max (max N L) K) |
| ((le_max_left N L).trans (le_max_left _ _)) |
| ((le_max_right N L).trans (le_max_left _ _))).mpr (hK _ (le_max_right _ _)) |
| · intro he |
| exact ⟨max N L,fun i hi => (hiff i |
| ((le_max_left _ _).trans hi) ((le_max_right _ _).trans hi)).mp he⟩ |
| |
| variable (hμ c hcard hsize hmerger hj E hE C) |
| |
| /-- Persistent least codes, defined over the fixed ground wellordering. -/ |
| abbrev Selected (a : ChainCode hμ c C) (d : CohenForcing.Condition I κ) : Prop := |
| ConditionCodeSelection.Selected (Works hμ c hcard hsize hmerger hj E hE C) |
| (Same hμ c C) a d |
| |
| theorem selected_mono {a : ChainCode hμ c C} {d e : CohenForcing.Condition I κ} |
| (hed : e ≤ d) (ha : Selected hμ c hcard hsize hmerger hj E hE C a d) : |
| Selected hμ c hcard hsize hmerger hj E hE C a e := |
| ConditionCodeSelection.selected_mono |
| (Works hμ c hcard hsize hmerger hj E hE C) (Same hμ c C) |
| (fun h ha => works_mono h ha) hed ha |
| |
| theorem selected_unique {a b : ChainCode hμ c C} {d : CohenForcing.Condition I κ} |
| (ha : Selected hμ c hcard hsize hmerger hj E hE C a d) |
| (hb : Selected hμ c hcard hsize hmerger hj E hE C b d) |
| (hab : Same hμ c C d a b) : a = b := |
| ConditionCodeSelection.selected_unique |
| (Works hμ c hcard hsize hmerger hj E hE C) (Same hμ c C) |
| (fun h => same_symm h) ha hb hab |
| |
| theorem dense_selected (d : CohenForcing.Condition I κ) (a : ChainCode hμ c C) |
| (ha : Works hμ c hcard hsize hmerger hj E hE C d a) : |
| ∃ e, e ≤ d ∧ ∃ b, Selected hμ c hcard hsize hmerger hj E hE C b e ∧ Same hμ c C e a b := |
| ConditionCodeSelection.dense_selected |
| (Works hμ c hcard hsize hmerger hj E hE C) (Same hμ c C) |
| (fun h hw => works_mono h hw) |
| (fun h he => same_mono h he) same_refl (fun h h' => same_trans h h') d a ha |
| |
| /-- The working-code predicate is invariant under a tail fixer acting on the |
| condition. The code itself, and its prescribed ground ordering, do not move. -/ |
| theorem works_covariance (k : C.tailFixer hj) (d : CohenForcing.Condition I κ) |
| (a : ChainCode hμ c C) : |
| Works hμ c hcard hsize hmerger hj E hE C (d.permute k.val.val.val) a ↔ |
| Works hμ c hcard hsize hmerger hj E hE C d a := by |
| let e := CohenForcing.Condition.permuteOrderIso (κ := κ) k.val.val.val |
| have hf (f : CohenForcing.Condition I κ) : |
| (∃ x : (D[principalFilter (e f)]).Glued hj v, |
| Represents hμ c hcard hsize hmerger hj E hE C (principalFilter (e f)) a x) ↔ |
| ∃ x : (D[principalFilter f]).Glued hj v, |
| Represents hμ c hcard hsize hmerger hj E hE C (principalFilter f) a x := by |
| rw [← principalFilter_move f e] |
| constructor |
| · rintro ⟨x,hx⟩ |
| obtain ⟨y,rfl⟩ := (transport hμ c hcard hsize hmerger hj E hE (principalFilter f) k.val).surjective x |
| exact ⟨y,(represents_same_code hμ c hcard hsize hmerger hj E hE C _ k a y).mp hx⟩ |
| · rintro ⟨y,hy⟩ |
| exact ⟨transport hμ c hcard hsize hmerger hj E hE (principalFilter f) k.val y, |
| (represents_same_code hμ c hcard hsize hmerger hj E hE C _ k a y).mpr hy⟩ |
| constructor |
| · intro h f hfd |
| exact (hf f).mp (h (e f) (e.monotone hfd)) |
| · intro h f hfd |
| change f ≤ e d at hfd |
| have hfd' : e.symm f ≤ d := by |
| simpa only [e.symm_apply_apply] using e.symm.monotone hfd |
| have hh := (hf (e.symm f)).mpr (h (e.symm f) hfd') |
| exact (show e (e.symm f) = f from e.apply_symm_apply f) ▸ hh |
| |
| omit [Infinite M] [Infinite I] in |
| /-- Eventual equality has the same covariance, again for the unchanged |
| codes. This uses literal fixation on a tail, not invariance of the code set's |
| wellordering under coordinatewise transport. -/ |
| theorem same_covariance (k : C.tailFixer hj) (d : CohenForcing.Condition I κ) |
| (a b : ChainCode hμ c C) : |
| Same hμ c C (d.permute k.val.val.val) a b ↔ Same hμ c C d a b := by |
| obtain ⟨N,hN⟩ := tail_fixed hμ c hj C k |
| have he (i : ℕ) (hi : N ≤ i) : |
| (localAtomic hμ (C.vertex i).diagram).EqF (d.permute k.val.val.val) (a i).name (b i).name ↔ |
| (localAtomic hμ (C.vertex i).diagram).EqF d (a i).name (b i).name := by |
| have hdg : (C.vertex i).diagram.permute k.val.val.val = (C.vertex i).diagram := |
| congrArg Vertex.diagram (hN i hi).1 |
| have hh := (system hμ).eq_symmetry k.val.val.val |
| ((d,(C.vertex i).diagram) : Poset M I κ) (a i).name (b i).name |
| simpa only [localAtomic,move_coe,permute,hdg,(hN i hi).2 (a i),(hN i hi).2 (b i)] using hh.symm |
| constructor |
| · rintro ⟨L,hL⟩ |
| exact ⟨max N L,fun i hi => (he i ((le_max_left _ _).trans hi)).mp |
| (hL i ((le_max_right _ _).trans hi))⟩ |
| · rintro ⟨L,hL⟩ |
| exact ⟨max N L,fun i hi => (he i ((le_max_left _ _).trans hi)).mpr |
| (hL i ((le_max_right _ _).trans hi))⟩ |
|
|
| /-- Condition-level covariance of least-code selection. All auxiliary |
| wellorders remain fixed. -/ |
| theorem selected_covariance (k : C.tailFixer hj) (d : CohenForcing.Condition I κ) |
| (a : ChainCode hμ c C) : |
| Selected hμ c hcard hsize hmerger hj E hE C a (d.permute k.val.val.val) ↔ |
| Selected hμ c hcard hsize hmerger hj E hE C a d := |
| ConditionCodeSelection.selected_covariance _ _ |
| (CohenForcing.Condition.permuteOrderIso k.val.val.val) |
| (works_covariance hμ c hcard hsize hmerger hj E hE C k) |
| (same_covariance hμ c hj C k) a d |
|
|
| end |
| end PartitionConsistency.ProductForcing.ChainCode |
|
|
|
|
| /-! ## PersistentCode -/ |
|
|
| /-! Stable availability gives actual working ground codes, persistently at |
| every refinement. This supplies the density input for least-code ranks, |
| without a countable family of external fully generic filters. -/ |
| namespace PartitionConsistency.ProductForcing |
| universe u |
| open SetForcingNames SetForcingNames.SymmetricSystem DiagramForcing ForcingQuotient |
| open DiagramOrder LocalDiagramSystem |
| noncomputable section |
| variable {M I κ : Type u} [LeftCancelMonoid M] [DiagramOrder.IsConical M] |
| variable {μ : Cardinal.{u}} (hμ : Cardinal.aleph0 ≤ μ) (c : κ → ZFSet.{u}) |
| variable [Infinite M] [Infinite I] |
| variable (hcard : Cardinal.mk M ≤ μ) (hsize : Cardinal.mk M < Cardinal.mk I) |
| variable (hmerger : HasFiniteMergers M) |
| variable {q : Diagram M I} (E : (system (M := M) (I := I) (κ := κ) hμ).Name) |
| variable (hE : ∀ π ∈ SupportFilter.Fix q.range, π • E = E) |
| local notation "D[" F "]" => eligibleSystem hμ c hcard hsize hmerger F q E hE |
|
|
| /-- Eligibility adds no restriction to the availability witnesses below a |
| supporting root: a representative of an eligible class is itself eligible, |
| by local decision. -/ |
| theorem eligibleSystem_availability_eq (F : GenericFilter (CohenForcing.Condition I κ)) |
| (r : Diagram M I) (a : M) (ha : r.sub a = q) (x : (D[F]).Obj r) : |
| (D[F]).availability r a x = |
| (allLocalSystem (c := c) hμ hcard hsize hmerger F).availability r a x.val := by |
| apply ConeIdeal.ext |
| ext n |
| change (n ≤ (show LeftDivOrder M from a) ∧ ∃ y : (D[F]).Obj (r.sub n), |
| (D[F]).restrict (r.self_le_sub n) y = x) ↔ |
| n ≤ (show LeftDivOrder M from a) ∧ ∃ y : LocalQuotient (c := c) hμ F (r.sub n), |
| LocalQuotient.restrict F (r.self_le_sub n) y = x.val |
| apply and_congr_right |
| intro hn |
| constructor |
| · rintro ⟨y,hy⟩ |
| exact ⟨y.val,congrArg Subtype.val hy⟩ |
| · rintro ⟨y,hy⟩ |
| have hrq : r.sub n ≤ q := ha ▸ r.sub_mono hn |
| have hey : Eligible hμ c F (r.sub n) E y := |
| (eligible_restrict_iff hμ c hsize hmerger F E (r.self_le_sub n) |
| (supported_mono hμ hrq E hE) y).mp (hy.symm ▸ x.property.2) |
| exact ⟨⟨y,hrq,hey⟩,Subtype.ext hy⟩ |
|
|
| /-- For any chosen name, the actual exact-fiber predicate in a principal |
| quotient agrees with eligibility and its computed forced availability. -/ |
| theorem exists_fiber_principal (d : CohenForcing.Condition I κ) (v : Vertex q) |
| (τ : LocalName hμ c v.diagram) |
| (hel : (system hμ).Forces ![τ.name,labelSet hμ c,E] |
| ((d,v.diagram) : Poset M I κ) (SetLanguage.isClass 0 1 2)) |
| (hU : forcedAvailability hμ c hcard hsize hmerger d v.diagram v.index τ = v.ideal) : |
| ∃ x : (D[principalFilter d]).vertexFiber v, |
| LocalQuotient.ofName (principalFilter d) τ = x.val.val := by |
| let x : (D[principalFilter d]).Obj v.diagram := |
| ⟨LocalQuotient.ofName (principalFilter d) τ,⟨v.index,v.root⟩,d,(mem_principalFilter d d).mpr le_rfl,hel⟩ |
| refine ⟨⟨x,?_⟩,rfl⟩ |
| rw [eligibleSystem_availability_eq hμ c hcard hsize hmerger E hE |
| (principalFilter d) v.diagram v.index v.root x] |
| exact hU |
|
|
| namespace ChainCode |
| variable (hj : HasConditionalJoins (LeftDivOrder M)) {v : Vertex q} (C : Vertex.Chain v) |
|
|
| /-- An explicit eligible name with permanently constant ideal at the root |
| has a code which works at EVERY refinement of the condition. At each chain |
| vertex the code's entry remains the exact same ground normalized name. -/ |
| theorem exists_working_code_of_stable (d : CohenForcing.Condition I κ) |
| (τ : LocalName hμ c v.diagram) |
| (hel : (system hμ).Forces ![τ.name,labelSet hμ c,E] |
| ((d,v.diagram) : Poset M I κ) (SetLanguage.isClass 0 1 2)) |
| (hstable : ∀ e, e ≤ d → |
| forcedAvailability hμ c hcard hsize hmerger e v.diagram v.index τ = v.ideal) : |
| ∃ a : ChainCode hμ c C, |
| Works hμ c hcard hsize hmerger hj E hE C d a ∧ |
| ∀ i, (system hμ).atomic.EqF ((d,v.diagram) : Poset M I κ) (a i).name τ.name := by |
| have hex (e : CohenForcing.Condition I κ) (hed : e ≤ d) : |
| ∃ x : (D[principalFilter e]).vertexFiber v, |
| LocalQuotient.ofName (principalFilter e) τ = x.val.val := by |
| exact exists_fiber_principal hμ c hcard hsize hmerger E hE e v τ |
| ((system hμ).atomic.forceFormula_mono |
| (WithTop.coe_le_coe.mpr (show (e,v.diagram) ≤ (d,v.diagram) from ⟨hed,le_rfl⟩)) hel) |
| (hstable e hed) |
| obtain ⟨x,hx⟩ := hex d le_rfl |
| have harr (i : ℕ) : Nonempty (v.Arrow (C.vertex i)) := by |
| simpa only [C.first] using C.increasing 0 i (Nat.zero_le i) |
| let f (i : ℕ) : v.Arrow (C.vertex i) := (harr i).some |
| let hdiag (i : ℕ) : v.diagram ≤ (C.vertex i).diagram := ⟨(f i).index,(f i).diagram⟩ |
| have hcodes (i : ℕ) : ∃ σ : LocalName hμ c (C.vertex i).diagram, |
| (system hμ).atomic.EqF ((d,v.diagram) : Poset M I κ) σ.name τ.name := by |
| obtain ⟨y,hy⟩ := (D[principalFilter d]).arrowMap_bijective hj (f i) |>.2 x |
| obtain ⟨σ,hσ⟩ := Quotient.mk'_surjective (s := localSetoid (c := c) hμ |
| (principalFilter d) (C.vertex i).diagram) y.val.val |
| refine ⟨σ,?_⟩ |
| apply ((localAtomic hμ v.diagram).eqG_principal d σ.name τ.name).mp |
| apply (LocalQuotient.ofName_eq (principalFilter d) (σ.restrict (hdiag i)) τ).mp |
| calc |
| LocalQuotient.ofName (principalFilter d) (σ.restrict (hdiag i)) = |
| LocalQuotient.restrict (principalFilter d) (hdiag i) y.val.val := congrArg (LocalQuotient.restrict (principalFilter d) (hdiag i)) hσ |
| _ = x.val.val := congrArg (fun z : (D[principalFilter d]).vertexFiber v => z.val.val) hy |
| _ = LocalQuotient.ofName (principalFilter d) τ := hx.symm |
| choose a ha using hcodes |
| refine ⟨a,?_,ha⟩ |
| intro e hed |
| obtain ⟨x',hx'⟩ := hex e hed |
| refine ⟨(D[principalFilter e]).toGlued hj v v (Vertex.Common.refl v) x',0,fun i _ => ?_⟩ |
| obtain ⟨y,hy⟩ := (D[principalFilter e]).arrowMap_bijective hj (f i) |>.2 x' |
| have heq : LocalQuotient.ofName (principalFilter e) (a i) = y.val.val := by |
| apply LocalQuotient.restrict_injective (principalFilter e) hsize hmerger (hdiag i) |
| have ht : LocalQuotient.ofName (principalFilter e) ((a i).restrict (hdiag i)) = |
| LocalQuotient.ofName (principalFilter e) τ := by |
| apply (LocalQuotient.ofName_eq (principalFilter e) _ _).mpr |
| apply ((localAtomic hμ v.diagram).eqG_principal e _ _).mpr |
| exact (system hμ).atomic.eq_mono |
| (WithTop.coe_le_coe.mpr (show (e,v.diagram) ≤ (d,v.diagram) from ⟨hed,le_rfl⟩)) (ha i) |
| exact ht.trans (hx'.trans |
| (congrArg (fun z : (D[principalFilter e]).vertexFiber v => z.val.val) hy).symm) |
| refine ⟨C.common i,y,a i,rfl,heq,?_⟩ |
| rw [← (D[principalFilter e]).toGlued_arrow hj v v (C.vertex i) |
| (Vertex.Common.refl v) (C.common i) (f i) y,hy] |
| |
| end ChainCode |
| end |
| end PartitionConsistency.ProductForcing |
| |
| |
| /-! ## OrdinalName -/ |
| |
| namespace PartitionConsistency.SetForcingNames.SymmetricSystem |
| universe u v w |
| noncomputable section |
| variable {P : Type w} [Preorder P] {Γ : Type v} [Group Γ] |
| variable (S : SymmetricSystem.{u} P Γ) |
| |
| /-- The semantic transitivity clause, with unrestricted HS names. -/ |
| def TransF (p : P) (σ : S.Name) : Prop := |
| ∀ (τ ν : S.Name) (q : P), q ≤ p → |
| S.atomic.MemF q τ σ → S.atomic.MemF q ν τ → S.atomic.MemF q ν σ |
| |
| /-- A transitive set of transitive sets; used to prove ordinal preservation, |
| not as a replacement for the ordinal formula in the statement of ACwo. -/ |
| def OrdF (p : P) (σ : S.Name) : Prop := |
| S.TransF p σ ∧ ∀ (τ : S.Name) (q : P), q ≤ p → S.atomic.MemF q τ σ → S.TransF q τ |
| |
| theorem transF_mono {p q : P} {σ : S.Name} (h : q ≤ p) (ht : S.TransF p σ) : |
| S.TransF q σ := fun τ ν r hr => ht τ ν r (hr.trans h) |
| |
| theorem transF_congr {p : P} {σ τ : S.Name} (he : S.atomic.EqF p σ τ) : |
| S.TransF p σ ↔ S.TransF p τ := by |
| have forward {σ τ : S.Name} (he : S.atomic.EqF p σ τ) (h : S.TransF p σ) : |
| S.TransF p τ := by |
| intro ν χ q hqp hν hχ |
| have hem := S.atomic.eq_mono hqp he |
| exact (S.atomic.mem_congr (S.atomic.eq_refl q χ) hem).mp |
| (h ν χ q hqp ((S.atomic.mem_congr (S.atomic.eq_refl q ν) hem).mpr hν) hχ) |
| exact ⟨forward he,forward (S.atomic.eq_symm he)⟩ |
| |
| theorem ordF_mono {p q : P} {σ : S.Name} (h : q ≤ p) (ho : S.OrdF p σ) : |
| S.OrdF q σ := ⟨S.transF_mono h ho.1,fun τ r hr => ho.2 τ r (hr.trans h)⟩ |
| |
| theorem ordF_congr {p : P} {σ τ : S.Name} (he : S.atomic.EqF p σ τ) : |
| S.OrdF p σ ↔ S.OrdF p τ := by |
| have forward {σ τ : S.Name} (he : S.atomic.EqF p σ τ) (h : S.OrdF p σ) : |
| S.OrdF p τ := by |
| refine ⟨(S.transF_congr he).mp h.1,?_⟩ |
| intro ν q hqp hν |
| exact h.2 ν q hqp ((S.atomic.mem_congr (S.atomic.eq_refl q ν) |
| (S.atomic.eq_mono hqp he)).mpr hν) |
| exact ⟨forward he,forward (S.atomic.eq_symm he)⟩ |
| |
| theorem ordF_mem {p : P} {σ τ : S.Name} (ho : S.OrdF p σ) |
| (hm : S.atomic.MemF p τ σ) : S.OrdF p τ := by |
| refine ⟨ho.2 τ p le_rfl hm,?_⟩ |
| intro ν q hqp hν |
| exact ho.2 ν q hqp (ho.1 τ ν q hqp (S.atomic.mem_mono hqp hm) hν) |
| |
| theorem forces_transitiveSet {n} (v : Fin n → S.Name) (p : P) (x : Fin n) : |
| S.Forces v p (SetLanguage.transitiveSet x) ↔ S.TransF p (v x) := by |
| simp only [Forces,SetLanguage.transitiveSet,S.atomic.forceFormula_rename S.atomic_regular, |
| S.atomic.forceFormula_all S.atomic_regular,S.atomic.forceFormula_imp S.atomic_regular, |
| ForcingQuotient.AtomicData.forceFormula_mem] |
| constructor |
| · intro h τ ν q hqp hτ hν |
| exact h τ ν q hqp hτ q le_rfl hν |
| · intro h τ ν q hqp hτ r hrq hν |
| exact h τ ν r (hrq.trans hqp) (S.atomic.mem_mono hrq hτ) hν |
| |
| /-- The literal ordinal sentence implies the semantic hereditary transitivity |
| used in the rank induction. Internal well-foundedness is not confused with |
| external well-foundedness of a model. -/ |
| theorem ordF_of_forces_ordinal {n} (v : Fin n → S.Name) (p : P) (x : Fin n) |
| (ho : S.Forces v p (SetLanguage.ordinal x)) : S.OrdF p (v x) := by |
| have ht : S.Forces v p (SetLanguage.transitiveSet x) := ho.1 |
| have hl : S.Forces v p (SetLanguage.membershipLinear x) := ho.2.1 |
| have ht' := (S.forces_transitiveSet v p x).mp ht |
| refine ⟨ht',?_⟩ |
| intro τ q hqp hτ ν χ r hrq hν hχ |
| simp only [Forces,SetLanguage.membershipLinear,S.atomic.forceFormula_rename S.atomic_regular, |
| S.atomic.forceFormula_all S.atomic_regular,S.atomic.forceFormula_imp S.atomic_regular, |
| ForcingQuotient.AtomicData.forceFormula_conj,ForcingQuotient.AtomicData.forceFormula_mem] at hl |
| have hτ' := S.atomic.mem_mono hrq hτ |
| have hν' := ht' τ ν r (hrq.trans hqp) hτ' hν |
| have hχ' := ht' ν χ r (hrq.trans hqp) hν' hχ |
| exact hl.2.1 χ ν τ r (hrq.trans hqp) hχ' r le_rfl hν' r le_rfl hτ' r le_rfl ⟨hχ,hν⟩ |
| |
| end |
| end PartitionConsistency.SetForcingNames.SymmetricSystem |
| |
| namespace PartitionConsistency.SetForcingNames.SymmetricSystem |
| universe u v w |
| noncomputable section |
| variable {P : Type w} [PartialOrder P] [OrderTop P] {Γ : Type v} [Group Γ] |
| variable (S : SymmetricSystem.{u} P Γ) |
| |
| /-- Ordinal preservation for unrestricted HS names. A condition forcing a |
| transitive set of transitive sets has an extension deciding it to be a ground |
| ordinal. The quantitative bound is proved by induction on literal name rank. -/ |
| theorem ordF_eq_check_le (σ : S.Name) (p : P) (ho : S.OrdF p σ) : |
| ∃ q, q ≤ p ∧ ∃ β : Ordinal.{u}, β ≤ σ.raw.rank ∧ |
| S.atomic.EqF q σ (Name.check β.toZFSet) := by |
| classical |
| induction σ using (InvImage.wf (fun σ : S.Name => σ.raw) child_wf).induction generalizing p with |
| | h σ ih => |
| have hbounded : ∀ (ν : S.Name) (q : P), q ≤ p → S.atomic.MemF q ν σ → |
| S.atomic.MemF q ν (Name.check σ.raw.rank.toZFSet) := by |
| intro ν q hqp hm |
| apply (S.mem_check _ ν q).mpr |
| intro r hrq |
| obtain ⟨s,hsr,τ,c,he,hsc,heq⟩ := (S.mem_iff.mp hm) r hrq |
| have hτσ : S.atomic.MemF s τ σ := S.mem_of_edge he hsc |
| obtain ⟨t,hts,β,hβ,hτ⟩ := ih τ ⟨S.code c,he⟩ s |
| (S.ordF_mem (S.ordF_mono (hsr.trans (hrq.trans hqp)) ho) hτσ) |
| exact ⟨t,hts.trans hsr,β.toZFSet, |
| Ordinal.toZFSet_mem_toZFSet_iff.mpr |
| (hβ.trans_lt (Child.rank_lt ⟨S.code c,he⟩)), |
| S.atomic.eq_trans (S.atomic.eq_mono hts heq) hτ⟩ |
| have hmiss : ¬ S.atomic.MemF p (Name.check σ.raw.rank.toZFSet) σ := by |
| intro hm |
| exact ZFSet.mem_irrefl _ ((S.mem_check_check _ _ p).mp |
| (hbounded _ p le_rfl hm)) |
| obtain ⟨α,hα,hmin⟩ := Ordinal.lt_wf.has_min |
| {α : Ordinal.{u} | ¬ S.atomic.MemF p (Name.check α.toZFSet) σ} ⟨σ.raw.rank,hmiss⟩ |
| have hαle : α ≤ σ.raw.rank := le_of_not_gt (hmin _ hmiss) |
| have hbelow : ∀ β < α, S.atomic.MemF p (Name.check β.toZFSet) σ := by |
| intro β hβ |
| by_contra hn |
| exact hmin β hn hβ |
| have hneg : ∃ q, q ≤ p ∧ ∀ r, r ≤ q → |
| ¬ S.atomic.MemF r (Name.check α.toZFSet) σ := by |
| by_contra hn |
| push Not at hn |
| exact hα (S.atomic_regular.2 p (Name.check α.toZFSet) σ hn) |
| obtain ⟨q,hqp,hneg⟩ := hneg |
| refine ⟨q,hqp,α,hαle,S.eq_of_same_members ?_⟩ |
| intro ν r hrq |
| constructor |
| · intro hm |
| apply (S.mem_check _ ν r).mpr |
| intro s hsr |
| obtain ⟨t,hts,y,hy,hey⟩ := (S.mem_check _ ν r).mp |
| (hbounded ν r (hrq.trans hqp) hm) s hsr |
| obtain ⟨β,hβ,rfl⟩ := Ordinal.mem_toZFSet_iff.mp hy |
| have hβσ : S.atomic.MemF t (Name.check β.toZFSet) σ := |
| (S.atomic.mem_congr hey (S.atomic.eq_refl t σ)).mp |
| (S.atomic.mem_mono (hts.trans hsr) hm) |
| have hβα : β < α := by |
| by_contra hn |
| rcases (not_lt.mp hn).eq_or_lt with h | h |
| · exact hneg t (hts.trans (hsr.trans hrq)) (h.symm ▸ hβσ) |
| · exact hneg t (hts.trans (hsr.trans hrq)) |
| (ho.1 (Name.check β.toZFSet) (Name.check α.toZFSet) t |
| (hts.trans (hsr.trans (hrq.trans hqp))) hβσ |
| (S.check_mem_of_mem (Ordinal.toZFSet_mem_toZFSet_iff.mpr h) t)) |
| exact ⟨t,hts,β.toZFSet,Ordinal.toZFSet_mem_toZFSet_iff.mpr hβα,hey⟩ |
| · intro hm |
| apply S.atomic_regular.2 |
| intro s hsr |
| obtain ⟨t,hts,y,hy,hey⟩ := (S.mem_check _ ν r).mp hm s hsr |
| obtain ⟨β,hβ,rfl⟩ := Ordinal.mem_toZFSet_iff.mp hy |
| exact ⟨t,hts,(S.atomic.mem_congr hey (S.atomic.eq_refl t σ)).mpr |
| (S.atomic.mem_mono (hts.trans (hsr.trans (hrq.trans hqp))) (hbelow β hβ))⟩ |
| |
| /-- Dense decision of any name satisfying the actual ordinal formula. This |
| applies at arbitrary rank, not merely to normalized subset names. -/ |
| theorem forces_ordinal_decide {n} (v : Fin n → S.Name) (p : P) (x : Fin n) |
| (ho : S.Forces v p (SetLanguage.ordinal x)) : |
| ∀ q, q ≤ p → ∃ r, r ≤ q ∧ ∃ β : Ordinal.{u}, |
| S.atomic.EqF r (v x) (Name.check β.toZFSet) := by |
| intro q hqp |
| obtain ⟨r,hrq,β,_,he⟩ := S.ordF_eq_check_le (v x) q |
| (S.ordF_mono hqp (S.ordF_of_forces_ordinal v p x ho)) |
| exact ⟨r,hrq,β,he⟩ |
| |
| end |
| end PartitionConsistency.SetForcingNames.SymmetricSystem |
| |
| end OAI |
| |
