openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Forcing /GroundCompleteProjectionAtomicTruth.lean
| import OAI.SetTheory.PartitionPrinciple.Forcing.GroundGraphValueDescendantWitnesses | |
| namespace OAI | |
| section | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) {P Q : Type u} | |
| theorem rename_between_mem (s : Presentation P) (t : Presentation Q) | |
| (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) | |
| (hs : s.carrier ∈ M.sets) (ht : t.carrier ∈ M.sets) | |
| (f : P → Q) (hf : s.graph t f ∈ M.sets) | |
| (τ : Name s) (hτ : τ.val ∈ M.sets) : (Name.rename t f τ).val ∈ M.sets := by | |
| let U := s.carrier ∪ t.carrier | |
| let D := ZFSet.sep (fun x => x ∉ s.carrier) U | |
| let F := s.graph t f | |
| let G := F ∪ identityFunctionGraph D | |
| have subS : s.carrier ⊆ U := fun _ hx => ZFSet.mem_union.2 (Or.inl hx) | |
| have subT : t.carrier ⊆ U := fun _ hx => ZFSet.mem_union.2 (Or.inr hx) | |
| have hU : U ∈ M.sets := M.binary_union_mem pairing unions hs ht | |
| have hD : D ∈ M.sets := M.bounded_separation_mem separation (.neg (.mem 0 1)) | |
| (extend s.carrier Fin.elim0) (Fin.cases hs (fun i => Fin.elim0 i)) hU | |
| have hG : G ∈ M.sets := M.binary_union_mem pairing unions hf | |
| (M.identityFunctionGraph_mem pairing unions powers separation hD) | |
| have ff := s.graph_isFunc t f | |
| have full : ZFSet.IsFunc U U G := by | |
| constructor | |
| · intro z hz | |
| rcases ZFSet.mem_union.1 hz with old | identity | |
| · obtain ⟨x, hx, y, hy, eq⟩ := ZFSet.mem_prod.1 (ff.1 old) | |
| exact ZFSet.mem_prod.2 ⟨x, subS hx, y, subT hy, eq⟩ | |
| · obtain ⟨x, hx, rfl⟩ := (mem_identityFunctionGraph D z).1 identity | |
| exact ZFSet.pair_mem_prod.2 ⟨(ZFSet.mem_sep.1 hx).1, (ZFSet.mem_sep.1 hx).1⟩ | |
| · intro x hx | |
| by_cases source : x ∈ s.carrier | |
| · obtain ⟨y, entry, unique⟩ := ff.2 x source | |
| refine ⟨y, ZFSet.mem_union.2 (Or.inl entry), ?_⟩ | |
| intro z hz | |
| rcases ZFSet.mem_union.1 hz with old | identity | |
| · exact unique z old | |
| · exact False.elim ((ZFSet.mem_sep.1 | |
| ((pair_mem_identityFunctionGraph D x z).1 identity).2).2 source) | |
| · refine ⟨x, ZFSet.mem_union.2 (Or.inr | |
| ((pair_mem_identityFunctionGraph D x x).2 ⟨rfl, ZFSet.mem_sep.2 ⟨hx, source⟩⟩)), ?_⟩ | |
| intro z hz | |
| rcases ZFSet.mem_union.1 hz with old | identity | |
| · exact False.elim (source (ZFSet.pair_mem_prod.1 (ff.1 old)).1) | |
| · exact ((pair_mem_identityFunctionGraph D x z).1 identity).1.symm | |
| let u := SetMembers.presentation U | |
| let es := s.intoSet U subS | |
| let et := t.intoSet U subT | |
| let h := u.decodeFunction u G full | |
| have commute (p : P) : h (es p) = et (f p) := by | |
| apply (u.decodeFunction_iff u G full (es p) (et (f p))).2 | |
| rw [s.encode_intoSet U subS, t.encode_intoSet U subT] | |
| exact ZFSet.mem_union.2 (Or.inl ((s.pair_mem_graph t f p (f p)).2 rfl)) | |
| have sourceCode := Name.rename_val_of_encode u es (s.encode_intoSet U subS) τ | |
| have ground := M.rename_mem u pairing unions powers separation collection hU h | |
| ((u.graph_decodeFunction u G full).symm ▸ hG) | |
| (Name.rename u es τ) (sourceCode ▸ hτ) | |
| have equation : Name.rename u h (Name.rename u es τ) = | |
| Name.rename u et (Name.rename t f τ) := by | |
| rw [Name.rename_comp, Name.rename_comp] | |
| apply congrArg (fun k => Name.rename u k τ) | |
| funext p | |
| exact commute p | |
| rw [equation, Name.rename_val_of_encode u et (t.encode_intoSet U subT)] at ground | |
| exact ground | |
| end PartitionPilot.Forcing.TransitiveGround | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) {Lower Upper : Type u} | |
| variable [PartialOrder Lower] [PartialOrder Upper] | |
| variable (lower : Presentation Lower) (upper : Presentation Upper) | |
| variable {restriction : Upper →o Lower} {inclusion : Lower ↪o Upper} | |
| 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) | |
| variable (separation : SeparationSchema M.sets) (collection : CollectionSchema M.sets) | |
| variable (lowerGround : lower.carrier ∈ M.sets) (upperGround : upper.carrier ∈ M.sets) | |
| variable (inclusionGround : lower.graph upper inclusion ∈ M.sets) | |
| variable (H : ConditionFilter Upper) | |
| variable (ordinary : H.GenericFor (formulaFamily (M.nameDomain upper))) | |
| include pairing unions powers separation collection lowerGround upperGround inclusionGround ordinary | |
| theorem completeProjection_eval_eq_iff_forcesEq (sigma tau : Name lower) | |
| (sigmaGround : sigma.val ∈ M.sets) (tauGround : tau.val ∈ M.sets) : | |
| Name.eval {q | (projection.projectedFilter H).mem q} sigma = | |
| Name.eval {q | (projection.projectedFilter H).mem q} tau ↔ | |
| ∃ q, (projection.projectedFilter H).mem q ∧ Name.ForcesEq q sigma tau := by | |
| have liftedSigma := M.rename_between_mem lower upper pairing unions powers separation collection | |
| lowerGround upperGround inclusion inclusionGround sigma sigmaGround | |
| have liftedTau := M.rename_between_mem lower upper pairing unions powers separation collection | |
| lowerGround upperGround inclusion inclusionGround tau tauGround | |
| have truth := Name.eval_eq_iff_forcesEq (M.nameDomain upper) H | |
| (fun E member => ordinary E (Or.inl member)) liftedSigma liftedTau | |
| simp only [Name.eval_rename] at truth | |
| constructor | |
| · intro equal | |
| obtain ⟨p, member, forced⟩ := truth.1 equal | |
| exact ⟨restriction p, (projection.projectedFilter_mem_iff H _).2 ⟨p, member, rfl⟩, | |
| (Name.forcesEq_rename_completeProjection lower upper restriction inclusion projection p sigma tau).1 forced⟩ | |
| · rintro ⟨q, member, forced⟩ | |
| apply truth.2 | |
| refine ⟨inclusion q, member, ?_⟩ | |
| apply (Name.forcesEq_rename_completeProjection lower upper restriction inclusion projection | |
| (inclusion q) sigma tau).2 | |
| simpa only [projection.retract] using forced | |
| theorem completeProjection_eval_mem_iff_forcesMem (sigma tau : Name lower) | |
| (sigmaGround : sigma.val ∈ M.sets) (tauGround : tau.val ∈ M.sets) : | |
| Name.eval {q | (projection.projectedFilter H).mem q} sigma ∈ | |
| Name.eval {q | (projection.projectedFilter H).mem q} tau ↔ | |
| ∃ q, (projection.projectedFilter H).mem q ∧ Name.ForcesMem q sigma tau := by | |
| have liftedSigma := M.rename_between_mem lower upper pairing unions powers separation collection | |
| lowerGround upperGround inclusion inclusionGround sigma sigmaGround | |
| have liftedTau := M.rename_between_mem lower upper pairing unions powers separation collection | |
| lowerGround upperGround inclusion inclusionGround tau tauGround | |
| have truth := Name.eval_mem_iff_forcesMem (M.nameDomain upper) H | |
| (fun E member => ordinary E (Or.inl member)) liftedSigma liftedTau | |
| simp only [Name.eval_rename] at truth | |
| constructor | |
| · intro member | |
| obtain ⟨p, hp, forced⟩ := truth.1 member | |
| exact ⟨restriction p, (projection.projectedFilter_mem_iff H _).2 ⟨p, hp, rfl⟩, | |
| (Name.forcesMem_rename_completeProjection lower upper restriction inclusion projection p sigma tau).1 forced⟩ | |
| · rintro ⟨q, member, forced⟩ | |
| apply truth.2 | |
| refine ⟨inclusion q, member, ?_⟩ | |
| apply (Name.forcesMem_rename_completeProjection lower upper restriction inclusion projection | |
| (inclusion q) sigma tau).2 | |
| simpa only [projection.retract] using forced | |
| theorem completeProjection_forcesNotEq_sound (sigma tau : Name lower) | |
| (sigmaGround : sigma.val ∈ M.sets) (tauGround : tau.val ∈ M.sets) | |
| {q : Lower} (member : (projection.projectedFilter H).mem q) | |
| (negative : ∀ r, r ≤ q → ¬ Name.ForcesEq r sigma tau) : | |
| Name.eval {r | (projection.projectedFilter H).mem r} sigma ≠ | |
| Name.eval {r | (projection.projectedFilter H).mem r} tau := by | |
| intro equal | |
| obtain ⟨r, hr, forced⟩ := (M.completeProjection_eval_eq_iff_forcesEq lower upper projection | |
| pairing unions powers separation collection lowerGround upperGround inclusionGround H ordinary | |
| sigma tau sigmaGround tauGround).1 equal | |
| obtain ⟨p, _hp, pq, pr⟩ := (projection.projectedFilter H).directed member hr | |
| exact negative p pq (Name.forcesEq_mono forced pr) | |
| theorem completeProjection_forcesNotMem_sound (sigma tau : Name lower) | |
| (sigmaGround : sigma.val ∈ M.sets) (tauGround : tau.val ∈ M.sets) | |
| {q : Lower} (member : (projection.projectedFilter H).mem q) | |
| (negative : Name.ForcesNotMem q sigma tau) : | |
| Name.eval {r | (projection.projectedFilter H).mem r} sigma ∉ | |
| Name.eval {r | (projection.projectedFilter H).mem r} tau := by | |
| intro belongs | |
| obtain ⟨r, hr, forced⟩ := (M.completeProjection_eval_mem_iff_forcesMem lower upper projection | |
| pairing unions powers separation collection lowerGround upperGround inclusionGround H ordinary | |
| sigma tau sigmaGround tauGround).1 belongs | |
| obtain ⟨p, _hp, pq, pr⟩ := (projection.projectedFilter H).directed member hr | |
| exact negative p pq (Name.forcesMem_mono forced pr) | |
| end PartitionPilot.Forcing.TransitiveGround | |
| end | |
| end OAI | |