openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Models /GroundMainFinalPartitionModel.lean
| import OAI.SetTheory.PartitionPrinciple.Definability.GroundMainFinalGraphValueCandidateAvailability | |
| import OAI.SetTheory.PartitionPrinciple.Definability.GroundSemanticStructuralSymmetricRefinementOutputs | |
| import OAI.SetTheory.PartitionPrinciple.Geometry.GroundMainFinalPersistentAssignmentLabels | |
| import OAI.SetTheory.PartitionPrinciple.Models.GroundMainFinalStructuralRowNonchoice | |
| import OAI.SetTheory.PartitionPrinciple.Models.GroundRowCoverPartitionPrinciple | |
| import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundExtensionOrdinals | |
| import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundRecursiveOriginalRowFamilies | |
| namespace OAI | |
| open scoped ZFSet | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetFormula SetRealization | |
| universe u v | |
| variable (M : TransitiveGround.{u}) {P : Type u} [PartialOrder P] | |
| variable (s : Presentation P) {G : Type v} [Group G] | |
| variable (a : PosetAction G P) (F : Compression.RecursiveMaps.NormalSubgroupFamily G) | |
| theorem symmetricExtension_quotient_injections | |
| (H : ConditionFilter P) (rowName : Name s) | |
| (named : ∀ tau : Fin 3 → (M.nameDomain s).names, | |
| (∀ i, HereditarilySymmetric a s F (tau i).val) → | |
| RefinementValidityCode (Name.eval {p | H.mem p} rowName) | |
| (Name.eval {p | H.mem p} (tau 0).val) | |
| (Name.eval {p | H.mem p} (tau 1).val) | |
| (Name.eval {p | H.mem p} (tau 2).val) → | |
| ∃ J ∈ (M.symmetricExtension s a F H).sets, | |
| InjectionCode | |
| (equivalenceClasses (Name.eval {p | H.mem p} (tau 0).val) | |
| (Name.eval {p | H.mem p} (tau 2).val)) | |
| (equivalenceClasses (Name.eval {p | H.mem p} (tau 0).val) | |
| (Name.eval {p | H.mem p} (tau 1).val)) J) : | |
| ∀ U ∈ (M.symmetricExtension s a F H).sets, | |
| ∀ Rf ∈ (M.symmetricExtension s a F H).sets, | |
| ∀ Rc ∈ (M.symmetricExtension s a F H).sets, | |
| RefinementValidityCode (Name.eval {p | H.mem p} rowName) U Rf Rc → | |
| (M.symmetricExtension s a F H).groundEmbeddable | |
| (equivalenceClasses U Rc) (equivalenceClasses U Rf) := by | |
| intro U hU Rf hRf Rc hRc validity | |
| obtain ⟨u, hu, symmetricU, equalU⟩ := (M.mem_symmetricExtension s a F H U).1 hU | |
| obtain ⟨fine, hFine, symmetricFine, equalFine⟩ := (M.mem_symmetricExtension s a F H Rf).1 hRf | |
| obtain ⟨coarse, hCoarse, symmetricCoarse, equalCoarse⟩ := | |
| (M.mem_symmetricExtension s a F H Rc).1 hRc | |
| let tau : Fin 3 → (M.nameDomain s).names := ![⟨u, hu⟩, ⟨fine, hFine⟩, ⟨coarse, hCoarse⟩] | |
| have symmetric : ∀ i, HereditarilySymmetric a s F (tau i).val := | |
| Fin.cases symmetricU (Fin.cases symmetricFine (Fin.cases symmetricCoarse (fun i => Fin.elim0 i))) | |
| have actual : RefinementValidityCode (Name.eval {p | H.mem p} rowName) | |
| (Name.eval {p | H.mem p} (tau 0).val) | |
| (Name.eval {p | H.mem p} (tau 1).val) | |
| (Name.eval {p | H.mem p} (tau 2).val) := by | |
| change RefinementValidityCode (Name.eval {p | H.mem p} rowName) | |
| (Name.eval {p | H.mem p} u) (Name.eval {p | H.mem p} fine) (Name.eval {p | H.mem p} coarse) | |
| rwa [equalU, equalFine, equalCoarse] | |
| obtain ⟨J, hJ, injection⟩ := named tau symmetric actual | |
| refine ⟨J, hJ, ?_⟩ | |
| change InjectionCode | |
| (equivalenceClasses (Name.eval {p | H.mem p} u) (Name.eval {p | H.mem p} coarse)) | |
| (equivalenceClasses (Name.eval {p | H.mem p} u) (Name.eval {p | H.mem p} fine)) J at injection | |
| rwa [equalU, equalFine, equalCoarse] at injection | |
| end PartitionPilot.Forcing.TransitiveGround | |
| namespace PartitionPilot.Forcing.GroundMainPrefix.FinalSupportFulfillment | |
| open SetFormula SetRealization | |
| universe u v | |
| variable {M : TransitiveGround.{u}} {K Labels C D rD : ZFSet.{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 {I : Type v} [Small.{u} I] [Preorder I] | |
| variable {run : GroundMainPrefix M K Labels C D rD pairing unions powers separation I} | |
| variable {level : GroundMainCandidateLevel M K} {i₀ : I} | |
| variable (fulfilled : run.FinalSupportFulfillment level i₀) | |
| theorem structural_ordinal_choice | |
| (collection : CollectionSchema M.sets) | |
| (infinite : Realize M.sets infinity Fin.elim0) | |
| (choice : Realize M.sets SetFormula.choice Fin.elim0) | |
| (labels : Labels = M.groundOmegaOne pairing unions powers separation collection infinite) | |
| (small : M.sets.Countable) (smallD : M.groundEmbeddable D ZFSet.omega) | |
| (irreflexive : ∀ q ∈ D, ZFSet.pair q q ∉ rD) | |
| (columns : ZFSet.{u}) (hColumns : columns ∈ M.sets) | |
| {mu : ZFSet.{u}} (hmu : mu ∈ M.sets) (muOrdinal : ordinalSetProperty mu) : | |
| let geometry := run.finalGeometry i₀ | |
| letI := geometry.group_code.toGroup | |
| letI := geometry.meet.order.toPartialOrder | |
| letI := geometry.decodedBottom | |
| let s := SetMembers.presentation geometry.carrier | |
| let b := SetMembers.presentation geometry.actors | |
| let a := geometry.decodedAction | |
| let directed := geometry.decoded_directed fulfilled.directed | |
| let hL := geometry.carrier_ground | |
| let hG := geometry.actors_ground | |
| let hC := hColumns | |
| let order : s.conditionOrder ∈ M.sets := geometry.decoded_order_eq.symm ▸ geometry.order_ground | |
| let graph : a.actionGraph s b ∈ M.sets := geometry.decoded_action_eq.symm ▸ geometry.action_ground | |
| let nodeMaps := M.conditionMapFamily_mem_of_actionGraph a s b pairing unions powers separation | |
| collection hL hG graph | |
| let supports := geometry.decoded_supportBasis_ground pairing unions powers separation | |
| letI := M.smallFunctionOrder (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega | |
| letI := M.smallFunctionTop (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega | |
| ⟨s.carrier, hL⟩ | |
| let act := M.internalRowAction a s b columns pairing unions powers separation infinite hL hC hG graph | |
| let c := SetMembers.presentation (M.smallPartialFunctions | |
| (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega) | |
| let rows := M.binaryRowNameGraph s.nonbottom.carrier columns ⊤ | |
| let S := M.rowPositionSequences s.carrier s.conditionOrder s.nonbottom.carrier mu | |
| let T := rowTupleTerms (c.encode ⊤) mu s.nonbottom.carrier (⋃₀ ⋃₀ rows) rows S | |
| ∀ valid : ∀ z ∈ T, IsName c z, | |
| let lifted := Name.renamedFamily c.pairEmpty id T valid | |
| let squared := orderedPairNameFamily (c.pairEmpty.encode ⊤) lifted lifted | |
| ∀ (hLifted : lifted ∈ M.sets) (hSquared : squared ∈ M.sets) | |
| (valid1 : ∀ z ∈ lifted, IsName c.pairEmpty z) | |
| (valid2 : ∀ z ∈ squared, IsName c.pairEmpty z) | |
| (closed1 : ∀ g (tau : Name c.pairEmpty), tau.val ∈ lifted → (act.act c.pairEmpty g tau).val ∈ lifted) | |
| (closed2 : ∀ g (tau : Name c.pairEmpty), tau.val ∈ squared → (act.act c.pairEmpty g tau).val ∈ squared) | |
| (children1 : ∀ tau : Name c.pairEmpty, tau.val ∈ lifted → | |
| HereditarilySymmetric act c.pairEmpty (a.principalSupportFamily ⊥ directed) tau) | |
| (children2 : ∀ tau : Name c.pairEmpty, tau.val ∈ squared → | |
| HereditarilySymmetric act c.pairEmpty (a.principalSupportFamily ⊥ directed) tau) | |
| (stages history : ZFSet.{u}) (hs : stages ∈ M.sets) (hh : history ∈ M.sets) | |
| (stagesOrdinal : ordinalSetProperty stages) | |
| (trace : OrdinalRecursionTrace (fun level prior stage => stage = | |
| M.structuralForcingStage c.carrier c.conditionOrder (c.encode ⊤) (act.actionGraph c b) | |
| b.carrier s.carrier s.conditionOrder (a.actionGraph s b) | |
| (supportBasisCode s b a.principalFix) lifted squared level prior) stages history), | |
| let coordinates := M.prod_mem pairing unions powers separation (M.nonbottom_carrier_mem s separation hL) hC | |
| let two := M.natSetCode_mem separation infinite 2 | |
| let carrier := M.countablePartialFunctions_mem pairing unions powers separation infinite coordinates two | |
| let forcingOrder := M.countableFunctionOrder_mem pairing unions powers separation infinite coordinates two | |
| let forcingAction := M.internalRowActionGraph_mem a s b columns pairing unions powers separation infinite hL hC hG graph | |
| let omega := M.omega_mem separation infinite | |
| let topMem := c.encode_mem ⊤ | |
| let topRows : ∀ r ∈ c.carrier, ZFSet.pair r (c.encode ⊤) ∈ c.conditionOrder := | |
| fun r hr => by | |
| obtain ⟨r, rfl⟩ := (c.mem_carrier r).1 hr | |
| exact (c.pair_mem_conditionOrder r ⊤).2 le_top | |
| let packed := M.structuralRefinementHistory b.carrier s.carrier s.conditionOrder | |
| (supportBasisCode s b a.principalFix) lifted squared stages history | |
| let upperQ := M.refinementHistoryForcing c.carrier lifted stages packed | |
| letI := M.refinementHistoryPartialOrder c.conditionOrder_code lifted stages packed | |
| let historyRun := M.structuralForcingTrace_recursiveOrder c.carrier c.conditionOrder (c.encode ⊤) | |
| (act.actionGraph c b) b.carrier s.carrier s.conditionOrder (a.actionGraph s b) | |
| (supportBasisCode s b a.principalFix) lifted squared stagesOrdinal trace | |
| letI := M.refinementHistoryOrderTop c.conditionOrder_code lifted stages packed | |
| historyRun.carriers stagesOrdinal carrier (c.encode ⊤) topMem topRows | |
| let upperAct := M.semanticStructuralAction c act b s a ⊥ directed lifted squared (c.encode ⊤) | |
| pairing unions powers separation collection carrier forcingOrder forcingAction hG hL order graph | |
| nodeMaps supports hLifted hSquared omega valid1 valid2 closed1 closed2 children1 children2 | |
| topMem topRows hs hh stagesOrdinal trace | |
| let upper := SetMembers.presentation upperQ | |
| ∀ H : ConditionFilter (SetMembers upperQ), | |
| H.GenericFor (formulaFamily (M.nameDomain upper)) → | |
| let N := M.symmetricExtension upper upperAct (a.principalSupportFamily ⊥ directed) H | |
| ZFRealization N.sets → | |
| ∀ delta ∈ N.sets, ordinalSetProperty delta → | |
| ∀ z ∈ N.sets, FunctionGraphOn delta z → | |
| (∀ beta A, ZFSet.pair beta A ∈ z → A.Nonempty) → | |
| ∃ f ∈ N.sets, FunctionGraphOn delta f ∧ | |
| ∀ beta A x, ZFSet.pair beta A ∈ z → ZFSet.pair beta x ∈ f → x ∈ A := by | |
| intro geometry | |
| let := geometry.group_code.toGroup | |
| let := geometry.meet.order.toPartialOrder | |
| let := geometry.decodedBottom | |
| intro s b a directed hL hG hC order graph nodeMaps supports | |
| let := M.smallFunctionOrder (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega | |
| let := M.smallFunctionTop (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega | |
| ⟨s.carrier, hL⟩ | |
| intro act c rows S T valid lifted squared hLifted hSquared valid1 valid2 | |
| closed1 closed2 children1 children2 stages history hs hh stagesOrdinal trace | |
| coordinates two carrier forcingOrder forcingAction omega topMem topRows packed upperQ | |
| let := M.refinementHistoryPartialOrder c.conditionOrder_code lifted stages packed | |
| intro historyRun | |
| let := M.refinementHistoryOrderTop c.conditionOrder_code lifted stages packed | |
| historyRun.carriers stagesOrdinal carrier (c.encode ⊤) topMem topRows | |
| intro upperAct upper H ordinary N zf delta hDelta ordinal z hz function nonempty | |
| have hPacked := M.structuralRefinementHistory_mem pairing unions powers separation collection | |
| ![b.carrier, s.carrier, s.conditionOrder, supportBasisCode s b a.principalFix, | |
| lifted, squared, stages, history] | |
| (Fin.cases hG (Fin.cases hL (Fin.cases order (Fin.cases supports | |
| (Fin.cases hLifted (Fin.cases hSquared (Fin.cases hs (Fin.cases hh (fun j => Fin.elim0 j))))))))) | |
| have hQ : upper.carrier ∈ M.sets := M.refinementHistoryForcing_mem pairing unions powers | |
| separation carrier hLifted hs hPacked omega | |
| have groundDelta : delta ∈ M.sets := M.symmetricExtension_ordinal_mem | |
| pairing unions powers separation collection upper upperAct | |
| (a.principalSupportFamily ⊥ directed) H hDelta ordinal | |
| obtain ⟨zName, groundZ, symmetric, same⟩ := | |
| (M.mem_symmetricExtension upper upperAct (a.principalSupportFamily ⊥ directed) H z).1 hz | |
| obtain ⟨V, fixedZ⟩ := symmetric.symmetric | |
| obtain ⟨E, strict⟩ := fulfilled.toFinalFulfillment.decoded_strict_growth V | |
| let original : (M.nameDomain upper).names := ⟨zName, groundZ⟩ | |
| have candidates := fulfilled.structural_graphValue_candidate_availability | |
| collection infinite choice labels small smallD irreflexive columns hColumns hmu muOrdinal | |
| valid hLifted hSquared valid1 valid2 closed1 closed2 children1 children2 | |
| stages history hs hh stagesOrdinal trace original V E strict symmetric fixedZ | |
| let W := M.graphValueCandidateCodes upperAct upper (a.principalFix E) zName | |
| have groundW : W ∈ M.sets := candidates.1 | |
| have validW : ∀ x ∈ W, IsName upper x := candidates.2.1 | |
| have fixed : ∀ psi : Name upper, psi.val ∈ W → | |
| a.principalFix E ≤ upperAct.stabilizer upper psi := fun psi member => | |
| (candidates.2.2.1 psi member).1 | |
| have children : ∀ psi : Name upper, psi.val ∈ W → | |
| HereditarilySymmetric upperAct upper (a.principalSupportFamily ⊥ directed) psi := | |
| fun psi member => (candidates.2.2.1 psi member).2 | |
| apply M.supportedNameFamily_graph_choice upper upperAct (a.principalSupportFamily ⊥ directed) | |
| pairing unions powers separation collection choice hQ groundW validW | |
| (a.principalFix E) ⟨E, le_rfl⟩ fixed children H zf hDelta hz function | |
| intro beta member | |
| have groundBeta : beta ∈ M.sets := M.transitive groundDelta member | |
| obtain ⟨A, edge⟩ := function.total member | |
| have edgeOriginal : ZFSet.pair beta A ∈ Name.eval {p | H.mem p} original.val := by | |
| rw [show Name.eval {p | H.mem p} original.val = z from same] | |
| exact edge | |
| obtain ⟨psi, candidate, B, betaB, chosen⟩ := candidates.2.2.2 beta groundBeta H ordinary | |
| ⟨A, edgeOriginal, nonempty beta A edge⟩ | |
| exact ⟨psi, candidate, B, same ▸ betaB, chosen⟩ | |
| theorem structural_refinement_quotient_injection | |
| (collection : CollectionSchema M.sets) | |
| (infinite : Realize M.sets infinity Fin.elim0) | |
| (choice : Realize M.sets SetFormula.choice Fin.elim0) | |
| (labels : Labels = M.groundOmegaOne pairing unions powers separation collection infinite) | |
| (small : M.sets.Countable) (smallD : M.groundEmbeddable D ZFSet.omega) | |
| (irreflexive : ∀ q ∈ D, ZFSet.pair q q ∉ rD) | |
| (columns : ZFSet.{u}) (hColumns : columns ∈ M.sets) | |
| {mu : ZFSet.{u}} (hmu : mu ∈ M.sets) (muOrdinal : ordinalSetProperty mu) : | |
| let geometry := run.finalGeometry i₀ | |
| letI := geometry.group_code.toGroup | |
| letI := geometry.meet.order.toPartialOrder | |
| letI := geometry.decodedBottom | |
| let s := SetMembers.presentation geometry.carrier | |
| let b := SetMembers.presentation geometry.actors | |
| let a := geometry.decodedAction | |
| let directed := geometry.decoded_directed fulfilled.directed | |
| let hL := geometry.carrier_ground | |
| let hG := geometry.actors_ground | |
| let hC := hColumns | |
| let order : s.conditionOrder ∈ M.sets := geometry.decoded_order_eq.symm ▸ geometry.order_ground | |
| let graph : a.actionGraph s b ∈ M.sets := geometry.decoded_action_eq.symm ▸ geometry.action_ground | |
| let nodeMaps := M.conditionMapFamily_mem_of_actionGraph a s b pairing unions powers separation | |
| collection hL hG graph | |
| let supports := geometry.decoded_supportBasis_ground pairing unions powers separation | |
| letI := M.smallFunctionOrder (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega | |
| letI := M.smallFunctionTop (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega | |
| ⟨s.carrier, hL⟩ | |
| let act := M.internalRowAction a s b columns pairing unions powers separation infinite hL hC hG graph | |
| let c := SetMembers.presentation (M.smallPartialFunctions | |
| (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega) | |
| let rows := M.binaryRowNameGraph s.nonbottom.carrier columns ⊤ | |
| let S := M.rowPositionSequences s.carrier s.conditionOrder s.nonbottom.carrier mu | |
| let T := rowTupleTerms (c.encode ⊤) mu s.nonbottom.carrier (⋃₀ ⋃₀ rows) rows S | |
| ∀ valid : ∀ z ∈ T, IsName c z, | |
| let lifted := Name.renamedFamily c.pairEmpty id T valid | |
| let squared := orderedPairNameFamily (c.pairEmpty.encode ⊤) lifted lifted | |
| ∀ (hLifted : lifted ∈ M.sets) (hSquared : squared ∈ M.sets) | |
| (valid1 : ∀ z ∈ lifted, IsName c.pairEmpty z) | |
| (valid2 : ∀ z ∈ squared, IsName c.pairEmpty z) | |
| (closed1 : ∀ g (tau : Name c.pairEmpty), tau.val ∈ lifted → (act.act c.pairEmpty g tau).val ∈ lifted) | |
| (closed2 : ∀ g (tau : Name c.pairEmpty), tau.val ∈ squared → (act.act c.pairEmpty g tau).val ∈ squared) | |
| (children1 : ∀ tau : Name c.pairEmpty, tau.val ∈ lifted → | |
| HereditarilySymmetric act c.pairEmpty (a.principalSupportFamily ⊥ directed) tau) | |
| (children2 : ∀ tau : Name c.pairEmpty, tau.val ∈ squared → | |
| HereditarilySymmetric act c.pairEmpty (a.principalSupportFamily ⊥ directed) tau) | |
| (stages history : ZFSet.{u}) (hs : stages ∈ M.sets) (hh : history ∈ M.sets) | |
| (stagesOrdinal : ordinalSetProperty stages) | |
| (trace : OrdinalRecursionTrace (fun level prior stage => stage = | |
| M.structuralForcingStage c.carrier c.conditionOrder (c.encode ⊤) (act.actionGraph c b) | |
| b.carrier s.carrier s.conditionOrder (a.actionGraph s b) | |
| (supportBasisCode s b a.principalFix) lifted squared level prior) stages history) | |
| (_standard : GroundStandardInaccessible M stages) | |
| (_smallRows : GroundBelow M c.carrier stages) (_smallLifted : GroundBelow M lifted stages), | |
| let coordinates := M.prod_mem pairing unions powers separation (M.nonbottom_carrier_mem s separation hL) hC | |
| let two := M.natSetCode_mem separation infinite 2 | |
| let carrier := M.countablePartialFunctions_mem pairing unions powers separation infinite coordinates two | |
| let forcingOrder := M.countableFunctionOrder_mem pairing unions powers separation infinite coordinates two | |
| let forcingAction := M.internalRowActionGraph_mem a s b columns pairing unions powers separation infinite hL hC hG graph | |
| let omega := M.omega_mem separation infinite | |
| let topMem := c.encode_mem ⊤ | |
| let topRows : ∀ r ∈ c.carrier, ZFSet.pair r (c.encode ⊤) ∈ c.conditionOrder := | |
| fun r hr => by | |
| obtain ⟨r, rfl⟩ := (c.mem_carrier r).1 hr | |
| exact (c.pair_mem_conditionOrder r ⊤).2 le_top | |
| let packed := M.structuralRefinementHistory b.carrier s.carrier s.conditionOrder | |
| (supportBasisCode s b a.principalFix) lifted squared stages history | |
| let historyRun := M.structuralForcingTrace_recursiveOrder c.carrier c.conditionOrder (c.encode ⊤) | |
| (act.actionGraph c b) b.carrier s.carrier s.conditionOrder (a.actionGraph s b) | |
| (supportBasisCode s b a.principalFix) lifted squared stagesOrdinal trace | |
| let upperSet := M.refinementHistoryForcing c.carrier lifted stages packed | |
| letI := M.refinementHistoryPartialOrder c.conditionOrder_code lifted stages packed | |
| letI := M.refinementHistoryOrderTop c.conditionOrder_code lifted stages packed | |
| historyRun.carriers stagesOrdinal carrier (c.encode ⊤) topMem topRows | |
| let upper := SetMembers.presentation upperSet | |
| let upperAct := M.semanticStructuralAction c act b s a ⊥ directed lifted squared (c.encode ⊤) | |
| pairing unions powers separation collection carrier forcingOrder forcingAction hG hL order graph | |
| nodeMaps supports hLifted hSquared omega valid1 valid2 closed1 closed2 children1 children2 | |
| topMem topRows hs hh stagesOrdinal trace | |
| let validUpper := M.refinementHistoryRowNameFamily_valid c historyRun.carriers stagesOrdinal carrier lifted valid1 | |
| ∀ (H : ConditionFilter (SetMembers upperSet)), | |
| H.GenericFor (formulaFamily (M.nameDomain upper)) → | |
| (∀ (beta : ZFSet.{u}) (member : beta ∈ stages), | |
| let hBeta := M.transitive hs member | |
| let betaOrdinal := ordinalSetProperty_member stagesOrdinal member | |
| let betaSubset := (And.left stagesOrdinal) beta member | |
| let lowerPacked := graphRestriction beta packed | |
| let lowerSet := M.refinementHistoryForcing c.carrier lifted beta lowerPacked | |
| letI := M.refinementHistoryPartialOrder c.conditionOrder_code lifted beta lowerPacked | |
| letI := M.refinementHistoryOrderTop c.conditionOrder_code lifted beta lowerPacked | |
| (historyRun.carriers.restrict betaOrdinal betaSubset) betaOrdinal carrier (c.encode ⊤) topMem topRows | |
| let lower := SetMembers.presentation lowerSet | |
| let projection := M.semanticStructuralTrace_completeProjection c act b s a ⊥ directed lifted squared (c.encode ⊤) | |
| pairing unions powers separation collection carrier forcingOrder forcingAction hG hL order graph | |
| nodeMaps supports hLifted hSquared omega valid1 valid2 closed1 closed2 children1 children2 | |
| topMem topRows hs hh stagesOrdinal trace beta hBeta betaOrdinal betaSubset infinite choice | |
| (projection.projectedFilter H).GenericFor (M.codedFamily lower) ∧ | |
| (projection.projectedFilter H).GenericFor (formulaFamily (M.nameDomain lower))) → | |
| ∀ tau : Fin 3 → (M.nameDomain upper).names, | |
| (∀ i, HereditarilySymmetric upperAct upper (a.principalSupportFamily ⊥ directed) (tau i).val) → | |
| RefinementValidityCode | |
| (Name.eval {p | H.mem p} (Name.familySet ⊤ lifted validUpper)) | |
| (Name.eval {p | H.mem p} (tau 0).val) (Name.eval {p | H.mem p} (tau 1).val) | |
| (Name.eval {p | H.mem p} (tau 2).val) → | |
| ∃ J ∈ (M.symmetricExtension upper upperAct (a.principalSupportFamily ⊥ directed) H).sets, | |
| InjectionCode | |
| (equivalenceClasses (Name.eval {p | H.mem p} (tau 0).val) | |
| (Name.eval {p | H.mem p} (tau 2).val)) | |
| (equivalenceClasses (Name.eval {p | H.mem p} (tau 0).val) | |
| (Name.eval {p | H.mem p} (tau 1).val)) J := by | |
| let geometry := run.finalGeometry i₀ | |
| let := geometry.group_code.toGroup | |
| let := geometry.meet.order.toPartialOrder | |
| let := geometry.decodedBottom | |
| let s := SetMembers.presentation geometry.carrier | |
| let b := SetMembers.presentation geometry.actors | |
| let a := geometry.decodedAction | |
| let directed := geometry.decoded_directed fulfilled.directed | |
| let hL := geometry.carrier_ground | |
| let hG := geometry.actors_ground | |
| let hC := hColumns | |
| let order : s.conditionOrder ∈ M.sets := geometry.decoded_order_eq.symm ▸ geometry.order_ground | |
| let graph : a.actionGraph s b ∈ M.sets := geometry.decoded_action_eq.symm ▸ geometry.action_ground | |
| let nodeMaps := M.conditionMapFamily_mem_of_actionGraph a s b pairing unions powers separation | |
| collection hL hG graph | |
| let supports := geometry.decoded_supportBasis_ground pairing unions powers separation | |
| let := M.smallFunctionOrder (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega | |
| let := M.smallFunctionTop (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega | |
| ⟨s.carrier, hL⟩ | |
| let act := M.internalRowAction a s b columns pairing unions powers separation infinite hL hC hG graph | |
| let c := SetMembers.presentation (M.smallPartialFunctions | |
| (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega) | |
| let rows := M.binaryRowNameGraph s.nonbottom.carrier columns ⊤ | |
| let S := M.rowPositionSequences s.carrier s.conditionOrder s.nonbottom.carrier mu | |
| let T := rowTupleTerms (c.encode ⊤) mu s.nonbottom.carrier (⋃₀ ⋃₀ rows) rows S | |
| dsimp only | |
| intro valid | |
| let lifted := Name.renamedFamily c.pairEmpty id T valid | |
| let squared := orderedPairNameFamily (c.pairEmpty.encode ⊤) lifted lifted | |
| intro hLifted hSquared valid1 valid2 closed1 closed2 children1 children2 | |
| stages history hs hh stagesOrdinal trace standard smallRows smallLifted | |
| let coordinates := M.prod_mem pairing unions powers separation (M.nonbottom_carrier_mem s separation hL) hC | |
| let two := M.natSetCode_mem separation infinite 2 | |
| let carrier := M.countablePartialFunctions_mem pairing unions powers separation infinite coordinates two | |
| let forcingOrder := M.countableFunctionOrder_mem pairing unions powers separation infinite coordinates two | |
| let forcingAction := M.internalRowActionGraph_mem a s b columns pairing unions powers separation infinite hL hC hG graph | |
| let omega := M.omega_mem separation infinite | |
| let topMem := c.encode_mem ⊤ | |
| let topRows : ∀ r ∈ c.carrier, ZFSet.pair r (c.encode ⊤) ∈ c.conditionOrder := | |
| fun r hr => by | |
| obtain ⟨r, rfl⟩ := (c.mem_carrier r).1 hr | |
| exact (c.pair_mem_conditionOrder r ⊤).2 le_top | |
| let packed := M.structuralRefinementHistory b.carrier s.carrier s.conditionOrder | |
| (supportBasisCode s b a.principalFix) lifted squared stages history | |
| let historyRun := M.structuralForcingTrace_recursiveOrder c.carrier c.conditionOrder (c.encode ⊤) | |
| (act.actionGraph c b) b.carrier s.carrier s.conditionOrder (a.actionGraph s b) | |
| (supportBasisCode s b a.principalFix) lifted squared stagesOrdinal trace | |
| let upperSet := M.refinementHistoryForcing c.carrier lifted stages packed | |
| let := M.refinementHistoryPartialOrder c.conditionOrder_code lifted stages packed | |
| let := M.refinementHistoryOrderTop c.conditionOrder_code lifted stages packed | |
| historyRun.carriers stagesOrdinal carrier (c.encode ⊤) topMem topRows | |
| let upper := SetMembers.presentation upperSet | |
| let upperAct := M.semanticStructuralAction c act b s a ⊥ directed lifted squared (c.encode ⊤) | |
| pairing unions powers separation collection carrier forcingOrder forcingAction hG hL order graph | |
| nodeMaps supports hLifted hSquared omega valid1 valid2 closed1 closed2 children1 children2 | |
| topMem topRows hs hh stagesOrdinal trace | |
| let validUpper := M.refinementHistoryRowNameFamily_valid c historyRun.carriers stagesOrdinal carrier lifted valid1 | |
| intro H ordinary lowerGeneric tau symmetric originalValid | |
| have indexed := M.semanticStructuralTrace_refinementOutputs c act b s a ⊥ directed | |
| lifted squared (c.encode ⊤) pairing unions powers separation collection carrier forcingOrder forcingAction | |
| hG hL order graph nodeMaps supports hLifted hSquared omega valid1 valid2 closed1 closed2 children1 children2 | |
| topMem topRows hs hh standard trace infinite choice smallRows smallLifted small rfl | |
| fulfilled.toFinalFulfillment.decoded_strict_growth tau symmetric | |
| obtain ⟨beta, member, data⟩ := indexed | |
| let hBeta := M.transitive hs member | |
| let betaOrdinal := ordinalSetProperty_member stagesOrdinal member | |
| let betaSubset := (And.left stagesOrdinal) beta member | |
| let lowerPacked := graphRestriction beta packed | |
| let lowerSet := M.refinementHistoryForcing c.carrier lifted beta lowerPacked | |
| let := M.refinementHistoryPartialOrder c.conditionOrder_code lifted beta lowerPacked | |
| let := M.refinementHistoryOrderTop c.conditionOrder_code lifted beta lowerPacked | |
| (historyRun.carriers.restrict betaOrdinal betaSubset) betaOrdinal carrier (c.encode ⊤) topMem topRows | |
| let lower := SetMembers.presentation lowerSet | |
| let localValid := M.refinementHistoryRowNameFamily_valid c | |
| (historyRun.carriers.restrict betaOrdinal betaSubset) betaOrdinal carrier lifted valid1 | |
| let hPacked := M.structuralRefinementHistory_mem pairing unions powers separation collection | |
| ![b.carrier, s.carrier, s.conditionOrder, supportBasisCode s b a.principalFix, | |
| lifted, squared, stages, history] | |
| (Fin.cases hG (Fin.cases hL (Fin.cases order (Fin.cases supports | |
| (Fin.cases hLifted (Fin.cases hSquared (Fin.cases hs (Fin.cases hh (fun j => Fin.elim0 j))))))))) | |
| let witnesses := M.structuralForcingTrace_witnesses c act b s a ⊥ directed lifted squared (c.encode ⊤) | |
| pairing unions powers separation collection carrier forcingOrder forcingAction hG hL order graph | |
| nodeMaps supports hLifted hSquared omega valid1 valid2 closed1 closed2 children1 children2 | |
| topMem topRows hs hh stagesOrdinal trace | |
| let mono := M.structuralHistory_rawTests_mono b s a ⊥ directed lifted squared stages history | |
| pairing unions powers separation collection hG hL supports hh hLifted witnesses | |
| let inc := RecursiveRefinementOrderHistory.inclusionFunction historyRun stagesOrdinal betaOrdinal betaSubset | |
| pairing unions powers separation infinite choice hs hPacked hLifted hBeta carrier (c.encode ⊤) topMem topRows mono | |
| dsimp only at data | |
| obtain ⟨_env, _names, _last, normalized, _entries, _normalizedLast, _forced, _supported, | |
| V, E, _baseV, _strict, _fixes, index, _stored, _attained, _fineGround, _coarseGround, _mapGround, values⟩ := data | |
| have outputValues := values H ordinary (lowerGeneric beta member).1 (lowerGeneric beta member).2 originalValid | |
| obtain ⟨_same, _objects, fineValues, coarseValues, _naturalMap⟩ := outputValues | |
| have injection := fulfilled.structural_assignment_label_injection collection infinite choice labels small smallD | |
| irreflexive columns hColumns hmu muOrdinal valid hLifted hSquared valid1 valid2 closed1 closed2 children1 children2 | |
| stages history hs hh stagesOrdinal trace beta member V E (normalized 0) (normalized 1) (normalized 2) | |
| index H ordinary | |
| have fineEq : Name.eval {q | H.mem (inc q)} | |
| (Name.refinementQuotient lifted localValid (normalized 0).val (normalized 1).val) = | |
| equivalenceClasses (Name.eval {p | H.mem p} (tau 0).val) (Name.eval {p | H.mem p} (tau 1).val) := | |
| fineValues | |
| have coarseEq : Name.eval {q | H.mem (inc q)} | |
| (Name.refinementQuotient lifted localValid (normalized 0).val (normalized 2).val) = | |
| equivalenceClasses (Name.eval {p | H.mem p} (tau 0).val) (Name.eval {p | H.mem p} (tau 2).val) := | |
| coarseValues | |
| refine ⟨_, injection.2, ?_⟩ | |
| rw [← coarseEq, ← fineEq] | |
| exact injection.1 | |
| theorem exists_rowSemanticQuotientInjectionModel | |
| (collection : CollectionSchema M.sets) (infinite : Realize M.sets infinity Fin.elim0) | |
| (choice : Realize M.sets SetFormula.choice Fin.elim0) | |
| (small : M.sets.Countable) | |
| (hK : K ∈ M.sets) (standard : GroundStandardInaccessible M K) | |
| (indices : GroundBelow M run.indices K) | |
| (labels : Labels = M.groundOmegaOne pairing unions powers separation collection infinite) | |
| (smallD : M.groundEmbeddable D ZFSet.omega) | |
| (irreflexive : ∀ q ∈ D, ZFSet.pair q q ∉ rD) : | |
| let geometry := run.finalGeometry i₀ | |
| letI := geometry.group_code.toGroup | |
| letI := geometry.meet.order.toPartialOrder | |
| letI := geometry.decodedBottom | |
| let s := SetMembers.presentation geometry.carrier | |
| let b := SetMembers.presentation geometry.actors | |
| let a := geometry.decodedAction | |
| let columns := M.groundOmegaOne pairing unions powers separation collection infinite | |
| let hColumns := (M.groundOmegaOne_spec pairing unions powers separation collection infinite).1 | |
| letI := M.smallFunctionOrder (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega | |
| letI := M.smallFunctionTop (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega | |
| ⟨s.carrier, geometry.carrier_ground⟩ | |
| let act := M.internalRowAction a s b columns pairing unions powers separation infinite | |
| geometry.carrier_ground hColumns geometry.actors_ground | |
| (geometry.decoded_action_eq.symm ▸ geometry.action_ground) | |
| let c := SetMembers.presentation (M.smallPartialFunctions | |
| (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega) | |
| let directed := geometry.decoded_directed fulfilled.directed | |
| ∃ mu ∈ M.sets, mu ∈ K ∧ GroundCardinal M mu ∧ ZFSet.omega ⊆ mu ∧ | |
| M.groundEmbeddable s.nonbottom.carrier mu ∧ | |
| let S := M.rowPositionSequences s.carrier s.conditionOrder s.nonbottom.carrier mu | |
| let rows := M.binaryRowNameGraph s.nonbottom.carrier columns ⊤ | |
| let T := rowTupleTerms (c.encode ⊤) mu s.nonbottom.carrier (⋃₀ ⋃₀ rows) rows S | |
| T ∈ M.sets ∧ GroundBelow M T K ∧ ∃ valid : ∀ z ∈ T, IsName c z, | |
| let lifted := Name.renamedFamily c.pairEmpty id T valid | |
| let squared := orderedPairNameFamily (c.pairEmpty.encode ⊤) lifted lifted | |
| ∃ (hLifted : lifted ∈ M.sets) (hSquared : squared ∈ M.sets) | |
| (valid1 : ∀ z ∈ lifted, IsName c.pairEmpty z) | |
| (valid2 : ∀ z ∈ squared, IsName c.pairEmpty z) | |
| (closed1 : ∀ g (tau : Name c.pairEmpty), tau.val ∈ lifted → (act.act c.pairEmpty g tau).val ∈ lifted) | |
| (closed2 : ∀ g (tau : Name c.pairEmpty), tau.val ∈ squared → (act.act c.pairEmpty g tau).val ∈ squared) | |
| (children1 : ∀ tau : Name c.pairEmpty, tau.val ∈ lifted → | |
| HereditarilySymmetric act c.pairEmpty (a.principalSupportFamily ⊥ directed) tau) | |
| (children2 : ∀ tau : Name c.pairEmpty, tau.val ∈ squared → | |
| HereditarilySymmetric act c.pairEmpty (a.principalSupportFamily ⊥ directed) tau), | |
| ∃ (history : ZFSet.{u}) (hHistory : history ∈ M.sets) | |
| (trace : OrdinalRecursionTrace (fun level prior stage => stage = | |
| M.structuralForcingStage c.carrier c.conditionOrder (c.encode ⊤) (act.actionGraph c b) | |
| b.carrier s.carrier s.conditionOrder (a.actionGraph s b) | |
| (supportBasisCode s b a.principalFix) lifted squared level prior) K history), | |
| let coordinateGround := M.prod_mem pairing unions powers separation | |
| (M.nonbottom_carrier_mem s separation geometry.carrier_ground) hColumns | |
| let nodeActionGround : a.actionGraph s b ∈ M.sets := | |
| geometry.decoded_action_eq.symm ▸ geometry.action_ground | |
| let nodeOrderGround : s.conditionOrder ∈ M.sets := | |
| geometry.decoded_order_eq.symm ▸ geometry.order_ground | |
| let forcingActionGround := M.internalRowActionGraph_mem a s b columns | |
| pairing unions powers separation infinite geometry.carrier_ground hColumns | |
| geometry.actors_ground nodeActionGround | |
| let supportGround := M.principalSupportBasis_mem a s b pairing unions powers separation | |
| geometry.carrier_ground geometry.actors_ground nodeOrderGround nodeActionGround | |
| let nodeMapsGround := M.conditionMapFamily_mem_of_actionGraph a s b pairing unions powers separation | |
| collection geometry.carrier_ground geometry.actors_ground nodeActionGround | |
| let topMem := c.encode_mem ⊤ | |
| let topRows : ∀ row ∈ c.carrier, ZFSet.pair row (c.encode ⊤) ∈ c.conditionOrder := by | |
| intro row member | |
| obtain ⟨p, rfl⟩ := (c.mem_carrier row).1 member | |
| exact (c.pair_mem_conditionOrder p ⊤).2 le_top | |
| let two := M.natSetCode_mem separation infinite 2 | |
| let carrier := M.countablePartialFunctions_mem pairing unions powers separation infinite coordinateGround two | |
| let forcingOrderGround := M.countableFunctionOrder_mem pairing unions powers separation infinite coordinateGround two | |
| let omega := M.omega_mem separation infinite | |
| let packed := M.structuralRefinementHistory b.carrier s.carrier s.conditionOrder | |
| (supportBasisCode s b a.principalFix) lifted squared K history | |
| let Q := M.refinementHistoryForcing c.carrier lifted K packed | |
| let Cuts := {alpha : ZFSet // alpha ∈ M.sets ∧ ordinalSetProperty alpha ∧ alpha ⊆ K} | |
| let lower := (fun j : Cuts => SetMembers (M.refinementHistoryForcing c.carrier lifted (Subtype.val j) (graphRestriction (Subtype.val j) packed))) | |
| let historyRun := M.structuralForcingTrace_recursiveOrder c.carrier c.conditionOrder (c.encode ⊤) (act.actionGraph c b) | |
| b.carrier s.carrier s.conditionOrder (a.actionGraph s b) (supportBasisCode s b a.principalFix) lifted squared standard.1.1 trace | |
| let witnesses := M.structuralForcingTrace_witnesses c act b s a ⊥ directed lifted squared (c.encode ⊤) pairing unions powers separation collection carrier forcingOrderGround forcingActionGround geometry.actors_ground geometry.carrier_ground nodeOrderGround nodeActionGround nodeMapsGround supportGround hLifted hSquared omega valid1 valid2 closed1 closed2 children1 children2 topMem topRows hK hHistory standard.1.1 trace | |
| let mono := M.structuralHistory_rawTests_mono b s a ⊥ directed lifted squared K history | |
| pairing unions powers separation collection geometry.actors_ground geometry.carrier_ground supportGround hHistory hLifted witnesses | |
| let hPacked := M.structuralRefinementHistory_mem pairing unions powers separation collection | |
| ![b.carrier, s.carrier, s.conditionOrder, supportBasisCode s b a.principalFix, lifted, squared, K, history] | |
| (Fin.cases geometry.actors_ground (Fin.cases geometry.carrier_ground (Fin.cases nodeOrderGround (Fin.cases supportGround | |
| (Fin.cases hLifted (Fin.cases hSquared (Fin.cases hK (Fin.cases hHistory (fun j => Fin.elim0 j))))))))) | |
| letI := M.refinementHistoryPartialOrder c.conditionOrder_code lifted K packed | |
| let upperAction := M.semanticStructuralAction c act b s a ⊥ directed lifted squared (c.encode ⊤) pairing unions powers separation collection carrier forcingOrderGround forcingActionGround geometry.actors_ground geometry.carrier_ground nodeOrderGround nodeActionGround nodeMapsGround supportGround hLifted hSquared omega valid1 valid2 closed1 closed2 children1 children2 topMem topRows hK hHistory standard.1.1 trace | |
| letI : ∀ j : Cuts, PartialOrder (lower j) := fun j => | |
| M.refinementHistoryPartialOrder c.conditionOrder_code lifted j.val (graphRestriction j.val packed) | |
| let restrictions : ∀ j : Cuts, SetMembers Q →o lower j := fun j => | |
| (historyRun).restriction standard.1.1 j.property.2.1 j.property.2.2 c.conditionOrder_code | |
| let inclusions : ∀ j : Cuts, lower j ↪o SetMembers Q := fun j => | |
| (historyRun).inclusion standard.1.1 j.property.2.1 j.property.2.2 pairing unions powers separation infinite choice | |
| hK hPacked hLifted j.property.1 carrier (c.encode ⊤) topMem topRows mono c.conditionOrder_code | |
| let projections : ∀ j, CompleteProjection (restrictions j) (inclusions j) := fun j => | |
| M.semanticStructuralTrace_completeProjection c act b s a ⊥ directed lifted squared (c.encode ⊤) pairing unions powers separation collection carrier forcingOrderGround forcingActionGround geometry.actors_ground geometry.carrier_ground nodeOrderGround nodeActionGround nodeMapsGround supportGround hLifted hSquared omega valid1 valid2 closed1 closed2 children1 children2 topMem topRows hK hHistory standard.1.1 trace j.val j.property.1 | |
| j.property.2.1 j.property.2.2 infinite choice | |
| let upperPres := SetMembers.presentation Q | |
| let F := a.principalSupportFamily ⊥ directed | |
| letI := M.refinementHistoryOrderTop c.conditionOrder_code lifted K packed | |
| historyRun.carriers standard.1.1 carrier (c.encode ⊤) topMem topRows | |
| let validUpper := M.refinementHistoryRowNameFamily_valid c historyRun.carriers | |
| standard.1.1 carrier lifted valid1 | |
| ∀ p : SetMembers Q, ∃ H : ConditionFilter (SetMembers Q), | |
| H.mem p ∧ H.GenericFor (M.codedFamily upperPres) ∧ | |
| H.GenericFor (formulaFamily (M.nameDomain upperPres)) ∧ | |
| H.GenericFor (formulaFamily ((upperAction).symmetricDomain upperPres (M.nameDomain upperPres) F)) ∧ | |
| (∀ j : Cuts, | |
| ((projections j).projectedFilter H).GenericFor | |
| (M.codedFamily (SetMembers.presentation (M.refinementHistoryForcing c.carrier lifted j.val (graphRestriction j.val packed)))) ∧ | |
| ((projections j).projectedFilter H).GenericFor | |
| (formulaFamily (M.nameDomain (SetMembers.presentation (M.refinementHistoryForcing c.carrier lifted j.val (graphRestriction j.val packed)))))) ∧ | |
| M.sets ⊆ ((upperAction).symmetricDomain upperPres (M.nameDomain upperPres) F).values {q | H.mem q} ∧ | |
| ZFRealization (((upperAction).symmetricDomain upperPres (M.nameDomain upperPres) F).values {q | H.mem q}) ∧ | |
| (∀ U ∈ M.sets, | |
| GroundSequenceReflection M (M.ordinaryExtension upperPres H) U ∧ | |
| GroundSequenceReflection M (M.symmetricExtension upperPres (upperAction) F H) U) ∧ | |
| (∀ tau : Fin 3 → (M.nameDomain upperPres).names, | |
| (∀ i, HereditarilySymmetric upperAction upperPres F (tau i).val) → | |
| RefinementValidityCode | |
| (Name.eval {q | H.mem q} (Name.familySet ⊤ lifted validUpper)) | |
| (Name.eval {q | H.mem q} (tau 0).val) (Name.eval {q | H.mem q} (tau 1).val) | |
| (Name.eval {q | H.mem q} (tau 2).val) → | |
| ∃ J ∈ (M.symmetricExtension upperPres upperAction F H).sets, | |
| InjectionCode | |
| (equivalenceClasses (Name.eval {q | H.mem q} (tau 0).val) | |
| (Name.eval {q | H.mem q} (tau 2).val)) | |
| (equivalenceClasses (Name.eval {q | H.mem q} (tau 0).val) | |
| (Name.eval {q | H.mem q} (tau 1).val)) J) := by | |
| let geometry := run.finalGeometry i₀ | |
| let := geometry.group_code.toGroup | |
| let := geometry.meet.order.toPartialOrder | |
| let := geometry.decodedBottom | |
| let s := SetMembers.presentation geometry.carrier | |
| let b := SetMembers.presentation geometry.actors | |
| let a := geometry.decodedAction | |
| let columns := M.groundOmegaOne pairing unions powers separation collection infinite | |
| have hColumns := (M.groundOmegaOne_spec pairing unions powers separation collection infinite).1 | |
| let := M.smallFunctionOrder (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega | |
| let := M.smallFunctionTop (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega | |
| ⟨s.carrier, geometry.carrier_ground⟩ | |
| have nodeActionGround : a.actionGraph s b ∈ M.sets := geometry.decoded_action_eq.symm ▸ geometry.action_ground | |
| have nodeOrderGround : s.conditionOrder ∈ M.sets := geometry.decoded_order_eq.symm ▸ geometry.order_ground | |
| let act := M.internalRowAction a s b columns pairing unions powers separation infinite | |
| geometry.carrier_ground hColumns geometry.actors_ground nodeActionGround | |
| let c := SetMembers.presentation (M.smallPartialFunctions | |
| (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega) | |
| have directed := geometry.decoded_directed fulfilled.directed | |
| have coordinates := M.prod_mem pairing unions powers separation | |
| (M.nonbottom_carrier_mem s separation geometry.carrier_ground) hColumns | |
| have forcingAction := M.internalRowActionGraph_mem a s b columns pairing unions powers separation infinite | |
| geometry.carrier_ground hColumns geometry.actors_ground nodeActionGround | |
| have supports := M.principalSupportBasis_mem a s b pairing unions powers separation | |
| geometry.carrier_ground geometry.actors_ground nodeOrderGround nodeActionGround | |
| have nodeMaps := M.conditionMapFamily_mem_of_actionGraph a s b pairing unions powers separation | |
| collection geometry.carrier_ground geometry.actors_ground nodeActionGround | |
| have original := fulfilled.toFinalFulfillment.exists_rowSemanticStructuralSequenceReflection | |
| collection infinite choice small hK standard indices | |
| obtain ⟨mu, hmu, hmuK, cardinal, omegaIncluded, positions, ground, below, valid, data⟩ := original | |
| let S := M.rowPositionSequences s.carrier s.conditionOrder s.nonbottom.carrier mu | |
| let rows := M.binaryRowNameGraph s.nonbottom.carrier columns ⊤ | |
| let T := rowTupleTerms (c.encode ⊤) mu s.nonbottom.carrier (⋃₀ ⋃₀ rows) rows S | |
| let lifted := Name.renamedFamily c.pairEmpty id T valid | |
| let squared := orderedPairNameFamily (c.pairEmpty.encode ⊤) lifted lifted | |
| obtain ⟨hLifted, hSquared, valid1, valid2, closed1, closed2, children1, children2, | |
| _hGraph, _injection, history, hHistory, trace, _hPacked0, _historyRun0, _witnesses0, | |
| _P, _order0, _top0, _action0, _code0, _fields0, _witness0, final⟩ := data | |
| dsimp only | |
| refine ⟨mu, hmu, hmuK, cardinal, omegaIncluded, positions, ground, below, valid, | |
| hLifted, hSquared, valid1, valid2, closed1, closed2, children1, children2, | |
| history, hHistory, trace, ?_⟩ | |
| let coordinateGround := M.prod_mem pairing unions powers separation | |
| (M.nonbottom_carrier_mem s separation geometry.carrier_ground) hColumns | |
| let nodeActionGround : a.actionGraph s b ∈ M.sets := | |
| geometry.decoded_action_eq.symm ▸ geometry.action_ground | |
| let nodeOrderGround : s.conditionOrder ∈ M.sets := | |
| geometry.decoded_order_eq.symm ▸ geometry.order_ground | |
| let forcingActionGround := M.internalRowActionGraph_mem a s b columns | |
| pairing unions powers separation infinite geometry.carrier_ground hColumns | |
| geometry.actors_ground nodeActionGround | |
| let supportGround := M.principalSupportBasis_mem a s b pairing unions powers separation | |
| geometry.carrier_ground geometry.actors_ground nodeOrderGround nodeActionGround | |
| let nodeMapsGround := M.conditionMapFamily_mem_of_actionGraph a s b pairing unions powers separation | |
| collection geometry.carrier_ground geometry.actors_ground nodeActionGround | |
| let topMem := c.encode_mem ⊤ | |
| let topRows : ∀ row ∈ c.carrier, ZFSet.pair row (c.encode ⊤) ∈ c.conditionOrder := by | |
| intro row member | |
| obtain ⟨p, rfl⟩ := (c.mem_carrier row).1 member | |
| exact (c.pair_mem_conditionOrder p ⊤).2 le_top | |
| let two := M.natSetCode_mem separation infinite 2 | |
| let carrier := M.countablePartialFunctions_mem pairing unions powers separation infinite coordinateGround two | |
| let forcingOrderGround := M.countableFunctionOrder_mem pairing unions powers separation infinite coordinateGround two | |
| let omega := M.omega_mem separation infinite | |
| let packed := M.structuralRefinementHistory b.carrier s.carrier s.conditionOrder | |
| (supportBasisCode s b a.principalFix) lifted squared K history | |
| let Q := M.refinementHistoryForcing c.carrier lifted K packed | |
| let Cuts := {alpha : ZFSet // alpha ∈ M.sets ∧ ordinalSetProperty alpha ∧ alpha ⊆ K} | |
| let lower := (fun j : Cuts => SetMembers (M.refinementHistoryForcing c.carrier lifted (Subtype.val j) (graphRestriction (Subtype.val j) packed))) | |
| let historyRun := M.structuralForcingTrace_recursiveOrder c.carrier c.conditionOrder (c.encode ⊤) (act.actionGraph c b) | |
| b.carrier s.carrier s.conditionOrder (a.actionGraph s b) (supportBasisCode s b a.principalFix) lifted squared standard.1.1 trace | |
| let witnesses := M.structuralForcingTrace_witnesses c act b s a ⊥ directed lifted squared (c.encode ⊤) pairing unions powers separation collection carrier forcingOrderGround forcingActionGround geometry.actors_ground geometry.carrier_ground nodeOrderGround nodeActionGround nodeMapsGround supportGround hLifted hSquared omega valid1 valid2 closed1 closed2 children1 children2 topMem topRows hK hHistory standard.1.1 trace | |
| let mono := M.structuralHistory_rawTests_mono b s a ⊥ directed lifted squared K history | |
| pairing unions powers separation collection geometry.actors_ground geometry.carrier_ground supportGround hHistory hLifted witnesses | |
| let hPacked := M.structuralRefinementHistory_mem pairing unions powers separation collection | |
| ![b.carrier, s.carrier, s.conditionOrder, supportBasisCode s b a.principalFix, lifted, squared, K, history] | |
| (Fin.cases geometry.actors_ground (Fin.cases geometry.carrier_ground (Fin.cases nodeOrderGround (Fin.cases supportGround | |
| (Fin.cases hLifted (Fin.cases hSquared (Fin.cases hK (Fin.cases hHistory (fun j => Fin.elim0 j))))))))) | |
| let := M.refinementHistoryPartialOrder c.conditionOrder_code lifted K packed | |
| let upperAction := M.semanticStructuralAction c act b s a ⊥ directed lifted squared (c.encode ⊤) pairing unions powers separation collection carrier forcingOrderGround forcingActionGround geometry.actors_ground geometry.carrier_ground nodeOrderGround nodeActionGround nodeMapsGround supportGround hLifted hSquared omega valid1 valid2 closed1 closed2 children1 children2 topMem topRows hK hHistory standard.1.1 trace | |
| let : ∀ j : Cuts, PartialOrder (lower j) := fun j => | |
| M.refinementHistoryPartialOrder c.conditionOrder_code lifted j.val (graphRestriction j.val packed) | |
| let restrictions : ∀ j : Cuts, SetMembers Q →o lower j := fun j => | |
| (historyRun).restriction standard.1.1 j.property.2.1 j.property.2.2 c.conditionOrder_code | |
| let inclusions : ∀ j : Cuts, lower j ↪o SetMembers Q := fun j => | |
| (historyRun).inclusion standard.1.1 j.property.2.1 j.property.2.2 pairing unions powers separation infinite choice | |
| hK hPacked hLifted j.property.1 carrier (c.encode ⊤) topMem topRows mono c.conditionOrder_code | |
| let projections : ∀ j, CompleteProjection (restrictions j) (inclusions j) := fun j => | |
| M.semanticStructuralTrace_completeProjection c act b s a ⊥ directed lifted squared (c.encode ⊤) pairing unions powers separation collection carrier forcingOrderGround forcingActionGround geometry.actors_ground geometry.carrier_ground nodeOrderGround nodeActionGround nodeMapsGround supportGround hLifted hSquared omega valid1 valid2 closed1 closed2 children1 children2 topMem topRows hK hHistory standard.1.1 trace j.val j.property.1 | |
| j.property.2.1 j.property.2.2 infinite choice | |
| let upperPres := SetMembers.presentation Q | |
| let F := a.principalSupportFamily ⊥ directed | |
| let := M.refinementHistoryOrderTop c.conditionOrder_code lifted K packed | |
| historyRun.carriers standard.1.1 carrier (c.encode ⊤) topMem topRows | |
| let validUpper := M.refinementHistoryRowNameFamily_valid c historyRun.carriers | |
| standard.1.1 carrier lifted valid1 | |
| have conditions := standard.to_conditions pairing unions powers separation hK | |
| have nodeSize : GroundBelow M s.carrier K := | |
| (run.finalGeometry_below i₀ choice hK standard indices).1 | |
| have hPositions := M.nonbottom_carrier_mem s separation geometry.carrier_ground | |
| have positionSize : GroundBelow M s.nonbottom.carrier K := | |
| nodeSize.restrict separation hPositions hK (fun z member => (s.mem_nonbottom_carrier z).1 member |>.1) | |
| have columnSize := conditions.groundOmegaOne_below pairing unions powers separation collection infinite hK | |
| have rowSize : GroundBelow M c.carrier K := | |
| GroundBelow.binaryRowCarrier pairing unions powers separation hPositions hColumns hK | |
| conditions positionSize columnSize | |
| have liftedSize : GroundBelow M lifted K := M.pairEmpty_renamedFamily_below c | |
| pairing unions powers separation collection carrier ground hK valid below | |
| obtain ⟨_carrierEq, chosen⟩ := final | |
| intro p | |
| obtain ⟨H, hp, coded, ordinary, symmetricGeneric, projectedGeneric, includes, zf, reflection⟩ := chosen p | |
| refine ⟨H, hp, coded, ordinary, symmetricGeneric, projectedGeneric, includes, zf, reflection, ?_⟩ | |
| intro tau symmetric validity | |
| apply fulfilled.structural_refinement_quotient_injection collection infinite choice labels small smallD | |
| irreflexive columns hColumns hmu cardinal.1 valid hLifted hSquared valid1 valid2 closed1 closed2 | |
| children1 children2 K history hK hHistory standard.1.1 trace standard rowSize liftedSize H ordinary | |
| _ tau symmetric validity | |
| intro beta member | |
| exact projectedGeneric ⟨beta, M.transitive hK member, | |
| ordinalSetProperty_member standard.1.1 member, (And.left standard.1.1) beta member⟩ | |
| include fulfilled | |
| theorem exists_partitionPrinciple_not_choice | |
| (collection : CollectionSchema M.sets) (infinite : Realize M.sets infinity Fin.elim0) | |
| (choice : Realize M.sets SetFormula.choice Fin.elim0) | |
| (small : M.sets.Countable) | |
| (hK : K ∈ M.sets) (standard : GroundStandardInaccessible M K) | |
| (indices : GroundBelow M run.indices K) | |
| (labels : Labels = M.groundOmegaOne pairing unions powers separation collection infinite) | |
| (smallD : M.groundEmbeddable D ZFSet.omega) | |
| (irreflexive : ∀ q ∈ D, ZFSet.pair q q ∉ rD) : | |
| ∃ N : TransitiveGround.{u}, M.sets ⊆ N.sets ∧ ZFRealization N.sets ∧ | |
| (∀ X ∈ N.sets, ∀ Y ∈ N.sets, ∀ f ∈ N.sets, ZFSet.IsFunc X Y f → | |
| (∀ y ∈ Y, ∃ x ∈ X, ZFSet.pair x y ∈ f) → N.groundEmbeddable Y X) ∧ | |
| ¬ Realize N.sets SetFormula.choice Fin.elim0 := by | |
| let geometry := run.finalGeometry i₀ | |
| let := geometry.group_code.toGroup | |
| let := geometry.meet.order.toPartialOrder | |
| let := geometry.decodedBottom | |
| let s := SetMembers.presentation geometry.carrier | |
| let b := SetMembers.presentation geometry.actors | |
| let a := geometry.decodedAction | |
| let columns := M.groundOmegaOne pairing unions powers separation collection infinite | |
| have hColumns := (M.groundOmegaOne_spec pairing unions powers separation collection infinite).1 | |
| let := M.smallFunctionOrder (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega | |
| let := M.smallFunctionTop (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega | |
| ⟨s.carrier, geometry.carrier_ground⟩ | |
| have nodeActionGround : a.actionGraph s b ∈ M.sets := geometry.decoded_action_eq.symm ▸ geometry.action_ground | |
| have nodeOrderGround : s.conditionOrder ∈ M.sets := geometry.decoded_order_eq.symm ▸ geometry.order_ground | |
| let act := M.internalRowAction a s b columns pairing unions powers separation infinite | |
| geometry.carrier_ground hColumns geometry.actors_ground nodeActionGround | |
| let c := SetMembers.presentation (M.smallPartialFunctions | |
| (ZFSet.prod s.nonbottom.carrier columns) (natSetCode 2) ZFSet.omega) | |
| have directed := geometry.decoded_directed fulfilled.directed | |
| have coordinates := M.prod_mem pairing unions powers separation | |
| (M.nonbottom_carrier_mem s separation geometry.carrier_ground) hColumns | |
| have forcingAction := M.internalRowActionGraph_mem a s b columns pairing unions powers separation infinite | |
| geometry.carrier_ground hColumns geometry.actors_ground nodeActionGround | |
| have supports := M.principalSupportBasis_mem a s b pairing unions powers separation | |
| geometry.carrier_ground geometry.actors_ground nodeOrderGround nodeActionGround | |
| have nodeMaps := M.conditionMapFamily_mem_of_actionGraph a s b pairing unions powers separation | |
| collection geometry.carrier_ground geometry.actors_ground nodeActionGround | |
| have original := fulfilled.exists_rowSemanticQuotientInjectionModel | |
| collection infinite choice small hK standard indices labels smallD irreflexive | |
| obtain ⟨mu, hmu, _hmuK, cardinal, _omegaIncluded, positions, _ground, _below, valid, data⟩ := original | |
| let S := M.rowPositionSequences s.carrier s.conditionOrder s.nonbottom.carrier mu | |
| let rows := M.binaryRowNameGraph s.nonbottom.carrier columns ⊤ | |
| let T := rowTupleTerms (c.encode ⊤) mu s.nonbottom.carrier (⋃₀ ⋃₀ rows) rows S | |
| let lifted := Name.renamedFamily c.pairEmpty id T valid | |
| let squared := orderedPairNameFamily (c.pairEmpty.encode ⊤) lifted lifted | |
| obtain ⟨hLifted, hSquared, valid1, valid2, closed1, closed2, children1, children2, | |
| history, hHistory, trace, chosen⟩ := data | |
| have topMem := c.encode_mem ⊤ | |
| have topRows : ∀ row ∈ c.carrier, ZFSet.pair row (c.encode ⊤) ∈ c.conditionOrder := by | |
| intro row member | |
| obtain ⟨p, rfl⟩ := (c.mem_carrier row).1 member | |
| exact (c.pair_mem_conditionOrder p ⊤).2 le_top | |
| have two := M.natSetCode_mem separation infinite 2 | |
| have carrier := M.countablePartialFunctions_mem pairing unions powers separation infinite coordinates two | |
| have forcingOrder := M.countableFunctionOrder_mem pairing unions powers separation infinite coordinates two | |
| have omega := M.omega_mem separation infinite | |
| let packed := M.structuralRefinementHistory b.carrier s.carrier s.conditionOrder | |
| (supportBasisCode s b a.principalFix) lifted squared K history | |
| let Q := M.refinementHistoryForcing c.carrier lifted K packed | |
| let historyRun := M.structuralForcingTrace_recursiveOrder c.carrier c.conditionOrder (c.encode ⊤) | |
| (act.actionGraph c b) b.carrier s.carrier s.conditionOrder (a.actionGraph s b) | |
| (supportBasisCode s b a.principalFix) lifted squared standard.1.1 trace | |
| let := M.refinementHistoryPartialOrder c.conditionOrder_code lifted K packed | |
| let := M.refinementHistoryOrderTop c.conditionOrder_code lifted K packed | |
| historyRun.carriers standard.1.1 carrier (c.encode ⊤) topMem topRows | |
| let upperAction := M.semanticStructuralAction c act b s a ⊥ directed lifted squared (c.encode ⊤) | |
| pairing unions powers separation collection carrier forcingOrder forcingAction geometry.actors_ground | |
| geometry.carrier_ground nodeOrderGround nodeActionGround nodeMaps supports hLifted hSquared omega | |
| valid1 valid2 closed1 closed2 children1 children2 topMem topRows hK hHistory standard.1.1 trace | |
| let upper := SetMembers.presentation Q | |
| let F := a.principalSupportFamily ⊥ directed | |
| let validUpper := M.refinementHistoryRowNameFamily_valid c historyRun.carriers | |
| standard.1.1 carrier lifted valid1 | |
| let rowName := Name.familySet (⊤ : SetMembers Q) lifted validUpper | |
| obtain ⟨H, _atTop, _coded, ordinary, _symmetricGeneric, _projectedGeneric, | |
| includes, zf, _reflection, named⟩ := chosen (⊤ : SetMembers Q) | |
| let N := M.symmetricExtension upper upperAction F H | |
| have quotientInjection := M.symmetricExtension_quotient_injections upper upperAction F H rowName named | |
| have uncountable : ¬ M.groundEmbeddable columns ZFSet.omega := | |
| (M.groundOmegaOne_spec pairing unions powers separation collection infinite).2.2.2 | |
| have covers := M.semanticBinaryRow_ordinal_partial_cover a s b columns | |
| pairing unions powers separation collection infinite choice geometry.carrier_ground | |
| nodeOrderGround hColumns geometry.actors_ground nodeActionGround nodeMaps supports directed | |
| uncountable mu hmu cardinal.1 positions lifted squared hLifted hSquared valid1 valid2 | |
| closed1 closed2 children1 children2 K history hK hHistory standard.1.1 trace | |
| obtain ⟨validRows, directValid, covers⟩ := covers | |
| let directRowName : Name upper := Name.familySet (⊤ : SetMembers Q) | |
| (Name.renamedFamily upper | |
| (M.refinementHistoryRowInclusion c historyRun.carriers standard.1.1 carrier) T validRows) directValid | |
| have actualCover : | |
| let Trow := Name.eval {p | H.mem p} directRowName | |
| Trow ∈ N.sets ∧ | |
| ∀ X ∈ N.sets, ∃ delta ∈ N.sets, ordinalSetProperty delta ∧ | |
| ∃ h ∈ N.sets, FunctionGraphOn delta h ∧ | |
| (∀ i hi, ZFSet.pair i hi ∈ h → PartialFunctionCode Trow (⋃₀ ⋃₀ hi) hi) ∧ | |
| ∀ x ∈ X, ∃ i ∈ delta, ∃ hi, ZFSet.pair i hi ∈ h ∧ | |
| ∃ u ∈ Trow, ZFSet.pair u x ∈ hi := covers H ordinary | |
| have sameRows : directRowName = rowName := | |
| M.refinementHistory_originalRowFamilySet_eq c historyRun.carriers | |
| standard.1.1 carrier (⊤ : SetMembers Q) T validRows directValid validUpper | |
| rw [sameRows] at actualCover | |
| have acwo := fulfilled.structural_ordinal_choice collection infinite choice labels small smallD | |
| irreflexive columns hColumns hmu cardinal.1 valid hLifted hSquared valid1 valid2 closed1 | |
| closed2 children1 children2 K history hK hHistory standard.1.1 trace H ordinary zf | |
| have notChoice := fulfilled.structural_lifted_rows_not_wellorderable_not_choice | |
| collection infinite choice small smallD irreflexive columns hColumns uncountable hmu | |
| cardinal.1 valid hLifted hSquared valid1 valid2 closed1 closed2 children1 children2 | |
| K history hK hHistory standard.1.1 trace H ordinary zf | |
| exact ⟨N, includes, zf, | |
| N.partitionPrinciple_of_rowCover_quotients zf actualCover.1 acwo actualCover.2 quotientInjection, | |
| notChoice.2.2⟩ | |
| end PartitionPilot.Forcing.GroundMainPrefix.FinalSupportFulfillment | |
| end OAI | |