openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Forcing /GroundDefinableRefinementNameGraphs.lean
| 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 | |