openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Geometry /GroundAssignmentLabelDomainTotality.lean
| import OAI.SetTheory.PartitionPrinciple.Forcing.GroundRepresentedDomainConditions | |
| namespace OAI | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) {P Q : Type u} | |
| variable [PartialOrder P] [OrderTop P] [PartialOrder Q] [OrderTop Q] | |
| variable (lower : Presentation P) (upper : Presentation Q) | |
| variable {restriction : Q →o P} {inclusion : P ↪o Q} | |
| variable (projection : CompleteProjection restriction inclusion) | |
| 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 (lowerGround : lower.carrier ∈ M.sets) (upperGround : upper.carrier ∈ M.sets) | |
| variable (lowerOrder : lower.conditionOrder ∈ M.sets) | |
| variable (inclusionGround : lower.graph upper inclusion ∈ M.sets) | |
| variable {levels alpha T : ZFSet.{u}} | |
| variable (hLevels : levels ∈ M.sets) (hAlpha : alpha ∈ M.sets) (hT : T ∈ M.sets) | |
| variable (valid : ∀ z ∈ T, IsName lower z) (idx : ZFSet.{u}) (hIdx : idx ∈ M.sets) | |
| variable (U Rc : (M.nameDomain lower).names) (Rf : Name lower) | |
| variable (cutCoordinates : ∀ p : Q, ∃ row A : ZFSet.{u}, upper.encode p = ZFSet.pair row A ∧ | |
| lower.encode (restriction p) = ZFSet.pair row (assignmentCut levels alpha A)) | |
| variable (H : ConditionFilter Q) (ordinary : H.GenericFor (formulaFamily (M.nameDomain upper))) | |
| include pairing unions powers separation collection lowerGround upperGround lowerOrder inclusionGround | |
| hLevels hAlpha hT hIdx cutCoordinates ordinary | |
| local notation "lowerH" => projection.projectedFilter H | |
| local notation "label" => Name.refinementAssignmentLabel upper inclusion ⊤ T valid idx Rf Rc.val | |
| local notation "domainSet" => (M.representedDomainConditions lower upper.carrier levels alpha T valid idx U Rc) | |
| theorem refinementAssignmentLabel_represents_active_term | |
| (u : (M.nameDomain lower).names) (_hu : u.val.val ∈ T) | |
| (ground : domainSet u ∈ M.sets) | |
| (dense : Dense {p : Q | upper.encode p ∈ domainSet u}) | |
| (active : ∃ q : P, (lowerH).mem q ∧ Name.ForcesMem q u.val U.val) : | |
| ∃ a : ZFSet.{u}, ZFSet.pair | |
| (Name.eval {q | (lowerH).mem q} (Name.refinementClass T valid Rc.val u.val)) a ∈ | |
| Name.eval {p | H.mem p} label := by | |
| obtain ⟨p, hp, inD⟩ := M.ordinary_generic_meets_ground_dense upper pairing unions powers separation | |
| H ordinary ground (M.representedDomainConditions_subset lower _ _ _ _ valid idx U Rc u) dense | |
| obtain ⟨row, A, pCode, cutCode⟩ := cutCoordinates p | |
| have cutMember : (lowerH).mem (restriction p) := | |
| (projection.projectedFilter_mem_iff H _).2 ⟨p, hp, rfl⟩ | |
| have branches := (M.pair_mem_representedDomainConditions lower pairing unions powers separation collection | |
| lowerGround lowerOrder upperGround hLevels hAlpha hT valid hIdx U Rc u row A | |
| (restriction p) cutCode).1 (pCode ▸ inD) | |
| rcases branches.2 with inactive | ⟨_active, v, w, hv, hw, literal, forcedEqual⟩ | |
| · obtain ⟨q, hq, activeQ⟩ := active | |
| obtain ⟨r, _hr, rp, rq⟩ := (lowerH).directed cutMember hq | |
| exact False.elim (inactive r rp (Name.forcesMem_mono activeQ rq)) | |
| · have classU := M.refinementClass_mem lower pairing unions powers separation collection | |
| lowerGround lowerOrder hT valid Rc.val u.val Rc.property u.property | |
| have classV := M.refinementClass_mem lower pairing unions powers separation collection | |
| lowerGround lowerOrder hT valid Rc.val v Rc.property (M.transitive hT hv) | |
| have equal := (M.completeProjection_eval_eq_iff_forcesEq lower upper projection | |
| pairing unions powers separation collection lowerGround upperGround inclusionGround H ordinary | |
| (Name.refinementClass T valid Rc.val u.val) (Name.refinementClass T valid Rc.val v) | |
| classU classV).2 ⟨restriction p, cutMember, forcedEqual⟩ | |
| let a := Name.eval {q | (lowerH).mem q} (Name.refinementClass T valid Rf w) | |
| refine ⟨a, (Name.mem_eval_refinementAssignmentLabel upper inclusion ⊤ T valid idx Rf Rc.val | |
| {p | H.mem p} H.top_mem _).2 ?_⟩ | |
| exact ⟨p, v, w, hp, hv, hw, ⟨row, A, pCode, literal⟩, | |
| congrArg (fun x => ZFSet.pair x a) equal.symm⟩ | |
| theorem refinementAssignmentLabel_domain_total | |
| (density : ∀ u : (M.nameDomain lower).names, u.val.val ∈ T → | |
| domainSet u ∈ M.sets ∧ Dense {p : Q | upper.encode p ∈ domainSet u}) : | |
| ∀ b ∈ Name.eval {q | (lowerH).mem q} (Name.refinementQuotient T valid U.val Rc.val), | |
| ∃ a : ZFSet.{u}, ZFSet.pair b a ∈ Name.eval {p | H.mem p} label := by | |
| intro b member | |
| obtain ⟨sigma, q, entry, hq, equal⟩ := (Name.mem_eval {q | (lowerH).mem q} | |
| (Name.refinementQuotient T valid U.val Rc.val) b).1 member | |
| obtain ⟨u, hu, active, rfl⟩ := (Name.entry_refinementQuotient T valid U.val Rc.val sigma q).1 entry | |
| let term : (M.nameDomain lower).names := ⟨u, M.transitive hT hu⟩ | |
| have result := M.refinementAssignmentLabel_represents_active_term lower upper projection | |
| pairing unions powers separation collection lowerGround upperGround lowerOrder inclusionGround | |
| hLevels hAlpha hT valid idx hIdx U Rc Rf cutCoordinates H ordinary term hu | |
| (density term hu).1 (density term hu).2 ⟨q, hq, active⟩ | |
| exact equal ▸ result | |
| end PartitionPilot.Forcing.TransitiveGround | |
| end OAI | |