Download data/lean/OAI/SetTheory/PartitionPrinciple/Forcing/GroundDefinableRefinementNameGraphs.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 21 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/SetTheory/PartitionPrinciple/Forcing/GroundDefinableRefinementNameGraphs.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/SetTheory/PartitionPrinciple/Forcing/GroundDefinableRefinementNameGraphs.lean
-
curl -L -o GroundDefinableRefinementNameGraphs.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/SetTheory/PartitionPrinciple/Forcing/GroundDefinableRefinementNameGraphs.lean
21 kB
| import OAI.SetTheory.PartitionPrinciple.Geometry.GroundDefinableIndexBounds | |
| namespace OAI | |
| namespace PartitionPilot.Forcing | |
| open SetRealization SetFormula | |
| universe u | |
| namespace Name | |
| variable {P : Type u} [PartialOrder P] [OrderTop P] {s : Presentation P} | |
| noncomputable def refinementOutput (kind : Fin 3) (T : ZFSet.{u}) | |
| (valid : β z β T, IsName s z) (U Rf Rc : Name s) : Name s := | |
| Fin.cases (refinementQuotient T valid U Rf) | |
| (Fin.cases (refinementQuotient T valid U Rc) (fun _ => refinementNaturalMap T valid U Rf Rc)) kind | |
| end Name | |
| namespace SetFormula | |
| def refinementOutputCodeFormula (kind : Fin 3) : SetFormula 8 := | |
| Fin.cases (reindex ![0, 1, 2, 3, 5, 6, 7] refinementQuotientCodeFormula) | |
| (Fin.cases (reindex ![0, 1, 2, 4, 5, 6, 7] refinementQuotientCodeFormula) | |
| (fun _ => refinementMapCodeFormula)) kind | |
| end SetFormula | |
| namespace TransitiveGround | |
| variable (M : TransitiveGround.{u}) | |
| noncomputable def refinementNameBound (T P top : ZFSet.{u}) : ZFSet.{u} := | |
| M.groundRelations (M.groundRelations T P βͺ | |
| orderedPairNameFamily top (M.groundRelations T P) (M.groundRelations T P)) P | |
| theorem refinementNameBound_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) | |
| {T P top : ZFSet.{u}} (hT : T β M.sets) (hP : P β M.sets) (htop : top β M.sets) : | |
| M.refinementNameBound T P top β M.sets := by | |
| have hc := M.groundRelations_mem pairing unions powers separation hT hP | |
| exact M.groundRelations_mem pairing unions powers separation | |
| (M.binary_union_mem pairing unions hc (M.orderedPairNameFamily_mem pairing unions powers separation htop hc hc)) hP | |
| variable {P : Type u} [PartialOrder P] [OrderTop P] (s : Presentation P) | |
| 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) | |
| variable (carrier : s.carrier β M.sets) (order : s.conditionOrder β M.sets) | |
| include pairing unions powers separation collection carrier order | |
| theorem refinementOutput_mem_bound (kind : Fin 3) {T : ZFSet.{u}} (hT : T β M.sets) | |
| (valid : β z β T, IsName s z) (U Rf Rc : Name s) | |
| (hU : U.val β M.sets) (hRf : Rf.val β M.sets) (hRc : Rc.val β M.sets) : | |
| (Name.refinementOutput kind T valid U Rf Rc).val β M.refinementNameBound T s.carrier (s.encode β€) := by | |
| let B := M.groundRelations T s.carrier | |
| let C := B βͺ orderedPairNameFamily (s.encode β€) B B | |
| have classBound (R : Name s) (hR : R.val β M.sets) (w : Name s) (hw : w.val β T) : | |
| (Name.refinementClass T valid R w).val β B := | |
| (M.mem_groundRelations T s.carrier _).2 | |
| β¨M.refinementClass_mem s pairing unions powers separation collection carrier order hT valid R w hR | |
| (M.transitive hT hw), Name.refinementClass_subset T valid R wβ© | |
| have quotient (R : Name s) (hR : R.val β M.sets) : | |
| (Name.refinementQuotient T valid U R).val β M.groundRelations C s.carrier := by | |
| apply (M.mem_groundRelations C s.carrier _).2 | |
| exact β¨M.refinementQuotient_mem s pairing unions powers separation collection carrier order hT valid U R hU hR, | |
| Name.activeImage_subset T valid U _ C (fun w hw => ZFSet.mem_union.2 (Or.inl (classBound R hR w hw)))β© | |
| have natural : (Name.refinementNaturalMap T valid U Rf Rc).val β M.groundRelations C s.carrier := by | |
| apply (M.mem_groundRelations C s.carrier _).2 | |
| refine β¨M.refinementNaturalMap_mem s pairing unions powers separation collection carrier order hT valid U Rf Rc hU hRf hRc, | |
| Name.activeImage_subset T valid U _ C ?_β© | |
| intro w hw | |
| exact ZFSet.mem_union.2 (Or.inr ((mem_orderedPairNameFamily _ B B _).2 | |
| β¨_, classBound Rf hRf w hw, _, classBound Rc hRc w hw, Name.orderedPair_code β€ _ _β©)) | |
| exact Fin.cases (quotient Rf hRf) (Fin.cases (quotient Rc hRc) | |
| (Fin.cases natural (fun j => Fin.elim0 j))) kind | |
| theorem realize_refinementOutputCodeFormula (kind : Fin 3) {T : ZFSet.{u}} (hT : T β M.sets) | |
| (valid : β z β T, IsName s z) (U Rf Rc : Name s) | |
| (hU : U.val β M.sets) (hRf : Rf.val β M.sets) (hRc : Rc.val β M.sets) | |
| (z : ZFSet.{u}) (hz : z β M.sets) : | |
| Realize M.sets (refinementOutputCodeFormula kind) | |
| (extend z (extend T (extend U.val (extend Rf.val (extend Rc.val | |
| (extend s.carrier (extend s.conditionOrder (extend (s.encode β€) Fin.elim0)))))))) β | |
| z = (Name.refinementOutput kind T valid U Rf Rc).val := by | |
| let env := extend z (extend T (extend U.val (extend Rf.val (extend Rc.val | |
| (extend s.carrier (extend s.conditionOrder (extend (s.encode β€) Fin.elim0))))))) | |
| have firstArgs : (fun j : Fin 7 => env (![0, 1, 2, 3, 5, 6, 7] j)) = | |
| extend z (extend T (extend U.val (extend Rf.val | |
| (extend s.carrier (extend s.conditionOrder (extend (s.encode β€) Fin.elim0)))))) := by | |
| funext j | |
| exact Fin.cases rfl (Fin.cases rfl (Fin.cases rfl (Fin.cases rfl | |
| (Fin.cases rfl (Fin.cases rfl (Fin.cases rfl (fun k => Fin.elim0 k))))))) j | |
| have secondArgs : (fun j : Fin 7 => env (![0, 1, 2, 4, 5, 6, 7] j)) = | |
| extend z (extend T (extend U.val (extend Rc.val | |
| (extend s.carrier (extend s.conditionOrder (extend (s.encode β€) Fin.elim0)))))) := by | |
| funext j | |
| exact Fin.cases rfl (Fin.cases rfl (Fin.cases rfl (Fin.cases rfl | |
| (Fin.cases rfl (Fin.cases rfl (Fin.cases rfl (fun k => Fin.elim0 k))))))) j | |
| refine Fin.cases ?_ (Fin.cases ?_ (Fin.cases ?_ (fun j => Fin.elim0 j))) kind | |
| Β· change Realize M.sets (reindex _ refinementQuotientCodeFormula) env β _ | |
| rw [realize_reindex, firstArgs] | |
| exact M.realize_refinementQuotientCodeFormula s pairing unions powers separation collection carrier order hT valid U Rf hU hRf z hz | |
| Β· change Realize M.sets (reindex _ refinementQuotientCodeFormula) env β _ | |
| rw [realize_reindex, secondArgs] | |
| exact M.realize_refinementQuotientCodeFormula s pairing unions powers separation collection carrier order hT valid U Rc hU hRc z hz | |
| Β· exact M.realize_refinementMapCodeFormula s pairing unions powers separation collection carrier order hT valid U Rf Rc hU hRf hRc z hz | |
| end TransitiveGround | |
| namespace SetFormula | |
| def refinementIndexNameGraphFormula (kind : Fin 3) : SetFormula 9 := | |
| let w := prefixIndex 9 5 | |
| let old := suffixIndex 9 5 | |
| exBlock 5 (.conj (.mem (w 0) (old 1)) | |
| (.conj (BoundedFormula.orderedPairFormula (old 0) (w 0) (w 1)).toFormula | |
| (.conj (BoundedFormula.pairMembershipFormula (w 0) (w 2) (old 2)).toFormula | |
| (.conj (BoundedFormula.pairMembershipFormula (w 0) (w 3) (old 3)).toFormula | |
| (.conj (BoundedFormula.pairMembershipFormula (w 0) (w 4) (old 4)).toFormula | |
| (reindex ![w 1, old 5, w 2, w 3, w 4, old 6, old 7, old 8] | |
| (refinementOutputCodeFormula kind))))))) | |
| end SetFormula | |
| namespace TransitiveGround | |
| variable (M : TransitiveGround.{u}) | |
| noncomputable def refinementIndexNameGraph (kind : Fin 3) | |
| (I UF FF CF T P order top : ZFSet.{u}) : ZFSet.{u} := | |
| ZFSet.sep (fun z => Realize M.sets (refinementIndexNameGraphFormula kind) | |
| (extend z ![I, UF, FF, CF, T, P, order, top])) | |
| (ZFSet.prod I (M.refinementNameBound T P top)) | |
| theorem refinementIndexNameGraph_mem (kind : Fin 3) | |
| (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) | |
| {I UF FF CF T P order top : ZFSet.{u}} | |
| (hI : I β M.sets) (hUF : UF β M.sets) (hFF : FF β M.sets) (hCF : CF β M.sets) | |
| (hT : T β M.sets) (hP : P β M.sets) (ho : order β M.sets) (ht : top β M.sets) : | |
| M.refinementIndexNameGraph kind I UF FF CF T P order top β M.sets := by | |
| exact M.separation_mem separation (refinementIndexNameGraphFormula kind) | |
| ![I, UF, FF, CF, T, P, order, top] | |
| (Fin.cases hI (Fin.cases hUF (Fin.cases hFF (Fin.cases hCF (Fin.cases hT | |
| (Fin.cases hP (Fin.cases ho (Fin.cases ht (fun j => Fin.elim0 j))))))))) | |
| (M.prod_mem pairing unions powers separation hI | |
| (M.refinementNameBound_mem pairing unions powers separation hT hP ht)) | |
| theorem realize_refinementIndexNameGraphFormula (kind : Fin 3) | |
| (env : Fin 9 β ZFSet.{u}) (members : β j, env j β M.sets) : | |
| Realize M.sets (refinementIndexNameGraphFormula kind) env β | |
| β w : Fin 5 β ZFSet.{u}, (β j, w j β M.sets) β§ | |
| w 0 β env 1 β§ env 0 = ZFSet.pair (w 0) (w 1) β§ | |
| ZFSet.pair (w 0) (w 2) β env 2 β§ ZFSet.pair (w 0) (w 3) β env 3 β§ | |
| ZFSet.pair (w 0) (w 4) β env 4 β§ | |
| Realize M.sets (refinementOutputCodeFormula kind) | |
| (extend (w 1) (extend (env 5) (extend (w 2) (extend (w 3) (extend (w 4) | |
| (extend (env 6) (extend (env 7) (extend (env 8) Fin.elim0)))))))) := by | |
| rw [refinementIndexNameGraphFormula, realize_exBlock] | |
| apply exists_congr | |
| intro w | |
| apply and_congr_right | |
| intro ground | |
| have args : (fun j : Fin 8 => extendMany 5 w env | |
| (![prefixIndex 9 5 1, suffixIndex 9 5 5, prefixIndex 9 5 2, | |
| prefixIndex 9 5 3, prefixIndex 9 5 4, suffixIndex 9 5 6, | |
| suffixIndex 9 5 7, suffixIndex 9 5 8] j)) = | |
| extend (w 1) (extend (env 5) (extend (w 2) (extend (w 3) (extend (w 4) | |
| (extend (env 6) (extend (env 7) (extend (env 8) Fin.elim0))))))) := by | |
| funext j | |
| exact Fin.cases rfl (Fin.cases rfl (Fin.cases rfl (Fin.cases rfl | |
| (Fin.cases rfl (Fin.cases rfl (Fin.cases rfl (Fin.cases rfl | |
| (fun k => Fin.elim0 k)))))))) j | |
| simp only [Realize, BoundedFormula.realize_toFormula M _ _ | |
| (extendMany_members 5 w env ground members), BoundedFormula.truth_orderedPairFormula, | |
| BoundedFormula.truth_pairMembershipFormula, extendMany_prefix, extendMany_suffix, | |
| realize_reindex, args] | |
| variable {P : Type u} [PartialOrder P] [OrderTop P] (s : Presentation P) | |
| theorem refinementIndexNameGraph_entry (kind : Fin 3) | |
| (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) | |
| (carrier : s.carrier β M.sets) (order : s.conditionOrder β M.sets) | |
| {I UF FF CF T : ZFSet.{u}} (hI : I β M.sets) (hUF : UF β M.sets) | |
| (hFF : FF β M.sets) (hCF : CF β M.sets) (hT : T β M.sets) | |
| (valid : β z β T, IsName s z) (U Rf Rc : Name s) | |
| (hU : U.val β M.sets) (hRf : Rf.val β M.sets) (hRc : Rc.val β M.sets) | |
| {i : ZFSet.{u}} (hi : i β I) | |
| (uEntry : β z, ZFSet.pair i z β UF β z = U.val) | |
| (fEntry : β z, ZFSet.pair i z β FF β z = Rf.val) | |
| (cEntry : β z, ZFSet.pair i z β CF β z = Rc.val) (y : ZFSet.{u}) : | |
| ZFSet.pair i y β M.refinementIndexNameGraph kind I UF FF CF T s.carrier s.conditionOrder (s.encode β€) β | |
| y = (Name.refinementOutput kind T valid U Rf Rc).val := by | |
| have ht := M.transitive carrier (s.encode_mem β€) | |
| have hB := M.refinementNameBound_mem pairing unions powers separation hT carrier ht | |
| have hidx := M.transitive hI hi | |
| let params : Fin 8 β ZFSet.{u} := ![I, UF, FF, CF, T, s.carrier, s.conditionOrder, s.encode β€] | |
| have hp : β j, params j β M.sets := Fin.cases hI (Fin.cases hUF (Fin.cases hFF | |
| (Fin.cases hCF (Fin.cases hT (Fin.cases carrier (Fin.cases order | |
| (Fin.cases ht (fun j => Fin.elim0 j)))))))) | |
| rw [refinementIndexNameGraph, ZFSet.mem_sep, ZFSet.pair_mem_prod] | |
| constructor | |
| Β· rintro β¨β¨_, hyBβ©, recognizedβ© | |
| have hy := M.transitive hB hyB | |
| have hpair := M.orderedPair_mem pairing hidx hy | |
| obtain β¨w, ground, _, equal, hu, hf, hc, outputβ© := | |
| (M.realize_refinementIndexNameGraphFormula kind (extend (ZFSet.pair i y) params) | |
| (Fin.cases hpair hp)).1 recognized | |
| have eq : ZFSet.pair i y = ZFSet.pair (w 0) (w 1) := equal | |
| obtain β¨idx, valβ© := ZFSet.pair_inj.1 eq | |
| have ue : w 2 = U.val := (uEntry _).1 (idx.symm βΈ hu) | |
| have fe : w 3 = Rf.val := (fEntry _).1 (idx.symm βΈ hf) | |
| have ce : w 4 = Rc.val := (cEntry _).1 (idx.symm βΈ hc) | |
| change Realize M.sets (refinementOutputCodeFormula kind) | |
| (extend (w 1) (extend T (extend (w 2) (extend (w 3) (extend (w 4) | |
| (extend s.carrier (extend s.conditionOrder (extend (s.encode β€) Fin.elim0)))))))) at output | |
| rw [β val, ue, fe, ce] at output | |
| exact (M.realize_refinementOutputCodeFormula s pairing unions powers separation collection | |
| carrier order kind hT valid U Rf Rc hU hRf hRc y hy).1 output | |
| Β· intro equal | |
| subst y | |
| have bound := M.refinementOutput_mem_bound s pairing unions powers separation collection | |
| carrier order kind hT valid U Rf Rc hU hRf hRc | |
| have hy := M.transitive hB bound | |
| refine β¨β¨hi, boundβ©, ?_β© | |
| apply (M.realize_refinementIndexNameGraphFormula kind (extend _ params) | |
| (Fin.cases (M.orderedPair_mem pairing hidx hy) hp)).2 | |
| refine β¨![i, (Name.refinementOutput kind T valid U Rf Rc).val, U.val, Rf.val, Rc.val], | |
| Fin.cases hidx (Fin.cases hy (Fin.cases hU (Fin.cases hRf (Fin.cases hRc | |
| (fun j => Fin.elim0 j))))), hi, rfl, (uEntry _).2 rfl, (fEntry _).2 rfl, | |
| (cEntry _).2 rfl, ?_β© | |
| exact (M.realize_refinementOutputCodeFormula s pairing unions powers separation collection | |
| carrier order kind hT valid U Rf Rc hU hRf hRc _ hy).2 rfl | |
| end TransitiveGround | |
| end PartitionPilot.Forcing | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) | |
| variable {G P L : Type u} [Group G] [PartialOrder P] [OrderTop P] [PartialOrder L] | |
| variable (a : PosetAction G P) (s : Presentation P) (b : Presentation L) (d : PosetAction G L) | |
| noncomputable def niceRefinementNameGraph (kind : Fin 3) (level T1 T2 : ZFSet.{u}) | |
| (valid1 : β z β T1, IsName s z) : ZFSet.{u} := | |
| let I := M.niceRefinementIndices a s b d level T1 T2 valid1 | |
| let bounds := M.niceRefinementIndexBounds s b level T1 T2 | |
| M.refinementIndexNameGraph kind I (refinementIndexFieldGraph I (bounds 3) 3) | |
| (refinementIndexFieldGraph I (bounds 4) 4) (refinementIndexFieldGraph I (bounds 5) 5) | |
| T1 s.carrier s.conditionOrder (s.encode β€) | |
| variable {level T1 T2 : ZFSet.{u}} {valid1 : β z β T1, IsName s z} {valid2 : β z β T2, IsName s z} | |
| variable (system : NiceRefinementIndexSystem M a s b d level T1 T2 valid1 valid2) | |
| include system in | |
| theorem niceRefinementIndex_field_entry (C E : L) (U Rf Rc : (M.nameDomain s).names) | |
| (member : refinementIndexCode level (b.encode C) (b.encode E) U.val.val Rf.val.val Rc.val.val β | |
| M.niceRefinementIndices a s b d level T1 T2 valid1) (j : Fin 6) (z : ZFSet.{u}) : | |
| ZFSet.pair (refinementIndexCode level (b.encode C) (b.encode E) U.val.val Rf.val.val Rc.val.val) z β | |
| refinementIndexFieldGraph (M.niceRefinementIndices a s b d level T1 T2 valid1) | |
| (M.niceRefinementIndexBounds s b level T1 T2 j) j β | |
| z = (![level, b.encode C, b.encode E, U.val.val, Rf.val.val, Rc.val.val] : Fin 6 β ZFSet.{u}) j := by | |
| let I := M.niceRefinementIndices a s b d level T1 T2 valid1 | |
| let fields : Fin 6 β ZFSet.{u} := ![level, b.encode C, b.encode E, U.val.val, Rf.val.val, Rc.val.val] | |
| let B := M.niceRefinementIndexBounds s b level T1 T2 j | |
| change ZFSet.pair (nonemptyTupleCode 5 fields) z β refinementIndexFieldGraph I B j β z = fields j | |
| constructor | |
| Β· intro entry | |
| exact ((refinementIndexFieldGraph_entry I B fields j z).1 entry).2.2 | |
| Β· intro equal | |
| obtain β¨v, hv, _β© := (system.field_function j).2 _ member | |
| have value : v = fields j := ((refinementIndexFieldGraph_entry I B fields j v).1 hv).2.2 | |
| exact equal.symm βΈ (value βΈ hv) | |
| 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) | |
| variable (hT1 : T1 β M.sets) (carrier : s.carrier β M.sets) (order : s.conditionOrder β M.sets) | |
| include system pairing unions powers separation hT1 carrier order in | |
| theorem niceRefinementNameGraph_mem (kind : Fin 3) : | |
| M.niceRefinementNameGraph a s b d kind level T1 T2 valid1 β M.sets := | |
| M.refinementIndexNameGraph_mem kind pairing unions powers separation system.index_ground | |
| (system.field_ground 3) (system.field_ground 4) (system.field_ground 5) hT1 carrier order | |
| (M.transitive carrier (s.encode_mem β€)) | |
| include system pairing unions powers separation collection hT1 carrier order in | |
| theorem niceRefinementNameGraph_entry (kind : Fin 3) | |
| (C E : L) (U Rf Rc : (M.nameDomain s).names) | |
| (member : refinementIndexCode level (b.encode C) (b.encode E) U.val.val Rf.val.val Rc.val.val β | |
| M.niceRefinementIndices a s b d level T1 T2 valid1) (y : ZFSet.{u}) : | |
| ZFSet.pair (refinementIndexCode level (b.encode C) (b.encode E) U.val.val Rf.val.val Rc.val.val) y β | |
| M.niceRefinementNameGraph a s b d kind level T1 T2 valid1 β | |
| y = (Name.refinementOutput kind T1 valid1 U.val Rf.val Rc.val).val := by | |
| exact M.refinementIndexNameGraph_entry s kind pairing unions powers separation collection carrier order | |
| system.index_ground (system.field_ground 3) (system.field_ground 4) (system.field_ground 5) | |
| hT1 valid1 U.val Rf.val Rc.val U.property Rf.property Rc.property member | |
| (M.niceRefinementIndex_field_entry a s b d system C E U Rf Rc member 3) | |
| (M.niceRefinementIndex_field_entry a s b d system C E U Rf Rc member 4) | |
| (M.niceRefinementIndex_field_entry a s b d system C E U Rf Rc member 5) y | |
| include system pairing unions powers separation collection hT1 carrier order in | |
| theorem niceRefinementNameGraph_function (kind : Fin 3) : | |
| ZFSet.IsFunc (M.niceRefinementIndices a s b d level T1 T2 valid1) | |
| (M.refinementNameBound T1 s.carrier (s.encode β€)) | |
| (M.niceRefinementNameGraph a s b d kind level T1 T2 valid1) := by | |
| refine β¨?_, ?_β© | |
| Β· intro z hz | |
| unfold niceRefinementNameGraph refinementIndexNameGraph at hz | |
| exact (ZFSet.mem_sep.1 hz).1 | |
| intro i hi | |
| obtain β¨C, E, U, Rf, Rc, rflβ© := system.decoded i hi | |
| refine β¨(Name.refinementOutput kind T1 valid1 U.val Rf.val Rc.val).val, ?_, ?_β© | |
| Β· exact (M.niceRefinementNameGraph_entry a s b d system pairing unions powers separation collection | |
| hT1 carrier order kind C E U Rf Rc hi _).2 rfl | |
| Β· intro y hy | |
| exact (M.niceRefinementNameGraph_entry a s b d system pairing unions powers separation collection | |
| hT1 carrier order kind C E U Rf Rc hi y).1 hy | |
| end PartitionPilot.Forcing.TransitiveGround | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open 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) | |
| noncomputable def definable_refinementNameBound : | |
| GroundDefinableFunction M (fun env : Fin 3 β ZFSet.{u} => M.refinementNameBound (env 0) (env 1) (env 2)) := by | |
| let v := GroundSetTerm.var M (n := 3) | |
| let classes := GroundSetTerm.app (M.definable_groundRelations pairing unions powers separation) ![v 0, v 1] | |
| let pairs := GroundSetTerm.app (M.definable_orderedPairNameFamily pairing unions powers separation) | |
| ![v 2, classes, classes] | |
| let children := GroundSetTerm.app (M.definable_binaryUnion pairing unions) ![classes, pairs] | |
| exact (GroundSetTerm.app (M.definable_groundRelations pairing unions powers separation) ![children, v 1]).definition | |
| noncomputable def definable_refinementIndexNameGraph (kind : Fin 3) : | |
| GroundDefinableFunction M (fun env : Fin 8 β ZFSet.{u} => | |
| M.refinementIndexNameGraph kind (env 0) (env 1) (env 2) (env 3) | |
| (env 4) (env 5) (env 6) (env 7)) := by | |
| let v := GroundSetTerm.var M (n := 8) | |
| let names := GroundSetTerm.app (M.definable_refinementNameBound pairing unions powers separation) | |
| ![v 4, v 5, v 7] | |
| let bound := GroundSetTerm.app (M.definable_product pairing unions powers separation) ![v 0, names] | |
| let term := GroundSetTerm.app (M.definable_separation separation (refinementIndexNameGraphFormula kind)) | |
| ![bound, v 0, v 1, v 2, v 3, v 4, v 5, v 6, v 7] | |
| refine term.definition.congr ?_ | |
| intro env | |
| apply congrArg (fun params : Fin 8 β ZFSet.{u} => | |
| ZFSet.sep (fun z => Realize M.sets (refinementIndexNameGraphFormula kind) (extend z params)) | |
| (ZFSet.prod (env 0) (M.refinementNameBound (env 4) (env 5) (env 7)))) | |
| funext j | |
| exact Fin.cases rfl (Fin.cases rfl (Fin.cases rfl (Fin.cases rfl (Fin.cases rfl | |
| (Fin.cases rfl (Fin.cases rfl (Fin.cases rfl (fun k => Fin.elim0 k)))))))) j | |
| end PartitionPilot.Forcing.TransitiveGround | |
| end OAI | |