openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Geometry /GroundCodedBinaryHeights.lean
| import OAI.SetTheory.PartitionPrinciple.Definability.PrincipalTileRealization | |
| import OAI.SetTheory.PartitionPrinciple.Forcing.GroundIdealProjections | |
| import OAI.SetTheory.PartitionPrinciple.Geometry.GroundCompressionHeightSteps | |
| import OAI.SetTheory.PartitionPrinciple.Geometry.GroundRequestedCompressionTiles | |
| namespace OAI | |
| open scoped ZFSet | |
| namespace PartitionPilot.Forcing | |
| open SetFormula | |
| universe u | |
| structure StrictHeightGraphCode (L H rL rH h : ZFSet.{u}) : Prop where | |
| function : ZFSet.IsFunc L H h | |
| strict : ∀ x ∈ L, ∀ y ∈ L, x ≠ y → ZFSet.pair x y ∈ rL → | |
| ∀ a b, ZFSet.pair x a ∈ h → ZFSet.pair y b ∈ h → ZFSet.pair a b ∈ rH | |
| theorem StrictLexHeightCode.strictHeightGraph {L C D r h rD : ZFSet.{u}} | |
| (code : StrictLexHeightCode L C D r h rD) : | |
| StrictHeightGraphCode L (ZFSet.prod C D) r (lexHeightOrder C D rD) h := by | |
| refine ⟨code.function, ?_⟩ | |
| intro x hx y hy different lower a b first second | |
| obtain ⟨c, hc, q, hq, eq⟩ := ZFSet.mem_prod.1 (ZFSet.pair_mem_prod.1 (code.function.1 first)).2 | |
| obtain ⟨d, hd, v, hv, eq'⟩ := ZFSet.mem_prod.1 (ZFSet.pair_mem_prod.1 (code.function.1 second)).2 | |
| subst a | |
| subst b | |
| exact (pair_mem_lexHeightOrder _ _ _ _ _ _ _).2 | |
| ⟨hc, hq, hd, hv, code.strict x hx y hy c q d v lower different first second⟩ | |
| namespace TransitiveGround | |
| theorem exists_groundHeightInterpolation (M : TransitiveGround.{u}) | |
| (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) | |
| (collection : CollectionSchema M.sets) (infinite : Realize M.sets SetFormula.infinity Fin.elim0) | |
| {L H rL rH seed D rD c lo hi : ZFSet.{u}} | |
| (hL : L ∈ M.sets) (hH : H ∈ M.sets) (hrH : rH ∈ M.sets) (hSeed : seed ∈ M.sets) | |
| (hD : D ∈ M.sets) (hrD : rD ∈ M.sets) (hc : c ∈ M.sets) | |
| (seedCode : StrictHeightGraphCode L H rL rH seed) | |
| (linear : StrictLinearOrderCode H rH) (target : DenseOrderCode D rD) | |
| (injection : InjectionCode D ZFSet.omega c) | |
| (small : M.groundEmbeddable (relationImage L H seed) ZFSet.omega) | |
| (hlo : lo ∈ D) (hhi : hi ∈ D) (gap : ZFSet.pair lo hi ∈ rD) : | |
| ∃ height ∈ M.sets, StrictHeightGraphCode L D rL rD height ∧ | |
| (∀ x z, ZFSet.pair x z ∈ height → ZFSet.pair lo z ∈ rD ∧ ZFSet.pair z hi ∈ rD) ∧ | |
| relationImage L D height ∈ M.sets ∧ | |
| M.groundEmbeddable (relationImage L D height) ZFSet.omega ∧ | |
| ∀ x y a b q z, ZFSet.pair x a ∈ seed → ZFSet.pair y b ∈ seed → | |
| ZFSet.pair x q ∈ height → ZFSet.pair y z ∈ height → | |
| (a = b ↔ q = z) ∧ (ZFSet.pair a b ∈ rH ↔ ZFSet.pair q z ∈ rD) := by | |
| let R := relationImage L H seed | |
| have hR := M.relationImage_mem separation hL hH hSeed | |
| have hOrder : heightOrderRestriction R rH ∈ M.sets := | |
| M.injection_restriction_mem separation hR hR hrH | |
| have rLinear : StrictLinearOrderCode R (heightOrderRestriction R rH) := | |
| heightOrderRestriction_linear linear (fun _ h => ((mem_relationImage L H seed _).1 h).1) | |
| obtain ⟨e, he, embedding⟩ := M.exists_intervalEmbedding pairing unions powers separation collection infinite | |
| hR hD hOrder hrD hc rLinear target injection small hlo hhi gap | |
| let height := relationCompose L R D seed e | |
| have function := relationCompose_function_of_subset (function_on_relationImage seedCode.function) | |
| embedding.injection.function (fun _ h => h) | |
| have ground : height ∈ M.sets := M.relationCompose_mem pairing unions powers separation hL hR hD hSeed he | |
| have liftEntry {x a z : ZFSet.{u}} (source : ZFSet.pair x a ∈ seed) | |
| (entry : ZFSet.pair x z ∈ height) : ZFSet.pair a z ∈ e := by | |
| obtain ⟨_, _, a', _, other, image⟩ := (pair_mem_relationCompose _ _ _ _ _ _ _).1 entry | |
| obtain ⟨v, _, unique⟩ := seedCode.function.2 x (ZFSet.pair_mem_prod.1 (seedCode.function.1 source)).1 | |
| have equal := (unique a source).trans (unique a' other).symm | |
| exact equal.symm ▸ image | |
| have exactOrder {x y a b q z : ZFSet.{u}} | |
| (first : ZFSet.pair x a ∈ seed) (second : ZFSet.pair y b ∈ seed) | |
| (left : ZFSet.pair x q ∈ height) (right : ZFSet.pair y z ∈ height) : | |
| (a = b ↔ q = z) ∧ (ZFSet.pair a b ∈ rH ↔ ZFSet.pair q z ∈ rD) := by | |
| have aq := liftEntry first left | |
| have bz := liftEntry second right | |
| have aR := (ZFSet.pair_mem_prod.1 (embedding.injection.function.1 aq)).1 | |
| have bR := (ZFSet.pair_mem_prod.1 (embedding.injection.function.1 bz)).1 | |
| refine ⟨?_, ?_⟩ | |
| · constructor | |
| · intro equal | |
| subst b | |
| obtain ⟨v, _, unique⟩ := embedding.injection.function.2 a aR | |
| exact (unique q aq).trans (unique z bz).symm | |
| · intro equal | |
| subst z | |
| exact embedding.injection.injective a b q aq bz | |
| · have order := embedding.order a b q z aq bz | |
| rw [pair_mem_heightOrderRestriction] at order | |
| exact ⟨fun hab => order.1 ⟨hab, aR, bR⟩, fun hqz => (order.2 hqz).1⟩ | |
| refine ⟨height, ground, ⟨function, ?_⟩, ?_, M.relationImage_mem separation hL hD ground, ?_, ?_⟩ | |
| · intro x hx y hy different lower q z left right | |
| obtain ⟨a, ax, _⟩ := seedCode.function.2 x hx | |
| obtain ⟨b, byEntry, _⟩ := seedCode.function.2 y hy | |
| exact (exactOrder ax byEntry left right).2.1 (seedCode.strict x hx y hy different lower a b ax byEntry) | |
| · intro x z entry | |
| obtain ⟨_, _, a, _, _, az⟩ := (pair_mem_relationCompose _ _ _ _ _ _ _).1 entry | |
| exact embedding.inside a z az | |
| · exact M.groundEmbeddable_restrict separation (M.relationImage_mem separation hL hD ground) | |
| (M.omega_mem separation infinite) (fun _ h => (mem_relationImage _ _ _ _).1 h |>.1) ⟨c, hc, injection⟩ | |
| · intro x y a b q z first second left right | |
| exact exactOrder first second left right | |
| end TransitiveGround | |
| end PartitionPilot.Forcing | |
| namespace PartitionPilot.Forcing | |
| open Compression.RecursiveMaps | |
| universe u | |
| noncomputable def lexProductOrder (C D rC rD : ZFSet.{u}) : ZFSet.{u} := | |
| ZFSet.sep (fun z => ∃ c ∈ C, ∃ q ∈ D, ∃ d ∈ C, ∃ v ∈ D, | |
| z = ZFSet.pair (ZFSet.pair c q) (ZFSet.pair d v) ∧ | |
| (ZFSet.pair c d ∈ rC ∨ (c = d ∧ ZFSet.pair q v ∈ rD))) | |
| (ZFSet.prod (ZFSet.prod C D) (ZFSet.prod C D)) | |
| theorem mem_lexProductOrder (C D rC rD z : ZFSet.{u}) : | |
| z ∈ lexProductOrder C D rC rD ↔ | |
| ∃ c ∈ C, ∃ q ∈ D, ∃ d ∈ C, ∃ v ∈ D, | |
| z = ZFSet.pair (ZFSet.pair c q) (ZFSet.pair d v) ∧ | |
| (ZFSet.pair c d ∈ rC ∨ (c = d ∧ ZFSet.pair q v ∈ rD)) := by | |
| constructor | |
| · exact fun h => (ZFSet.mem_sep.1 h).2 | |
| · rintro ⟨c, hc, q, hq, d, hd, v, hv, rfl, lower⟩ | |
| exact ZFSet.mem_sep.2 ⟨ZFSet.pair_mem_prod.2 | |
| ⟨ZFSet.pair_mem_prod.2 ⟨hc, hq⟩, ZFSet.pair_mem_prod.2 ⟨hd, hv⟩⟩, | |
| c, hc, q, hq, d, hd, v, hv, rfl, lower⟩ | |
| theorem pair_mem_lexProductOrder (C D rC rD c q d v : ZFSet.{u}) : | |
| ZFSet.pair (ZFSet.pair c q) (ZFSet.pair d v) ∈ lexProductOrder C D rC rD ↔ | |
| c ∈ C ∧ q ∈ D ∧ d ∈ C ∧ v ∈ D ∧ (ZFSet.pair c d ∈ rC ∨ (c = d ∧ ZFSet.pair q v ∈ rD)) := by | |
| rw [mem_lexProductOrder] | |
| constructor | |
| · rintro ⟨c', hc, q', hq, d', hd, v', hv, equal, lower⟩ | |
| obtain ⟨left, right⟩ := ZFSet.pair_inj.1 equal | |
| obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 left | |
| obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 right | |
| exact ⟨hc, hq, hd, hv, lower⟩ | |
| · rintro ⟨hc, hq, hd, hv, lower⟩ | |
| exact ⟨c, hc, q, hq, d, hd, v, hv, rfl, lower⟩ | |
| theorem lexProductOrder_code {C D rC rD : ZFSet.{u}} | |
| (columns : StrictLinearOrderCode C rC) (target : StrictLinearOrderCode D rD) : | |
| StrictLinearOrderCode (ZFSet.prod C D) (lexProductOrder C D rC rD) := by | |
| refine ⟨fun _ hz => (ZFSet.mem_sep.1 hz).1, ?_, ?_, ?_⟩ | |
| · intro x hx hxx | |
| obtain ⟨c, _, q, hq, rfl⟩ := ZFSet.mem_prod.1 hx | |
| rcases ((pair_mem_lexProductOrder C D rC rD c q c q).1 hxx).2.2.2.2 with less | same | |
| · exact columns.irrefl c (ZFSet.pair_mem_prod.1 (columns.shape less)).1 less | |
| · exact target.irrefl q hq same.2 | |
| · intro x y z hxy hyz | |
| have xy := ZFSet.pair_mem_prod.1 (ZFSet.mem_sep.1 hxy).1 | |
| have yz := ZFSet.pair_mem_prod.1 (ZFSet.mem_sep.1 hyz).1 | |
| obtain ⟨c, hc, q, hq, rfl⟩ := ZFSet.mem_prod.1 xy.1 | |
| obtain ⟨d, _, v, _, rfl⟩ := ZFSet.mem_prod.1 xy.2 | |
| obtain ⟨b, hb, w, hw, rfl⟩ := ZFSet.mem_prod.1 yz.2 | |
| have left := ((pair_mem_lexProductOrder C D rC rD c q d v).1 hxy).2.2.2.2 | |
| have right := ((pair_mem_lexProductOrder C D rC rD d v b w).1 hyz).2.2.2.2 | |
| apply (pair_mem_lexProductOrder C D rC rD c q b w).2 | |
| refine ⟨hc, hq, hb, hw, ?_⟩ | |
| rcases left with lower | ⟨same, inside⟩ | |
| · rcases right with lower' | ⟨same', _⟩ | |
| · exact Or.inl (columns.trans c d b lower lower') | |
| · exact Or.inl (same' ▸ lower) | |
| · rcases right with lower' | ⟨same', inside'⟩ | |
| · exact Or.inl (same.symm ▸ lower') | |
| · exact Or.inr ⟨same.trans same', target.trans q v w inside inside'⟩ | |
| · intro x hx y hy | |
| obtain ⟨c, hc, q, hq, rfl⟩ := ZFSet.mem_prod.1 hx | |
| obtain ⟨d, hd, v, hv, rfl⟩ := ZFSet.mem_prod.1 hy | |
| rcases columns.compare c hc d hd with lower | same | greater | |
| · exact Or.inl ((pair_mem_lexProductOrder C D rC rD c q d v).2 ⟨hc, hq, hd, hv, Or.inl lower⟩) | |
| · subst d | |
| rcases target.compare q hq v hv with lower | same | greater | |
| · exact Or.inl ((pair_mem_lexProductOrder C D rC rD c q c v).2 | |
| ⟨hc, hq, hc, hv, Or.inr ⟨rfl, lower⟩⟩) | |
| · exact Or.inr (Or.inl (congrArg (ZFSet.pair c) same)) | |
| · exact Or.inr (Or.inr ((pair_mem_lexProductOrder C D rC rD c v c q).2 | |
| ⟨hc, hv, hc, hq, Or.inr ⟨rfl, greater⟩⟩)) | |
| · exact Or.inr (Or.inr ((pair_mem_lexProductOrder C D rC rD d v c q).2 | |
| ⟨hd, hv, hc, hq, Or.inl greater⟩)) | |
| namespace BoundedFormula | |
| def lexProductEntryFormula {n} (z C D rC rD : Fin n) : BoundedFormula n := | |
| let lift (i : Fin n) := i.succ.succ.succ.succ | |
| exMem C (exMem D.succ (exMem C.succ.succ (exMem D.succ.succ.succ | |
| (.conj (pairOfPairsFormula (lift z) 3 2 1 0) | |
| (disj (pairMembershipFormula 3 1 (lift rC)) (.conj (.equal 3 1) (pairMembershipFormula 2 0 (lift rD)))))))) | |
| theorem truth_lexProductEntryFormula {n} (z C D rC rD : Fin n) (env : Fin n → ZFSet.{u}) : | |
| Truth (lexProductEntryFormula z C D rC rD) env ↔ | |
| ∃ c ∈ env C, ∃ q ∈ env D, ∃ d ∈ env C, ∃ v ∈ env D, | |
| env z = ZFSet.pair (ZFSet.pair c q) (ZFSet.pair d v) ∧ | |
| (ZFSet.pair c d ∈ env rC ∨ (c = d ∧ ZFSet.pair q v ∈ env rD)) := by | |
| simp only [lexProductEntryFormula, truth_exMem, Truth, truth_disj, | |
| truth_pairOfPairsFormula, truth_pairMembershipFormula] | |
| rfl | |
| end BoundedFormula | |
| namespace TransitiveGround | |
| open SetFormula | |
| theorem lexProductOrder_mem (M : TransitiveGround.{u}) | |
| (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) | |
| {C D rC rD : ZFSet.{u}} (hC : C ∈ M.sets) (hD : D ∈ M.sets) (hrC : rC ∈ M.sets) (hrD : rD ∈ M.sets) : | |
| lexProductOrder C D rC rD ∈ M.sets := by | |
| have carrier := M.prod_mem pairing unions powers separation hC hD | |
| let params := extend C (extend D (extend rC (extend rD Fin.elim0))) | |
| have selected := M.bounded_separation_mem separation | |
| (BoundedFormula.lexProductEntryFormula 0 1 2 3 4) params | |
| (Fin.cases hC (Fin.cases hD (Fin.cases hrC (Fin.cases hrD (fun i => Fin.elim0 i))))) | |
| (M.prod_mem pairing unions powers separation carrier carrier) | |
| have equal : ZFSet.sep (fun z => BoundedFormula.Truth | |
| (BoundedFormula.lexProductEntryFormula 0 1 2 3 4) (extend z params)) | |
| (ZFSet.prod (ZFSet.prod C D) (ZFSet.prod C D)) = lexProductOrder C D rC rD := by | |
| apply ZFSet.ext | |
| intro z | |
| rw [ZFSet.mem_sep, lexProductOrder, ZFSet.mem_sep] | |
| exact and_congr Iff.rfl (BoundedFormula.truth_lexProductEntryFormula 0 1 2 3 4 _) | |
| exact equal ▸ selected | |
| end TransitiveGround | |
| end PartitionPilot.Forcing | |
| section | |
| namespace PartitionPilot.Forcing | |
| open SetRealization Compression.RecursiveMaps SetFormula | |
| universe u | |
| noncomputable def StrictLinearOrderCode.smallOrder {H rH : ZFSet.{u}} | |
| (code : StrictLinearOrderCode H rH) : LinearHeightOrder (SetMembers H) where | |
| lt x y := ZFSet.pair (SetMembers.raw x) (SetMembers.raw y) ∈ rH | |
| irrefl x := code.irrefl _ (SetMembers.raw_mem x) | |
| trans {x y z} := code.trans (SetMembers.raw x) (SetMembers.raw y) (SetMembers.raw z) | |
| compare x y := (code.compare _ (SetMembers.raw_mem x) _ (SetMembers.raw_mem y)).imp id | |
| (fun h => h.imp (fun eq => SetMembers.raw_injective H eq) id) | |
| noncomputable def StrictHeightGraphCode.smallHeight {L H rL rH h μ : ZFSet.{u}} | |
| (code : StrictHeightGraphCode L H rL rH h) (meet : MeetOrderCode L rL μ) | |
| (linear : StrictLinearOrderCode H rH) : | |
| StrictHeight meet.toSmallMeetOrder linear.smallOrder.toHeightOrder where | |
| value := (SetMembers.presentation L).decodeFunction (SetMembers.presentation H) h code.function | |
| strict x y lower different := code.strict _ (SetMembers.raw_mem x) _ (SetMembers.raw_mem y) | |
| (fun eq => different (SetMembers.raw_injective L eq)) lower _ _ | |
| ((SetMembers.presentation L).decodeFunction_mem (SetMembers.presentation H) h code.function x) | |
| ((SetMembers.presentation L).decodeFunction_mem (SetMembers.presentation H) h code.function y) | |
| theorem StrictHeightGraphCode.smallHeight_graph {L H rL rH h μ : ZFSet.{u}} | |
| (code : StrictHeightGraphCode L H rL rH h) (meet : MeetOrderCode L rL μ) | |
| (linear : StrictLinearOrderCode H rH) : | |
| (SetMembers.presentation L).graph (SetMembers.presentation H) (code.smallHeight meet linear).value = h := | |
| (SetMembers.presentation L).graph_decodeFunction (SetMembers.presentation H) h code.function | |
| end PartitionPilot.Forcing | |
| namespace PartitionPilot.SetRealization.Presentation | |
| open Forcing Compression.RecursiveMaps | |
| universe u | |
| variable {A B C : Type u} | |
| theorem strictHeightGraphCode (s : Presentation A) (t : Presentation B) | |
| {P : MeetOrder A} {R : HeightOrder B} (height : StrictHeight P R) | |
| {r rH : ZFSet.{u}} | |
| (order : ∀ x y, ZFSet.pair (s.encode x) (s.encode y) ∈ r ↔ P.le x y) | |
| (target : ∀ a b, ZFSet.pair (t.encode a) (t.encode b) ∈ rH ↔ R.lt a b) : | |
| StrictHeightGraphCode s.carrier t.carrier r rH (s.graph t height.value) := by | |
| refine ⟨s.graph_isFunc t height.value, ?_⟩ | |
| intro x hx y hy different lower a b first second | |
| obtain ⟨x, rfl⟩ := (s.mem_carrier x).1 hx | |
| obtain ⟨y, rfl⟩ := (s.mem_carrier y).1 hy | |
| obtain ⟨a, rfl⟩ := (t.mem_carrier a).1 (ZFSet.pair_mem_prod.1 ((s.graph_isFunc t height.value).1 first)).2 | |
| obtain ⟨b, rfl⟩ := (t.mem_carrier b).1 (ZFSet.pair_mem_prod.1 ((s.graph_isFunc t height.value).1 second)).2 | |
| have firstEq := (s.pair_mem_graph t height.value x a).1 first | |
| have secondEq := (s.pair_mem_graph t height.value y b).1 second | |
| rw [← firstEq, ← secondEq] | |
| exact (target _ _).2 (height.strict x y ((order x y).1 lower) (fun eq => different (congrArg s.encode eq))) | |
| theorem lexProductOrder_iff (s : Presentation A) (t : Presentation B) | |
| (R : LinearHeightOrder A) (S : LinearHeightOrder B) {rR rS : ZFSet.{u}} | |
| (first : ∀ a b, ZFSet.pair (s.encode a) (s.encode b) ∈ rR ↔ R.lt a b) | |
| (second : ∀ a b, ZFSet.pair (t.encode a) (t.encode b) ∈ rS ↔ S.lt a b) (x y : A × B) : | |
| ZFSet.pair ((s.product t).encode x) ((s.product t).encode y) ∈ | |
| lexProductOrder s.carrier t.carrier rR rS ↔ (R.lex S).lt x y := by | |
| change ZFSet.pair (ZFSet.pair (s.encode x.1) (t.encode x.2)) | |
| (ZFSet.pair (s.encode y.1) (t.encode y.2)) ∈ _ ↔ _ | |
| rw [pair_mem_lexProductOrder] | |
| simp only [s.encode_mem, t.encode_mem, true_and, first, second, s.injective.eq_iff] | |
| rfl | |
| theorem compose_graphs (s : Presentation A) (t : Presentation B) (v : Presentation C) | |
| (f : A → B) (g : B → C) : | |
| relationCompose s.carrier t.carrier v.carrier (s.graph t f) (t.graph v g) = | |
| s.graph v (fun x => g (f x)) := by | |
| apply ZFSet.ext | |
| intro z | |
| rw [mem_relationCompose, Presentation.mem_graph] | |
| constructor | |
| · rintro ⟨x, hx, y, hy, w, hw, rfl, first, second⟩ | |
| obtain ⟨a, rfl⟩ := (s.mem_carrier x).1 hx | |
| obtain ⟨b, rfl⟩ := (t.mem_carrier y).1 hy | |
| obtain ⟨c, rfl⟩ := (v.mem_carrier w).1 hw | |
| have ab := (s.pair_mem_graph t f a b).1 first | |
| have bc := (t.pair_mem_graph v g b c).1 second | |
| subst b | |
| subst c | |
| exact ⟨a, rfl⟩ | |
| · rintro ⟨a, rfl⟩ | |
| exact ⟨s.encode a, s.encode_mem a, t.encode (f a), t.encode_mem _, | |
| v.encode (g (f a)), v.encode_mem _, rfl, | |
| (s.pair_mem_graph t f _ _).2 rfl, (t.pair_mem_graph v g _ _).2 rfl⟩ | |
| end PartitionPilot.SetRealization.Presentation | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) | |
| 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 {A B C : Type u} (s : Presentation A) (t : Presentation B) (v : Presentation C) | |
| include pairing unions powers separation | |
| theorem composed_graph_mem (f : A → B) (g : B → C) | |
| (hs : s.carrier ∈ M.sets) (ht : t.carrier ∈ M.sets) (hv : v.carrier ∈ M.sets) | |
| (hf : s.graph t f ∈ M.sets) (hg : t.graph v g ∈ M.sets) : | |
| s.graph v (fun x => g (f x)) ∈ M.sets := by | |
| rw [← s.compose_graphs t v f g] | |
| exact M.relationCompose_mem pairing unions powers separation hs ht hv hf hg | |
| theorem paired_graph_mem (f : A → B) (g : A → C) | |
| (hs : s.carrier ∈ M.sets) (ht : t.carrier ∈ M.sets) (hv : v.carrier ∈ M.sets) | |
| (hf : s.graph t f ∈ M.sets) (hg : s.graph v g ∈ M.sets) : | |
| s.graph (t.product v) (fun x => (f x, g x)) ∈ M.sets := by | |
| rw [← pairedGraph_eq s t v f g] | |
| exact M.pairedGraph_mem pairing unions powers separation hs ht hv hf hg | |
| end PartitionPilot.Forcing.TransitiveGround | |
| end | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization Compression.RecursiveMaps SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) | |
| 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 SetFormula.infinity Fin.elim0) | |
| variable {A H : Type u} (s : Presentation A) (t : Presentation H) | |
| variable {P : MeetOrder A} (top : A) (greatest : ∀ a, P.le a top) | |
| variable (R : LinearHeightOrder H) (seed : StrictHeight P R.toHeightOrder) | |
| variable (hP : s.carrier ∈ M.sets) (hH : t.carrier ∈ M.sets) | |
| variable (hSeed : s.graph t seed.value ∈ M.sets) | |
| variable (small : M.groundEmbeddable (relationImage s.carrier t.carrier (s.graph t seed.value)) ZFSet.omega) | |
| include pairing unions powers separation infinite hP hH hSeed small | |
| theorem binaryTuple_ground (tile : TileRequests.Tile P (ULift.{u} Unit)) | |
| (q : Presentation tile.Space) {ν : ZFSet.{u}} | |
| (hL : q.carrier ∈ M.sets) (hν : ν ∈ M.sets) | |
| (meetFunction : ZFSet.IsFunc (ZFSet.prod q.carrier q.carrier) q.carrier ν) | |
| (meetEntries : ∀ x y, ZFSet.pair (ZFSet.pair (q.encode x) (q.encode y)) | |
| (q.encode (tile.order.meet x y)) ∈ ν) | |
| (root : s.graph q tile.root.toFun ∈ M.sets) | |
| (child : s.graph q (tile.child ⟨()⟩).toFun ∈ M.sets) : | |
| let graph := q.graph (t.product t) (tile.binaryTuple top greatest R seed).value | |
| graph ∈ M.sets ∧ M.groundEmbeddable | |
| (relationImage q.carrier (t.product t).carrier graph) ZFSet.omega := by | |
| dsimp only | |
| have first := M.idealProjection_mem s q tile.root top meetFunction meetEntries | |
| pairing unions powers separation hP hL hν root | |
| have second := M.idealProjection_mem s q (tile.child ⟨()⟩) top meetFunction meetEntries | |
| pairing unions powers separation hP hL hν child | |
| have firstHeight := M.composed_graph_mem pairing unions powers separation q s t | |
| (tile.root.projection top) seed.value hL hP hH first hSeed | |
| have secondHeight := M.composed_graph_mem pairing unions powers separation q s t | |
| ((tile.child ⟨()⟩).projection top) seed.value hL hP hH second hSeed | |
| have graphGround : q.graph (t.product t) (tile.binaryTuple top greatest R seed).value ∈ M.sets := | |
| M.paired_graph_mem pairing unions powers separation q t t _ _ hL hH hH firstHeight secondHeight | |
| refine ⟨graphGround, ?_⟩ | |
| let E := relationImage s.carrier t.carrier (s.graph t seed.value) | |
| have hE : E ∈ M.sets := M.relationImage_mem separation hP hH hSeed | |
| have each (a : A) : t.encode (seed.value a) ∈ E := | |
| (mem_relationImage _ _ _ _).2 ⟨t.encode_mem _, s.encode a, s.encode_mem a, | |
| (s.pair_mem_graph t seed.value _ _).2 rfl⟩ | |
| apply M.groundEmbeddable_restrict separation | |
| (M.relationImage_mem separation hL (M.prod_mem pairing unions powers separation hH hH) graphGround) | |
| (M.omega_mem separation infinite) ?_ | |
| (M.groundEmbeddable_product pairing unions powers separation infinite hE hE small small) | |
| intro z hz | |
| obtain ⟨_, x, hx, entry⟩ := (mem_relationImage _ _ _ _).1 hz | |
| obtain ⟨x, rfl⟩ := (q.mem_carrier x).1 hx | |
| obtain ⟨y, eq⟩ := (q.mem_graph (t.product t) (tile.binaryTuple top greatest R seed).value _).1 entry | |
| have parts := ZFSet.pair_inj.1 eq | |
| have xy := q.injective parts.1 | |
| subst y | |
| rw [← parts.2] | |
| exact ZFSet.pair_mem_prod.2 ⟨each _, each _⟩ | |
| theorem rectangleTuple_ground (tile : TileRequests.Tile P (ULift.{u} Bool)) | |
| (q : Presentation tile.Space) {ν : ZFSet.{u}} | |
| (hL : q.carrier ∈ M.sets) (hν : ν ∈ M.sets) | |
| (meetFunction : ZFSet.IsFunc (ZFSet.prod q.carrier q.carrier) q.carrier ν) | |
| (meetEntries : ∀ x y, ZFSet.pair (ZFSet.pair (q.encode x) (q.encode y)) | |
| (q.encode (tile.order.meet x y)) ∈ ν) | |
| (root : s.graph q tile.root.toFun ∈ M.sets) | |
| (first : s.graph q (tile.child ⟨false⟩).toFun ∈ M.sets) | |
| (second : s.graph q (tile.child ⟨true⟩).toFun ∈ M.sets) : | |
| let graph := q.graph (t.product (t.product t)) (tile.rectangleTuple top greatest R seed).value | |
| graph ∈ M.sets ∧ M.groundEmbeddable | |
| (relationImage q.carrier (t.product (t.product t)).carrier graph) ZFSet.omega := by | |
| dsimp only | |
| have project (e : IdealEmbedding P tile.order) (he : s.graph q e.toFun ∈ M.sets) := | |
| M.composed_graph_mem pairing unions powers separation q s t (e.projection top) seed.value | |
| hL hP hH (M.idealProjection_mem s q e top meetFunction meetEntries | |
| pairing unions powers separation hP hL hν he) hSeed | |
| have pairGround := M.paired_graph_mem pairing unions powers separation q t t _ _ hL hH hH | |
| (project (tile.child ⟨false⟩) first) (project (tile.child ⟨true⟩) second) | |
| have hHH := M.prod_mem pairing unions powers separation hH hH | |
| have graphGround : q.graph (t.product (t.product t)) (tile.rectangleTuple top greatest R seed).value ∈ M.sets := | |
| M.paired_graph_mem pairing unions powers separation q t (t.product t) _ _ hL hH hHH | |
| (project tile.root root) pairGround | |
| refine ⟨graphGround, ?_⟩ | |
| let E := relationImage s.carrier t.carrier (s.graph t seed.value) | |
| have hE : E ∈ M.sets := M.relationImage_mem separation hP hH hSeed | |
| have each (a : A) : t.encode (seed.value a) ∈ E := | |
| (mem_relationImage _ _ _ _).2 ⟨t.encode_mem _, s.encode a, s.encode_mem a, | |
| (s.pair_mem_graph t seed.value _ _).2 rfl⟩ | |
| have smallEE := M.groundEmbeddable_product pairing unions powers separation infinite hE hE small small | |
| have smallEEE := M.groundEmbeddable_product pairing unions powers separation infinite hE | |
| (M.prod_mem pairing unions powers separation hE hE) small smallEE | |
| apply M.groundEmbeddable_restrict separation | |
| (M.relationImage_mem separation hL (M.prod_mem pairing unions powers separation hH hHH) graphGround) | |
| (M.omega_mem separation infinite) ?_ smallEEE | |
| intro z hz | |
| obtain ⟨_, x, hx, entry⟩ := (mem_relationImage _ _ _ _).1 hz | |
| obtain ⟨x, rfl⟩ := (q.mem_carrier x).1 hx | |
| obtain ⟨y, eq⟩ := (q.mem_graph (t.product (t.product t)) (tile.rectangleTuple top greatest R seed).value _).1 entry | |
| have parts := ZFSet.pair_inj.1 eq | |
| have xy := q.injective parts.1 | |
| subst y | |
| rw [← parts.2] | |
| exact ZFSet.pair_mem_prod.2 ⟨each _, ZFSet.pair_mem_prod.2 ⟨each _, each _⟩⟩ | |
| end PartitionPilot.Forcing.TransitiveGround | |
| namespace PartitionPilot.Forcing | |
| open SetRealization Compression.RecursiveMaps SetFormula | |
| universe u | |
| structure IntervalHeightCode (L r D rD lo hi height : ZFSet.{u}) : Prop | |
| extends StrictHeightGraphCode L D r rD height where | |
| inside : ∀ x z, ZFSet.pair x z ∈ height → ZFSet.pair lo z ∈ rD ∧ ZFSet.pair z hi ∈ rD | |
| theorem StrictHeightGraphCode.weak {L H r rH h : ZFSet.{u}} | |
| (code : StrictHeightGraphCode L H r rH h) {x y a b : ZFSet.{u}} | |
| (lower : ZFSet.pair x y ∈ r) (first : ZFSet.pair x a ∈ h) (second : ZFSet.pair y b ∈ h) : | |
| a = b ∨ ZFSet.pair a b ∈ rH := by | |
| have hx := (ZFSet.pair_mem_prod.1 (code.function.1 first)).1 | |
| have hy := (ZFSet.pair_mem_prod.1 (code.function.1 second)).1 | |
| by_cases equal : x = y | |
| · subst y | |
| obtain ⟨v, _, unique⟩ := code.function.2 x hx | |
| exact Or.inl ((unique a first).trans (unique b second).symm) | |
| · exact Or.inr (code.strict x hx y hy equal lower a b first second) | |
| namespace TransitiveGround | |
| variable (M : TransitiveGround.{u}) | |
| 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 (collection : CollectionSchema M.sets) (infinite : Realize M.sets SetFormula.infinity Fin.elim0) | |
| variable {A H : Type u} (s : Presentation A) (t : Presentation H) | |
| variable {P : MeetOrder A} (top : A) (greatest : ∀ a, P.le a top) | |
| variable (R : LinearHeightOrder H) (seed : StrictHeight P R.toHeightOrder) | |
| variable {rH D rD c lo hi : ZFSet.{u}} | |
| variable (heightOrder : ∀ a b, ZFSet.pair (t.encode a) (t.encode b) ∈ rH ↔ R.lt a b) | |
| variable (linear : StrictLinearOrderCode t.carrier rH) | |
| variable (target : DenseOrderCode D rD) (injection : InjectionCode D ZFSet.omega c) | |
| variable (hP : s.carrier ∈ M.sets) (hH : t.carrier ∈ M.sets) | |
| variable (hSeed : s.graph t seed.value ∈ M.sets) (hrH : rH ∈ M.sets) | |
| variable (hD : D ∈ M.sets) (hrD : rD ∈ M.sets) (hc : c ∈ M.sets) | |
| variable (small : M.groundEmbeddable (relationImage s.carrier t.carrier (s.graph t seed.value)) ZFSet.omega) | |
| variable (hlo : lo ∈ D) (hhi : hi ∈ D) (gap : ZFSet.pair lo hi ∈ rD) | |
| include top greatest pairing unions powers separation collection infinite heightOrder linear target injection | |
| hP hH hSeed hrH hD hrD hc small hlo hhi gap | |
| theorem exists_binaryTileIntervalHeight (tile : TileRequests.Tile P (ULift.{u} Unit)) | |
| (q : Presentation tile.Space) {r ν : ZFSet.{u}} | |
| (hL : q.carrier ∈ M.sets) (hν : ν ∈ M.sets) | |
| (related : ∀ x y, ZFSet.pair (q.encode x) (q.encode y) ∈ r ↔ tile.order.le x y) | |
| (meetFunction : ZFSet.IsFunc (ZFSet.prod q.carrier q.carrier) q.carrier ν) | |
| (meetEntries : ∀ x y, ZFSet.pair (ZFSet.pair (q.encode x) (q.encode y)) | |
| (q.encode (tile.order.meet x y)) ∈ ν) | |
| (root : s.graph q tile.root.toFun ∈ M.sets) | |
| (child : s.graph q (tile.child ⟨()⟩).toFun ∈ M.sets) : | |
| ∃ height ∈ M.sets, IntervalHeightCode q.carrier r D rD lo hi height ∧ | |
| relationImage q.carrier D height ∈ M.sets ∧ | |
| M.groundEmbeddable (relationImage q.carrier D height) ZFSet.omega := by | |
| have tuple := M.binaryTuple_ground pairing unions powers separation infinite s t top greatest R seed | |
| hP hH hSeed small tile q hL hν meetFunction meetEntries root child | |
| have strict := q.strictHeightGraphCode (t.product t) (tile.binaryTuple top greatest R seed) related | |
| (t.lexProductOrder_iff t R R heightOrder heightOrder) | |
| obtain ⟨height, ground, code, inside, rangeGround, rangeSmall, _⟩ := | |
| M.exists_groundHeightInterpolation pairing unions powers separation collection infinite hL | |
| (M.prod_mem pairing unions powers separation hH hH) | |
| (M.lexProductOrder_mem pairing unions powers separation hH hH hrH hrH) tuple.1 | |
| hD hrD hc strict (lexProductOrder_code linear linear) target injection tuple.2 hlo hhi gap | |
| exact ⟨height, ground, ⟨code, inside⟩, rangeGround, rangeSmall⟩ | |
| theorem exists_rectangleTileIntervalHeight (tile : TileRequests.Tile P (ULift.{u} Bool)) | |
| (q : Presentation tile.Space) {r ν : ZFSet.{u}} | |
| (hL : q.carrier ∈ M.sets) (hν : ν ∈ M.sets) | |
| (related : ∀ x y, ZFSet.pair (q.encode x) (q.encode y) ∈ r ↔ tile.order.le x y) | |
| (meetFunction : ZFSet.IsFunc (ZFSet.prod q.carrier q.carrier) q.carrier ν) | |
| (meetEntries : ∀ x y, ZFSet.pair (ZFSet.pair (q.encode x) (q.encode y)) | |
| (q.encode (tile.order.meet x y)) ∈ ν) | |
| (root : s.graph q tile.root.toFun ∈ M.sets) | |
| (first : s.graph q (tile.child ⟨false⟩).toFun ∈ M.sets) | |
| (second : s.graph q (tile.child ⟨true⟩).toFun ∈ M.sets) : | |
| ∃ height ∈ M.sets, IntervalHeightCode q.carrier r D rD lo hi height ∧ | |
| relationImage q.carrier D height ∈ M.sets ∧ | |
| M.groundEmbeddable (relationImage q.carrier D height) ZFSet.omega := by | |
| have tuple := M.rectangleTuple_ground pairing unions powers separation infinite s t top greatest R seed | |
| hP hH hSeed small tile q hL hν meetFunction meetEntries root first second | |
| have inner := t.lexProductOrder_iff t R R heightOrder heightOrder | |
| have strict := q.strictHeightGraphCode (t.product (t.product t)) (tile.rectangleTuple top greatest R seed) related | |
| (t.lexProductOrder_iff (t.product t) R (R.lex R) heightOrder inner) | |
| have hHH := M.prod_mem pairing unions powers separation hH hH | |
| have hrHH := M.lexProductOrder_mem pairing unions powers separation hH hH hrH hrH | |
| obtain ⟨height, ground, code, inside, rangeGround, rangeSmall, _⟩ := | |
| M.exists_groundHeightInterpolation pairing unions powers separation collection infinite hL | |
| (M.prod_mem pairing unions powers separation hH hHH) | |
| (M.lexProductOrder_mem pairing unions powers separation hH hHH hrH hrHH) tuple.1 | |
| hD hrD hc strict (lexProductOrder_code linear (lexProductOrder_code linear linear)) | |
| target injection tuple.2 hlo hhi gap | |
| exact ⟨height, ground, ⟨code, inside⟩, rangeGround, rangeSmall⟩ | |
| end TransitiveGround | |
| end PartitionPilot.Forcing | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization Compression.RecursiveMaps SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) | |
| 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 (collection : CollectionSchema M.sets) (infinite : Realize M.sets SetFormula.infinity Fin.elim0) | |
| variable {A H : Type u} (s : Presentation A) (t : Presentation H) | |
| variable {P : MeetOrder A} (top : A) (greatest : ∀ a, P.le a top) | |
| variable (R : LinearHeightOrder H) (seed : StrictHeight P R.toHeightOrder) | |
| variable {rH D rD c lo hi : ZFSet.{u}} | |
| variable (heightOrder : ∀ a b, ZFSet.pair (t.encode a) (t.encode b) ∈ rH ↔ R.lt a b) | |
| variable (linear : StrictLinearOrderCode t.carrier rH) | |
| variable (target : DenseOrderCode D rD) (injection : InjectionCode D ZFSet.omega c) | |
| variable (hP : s.carrier ∈ M.sets) (hH : t.carrier ∈ M.sets) | |
| variable (hSeed : s.graph t seed.value ∈ M.sets) (hrH : rH ∈ M.sets) | |
| variable (hD : D ∈ M.sets) (hrD : rD ∈ M.sets) (hc : c ∈ M.sets) | |
| variable (small : M.groundEmbeddable (relationImage s.carrier t.carrier (s.graph t seed.value)) ZFSet.omega) | |
| variable (hlo : lo ∈ D) (hhi : hi ∈ D) (gap : ZFSet.pair lo hi ∈ rD) | |
| include top greatest pairing unions powers separation collection infinite heightOrder linear target injection | |
| hP hH hSeed hrH hD hrD hc small hlo hhi gap | |
| theorem exists_requestTileIntervalHeight (request : TileRequests.Request P) | |
| (q : Presentation (request.tile top greatest).Space) {r ν : ZFSet.{u}} | |
| (hL : q.carrier ∈ M.sets) (hν : ν ∈ M.sets) | |
| (related : ∀ x y, ZFSet.pair (q.encode x) (q.encode y) ∈ r ↔ (request.tile top greatest).order.le x y) | |
| (meetFunction : ZFSet.IsFunc (ZFSet.prod q.carrier q.carrier) q.carrier ν) | |
| (meetEntries : ∀ x y, ZFSet.pair (ZFSet.pair (q.encode x) (q.encode y)) | |
| (q.encode ((request.tile top greatest).order.meet x y)) ∈ ν) | |
| (root : s.graph q (request.tile top greatest).root.toFun ∈ M.sets) | |
| (children : ∀ j, s.graph q ((request.tile top greatest).child j).toFun ∈ M.sets) : | |
| ∃ height ∈ M.sets, IntervalHeightCode q.carrier r D rD lo hi height ∧ | |
| relationImage q.carrier D height ∈ M.sets ∧ | |
| M.groundEmbeddable (relationImage q.carrier D height) ZFSet.omega := by | |
| cases request with | |
| | separation W => | |
| exact M.exists_binaryTileIntervalHeight pairing unions powers separation collection infinite s t top greatest R seed | |
| heightOrder linear target injection hP hH hSeed hrH hD hrD hc small hlo hhi gap | |
| _ q hL hν related meetFunction meetEntries root (children ⟨()⟩) | |
| | compression K copy => | |
| exact M.exists_binaryTileIntervalHeight pairing unions powers separation collection infinite s t top greatest R seed | |
| heightOrder linear target injection hP hH hSeed hrH hD hrD hc small hlo hhi gap | |
| _ q hL hν related meetFunction meetEntries root (children ⟨()⟩) | |
| | rectangle data => | |
| exact M.exists_rectangleTileIntervalHeight pairing unions powers separation collection infinite s t top greatest R seed | |
| heightOrder linear target injection hP hH hSeed hrH hD hrD hc small hlo hhi gap | |
| _ q hL hν related meetFunction meetEntries root (children ⟨false⟩) (children ⟨true⟩) | |
| end PartitionPilot.Forcing.TransitiveGround | |
| namespace PartitionPilot.Forcing | |
| universe u | |
| def intervalHeightCandidate (Ps rs D rD lo hi i f : ZFSet.{u}) : Prop := | |
| ∃ P ∈ ⋃₀ ⋃₀ Ps, ∃ r ∈ ⋃₀ ⋃₀ rs, | |
| ZFSet.pair i P ∈ Ps ∧ ZFSet.pair i r ∈ rs ∧ IntervalHeightCode P r D rD lo hi f | |
| noncomputable def intervalHeightRelation (I W Ps rs D rD lo hi : ZFSet.{u}) : ZFSet.{u} := | |
| ZFSet.sep (fun z => ∃ i ∈ I, ∃ f ∈ W, z = ZFSet.pair i f ∧ | |
| intervalHeightCandidate Ps rs D rD lo hi i f) (ZFSet.prod I W) | |
| theorem pair_mem_intervalHeightRelation (I W Ps rs D rD lo hi i f : ZFSet.{u}) : | |
| ZFSet.pair i f ∈ intervalHeightRelation I W Ps rs D rD lo hi ↔ | |
| i ∈ I ∧ f ∈ W ∧ intervalHeightCandidate Ps rs D rD lo hi i f := by | |
| rw [intervalHeightRelation, ZFSet.mem_sep, ZFSet.pair_mem_prod] | |
| constructor | |
| · rintro ⟨⟨hi, hf⟩, j, _, g, _, equal, valid⟩ | |
| obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal | |
| exact ⟨hi, hf, valid⟩ | |
| · rintro ⟨hi, hf, valid⟩ | |
| exact ⟨⟨hi, hf⟩, i, hi, f, hf, rfl, valid⟩ | |
| theorem intervalHeightCandidate_iff {I Ps rs D rD lo hi : ZFSet.{u}} | |
| (sources : FunctionGraphOn I Ps) (orders : FunctionGraphOn I rs) | |
| (i : {i : ZFSet.{u} // i ∈ I}) (f : ZFSet.{u}) : | |
| intervalHeightCandidate Ps rs D rD lo hi i.val f ↔ | |
| IntervalHeightCode (sources.value i) (orders.value i) D rD lo hi f := by | |
| constructor | |
| · rintro ⟨P, _, r, _, pEntry, rEntry, code⟩ | |
| rw [sources.value_eq_of_entry i pEntry, orders.value_eq_of_entry i rEntry] | |
| exact code | |
| · intro code | |
| exact ⟨sources.value i, sources.value_mem_doubleUnion i, | |
| orders.value i, orders.value_mem_doubleUnion i, | |
| sources.value_entry i, orders.value_entry i, code⟩ | |
| end PartitionPilot.Forcing | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization Compression.RecursiveMaps SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) | |
| 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 (collection : CollectionSchema M.sets) (infinite : Realize M.sets SetFormula.infinity Fin.elim0) | |
| variable {P r μ H rH old D rD c lo hi : ZFSet.{u}} | |
| variable (source : MeetOrderCode P r μ) (top : SetMembers P) | |
| variable (greatest : ∀ x, source.toSmallMeetOrder.le x top) | |
| variable (height : StrictHeightGraphCode P H r rH old) (linear : StrictLinearOrderCode H rH) | |
| variable (target : DenseOrderCode D rD) (injection : InjectionCode D ZFSet.omega c) | |
| variable (hP : P ∈ M.sets) (hH : H ∈ M.sets) (hOld : old ∈ M.sets) (hrH : rH ∈ M.sets) | |
| variable (hD : D ∈ M.sets) (hrD : rD ∈ M.sets) (hc : c ∈ M.sets) | |
| variable (small : M.groundEmbeddable (relationImage P H old) ZFSet.omega) | |
| variable (hlo : lo ∈ D) (hhi : hi ∈ D) (gap : ZFSet.pair lo hi ∈ rD) | |
| include pairing unions powers separation collection infinite top greatest | |
| height linear target injection hP hH hOld hrH hD hrD hc small hlo hhi gap | |
| theorem exists_codedBinaryTileHeight {L v ν first second : ZFSet.{u}} | |
| (tileMeet : MeetOrderCode L v ν) (hL : L ∈ M.sets) (hν : ν ∈ M.sets) | |
| (left : MeetEmbeddingCode P L r v μ ν first) (right : MeetEmbeddingCode P L r v μ ν second) | |
| (hFirst : first ∈ M.sets) (hSecond : second ∈ M.sets) | |
| (leftIdeal : ∀ x y z, ZFSet.pair x y ∈ first → z ∈ L → ZFSet.pair z y ∈ v → | |
| ∃ a ∈ P, ZFSet.pair a z ∈ first) | |
| (rightIdeal : ∀ x y z, ZFSet.pair x y ∈ second → z ∈ L → ZFSet.pair z y ∈ v → | |
| ∃ a ∈ P, ZFSet.pair a z ∈ second) | |
| (cover : ∀ z ∈ L, (∃ x ∈ P, ZFSet.pair x z ∈ first) ∨ ∃ x ∈ P, ZFSet.pair x z ∈ second) : | |
| ∃ h ∈ M.sets, IntervalHeightCode L v D rD lo hi h ∧ relationImage L D h ∈ M.sets ∧ | |
| M.groundEmbeddable (relationImage L D h) ZFSet.omega := by | |
| let tile := binaryTileOfCodes source tileMeet left right leftIdeal rightIdeal cover | |
| have seedGround : (SetMembers.presentation P).graph (SetMembers.presentation H) | |
| (height.smallHeight source linear).value ∈ M.sets := by | |
| rw [height.smallHeight_graph] | |
| exact hOld | |
| have seedSmall : M.groundEmbeddable (relationImage P H | |
| ((SetMembers.presentation P).graph (SetMembers.presentation H) (height.smallHeight source linear).value)) ZFSet.omega := by | |
| rw [height.smallHeight_graph] | |
| exact small | |
| have leftGround : (SetMembers.presentation P).graph (SetMembers.presentation L) tile.root.toFun ∈ M.sets := by | |
| change (SetMembers.presentation P).graph (SetMembers.presentation L) left.smallValue ∈ M.sets | |
| rw [left.smallValue_graph] | |
| exact hFirst | |
| have rightGround : (SetMembers.presentation P).graph (SetMembers.presentation L) (tile.child ⟨()⟩).toFun ∈ M.sets := by | |
| change (SetMembers.presentation P).graph (SetMembers.presentation L) right.smallValue ∈ M.sets | |
| rw [right.smallValue_graph] | |
| exact hSecond | |
| exact M.exists_binaryTileIntervalHeight pairing unions powers separation collection infinite | |
| (SetMembers.presentation P) (SetMembers.presentation H) top greatest linear.smallOrder | |
| (height.smallHeight source linear) (fun _ _ => Iff.rfl) linear target injection | |
| hP hH seedGround hrH hD hrD hc seedSmall hlo hhi gap tile (SetMembers.presentation L) | |
| hL hν (fun _ _ => Iff.rfl) tileMeet.operation tileMeet.smallMeet_entry leftGround rightGround | |
| theorem exists_separationTileHeight {W : ZFSet.{u}} | |
| (hr : r ∈ M.sets) (hμ : μ ∈ M.sets) (hW : W ∈ P) : | |
| ∃ h ∈ M.sets, IntervalHeightCode (separationTileCarrier P r W) (separationTileOrder P r μ W) | |
| D rD lo hi h ∧ relationImage (separationTileCarrier P r W) D h ∈ M.sets ∧ | |
| M.groundEmbeddable (relationImage (separationTileCarrier P r W) D h) ZFSet.omega := by | |
| let tile := separationTileCoding source ⟨W, hW⟩ | |
| have ground := M.separationTile_ground pairing unions powers separation source hP hr hμ hW | |
| have embeddings := separationTile_embeddings source hW | |
| apply M.exists_codedBinaryTileHeight pairing unions powers separation collection infinite | |
| source top greatest height linear target injection hP hH hOld hrH hD hrD hc small hlo hhi gap | |
| tile.meetOrder ground.1 ground.2.2.1 embeddings.1 embeddings.2 ground.2.2.2.1 ground.2.2.2.2 | |
| · intro x y z entry hz lower | |
| obtain ⟨hx, equal⟩ := (pair_mem_attachmentOldEmbeddingGraph P x y).1 entry | |
| subst y | |
| exact tile.old_graph_ideal hx hz lower | |
| · exact fun _ _ _ entry hz lower => tile.template_graph_ideal entry hz lower | |
| · exact tile.vertex_cover | |
| theorem exists_compressionTileHeight {f : ZFSet.{u}} | |
| (embedding : MeetEmbeddingCode P P r r μ μ f) | |
| (K : {x : ZFSet.{u} // x ∈ P}) | |
| (range : ∀ z, (∃ x ∈ P, ZFSet.pair x z ∈ f) ↔ z ∈ P ∧ ZFSet.pair z K.val ∈ r) : | |
| let topRaw : {x : ZFSet.{u} // x ∈ P} := ⟨SetMembers.raw top, SetMembers.raw_mem top⟩ | |
| let rawGreatest : ∀ x, source.toMeetOrder.le x topRaw := | |
| fun x => by | |
| change ZFSet.pair x.val (SetMembers.raw top) ∈ r | |
| have lower := greatest (SetMembers.ofMem x.val x.property) | |
| change ZFSet.pair (SetMembers.raw (SetMembers.ofMem x.val x.property)) (SetMembers.raw top) ∈ r at lower | |
| simpa only [SetMembers.raw_ofMem] using lower | |
| let tile := compressionTileCoding source embedding topRaw K rawGreatest range | |
| ∃ h ∈ M.sets, IntervalHeightCode tile.carrier tile.order D rD lo hi h ∧ | |
| relationImage tile.carrier D h ∈ M.sets ∧ | |
| M.groundEmbeddable (relationImage tile.carrier D h) ZFSet.omega := by | |
| dsimp only | |
| obtain ⟨h, ground, strict, inside, rangeGround, rangeSmall, _⟩ := | |
| M.exists_groundHeightInterpolation pairing unions powers separation collection infinite | |
| hP hH hrH hOld hD hrD hc height linear target injection small hlo hhi gap | |
| have codes := compressionTile_exact_codes source embedding | |
| ⟨SetMembers.raw top, SetMembers.raw_mem top⟩ K | |
| (fun x => by | |
| change ZFSet.pair x.val (SetMembers.raw top) ∈ r | |
| have lower := greatest (SetMembers.ofMem x.val x.property) | |
| change ZFSet.pair (SetMembers.raw (SetMembers.ofMem x.val x.property)) (SetMembers.raw top) ∈ r at lower | |
| simpa only [SetMembers.raw_ofMem] using lower) range | |
| rw [codes.1, codes.2.1] | |
| exact ⟨h, ground, ⟨strict, inside⟩, rangeGround, rangeSmall⟩ | |
| end PartitionPilot.Forcing.TransitiveGround | |
| end OAI | |