| import Mathlib |
| import OAI.SetTheory.PartitionConsistency.Models.GermSelectors |
|
|
| namespace OAI |
|
|
| /-! ## ConditionSelector -/ |
|
|
| /-! The countable-germ selector as a genuine condition-by-condition recipe. |
| There is no total family of generic rows in the ambient universe in this |
| construction. A countable condition suffices to decide each selection, and |
| the decisions are both persistent and covariant. -/ |
| namespace PartitionConsistency.CohenForcing.Condition |
| universe u |
| noncomputable section |
| open scoped Classical |
| variable {I κ : Type u} |
|
|
| / |
| row data, NOT the generic rows; only values in the domain will be used to |
| make a persistent decision. -/ |
| def rows (p : Condition I κ) (i : I) (a : κ) : Bool := |
| if ((i,a),true) ∈ p.graph then true else false |
|
|
| theorem rows_of_mem (p : Condition I κ) (i : I) (a : κ) (b : Bool) |
| (h : ((i,a),b) ∈ p.graph) : p.rows i a = b := by |
| cases b |
| · have hn : ((i,a),true) ∉ p.graph := fun ht => Bool.false_ne_true (p.functional _ _ _ h ht) |
| simp [rows,hn] |
| · simp [rows,h] |
|
|
| theorem rows_eq_of_le {p q : Condition I κ} (hqp : q ≤ p) {i : I} {a : κ} |
| (ha : (i,a) ∈ p.dom) : q.rows i a = p.rows i a := by |
| obtain ⟨b,hb⟩ := (p.mem_dom _).mp ha |
| exact (q.rows_of_mem i a b (hqp hb)).trans (p.rows_of_mem i a b hb).symm |
|
|
| @[simp] theorem rows_permute (σ : Equiv.Perm I) (p : Condition I κ) (i : I) (a : κ) : |
| (p.permute σ).rows i a = p.rows (σ.symm i) a := by |
| simp only [rows,mem_permute] |
|
|
| theorem dom_mono {p q : Condition I κ} (hqp : q ≤ p) : p.dom ⊆ q.dom := by |
| intro a ha |
| obtain ⟨b,hb⟩ := (p.mem_dom _).mp ha |
| exact (q.mem_dom _).mpr ⟨b,hqp hb⟩ |
|
|
| / |
| def fill (p : Condition I κ) (A : Set (I × κ)) (hA : A.Countable) : Condition I κ where |
| graph := p.graph ∪ {z | z.1 ∈ A ∧ z.1 ∉ p.dom ∧ z.2 = false} |
| functional := by |
| intro a b c hb hc |
| rcases hb with hb | hb <;> rcases hc with hc | hc |
| · exact p.functional a b c hb hc |
| · exact False.elim (hc.2.1 ((p.mem_dom a).mpr ⟨b,hb⟩)) |
| · exact False.elim (hb.2.1 ((p.mem_dom a).mpr ⟨c,hc⟩)) |
| · exact hb.2.2.trans hc.2.2.symm |
| countable_graph := p.countable_graph.union ((hA.image (fun a => (a,false))).mono (by |
| rintro ⟨a,b⟩ ⟨ha,_,hb⟩ |
| exact ⟨a,ha,Prod.ext rfl hb.symm⟩)) |
|
|
| theorem fill_le (p : Condition I κ) (A : Set (I × κ)) (hA : A.Countable) : |
| p.fill A hA ≤ p := fun _ h => Or.inl h |
|
|
| theorem subset_dom_fill (p : Condition I κ) (A : Set (I × κ)) (hA : A.Countable) : |
| A ⊆ (p.fill A hA).dom := by |
| intro a ha |
| by_cases h : a ∈ p.dom |
| · exact dom_mono (p.fill_le A hA) h |
| · exact ((p.fill A hA).mem_dom a).mpr ⟨false,Or.inr ⟨ha,h,rfl⟩⟩ |
|
|
| end |
| end PartitionConsistency.CohenForcing.Condition |
|
|
| namespace PartitionConsistency.TailSelector.TailData |
| universe u |
| noncomputable section |
| open scoped Classical |
| open CohenForcing |
| variable {G I κ : Type u} [Group G] [MulAction G I] (D : TailData G I) |
| variable [LinearOrder κ] |
|
|
| / |
| other representative on each detector sequence. -/ |
| theorem representative_eventually (g : G) (δ : D.Nonidentity) : |
| ∃ N, ∀ n, N ≤ n → (g : D.Cosets).out • D.detector δ n = g • D.detector δ n := by |
| obtain ⟨N,hN⟩ := D.detector_fixed_eventually |
| (QuotientGroup.eq.mp (QuotientGroup.out_eq' (g : D.Cosets))) δ |
| refine ⟨N,fun n hn => ?_⟩ |
| have h := congrArg (fun i : I => (g : D.Cosets).out • i) (hN n hn) |
| simpa only [← mul_smul,mul_inv_cancel_left] using h.symm |
| |
| /-- Every bounded detector row is completely assigned after a finite initial |
| segment. The quantifier over all representatives makes covariance literal. -/ |
| def Complete (p : Condition I κ) (α : κ) : Prop := |
| ∀ g : G, ∀ δ : D.Nonidentity, ∃ N, ∀ n, N ≤ n → |
| ∀ b : Set.Iio α, (g • D.detector δ n,b.val) ∈ p.dom |
| |
| theorem Complete.mono {p q : Condition I κ} {α : κ} (h : D.Complete p α) (hqp : q ≤ p) : |
| D.Complete q α := by |
| intro g δ |
| obtain ⟨N,hN⟩ := h g δ |
| exact ⟨N,fun n hn b => Condition.dom_mono hqp (hN n hn b)⟩ |
| |
| theorem Complete.downward {p : Condition I κ} {α β : κ} |
| (h : D.Complete p α) (hβα : β ≤ α) : D.Complete p β := by |
| intro g δ |
| obtain ⟨N,hN⟩ := h g δ |
| exact ⟨N,fun n hn b => hN n hn ⟨b.val,b.property.trans_le hβα⟩⟩ |
| |
| /-- Assigned bounded patterns cannot be altered by an extension. -/ |
| theorem Complete.pattern_eq {p q : Condition I κ} {α : κ} |
| (h : D.Complete p α) (hqp : q ≤ p) : D.pattern q.rows α = D.pattern p.rows α := by |
| funext c δ |
| apply (eventualMk_eq_iff _ _).mpr |
| obtain ⟨N,hN⟩ := h c.out δ |
| refine ⟨N,fun n hn => funext (fun b => ?_)⟩ |
| exact Condition.rows_eq_of_le hqp (hN n hn b) |
| |
| theorem Complete.permute {p : Condition I κ} {α : κ} |
| (h : D.Complete p α) (σ : G) : D.Complete (p.permute (MulAction.toPerm σ)) α := by |
| intro g δ |
| obtain ⟨N,hN⟩ := h (σ⁻¹*g) δ |
| refine ⟨N,fun n hn b => ?_⟩ |
| obtain ⟨a,ha⟩ := (p.mem_dom _).mp (hN n hn b) |
| apply ((p.permute (MulAction.toPerm σ)).mem_dom _).mpr |
| refine ⟨a,?_⟩ |
| simpa only [Condition.mem_permute,Condition.coordinatePerm_symm_apply, |
| MulAction.toPerm_symm_apply,mul_smul] using ha |
| |
| omit [LinearOrder κ] in |
| theorem rows_permute (σ : G) (p : Condition I κ) : |
| (p.permute (MulAction.toPerm σ)).rows = moveRows σ p.rows := by |
| funext i a |
| simpa only [moveRows,MulAction.toPerm_symm_apply] using |
| Condition.rows_permute (MulAction.toPerm σ) p i a |
| |
| /-- A good condition actually decides a distinguishing pattern; arbitrary |
| unassigned row values are never used for a stable selection. -/ |
| def Good (p : Condition I κ) : Prop := |
| ∃ α : κ, D.Complete p α ∧ Function.Injective (D.pattern p.rows α) |
| |
| theorem Good.mono {p q : Condition I κ} (h : D.Good p) (hqp : q ≤ p) : D.Good q := by |
| obtain ⟨α,hc,hi⟩ := h |
| refine ⟨α,hc.mono D hqp,?_⟩ |
| rwa [hc.pattern_eq D hqp] |
| |
| theorem Good.permute [WellFoundedLT κ] {p : Condition I κ} (h : D.Good p) (σ : G) : |
| D.Good (p.permute (MulAction.toPerm σ)) := by |
| obtain ⟨α,hc,hi⟩ := h |
| refine ⟨α,hc.permute D σ,?_⟩ |
| rw [rows_permute] |
| exact (D.distinguishes_moveRows_iff σ p.rows α).mpr hi |
| |
| /-- The countable coordinate family used by the fixed representatives. -/ |
| def detectorSites : Set I := |
| Set.range (fun z : D.Cosets × D.Nonidentity × ℕ => z.1.out • D.detector z.2.1 z.2.2) |
| |
| theorem detectorSites_countable [Countable D.Cosets] : D.detectorSites.Countable := |
| Set.countable_range _ |
| |
| theorem detectorSite_mem (c : D.Cosets) (δ : D.Nonidentity) (n : ℕ) : |
| c.out • D.detector δ n ∈ D.detectorSites := ⟨(c,δ,n),rfl⟩ |
| |
| theorem complete_of_covered {p : Condition I κ} {α : κ} |
| (h : D.detectorSites ×ˢ Set.Iio α ⊆ p.dom) : D.Complete p α := by |
| intro g δ |
| obtain ⟨N,hN⟩ := D.representative_eventually g δ |
| refine ⟨N,fun n hn b => ?_⟩ |
| rw [← hN n hn] |
| exact h ⟨D.detectorSite_mem (g : D.Cosets) δ n,b.property⟩ |
| |
| private theorem bounded_countable [Nonempty κ] |
| (hbound : ∀ f : ℕ → κ, ∃ α, ∀ n, f n < α) |
| {A : Type u} [Countable A] (f : A → κ) : ∃ α, ∀ a, f a < α := by |
| let : Encodable A := Encodable.ofCountable A |
| let g : ℕ → κ := fun n => (Encodable.decode (α := A) n).elim |
| (Classical.choice ‹Nonempty κ›) f |
| obtain ⟨α,hα⟩ := hbound g |
| refine ⟨α,fun a => ?_⟩ |
| simpa only [g,Encodable.encodek,Option.elim_some] using hα (Encodable.encode a) |
| |
| /-- In one countable extension all relevant unequal detector sites acquire |
| opposite bits below a common countable bound. This argument does not assume |
| that the ambient universe already contains distinct rows on all of I. -/ |
| theorem good_dense [Nonempty κ] [Uncountable κ] [Countable D.Cosets] |
| (hbound : ∀ f : ℕ → κ, ∃ α, ∀ n, f n < α) |
| (hcount : ∀ α : κ, (Set.Iio α).Countable) (p : Condition I κ) : |
| ∃ q, q ≤ p ∧ D.Good q := by |
| let J := D.detectorSites |
| let : Countable J := D.detectorSites_countable.to_subtype |
| let A := {z : J × J // z.1 ≠ z.2} |
| let R (z : A) (q : Condition I κ) := |
| ∃ a : κ, ((z.val.1.val,a),false) ∈ q.graph ∧ ((z.val.2.val,a),true) ∈ q.graph |
| have hdense : ∀ z q, q ≤ p → ∃ r, r ≤ q ∧ R z r := by |
| intro z q _ |
| have hne : z.val.1.val ≠ z.val.2.val := fun h => z.property (Subtype.ext h) |
| obtain ⟨r,a,hr,hx,hy⟩ := q.separate_labels hne |
| exact ⟨r,hr,a,hx,hy⟩ |
| obtain ⟨q,hqp,hq⟩ := Condition.countable_fusion p R |
| (fun z q r hr ⟨a,hx,hy⟩ => ⟨a,hr hx,hr hy⟩) hdense |
| choose bit hfalse htrue using hq |
| obtain ⟨α,hα⟩ := bounded_countable hbound bit |
| let B := J ×ˢ Set.Iio α |
| have hB : B.Countable := D.detectorSites_countable.prod (hcount α) |
| let r := q.fill B hB |
| have hrq : r ≤ q := q.fill_le B hB |
| refine ⟨r,hrq.trans hqp,α,D.complete_of_covered (q.subset_dom_fill B hB),?_⟩ |
| intro c e he |
| by_contra hne |
| have hne' : (c.out : D.Cosets) ≠ (e.out : D.Cosets) := by |
| simpa only [QuotientGroup.out_eq'] using hne |
| obtain ⟨δ,N,hN⟩ := D.detector_separates c.out e.out hne' |
| obtain ⟨M,hM⟩ := (eventualMk_eq_iff _ _).mp (congrFun he δ) |
| let x : J := ⟨c.out • D.detector δ (N+M),D.detectorSite_mem c δ (N+M)⟩ |
| let y : J := ⟨e.out • D.detector δ (N+M),D.detectorSite_mem e δ (N+M)⟩ |
| let z : A := ⟨(x,y),fun h => hN (N+M) (Nat.le_add_right _ _) (congrArg Subtype.val h)⟩ |
| have hh := congrFun (hM (N+M) (Nat.le_add_left _ _)) (⟨bit z,hα z⟩ : Set.Iio α) |
| have hx : r.rows x.val (bit z) = false := r.rows_of_mem _ _ _ (hrq (hfalse z)) |
| have hy : r.rows y.val (bit z) = true := r.rows_of_mem _ _ _ (hrq (htrue z)) |
| exact Bool.false_ne_true (hx.symm.trans (hh.trans hy)) |
|
|
| variable [WellFoundedLT κ] |
|
|
| theorem leastBound_le (R : I → κ → Bool) |
| (h : ∃ α, Function.Injective (D.pattern R α)) (α : κ) |
| (hα : Function.Injective (D.pattern R α)) : D.leastBound R h ≤ α := |
| not_lt.mp (wellFounded_lt.not_lt_min _ hα) |
|
|
| / |
| def conditionSelector (p : Condition I κ) (h : D.Good p) : D.Cosets := |
| D.selector p.rows ⟨h.choose,h.choose_spec.2⟩ |
|
|
| theorem Good.complete_least {p : Condition I κ} (h : D.Good p) : |
| D.Complete p (D.leastBound p.rows ⟨h.choose,h.choose_spec.2⟩) := |
| h.choose_spec.1.downward D (D.leastBound_le _ _ _ h.choose_spec.2) |
|
|
| / |
| undefined rows were filled. -/ |
| theorem leastBound_extension {p q : Condition I κ} (hp : D.Good p) (hq : D.Good q) |
| (hqp : q ≤ p) : |
| D.leastBound q.rows ⟨hq.choose,hq.choose_spec.2⟩ = |
| D.leastBound p.rows ⟨hp.choose,hp.choose_spec.2⟩ := by |
| let α := D.leastBound p.rows ⟨hp.choose,hp.choose_spec.2⟩ |
| let β := D.leastBound q.rows ⟨hq.choose,hq.choose_spec.2⟩ |
| have hc : D.Complete p α := hp.complete_least D |
| have hi : Function.Injective (D.pattern q.rows α) := by |
| rw [hc.pattern_eq D hqp] |
| exact D.leastBound_distinguishes _ _ |
| have hβα : β ≤ α := D.leastBound_le _ _ _ hi |
| have hi' : Function.Injective (D.pattern p.rows β) := by |
| rw [← (hc.downward D hβα).pattern_eq D hqp] |
| exact D.leastBound_distinguishes _ _ |
| exact le_antisymm hβα (D.leastBound_le _ _ _ hi') |
|
|
| omit [WellFoundedLT κ] in |
| theorem bestCoset_congr (R R' : I → κ → Bool) (α : κ) |
| (h : D.pattern R α = D.pattern R' α) : D.bestCoset R α = D.bestCoset R' α := by |
| unfold bestCoset |
| congr 1 |
| rw [h] |
| |
| /-- Every stronger condition makes the same coset decision. -/ |
| theorem conditionSelector_extension {p q : Condition I κ} (hp : D.Good p) (hq : D.Good q) |
| (hqp : q ≤ p) : D.conditionSelector q hq = D.conditionSelector p hp := by |
| unfold conditionSelector selector |
| rw [D.leastBound_extension hp hq hqp] |
| exact D.bestCoset_congr _ _ _ ((hp.complete_least D).pattern_eq D hqp) |
| |
| /-- Genuine covariance of the persistent decision made by a Cohen condition. -/ |
| theorem conditionSelector_permute (p : Condition I κ) (hp : D.Good p) (σ : G) |
| (hq : D.Good (p.permute (MulAction.toPerm σ))) : |
| D.conditionSelector (p.permute (MulAction.toPerm σ)) hq = |
| (σ : D.Cosets) * D.conditionSelector p hp := by |
| unfold conditionSelector |
| have hrow := rows_permute σ p |
| have he : ∃ α, Function.Injective (D.pattern (moveRows σ p.rows) α) := by |
| simpa only [hrow] using (show ∃ α, Function.Injective |
| (D.pattern (p.permute (MulAction.toPerm σ)).rows α) from ⟨hq.choose,hq.choose_spec.2⟩) |
| have hh := D.selector_covariance σ p.rows ⟨hp.choose,hp.choose_spec.2⟩ he |
| convert hh using 1 |
| simp only [hrow] |
| |
| /-- The downward-persistent relation that can be used as a name recipe. -/ |
| def Selected (p : Condition I κ) (c : D.Cosets) : Prop := |
| ∃ h : D.Good p, D.conditionSelector p h = c |
| |
| theorem Selected.mono {p q : Condition I κ} {c : D.Cosets} |
| (h : D.Selected p c) (hqp : q ≤ p) : D.Selected q c := by |
| obtain ⟨hp,rfl⟩ := h |
| exact ⟨hp.mono D hqp,D.conditionSelector_extension hp (hp.mono D hqp) hqp⟩ |
| |
| theorem selected_unique {p : Condition I κ} {c e : D.Cosets} |
| (hc : D.Selected p c) (he : D.Selected p e) : c = e := by |
| obtain ⟨hp,rfl⟩ := hc |
| obtain ⟨hq,rfl⟩ := he |
| rfl |
| |
| theorem Selected.permute {p : Condition I κ} {c : D.Cosets} |
| (h : D.Selected p c) (σ : G) : |
| D.Selected (p.permute (MulAction.toPerm σ)) ((σ : D.Cosets)*c) := by |
| obtain ⟨hp,rfl⟩ := h |
| exact ⟨hp.permute D σ,D.conditionSelector_permute p hp σ _⟩ |
| |
| theorem selected_compatible {p q : Condition I κ} {c e : D.Cosets} |
| (hc : D.Selected p c) (he : D.Selected q e) (h : Condition.Compatible p q) : c = e := |
| D.selected_unique (hc.mono D (p.union_le_left q h)) (he.mono D (p.union_le_right q h)) |
| |
| end |
| end PartitionConsistency.TailSelector.TailData |
| |
| |
| /-! ## CosetPredicate -/ |
| |
| /-! Coset transport for predicates on the total space of computations. |
| The inverse moves every argument, in particular the actual Cohen condition. -/ |
| namespace PartitionConsistency.CohenForcing.Condition |
| universe u |
| variable {I κ : Type u} |
| instance coordinateAction : MulAction (Equiv.Perm I) (Condition I κ) where |
| smul π d := d.permute π |
| one_smul := permute_one |
| mul_smul := fun π σ d => permute_mul π σ d |
| @[simp] theorem smul_condition (π : Equiv.Perm I) (d : Condition I κ) : |
| π • d = d.permute π := rfl |
| end PartitionConsistency.CohenForcing.Condition |
| |
| namespace PartitionConsistency.CosetPredicate |
| universe u v |
| variable {G : Type u} [Group G] {X : Type v} [MulAction G X] |
| noncomputable section |
| |
| def shift (g : G) (R : X → Prop) : X → Prop := fun x => R (g⁻¹ • x) |
| |
| @[simp] theorem shift_one (R : X → Prop) : shift (1 : G) R = R := by |
| funext x |
| simp only [shift, inv_one, one_smul] |
| |
| theorem shift_mul (g h : G) (R : X → Prop) : |
| shift (g*h) R = shift g (shift h R) := by |
| funext x |
| simp only [shift, mul_inv_rev, mul_smul] |
| |
| theorem shift_at_moved (g : G) (R : X → Prop) (x : X) : |
| shift g R (g • x) = R x := by |
| simp only [shift, inv_smul_smul] |
| |
| def Invariant (K : Subgroup G) (R : X → Prop) : Prop := |
| ∀ k ∈ K, ∀ x, R (k • x) ↔ R x |
| |
| theorem shift_eq (K : Subgroup G) (R : X → Prop) (hR : Invariant K R) |
| {g h : G} (he : (g : G ⧸ K) = h) : shift g R = shift h R := by |
| have hk : g⁻¹*h ∈ K := QuotientGroup.eq.mp he |
| have hi : shift (g⁻¹*h) R = R := by |
| funext x |
| exact propext (hR _ (K.inv_mem hk) x) |
| calc |
| shift g R = shift g (shift (g⁻¹*h) R) := by rw [hi] |
| _ = shift (g*(g⁻¹*h)) R := (shift_mul _ _ _).symm |
| _ = shift h R := by rw [mul_inv_cancel_left] |
| |
| end |
| end PartitionConsistency.CosetPredicate |
| |
| |
| /-! ## Corrected -/ |
| |
| /-! A component assignment on actual conditions: select a residual coset, |
| compute at the inverse-moved condition, then transport every argument back. |
| The quotient operation uses proved tail invariance, not an arbitrary choice |
| of a bijection. -/ |
| namespace PartitionConsistency.ProductForcing.ChainCode |
| universe u |
| open SetForcingNames SetForcingNames.SymmetricSystem DiagramForcing ForcingQuotient |
| open DiagramOrder LocalDiagramSystem |
| noncomputable section |
| variable {M I κ : Type u} [LeftCancelMonoid M] [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) |
| local notation "S" => system (M := M) (I := I) (κ := κ) hμ |
| local notation "G" => Vertex.componentStabilizer hj v |
| local notation "K" => C.tailFixer hj |
| |
| abbrev AssignmentPoint := CohenForcing.Condition I κ × Vertex q × labelFiberSet v × (S).Name |
| |
| def preliminaryPoint (x : AssignmentPoint (κ := κ) hμ (v := v)) : Prop := |
| Preliminary hμ c hcard hsize hmerger hj E hE C x.1 x.2.1 x.2.2.1 x.2.2.2 |
| |
| theorem preliminaryPoint_move (k : K) (x : AssignmentPoint (κ := κ) hμ (v := v)) |
| (hx : preliminaryPoint hμ c hcard hsize hmerger hj E hE C x) : |
| preliminaryPoint hμ c hcard hsize hmerger hj E hE C (k.val • x) := by |
| obtain ⟨d,w,j,τ⟩ := x |
| change Preliminary hμ c hcard hsize hmerger hj E hE C |
| (d.permute k.val.val.val) (k.val.val • w) (k.val • j) (k.val.val.val • τ) |
| rw [Vertex.Chain.tailFixer_fixes_label hj v C k j] |
| exact preliminary_permute hμ c hcard hsize hmerger hj E hE C k d w j τ hx |
| |
| theorem preliminaryPoint_invariant : CosetPredicate.Invariant K |
| (preliminaryPoint hμ c hcard hsize hmerger hj E hE C) := by |
| intro k hk x |
| constructor |
| · intro h |
| have hh := preliminaryPoint_move hμ c hcard hsize hmerger hj E hE C ⟨k⁻¹,(K).inv_mem hk⟩ (k • x) h |
| simpa only [inv_smul_smul] using hh |
| · exact preliminaryPoint_move hμ c hcard hsize hmerger hj E hE C ⟨k,hk⟩ x |
| |
| variable [LinearOrder κ] [WellFoundedLT κ] |
| |
| /-- The persistent selected-coset version of the assignment predicate. -/ |
| def Corrected (d : CohenForcing.Condition I κ) (w : Vertex q) |
| (j : labelFiberSet v) (τ : (S).Name) : Prop := |
| ∃ g : G, (C.tailData hj).Selected d (g : G ⧸ K) ∧ |
| CosetPredicate.shift g (preliminaryPoint hμ c hcard hsize hmerger hj E hE C) (d,w,j,τ) |
| |
| /-- Independence of the representative of the selected coset. -/ |
| theorem corrected_selected {d : CohenForcing.Condition I κ} {w : Vertex q} |
| {j : labelFiberSet v} {τ : (S).Name} (g : G) |
| (hg : (C.tailData hj).Selected d (g : G ⧸ K)) : |
| Corrected hμ c hcard hsize hmerger hj E hE C d w j τ ↔ |
| Preliminary hμ c hcard hsize hmerger hj E hE C |
| (g⁻¹ • d) (g⁻¹ • w) (g⁻¹ • j) (g⁻¹ • τ) := by |
| constructor |
| · rintro ⟨k,hk,h⟩ |
| have he : (k : G ⧸ K) = g := (C.tailData hj).selected_unique hk hg |
| have hs := CosetPredicate.shift_eq K |
| (preliminaryPoint hμ c hcard hsize hmerger hj E hE C) |
| (preliminaryPoint_invariant hμ c hcard hsize hmerger hj E hE C) he |
| rw [hs] at h |
| exact h |
| · intro h |
| exact ⟨g,hg,h⟩ |
| |
| variable {hμ c hcard hsize hmerger hj E hE C} |
| |
| theorem corrected_mono {d e : CohenForcing.Condition I κ} {w : Vertex q} |
| {j : labelFiberSet v} {τ : (S).Name} (hed : e ≤ d) |
| (h : Corrected hμ c hcard hsize hmerger hj E hE C d w j τ) : |
| Corrected hμ c hcard hsize hmerger hj E hE C e w j τ := by |
| obtain ⟨g,hg,h⟩ := h |
| refine ⟨g,hg.mono _ hed,?_⟩ |
| exact preliminary_mono ((CohenForcing.Condition.permuteOrderIso g.val.val⁻¹).monotone hed) h |
| |
| theorem corrected_common {d : CohenForcing.Condition I κ} {w : Vertex q} |
| {j : labelFiberSet v} {τ : (S).Name} |
| (h : Corrected hμ c hcard hsize hmerger hj E hE C d w j τ) : Vertex.Common v w := by |
| obtain ⟨g,_,h⟩ := h |
| have hc := Vertex.common_moved hj v g (preliminary_common h) |
| change Vertex.Common v (g • (g⁻¹ • w)) at hc |
| simpa only [smul_inv_smul] using hc |
| |
| variable (hμ) |
| |
| omit [Infinite M] [Infinite I] [LinearOrder κ] [WellFoundedLT κ] in |
| /-- Equality transport at a moved vertex, with the moved Cohen coordinate. -/ |
| theorem root_eq_symmetry (g : Vertex.RootGroup q) (d : CohenForcing.Condition I κ) |
| (w : Vertex q) (τ σ : (S).Name) : |
| (S).atomic.EqF ((g • d,(g • w).diagram) : Poset M I κ) (g • τ) (g • σ) ↔ |
| (S).atomic.EqF ((d,w.diagram) : Poset M I κ) τ σ := by |
| change (S).atomic.EqF ((d.permute g.val,w.diagram.permute g.val) : Poset M I κ) |
| (g.val • τ) (g.val • σ) ↔ _ |
| simpa only [move_coe,permute] using |
| ((S).eq_symmetry g.val ((d,w.diagram) : Poset M I κ) τ σ).symm |
| |
| variable {hμ} |
| |
| theorem corrected_congr {d : CohenForcing.Condition I κ} {w : Vertex q} |
| {j : labelFiberSet v} {τ σ : (S).Name} |
| (h : Corrected hμ c hcard hsize hmerger hj E hE C d w j τ) |
| (he : (S).atomic.EqF ((d,w.diagram) : Poset M I κ) τ σ) : |
| Corrected hμ c hcard hsize hmerger hj E hE C d w j σ := by |
| obtain ⟨g,hg,h⟩ := h |
| exact ⟨g,hg,preliminary_congr h ((root_eq_symmetry hμ g.val⁻¹ d w τ σ).mpr he)⟩ |
| |
| variable (hμ c hcard hsize hmerger hj E hE C) |
| |
| /-- Both injectivity and single-valuedness survive coset correction. -/ |
| theorem corrected_eq_iff {d : CohenForcing.Condition I κ} {w : Vertex q} |
| {j k : labelFiberSet v} {τ σ : (S).Name} |
| (h : Corrected hμ c hcard hsize hmerger hj E hE C d w j τ) |
| (h' : Corrected hμ c hcard hsize hmerger hj E hE C d w k σ) : |
| (S).atomic.EqF ((d,w.diagram) : Poset M I κ) τ σ ↔ j = k := by |
| obtain ⟨g,hg,h⟩ := h |
| have hh := (corrected_selected hμ c hcard hsize hmerger hj E hE C g hg).mp h' |
| rw [← root_eq_symmetry hμ g.val⁻¹ d w τ σ] |
| exact (preliminary_eq_iff h hh).trans (MulAction.injective g⁻¹).eq_iff |
| |
| /-- Covariance under every element of the entire component stabilizer. -/ |
| theorem corrected_permute (g : G) (d : CohenForcing.Condition I κ) (w : Vertex q) |
| (j : labelFiberSet v) (τ : (S).Name) |
| (h : Corrected hμ c hcard hsize hmerger hj E hE C d w j τ) : |
| Corrected hμ c hcard hsize hmerger hj E hE C |
| (g • d) (g • w) (g • j) (g • τ) := by |
| obtain ⟨k,hk,h⟩ := h |
| refine ⟨g*k,?_,?_⟩ |
| · have hg : MulAction.toPerm g = g.val.val := by ext; rfl |
| change (C.tailData hj).Selected (d.permute g.val.val) _ |
| rw [QuotientGroup.mk_mul] |
| have hh := hk.permute (C.tailData hj) g |
| rw [hg] at hh |
| exact hh |
| · change CosetPredicate.shift (g*k) |
| (preliminaryPoint hμ c hcard hsize hmerger hj E hE C) |
| (g • (d,w,j,τ)) |
| rw [CosetPredicate.shift_mul,CosetPredicate.shift_at_moved] |
| exact h |
| |
| /-- Pullback along a contraction retains precisely the same representative. -/ |
| theorem corrected_restrict {d : CohenForcing.Condition I κ} {w z : Vertex q} |
| (f : w.Arrow z) {j : labelFiberSet v} {τ : (S).Name} |
| (h : Corrected hμ c hcard hsize hmerger hj E hE C d z j τ) : |
| Corrected hμ c hcard hsize hmerger hj E hE C d w j τ := by |
| obtain ⟨g,hg,h⟩ := h |
| exact ⟨g,hg,preliminary_restrict hμ c hcard hsize hmerger hj E hE C (f.move g.val⁻¹) h⟩ |
| |
| /-- Reflection along a contraction for a name already supported on its target. -/ |
| theorem corrected_descend {d : CohenForcing.Condition I κ} {w z : Vertex q} |
| (f : w.Arrow z) {j : labelFiberSet v} {τ : LocalName hμ c z.diagram} |
| (h : Corrected hμ c hcard hsize hmerger hj E hE C d w j τ.name) : |
| Corrected hμ c hcard hsize hmerger hj E hE C d z j τ.name := by |
| obtain ⟨g,hg,h⟩ := h |
| exact ⟨g,hg,preliminary_descend hμ c hcard hsize hmerger hj E hE C (f.move g.val⁻¹) |
| (τ := τ.transport hμ g.val.val⁻¹) h⟩ |
| |
| end |
| end PartitionConsistency.ProductForcing.ChainCode |
| |
| |
| /-! ## StableTransport -/ |
| |
| /-! Coordinate transport for the permanently decided availability ideal. |
| This is used both for coset correction and for moving between component |
| orbits. -/ |
| namespace PartitionConsistency.ProductForcing |
| universe u |
| open SetForcingNames SetForcingNames.SymmetricSystem DiagramForcing ForcingQuotient |
| open DiagramOrder LocalDiagramSystem |
| noncomputable section |
| variable {M I κ : Type u} [LeftCancelMonoid M] [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) |
| local notation "S" => system (M := M) (I := I) (κ := κ) hμ |
| |
| omit [Infinite M] [Infinite I] in |
| /-- Moving the entire local equality test also moves its normalized witness. -/ |
| theorem forcedAvailable_permute_iff (π : Equiv.Perm I) |
| (d : CohenForcing.Condition I κ) (r : Diagram M I) (τ : LocalName hμ c r) (n : M) : |
| ForcedAvailable hμ c (d.permute π) (r.permute π) (τ.transport hμ π) n ↔ |
| ForcedAvailable hμ c d r τ n := by |
| constructor |
| · rintro ⟨σ,he⟩ |
| let ρ := σ.rebase hμ c (Diagram.permute_sub π r n).symm |
| obtain ⟨ν,hν⟩ := (LocalName.transportEquiv hμ c π (r.sub n)).surjective ρ |
| have hname : π • ν.name = σ.name := congrArg LocalName.name hν |
| refine ⟨ν,?_⟩ |
| apply ((S).eq_symmetry π ((d,r) : Poset M I κ) ν.name τ.name).mpr |
| simpa only [move_coe,permute,hname,LocalName.transport_name] using he |
| · rintro ⟨σ,he⟩ |
| refine ⟨(σ.transport hμ π).rebase hμ c (Diagram.permute_sub π r n),?_⟩ |
| simpa only [move_coe,permute,LocalName.rebase_name,LocalName.transport_name] using |
| ((S).eq_symmetry π ((d,r) : Poset M I κ) σ.name τ.name).mp he |
| |
| /-- The actual ideal is preserved, not merely its cardinality. -/ |
| theorem forcedAvailability_permute (π : Equiv.Perm I) |
| (d : CohenForcing.Condition I κ) (r : Diagram M I) (a : M) (τ : LocalName hμ c r) : |
| forcedAvailability hμ c hcard hsize hmerger (d.permute π) (r.permute π) a |
| (τ.transport hμ π) = forcedAvailability hμ c hcard hsize hmerger d r a τ := by |
| apply ConeIdeal.ext |
| ext n |
| erw [mem_forcedAvailability,mem_forcedAvailability,forcedAvailable_permute_iff] |
| |
| variable {q : Diagram M I} |
| |
| /-- An actual local class whose availability has become permanent. Keeping |
| the literal name as an argument avoids any chosen representative under |
| transport between vertices. -/ |
| def StableAt (E : (S).Name) (d : CohenForcing.Condition I κ) (w : Vertex q) |
| (τ : (S).Name) : Prop := |
| ∃ ρ : LocalName hμ c w.diagram, ρ.name = τ ∧ |
| (S).Forces ![τ,labelSet hμ c,E] ((d,w.diagram) : Poset M I κ) |
| (SetLanguage.isClass 0 1 2) ∧ |
| ∀ e, e ≤ d → forcedAvailability hμ c hcard hsize hmerger e w.diagram w.index ρ = w.ideal |
| |
| /-- This permutation is allowed to move the component as well as its chain. -/ |
| theorem stableAt_permute (E : (S).Name) |
| (hE : ∀ π ∈ SupportFilter.Fix q.range, π • E = E) |
| (g : Vertex.RootGroup q) (d : CohenForcing.Condition I κ) (w : Vertex q) (τ : (S).Name) |
| (h : StableAt hμ c hcard hsize hmerger E d w τ) : |
| StableAt hμ c hcard hsize hmerger E (g • d) (g • w) (g • τ) := by |
| obtain ⟨ρ,rfl,hel,hs⟩ := h |
| refine ⟨ρ.transport hμ g.val,rfl,?_,?_⟩ |
| · change (S).Forces ![g.val • ρ.name,labelSet hμ c,E] |
| ((d.permute g.val,w.diagram.permute g.val) : Poset M I κ) (SetLanguage.isClass 0 1 2) |
| have hv : (fun i => g.val • (![ρ.name,labelSet hμ c,E] : Fin 3 → (S).Name) i) = |
| ![g.val • ρ.name,labelSet hμ c,E] := by |
| funext i |
| fin_cases i |
| · rfl |
| · exact smul_labelSet hμ c g.val |
| · exact hE g.val g.property |
| simpa only [move_coe,permute,hv] using |
| ((S).forces_symmetry g.val (SetLanguage.isClass 0 1 2) |
| ![ρ.name,labelSet hμ c,E] ((d,w.diagram) : Poset M I κ)).mp hel |
| · change ∀ e, e ≤ d.permute g.val → forcedAvailability hμ c hcard hsize hmerger e |
| (w.diagram.permute g.val) w.index (ρ.transport hμ g.val) = w.ideal |
| intro e he |
| have hed : e.permute g.val⁻¹ ≤ d := by |
| have hh := (CohenForcing.Condition.permuteOrderIso g.val⁻¹).monotone he |
| change e.permute g.val⁻¹ ≤ (d.permute g.val).permute g.val⁻¹ at hh |
| simpa only [CohenForcing.Condition.permute_inv_permute] using hh |
| have hh := forcedAvailability_permute hμ c hcard hsize hmerger g.val |
| (e.permute g.val⁻¹) w.diagram w.index ρ |
| simpa only [CohenForcing.Condition.permute_permute_inv] using hh.trans (hs _ hed) |
| |
| theorem stableAt_permute_iff (E : (S).Name) |
| (hE : ∀ π ∈ SupportFilter.Fix q.range, π • E = E) |
| (g : Vertex.RootGroup q) (d : CohenForcing.Condition I κ) (w : Vertex q) (τ : (S).Name) : |
| StableAt hμ c hcard hsize hmerger E (g • d) (g • w) (g • τ) ↔ |
| StableAt hμ c hcard hsize hmerger E d w τ := by |
| constructor |
| · intro h |
| have hh := stableAt_permute hμ c hcard hsize hmerger E hE g⁻¹ (g • d) (g • w) (g • τ) h |
| simpa only [inv_smul_smul] using hh |
| · exact stableAt_permute hμ c hcard hsize hmerger E hE g d w τ |
| |
| end |
| end PartitionConsistency.ProductForcing |
| |
| end OAI |
| |
