openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Forcing /CodedRecursiveTaskActions.lean
| import OAI.SetTheory.PartitionPrinciple.Transfinite.RecursiveLiftAgreement | |
| namespace OAI | |
| namespace PartitionPilot.Forcing | |
| section | |
| universe u | |
| structure SetActionCode (G X m e A : ZFSet.{u}) : Prop where | |
| function : ZFSet.IsFunc (ZFSet.prod G X) X A | |
| one : ∀ p ∈ X, ZFSet.pair (ZFSet.pair e p) p ∈ A | |
| mul : ∀ g ∈ G, ∀ h ∈ G, ∀ k ∈ G, ∀ p ∈ X, ∀ q ∈ X, ∀ r ∈ X, | |
| ZFSet.pair (ZFSet.pair g h) k ∈ m → ZFSet.pair (ZFSet.pair h p) q ∈ A → | |
| ZFSet.pair (ZFSet.pair g q) r ∈ A → ZFSet.pair (ZFSet.pair k p) r ∈ A | |
| theorem PosetActionCode.toSetAction {G P m e r A : ZFSet.{u}} | |
| (action : PosetActionCode G P m e r A) : SetActionCode G P m e A := | |
| ⟨action.function, action.one, action.mul⟩ | |
| noncomputable def taggedActionGraph (G P N A B : ZFSet.{u}) : ZFSet.{u} := | |
| A ∪ ZFSet.sep (fun z => ∃ g ∈ G, ∃ q ∈ N, ∃ t ∈ N, | |
| z = ZFSet.pair (ZFSet.pair g (ZFSet.pair P q)) (ZFSet.pair P t) ∧ | |
| ZFSet.pair (ZFSet.pair g q) t ∈ B) | |
| (ZFSet.prod (ZFSet.prod G (taggedExtension P N)) (taggedExtension P N)) | |
| theorem triple_mem_taggedActionGraph (G P N A B g x y : ZFSet.{u}) : | |
| ZFSet.pair (ZFSet.pair g x) y ∈ taggedActionGraph G P N A B ↔ | |
| ZFSet.pair (ZFSet.pair g x) y ∈ A ∨ | |
| (g ∈ G ∧ ∃ q ∈ N, ∃ t ∈ N, x = ZFSet.pair P q ∧ y = ZFSet.pair P t ∧ | |
| ZFSet.pair (ZFSet.pair g q) t ∈ B) := by | |
| rw [taggedActionGraph, ZFSet.mem_union, ZFSet.mem_sep] | |
| apply or_congr Iff.rfl | |
| constructor | |
| · rintro ⟨_, g', hg, q, hq, t, ht, equal, entry⟩ | |
| obtain ⟨first, last⟩ := ZFSet.pair_inj.1 equal | |
| obtain ⟨actor, middle⟩ := ZFSet.pair_inj.1 first | |
| subst g' | |
| exact ⟨hg, q, hq, t, ht, middle, last, entry⟩ | |
| · rintro ⟨hg, q, hq, t, ht, rfl, rfl, entry⟩ | |
| exact ⟨ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 | |
| ⟨hg, pair_mem_taggedExtension.2 hq⟩, pair_mem_taggedExtension.2 ht⟩, | |
| g, hg, q, hq, t, ht, rfl, entry⟩ | |
| theorem SetActionCode.entry_shape {G X m e A g x y : ZFSet.{u}} | |
| (action : SetActionCode G X m e A) (entry : ZFSet.pair (ZFSet.pair g x) y ∈ A) : | |
| g ∈ G ∧ x ∈ X ∧ y ∈ X := by | |
| have shape := ZFSet.pair_mem_prod.1 (action.function.1 entry) | |
| have domain := ZFSet.pair_mem_prod.1 shape.1 | |
| exact ⟨domain.1, domain.2, shape.2⟩ | |
| theorem SetActionCode.entry_unique {G X m e A g x y z : ZFSet.{u}} | |
| (action : SetActionCode G X m e A) | |
| (first : ZFSet.pair (ZFSet.pair g x) y ∈ A) | |
| (second : ZFSet.pair (ZFSet.pair g x) z ∈ A) : y = z := by | |
| have shape := action.entry_shape first | |
| obtain ⟨w, _, unique⟩ := action.function.2 (ZFSet.pair g x) | |
| (ZFSet.pair_mem_prod.2 ⟨shape.1, shape.2.1⟩) | |
| exact (unique y first).trans (unique z second).symm | |
| theorem taggedActionGraph_old_iff {G P N A B g x y : ZFSet.{u}} (hx : x ∈ P) : | |
| ZFSet.pair (ZFSet.pair g x) y ∈ taggedActionGraph G P N A B ↔ | |
| ZFSet.pair (ZFSet.pair g x) y ∈ A := by | |
| rw [triple_mem_taggedActionGraph] | |
| refine ⟨fun h => h.elim id ?_, Or.inl⟩ | |
| rintro ⟨_, q, _, t, _, equal, _, _⟩ | |
| exact False.elim (pair_tag_not_mem P q (equal ▸ hx)) | |
| theorem taggedActionGraph_fresh_iff {G P N m e A B g q y : ZFSet.{u}} | |
| (old : SetActionCode G P m e A) (fresh : SetActionCode G N m e B) : | |
| ZFSet.pair (ZFSet.pair g (ZFSet.pair P q)) y ∈ taggedActionGraph G P N A B ↔ | |
| ∃ t ∈ N, y = ZFSet.pair P t ∧ ZFSet.pair (ZFSet.pair g q) t ∈ B := by | |
| rw [triple_mem_taggedActionGraph] | |
| constructor | |
| · rintro (entry | ⟨_, q', _, t, ht, equal, hy, entry⟩) | |
| · exact False.elim (pair_tag_not_mem P q (old.entry_shape entry).2.1) | |
| · have same := (ZFSet.pair_inj.1 equal).2 | |
| subst q' | |
| exact ⟨t, ht, hy, entry⟩ | |
| · rintro ⟨t, ht, hy, entry⟩ | |
| have shape := fresh.entry_shape entry | |
| exact Or.inr ⟨shape.1, q, shape.2.1, t, ht, rfl, hy, entry⟩ | |
| theorem taggedActionGraph_fresh_pair_iff {G P N m e A B g q t : ZFSet.{u}} | |
| (old : SetActionCode G P m e A) (fresh : SetActionCode G N m e B) : | |
| ZFSet.pair (ZFSet.pair g (ZFSet.pair P q)) (ZFSet.pair P t) ∈ | |
| taggedActionGraph G P N A B ↔ ZFSet.pair (ZFSet.pair g q) t ∈ B := by | |
| rw [taggedActionGraph_fresh_iff old fresh] | |
| constructor | |
| · rintro ⟨t', _, equal, entry⟩ | |
| exact (ZFSet.pair_inj.1 equal).2.symm ▸ entry | |
| · intro entry | |
| exact ⟨t, (fresh.entry_shape entry).2.2, rfl, entry⟩ | |
| theorem taggedActionGraph_subset {G P N m e A B : ZFSet.{u}} | |
| (old : SetActionCode G P m e A) : | |
| taggedActionGraph G P N A B ⊆ | |
| ZFSet.prod (ZFSet.prod G (taggedExtension P N)) (taggedExtension P N) := by | |
| intro z hz | |
| rcases ZFSet.mem_union.1 hz with oldEntry | freshEntry | |
| · obtain ⟨v, hv, y, hy, rfl⟩ := ZFSet.mem_prod.1 (old.function.1 oldEntry) | |
| obtain ⟨g, hg, x, hx, rfl⟩ := ZFSet.mem_prod.1 hv | |
| exact ZFSet.pair_mem_prod.2 ⟨ZFSet.pair_mem_prod.2 | |
| ⟨hg, old_mem_taggedExtension hx⟩, old_mem_taggedExtension hy⟩ | |
| · exact (ZFSet.mem_sep.1 freshEntry).1 | |
| theorem taggedActionGraph_function {G P N m e A B : ZFSet.{u}} | |
| (old : SetActionCode G P m e A) (fresh : SetActionCode G N m e B) : | |
| ZFSet.IsFunc (ZFSet.prod G (taggedExtension P N)) (taggedExtension P N) | |
| (taggedActionGraph G P N A B) := by | |
| refine ⟨taggedActionGraph_subset old, ?_⟩ | |
| intro v hv | |
| obtain ⟨g, hg, x, hx, rfl⟩ := ZFSet.mem_prod.1 hv | |
| rcases mem_taggedExtension.1 hx with hx | ⟨q, hq, rfl⟩ | |
| · obtain ⟨y, entry, unique⟩ := old.function.2 (ZFSet.pair g x) (ZFSet.pair_mem_prod.2 ⟨hg, hx⟩) | |
| exact ⟨y, taggedActionGraph_old_iff hx |>.2 entry, | |
| fun z hz => unique z ((taggedActionGraph_old_iff hx).1 hz)⟩ | |
| · obtain ⟨t, entry, unique⟩ := fresh.function.2 (ZFSet.pair g q) (ZFSet.pair_mem_prod.2 ⟨hg, hq⟩) | |
| refine ⟨ZFSet.pair P t, (taggedActionGraph_fresh_pair_iff old fresh).2 entry, ?_⟩ | |
| intro y hy | |
| obtain ⟨t', _, equal, entry'⟩ := (taggedActionGraph_fresh_iff old fresh).1 hy | |
| exact equal.trans (congrArg (ZFSet.pair P) (unique t' entry')) | |
| theorem taggedActionGraph_one {G P N m e A B : ZFSet.{u}} | |
| (old : SetActionCode G P m e A) (fresh : SetActionCode G N m e B) : | |
| ∀ x ∈ taggedExtension P N, ZFSet.pair (ZFSet.pair e x) x ∈ taggedActionGraph G P N A B := by | |
| intro x hx | |
| rcases mem_taggedExtension.1 hx with hx | ⟨q, hq, rfl⟩ | |
| · exact (taggedActionGraph_old_iff hx).2 (old.one x hx) | |
| · exact (taggedActionGraph_fresh_pair_iff old fresh).2 (fresh.one q hq) | |
| theorem taggedActionGraph_mul {G P N m e A B : ZFSet.{u}} | |
| (old : SetActionCode G P m e A) (fresh : SetActionCode G N m e B) : | |
| ∀ g ∈ G, ∀ h ∈ G, ∀ k ∈ G, ∀ p ∈ taggedExtension P N, | |
| ∀ q ∈ taggedExtension P N, ∀ s ∈ taggedExtension P N, | |
| ZFSet.pair (ZFSet.pair g h) k ∈ m → | |
| ZFSet.pair (ZFSet.pair h p) q ∈ taggedActionGraph G P N A B → | |
| ZFSet.pair (ZFSet.pair g q) s ∈ taggedActionGraph G P N A B → | |
| ZFSet.pair (ZFSet.pair k p) s ∈ taggedActionGraph G P N A B := by | |
| intro g hg h hh k hk p hp q _ s _ product first second | |
| rcases mem_taggedExtension.1 hp with hp | ⟨x, hx, rfl⟩ | |
| · have first' := (taggedActionGraph_old_iff hp).1 first | |
| have hq := (old.entry_shape first').2.2 | |
| have second' := (taggedActionGraph_old_iff hq).1 second | |
| have hs := (old.entry_shape second').2.2 | |
| exact (taggedActionGraph_old_iff hp).2 (old.mul g hg h hh k hk p hp q hq s hs product first' second') | |
| · obtain ⟨y, hy, rfl, first'⟩ := (taggedActionGraph_fresh_iff old fresh).1 first | |
| obtain ⟨z, hz, rfl, second'⟩ := (taggedActionGraph_fresh_iff old fresh).1 second | |
| exact (taggedActionGraph_fresh_pair_iff old fresh).2 | |
| (fresh.mul g hg h hh k hk x hx y hy z hz product first' second') | |
| theorem SetActionCode.tagged {G P N m e A B : ZFSet.{u}} | |
| (old : SetActionCode G P m e A) (fresh : SetActionCode G N m e B) : | |
| SetActionCode G (taggedExtension P N) m e (taggedActionGraph G P N A B) := | |
| ⟨taggedActionGraph_function old fresh, taggedActionGraph_one old fresh, taggedActionGraph_mul old fresh⟩ | |
| end | |
| namespace SetActionCode | |
| open SetRealization | |
| universe u | |
| variable {G X m inv one A : ZFSet.{u}} | |
| variable (action : SetActionCode G X m one A) | |
| noncomputable def rawAct (g : {g : ZFSet.{u} // g ∈ G}) | |
| (x : {x : ZFSet.{u} // x ∈ X}) : {x : ZFSet.{u} // x ∈ X} := | |
| let graph : FunctionGraphOn (ZFSet.prod G X) A := ⟨X, action.function⟩ | |
| let input := (⟨ZFSet.pair g.val x.val, ZFSet.pair_mem_prod.2 ⟨g.property, x.property⟩⟩ : | |
| {z : ZFSet.{u} // z ∈ ZFSet.prod G X}) | |
| ⟨graph.value input, (ZFSet.pair_mem_prod.1 (action.function.1 (graph.value_entry input))).2⟩ | |
| theorem rawAct_entry (g : {g : ZFSet.{u} // g ∈ G}) (x : {x : ZFSet.{u} // x ∈ X}) : | |
| ZFSet.pair (ZFSet.pair g.val x.val) (action.rawAct g x).val ∈ A := | |
| (show FunctionGraphOn (ZFSet.prod G X) A from ⟨X, action.function⟩).value_entry | |
| ⟨ZFSet.pair g.val x.val, ZFSet.pair_mem_prod.2 ⟨g.property, x.property⟩⟩ | |
| theorem rawAct_eq_iff (g : {g : ZFSet.{u} // g ∈ G}) | |
| (x y : {x : ZFSet.{u} // x ∈ X}) : | |
| action.rawAct g x = y ↔ ZFSet.pair (ZFSet.pair g.val x.val) y.val ∈ A := by | |
| constructor | |
| · intro equal | |
| exact equal ▸ action.rawAct_entry g x | |
| · intro entry | |
| exact Subtype.ext (action.entry_unique (action.rawAct_entry g x) entry) | |
| noncomputable def inverseActor (group : GroupCode G m inv one) | |
| (g : {g : ZFSet.{u} // g ∈ G}) : {g : ZFSet.{u} // g ∈ G} := | |
| ⟨SetMembers.raw (group.inv (SetMembers.ofMem g.val g.property)), | |
| SetMembers.raw_mem _⟩ | |
| theorem inverseActor_left (group : GroupCode G m inv one) | |
| (g : {g : ZFSet.{u} // g ∈ G}) : | |
| ZFSet.pair (ZFSet.pair (inverseActor group g).val g.val) one ∈ m := by | |
| apply group.inv_mul g.val g.property _ (inverseActor group g).property | |
| simpa only [inverseActor, SetMembers.raw_ofMem] using | |
| group.inv_mem (SetMembers.ofMem g.val g.property) | |
| theorem inverseActor_right (group : GroupCode G m inv one) | |
| (g : {g : ZFSet.{u} // g ∈ G}) : | |
| ZFSet.pair (ZFSet.pair g.val (inverseActor group g).val) one ∈ m := by | |
| let actor := SetMembers.ofMem g.val g.property | |
| have equal : group.mul actor (group.inv actor) = group.one := by | |
| let := group.toGroup | |
| exact mul_inv_cancel actor | |
| have entry := group.mul_mem actor (group.inv actor) | |
| rw [equal, group.raw_one] at entry | |
| simpa only [actor, inverseActor, SetMembers.raw_ofMem] using entry | |
| theorem rawAct_inverse_left (group : GroupCode G m inv one) | |
| (g : {g : ZFSet.{u} // g ∈ G}) (x : {x : ZFSet.{u} // x ∈ X}) : | |
| action.rawAct (inverseActor group g) (action.rawAct g x) = x := by | |
| apply Subtype.ext | |
| exact action.entry_unique | |
| (action.mul _ (inverseActor group g).property g.val g.property one group.identity_mem | |
| x.val x.property _ (action.rawAct g x).property _ | |
| (action.rawAct (inverseActor group g) (action.rawAct g x)).property | |
| (inverseActor_left group g) (action.rawAct_entry g x) | |
| (action.rawAct_entry (inverseActor group g) (action.rawAct g x))) | |
| (action.one x.val x.property) | |
| theorem rawAct_inverse_right (group : GroupCode G m inv one) | |
| (g : {g : ZFSet.{u} // g ∈ G}) (x : {x : ZFSet.{u} // x ∈ X}) : | |
| action.rawAct g (action.rawAct (inverseActor group g) x) = x := by | |
| apply Subtype.ext | |
| exact action.entry_unique | |
| (action.mul g.val g.property _ (inverseActor group g).property one group.identity_mem | |
| x.val x.property _ (action.rawAct (inverseActor group g) x).property _ | |
| (action.rawAct g (action.rawAct (inverseActor group g) x)).property | |
| (inverseActor_right group g) (action.rawAct_entry (inverseActor group g) x) | |
| (action.rawAct_entry g (action.rawAct (inverseActor group g) x))) | |
| (action.one x.val x.property) | |
| noncomputable def toPerm (group : GroupCode G m inv one) | |
| (g : {g : ZFSet.{u} // g ∈ G}) : Equiv.Perm {x : ZFSet.{u} // x ∈ X} where | |
| toFun := action.rawAct g | |
| invFun := action.rawAct (inverseActor group g) | |
| left_inv := action.rawAct_inverse_left group g | |
| right_inv := action.rawAct_inverse_right group g | |
| end SetActionCode | |
| section | |
| universe u | |
| namespace BoundedFormula | |
| open SetFormula | |
| def taggedActionEntryFormula {n} (z G P N B : Fin n) : BoundedFormula n := | |
| exMem G (exMem N.succ (exMem N.succ.succ | |
| (.conj (nestedActionTripleFormula z.succ.succ.succ 2 P.succ.succ.succ 1 P.succ.succ.succ 0) | |
| (tripleMembershipFormula 2 1 0 B.succ.succ.succ)))) | |
| theorem truth_taggedActionEntryFormula {n} (z G P N B : Fin n) | |
| (env : Fin n → ZFSet.{u}) : | |
| Truth (taggedActionEntryFormula z G P N B) env ↔ | |
| ∃ g ∈ env G, ∃ q ∈ env N, ∃ t ∈ env N, | |
| env z = ZFSet.pair (ZFSet.pair g (ZFSet.pair (env P) q)) (ZFSet.pair (env P) t) ∧ | |
| ZFSet.pair (ZFSet.pair g q) t ∈ env B := by | |
| simp only [taggedActionEntryFormula, truth_exMem, Truth, | |
| truth_nestedActionTripleFormula, truth_tripleMembershipFormula] | |
| rfl | |
| end BoundedFormula | |
| namespace TransitiveGround | |
| open SetFormula | |
| theorem taggedActionGraph_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) | |
| {G P N A B : ZFSet.{u}} (hG : G ∈ M.sets) (hP : P ∈ M.sets) | |
| (hN : N ∈ M.sets) (hA : A ∈ M.sets) (hB : B ∈ M.sets) : | |
| taggedActionGraph G P N A B ∈ M.sets := by | |
| have hL := M.taggedExtension_mem pairing unions powers separation hP hN | |
| let params := extend G (extend P (extend N (extend B Fin.elim0))) | |
| have selected := M.bounded_separation_mem separation | |
| (BoundedFormula.taggedActionEntryFormula 0 1 2 3 4) params | |
| (Fin.cases hG (Fin.cases hP (Fin.cases hN (Fin.cases hB (fun i => Fin.elim0 i))))) | |
| (M.prod_mem pairing unions powers separation | |
| (M.prod_mem pairing unions powers separation hG hL) hL) | |
| have equal : ZFSet.sep (fun z => BoundedFormula.Truth | |
| (BoundedFormula.taggedActionEntryFormula 0 1 2 3 4) (extend z params)) | |
| (ZFSet.prod (ZFSet.prod G (taggedExtension P N)) (taggedExtension P N)) = | |
| ZFSet.sep (fun z => ∃ g ∈ G, ∃ q ∈ N, ∃ t ∈ N, | |
| z = ZFSet.pair (ZFSet.pair g (ZFSet.pair P q)) (ZFSet.pair P t) ∧ | |
| ZFSet.pair (ZFSet.pair g q) t ∈ B) | |
| (ZFSet.prod (ZFSet.prod G (taggedExtension P N)) (taggedExtension P N)) := by | |
| apply ZFSet.ext | |
| intro z | |
| rw [ZFSet.mem_sep, ZFSet.mem_sep] | |
| exact and_congr Iff.rfl (BoundedFormula.truth_taggedActionEntryFormula 0 1 2 3 4 _) | |
| exact M.binary_union_mem pairing unions hA (equal ▸ selected) | |
| end TransitiveGround | |
| structure CodedAttachmentCovariance (G P N A B inside shadow upper : ZFSet.{u}) : Prop where | |
| inside : ∀ g ∈ G, ∀ q ∈ N, ∀ t ∈ N, ∀ q' ∈ N, ∀ t' ∈ N, | |
| ZFSet.pair (ZFSet.pair g q) q' ∈ B → ZFSet.pair (ZFSet.pair g t) t' ∈ B → | |
| ZFSet.pair q t ∈ inside → ZFSet.pair q' t' ∈ inside | |
| shadow : ∀ g ∈ G, ∀ q ∈ N, ∀ q' ∈ N, ∀ p ∈ P, ∀ p' ∈ P, | |
| ZFSet.pair (ZFSet.pair g q) q' ∈ B → ZFSet.pair (ZFSet.pair g p) p' ∈ A → | |
| ZFSet.pair q p ∈ shadow → ZFSet.pair q' p' ∈ shadow | |
| upper : ∀ g ∈ G, ∀ q ∈ N, ∀ q' ∈ N, ∀ p ∈ P, ∀ p' ∈ P, | |
| ZFSet.pair (ZFSet.pair g q) q' ∈ B → ZFSet.pair (ZFSet.pair g p) p' ∈ A → | |
| ZFSet.pair q p ∈ upper → ZFSet.pair q' p' ∈ upper | |
| theorem CodedAttachmentCovariance.monotone | |
| {G P N m e r A B inside shadow upper : ZFSet.{u}} | |
| (covariance : CodedAttachmentCovariance G P N A B inside shadow upper) | |
| (old : PosetActionCode G P m e r A) (fresh : SetActionCode G N m e B) : | |
| ∀ g ∈ G, ∀ p ∈ taggedExtension P N, ∀ q ∈ taggedExtension P N, | |
| ∀ p' ∈ taggedExtension P N, ∀ q' ∈ taggedExtension P N, | |
| ZFSet.pair (ZFSet.pair g p) p' ∈ taggedActionGraph G P N A B → | |
| ZFSet.pair (ZFSet.pair g q) q' ∈ taggedActionGraph G P N A B → | |
| ZFSet.pair p q ∈ codedAttachmentOrder P N r inside shadow upper → | |
| ZFSet.pair p' q' ∈ codedAttachmentOrder P N r inside shadow upper := by | |
| intro g hg p _ q _ p' hp' q' hq' first second lower | |
| have compared := ((pair_mem_codedAttachmentOrder P N r inside shadow upper p q).1 lower).2.2 | |
| apply (pair_mem_codedAttachmentOrder P N r inside shadow upper p' q').2 | |
| refine ⟨hp', hq', ?_⟩ | |
| rcases compared with oldOld | oldFresh | freshOld | freshFresh | |
| · obtain ⟨hp, hq, below⟩ := oldOld | |
| have actedP := (taggedActionGraph_old_iff hp).1 first | |
| have actedQ := (taggedActionGraph_old_iff hq).1 second | |
| have hp'P := (old.toSetAction.entry_shape actedP).2.2 | |
| have hq'P := (old.toSetAction.entry_shape actedQ).2.2 | |
| exact Or.inl ⟨hp'P, hq'P, old.monotone g hg p hp q hq p' hp'P q' hq'P actedP actedQ below⟩ | |
| · obtain ⟨hp, t, ht, s, hs, rfl, shadowEntry, below⟩ := oldFresh | |
| have actedP := (taggedActionGraph_old_iff hp).1 first | |
| have hp'P := (old.toSetAction.entry_shape actedP).2.2 | |
| obtain ⟨t', ht', rfl, actedT⟩ := (taggedActionGraph_fresh_iff old.toSetAction fresh).1 second | |
| obtain ⟨s', actedS, _⟩ := old.function.2 (ZFSet.pair g s) (ZFSet.pair_mem_prod.2 ⟨hg, hs⟩) | |
| have hs' := (old.toSetAction.entry_shape actedS).2.2 | |
| exact Or.inr (Or.inl ⟨hp'P, t', ht', s', hs', rfl, | |
| covariance.shadow g hg t ht t' ht' s hs s' hs' actedT actedS shadowEntry, | |
| old.monotone g hg p hp s hs p' hp'P s' hs' actedP actedS below⟩) | |
| · obtain ⟨hq, t, ht, rfl, upperEntry⟩ := freshOld | |
| obtain ⟨t', ht', rfl, actedT⟩ := (taggedActionGraph_fresh_iff old.toSetAction fresh).1 first | |
| have actedQ := (taggedActionGraph_old_iff hq).1 second | |
| have hq'P := (old.toSetAction.entry_shape actedQ).2.2 | |
| exact Or.inr (Or.inr (Or.inl ⟨hq'P, t', ht', rfl, | |
| covariance.upper g hg t ht t' ht' q hq q' hq'P actedT actedQ upperEntry⟩)) | |
| · obtain ⟨s, hs, t, ht, rfl, rfl, below⟩ := freshFresh | |
| obtain ⟨s', hs', rfl, actedS⟩ := (taggedActionGraph_fresh_iff old.toSetAction fresh).1 first | |
| obtain ⟨t', ht', rfl, actedT⟩ := (taggedActionGraph_fresh_iff old.toSetAction fresh).1 second | |
| refine Or.inr (Or.inr (Or.inr ⟨s', hs', t', ht', rfl, rfl, ?_⟩)) | |
| rcases below with internal | ⟨v, hv, shadowEntry, upperEntry⟩ | |
| · exact Or.inl (covariance.inside g hg s hs t ht s' hs' t' ht' actedS actedT internal) | |
| · obtain ⟨v', actedV, _⟩ := old.function.2 (ZFSet.pair g v) (ZFSet.pair_mem_prod.2 ⟨hg, hv⟩) | |
| have hv' := (old.toSetAction.entry_shape actedV).2.2 | |
| exact Or.inr ⟨v', hv', | |
| covariance.shadow g hg t ht t' ht' v hv v' hv' actedT actedV shadowEntry, | |
| covariance.upper g hg s hs s' hs' v hv v' hv' actedS actedV upperEntry⟩ | |
| theorem PosetActionCode.tagged_attachment | |
| {G P N m e r A B inside shadow upper : ZFSet.{u}} | |
| (old : PosetActionCode G P m e r A) (fresh : SetActionCode G N m e B) | |
| (covariance : CodedAttachmentCovariance G P N A B inside shadow upper) : | |
| PosetActionCode G (taggedExtension P N) m e | |
| (codedAttachmentOrder P N r inside shadow upper) (taggedActionGraph G P N A B) := | |
| ⟨(old.toSetAction.tagged fresh).function, (old.toSetAction.tagged fresh).one, | |
| (old.toSetAction.tagged fresh).mul, covariance.monotone old fresh⟩ | |
| end | |
| open Compression.RecursiveMaps | |
| universe u | |
| structure CodedRecursiveTaskAction | |
| {D rD μD J Qs rs μs As Es Fs Ss I Maps Sources Reps G m inv one A : ZFSet.{u}} | |
| {d : AttachmentBatchInputs D rD μD J Qs rs μs As Es Fs Ss} | |
| (h : CodedRecursiveMapInputs d I Maps Sources Reps G m inv one A) | |
| (T : ZFSet.{u}) : Prop where | |
| taskAction : SetActionCode G I m one T | |
| source : ∀ g i j a b, ZFSet.pair (ZFSet.pair g i) j ∈ T → | |
| ZFSet.pair i a ∈ Sources → ZFSet.pair j b ∈ Sources → a = b | |
| intertwine : ∀ g i j S S' p x y, ZFSet.pair (ZFSet.pair g i) j ∈ T → | |
| ZFSet.pair i S ∈ Maps → ZFSet.pair j S' ∈ Maps → | |
| ZFSet.pair p x ∈ S → ZFSet.pair p y ∈ S' → ZFSet.pair (ZFSet.pair g x) y ∈ A | |
| namespace CodedRecursiveTaskAction | |
| variable {D rD μD J Qs rs μs As Es Fs Ss I Maps Sources Reps G m inv one A T : ZFSet.{u}} | |
| variable {d : AttachmentBatchInputs D rD μD J Qs rs μs As Es Fs Ss} | |
| variable {h : CodedRecursiveMapInputs d I Maps Sources Reps G m inv one A} | |
| variable (s : CodedRecursiveTaskAction h T) | |
| noncomputable def current (_s : CodedRecursiveTaskAction h T) (g : {g : ZFSet.{u} // g ∈ G}) : | |
| Compression.MeetIso d.templates.extension d.templates.extension := by | |
| let encoding := d.coding.encodingIso | |
| let acted := h.action.toMeetIso h.group d.batch_meetOrder g | |
| refine isoOfOrder | |
| (fun x => encoding.inverse (acted.toFun (encoding.toFun x))) | |
| (fun x => encoding.inverse (acted.inverse (encoding.toFun x))) ?_ ?_ ?_ | |
| · intro x | |
| rw [encoding.right_inverse, acted.left_inverse, encoding.left_inverse] | |
| · intro x | |
| rw [encoding.right_inverse, acted.right_inverse, encoding.left_inverse] | |
| · intro x y | |
| exact ((inverseIso encoding).le_iff _ _).trans | |
| ((acted.le_iff _ _).trans (encoding.le_iff x y)) | |
| theorem current_entry (g : {g : ZFSet.{u} // g ∈ G}) | |
| (x : {x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) : | |
| ZFSet.pair (ZFSet.pair g.val (d.coding.encode x)) | |
| (d.coding.encode ((s.current g).toFun x)) ∈ A := by | |
| change ZFSet.pair (ZFSet.pair g.val (d.coding.encode x)) | |
| (d.coding.encode (d.coding.decode ((h.action.toMeetIso h.group d.batch_meetOrder g).toFun | |
| ⟨d.coding.encode x, d.coding.encode_mem x⟩))) ∈ A | |
| rw [d.coding.encode_decode] | |
| exact h.action.toMeetIso_entry h.group d.batch_meetOrder g | |
| ⟨d.coding.encode x, d.coding.encode_mem x⟩ | |
| noncomputable def toTaskSymmetry (g : {g : ZFSet.{u} // g ∈ G}) : TaskSymmetry h.toInputs where | |
| perm := s.taskAction.rawAct g | |
| inverse := (s.taskAction.toPerm h.group g).invFun | |
| left_inverse := (s.taskAction.toPerm h.group g).left_inv | |
| right_inverse := (s.taskAction.toPerm h.group g).right_inv | |
| current := s.current g | |
| source i := Subtype.ext (s.source g.val i.val _ _ _ (s.taskAction.rawAct_entry g i) | |
| (h.source_entry i) (h.source_entry (s.taskAction.rawAct g i))).symm | |
| intertwine i p := by | |
| apply d.coding.encode_injective | |
| exact h.action.toSetAction.entry_unique (s.current_entry g ((h.toInputs.previous i).toFun p)) | |
| (s.intertwine g.val i.val _ _ _ p.val _ _ (s.taskAction.rawAct_entry g i) | |
| (h.maps.value_entry i) (h.maps.value_entry (s.taskAction.rawAct g i)) | |
| (h.toInputs_previous_entry i p) (h.toInputs_previous_entry (s.taskAction.rawAct g i) p)) | |
| theorem toTaskSymmetry_perm_entry (g : {g : ZFSet.{u} // g ∈ G}) | |
| (i : {i : ZFSet.{u} // i ∈ I}) : | |
| ZFSet.pair (ZFSet.pair g.val i.val) ((s.toTaskSymmetry g).perm i).val ∈ T := | |
| s.taskAction.rawAct_entry g i | |
| theorem toTaskSymmetry_current_entry (g : {g : ZFSet.{u} // g ∈ G}) | |
| (x : {x : ZFSet.{u} // x ∈ D} ⊕ d.templates.Fresh) : | |
| ZFSet.pair (ZFSet.pair g.val (d.coding.encode x)) | |
| (d.coding.encode ((s.toTaskSymmetry g).current.toFun x)) ∈ A := s.current_entry g x | |
| end CodedRecursiveTaskAction | |
| end PartitionPilot.Forcing | |
| end OAI | |