openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Geometry /GroundAbsentLiftRangeCollisions.lean
| import OAI.SetTheory.PartitionPrinciple.Forcing.GroundRefinementCollisionSymmetry | |
| import OAI.SetTheory.PartitionPrinciple.Forcing.StageOneEvaluatedAssignments | |
| namespace OAI | |
| section | |
| namespace PartitionPilot.Forcing.SetFormula | |
| def refinementVisibleLiftFormula : SetFormula 4 := | |
| ex (.conj (.mem 0 1) (.conj (.mem 0 2) | |
| (BoundedFormula.pairMembershipFormula 0 3 4).toFormula)) | |
| end PartitionPilot.Forcing.SetFormula | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) {P : Type u} [PartialOrder P] [OrderTop P] | |
| variable (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) | |
| variable {T : ZFSet.{u}} (hT : T ∈ M.sets) (valid : ∀ z ∈ T, IsName s z) | |
| theorem refinementVisibleLift_groundTerm_dense (small : M.sets.Countable) | |
| (U Rf Rc visibility target : (M.nameDomain s).names) (p : P) : | |
| let quotient : (M.nameDomain s).names := ⟨Name.refinementQuotient T valid U.val Rf.val, | |
| M.refinementQuotient_mem s pairing unions powers separation collection carrier order | |
| hT valid U.val Rf.val U.property Rf.property⟩ | |
| let map := M.stageOneMapName s pairing unions powers separation collection carrier order | |
| hT valid U Rf Rc | |
| Forces (M.nameDomain s) refinementVisibleLiftFormula ![quotient, visibility, target, map] p → | |
| DenseBelow p {q | ∃ w : (M.nameDomain s).names, w.val.val ∈ T ∧ | |
| Name.ForcesMem q w.val U.val ∧ | |
| let fine := M.stageOneClassName s pairing unions powers separation collection carrier order | |
| hT valid Rf w | |
| Name.ForcesMem q fine.val visibility.val ∧ | |
| Forces (M.nameDomain s) (BoundedFormula.pairMembershipFormula 0 1 2).toFormula | |
| ![fine, target, map] q} := by | |
| let quotient : (M.nameDomain s).names := ⟨Name.refinementQuotient T valid U.val Rf.val, | |
| M.refinementQuotient_mem s pairing unions powers separation collection carrier order | |
| hT valid U.val Rf.val U.property Rf.property⟩ | |
| let map := M.stageOneMapName s pairing unions powers separation collection carrier order hT valid U Rf Rc | |
| let env : Assignment (M.nameDomain s) 4 := ![quotient, visibility, target, map] | |
| let phi : SetFormula 5 := .conj (.mem 0 2) (BoundedFormula.pairMembershipFormula 0 3 4).toFormula | |
| change Forces (M.nameDomain s) (ex (.conj (.mem 0 1) phi)) env p → _ | |
| intro forced r rp | |
| obtain ⟨q, qr, rho, member, property⟩ := | |
| (forces_ex_iff (M.nameDomain s) (.conj (.mem 0 1) phi) env p).1 forced r rp | |
| change Name.ForcesMem q rho.val quotient.val at member | |
| obtain ⟨v, vq, sigma, k, entry, vk, equal⟩ := member q le_rfl | |
| obtain ⟨w, hw, active, same⟩ := | |
| (Name.entry_refinementQuotient T valid U.val Rf.val sigma k).1 entry | |
| let wName : (M.nameDomain s).names := ⟨w, M.transitive hT hw⟩ | |
| let fine := M.stageOneClassName s pairing unions powers separation collection carrier order hT valid Rf wName | |
| have sameFine : fine.val = sigma := same | |
| have equality : Name.ForcesEq v rho.val fine.val := sameFine.symm ▸ equal | |
| have propertyV : Forces (M.nameDomain s) phi (extend rho env) v := | |
| forces_mono (M.nameDomain s) phi (extend rho env) property vq | |
| have selected : Forces (M.nameDomain s) phi (extend fine env) v := | |
| (M.ordinaryForces_replace_first s small carrier phi env rho fine v equality).1 propertyV | |
| refine ⟨v, vq.trans qr, wName, hw, Name.forcesMem_mono active vk, ?_⟩ | |
| exact selected | |
| end PartitionPilot.Forcing.TransitiveGround | |
| end | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) {P : Type u} [PartialOrder P] [OrderTop P] | |
| variable (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) | |
| variable {T : ZFSet.{u}} (hT : T ∈ M.sets) (valid : ∀ z ∈ T, IsName s z) | |
| theorem refinementActiveTerm_fineLift (small : M.sets.Countable) | |
| (U Rf Rc u : (M.nameDomain s).names) (term : u.val.val ∈ T) (p : P) | |
| (active : Name.ForcesMem p u.val U.val) : | |
| let cls := M.stageOneClassName s pairing unions powers separation collection carrier order hT valid | |
| let quotient : (M.nameDomain s).names := ⟨Name.refinementQuotient T valid U.val Rf.val, | |
| M.refinementQuotient_mem s pairing unions powers separation collection carrier order | |
| hT valid U.val Rf.val U.property Rf.property⟩ | |
| let map := M.stageOneMapName s pairing unions powers separation collection carrier order hT valid U Rf Rc | |
| Name.ForcesMem p (cls Rf u).val quotient.val ∧ | |
| Forces (M.nameDomain s) (BoundedFormula.pairMembershipFormula 0 1 2).toFormula | |
| ![cls Rf u, cls Rc u, map] p := by | |
| dsimp only | |
| let cls := M.stageOneClassName s pairing unions powers separation collection carrier order hT valid | |
| let map := M.stageOneMapName s pairing unions powers separation collection carrier order hT valid U Rf Rc | |
| have fineEntry := (Name.entry_refinementQuotient T valid U.val Rf.val _ p).2 | |
| ⟨u.val, term, active, rfl⟩ | |
| have mapEntry := (Name.entry_refinementNaturalMap T valid U.val Rf.val Rc.val _ p).2 | |
| ⟨u.val, term, active, rfl⟩ | |
| refine ⟨Name.forcesMem_entry fineEntry, ?_⟩ | |
| apply (M.ordinaryForces_iff_all_generics s small carrier _ _ p).2 | |
| intro H hp generic | |
| let evaluated : TransitiveGround.{u} := | |
| ⟨(M.nameDomain s).values {q | H.mem q}, (M.nameDomain s).values_transitive _⟩ | |
| apply (BoundedFormula.realize_toFormula evaluated _ _ (fun j => ⟨_, rfl⟩)).2 | |
| apply (BoundedFormula.truth_pairMembershipFormula 0 1 2 _).2 | |
| have inMap := (Name.mem_eval {q | H.mem q} map.val _).2 | |
| ⟨_, p, mapEntry, hp, rfl⟩ | |
| rw [Name.eval_orderedPair {q | H.mem q} ⊤ H.top_mem] at inMap | |
| exact inMap | |
| theorem refinementAbsentVisibleLift_nonvisible (small : M.sets.Countable) | |
| (U Rf Rc u visibility : (M.nameDomain s).names) (term : u.val.val ∈ T) (p : P) | |
| (active : Name.ForcesMem p u.val U.val) : | |
| let cls := M.stageOneClassName s pairing unions powers separation collection carrier order hT valid | |
| let quotient : (M.nameDomain s).names := ⟨Name.refinementQuotient T valid U.val Rf.val, | |
| M.refinementQuotient_mem s pairing unions powers separation collection carrier order | |
| hT valid U.val Rf.val U.property Rf.property⟩ | |
| let map := M.stageOneMapName s pairing unions powers separation collection carrier order hT valid U Rf Rc | |
| Forces (M.nameDomain s) (.neg refinementVisibleLiftFormula) | |
| ![quotient, visibility, cls Rc u, map] p → | |
| Name.ForcesMem p (cls Rf u).val quotient.val ∧ | |
| Forces (M.nameDomain s) (BoundedFormula.pairMembershipFormula 0 1 2).toFormula | |
| ![cls Rf u, cls Rc u, map] p ∧ | |
| (∀ q, q ≤ p → ¬ Name.ForcesMem q (cls Rf u).val visibility.val) := by | |
| dsimp only | |
| let cls := M.stageOneClassName s pairing unions powers separation collection carrier order hT valid | |
| let quotient : (M.nameDomain s).names := ⟨Name.refinementQuotient T valid U.val Rf.val, | |
| M.refinementQuotient_mem s pairing unions powers separation collection carrier order | |
| hT valid U.val Rf.val U.property Rf.property⟩ | |
| let map := M.stageOneMapName s pairing unions powers separation collection carrier order hT valid U Rf Rc | |
| intro absent | |
| obtain ⟨member, mapped⟩ := M.refinementActiveTerm_fineLift s pairing unions powers separation collection | |
| carrier order hT valid small U Rf Rc u term p active | |
| refine ⟨member, mapped, ?_⟩ | |
| intro q qp visible | |
| apply absent q qp | |
| apply (forces_ex_iff (M.nameDomain s) _ ![quotient, visibility, cls Rc u, map] q).2 | |
| intro r rq | |
| refine ⟨r, le_rfl, cls Rf u, Name.forcesMem_mono member (rq.trans qp), | |
| Name.forcesMem_mono visible rq, ?_⟩ | |
| exact forces_mono (M.nameDomain s) (BoundedFormula.pairMembershipFormula 0 1 2).toFormula | |
| ![cls Rf u, cls Rc u, map] mapped (rq.trans qp) | |
| end PartitionPilot.Forcing.TransitiveGround | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) {P : Type u} | |
| variable [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) | |
| variable {T : ZFSet.{u}} (hT : T ∈ M.sets) (valid : ∀ z ∈ T, IsName s z) | |
| variable (small : M.sets.Countable) | |
| include small in | |
| theorem stageOneCollisionTest_self (Rf Rc u w : (M.nameDomain s).names) (p : P) : | |
| M.stageOneCollisionTest s pairing unions powers separation collection carrier order hT valid | |
| Rf Rc u u w w p := by | |
| unfold stageOneCollisionTest | |
| apply (M.ordinaryForces_iff_all_generics s small carrier _ _ p).2 | |
| intro H hp generic | |
| let evaluated : TransitiveGround.{u} := | |
| ⟨(M.nameDomain s).values {q | H.mem q}, (M.nameDomain s).values_transitive _⟩ | |
| apply (evaluated.realize_refinementCollisionFormula _ (fun j => ⟨_, rfl⟩)).2 | |
| exact ⟨fun _ => rfl, fun _ => rfl⟩ | |
| include small in | |
| theorem stageOneCollisionTest_diagonal (R u v : (M.nameDomain s).names) (p : P) : | |
| M.stageOneCollisionTest s pairing unions powers separation collection carrier order hT valid | |
| R R u v u v p := by | |
| unfold stageOneCollisionTest | |
| apply (M.ordinaryForces_iff_all_generics s small carrier _ _ p).2 | |
| intro H hp generic | |
| let evaluated : TransitiveGround.{u} := | |
| ⟨(M.nameDomain s).values {q | H.mem q}, (M.nameDomain s).values_transitive _⟩ | |
| apply (evaluated.realize_refinementCollisionFormula _ (fun j => ⟨_, rfl⟩)).2 | |
| exact Iff.rfl | |
| variable {G L : Type u} [Group G] [PartialOrder L] | |
| variable (a : PosetAction G P) (b : Presentation L) (d : PosetAction G L) | |
| variable (base : L) (directed : ∀ x y : L, ∃ z, x ≤ z ∧ y ≤ z) | |
| variable (system : NiceNameSystem M a s b d base directed T valid) | |
| include small in | |
| theorem stageOneSingleTests_diagonal (C E : L) (U R u : (M.nameDomain s).names) | |
| (term : u.val.val ∈ T) (p : P) (active : Name.ForcesMem p u.val U.val) : | |
| M.stageOneSingleTests s pairing unions powers separation collection carrier order hT valid | |
| a b d base directed system C E U R R u u p := by | |
| refine ⟨⟨active, active⟩, ?_, ?_⟩ | |
| · intro v hv | |
| apply (M.ordinaryForces_iff_all_generics s small carrier _ _ p).2 | |
| intro H hp generic | |
| let evaluated : TransitiveGround.{u} := | |
| ⟨(M.nameDomain s).values {q | H.mem q}, (M.nameDomain s).values_transitive _⟩ | |
| apply (evaluated.realize_refinementProfileFormula _ (fun j => ⟨_, rfl⟩)).2 | |
| exact Iff.rfl | |
| · apply (M.ordinaryForces_iff_all_generics s small carrier _ _ p).2 | |
| intro H hp generic | |
| let evaluated : TransitiveGround.{u} := | |
| ⟨(M.nameDomain s).values {q | H.mem q}, (M.nameDomain s).values_transitive _⟩ | |
| apply (evaluated.realize_refinementCompatibilityFormula _ (fun j => ⟨_, rfl⟩)).2 | |
| intro visible | |
| let cls := Name.refinementClass T valid R.val u.val | |
| change ZFSet.pair (Name.eval {q | H.mem q} cls) (Name.eval {q | H.mem q} cls) ∈ | |
| Name.eval {q | H.mem q} (Name.refinementNaturalMap T valid U.val R.val R.val) | |
| apply (Name.mem_eval _ _ _).2 | |
| refine ⟨Name.orderedPair ⊤ cls cls, p, ?_, hp, ?_⟩ | |
| · exact (Name.entry_refinementNaturalMap T valid U.val R.val R.val _ p).2 | |
| ⟨u.val, term, active, rfl⟩ | |
| · exact Name.eval_orderedPair _ ⊤ H.top_mem cls cls | |
| end PartitionPilot.Forcing.TransitiveGround | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) {G P L : Type u} | |
| variable [Group G] [PartialOrder P] [OrderTop P] [PartialOrder L] | |
| variable (s : Presentation P) (carrier : s.carrier ∈ M.sets) | |
| variable (a : PosetAction G P) (b : Presentation L) (d : PosetAction G L) | |
| variable {T : ZFSet.{u}} (valid : ∀ z ∈ T, IsName s z) | |
| variable (base : L) (directed : ∀ x y : L, ∃ z, x ≤ z ∧ y ≤ z) | |
| variable (system : NiceNameSystem M a s b d base directed T valid) | |
| include carrier in | |
| theorem absentLift_profile_inequalities (small : M.sets.Countable) | |
| (C K : L) (moved old : (M.nameDomain s).names) (profile : ZFSet.{u}) | |
| (r q : P) (below : q ≤ r) | |
| (decisions : M.DecidesVisibilityProfile a s b d.principalFix T profile old.val r) | |
| (survivor : b.encode C ∉ profile → b.encode K ∉ profile) : | |
| let vis := M.stageOneVisibilityName s valid a b d base directed system | |
| Name.ForcesMem q moved.val (vis K).val → | |
| (∀ p, p ≤ q → ¬ Name.ForcesMem p moved.val (vis C).val) → | |
| (∀ p, p ≤ q → ¬ Name.ForcesEq p moved.val old.val) ∧ | |
| (∀ p, p ≤ q → ¬ Name.ForcesEq p old.val moved.val) := by | |
| dsimp only | |
| let vis := M.stageOneVisibilityName s valid a b d base directed system | |
| intro visible absent | |
| have negative : Forces (M.nameDomain s) (.neg (.equal 0 1)) ![moved, old] q := by | |
| apply (M.ordinaryForces_iff_all_generics s small carrier _ _ q).2 | |
| intro H hq generic same | |
| change Name.eval {p | H.mem p} moved.val = Name.eval {p | H.mem p} old.val at same | |
| classical | |
| by_cases atC : b.encode C ∈ profile | |
| · have oldVisible := Name.forcesMem_mono ((decisions C).1 atC) below | |
| have seen := Name.forcesMem_sound (M.nameDomain s) H | |
| (fun D hD dense => generic D (Or.inl hD) dense) | |
| old.property (vis C).property hq oldVisible | |
| have movedNegative : Forces (M.nameDomain s) (.neg (.mem 0 1)) ![moved, vis C] q := absent | |
| have unseen : Name.eval {p | H.mem p} moved.val ∉ Name.eval {p | H.mem p} (vis C).val := | |
| forces_sound (M.nameDomain s) H generic (.neg (.mem 0 1)) ![moved, vis C] hq movedNegative | |
| exact unseen (same.symm ▸ seen) | |
| · have oldNegative : Forces (M.nameDomain s) (.neg (.mem 0 1)) ![old, vis K] q := | |
| fun p pq => (decisions K).2 (survivor atC) p (pq.trans below) | |
| have unseen : Name.eval {p | H.mem p} old.val ∉ Name.eval {p | H.mem p} (vis K).val := | |
| forces_sound (M.nameDomain s) H generic (.neg (.mem 0 1)) ![old, vis K] hq oldNegative | |
| have seen := Name.forcesMem_sound (M.nameDomain s) H | |
| (fun D hD dense => generic D (Or.inl hD) dense) | |
| moved.property (vis K).property hq visible | |
| exact unseen (same ▸ seen) | |
| exact ⟨negative, fun p pq equal => negative p pq (Name.forcesEq_symm equal)⟩ | |
| 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 (order : s.conditionOrder ∈ M.sets) (hT : T ∈ M.sets) | |
| theorem refinementAbsentLift_profile_collisions (small : M.sets.Countable) | |
| (C K : L) (Rf Rc u oldU w oldW : (M.nameDomain s).names) | |
| (profile : ZFSet.{u}) (r q : P) (below : q ≤ r) : | |
| let cls := M.stageOneClassName s pairing unions powers separation collection carrier order hT valid | |
| let vis := M.stageOneVisibilityName s valid a b d base directed system | |
| M.DecidesVisibilityProfile a s b d.principalFix T profile (cls Rf oldW).val r → | |
| (b.encode C ∉ profile → b.encode K ∉ profile) → | |
| Name.ForcesMem q (cls Rf w).val (vis K).val → | |
| (∀ p, p ≤ q → ¬ Name.ForcesMem p (cls Rf w).val (vis C).val) → | |
| (∀ p, p ≤ q → ¬ Name.ForcesEq p (cls Rc u).val (cls Rc oldU).val) → | |
| (∀ p, p ≤ q → ¬ Name.ForcesEq p (cls Rf w).val (cls Rf oldW).val) ∧ | |
| (∀ p, p ≤ q → ¬ Name.ForcesEq p (cls Rf oldW).val (cls Rf w).val) ∧ | |
| M.stageOneCollisionTest s pairing unions powers separation collection carrier order hT valid | |
| Rf Rc u oldU w oldW q ∧ | |
| M.stageOneCollisionTest s pairing unions powers separation collection carrier order hT valid | |
| Rf Rc oldU u oldW w q ∧ | |
| M.stageOneCollisionTest s pairing unions powers separation collection carrier order hT valid | |
| Rf Rc u u w w q := by | |
| dsimp only | |
| let cls := M.stageOneClassName s pairing unions powers separation collection carrier order hT valid | |
| intro decisions survivor visible absent coarseDifferent | |
| obtain ⟨fineDifferent, fineDifferent'⟩ := M.absentLift_profile_inequalities s carrier a b d valid | |
| base directed system small C K (cls Rf w) (cls Rf oldW) profile r q below | |
| decisions survivor visible absent | |
| have collision : M.stageOneCollisionTest s pairing unions powers separation collection carrier order hT valid | |
| Rf Rc u oldU w oldW q := by | |
| constructor | |
| · intro p pq facts | |
| exact coarseDifferent p pq facts.1 | |
| · intro p pq facts | |
| exact fineDifferent p pq facts.1 | |
| exact ⟨fineDifferent, fineDifferent', collision, | |
| M.stageOneCollisionTest_symm s pairing unions powers separation collection carrier order hT valid | |
| Rf Rc u oldU w oldW q collision, | |
| M.stageOneCollisionTest_self s pairing unions powers separation collection carrier order hT valid | |
| small Rf Rc u w q⟩ | |
| end PartitionPilot.Forcing.TransitiveGround | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetRealization SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) {G P L : Type u} | |
| variable [Group G] [PartialOrder P] [OrderTop P] [PartialOrder L] | |
| variable (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) | |
| variable {T T2 : ZFSet.{u}} (hT : T ∈ M.sets) | |
| variable (valid : ∀ z ∈ T, IsName s z) {valid2 : ∀ z ∈ T2, IsName s z} | |
| variable (a : PosetAction G P) (b : Presentation L) (d : PosetAction G L) | |
| variable (level : ZFSet.{u}) | |
| variable (indices : NiceRefinementIndexSystem M a s b d level T T2 valid valid2) | |
| include indices in | |
| theorem refinementVisibleLift_collisions (small : M.sets.Countable) | |
| (C E : L) (U Rf Rc u v w oldW visibility : (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 T T2 valid) | |
| (p : P) : | |
| let cls := M.stageOneClassName s pairing unions powers separation collection carrier order hT valid | |
| let map := M.stageOneMapName s pairing unions powers separation collection carrier order hT valid U Rf Rc | |
| Name.ForcesMem p (cls Rf w).val visibility.val → | |
| Forces (M.nameDomain s) (BoundedFormula.pairMembershipFormula 0 1 2).toFormula | |
| ![cls Rf w, cls Rc u, map] p → | |
| Forces (M.nameDomain s) refinementCompatibilityFormula | |
| ![cls Rf oldW, visibility, cls Rc v, map] p → | |
| (∀ q, q ≤ p → ¬ Name.ForcesEq q (cls Rc u).val (cls Rc v).val) → | |
| (∀ q, q ≤ p → ¬ Name.ForcesEq q (cls Rf w).val (cls Rf oldW).val) ∧ | |
| M.stageOneCollisionTest s pairing unions powers separation collection carrier order hT valid | |
| Rf Rc u v w oldW p ∧ | |
| M.stageOneCollisionTest s pairing unions powers separation collection carrier order hT valid | |
| Rf Rc v u oldW w p ∧ | |
| M.stageOneCollisionTest s pairing unions powers separation collection carrier order hT valid | |
| Rf Rc u u w w p := by | |
| dsimp only | |
| let cls := M.stageOneClassName s pairing unions powers separation collection carrier order hT valid | |
| let map := M.stageOneMapName s pairing unions powers separation collection carrier order hT valid U Rf Rc | |
| intro visible selected oldGuard different | |
| have coarseNegative : Forces (M.nameDomain s) (.neg (.equal 0 1)) ![cls Rc u, cls Rc v] p := different | |
| have values (H : ConditionFilter P) (hp : H.mem p) | |
| (generic : H.GenericFor (formulaFamily (M.nameDomain s))) : | |
| Name.eval {q | H.mem q} (cls Rc u).val ≠ Name.eval {q | H.mem q} (cls Rc v).val ∧ | |
| Name.eval {q | H.mem q} (cls Rf w).val ≠ Name.eval {q | H.mem q} (cls Rf oldW).val := by | |
| have coarseDifferent : Name.eval {q | H.mem q} (cls Rc u).val ≠ | |
| Name.eval {q | H.mem q} (cls Rc v).val := | |
| forces_sound (M.nameDomain s) H generic (.neg (.equal 0 1)) ![cls Rc u, cls Rc v] hp coarseNegative | |
| refine ⟨coarseDifferent, ?_⟩ | |
| intro sameFine | |
| have visibleValue := Name.forcesMem_sound (M.nameDomain s) H | |
| (fun D hD dense => generic D (Or.inl hD) dense) | |
| (cls Rf w).property visibility.property hp visible | |
| have oldVisible : Name.eval {q | H.mem q} (cls Rf oldW).val ∈ | |
| Name.eval {q | H.mem q} visibility.val := sameFine ▸ visibleValue | |
| have oldEntry := M.refinementCompatibility_eval s | |
| ![cls Rf oldW, visibility, cls Rc v, map] H generic hp oldGuard oldVisible | |
| let evaluated : TransitiveGround.{u} := | |
| ⟨(M.nameDomain s).values {q | H.mem q}, (M.nameDomain s).values_transitive _⟩ | |
| have selectedTruth := forces_sound (M.nameDomain s) H generic | |
| (BoundedFormula.pairMembershipFormula 0 1 2).toFormula ![cls Rf w, cls Rc u, map] hp selected | |
| have selectedEntry : ZFSet.pair (Name.eval {q | H.mem q} (cls Rf w).val) | |
| (Name.eval {q | H.mem q} (cls Rc u).val) ∈ Name.eval {q | H.mem q} map.val := | |
| (BoundedFormula.truth_pairMembershipFormula 0 1 2 _).1 | |
| ((BoundedFormula.realize_toFormula evaluated _ _ (fun j => ⟨_, rfl⟩)).1 selectedTruth) | |
| obtain ⟨_, _, _, _, forced⟩ := (indices.typed_entries C E U Rf Rc).1 member | |
| have objects := M.refinementObjects_eval s pairing carrier hT valid indices.family_ground | |
| U Rf Rc H generic H.top_mem forced | |
| have oldEntry' : ZFSet.pair (Name.eval {q | H.mem q} (cls Rf w).val) | |
| (Name.eval {q | H.mem q} (cls Rc v).val) ∈ Name.eval {q | H.mem q} map.val := | |
| sameFine.symm ▸ oldEntry | |
| exact coarseDifferent ((functionCode_partial objects.function).unique _ _ _ selectedEntry oldEntry') | |
| have fineNegative : Forces (M.nameDomain s) (.neg (.equal 0 1)) ![cls Rf w, cls Rf oldW] p := by | |
| apply (M.ordinaryForces_iff_all_generics s small carrier _ _ p).2 | |
| intro H hp generic | |
| exact (values H hp generic).2 | |
| have collision : M.stageOneCollisionTest s pairing unions powers separation collection carrier order hT valid | |
| Rf Rc u v w oldW p := by | |
| apply (M.ordinaryForces_iff_all_generics s small carrier _ _ p).2 | |
| intro H hp generic | |
| let evaluated : TransitiveGround.{u} := | |
| ⟨(M.nameDomain s).values {q | H.mem q}, (M.nameDomain s).values_transitive _⟩ | |
| apply (evaluated.realize_refinementCollisionFormula _ (fun j => ⟨_, rfl⟩)).2 | |
| have differentValues := values H hp generic | |
| exact ⟨fun eq => False.elim (differentValues.1 eq), fun eq => False.elim (differentValues.2 eq)⟩ | |
| exact ⟨fineNegative, collision, | |
| M.stageOneCollisionTest_symm s pairing unions powers separation collection carrier order hT valid | |
| Rf Rc u v w oldW p collision, | |
| M.stageOneCollisionTest_self s pairing unions powers separation collection carrier order hT valid | |
| small Rf Rc u w p⟩ | |
| end PartitionPilot.Forcing.TransitiveGround | |
| end OAI | |