openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Definability /BoundedAtomicEquality.lean
| import OAI.SetTheory.PartitionPrinciple.Forcing.GroundFixedPoints | |
| import OAI.SetTheory.PartitionPrinciple.Geometry.RawEqualitySteps | |
| namespace OAI | |
| section | |
| namespace PartitionPilot.Forcing.SetFormula | |
| def orderedTripleFormula {n : Nat} (z p x y : Fin n) : SetFormula n := | |
| ex (.conj (orderedPairFormula 0 x.succ y.succ) | |
| (orderedPairFormula z.succ p.succ 0)) | |
| def codedRelationFormula : SetFormula 6 := tripleMembershipFormula 0 1 2 3 | |
| def equalityStateFormula : SetFormula 4 := | |
| exConditions 2 <| ex <| ex <| | |
| .conj (orderedTripleFormula 3 2 1 0) | |
| (equalityStepFormula codedRelationFormula 1 2 (fun j => j.succ.succ.succ.succ) 2 1 0) | |
| end PartitionPilot.Forcing.SetFormula | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) | |
| theorem realize_orderedTripleFormula | |
| (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| {n : Nat} (z p x y : Fin n) (env : Fin n → ZFSet.{u}) | |
| (hz : env z ∈ M.sets) (hp : env p ∈ M.sets) | |
| (hx : env x ∈ M.sets) (hy : env y ∈ M.sets) : | |
| Realize M.sets (orderedTripleFormula z p x y) env ↔ | |
| env z = ZFSet.pair (env p) (ZFSet.pair (env x) (env y)) := by | |
| rw [orderedTripleFormula, realize_ex] | |
| constructor | |
| · rintro ⟨w, hw, inner, outer⟩ | |
| have wi := (M.realize_orderedPairFormula pairing 0 x.succ y.succ | |
| (extend w env) hw hx hy).1 inner | |
| have zo := (M.realize_orderedPairFormula pairing z.succ p.succ 0 | |
| (extend w env) hz hp hw).1 outer | |
| change w = ZFSet.pair (env x) (env y) at wi | |
| change env z = ZFSet.pair (env p) w at zo | |
| exact wi ▸ zo | |
| · intro eq | |
| have hw := M.orderedPair_mem pairing hx hy | |
| exact ⟨ZFSet.pair (env x) (env y), hw, | |
| (M.realize_orderedPairFormula pairing 0 x.succ y.succ | |
| (extend (ZFSet.pair (env x) (env y)) env) hw hx hy).2 rfl, | |
| (M.realize_orderedPairFormula pairing z.succ p.succ 0 | |
| (extend (ZFSet.pair (env x) (env y)) env) hz hp hw).2 eq⟩ | |
| variable {P : Type u} [Preorder P] (s : Presentation P) | |
| noncomputable def equalityParameters : Fin 2 → ZFSet.{u} := | |
| extend s.carrier (extend s.conditionOrder Fin.elim0) | |
| def RawCodedRelation (S : ZFSet.{u}) (p : P) (x y : ZFSet.{u}) : Prop := | |
| ZFSet.pair (s.encode p) (ZFSet.pair x y) ∈ S | |
| theorem rawRelationMeaning_coded | |
| (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| (carrier : s.carrier ∈ M.sets) (S : ZFSet.{u}) (hS : S ∈ M.sets) : | |
| M.RawRelationMeaning s (RawCodedRelation s S) codedRelationFormula | |
| (extend S (equalityParameters s)) := by | |
| intro p x hx y hy | |
| exact M.realize_tripleMembershipFormula pairing 0 1 2 3 _ | |
| (M.transitive carrier (s.encode_mem p)) hx hy hS | |
| theorem realize_equalityState | |
| (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| (carrier : s.carrier ∈ M.sets) (order : s.conditionOrder ∈ M.sets) | |
| (z S : ZFSet.{u}) (hz : z ∈ M.sets) (hS : S ∈ M.sets) : | |
| Realize M.sets equalityStateFormula (extend z (extend S (equalityParameters s))) ↔ | |
| ∃ p x, x ∈ M.sets ∧ ∃ y, y ∈ M.sets ∧ | |
| z = ZFSet.pair (s.encode p) (ZFSet.pair x y) ∧ | |
| M.RawEqualityStep s (RawCodedRelation s S) p x y := by | |
| let env := extend z (extend S (equalityParameters s)) | |
| rw [equalityStateFormula, M.realize_exConditions s 2 _ env carrier rfl] | |
| apply exists_congr | |
| intro p | |
| rw [realize_ex] | |
| apply exists_congr | |
| intro x | |
| apply and_congr_right | |
| intro hx | |
| rw [realize_ex] | |
| apply exists_congr | |
| intro y | |
| apply and_congr_right | |
| intro hy | |
| let e := extend y (extend x (extend (s.encode p) env)) | |
| change (Realize M.sets _ e ∧ Realize M.sets _ e) ↔ _ | |
| rw [M.realize_orderedTripleFormula pairing 3 2 1 0 e hz | |
| (M.transitive carrier (s.encode_mem p)) hx hy, | |
| M.realize_rawEqualityStep s (RawCodedRelation s S) pairing carrier order | |
| codedRelationFormula 1 2 (fun j => j.succ.succ.succ.succ) 2 1 0 e rfl rfl | |
| (M.rawRelationMeaning_coded s pairing carrier S hS) p rfl hx hy] | |
| rfl | |
| theorem equalityState_mono | |
| (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| (carrier : s.carrier ∈ M.sets) (order : s.conditionOrder ∈ M.sets) | |
| {z S T : ZFSet.{u}} (hz : z ∈ M.sets) (hS : S ∈ M.sets) (hT : T ∈ M.sets) | |
| (sub : S ⊆ T) : | |
| Realize M.sets equalityStateFormula (extend z (extend S (equalityParameters s))) → | |
| Realize M.sets equalityStateFormula (extend z (extend T (equalityParameters s))) := by | |
| rw [M.realize_equalityState s pairing carrier order z S hz hS, | |
| M.realize_equalityState s pairing carrier order z T hz hT] | |
| rintro ⟨p, x, hx, y, hy, shape, step⟩ | |
| exact ⟨p, x, hx, y, hy, shape, M.rawEqualityStep_mono s (fun _ _ _ h => sub h) step⟩ | |
| end PartitionPilot.Forcing.TransitiveGround | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) {P : Type u} [Preorder P] (s : Presentation P) | |
| theorem rawEqualityStep_names (D : Name.NameDomain s) | |
| (ground : ∀ τ ∈ D.names, τ.val ∈ M.sets) | |
| (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| (carrier : s.carrier ∈ M.sets) (order : s.conditionOrder ∈ M.sets) | |
| (S : ZFSet.{u}) (hS : S ∈ M.sets) (p : P) (σ τ : D.names) : | |
| M.RawEqualityStep s (RawCodedRelation s S) p σ.val.val τ.val.val ↔ | |
| Name.EqualityStep (Name.codedEqualityRelation s S) p σ.val τ.val := by | |
| let constants := extend S (equalityParameters s) | |
| let env := extend (s.encode p) (extend σ.val.val (extend τ.val.val constants)) | |
| have raw := M.realize_rawEqualityStep s (RawCodedRelation s S) pairing carrier order | |
| codedRelationFormula 1 2 (fun j => j.succ.succ.succ) 0 1 2 env rfl rfl | |
| (M.rawRelationMeaning_coded s pairing carrier S hS) p rfl | |
| (ground σ.val σ.property) (ground τ.val τ.property) | |
| have named := M.realize_equalityStep s D (Name.codedEqualityRelation s S) | |
| ground pairing carrier order codedRelationFormula 1 2 (fun j => j.succ.succ.succ) | |
| 0 1 2 env rfl rfl (M.relationMeaning_coded s D ground pairing carrier 0 constants hS) | |
| p σ τ rfl rfl rfl | |
| exact raw.symm.trans named | |
| theorem realize_equalityState_names (D : Name.NameDomain s) | |
| (ground : ∀ τ ∈ D.names, τ.val ∈ M.sets) | |
| (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| (carrier : s.carrier ∈ M.sets) (order : s.conditionOrder ∈ M.sets) | |
| (S : ZFSet.{u}) (hS : S ∈ M.sets) (p : P) (σ τ : D.names) : | |
| Realize M.sets equalityStateFormula | |
| (extend (ZFSet.pair (s.encode p) (ZFSet.pair σ.val.val τ.val.val)) | |
| (extend S (equalityParameters s))) ↔ | |
| Name.EqualityStep (Name.codedEqualityRelation s S) p σ.val τ.val := by | |
| have hz := M.orderedPair_mem pairing (M.transitive carrier (s.encode_mem p)) | |
| (M.orderedPair_mem pairing (ground σ.val σ.property) (ground τ.val τ.property)) | |
| rw [M.realize_equalityState s pairing carrier order _ S hz hS] | |
| constructor | |
| · rintro ⟨q, x, _, y, _, shape, step⟩ | |
| obtain ⟨pq, xy⟩ := ZFSet.pair_inj.1 shape | |
| have peq := s.injective pq | |
| obtain ⟨sx, ty⟩ := ZFSet.pair_inj.1 xy | |
| subst q | |
| subst x | |
| subst y | |
| exact (M.rawEqualityStep_names s D ground pairing carrier order S hS p σ τ).1 step | |
| · intro step | |
| exact ⟨p, σ.val.val, ground σ.val σ.property, τ.val.val, ground τ.val τ.property, rfl, | |
| (M.rawEqualityStep_names s D ground pairing carrier order S hS p σ τ).2 step⟩ | |
| theorem exists_bounded_atomicEquality (D : Name.NameDomain s) | |
| (ground : ∀ τ ∈ D.names, τ.val ∈ M.sets) | |
| (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) | |
| (carrier : s.carrier ∈ M.sets) (order : s.conditionOrder ∈ M.sets) | |
| (B : ZFSet.{u}) (hB : B ∈ M.sets) | |
| (bound : ∀ p (σ τ : D.names), ZFSet.pair (s.encode p) (ZFSet.pair σ.val.val τ.val.val) ∈ B) : | |
| ∃ S ∈ M.sets, S ⊆ B ∧ ∀ p (σ τ : D.names), | |
| Name.codedEqualityRelation s S p σ.val τ.val ↔ Name.ForcesEq p σ.val τ.val := by | |
| have members : ∀ i, equalityParameters s i ∈ M.sets := | |
| Fin.cases carrier (Fin.cases order (fun i => Fin.elim0 i)) | |
| have mono : ∀ S ∈ M.sets, ∀ T ∈ M.sets, S ⊆ B → T ⊆ B → S ⊆ T → | |
| definableOperator M.sets equalityStateFormula (equalityParameters s) B S ⊆ | |
| definableOperator M.sets equalityStateFormula (equalityParameters s) B T := by | |
| intro S hS T hT _ _ sub z hz | |
| obtain ⟨hzB, step⟩ := ZFSet.mem_sep.1 hz | |
| exact ZFSet.mem_sep.2 ⟨hzB, | |
| M.equalityState_mono s pairing carrier order (M.transitive hB hzB) hS hT sub step⟩ | |
| obtain ⟨S, hS, hSB, fixed, _⟩ := M.exists_greatest_definable_fixedPoint unions powers separation | |
| equalityStateFormula (equalityParameters s) members hB mono | |
| have step : ∀ σ ∈ D.names, ∀ τ ∈ D.names, ∀ p, | |
| Name.codedEqualityRelation s S p σ τ ↔ Name.EqualityStep (Name.codedEqualityRelation s S) p σ τ := by | |
| intro σ hσ τ hτ p | |
| change ZFSet.pair (s.encode p) (ZFSet.pair σ.val τ.val) ∈ S ↔ _ | |
| calc | |
| _ ↔ ZFSet.pair (s.encode p) (ZFSet.pair σ.val τ.val) ∈ | |
| definableOperator M.sets equalityStateFormula (equalityParameters s) B S := by rw [fixed] | |
| _ ↔ _ := by | |
| rw [definableOperator, ZFSet.mem_sep, | |
| M.realize_equalityState_names s D ground pairing carrier order S hS p ⟨σ, hσ⟩ ⟨τ, hτ⟩] | |
| exact and_iff_right (bound p ⟨σ, hσ⟩ ⟨τ, hτ⟩) | |
| exact ⟨S, hS, hSB, fun p σ τ => | |
| Name.fixed_equality_iff D (Name.codedEqualityRelation s S) step σ.property τ.property p⟩ | |
| end PartitionPilot.Forcing.TransitiveGround | |
| end | |
| end OAI | |