| import Mathlib | |
| import OAI.SetTheory.PartitionConsistency.Models.OrdinalChoice | |
| import OAI.SetTheory.PartitionConsistency.Models.ConcreteSystem | |
| namespace OAI | |
| /-! ## SaturatedFibers -/ | |
| namespace PartitionConsistency.MonoidConstruction.Saturation | |
| universe u | |
| open DiagramOrder DiagramForcing LocalDiagramSystem | |
| noncomputable section | |
| variable (M : Object.{u}) (K : Type u) [Nonempty K] [Infinite K] | |
| /-- Reindex the actual saturated probes into independently hit rows. This | |
| uses infinitude of the prescribed multiplicity, not a new saturation step. -/ | |
| theorem square_ideal_probes (a b : target M K) (hb : b ≠ 1) | |
| (U : ConeIdeal (α := LeftDivOrder (target M K)) a) : | |
| ∃ m : K × K → target M K, Function.Injective m ∧ | |
| (∀ i, m i * b = a * (target M K).e ∧ ¬ m i ∣ a ∧ | |
| (∀ x : target M K, x ∣ a ∧ x ∣ m i ↔ x ∈ U.carrier) ∧ | |
| ∀ x : target M K, x ∣ a → x ∉ U.carrier → | |
| ∀ z : target M K, x ∣ z ∧ m i ∣ z ↔ a * (target M K).e ∣ z) ∧ | |
| ∀ i j, i ≠ j → ∀ z : target M K, | |
| m i ∣ z ∧ m j ∣ z ↔ a * (target M K).e ∣ z := by | |
| have hs : Cardinal.mk (K × K) = Cardinal.mk K := by | |
| rw [Cardinal.mk_prod,Cardinal.lift_id,Cardinal.mul_eq_self (Cardinal.aleph0_le_mk K)] | |
| obtain ⟨h⟩ := Cardinal.eq.mp hs | |
| obtain ⟨m,hinj,hm,hi⟩ := ideal_probes M K a b hb U | |
| exact ⟨m ∘ h,hinj.comp h.injective,fun i => hm (h i), | |
| fun i j hij => hi (h i) (h j) (fun he => hij (h.injective he))⟩ | |
| end | |
| end PartitionConsistency.MonoidConstruction.Saturation | |
| namespace PartitionConsistency.LocalDiagramSystem.System | |
| universe u v w | |
| open DiagramOrder DiagramForcing | |
| variable {M I : Type u} [LeftCancelMonoid M] [IsConical M] | |
| variable (D : System.{u,v} M I) | |
| instance fiberSmall (r : Diagram M I) (a : M) (U : ConeIdeal (show LeftDivOrder M from a)) | |
| [Small.{w} (D.Obj r)] : Small.{w} (D.Fiber r a U) := | |
| inferInstanceAs (Small.{w} {x : D.Obj r // D.availability r a x = U}) | |
| end PartitionConsistency.LocalDiagramSystem.System | |
| namespace PartitionConsistency.ProductForcing | |
| universe u | |
| open SetForcingNames SetForcingNames.SymmetricSystem DiagramForcing ForcingQuotient | |
| open DiagramOrder LocalDiagramSystem MonoidConstruction | |
| noncomputable section | |
| variable {M I κ : Type u} [LeftCancelMonoid M] [IsConical M] | |
| variable {μ : Cardinal.{u}} (hμ : Cardinal.aleph0 ≤ μ) (c : κ → ZFSet.{u}) | |
| instance eligibleSystem_obj_small [Infinite M] [Infinite I] | |
| (hcard : Cardinal.mk M ≤ μ) (hsize : Cardinal.mk M < Cardinal.mk I) | |
| (hmerger : HasFiniteMergers M) (F : GenericFilter (CohenForcing.Condition I κ)) | |
| (q r : Diagram M I) (E : (system (M := M) (I := I) (κ := κ) hμ).Name) | |
| (hE : ∀ π ∈ SupportFilter.Fix q.range, π • E = E) : | |
| Small.{u} ((eligibleSystem hμ c hcard hsize hmerger F q E hE).Obj r) := | |
| inferInstanceAs (Small.{u} {x : LocalQuotient (c := c) hμ F r // | |
| r ≤ q ∧ Eligible hμ c F r E x}) | |
| /-- The entire eligible quotient bounds every exact fiber. The input is | |
| only meeting the explicit, proved dense record sets, not an assumed list | |
| of representatives or an assumed fiber cardinal. -/ | |
| theorem classFiber_cardinal_le [Infinite M] [Infinite I] | |
| (hpower : μ ^ Cardinal.aleph0 = μ) (hcard : Cardinal.mk M ≤ μ) | |
| (hκ : Cardinal.mk κ ≤ μ) (hsize : Cardinal.mk M < Cardinal.mk I) | |
| (hmerger : HasFiniteMergers M) (F : GenericFilter (CohenForcing.Condition I κ)) | |
| {q : Diagram M I} (w : Vertex q) | |
| (E : (system (M := M) (I := I) (κ := κ) hμ).Name) | |
| (hE : ∀ π ∈ SupportFilter.Fix q.range, π • E = E) | |
| (hmeets : ∀ (τ : LocalName hμ c w.diagram) (d₀ : CohenForcing.Condition I κ), d₀ ∈ F → | |
| (system hμ).Forces ![τ.name,labelSet hμ c,E] ((d₀,w.diagram) : Poset M I κ) | |
| (SetLanguage.isClass 0 1 2) → | |
| ∃ d, d ∈ F ∧ d ∈ classRepresentationDenseSet hμ c w.diagram E τ d₀) : | |
| Cardinal.mk (Shrink.{u} ((eligibleSystem hμ c hcard hsize hmerger F q E hE).vertexFiber w)) ≤ μ := by | |
| let D := eligibleSystem hμ c hcard hsize hmerger F q E hE | |
| let f : D.vertexFiber w → EligibleClasses hμ c F w.diagram E := | |
| fun x => ⟨x.val.val,x.val.property.2⟩ | |
| have hinj : Function.Injective f := by | |
| intro x y h | |
| apply Subtype.ext | |
| apply Subtype.ext | |
| exact congrArg (fun z : EligibleClasses hμ c F w.diagram E => z.val) h | |
| have hbound : Cardinal.mk (Shrink.{u} (D.vertexFiber w)) ≤ | |
| Cardinal.mk (Shrink.{u} (EligibleClasses hμ c F w.diagram E)) := | |
| Cardinal.mk_le_of_injective ((equivShrink _).injective.comp | |
| (hinj.comp (equivShrink _).symm.injective)) | |
| exact hbound.trans (eligibleClasses_cardinal_le hμ c hpower hcard hκ hsize hmerger F | |
| w.diagram E (supported_mono hμ ⟨w.index,w.root⟩ E hE) hmeets) | |
| end | |
| end PartitionConsistency.ProductForcing | |
| namespace PartitionConsistency.ConcreteSystem | |
| open MonoidConstruction CardinalParameters DiagramForcing SetForcingNames | |
| open ProductForcing ForcingQuotient LocalDiagramSystem | |
| noncomputable section | |
| /-- For the concrete executed saturation, an outside witness supplies dense | |
| requirements for the exact lower class-fiber bound. All final ideals at all | |
| vertices are covered; no algebraic profile or exact-intersection premise is | |
| left for the extension argument to supply. -/ | |
| theorem classFiber_dense_lower {q : Diagram T I} (w : Vertex q) (b : T) (hb : b ≠ 1) | |
| (E : S.Name) (hE : ∀ π ∈ SupportFilter.Fix (q.sub T.e).range, π • E = E) | |
| (t : Diagram T I) (ht : t.sub b = q.sub T.e) | |
| (d : CohenForcing.Condition I κ) (hd : d.support ⊆ t.range) | |
| (j : I) (hj : j ∈ t.range) | |
| (hout : ∀ z : P, z ≤ (d,t) → | |
| ¬ S.atomic.MemF z (labelClass aleph0_le_μ (posetCode κ) E j) | |
| (localList aleph0_le_μ (posetCode κ) cardinal_T.le (q.sub T.e))) : | |
| ∃ D : K → Set (CohenForcing.Condition I κ), (∀ i, Dense (D i)) ∧ | |
| ∀ F : GenericFilter (CohenForcing.Condition I κ), d ∈ F → | |
| (∀ i, ∃ a, a ∈ F ∧ a ∈ D i) → | |
| Nonempty (K ↪ (eligibleSystem aleph0_le_μ (posetCode κ) cardinal_T.le size_lt finiteMergers F q E | |
| (supported_mono aleph0_le_μ (q.self_le_sub T.e) E hE)).vertexFiber w) := by | |
| obtain ⟨m,_,hm,hi⟩ := Saturation.square_ideal_probes Base.object K w.index b hb w.ideal | |
| exact ProductForcing.classFiber_dense_lower aleph0_le_μ (posetCode κ) cardinal_T.le size_lt | |
| finiteMergers w T.e b m (fun i => (hm i).1) (fun i => (hm i).2.2.1) | |
| (fun i => (hm i).2.2.2) hi E hE t ht d hd j hj hout | |
| private theorem concreteEligibleFiberSmall | |
| (F : GenericFilter (CohenForcing.Condition I κ)) {q : Diagram T I} (w : Vertex q) | |
| (E : S.Name) (hE : ∀ π ∈ SupportFilter.Fix q.range, π • E = E) : | |
| Small.{0} ((eligibleSystem aleph0_le_μ (posetCode κ) cardinal_T.le size_lt finiteMergers F q E | |
| hE).vertexFiber w) := by | |
| let D := eligibleSystem aleph0_le_μ (posetCode κ) cardinal_T.le size_lt finiteMergers F q E hE | |
| let _ : Small.{0} (D.Obj w.diagram) := | |
| eligibleSystem_obj_small aleph0_le_μ (posetCode κ) cardinal_T.le size_lt finiteMergers F q | |
| w.diagram E hE | |
| exact LocalDiagramSystem.System.fiberSmall D w.diagram w.index w.ideal | |
| /-- The exact-fiber theorem for the concrete system, with explicitly | |
| identified ordinary Cohen requirements. No genericity or existence of an | |
| intermediate ordinary extension is claimed by this statement. -/ | |
| theorem classFiber_dense_exact {q : Diagram T I} (w : Vertex q) (b : T) (hb : b ≠ 1) | |
| (E : S.Name) (hE : ∀ π ∈ SupportFilter.Fix (q.sub T.e).range, π • E = E) | |
| (t : Diagram T I) (ht : t.sub b = q.sub T.e) | |
| (d : CohenForcing.Condition I κ) (hd : d.support ⊆ t.range) | |
| (j : I) (hj : j ∈ t.range) | |
| (hout : ∀ z : P, z ≤ (d,t) → | |
| ¬ S.atomic.MemF z (labelClass aleph0_le_μ (posetCode κ) E j) | |
| (localList aleph0_le_μ (posetCode κ) cardinal_T.le (q.sub T.e))) : | |
| ∃ D : K → Set (CohenForcing.Condition I κ), (∀ i, Dense (D i)) ∧ | |
| ∀ F : GenericFilter (CohenForcing.Condition I κ), d ∈ F → | |
| (∀ i, ∃ a, a ∈ F ∧ a ∈ D i) → | |
| (∀ (τ : LocalName aleph0_le_μ (posetCode κ) w.diagram) (d₀ : CohenForcing.Condition I κ), d₀ ∈ F → | |
| S.Forces ![τ.name,labelSet aleph0_le_μ (posetCode κ),E] ((d₀,w.diagram) : P) | |
| (SetLanguage.isClass 0 1 2) → | |
| ∃ a, a ∈ F ∧ a ∈ classRepresentationDenseSet aleph0_le_μ (posetCode κ) w.diagram E τ d₀) → | |
| Cardinal.mk (@Shrink.{0} ((eligibleSystem aleph0_le_μ (posetCode κ) cardinal_T.le size_lt finiteMergers F q E | |
| (supported_mono aleph0_le_μ (q.self_le_sub T.e) E hE)).vertexFiber w) | |
| (concreteEligibleFiberSmall F w E | |
| (supported_mono aleph0_le_μ (q.self_le_sub T.e) E hE))) = μ := by | |
| obtain ⟨D,hD,hits⟩ := classFiber_dense_lower w b hb E hE t ht d hd j hj hout | |
| refine ⟨D,hD,fun F hF hmeets hrecords => ?_⟩ | |
| let _ := concreteEligibleFiberSmall F w E | |
| (supported_mono aleph0_le_μ (q.self_le_sub T.e) E hE) | |
| apply le_antisymm | |
| · exact ProductForcing.classFiber_cardinal_le aleph0_le_μ (posetCode κ) μ_countable_power | |
| cardinal_T.le (cardinal_κ ▸ aleph_one_le_μ) size_lt finiteMergers F w E | |
| (supported_mono aleph0_le_μ (q.self_le_sub T.e) E hE) hrecords | |
| · obtain ⟨f⟩ := hits F hF hmeets | |
| exact cardinal_K.symm.trans_le | |
| (Cardinal.mk_le_of_injective ((equivShrink _).injective.comp f.injective)) | |
| end | |
| end PartitionConsistency.ConcreteSystem | |
| /-! ## Preliminary -/ | |
| /-! A preliminary assignment on the genuine symbolic component with tail | |
| covariance. Exact cardinality at an intermediate filter is an explicit | |
| input here; the issued dense requirements needed to obtain it are in | |
| `SaturatedFibersWork`. No existence of a filter generic over every ambient | |
| set is assumed or asserted. -/ | |
| namespace PartitionConsistency.ProductForcing | |
| 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 | |
| instance eligibleSystem_glued_small (F : GenericFilter (CohenForcing.Condition I κ)) : | |
| Small.{u} ((D[F]).Glued hj v) := | |
| small_of_surjective ((D[F]).toGlued_surjective hj v v (Vertex.Common.refl v)) | |
| namespace ChainCode | |
| /-- The order bound is the order type of the one fixed ground-code | |
| wellordering, computed on a small copy of the code set. -/ | |
| def codeOrderBound : Ordinal.{u} := | |
| Ordinal.type (OrderAssignment.smallRel.{u} (WellOrderingRel (α := ChainCode hμ c C))) | |
| /-- The least-code ordering is induced on a subset of the code set, so its | |
| order type cannot exceed the chosen ground bound. -/ | |
| theorem orderType_le (F : GenericFilter (CohenForcing.Condition I κ)) : | |
| Ordinal.type (OrderAssignment.smallRel.{u} (LT hμ c hcard hsize hmerger hj E hE C F)) ≤ | |
| codeOrderBound hμ c C := by | |
| let e : LT hμ c hcard hsize hmerger hj E hE C F ↪r | |
| WellOrderingRel (α := ChainCode hμ c C) := { | |
| toFun := leastCode hμ c hcard hsize hmerger hj E hE C F | |
| inj' := leastCode_injective hμ c hcard hsize hmerger hj E hE C F | |
| map_rel_iff' := Iff.rfl } | |
| exact OrderAssignment.type_smallRel_le e | |
| /-- This is a bounded table chosen just once for the component and its | |
| chain; in particular it has no filter argument. -/ | |
| def componentTable : OrderAssignment.Table (labelFiberSet v) (codeOrderBound hμ c C) := | |
| OrderAssignment.chooseTable _ _ | |
| /-- The preliminary bijection uses the actual least-code order and the | |
| one fixed table. The displayed cardinal equality is precisely the point | |
| at which the exact-fiber theorem is used. -/ | |
| def preliminary (F : GenericFilter (CohenForcing.Condition I κ)) | |
| (hc : Cardinal.mk (Shrink.{u} ((D[F]).Glued hj v)) = Cardinal.mk (labelFiberSet v)) : | |
| labelFiberSet v ≃ (D[F]).Glued hj v := | |
| OrderAssignment.smallAssignment (componentTable hμ c C) | |
| (LT hμ c hcard hsize hmerger hj E hE C F) | |
| (orderType_le hμ c hcard hsize hmerger hj E hE C F) hc | |
| /-- Literal covariance of the preliminary assignment between F and kF. | |
| The label is unchanged, as every member of the tail fixer fixes all the | |
| labels in this fiber. The two cardinal-equality proofs are immaterial. -/ | |
| theorem preliminary_covariance (F : GenericFilter (CohenForcing.Condition I κ)) | |
| (k : C.tailFixer hj) | |
| (hc : Cardinal.mk (Shrink.{u} ((D[F]).Glued hj v)) = Cardinal.mk (labelFiberSet v)) | |
| (hc' : Cardinal.mk (Shrink.{u} | |
| ((D[F.move (CohenForcing.Condition.permuteOrderIso k.val.val.val)]).Glued hj v)) = | |
| Cardinal.mk (labelFiberSet v)) (j : labelFiberSet v) : | |
| preliminary hμ c hcard hsize hmerger hj E hE C | |
| (F.move (CohenForcing.Condition.permuteOrderIso k.val.val.val)) hc' j = | |
| transport hμ c hcard hsize hmerger hj E hE F k.val | |
| (preliminary hμ c hcard hsize hmerger hj E hE C F hc j) := | |
| (OrderAssignment.smallAssignment_natural (componentTable hμ c C) | |
| _ hc _ hc' (leastCodeOrderIso hμ c hcard hsize hmerger hj E hE C F k) j).symm | |
| end ChainCode | |
| end | |
| end PartitionConsistency.ProductForcing | |
| /-! ## ComponentAction -/ | |
| /-! The actual symbolic fibers carry transport between moved Cohen filters. | |
| On the total space this is a genuine group action. The individual interpreted | |
| universes are not being treated as if they carried this action internally. -/ | |
| namespace PartitionConsistency.ForcingQuotient | |
| universe u | |
| open CohenForcing | |
| variable {I κ : Type u} | |
| instance : MulAction (Equiv.Perm I) (GenericFilter (Condition I κ)) where | |
| smul π F := F.move (Condition.permuteOrderIso π) | |
| one_smul F := by | |
| ext p | |
| change (OrderDual.ofDual p).permute ((1 : Equiv.Perm I)⁻¹) ∈ F ↔ p ∈ F | |
| rw [inv_one,Condition.permute_one] | |
| rfl | |
| mul_smul π σ F := by | |
| ext p | |
| change (OrderDual.ofDual p).permute ((π*σ)⁻¹) ∈ F ↔ | |
| ((OrderDual.ofDual p).permute π⁻¹).permute σ⁻¹ ∈ F | |
| rw [mul_inv_rev,Condition.permute_mul] | |
| @[simp] theorem smul_filter (π : Equiv.Perm I) (F : GenericFilter (Condition I κ)) : | |
| π • F = F.move (Condition.permuteOrderIso π) := rfl | |
| end PartitionConsistency.ForcingQuotient | |
| namespace PartitionConsistency.LocalDiagramSystem | |
| universe u | |
| open DiagramForcing DiagramOrder | |
| noncomputable section | |
| variable {M I : Type u} [LeftCancelMonoid M] [IsConical M] | |
| /-- Coordinate transport for literal label fibers. -/ | |
| def labelTransport (π : Equiv.Perm I) : ReindexIso (labelSystem (M := M)) labelSystem π where | |
| app r := π.subtypeEquiv (fun j => by | |
| constructor | |
| · rintro ⟨m,hm⟩ | |
| exact ⟨m,congrArg π hm⟩ | |
| · rintro ⟨m,hm⟩ | |
| exact ⟨m,π.injective hm⟩) | |
| natural _ _ := rfl | |
| @[simp] theorem labelTransport_fiber_val {q : Diagram M I} (g : Vertex.RootGroup q) | |
| (v : Vertex q) (x : (labelSystem (M := M)).vertexFiber v) : | |
| ((labelTransport g.val).fiberEquiv g v x).val.val = g.val x.val.val := rfl | |
| theorem labelFiberSet_permute {q : Diagram M I} (g : Vertex.RootGroup q) | |
| (v : Vertex q) (j : I) : j ∈ labelFiberSet v ↔ g.val j ∈ labelFiberSet (g • v) := by | |
| constructor | |
| · rintro ⟨x,rfl⟩ | |
| exact ⟨(labelTransport g.val).fiberEquiv g v x,rfl⟩ | |
| · rintro ⟨y,hy⟩ | |
| obtain ⟨x,rfl⟩ := ((labelTransport g.val).fiberEquiv g v).surjective y | |
| exact ⟨x,g.val.injective hy⟩ | |
| namespace Vertex | |
| variable {q : Diagram M I} (hj : HasConditionalJoins (LeftDivOrder M)) (v : Vertex q) | |
| /-- The stabilizer permutes the actual common subset of label indices. -/ | |
| instance labelFiberAction : MulAction (componentStabilizer hj v) (labelFiberSet v) where | |
| smul g j := ⟨g.val.val j.val,by | |
| exact (labelFiberSet_common hj g.property).symm.subset | |
| ((labelFiberSet_permute g.val v j.val).mp j.property)⟩ | |
| one_smul _ := Subtype.ext rfl | |
| mul_smul _ _ _ := Subtype.ext rfl | |
| @[simp] theorem smul_labelFiber_val (g : componentStabilizer hj v) (j : labelFiberSet v) : | |
| (g • j).val = g.val.val j.val := rfl | |
| theorem Chain.tailFixer_fixes_label (C : Chain v) (k : C.tailFixer hj) (j : labelFiberSet v) : | |
| k.val • j = j := | |
| Subtype.ext (C.tailFixer_fixes_labels hj k j.val j.property) | |
| end Vertex | |
| end | |
| end PartitionConsistency.LocalDiagramSystem | |
| 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) | |
| local notation "D[" F "]" => eligibleSystem hμ c hcard hsize hmerger F q E hE | |
| /-- The total symbolic component over all ordinary Cohen filters. There is | |
| no assertion here that any particular such filter is a ground generic. -/ | |
| def Total := Σ F : GenericFilter (CohenForcing.Condition I κ), (D[F]).Glued hj v | |
| /-- Representation in the total space, retaining its actual filter. -/ | |
| def TotalAt (w : Vertex q) (τ : (system (M := M) (I := I) (κ := κ) hμ).Name) | |
| (x : Total hμ c hcard hsize hmerger hj E hE v) : Prop := | |
| At hμ c hcard hsize hmerger hj E hE x.1 w τ x.2 | |
| variable {hμ c hcard hsize hmerger hj E hE v} | |
| theorem total_eq_of_representation {w : Vertex q} | |
| {τ : (system (M := M) (I := I) (κ := κ) hμ).Name} | |
| {x y : Total hμ c hcard hsize hmerger hj E hE v} | |
| (hF : x.1 = y.1) (hx : TotalAt hμ c hcard hsize hmerger hj E hE v w τ x) | |
| (hy : TotalAt hμ c hcard hsize hmerger hj E hE v w τ y) : x = y := by | |
| obtain ⟨F,x⟩ := x | |
| obtain ⟨F',y⟩ := y | |
| dsimp only at hF | |
| subst F' | |
| exact congrArg (Sigma.mk F) (at_unique hx hy) | |
| theorem total_has_representation (x : Total hμ c hcard hsize hmerger hj E hE v) : | |
| ∃ τ, TotalAt hμ c hcard hsize hmerger hj E hE v v τ x := by | |
| obtain ⟨y,hy⟩ := (D[x.1]).toGlued_surjective hj v v (Vertex.Common.refl v) x.2 | |
| obtain ⟨σ,hσ⟩ := Quotient.mk'_surjective | |
| (s := localSetoid (c := c) hμ x.1 v.diagram) y.val.val | |
| exact ⟨σ.name,Vertex.Common.refl v,y,σ,rfl,hσ,hy⟩ | |
| variable (hμ c hcard hsize hmerger hj E hE v) | |
| /-- A lift of transport to the total space, before verifying the action laws. -/ | |
| def totalMove (g : Vertex.componentStabilizer hj v) | |
| (x : Total hμ c hcard hsize hmerger hj E hE v) : | |
| Total hμ c hcard hsize hmerger hj E hE v := | |
| ⟨g • x.1,transport hμ c hcard hsize hmerger hj E hE x.1 g x.2⟩ | |
| theorem totalAt_move (g : Vertex.componentStabilizer hj v) (w : Vertex q) | |
| (τ : (system (M := M) (I := I) (κ := κ) hμ).Name) | |
| (x : Total hμ c hcard hsize hmerger hj E hE v) : | |
| TotalAt hμ c hcard hsize hmerger hj E hE v (g.val • w) (g.val.val • τ) | |
| (totalMove hμ c hcard hsize hmerger hj E hE v g x) ↔ | |
| TotalAt hμ c hcard hsize hmerger hj E hE v w τ x := | |
| at_transport_iff hμ c hcard hsize hmerger hj E hE x.1 g w τ x.2 | |
| theorem totalMove_one (x : Total hμ c hcard hsize hmerger hj E hE v) : | |
| totalMove hμ c hcard hsize hmerger hj E hE v 1 x = x := by | |
| obtain ⟨τ,hτ⟩ := total_has_representation x | |
| apply total_eq_of_representation (one_smul _ x.1) (w := v) (τ := τ) _ hτ | |
| simpa only [Subgroup.coe_one,one_smul] using | |
| (totalAt_move hμ c hcard hsize hmerger hj E hE v 1 v τ x).mpr hτ | |
| theorem totalMove_mul (g k : Vertex.componentStabilizer hj v) | |
| (x : Total hμ c hcard hsize hmerger hj E hE v) : | |
| totalMove hμ c hcard hsize hmerger hj E hE v (g*k) x = | |
| totalMove hμ c hcard hsize hmerger hj E hE v g | |
| (totalMove hμ c hcard hsize hmerger hj E hE v k x) := by | |
| obtain ⟨τ,hτ⟩ := total_has_representation x | |
| have hx := (totalAt_move hμ c hcard hsize hmerger hj E hE v (g*k) v τ x).mpr hτ | |
| have hy := (totalAt_move hμ c hcard hsize hmerger hj E hE v g (k.val • v) | |
| (k.val.val • τ) (totalMove hμ c hcard hsize hmerger hj E hE v k x)).mpr | |
| ((totalAt_move hμ c hcard hsize hmerger hj E hE v k v τ x).mpr hτ) | |
| apply total_eq_of_representation (mul_smul g k x.1) hx | |
| simpa only [Subgroup.coe_mul,mul_smul] using hy | |
| /-- A genuine action only on the *family* of all moved computations. -/ | |
| instance totalAction : MulAction (Vertex.componentStabilizer hj v) | |
| (Total hμ c hcard hsize hmerger hj E hE v) where | |
| smul := totalMove hμ c hcard hsize hmerger hj E hE v | |
| one_smul := totalMove_one hμ c hcard hsize hmerger hj E hE v | |
| mul_smul := totalMove_mul hμ c hcard hsize hmerger hj E hE v | |
| @[simp] theorem totalAction_fst (g : Vertex.componentStabilizer hj v) | |
| (x : Total hμ c hcard hsize hmerger hj E hE v) : (g • x).1 = g • x.1 := rfl | |
| end | |
| end PartitionConsistency.ProductForcing.ChainCode | |
| /-! ## CodeCovariance -/ | |
| /-! Covariance on actual forcing conditions. The code order is held fixed, | |
| whereas both the Cohen condition and the local supporting vertex move. -/ | |
| namespace PartitionConsistency.ProductForcing.ChainCode | |
| 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) (hj : HasConditionalJoins (LeftDivOrder M)) | |
| variable {q : Diagram M I} | |
| variable (E : (system (M := M) (I := I) (κ := κ) hμ).Name) | |
| variable (hE : ∀ π ∈ SupportFilter.Fix q.range, π • E = E) | |
| variable {v : Vertex q} (C : Vertex.Chain v) | |
| omit [Infinite M] [Infinite I] in | |
| /-- Every one of the shrinking chain diagrams supports the ordinal names, | |
| not just the first diagram. -/ | |
| theorem chainFix_le_tailGroup (i : ℕ) : | |
| SupportFilter.Fix (C.vertex i).diagram.range ≤ tailGroup hj C := by | |
| intro π hπ | |
| have hr : (C.vertex i).diagram ≤ q := ⟨(C.vertex i).index,(C.vertex i).root⟩ | |
| have hπq : π ∈ Vertex.RootGroup q := by | |
| apply (SupportFilter.mem_Fix _ _).mpr | |
| intro j hj | |
| exact (SupportFilter.mem_Fix _ _).mp hπ j (Diagram.range_antitone hr hj) | |
| let g : Vertex.RootGroup q := ⟨π,hπq⟩ | |
| have hg (j : I) (hj : j ∈ (C.vertex i).diagram.range) : g.val j = j := | |
| (SupportFilter.mem_Fix _ _).mp hπ j hj | |
| let k : Vertex.componentStabilizer hj v := ⟨g,C.fixes_mem_stabilizer hj g i hg⟩ | |
| exact (tailGroup_mem hj C π).mpr ⟨⟨k,i,hg⟩,rfl⟩ | |
| omit [Infinite M] [Infinite I] in | |
| /-- The same code is linked to the transported name at the moved vertex. | |
| It is not necessary for the permutation to fix the original root. -/ | |
| theorem links_permute (k : C.tailFixer hj) (d : CohenForcing.Condition I κ) | |
| (w : Vertex q) (τ : (system (M := M) (I := I) (κ := κ) hμ).Name) | |
| (a : ChainCode hμ c C) (h : Links hμ c C d w τ a) : | |
| Links hμ c C (d.permute k.val.val.val) (k.val.val • w) (k.val.val.val • τ) a := by | |
| obtain ⟨N,hN⟩ := h | |
| obtain ⟨L,hL⟩ := tail_fixed hμ c hj C k | |
| refine ⟨max N L,fun i hi => ?_⟩ | |
| obtain ⟨⟨f⟩,he⟩ := hN i ((le_max_left _ _).trans hi) | |
| obtain ⟨hv,hn⟩ := hL i ((le_max_right _ _).trans hi) | |
| refine ⟨?_,?_⟩ | |
| · simpa only [hv] using (show Nonempty ((k.val.val • w).Arrow (k.val.val • C.vertex i)) from | |
| ⟨f.move k.val.val⟩) | |
| · simpa only [hn (a i),move_coe,permute,Vertex.smul_diagram] using | |
| ((system hμ).eq_symmetry k.val.val.val ((d,w.diagram) : Poset M I κ) (a i).name τ).mp he | |
| include c hsize hmerger in | |
| /-- Local decision reflects a tail-invariant equality back from the moved | |
| root. This is the needed covariance of ordinal VALUES, not just names. -/ | |
| theorem tail_eq_permute (k : C.tailFixer hj) (d : CohenForcing.Condition I κ) | |
| (τ σ : (system (M := M) (I := I) (κ := κ) hμ).Name) | |
| (hτ : ∀ π ∈ tailGroup hj C, π • τ = τ) | |
| (hσ : ∀ π ∈ tailGroup hj C, π • σ = σ) | |
| (he : (system hμ).atomic.EqF ((d,v.diagram) : Poset M I κ) τ σ) : | |
| (system hμ).atomic.EqF ((d.permute k.val.val.val,v.diagram) : Poset M I κ) τ σ := by | |
| obtain ⟨N,hN⟩ := tail_fixed hμ c hj C k | |
| have hk : k.val.val.val ∈ tailGroup hj C := (tailGroup_mem hj C _).mpr ⟨k,rfl⟩ | |
| have hm : (system hμ).atomic.EqF | |
| ((d.permute k.val.val.val,(k.val.val • v).diagram) : Poset M I κ) τ σ := by | |
| simpa only [hτ _ hk,hσ _ hk,move_coe,permute,Vertex.smul_diagram] using | |
| ((system hμ).eq_symmetry k.val.val.val ((d,v.diagram) : Poset M I κ) τ σ).mp he | |
| have hf : Nonempty (v.Arrow (C.vertex N)) := by | |
| simpa only [C.first] using C.increasing 0 N (Nat.zero_le _) | |
| have hfm : Nonempty ((k.val.val • v).Arrow (C.vertex N)) := by | |
| simpa only [(hN N le_rfl).1] using | |
| (show Nonempty ((k.val.val • v).Arrow (k.val.val • C.vertex N)) from ⟨hf.some.move k.val.val⟩) | |
| have ht := eq_at_root hμ hsize hmerger τ σ (C.vertex N).diagram | |
| (k.val.val • v).diagram ⟨hfm.some.index,hfm.some.diagram⟩ | |
| (fun π hπ => hτ π (chainFix_le_tailGroup hj C N hπ)) | |
| (fun π hπ => hσ π (chainFix_le_tailGroup hj C N hπ)) (d.permute k.val.val.val) hm | |
| exact (system hμ).atomic.eq_mono | |
| (WithTop.coe_le_coe.mpr (show (d.permute k.val.val.val,v.diagram) ≤ | |
| (d.permute k.val.val.val,(C.vertex N).diagram) from | |
| ⟨le_rfl,⟨hf.some.index,hf.some.diagram⟩⟩)) ht | |
| /-- Both ordinal name constructions are literally fixed by the tail group. -/ | |
| theorem ordinalRank_fixed (a : Index hμ c C) (π : Equiv.Perm I) (hπ : π ∈ tailGroup hj C) : | |
| π • ordinalRank hμ c hcard hsize hmerger hj E hE C a = | |
| ordinalRank hμ c hcard hsize hmerger hj E hE C a := | |
| CohenSelection.rank_fixed hμ _ _ _ _ a π hπ | |
| theorem ordinalType_fixed (π : Equiv.Perm I) (hπ : π ∈ tailGroup hj C) : | |
| π • ordinalType hμ c hcard hsize hmerger hj E hE C = | |
| ordinalType hμ c hcard hsize hmerger hj E hE C := | |
| CohenSelection.orderType_fixed hμ _ _ _ _ π hπ | |
| end | |
| end PartitionConsistency.ProductForcing.ChainCode | |
| end OAI | |