openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Definability /CompressionExternalStepRealization.lean
| import OAI.SetTheory.PartitionPrinciple.Geometry.ExternalTileVertexPresentation | |
| import OAI.SetTheory.PartitionPrinciple.Geometry.GroundCompressionStarIncidence | |
| namespace OAI | |
| open scoped ZFSet | |
| namespace PartitionPilot.Forcing | |
| open SetFormula | |
| universe u | |
| def ExternalFlatVertexWordCode | |
| (E S generators m zero first second q i w v : ZFSet.{u}) : Prop := | |
| (i = zero ∧ v = w) ∨ ∃ s ∈ S, ∃ k ∈ E, | |
| ((i = first ∧ s = ZFSet.pair q zero) ∨ (i = second ∧ s = ZFSet.pair q first)) ∧ | |
| ZFSet.pair s k ∈ generators ∧ ZFSet.pair (ZFSet.pair w k) v ∈ m | |
| noncomputable def externalFlatPlacements (E Requests U V S generators m : ZFSet.{u}) : ZFSet.{u} := | |
| ZFSet.sep (fun z => ∃ w ∈ E, ∃ a ∈ V, ∃ b ∈ ZFSet.prod E U, | |
| ∃ q ∈ Requests, ∃ i ∈ externalRequestTags, ∃ x ∈ U, ∃ v ∈ E, | |
| z = ZFSet.pair (ZFSet.pair w a) b ∧ a = ZFSet.pair (ZFSet.pair q i) x ∧ b = ZFSet.pair v x ∧ | |
| ExternalFlatVertexWordCode E S generators m (natSetCode 0) (natSetCode 1) (natSetCode 2) q i w v) | |
| (ZFSet.prod (ZFSet.prod E V) (ZFSet.prod E U)) | |
| theorem triple_mem_externalFlatPlacements (E Requests U V S generators m w a b : ZFSet.{u}) : | |
| ZFSet.pair (ZFSet.pair w a) b ∈ externalFlatPlacements E Requests U V S generators m ↔ | |
| w ∈ E ∧ a ∈ V ∧ b ∈ ZFSet.prod E U ∧ | |
| ∃ q ∈ Requests, ∃ i ∈ externalRequestTags, ∃ x ∈ U, ∃ v ∈ E, | |
| a = ZFSet.pair (ZFSet.pair q i) x ∧ b = ZFSet.pair v x ∧ | |
| ExternalFlatVertexWordCode E S generators m (natSetCode 0) (natSetCode 1) (natSetCode 2) q i w v := by | |
| rw [externalFlatPlacements, ZFSet.mem_sep] | |
| constructor | |
| · rintro ⟨_, w', hw, a', ha, b', hb, q, hq, i, hi, x, hx, v, hv, equal, left, right, word⟩ | |
| obtain ⟨wa, rfl⟩ := ZFSet.pair_inj.1 equal | |
| obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 wa | |
| exact ⟨hw, ha, hb, q, hq, i, hi, x, hx, v, hv, left, right, word⟩ | |
| · rintro ⟨hw, ha, hb, q, hq, i, hi, x, hx, v, hv, left, right, word⟩ | |
| exact ⟨ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 ⟨hw, ha⟩, hb⟩, | |
| w, hw, a, ha, b, hb, q, hq, i, hi, x, hx, v, hv, rfl, left, right, word⟩ | |
| namespace BoundedFormula | |
| def externalFlatVertexWordFormula {n} (E S generators m zero first second q i w v : Fin n) : BoundedFormula n := | |
| disj (.conj (.equal i zero) (.equal v w)) | |
| (exMem S (exMem E.succ | |
| (.conj (disj (.conj (.equal i.succ.succ first.succ.succ) | |
| (orderedPairFormula 1 q.succ.succ zero.succ.succ)) | |
| (.conj (.equal i.succ.succ second.succ.succ) (orderedPairFormula 1 q.succ.succ first.succ.succ))) | |
| (.conj (pairMembershipFormula 1 0 generators.succ.succ) | |
| (tripleMembershipFormula w.succ.succ 0 v.succ.succ m.succ.succ))))) | |
| theorem truth_externalFlatVertexWordFormula {n} | |
| (E S generators m zero first second q i w v : Fin n) (env : Fin n → ZFSet.{u}) : | |
| Truth (externalFlatVertexWordFormula E S generators m zero first second q i w v) env ↔ | |
| ExternalFlatVertexWordCode (env E) (env S) (env generators) (env m) (env zero) (env first) (env second) | |
| (env q) (env i) (env w) (env v) := by | |
| simp only [externalFlatVertexWordFormula, Truth, truth_exMem, truth_disj, truth_orderedPairFormula, | |
| truth_pairMembershipFormula, truth_tripleMembershipFormula, ExternalFlatVertexWordCode] | |
| rfl | |
| def externalFlatPlacementEntryFormula {n} | |
| (z E Requests Tags U V L S generators m zero first second : Fin n) : BoundedFormula n := | |
| exMem E (exMem V.succ (exMem L.succ.succ (exMem Requests.succ.succ.succ | |
| (exMem Tags.succ.succ.succ.succ (exMem U.succ.succ.succ.succ.succ | |
| (exMem E.succ.succ.succ.succ.succ.succ | |
| (.conj (orderedTripleFormula z.succ.succ.succ.succ.succ.succ.succ 6 5 4) | |
| (.conj (orderedTripleFormula 5 3 2 1) | |
| (.conj (orderedPairFormula 4 0 1) | |
| (externalFlatVertexWordFormula E.succ.succ.succ.succ.succ.succ.succ | |
| S.succ.succ.succ.succ.succ.succ.succ generators.succ.succ.succ.succ.succ.succ.succ | |
| m.succ.succ.succ.succ.succ.succ.succ zero.succ.succ.succ.succ.succ.succ.succ | |
| first.succ.succ.succ.succ.succ.succ.succ second.succ.succ.succ.succ.succ.succ.succ | |
| 3 2 6 0)))))))))) | |
| theorem truth_externalFlatPlacementEntryFormula {n} | |
| (z E Requests Tags U V L S generators m zero first second : Fin n) (env : Fin n → ZFSet.{u}) : | |
| Truth (externalFlatPlacementEntryFormula z E Requests Tags U V L S generators m zero first second) env ↔ | |
| ∃ w ∈ env E, ∃ a ∈ env V, ∃ b ∈ env L, ∃ q ∈ env Requests, ∃ i ∈ env Tags, | |
| ∃ x ∈ env U, ∃ v ∈ env E, | |
| env z = ZFSet.pair (ZFSet.pair w a) b ∧ a = ZFSet.pair (ZFSet.pair q i) x ∧ b = ZFSet.pair v x ∧ | |
| ExternalFlatVertexWordCode (env E) (env S) (env generators) (env m) (env zero) (env first) (env second) | |
| q i w v := by | |
| simp only [externalFlatPlacementEntryFormula, Truth, truth_exMem, truth_orderedPairFormula, | |
| truth_orderedTripleFormula, truth_externalFlatVertexWordFormula] | |
| rfl | |
| end BoundedFormula | |
| namespace TransitiveGround | |
| variable (M : TransitiveGround.{u}) | |
| theorem externalFlatPlacements_mem | |
| (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| {E Requests U V S generators m : ZFSet.{u}} | |
| (hE : E ∈ M.sets) (hRequests : Requests ∈ M.sets) (hU : U ∈ M.sets) (hV : V ∈ M.sets) | |
| (hS : S ∈ M.sets) (hGenerators : generators ∈ M.sets) (hm : m ∈ M.sets) : | |
| externalFlatPlacements E Requests U V S generators m ∈ M.sets := by | |
| have hZero : natSetCode 0 ∈ M.sets := M.empty_mem ⟨U, hU⟩ | |
| have hFirst : natSetCode 1 ∈ M.sets := M.insert_mem pairing unions hZero hZero | |
| have hSecond : natSetCode 2 ∈ M.sets := M.insert_mem pairing unions hFirst hFirst | |
| have single : ({natSetCode 2} : ZFSet.{u}) ∈ M.sets := by | |
| simpa only [ZFSet.pair_eq_singleton] using M.unorderedPair_mem pairing hSecond hSecond | |
| have hTags : externalRequestTags ∈ M.sets := | |
| M.insert_mem pairing unions hZero (M.insert_mem pairing unions hFirst single) | |
| have hL := M.prod_mem pairing unions powers separation hE hU | |
| let params := extend E (extend Requests (extend externalRequestTags (extend U (extend V | |
| (extend (ZFSet.prod E U) (extend S (extend generators (extend m (extend (natSetCode 0) | |
| (extend (natSetCode 1) (extend (natSetCode 2) Fin.elim0))))))))))) | |
| have selected := M.bounded_separation_mem separation | |
| (BoundedFormula.externalFlatPlacementEntryFormula 0 1 2 3 4 5 6 7 8 9 10 11 12) params | |
| (Fin.cases hE (Fin.cases hRequests (Fin.cases hTags (Fin.cases hU (Fin.cases hV (Fin.cases hL | |
| (Fin.cases hS (Fin.cases hGenerators (Fin.cases hm (Fin.cases hZero | |
| (Fin.cases hFirst (Fin.cases hSecond (fun i => Fin.elim0 i))))))))))))) | |
| (M.prod_mem pairing unions powers separation (M.prod_mem pairing unions powers separation hE hV) hL) | |
| have equal : ZFSet.sep (fun z => BoundedFormula.Truth | |
| (BoundedFormula.externalFlatPlacementEntryFormula 0 1 2 3 4 5 6 7 8 9 10 11 12) (extend z params)) | |
| (ZFSet.prod (ZFSet.prod E V) (ZFSet.prod E U)) = externalFlatPlacements E Requests U V S generators m := by | |
| apply ZFSet.ext | |
| intro z | |
| rw [externalFlatPlacements, ZFSet.mem_sep, ZFSet.mem_sep] | |
| exact and_congr Iff.rfl (BoundedFormula.truth_externalFlatPlacementEntryFormula | |
| 0 1 2 3 4 5 6 7 8 9 10 11 12 _) | |
| exact equal ▸ selected | |
| end TransitiveGround | |
| def ExternalFlatCoordinateCode (E U G old m A a b : ZFSet.{u}) : Prop := | |
| ∃ w ∈ E, ∃ k ∈ E, ∃ v ∈ E, ∃ j ∈ G, ∃ x ∈ U, ∃ y ∈ U, | |
| ZFSet.pair j k ∈ old ∧ ZFSet.pair (ZFSet.pair w k) v ∈ m ∧ | |
| ZFSet.pair (ZFSet.pair j x) y ∈ A ∧ a = ZFSet.pair v x ∧ b = ZFSet.pair w y | |
| def ExternalFlatTileStepCode (E V placements overlaps a b : ZFSet.{u}) : Prop := | |
| ∃ w ∈ E, ∃ x ∈ V, ∃ y ∈ V, | |
| ZFSet.pair (ZFSet.pair w x) a ∈ placements ∧ | |
| ZFSet.pair (ZFSet.pair w y) b ∈ placements ∧ ZFSet.pair x y ∈ overlaps | |
| def ExternalFlatStepCode (E U G V old m A placements overlaps a b : ZFSet.{u}) : Prop := | |
| (ExternalFlatCoordinateCode E U G old m A a b ∨ ExternalFlatTileStepCode E V placements overlaps a b) ∨ | |
| (ExternalFlatCoordinateCode E U G old m A b a ∨ ExternalFlatTileStepCode E V placements overlaps b a) | |
| theorem ExternalFlatStepCode.symm {E U G V old m A placements overlaps a b : ZFSet.{u}} | |
| (step : ExternalFlatStepCode E U G V old m A placements overlaps a b) : | |
| ExternalFlatStepCode E U G V old m A placements overlaps b a := Or.symm step | |
| noncomputable def externalFlatStepGraph (E U G V old m A placements overlaps : ZFSet.{u}) : ZFSet.{u} := | |
| ZFSet.sep (fun z => ∃ a ∈ ZFSet.prod E U, ∃ b ∈ ZFSet.prod E U, z = ZFSet.pair a b ∧ | |
| ExternalFlatStepCode E U G V old m A placements overlaps a b) | |
| (ZFSet.prod (ZFSet.prod E U) (ZFSet.prod E U)) | |
| theorem pair_mem_externalFlatStepGraph (E U G V old m A placements overlaps a b : ZFSet.{u}) : | |
| ZFSet.pair a b ∈ externalFlatStepGraph E U G V old m A placements overlaps ↔ | |
| a ∈ ZFSet.prod E U ∧ b ∈ ZFSet.prod E U ∧ | |
| ExternalFlatStepCode E U G V old m A placements overlaps a b := by | |
| rw [externalFlatStepGraph, ZFSet.mem_sep] | |
| constructor | |
| · rintro ⟨_, a', ha, b', hb, equal, step⟩ | |
| obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal | |
| exact ⟨ha, hb, step⟩ | |
| · rintro ⟨ha, hb, step⟩ | |
| exact ⟨ZFSet.pair_mem_prod.2 ⟨ha, hb⟩, a, ha, b, hb, rfl, step⟩ | |
| theorem externalFlatStepGraph_subset (E U G V old m A placements overlaps : ZFSet.{u}) : | |
| externalFlatStepGraph E U G V old m A placements overlaps ⊆ | |
| ZFSet.prod (ZFSet.prod E U) (ZFSet.prod E U) := | |
| fun _ member => (ZFSet.mem_sep.1 member).1 | |
| theorem externalFlatStepGraph_symmetric {E U G V old m A placements overlaps a b : ZFSet.{u}} | |
| (entry : ZFSet.pair a b ∈ externalFlatStepGraph E U G V old m A placements overlaps) : | |
| ZFSet.pair b a ∈ externalFlatStepGraph E U G V old m A placements overlaps := by | |
| obtain ⟨ha, hb, step⟩ := (pair_mem_externalFlatStepGraph _ _ _ _ _ _ _ _ _ _ _).1 entry | |
| exact (pair_mem_externalFlatStepGraph _ _ _ _ _ _ _ _ _ _ _).2 ⟨hb, ha, step.symm⟩ | |
| namespace BoundedFormula | |
| def externalFlatCoordinateFormula {n} (E U G old m A a b : Fin n) : BoundedFormula n := | |
| exMem E (exMem E.succ (exMem E.succ.succ (exMem G.succ.succ.succ | |
| (exMem U.succ.succ.succ.succ (exMem U.succ.succ.succ.succ.succ | |
| (.conj (pairMembershipFormula 2 4 old.succ.succ.succ.succ.succ.succ) | |
| (.conj (tripleMembershipFormula 5 4 3 m.succ.succ.succ.succ.succ.succ) | |
| (.conj (tripleMembershipFormula 2 1 0 A.succ.succ.succ.succ.succ.succ) | |
| (.conj (orderedPairFormula a.succ.succ.succ.succ.succ.succ 3 1) | |
| (orderedPairFormula b.succ.succ.succ.succ.succ.succ 5 0)))))))))) | |
| def externalFlatTileStepFormula {n} (E V placements overlaps a b : Fin n) : BoundedFormula n := | |
| exMem E (exMem V.succ (exMem V.succ.succ | |
| (.conj (tripleMembershipFormula 2 1 a.succ.succ.succ placements.succ.succ.succ) | |
| (.conj (tripleMembershipFormula 2 0 b.succ.succ.succ placements.succ.succ.succ) | |
| (pairMembershipFormula 1 0 overlaps.succ.succ.succ))))) | |
| theorem truth_externalFlatCoordinateFormula {n} (E U G old m A a b : Fin n) (env : Fin n → ZFSet.{u}) : | |
| Truth (externalFlatCoordinateFormula E U G old m A a b) env ↔ | |
| ExternalFlatCoordinateCode (env E) (env U) (env G) (env old) (env m) (env A) (env a) (env b) := by | |
| simp only [externalFlatCoordinateFormula, Truth, truth_exMem, truth_orderedPairFormula, | |
| truth_pairMembershipFormula, truth_tripleMembershipFormula, ExternalFlatCoordinateCode] | |
| rfl | |
| theorem truth_externalFlatTileStepFormula {n} (E V placements overlaps a b : Fin n) (env : Fin n → ZFSet.{u}) : | |
| Truth (externalFlatTileStepFormula E V placements overlaps a b) env ↔ | |
| ExternalFlatTileStepCode (env E) (env V) (env placements) (env overlaps) (env a) (env b) := by | |
| simp only [externalFlatTileStepFormula, Truth, truth_exMem, truth_pairMembershipFormula, | |
| truth_tripleMembershipFormula, ExternalFlatTileStepCode] | |
| rfl | |
| def externalFlatStepFormula {n} (E U G V old m A placements overlaps a b : Fin n) : BoundedFormula n := | |
| disj (disj (externalFlatCoordinateFormula E U G old m A a b) (externalFlatTileStepFormula E V placements overlaps a b)) | |
| (disj (externalFlatCoordinateFormula E U G old m A b a) (externalFlatTileStepFormula E V placements overlaps b a)) | |
| theorem truth_externalFlatStepFormula {n} | |
| (E U G V old m A placements overlaps a b : Fin n) (env : Fin n → ZFSet.{u}) : | |
| Truth (externalFlatStepFormula E U G V old m A placements overlaps a b) env ↔ | |
| ExternalFlatStepCode (env E) (env U) (env G) (env V) (env old) (env m) (env A) | |
| (env placements) (env overlaps) (env a) (env b) := by | |
| simp only [externalFlatStepFormula, truth_disj, truth_externalFlatCoordinateFormula, | |
| truth_externalFlatTileStepFormula, ExternalFlatStepCode] | |
| def externalFlatStepEntryFormula {n} (z L E U G V old m A placements overlaps : Fin n) : BoundedFormula n := | |
| exMem L (exMem L.succ (.conj (orderedPairFormula z.succ.succ 1 0) | |
| (externalFlatStepFormula E.succ.succ U.succ.succ G.succ.succ V.succ.succ old.succ.succ | |
| m.succ.succ A.succ.succ placements.succ.succ overlaps.succ.succ 1 0))) | |
| theorem truth_externalFlatStepEntryFormula {n} | |
| (z L E U G V old m A placements overlaps : Fin n) (env : Fin n → ZFSet.{u}) : | |
| Truth (externalFlatStepEntryFormula z L E U G V old m A placements overlaps) env ↔ | |
| ∃ a ∈ env L, ∃ b ∈ env L, env z = ZFSet.pair a b ∧ | |
| ExternalFlatStepCode (env E) (env U) (env G) (env V) (env old) (env m) (env A) | |
| (env placements) (env overlaps) a b := by | |
| simp only [externalFlatStepEntryFormula, Truth, truth_exMem, truth_orderedPairFormula, | |
| truth_externalFlatStepFormula] | |
| rfl | |
| end BoundedFormula | |
| namespace TransitiveGround | |
| variable (M : TransitiveGround.{u}) | |
| theorem externalFlatStepGraph_mem | |
| (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| {E U G V old m A placements overlaps : ZFSet.{u}} | |
| (hE : E ∈ M.sets) (hU : U ∈ M.sets) (hG : G ∈ M.sets) (hV : V ∈ M.sets) | |
| (hOld : old ∈ M.sets) (hm : m ∈ M.sets) (hA : A ∈ M.sets) | |
| (hPlacements : placements ∈ M.sets) (hOverlaps : overlaps ∈ M.sets) : | |
| externalFlatStepGraph E U G V old m A placements overlaps ∈ M.sets := by | |
| have hL := M.prod_mem pairing unions powers separation hE hU | |
| let params := extend (ZFSet.prod E U) (extend E (extend U (extend G (extend V (extend old | |
| (extend m (extend A (extend placements (extend overlaps Fin.elim0))))))))) | |
| have selected := M.bounded_separation_mem separation | |
| (BoundedFormula.externalFlatStepEntryFormula 0 1 2 3 4 5 6 7 8 9 10) params | |
| (Fin.cases hL (Fin.cases hE (Fin.cases hU (Fin.cases hG (Fin.cases hV (Fin.cases hOld | |
| (Fin.cases hm (Fin.cases hA (Fin.cases hPlacements (Fin.cases hOverlaps (fun i => Fin.elim0 i))))))))))) | |
| (M.prod_mem pairing unions powers separation hL hL) | |
| have equal : ZFSet.sep (fun z => BoundedFormula.Truth | |
| (BoundedFormula.externalFlatStepEntryFormula 0 1 2 3 4 5 6 7 8 9 10) (extend z params)) | |
| (ZFSet.prod (ZFSet.prod E U) (ZFSet.prod E U)) = externalFlatStepGraph E U G V old m A placements overlaps := by | |
| apply ZFSet.ext | |
| intro z | |
| rw [externalFlatStepGraph, ZFSet.mem_sep, ZFSet.mem_sep] | |
| exact and_congr Iff.rfl (BoundedFormula.truth_externalFlatStepEntryFormula 0 1 2 3 4 5 6 7 8 9 10 _) | |
| exact equal ▸ selected | |
| end TransitiveGround | |
| end PartitionPilot.Forcing | |
| namespace PartitionPilot.Forcing | |
| open SetRealization Compression.RecursiveMaps Attachment CosetGeometry | |
| universe u | |
| variable {A J R : Type u} [Group J] {P : MeetOrder A} | |
| variable (f : TileRequests.Family P R) (a : OrderAction J P) | |
| variable (s : Presentation (External J f.Letters)) (t : Presentation A) (g : Presentation J) | |
| variable (v : Presentation (Sigma fun r => Option (f.Child r) × A)) | |
| variable {oldGraph mulGraph actGraph placements overlaps : ZFSet.{u}} | |
| variable (oldEntries : ∀ j w, ZFSet.pair (g.encode j) (s.encode w) ∈ oldGraph ↔ old J f.Letters j = w) | |
| variable (mulEntries : ∀ w k l, ZFSet.pair (ZFSet.pair (s.encode w) (s.encode k)) (s.encode l) ∈ mulGraph ↔ w * k = l) | |
| variable (actEntries : ∀ j x y, ZFSet.pair (ZFSet.pair (g.encode j) (t.encode x)) (t.encode y) ∈ actGraph ↔ (a.iso j).toFun x = y) | |
| variable (placed : ∀ w u z, ZFSet.pair (ZFSet.pair (s.encode w) (v.encode u)) ((s.product t).encode z) ∈ placements ↔ | |
| z = (f.flatWord w u.1 u.2.1, u.2.2)) | |
| variable (overlapSource : ∀ u w, ZFSet.pair (v.encode u) (v.encode w) ∈ overlaps → u.1 = w.1) | |
| variable (overlapEntries : ∀ r i j x y, | |
| ZFSet.pair (v.encode ⟨r, i, x⟩) (v.encode ⟨r, j, y⟩) ∈ overlaps ↔ | |
| (f.flatVertex r i).toFun x = (f.flatVertex r j).toFun y) | |
| include oldEntries mulEntries actEntries in | |
| theorem externalFlatCoordinate_to_step (x y : f.FlatLabel (J := J)) | |
| (code : ExternalFlatCoordinateCode s.carrier t.carrier g.carrier oldGraph mulGraph actGraph | |
| ((s.product t).encode x) ((s.product t).encode y)) : f.FlatStep a x y := by | |
| obtain ⟨w, hw, k, hk, l, hl, j, hj, b, hb, c, hc, oldEntry, mulEntry, actEntry, left, right⟩ := code | |
| obtain ⟨w, rfl⟩ := (s.mem_carrier w).1 hw | |
| obtain ⟨k, rfl⟩ := (s.mem_carrier k).1 hk | |
| obtain ⟨l, rfl⟩ := (s.mem_carrier l).1 hl | |
| obtain ⟨j, rfl⟩ := (g.mem_carrier j).1 hj | |
| obtain ⟨b, rfl⟩ := (t.mem_carrier b).1 hb | |
| obtain ⟨c, rfl⟩ := (t.mem_carrier c).1 hc | |
| have hx : x = (l, b) := (s.product t).injective left | |
| have hy : y = (w, c) := (s.product t).injective right | |
| rw [hx, hy, ← (mulEntries w k l).1 mulEntry, ← (oldEntries j k).1 oldEntry, | |
| ← (actEntries j b c).1 actEntry] | |
| exact .coordinate w j b | |
| include placed overlapSource overlapEntries in | |
| theorem externalFlatTileStep_to_step (x y : f.FlatLabel (J := J)) | |
| (code : ExternalFlatTileStepCode s.carrier v.carrier placements overlaps | |
| ((s.product t).encode x) ((s.product t).encode y)) : f.FlatStep a x y := by | |
| obtain ⟨w, hw, u, hu, z, hz, left, right, equal⟩ := code | |
| obtain ⟨w, rfl⟩ := (s.mem_carrier w).1 hw | |
| obtain ⟨⟨r, i, b⟩, rfl⟩ := (v.mem_carrier u).1 hu | |
| obtain ⟨⟨r', j, c⟩, rfl⟩ := (v.mem_carrier z).1 hz | |
| have same : r = r' := overlapSource ⟨r, i, b⟩ ⟨r', j, c⟩ equal | |
| cases same | |
| rw [(placed w ⟨r, i, b⟩ x).1 left, (placed w ⟨r, j, c⟩ y).1 right] | |
| exact .tile w r i j b c ((overlapEntries r i j b c).1 equal) | |
| include oldEntries mulEntries actEntries placed overlapSource overlapEntries in | |
| theorem pair_mem_externalFlatStepGraph_iff (x y : f.FlatLabel (J := J)) : | |
| ZFSet.pair ((s.product t).encode x) ((s.product t).encode y) ∈ | |
| externalFlatStepGraph s.carrier t.carrier g.carrier v.carrier oldGraph mulGraph actGraph placements overlaps ↔ | |
| f.FlatStep a x y := by | |
| rw [pair_mem_externalFlatStepGraph] | |
| constructor | |
| · rintro ⟨_, _, h⟩ | |
| rcases h with (coordinate | tile) | (coordinate | tile) | |
| · exact externalFlatCoordinate_to_step f a s t g oldEntries mulEntries actEntries x y coordinate | |
| · exact externalFlatTileStep_to_step f a s t v placed overlapSource overlapEntries x y tile | |
| · exact (externalFlatCoordinate_to_step f a s t g oldEntries mulEntries actEntries y x coordinate).symm | |
| · exact (externalFlatTileStep_to_step f a s t v placed overlapSource overlapEntries y x tile).symm | |
| · intro h | |
| refine ⟨(s.product t).encode_mem x, (s.product t).encode_mem y, ?_⟩ | |
| induction h with | |
| | coordinate w j b => | |
| apply Or.inl | |
| apply Or.inl | |
| exact ⟨s.encode w, s.encode_mem w, s.encode (old J f.Letters j), s.encode_mem _, | |
| s.encode (w * old J f.Letters j), s.encode_mem _, g.encode j, g.encode_mem j, | |
| t.encode b, t.encode_mem b, t.encode ((a.iso j).toFun b), t.encode_mem _, | |
| (oldEntries j _).2 rfl, (mulEntries w _ _).2 rfl, (actEntries j b _).2 rfl, rfl, rfl⟩ | |
| | tile w r i j b c equal => | |
| apply Or.inl | |
| apply Or.inr | |
| exact ⟨s.encode w, s.encode_mem w, v.encode ⟨r, i, b⟩, v.encode_mem _, | |
| v.encode ⟨r, j, c⟩, v.encode_mem _, (placed w ⟨r, i, b⟩ _).2 rfl, | |
| (placed w ⟨r, j, c⟩ _).2 rfl, (overlapEntries r i j b c).2 equal⟩ | |
| | symm h ih => exact ih.symm | |
| end PartitionPilot.Forcing | |
| namespace PartitionPilot.Forcing | |
| open SetFormula SetRealization | |
| universe u | |
| namespace GroundCompressionCompletion | |
| variable {M : TransitiveGround.{u}} {initial : RecursiveStateData.{u}} | |
| variable {I Sources Reps G m one T τ : ZFSet.{u}} | |
| variable (completion : GroundCompressionCompletion M initial I Sources Reps G m one T τ) | |
| noncomputable def externalVertices (P r μ A : ZFSet.{u}) : ZFSet.{u} := | |
| externalTileVertices (externalRequestCarrier I P (externalRectangles P G r μ A)) | |
| (externalRectangles P G r μ A) (completion.algebra.union.fields 0) | |
| noncomputable def externalOverlaps (P r μ A : ZFSet.{u}) : ZFSet.{u} := | |
| externalRequestOverlapGraph (externalRequestCarrier I P (externalRectangles P G r μ A)) | |
| P G (externalRectangles P G r μ A) completion.externalMaps | |
| (completion.algebra.union.fields 0) (completion.algebra.union.fields 1) (completion.algebra.union.fields 12) | |
| noncomputable def externalPlacements (P r μ A : ZFSet.{u}) : ZFSet.{u} := | |
| let S := externalChildLetters I P (externalRectangles P G r μ A) | |
| externalFlatPlacements (M.externalGroupCarrier G S m one) | |
| (externalRequestCarrier I P (externalRectangles P G r μ A)) | |
| (completion.algebra.union.fields 0) (completion.externalVertices P r μ A) S | |
| (M.externalChildGenerators G S m one) (M.externalGroupMultiplication G S m one) | |
| noncomputable def externalFlatSteps (P r μ A : ZFSet.{u}) : ZFSet.{u} := | |
| let S := externalChildLetters I P (externalRectangles P G r μ A) | |
| externalFlatStepGraph (M.externalGroupCarrier G S m one) (completion.algebra.union.fields 0) G | |
| (completion.externalVertices P r μ A) (M.externalOldInclusion G S m one) | |
| (M.externalGroupMultiplication G S m one) (completion.algebra.union.fields 12) | |
| (completion.externalPlacements P r μ A) (completion.externalOverlaps P r μ A) | |
| noncomputable def externalFlatEquivalence (P r μ A : ZFSet.{u}) : ZFSet.{u} := | |
| M.finitePathClosure | |
| (ZFSet.prod (M.externalGroupCarrier G (externalChildLetters I P (externalRectangles P G r μ A)) m one) | |
| (completion.algebra.union.fields 0)) (completion.externalFlatSteps P r μ A) | |
| noncomputable def externalPointCarrier (P r μ A : ZFSet.{u}) : ZFSet.{u} := | |
| equivalenceClasses | |
| (ZFSet.prod (M.externalGroupCarrier G (externalChildLetters I P (externalRectangles P G r μ A)) m one) | |
| (completion.algebra.union.fields 0)) (completion.externalFlatEquivalence P r μ A) | |
| noncomputable def externalPointClassifier (P r μ A : ZFSet.{u}) : ZFSet.{u} := | |
| equivalenceClassifier | |
| (ZFSet.prod (M.externalGroupCarrier G (externalChildLetters I P (externalRectangles P G r μ A)) m one) | |
| (completion.algebra.union.fields 0)) (completion.externalFlatEquivalence P r μ A) | |
| end GroundCompressionCompletion | |
| namespace GroundExternalGeometryInputs | |
| variable {M : TransitiveGround.{u}} {initial : RecursiveStateData.{u}} | |
| variable {I Sources Reps G m inv one T τ P r μ A : ZFSet.{u}} | |
| variable {completion : GroundCompressionCompletion M initial I Sources Reps G m one T τ} | |
| variable (data : GroundExternalGeometryInputs M initial I Sources Reps G m inv one T τ P r μ A completion) | |
| include data | |
| theorem flat_relations_ground | |
| (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| (hP : P ∈ M.sets) (hG : G ∈ M.sets) : | |
| completion.externalVertices P r μ A ∈ M.sets ∧ completion.externalOverlaps P r μ A ∈ M.sets ∧ | |
| completion.externalPlacements P r μ A ∈ M.sets ∧ completion.externalFlatSteps P r μ A ∈ M.sets := by | |
| have vertices := M.externalTileVertices_mem pairing unions powers separation | |
| data.words.requests_ground data.words.rectangles_ground (completion.algebra.union.ground 0) | |
| have overlaps := M.externalRequestOverlapGraph_mem pairing unions powers separation | |
| data.words.requests_ground hP hG data.words.rectangles_ground data.words.maps_ground | |
| (completion.algebra.union.ground 0) (completion.algebra.union.ground 1) (completion.algebra.union.ground 12) | |
| have placements := M.externalFlatPlacements_mem pairing unions powers separation | |
| data.group.carrier_mem data.words.requests_ground (completion.algebra.union.ground 0) vertices | |
| data.words.letters_ground data.generators_ground data.group.multiplication_mem | |
| exact ⟨vertices, overlaps, placements, M.externalFlatStepGraph_mem pairing unions powers separation | |
| data.group.carrier_mem (completion.algebra.union.ground 0) hG vertices data.old_inclusion_ground | |
| data.group.multiplication_mem (completion.algebra.union.ground 12) placements overlaps⟩ | |
| theorem point_quotient_ground | |
| (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| (infinite : Realize M.sets SetFormula.infinity Fin.elim0) | |
| (hP : P ∈ M.sets) (hG : G ∈ M.sets) : | |
| let L := ZFSet.prod (M.externalGroupCarrier G (externalChildLetters I P (externalRectangles P G r μ A)) m one) | |
| (completion.algebra.union.fields 0) | |
| completion.externalFlatEquivalence P r μ A ∈ M.sets ∧ | |
| EquivalenceRelationCode L (completion.externalFlatEquivalence P r μ A) ∧ | |
| completion.externalPointCarrier P r μ A ∈ M.sets ∧ completion.externalPointClassifier P r μ A ∈ M.sets ∧ | |
| ZFSet.IsFunc L (completion.externalPointCarrier P r μ A) (completion.externalPointClassifier P r μ A) ∧ | |
| (∀ C ∈ completion.externalPointCarrier P r μ A, ∃ x ∈ L, | |
| ZFSet.pair x C ∈ completion.externalPointClassifier P r μ A) ∧ | |
| (∀ x y C D, ZFSet.pair x C ∈ completion.externalPointClassifier P r μ A → | |
| ZFSet.pair y D ∈ completion.externalPointClassifier P r μ A → | |
| (C = D ↔ ZFSet.pair x y ∈ completion.externalFlatEquivalence P r μ A)) := by | |
| dsimp only | |
| let L := ZFSet.prod (M.externalGroupCarrier G (externalChildLetters I P (externalRectangles P G r μ A)) m one) | |
| (completion.algebra.union.fields 0) | |
| let p := SetMembers.presentation L | |
| let relation : SetMembers L → SetMembers L → Prop := fun x y => | |
| ZFSet.pair (SetMembers.raw x) (SetMembers.raw y) ∈ completion.externalFlatSteps P r μ A | |
| have hL : L ∈ M.sets := M.prod_mem pairing unions powers separation | |
| data.group.carrier_mem (completion.algebra.union.ground 0) | |
| exact M.finitePathQuotient_spec pairing unions separation infinite p relation (fun _ _ => Iff.rfl) hL powers | |
| (data.flat_relations_ground pairing unions powers separation hP hG).2.2.2 | |
| (fun _ _ step => externalFlatStepGraph_symmetric step) | |
| end GroundExternalGeometryInputs | |
| end PartitionPilot.Forcing | |
| namespace PartitionPilot.Forcing.GroundCompressionCompletion | |
| open SetRealization Compression Compression.RecursiveMaps | |
| universe u | |
| variable {M : TransitiveGround.{u}} {initial : RecursiveStateData.{u}} | |
| variable {I Sources Reps G m inv one T τ P0 r0 μ0 A0 : ZFSet.{u}} | |
| variable (completion : GroundCompressionCompletion M initial I Sources Reps G m one T τ) | |
| variable (group : GroupCode G m inv one) (oldAction : PosetActionCode G P0 m one r0 A0) | |
| variable (compression : CompressionOriginalData P0 r0 μ0 A0 G | |
| (completion.algebra.union.fields 0) (completion.algebra.union.fields 1) | |
| (completion.algebra.union.fields 2) (completion.algebra.union.fields 12)) | |
| local notation "f" => completion.externalFamily group oldAction compression | |
| local notation "U" => completion.algebra.union.fields 0 | |
| local notation "ru" => completion.algebra.union.fields 1 | |
| local notation "au" => completion.algebra.union.fields 12 | |
| local notation "Rects" => externalRectangles P0 G r0 μ0 A0 | |
| local notation "Requests" => externalRequestCarrier I P0 Rects | |
| local notation "vcode" => completion.externalFamilyVertexCode group oldAction compression | |
| theorem externalFamily_overlapCode_iff (r : ExternalRequestIndex I P0 Rects) | |
| (i j : Option ((f).Child r)) (x y : SetMembers U) : | |
| ExternalRequestOverlapCode P0 G Rects completion.externalMaps (⋃₀ ⋃₀ completion.externalMaps) ru au | |
| (natSetCode 0) (natSetCode 1) (natSetCode 2) (externalRequestIndexCode r) | |
| (vcode r i) (SetMembers.raw x) (vcode r j) (SetMembers.raw y) ↔ | |
| ((f).flatVertex r i).toFun x = ((f).flatVertex r j).toFun y := by | |
| rcases r with task | (point | rect) | |
| · rcases i with _ | ⟨⟨⟨⟩⟩⟩ <;> rcases j with _ | ⟨⟨⟨⟩⟩⟩ | |
| all_goals simp only [ExternalRequestOverlapCode, externalRequestIndexCode, | |
| externalFamilyVertexCode_root, externalFamilyVertexCode_compression, | |
| completion.externalOverlapForward_compression, natSetCode_injective.eq_iff] | |
| · simpa using (completion.externalFamily_diagonal_iff group oldAction compression (.inl task) none x y).symm | |
| · simpa using (completion.externalFamily_compression_overlap group oldAction compression task x y).symm | |
| · simpa only [Nat.one_ne_zero, Nat.zero_ne_one, false_and, true_and, or_false, false_or, eq_comm] using | |
| (completion.externalFamily_compression_overlap group oldAction compression task y x).symm | |
| · simpa using (completion.externalFamily_diagonal_iff group oldAction compression (.inl task) (some ⟨()⟩) x y).symm | |
| · rcases i with _ | ⟨⟨⟨⟩⟩⟩ <;> rcases j with _ | ⟨⟨⟨⟩⟩⟩ | |
| all_goals simp only [ExternalRequestOverlapCode, externalRequestIndexCode, | |
| externalFamilyVertexCode_root, externalFamilyVertexCode_separation, | |
| completion.externalOverlapForward_separation, natSetCode_injective.eq_iff] | |
| · simpa using (completion.externalFamily_diagonal_iff group oldAction compression (.inr (.inl point)) none x y).symm | |
| · simpa using (completion.externalFamily_separation_overlap group oldAction compression point x y).symm | |
| · simpa only [Nat.one_ne_zero, Nat.zero_ne_one, false_and, true_and, or_false, false_or, eq_comm] using | |
| (completion.externalFamily_separation_overlap group oldAction compression point y x).symm | |
| · simpa using (completion.externalFamily_diagonal_iff group oldAction compression (.inr (.inl point)) (some ⟨()⟩) x y).symm | |
| · rcases i with _ | ⟨⟨a⟩⟩ <;> rcases j with _ | ⟨⟨b⟩⟩ | |
| · simp only [ExternalRequestOverlapCode, externalRequestIndexCode, | |
| externalFamilyVertexCode_root, completion.externalOverlapForward_rectangle, natSetCode_injective.eq_iff] | |
| simpa using (completion.externalFamily_diagonal_iff group oldAction compression (.inr (.inr rect)) none x y).symm | |
| · cases b <;> simp only [ExternalRequestOverlapCode, externalRequestIndexCode, | |
| externalFamilyVertexCode_root, externalFamilyVertexCode_rectangle, Bool.false_eq_true, ite_false, ite_true, | |
| completion.externalOverlapForward_rectangle, natSetCode_injective.eq_iff] | |
| · simpa using (completion.externalFamily_rectangle_first_overlap group oldAction compression rect x y).symm | |
| · simpa using (completion.externalFamily_rectangle_second_overlap group oldAction compression rect x y).symm | |
| · cases a <;> simp only [ExternalRequestOverlapCode, externalRequestIndexCode, | |
| externalFamilyVertexCode_root, externalFamilyVertexCode_rectangle, Bool.false_eq_true, ite_false, ite_true, | |
| completion.externalOverlapForward_rectangle, natSetCode_injective.eq_iff] | |
| · simpa [eq_comm] using (completion.externalFamily_rectangle_first_overlap group oldAction compression rect y x).symm | |
| · simpa [eq_comm] using (completion.externalFamily_rectangle_second_overlap group oldAction compression rect y x).symm | |
| · cases a <;> cases b <;> simp only [ExternalRequestOverlapCode, externalRequestIndexCode, | |
| externalFamilyVertexCode_rectangle, Bool.false_eq_true, ite_false, ite_true, | |
| completion.externalOverlapForward_rectangle, natSetCode_injective.eq_iff] | |
| · simpa using (completion.externalFamily_diagonal_iff group oldAction compression (.inr (.inr rect)) (some ⟨false⟩) x y).symm | |
| · simpa using (completion.externalFamily_rectangle_children_overlap group oldAction compression rect x y).symm | |
| · simpa [eq_comm] using (completion.externalFamily_rectangle_children_overlap group oldAction compression rect y x).symm | |
| · simpa using (completion.externalFamily_diagonal_iff group oldAction compression (.inr (.inr rect)) (some ⟨true⟩) x y).symm | |
| theorem externalFamilyVertexCode_mem_tags (r : ExternalRequestIndex I P0 Rects) | |
| (i : Option ((f).Child r)) : vcode r i ∈ externalRequestTags := by | |
| have range := (completion.externalFamilyVertexCode_range group oldAction compression r _).2 ⟨i, rfl⟩ | |
| rcases range with equal | equal | ⟨_, equal⟩ <;> rw [equal] <;> simp [externalRequestTags] | |
| theorem externalOverlaps_same_request | |
| (x y : Sigma fun r : ExternalRequestIndex I P0 Rects => Option ((f).Child r) × SetMembers U) | |
| (entry : ZFSet.pair | |
| ((completion.externalFamilyTileVertexPresentation group oldAction compression).encode x) | |
| ((completion.externalFamilyTileVertexPresentation group oldAction compression).encode y) ∈ | |
| completion.externalOverlaps P0 r0 μ0 A0) : x.1 = y.1 := by | |
| obtain ⟨_, _, q, _, i, _, a, _, j, _, b, _, left, right, _⟩ := | |
| (pair_mem_externalRequestOverlapGraph _ _ _ _ _ _ _ _ _ _).1 entry | |
| exact externalRequestIndexCode_injective I P0 Rects | |
| (((ZFSet.pair_inj.1 (ZFSet.pair_inj.1 left).1).1).trans | |
| ((ZFSet.pair_inj.1 (ZFSet.pair_inj.1 right).1).1).symm) | |
| theorem externalOverlaps_entry_iff (r : ExternalRequestIndex I P0 Rects) | |
| (i j : Option ((f).Child r)) (x y : SetMembers U) : | |
| ZFSet.pair | |
| ((completion.externalFamilyTileVertexPresentation group oldAction compression).encode ⟨r, i, x⟩) | |
| ((completion.externalFamilyTileVertexPresentation group oldAction compression).encode ⟨r, j, y⟩) ∈ | |
| completion.externalOverlaps P0 r0 μ0 A0 ↔ | |
| ((f).flatVertex r i).toFun x = ((f).flatVertex r j).toFun y := by | |
| rw [← completion.externalFamily_overlapCode_iff group oldAction compression] | |
| constructor | |
| · intro entry | |
| obtain ⟨_, _, q, _, i', _, a, _, j', _, b, _, left, right, code⟩ := | |
| (pair_mem_externalRequestOverlapGraph _ _ _ _ _ _ _ _ _ _).1 entry | |
| obtain ⟨leftPair, rfl⟩ := ZFSet.pair_inj.1 left | |
| obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 leftPair | |
| obtain ⟨rightPair, rfl⟩ := ZFSet.pair_inj.1 right | |
| obtain ⟨_, rfl⟩ := ZFSet.pair_inj.1 rightPair | |
| exact code | |
| · intro code | |
| exact (pair_mem_externalRequestOverlapGraph _ _ _ _ _ _ _ _ _ _).2 | |
| ⟨(completion.externalFamilyTileVertexPresentation group oldAction compression).encode_mem ⟨r, i, x⟩, | |
| (completion.externalFamilyTileVertexPresentation group oldAction compression).encode_mem ⟨r, j, y⟩, | |
| externalRequestIndexCode r, (externalRequestPresentation I P0 Rects).encode_mem r, | |
| vcode r i, completion.externalFamilyVertexCode_mem_tags group oldAction compression r i, | |
| SetMembers.raw x, SetMembers.raw_mem x, | |
| vcode r j, completion.externalFamilyVertexCode_mem_tags group oldAction compression r j, | |
| SetMembers.raw y, SetMembers.raw_mem y, rfl, rfl, code⟩ | |
| end PartitionPilot.Forcing.GroundCompressionCompletion | |
| namespace PartitionPilot.Forcing.GroundCompressionCompletion | |
| open SetRealization SetFormula Compression.RecursiveMaps.CosetGeometry | |
| universe u | |
| variable {M : TransitiveGround.{u}} {initial : RecursiveStateData.{u}} | |
| variable {I Sources Reps G m inv one T τ P0 r0 μ0 A0 : ZFSet.{u}} | |
| variable (completion : GroundCompressionCompletion M initial I Sources Reps G m one T τ) | |
| variable (group : GroupCode G m inv one) (oldAction : PosetActionCode G P0 m one r0 A0) | |
| variable (compression : CompressionOriginalData P0 r0 μ0 A0 G | |
| (completion.algebra.union.fields 0) (completion.algebra.union.fields 1) | |
| (completion.algebra.union.fields 2) (completion.algebra.union.fields 12)) | |
| local notation "family" => completion.externalFamily group oldAction compression | |
| local notation "letters" => completion.externalFamilyLetterPresentation group oldAction compression | |
| local notation "vertices" => completion.externalFamilyTileVertexPresentation group oldAction compression | |
| local notation "U" => completion.algebra.union.fields 0 | |
| local notation "Rects" => externalRectangles P0 G r0 μ0 A0 | |
| local notation "S" => externalChildLetters I P0 Rects | |
| local notation "E" => M.externalGroupCarrier G S m one | |
| local notation "vcode" => completion.externalFamilyVertexCode group oldAction compression | |
| theorem externalFamily_vertex_letter (r : ExternalRequestIndex I P0 Rects) | |
| (i : Option ((family).Child r)) (s : ZFSet.{u}) : | |
| ((vcode r i = natSetCode 1 ∧ s = ZFSet.pair (externalRequestIndexCode r) (natSetCode 0)) ∨ | |
| (vcode r i = natSetCode 2 ∧ s = ZFSet.pair (externalRequestIndexCode r) (natSetCode 1))) ↔ | |
| ∃ child : (family).Child r, i = some child ∧ s = (letters).encode ⟨r, child⟩ := by | |
| rcases r with task | (point | rect) | |
| · rcases i with _ | ⟨⟨⟨⟩⟩⟩ | |
| · simp [externalFamilyVertexCode_root, natSetCode_injective.eq_iff] | |
| · constructor | |
| · rintro (⟨_, equal⟩ | ⟨equal, _⟩) | |
| · exact ⟨⟨()⟩, rfl, equal⟩ | |
| · have bad : (1 : Nat) = 2 := natSetCode_injective equal | |
| omega | |
| · rintro ⟨⟨⟨⟩⟩, _, equal⟩ | |
| exact Or.inl ⟨rfl, equal⟩ | |
| · rcases i with _ | ⟨⟨⟨⟩⟩⟩ | |
| · simp [externalFamilyVertexCode_root, natSetCode_injective.eq_iff] | |
| · constructor | |
| · rintro (⟨_, equal⟩ | ⟨equal, _⟩) | |
| · exact ⟨⟨()⟩, rfl, equal⟩ | |
| · have bad : (1 : Nat) = 2 := natSetCode_injective equal | |
| omega | |
| · rintro ⟨⟨⟨⟩⟩, _, equal⟩ | |
| exact Or.inl ⟨rfl, equal⟩ | |
| · rcases i with _ | ⟨⟨b⟩⟩ | |
| · simp [externalFamilyVertexCode_root, natSetCode_injective.eq_iff] | |
| · cases b | |
| · constructor | |
| · rintro (⟨_, equal⟩ | ⟨equal, _⟩) | |
| · exact ⟨⟨false⟩, rfl, equal⟩ | |
| · have bad : (1 : Nat) = 2 := natSetCode_injective equal | |
| omega | |
| · rintro ⟨child, equal, code⟩ | |
| have same := Option.some.inj equal | |
| subst child | |
| exact Or.inl ⟨rfl, code⟩ | |
| · constructor | |
| · rintro (⟨equal, _⟩ | ⟨_, equal⟩) | |
| · have bad : (2 : Nat) = 1 := natSetCode_injective equal | |
| omega | |
| · exact ⟨⟨true⟩, rfl, equal⟩ | |
| · rintro ⟨child, equal, code⟩ | |
| have same := Option.some.inj equal | |
| subst child | |
| exact Or.inr ⟨rfl, code⟩ | |
| variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| variable (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| variable (infinite : Realize M.sets infinity Fin.elim0) | |
| variable (hG : G ∈ M.sets) | |
| variable (hLetters : externalChildLetters I P0 (externalRectangles P0 G r0 μ0 A0) ∈ M.sets) | |
| local notation "sGroup" => completion.externalFamilyGroupPresentation group oldAction compression | |
| pairing unions powers separation infinite hG hLetters | |
| include pairing unions powers separation infinite hG hLetters | |
| theorem externalFlatVertexWordCode_iff (r : ExternalRequestIndex I P0 Rects) | |
| (i : Option ((family).Child r)) : | |
| letI := group.toGroup | |
| ∀ w v : External (SetMembers G) (family).Letters, | |
| ExternalFlatVertexWordCode E S (M.externalChildGenerators G S m one) | |
| (M.externalGroupMultiplication G S m one) (natSetCode 0) (natSetCode 1) (natSetCode 2) | |
| (externalRequestIndexCode r) (vcode r i) ((sGroup).encode w) ((sGroup).encode v) ↔ | |
| v = (family).flatWord w r i := by | |
| let := group.toGroup | |
| intro w v | |
| have carrier := completion.externalFamilyGroupPresentation_carrier group oldAction compression | |
| pairing unions powers separation infinite hG hLetters | |
| have generators := completion.externalFamilyGroupPresentation_generators group oldAction compression | |
| pairing unions powers separation infinite hG hLetters | |
| have multiplication := completion.externalFamilyGroupPresentation_multiplication group oldAction compression | |
| pairing unions powers separation infinite hG hLetters | |
| constructor | |
| · rintro (⟨root, equal⟩ | ⟨letter, _, k, hk, childFields, gen, mul⟩) | |
| · have vertex : i = none := completion.externalFamilyVertexCode_injective group oldAction compression r root | |
| subst i | |
| exact (sGroup).injective equal | |
| · obtain ⟨child, rfl, rfl⟩ := (completion.externalFamily_vertex_letter group oldAction compression r i letter).1 childFields | |
| obtain ⟨g, rfl⟩ := ((sGroup).mem_carrier k).1 (carrier.symm ▸ hk) | |
| rw [generators] at gen | |
| have generatorEq := ((letters).pair_mem_graph (sGroup) _ ⟨r, child⟩ g).1 gen | |
| rw [multiplication] at mul | |
| have product := (((sGroup).product (sGroup)).pair_mem_graph (sGroup) (fun p => p.1 * p.2) (w, g) v).1 mul | |
| exact product.symm.trans (congrArg (fun g => w * g) generatorEq.symm) | |
| · intro equal | |
| subst v | |
| cases i with | |
| | none => exact Or.inl ⟨rfl, rfl⟩ | |
| | some child => | |
| let g := generator (SetMembers G) (family).Letters ⟨r, child⟩ | |
| refine Or.inr ⟨(letters).encode ⟨r, child⟩, (letters).encode_mem ⟨r, child⟩, | |
| (sGroup).encode g, carrier ▸ (sGroup).encode_mem g, | |
| (completion.externalFamily_vertex_letter group oldAction compression r (some child) _).2 ⟨child, rfl, rfl⟩, ?_, ?_⟩ | |
| · rw [generators] | |
| exact ((letters).pair_mem_graph (sGroup) _ ⟨r, child⟩ g).2 rfl | |
| · rw [multiplication] | |
| exact (((sGroup).product (sGroup)).pair_mem_graph (sGroup) (fun p => p.1 * p.2) (w, g) (w * g)).2 rfl | |
| theorem externalPlacements_entry_iff : | |
| letI := group.toGroup | |
| ∀ (w : External (SetMembers G) (family).Letters) | |
| (v : Sigma fun r : ExternalRequestIndex I P0 Rects => Option ((family).Child r) × SetMembers U) | |
| (z : External (SetMembers G) (family).Letters × SetMembers U), | |
| ZFSet.pair (ZFSet.pair ((sGroup).encode w) ((vertices).encode v)) | |
| (((sGroup).product (SetMembers.presentation U)).encode z) ∈ completion.externalPlacements P0 r0 μ0 A0 ↔ | |
| z = ((family).flatWord w v.1 v.2.1, v.2.2) := by | |
| let := group.toGroup | |
| intro w v z | |
| rcases v with ⟨r, i, x⟩ | |
| have carrier := completion.externalFamilyGroupPresentation_carrier group oldAction compression | |
| pairing unions powers separation infinite hG hLetters | |
| constructor | |
| · intro entry | |
| obtain ⟨_, _, _, q, _, j, _, y, _, k, _, left, right, word⟩ := | |
| (triple_mem_externalFlatPlacements _ _ _ _ _ _ _ _ _ _).1 entry | |
| obtain ⟨leftPair, rfl⟩ := ZFSet.pair_inj.1 left | |
| obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 leftPair | |
| obtain ⟨rfl, point⟩ := ZFSet.pair_inj.1 right | |
| exact Prod.ext | |
| ((completion.externalFlatVertexWordCode_iff group oldAction compression | |
| pairing unions powers separation infinite hG hLetters r i w z.1).1 word) | |
| (SetMembers.raw_injective U point) | |
| · intro equal | |
| subst z | |
| apply (triple_mem_externalFlatPlacements _ _ _ _ _ _ _ _ _ _).2 | |
| refine ⟨carrier ▸ (sGroup).encode_mem w, (vertices).encode_mem ⟨r, i, x⟩, | |
| ZFSet.pair_mem_prod.2 ⟨carrier ▸ (sGroup).encode_mem _, SetMembers.raw_mem x⟩, | |
| externalRequestIndexCode r, (externalRequestPresentation I P0 Rects).encode_mem r, | |
| vcode r i, completion.externalFamilyVertexCode_mem_tags group oldAction compression r i, | |
| SetMembers.raw x, SetMembers.raw_mem x, | |
| (sGroup).encode ((family).flatWord w r i), carrier ▸ (sGroup).encode_mem _, rfl, rfl, ?_⟩ | |
| exact (completion.externalFlatVertexWordCode_iff group oldAction compression | |
| pairing unions powers separation infinite hG hLetters r i w _).2 rfl | |
| end PartitionPilot.Forcing.GroundCompressionCompletion | |
| namespace PartitionPilot.Forcing.GroundCompressionCompletion | |
| open SetRealization SetFormula Compression.RecursiveMaps.CosetGeometry | |
| universe u | |
| variable {M : TransitiveGround.{u}} {initial : RecursiveStateData.{u}} | |
| variable {I Sources Reps G m inv one T τ P0 r0 μ0 A0 : ZFSet.{u}} | |
| variable (completion : GroundCompressionCompletion M initial I Sources Reps G m one T τ) | |
| variable (group : GroupCode G m inv one) (oldAction : PosetActionCode G P0 m one r0 A0) | |
| variable (compression : CompressionOriginalData P0 r0 μ0 A0 G | |
| (completion.algebra.union.fields 0) (completion.algebra.union.fields 1) | |
| (completion.algebra.union.fields 2) (completion.algebra.union.fields 12)) | |
| variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| variable (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| variable (infinite : Realize M.sets infinity Fin.elim0) | |
| variable (hG : G ∈ M.sets) | |
| variable (hLetters : externalChildLetters I P0 (externalRectangles P0 G r0 μ0 A0) ∈ M.sets) | |
| local notation "family" => completion.externalFamily group oldAction compression | |
| local notation "U" => completion.algebra.union.fields 0 | |
| local notation "sGroup" => completion.externalFamilyGroupPresentation group oldAction compression | |
| pairing unions powers separation infinite hG hLetters | |
| include pairing unions powers separation infinite hG hLetters in | |
| theorem externalFlatSteps_iff : | |
| letI := group.toGroup | |
| let a := completion.algebra.union.action.toOrderAction group completion.algebra.union.meet | |
| ∀ x y : (family).FlatLabel (J := SetMembers G), | |
| ZFSet.pair (((sGroup).product (SetMembers.presentation U)).encode x) | |
| (((sGroup).product (SetMembers.presentation U)).encode y) ∈ completion.externalFlatSteps P0 r0 μ0 A0 ↔ | |
| (family).FlatStep a x y := by | |
| let := group.toGroup | |
| dsimp only | |
| let a := completion.algebra.union.action.toOrderAction group completion.algebra.union.meet | |
| let s := sGroup | |
| let t := SetMembers.presentation U | |
| let g := SetMembers.presentation G | |
| let v := completion.externalFamilyTileVertexPresentation group oldAction compression | |
| have carrier := completion.externalFamilyGroupPresentation_carrier group oldAction compression | |
| pairing unions powers separation infinite hG hLetters | |
| have oldEntries : ∀ j w, ZFSet.pair (g.encode j) (s.encode w) ∈ M.externalOldInclusion G | |
| (externalChildLetters I P0 (externalRectangles P0 G r0 μ0 A0)) m one ↔ | |
| old (SetMembers G) (family).Letters j = w := by | |
| intro j w | |
| rw [completion.externalFamilyGroupPresentation_old group oldAction compression | |
| pairing unions powers separation infinite hG hLetters] | |
| exact g.pair_mem_graph s _ j w | |
| have mulEntries : ∀ w k l, ZFSet.pair (ZFSet.pair (s.encode w) (s.encode k)) (s.encode l) ∈ | |
| M.externalGroupMultiplication G (externalChildLetters I P0 (externalRectangles P0 G r0 μ0 A0)) m one ↔ | |
| w * k = l := by | |
| intro w k l | |
| rw [completion.externalFamilyGroupPresentation_multiplication group oldAction compression | |
| pairing unions powers separation infinite hG hLetters] | |
| exact (s.product s).pair_mem_graph s _ (w, k) l | |
| have actEntries : ∀ j x y, ZFSet.pair (ZFSet.pair (g.encode j) (t.encode x)) (t.encode y) ∈ | |
| completion.algebra.union.fields 12 ↔ (a.iso j).toFun x = y := | |
| fun j x y => (completion.algebra.union.action.toOrderAction_eq_iff group completion.algebra.union.meet j x y).symm | |
| intro x y | |
| have result := pair_mem_externalFlatStepGraph_iff (family) a s t g v oldEntries mulEntries actEntries | |
| (completion.externalPlacements_entry_iff group oldAction compression pairing unions powers separation infinite hG hLetters) | |
| (completion.externalOverlaps_same_request group oldAction compression) | |
| (completion.externalOverlaps_entry_iff group oldAction compression) x y | |
| change ZFSet.pair ((s.product t).encode x) ((s.product t).encode y) ∈ | |
| externalFlatStepGraph s.carrier U G (completion.externalVertices P0 r0 μ0 A0) _ _ _ _ _ ↔ _ at result | |
| rw [carrier] at result | |
| exact result | |
| end PartitionPilot.Forcing.GroundCompressionCompletion | |
| end OAI | |