openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Definability /CodedInjectiveCones.lean
| import OAI.SetTheory.PartitionPrinciple.Definability.MapFamilyApplicationGraphs | |
| import OAI.SetTheory.PartitionPrinciple.Forcing.GroundSmallFunctionPermutations | |
| import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundChronologyPairs | |
| namespace OAI | |
| namespace PartitionPilot.Forcing | |
| section | |
| open SetFormula | |
| universe u | |
| def GraphDiagonalCode (f : ZFSet.{u}) : Prop := | |
| ∀ x y, ZFSet.pair x y ∈ f → x = y | |
| def GraphCompositionCode (f g h : ZFSet.{u}) : Prop := | |
| ∀ x y, ZFSet.pair x y ∈ f → ∀ z, | |
| (ZFSet.pair y z ∈ g ↔ ZFSet.pair x z ∈ h) | |
| namespace BoundedFormula | |
| def graphDiagonalFormula {n} (f : Fin n) : BoundedFormula n := | |
| .allMem f (.allMem 0 (.allMem 0 (.allMem 2 (.allMem 0 | |
| (imp (orderedPairFormula 4 2 0) (.equal 2 0)))))) | |
| theorem truth_graphDiagonalFormula {n} (f : Fin n) (env : Fin n → ZFSet.{u}) : | |
| Truth (graphDiagonalFormula f) env ↔ GraphDiagonalCode (env f) := by | |
| simp only [graphDiagonalFormula, Truth, truth_imp, truth_orderedPairFormula] | |
| change (∀ p ∈ env f, ∀ a ∈ p, ∀ x ∈ a, ∀ b ∈ p, ∀ y ∈ b, | |
| p = ZFSet.pair x y → x = y) ↔ _ | |
| constructor | |
| · intro h x y entry | |
| exact h (ZFSet.pair x y) entry {x, y} (ZFSet.mem_pair.2 (Or.inr rfl)) | |
| x (ZFSet.mem_pair.2 (Or.inl rfl)) {x, y} (ZFSet.mem_pair.2 (Or.inr rfl)) | |
| y (ZFSet.mem_pair.2 (Or.inr rfl)) rfl | |
| · intro h p hp a _ x _ b _ y _ equal | |
| exact h x y (equal ▸ hp) | |
| def graphCompositionFormula {n} (f g h : Fin n) : BoundedFormula n := | |
| .allMem f (.allMem 0 (.allMem 0 (.allMem 2 (.allMem 0 | |
| (imp (orderedPairFormula 4 2 0) | |
| (graphFiberEqualityFormula 0 2 g.succ.succ.succ.succ.succ h.succ.succ.succ.succ.succ)))))) | |
| theorem truth_graphCompositionFormula {n} (f g h : Fin n) (env : Fin n → ZFSet.{u}) : | |
| Truth (graphCompositionFormula f g h) env ↔ GraphCompositionCode (env f) (env g) (env h) := by | |
| simp only [graphCompositionFormula, Truth, truth_imp, truth_orderedPairFormula, | |
| truth_graphFiberEqualityFormula] | |
| change (∀ p ∈ env f, ∀ a ∈ p, ∀ x ∈ a, ∀ b ∈ p, ∀ y ∈ b, | |
| p = ZFSet.pair x y → ∀ z, (ZFSet.pair y z ∈ env g ↔ ZFSet.pair x z ∈ env h)) ↔ _ | |
| constructor | |
| · intro law x y entry | |
| exact law (ZFSet.pair x y) entry {x, y} (ZFSet.mem_pair.2 (Or.inr rfl)) | |
| x (ZFSet.mem_pair.2 (Or.inl rfl)) {x, y} (ZFSet.mem_pair.2 (Or.inr rfl)) | |
| y (ZFSet.mem_pair.2 (Or.inr rfl)) rfl | |
| · intro law p hp a _ x _ b _ y _ equal | |
| exact law x y (equal ▸ hp) | |
| end BoundedFormula | |
| end | |
| section | |
| open SetRealization SetFormula | |
| universe u | |
| noncomputable def identityFunctionGraph (A : ZFSet.{u}) : ZFSet.{u} := | |
| (SetMembers.presentation A).graph (SetMembers.presentation A) id | |
| theorem mem_identityFunctionGraph (A z : ZFSet.{u}) : | |
| z ∈ identityFunctionGraph A ↔ ∃ x ∈ A, z = ZFSet.pair x x := by | |
| constructor | |
| · intro hz | |
| obtain ⟨x, eq⟩ := ((SetMembers.presentation A).mem_graph (SetMembers.presentation A) id z).1 hz | |
| exact ⟨SetMembers.raw x, SetMembers.raw_mem x, eq.symm⟩ | |
| · rintro ⟨x, hx, rfl⟩ | |
| have entry := ((SetMembers.presentation A).pair_mem_graph (SetMembers.presentation A) id (SetMembers.ofMem x hx) (SetMembers.ofMem x hx)).2 rfl | |
| change ZFSet.pair (SetMembers.raw (SetMembers.ofMem x hx)) (SetMembers.raw (SetMembers.ofMem x hx)) ∈ identityFunctionGraph A at entry | |
| simpa only [SetMembers.raw_ofMem] using entry | |
| theorem pair_mem_identityFunctionGraph (A x y : ZFSet.{u}) : | |
| ZFSet.pair x y ∈ identityFunctionGraph A ↔ x = y ∧ x ∈ A := by | |
| rw [mem_identityFunctionGraph] | |
| constructor | |
| · rintro ⟨z, hz, equal⟩ | |
| obtain ⟨rfl, rfl⟩ := ZFSet.pair_inj.1 equal | |
| exact ⟨rfl, hz⟩ | |
| · rintro ⟨rfl, hx⟩ | |
| exact ⟨x, hx, rfl⟩ | |
| theorem identityFunctionGraph_injection (A : ZFSet.{u}) : InjectionCode A A (identityFunctionGraph A) := | |
| (SetMembers.presentation A).graph_injection (SetMembers.presentation A) id (fun _ _ h => h) | |
| namespace TransitiveGround | |
| variable (M : TransitiveGround.{u}) | |
| theorem identityFunctionGraph_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) | |
| {A : ZFSet.{u}} (hA : A ∈ M.sets) : identityFunctionGraph A ∈ M.sets := by | |
| let phi : BoundedFormula 2 := .exMem 1 (BoundedFormula.orderedPairFormula 1 0 0) | |
| have truth (z : ZFSet.{u}) : BoundedFormula.Truth phi (extend z (extend A Fin.elim0)) ↔ | |
| z ∈ identityFunctionGraph A := by | |
| simp only [phi, BoundedFormula.truth_exMem, BoundedFormula.truth_orderedPairFormula, | |
| extend, Fin.cases_zero] | |
| exact (mem_identityFunctionGraph A z).symm | |
| have equal : ZFSet.sep (fun z => BoundedFormula.Truth phi (extend z (extend A Fin.elim0))) (ZFSet.prod A A) = | |
| identityFunctionGraph A := by | |
| apply ZFSet.ext | |
| intro z | |
| rw [ZFSet.mem_sep, truth] | |
| exact ⟨And.right, fun hz => ⟨(identityFunctionGraph_injection A).function.1 hz, hz⟩⟩ | |
| rw [← equal] | |
| exact M.bounded_separation_mem separation phi (extend A Fin.elim0) | |
| (Fin.cases hA (fun i => Fin.elim0 i)) (M.prod_mem pairing unions powers separation hA hA) | |
| end TransitiveGround | |
| end | |
| section | |
| universe u v | |
| structure CodedDirectSystem (I : Type v) [Preorder I] where | |
| carrier : I → ZFSet.{u} | |
| map : ∀ {i j : I}, i ≤ j → ZFSet.{u} | |
| injection : ∀ {i j : I} (before : i ≤ j), InjectionCode (carrier i) (carrier j) (map before) | |
| identity : ∀ i, map (le_refl i) = identityFunctionGraph (carrier i) | |
| composition : ∀ {i j k : I} (first : i ≤ j) (second : j ≤ k), | |
| map (le_trans first second) = relationCompose (carrier i) (carrier j) (carrier k) (map first) (map second) | |
| common_upper : ∀ i j : I, ∃ k, i ≤ k ∧ j ≤ k | |
| namespace CodedDirectSystem | |
| variable {I : Type v} [Preorder I] (system : CodedDirectSystem.{u} I) | |
| def Related (i : I) (x : ZFSet.{u}) (j : I) (y : ZFSet.{u}) : Prop := | |
| ∃ k, ∃ first : i ≤ k, ∃ second : j ≤ k, ∃ z, | |
| ZFSet.pair x z ∈ system.map first ∧ ZFSet.pair y z ∈ system.map second | |
| theorem map_entry_bounds {i j : I} (before : i ≤ j) {x y : ZFSet.{u}} | |
| (entry : ZFSet.pair x y ∈ system.map before) : | |
| x ∈ system.carrier i ∧ y ∈ system.carrier j := | |
| ZFSet.pair_mem_prod.1 ((system.injection before).function.1 entry) | |
| theorem map_entry_total {i j : I} (before : i ≤ j) {x : ZFSet.{u}} | |
| (member : x ∈ system.carrier i) : ∃ y, ZFSet.pair x y ∈ system.map before := by | |
| obtain ⟨y, entry, _⟩ := (system.injection before).function.2 x member | |
| exact ⟨y, entry⟩ | |
| theorem map_identity_entry {i : I} {x : ZFSet.{u}} (member : x ∈ system.carrier i) : | |
| ZFSet.pair x x ∈ system.map (le_refl i) := by | |
| rw [system.identity] | |
| exact (pair_mem_identityFunctionGraph _ _ _).2 ⟨rfl, member⟩ | |
| theorem map_comp_entry {i j k : I} (first : i ≤ j) (second : j ≤ k) {x y z : ZFSet.{u}} | |
| (xy : ZFSet.pair x y ∈ system.map first) (yz : ZFSet.pair y z ∈ system.map second) : | |
| ZFSet.pair x z ∈ system.map (le_trans first second) := by | |
| rw [system.composition first second] | |
| exact (pair_mem_relationCompose _ _ _ _ _ _ _).2 | |
| ⟨(system.map_entry_bounds first xy).1, (system.map_entry_bounds second yz).2, | |
| y, (system.map_entry_bounds first xy).2, xy, yz⟩ | |
| end CodedDirectSystem | |
| end | |
| section | |
| universe u | |
| theorem GraphDiagonalCode.eq_identityFunctionGraph {A B f : ZFSet.{u}} | |
| (diagonal : GraphDiagonalCode f) (function : ZFSet.IsFunc A B f) : | |
| f = identityFunctionGraph A := by | |
| apply ZFSet.ext | |
| intro z | |
| constructor | |
| · intro hz | |
| obtain ⟨x, hx, y, _, rfl⟩ := ZFSet.mem_prod.1 (function.1 hz) | |
| exact (pair_mem_identityFunctionGraph A x y).2 ⟨diagonal x y hz, hx⟩ | |
| · intro hz | |
| obtain ⟨x, hx, rfl⟩ := (mem_identityFunctionGraph A z).1 hz | |
| obtain ⟨v, entry, _⟩ := function.2 x hx | |
| have same : v = x := (diagonal x v entry).symm | |
| exact same ▸ entry | |
| theorem graphDiagonalCode_identity (A : ZFSet.{u}) : GraphDiagonalCode (identityFunctionGraph A) := | |
| fun x y entry => ((pair_mem_identityFunctionGraph A x y).1 entry).1 | |
| theorem GraphCompositionCode.eq_relationCompose {A B C f g h : ZFSet.{u}} | |
| (coherent : GraphCompositionCode f g h) (first : ZFSet.IsFunc A B f) | |
| (shape : h ⊆ ZFSet.prod A C) : h = relationCompose A B C f g := by | |
| apply ZFSet.ext | |
| intro z | |
| constructor | |
| · intro hz | |
| obtain ⟨x, hx, v, hv, rfl⟩ := ZFSet.mem_prod.1 (shape hz) | |
| obtain ⟨y, entry, _⟩ := first.2 x hx | |
| have hy := (ZFSet.pair_mem_prod.1 (first.1 entry)).2 | |
| exact (pair_mem_relationCompose A B C f g x v).2 | |
| ⟨hx, hv, y, hy, entry, (coherent x y entry v).2 hz⟩ | |
| · intro hz | |
| obtain ⟨x, _, y, _, v, _, rfl, xy, yv⟩ := (mem_relationCompose A B C f g z).1 hz | |
| exact (coherent x y xy v).1 yv | |
| theorem graphCompositionCode_relationCompose {A B C f g : ZFSet.{u}} | |
| (first : ZFSet.IsFunc A B f) (second : ZFSet.IsFunc B C g) : | |
| GraphCompositionCode f g (relationCompose A B C f g) := by | |
| intro x y xy z | |
| constructor | |
| · intro yz | |
| have bounds := ZFSet.pair_mem_prod.1 (first.1 xy) | |
| have target := (ZFSet.pair_mem_prod.1 (second.1 yz)).2 | |
| exact (pair_mem_relationCompose A B C f g x z).2 | |
| ⟨bounds.1, target, y, bounds.2, xy, yz⟩ | |
| · intro xz | |
| obtain ⟨_, _, v, _, xv, vz⟩ := (pair_mem_relationCompose A B C f g x z).1 xz | |
| have equal := (show FunctionGraphOn A f from ⟨B, first⟩).unique xv xy | |
| exact equal ▸ vz | |
| theorem relationCompose_assoc (A B C D r s t : ZFSet.{u}) : | |
| relationCompose A C D (relationCompose A B C r s) t = | |
| relationCompose A B D r (relationCompose B C D s t) := by | |
| apply ZFSet.ext | |
| intro z | |
| constructor | |
| · intro entry | |
| obtain ⟨x, hx, y, hy, w, hw, rfl, xy, yw⟩ := (mem_relationCompose _ _ _ _ _ z).1 entry | |
| obtain ⟨_, _, a, ha, xa, ay⟩ := (pair_mem_relationCompose _ _ _ _ _ x y).1 xy | |
| exact (pair_mem_relationCompose _ _ _ _ _ x w).2 | |
| ⟨hx, hw, a, ha, xa, (pair_mem_relationCompose _ _ _ _ _ a w).2 ⟨ha, hw, y, hy, ay, yw⟩⟩ | |
| · intro entry | |
| obtain ⟨x, hx, a, ha, w, hw, rfl, xa, aw⟩ := (mem_relationCompose _ _ _ _ _ z).1 entry | |
| obtain ⟨_, _, y, hy, ay, yw⟩ := (pair_mem_relationCompose _ _ _ _ _ a w).1 aw | |
| exact (pair_mem_relationCompose _ _ _ _ _ x w).2 | |
| ⟨hx, hw, y, hy, (pair_mem_relationCompose _ _ _ _ _ x y).2 ⟨hx, hy, a, ha, xa, ay⟩, yw⟩ | |
| theorem relationCompose_identity_left {A B r : ZFSet.{u}} (bound : r ⊆ ZFSet.prod A B) : | |
| relationCompose A A B (identityFunctionGraph A) r = r := by | |
| apply ZFSet.ext | |
| intro z | |
| constructor | |
| · intro entry | |
| obtain ⟨x, _, a, _, y, _, rfl, identity, image⟩ := (mem_relationCompose _ _ _ _ _ z).1 entry | |
| obtain ⟨rfl, _⟩ := (pair_mem_identityFunctionGraph A x a).1 identity | |
| exact image | |
| · intro entry | |
| obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 (bound entry) | |
| exact (pair_mem_relationCompose _ _ _ _ _ x y).2 | |
| ⟨hx, hy, x, hx, (pair_mem_identityFunctionGraph A x x).2 ⟨rfl, hx⟩, entry⟩ | |
| theorem relationCompose_identity_right {A B r : ZFSet.{u}} (bound : r ⊆ ZFSet.prod A B) : | |
| relationCompose A B B r (identityFunctionGraph B) = r := by | |
| apply ZFSet.ext | |
| intro z | |
| constructor | |
| · intro entry | |
| obtain ⟨x, _, a, _, y, _, rfl, image, identity⟩ := (mem_relationCompose _ _ _ _ _ z).1 entry | |
| obtain ⟨rfl, _⟩ := (pair_mem_identityFunctionGraph B a y).1 identity | |
| exact image | |
| · intro entry | |
| obtain ⟨x, hx, y, hy, rfl⟩ := ZFSet.mem_prod.1 (bound entry) | |
| exact (pair_mem_relationCompose _ _ _ _ _ x y).2 | |
| ⟨hx, hy, y, hy, entry, (pair_mem_identityFunctionGraph B y y).2 ⟨rfl, hy⟩⟩ | |
| end | |
| section | |
| universe u v | |
| structure CodedDirectPresentation {I : Type v} [Small.{u} I] [Preorder I] | |
| (system : CodedDirectSystem.{u} I) (T U A F : ZFSet.{u}) where | |
| key : I → ZFSet.{u} | |
| key_injective : Function.Injective key | |
| key_range : ZFSet.range key = T | |
| key_order : ∀ i j, i ≤ j ↔ key i = key j ∨ key i ∈ key j | |
| carrier_function : FunctionGraphOn T A | |
| carrier_entry : ∀ i, ZFSet.pair (key i) (system.carrier i) ∈ A | |
| map_function : FunctionGraphOn (chronologyPairs T) F | |
| map_entry : ∀ {i j} (before : i ≤ j), ZFSet.pair (ZFSet.pair (key j) (key i)) (system.map before) ∈ F | |
| carrier_bound : ∀ i, system.carrier i ⊆ U | |
| namespace CodedDirectPresentation | |
| variable {I : Type v} [Small.{u} I] [Preorder I] {system : CodedDirectSystem.{u} I} | |
| variable {T U A F : ZFSet.{u}} (p : CodedDirectPresentation system T U A F) | |
| theorem key_mem (i : I) : p.key i ∈ T := by | |
| have member : p.key i ∈ ZFSet.range p.key := ZFSet.mem_range.2 ⟨i, rfl⟩ | |
| simpa only [p.key_range] using member | |
| theorem exists_key {j : ZFSet.{u}} (member : j ∈ T) : ∃ i, p.key i = j := | |
| ZFSet.mem_range.1 (p.key_range.symm ▸ member) | |
| theorem label_mem (i : I) (x : ZFSet.{u}) : | |
| ZFSet.pair (p.key i) x ∈ indexedCarrierLabels T U A ↔ x ∈ system.carrier i := | |
| pair_mem_indexedCarrierLabels_of_entry p.carrier_function (p.carrier_entry i) (p.carrier_bound i) | |
| theorem label_cases {z : ZFSet.{u}} (member : z ∈ indexedCarrierLabels T U A) : | |
| ∃ i x, x ∈ system.carrier i ∧ z = ZFSet.pair (p.key i) x := by | |
| obtain ⟨j, hj, X, _, x, hx, _, rfl, entry⟩ := (mem_indexedCarrierLabels T U A z).1 member | |
| obtain ⟨i, rfl⟩ := p.exists_key hj | |
| have equal := p.carrier_function.unique entry (p.carrier_entry i) | |
| exact ⟨i, x, equal ▸ hx, rfl⟩ | |
| theorem map_lookup {i j : I} {f : ZFSet.{u}} | |
| (entry : ZFSet.pair (ZFSet.pair (p.key j) (p.key i)) f ∈ F) : | |
| ∃ before : i ≤ j, f = system.map before := by | |
| have ordered := (pair_mem_chronologyPairs T (p.key j) (p.key i)).1 | |
| (p.map_function.pair_source entry) | |
| have before := (p.key_order i j).2 ordered.2.2 | |
| exact ⟨before, p.map_function.unique entry (p.map_entry before)⟩ | |
| end CodedDirectPresentation | |
| end | |
| namespace CodedDirectSystem | |
| universe u v | |
| variable {I : Type v} [Preorder I] (system : CodedDirectSystem.{u} I) | |
| theorem related_bounds {i j : I} {x y : ZFSet.{u}} (related : system.Related i x j y) : | |
| x ∈ system.carrier i ∧ y ∈ system.carrier j := by | |
| obtain ⟨k, first, second, z, xz, yz⟩ := related | |
| exact ⟨(system.map_entry_bounds first xz).1, (system.map_entry_bounds second yz).1⟩ | |
| theorem related_refl {i : I} {x : ZFSet.{u}} (member : x ∈ system.carrier i) : | |
| system.Related i x i x := | |
| ⟨i, le_rfl, le_rfl, x, system.map_identity_entry member, system.map_identity_entry member⟩ | |
| theorem related_symm {i j : I} {x y : ZFSet.{u}} (related : system.Related i x j y) : | |
| system.Related j y i x := by | |
| obtain ⟨k, first, second, z, xz, yz⟩ := related | |
| exact ⟨k, second, first, z, yz, xz⟩ | |
| theorem related_trans {i j k : I} {x y z : ZFSet.{u}} | |
| (first : system.Related i x j y) (second : system.Related j y k z) : | |
| system.Related i x k z := by | |
| obtain ⟨a, ia, ja, v, xv, yv⟩ := first | |
| obtain ⟨b, jb, kb, w, yw, zw⟩ := second | |
| obtain ⟨c, ac, bc⟩ := system.common_upper a b | |
| obtain ⟨v', vv'⟩ := system.map_entry_total ac (system.map_entry_bounds ia xv).2 | |
| obtain ⟨w', ww'⟩ := system.map_entry_total bc (system.map_entry_bounds jb yw).2 | |
| have yv' := system.map_comp_entry ja ac yv vv' | |
| have yw' := system.map_comp_entry jb bc yw ww' | |
| have equal : v' = w' := | |
| (show FunctionGraphOn (system.carrier j) (system.map (le_trans ja ac)) from | |
| ⟨system.carrier c, (system.injection (le_trans ja ac)).function⟩).unique yv' yw' | |
| refine ⟨c, le_trans ia ac, le_trans kb bc, v', system.map_comp_entry ia ac xv vv', ?_⟩ | |
| exact equal.symm ▸ system.map_comp_entry kb bc zw ww' | |
| theorem related_same_iff {i : I} {x y : ZFSet.{u}} : | |
| system.Related i x i y ↔ x = y ∧ x ∈ system.carrier i := by | |
| constructor | |
| · rintro ⟨k, first, second, z, xz, yz⟩ | |
| exact ⟨(system.injection first).injective x y z xz yz, (system.map_entry_bounds first xz).1⟩ | |
| · rintro ⟨rfl, member⟩ | |
| exact system.related_refl member | |
| theorem related_same_iff_eq {i : I} {x y : ZFSet.{u}} (member : x ∈ system.carrier i) : | |
| system.Related i x i y ↔ x = y := by | |
| rw [system.related_same_iff] | |
| exact and_iff_left member | |
| theorem related_of_entry {i j : I} (before : i ≤ j) {x y : ZFSet.{u}} | |
| (entry : ZFSet.pair x y ∈ system.map before) : system.Related i x j y := | |
| ⟨j, before, le_rfl, y, entry, system.map_identity_entry (system.map_entry_bounds before entry).2⟩ | |
| theorem related_iff_entry {i j : I} (before : i ≤ j) {x y : ZFSet.{u}} : | |
| system.Related i x j y ↔ ZFSet.pair x y ∈ system.map before := by | |
| constructor | |
| · intro related | |
| obtain ⟨v, entry⟩ := system.map_entry_total before (system.related_bounds related).1 | |
| have same := system.related_trans (system.related_symm (system.related_of_entry before entry)) related | |
| have equal := (system.related_same_iff).1 same | |
| exact equal.1 ▸ entry | |
| · exact system.related_of_entry before | |
| theorem related_map_left_iff {i j k : I} (before : i ≤ j) {x y z : ZFSet.{u}} | |
| (entry : ZFSet.pair x y ∈ system.map before) : | |
| system.Related i x k z ↔ system.Related j y k z := by | |
| have step := system.related_of_entry before entry | |
| exact ⟨fun related => system.related_trans (system.related_symm step) related, | |
| fun related => system.related_trans step related⟩ | |
| theorem related_map_right_iff {i j k : I} (before : i ≤ j) {x y z : ZFSet.{u}} | |
| (entry : ZFSet.pair x y ∈ system.map before) : | |
| system.Related k z i x ↔ system.Related k z j y := by | |
| have step := system.related_of_entry before entry | |
| exact ⟨fun related => system.related_trans related step, | |
| fun related => system.related_trans related (system.related_symm step)⟩ | |
| theorem related_iff_common_images {i j k : I} (first : i ≤ k) (second : j ≤ k) | |
| {x y v w : ZFSet.{u}} (xv : ZFSet.pair x v ∈ system.map first) | |
| (yw : ZFSet.pair y w ∈ system.map second) : | |
| system.Related i x j y ↔ v = w := by | |
| rw [system.related_map_left_iff first xv, system.related_map_right_iff second yw] | |
| exact system.related_same_iff_eq (system.map_entry_bounds first xv).2 | |
| end CodedDirectSystem | |
| namespace CodedDirectSystem | |
| universe u v | |
| structure InjectiveCone {I : Type v} [Preorder I] | |
| (system : CodedDirectSystem.{u} I) (Q : ZFSet.{u}) where | |
| map : I → ZFSet.{u} | |
| injection : ∀ i, InjectionCode (system.carrier i) Q (map i) | |
| coherence : ∀ {i j : I} (before : i ≤ j), | |
| map i = relationCompose (system.carrier i) (system.carrier j) Q | |
| (system.map before) (map j) | |
| namespace InjectiveCone | |
| variable {I : Type v} [Preorder I] {system : CodedDirectSystem.{u} I} | |
| variable {Q : ZFSet.{u}} (cone : system.InjectiveCone Q) | |
| theorem entry_bounds {i : I} {x y : ZFSet.{u}} | |
| (entry : ZFSet.pair x y ∈ cone.map i) : x ∈ system.carrier i ∧ y ∈ Q := | |
| ZFSet.pair_mem_prod.1 ((cone.injection i).function.1 entry) | |
| theorem entry_total {i : I} {x : ZFSet.{u}} (hx : x ∈ system.carrier i) : | |
| ∃ y, ZFSet.pair x y ∈ cone.map i := by | |
| obtain ⟨y, entry, _⟩ := (cone.injection i).function.2 x hx | |
| exact ⟨y, entry⟩ | |
| theorem later_entry_iff {i j : I} (before : i ≤ j) {x y z : ZFSet.{u}} | |
| (xy : ZFSet.pair x y ∈ system.map before) : | |
| ZFSet.pair x z ∈ cone.map i ↔ ZFSet.pair y z ∈ cone.map j := by | |
| constructor | |
| · intro xz | |
| rw [cone.coherence before] at xz | |
| obtain ⟨_, _, y', _, xy', yz⟩ := (pair_mem_relationCompose _ _ _ _ _ _ _).1 xz | |
| have equal : y' = y := | |
| (show FunctionGraphOn (system.carrier i) (system.map before) from | |
| ⟨system.carrier j, (system.injection before).function⟩).unique xy' xy | |
| exact equal ▸ yz | |
| · intro yz | |
| rw [cone.coherence before] | |
| exact (pair_mem_relationCompose _ _ _ _ _ _ _).2 | |
| ⟨(system.map_entry_bounds before xy).1, (cone.entry_bounds yz).2, | |
| y, (system.map_entry_bounds before xy).2, xy, yz⟩ | |
| theorem entry_eq_iff_related {i j : I} {x y a b : ZFSet.{u}} | |
| (xa : ZFSet.pair x a ∈ cone.map i) (yb : ZFSet.pair y b ∈ cone.map j) : | |
| a = b ↔ system.Related i x j y := by | |
| constructor | |
| · intro equal | |
| obtain ⟨k, ik, jk⟩ := system.common_upper i j | |
| obtain ⟨x', xx'⟩ := system.map_entry_total ik (cone.entry_bounds xa).1 | |
| obtain ⟨y', yy'⟩ := system.map_entry_total jk (cone.entry_bounds yb).1 | |
| have x'a := (cone.later_entry_iff ik xx').1 xa | |
| have y'b := (cone.later_entry_iff jk yy').1 yb | |
| have same : x' = y' := (cone.injection k).injective x' y' a x'a (equal.symm ▸ y'b) | |
| exact ⟨k, ik, jk, x', xx', same.symm ▸ yy'⟩ | |
| · rintro ⟨k, ik, jk, z, xz, yz⟩ | |
| exact (show FunctionGraphOn (system.carrier k) (cone.map k) from | |
| ⟨Q, (cone.injection k).function⟩).unique | |
| ((cone.later_entry_iff ik xz).1 xa) ((cone.later_entry_iff jk yz).1 yb) | |
| def Covers (B : ZFSet.{u}) : Prop := | |
| ∀ y ∈ B, ∃ i x, x ∈ system.carrier i ∧ ZFSet.pair x y ∈ cone.map i | |
| end InjectiveCone | |
| end CodedDirectSystem | |
| end PartitionPilot.Forcing | |
| end OAI | |