openAI-math-dataset / lean /OAI /Computability /DegreeRigidity /OrdinalCodes /LimitOmegaGraphSyntax.lean
| import OAI.Computability.DegreeRigidity.OrdinalCodes.CodeOperationCertificates | |
| import OAI.Computability.DegreeRigidity.OrdinalCodes.OrdinalCodeBranch | |
| namespace OAI | |
| namespace TuringRigidity.OrdinalArithmetic | |
| open TransitiveNameModel BoundedSetTheory RelationCollapse ElementaryModel RelativeConstructible | |
| open OrdinalCoding | |
| universe u | |
| noncomputable def omegaNextPairSentence : SentenceForm := | |
| .ex (.ex (.ex (.conj | |
| (fromBounded (.conj (ordinalFormula 2) (.conj (.successor 0 2) (.orderedPair 3 2 1)))) | |
| (codePowerAt 1 0)))) | |
| theorem omegaNextPairSentence_bound : omegaNextPairSentence.bound = 1 := by | |
| have hbounded : | |
| (fromBounded (.conj (ordinalFormula 2) (.conj (.successor 0 2) (.orderedPair 3 2 1)))).bound = 4 := by | |
| rfl | |
| have hpower : (codePowerAt 1 0).bound ≤ 4 := | |
| code_rename_bound omegaPowerSentence _ 4 (by intro i _; split <;> omega) | |
| have finish (p q : SentenceForm) (hp : p.bound = 4) (hq : q.bound ≤ 4) : | |
| (SentenceForm.ex (.ex (.ex (.conj p q)))).bound = 1 := by | |
| change max p.bound q.bound - 1 - 1 - 1 = 1 | |
| rw [hp, max_eq_left hq] | |
| exact finish _ _ hbounded hpower | |
| theorem omegaNextPairSentence_semantics (M : ZFSet.{u}) (hM : Transitive M) | |
| (e : ℕ → ZFSet.{u}) (he : ∀ i, e i ∈ M) : | |
| omegaNextPairSentence.Sat (M : Set ZFSet) e ↔ | |
| ∃ x ∈ M, ∃ y ∈ M, ∃ k ∈ M, | |
| (x.IsOrdinal ∧ k = insert x x ∧ e 0 = ZFSet.pair x y) ∧ | |
| (codePowerAt 1 0).Sat (M : Set ZFSet) (cons k (cons y (cons x e))) := by | |
| change (∃ x ∈ M, ∃ y ∈ M, ∃ k ∈ M, _) ↔ _ | |
| apply exists_congr; intro x | |
| apply and_congr_right; intro hx | |
| apply exists_congr; intro y | |
| apply and_congr_right; intro hy | |
| apply exists_congr; intro k | |
| apply and_congr_right; intro hk | |
| have hE : ∀ i, cons k (cons y (cons x e)) i ∈ M := by | |
| intro i; rcases i with _|_|_|i | |
| exact hk; exact hy; exact hx; exact he i | |
| rw [SentenceForm.Sat,bounded_sat,Formula.absolute _ M hM _ hE] | |
| simp only [Formula.Eval,eval_ordinalFormula,Formula.eval_successor, | |
| Formula.eval_orderedPair,cons_zero,cons_succ] | |
| theorem omegaNextPairSentence_at_cut (M : ZFSet.{u}) (hM : Transitive M) | |
| (hω : ZFSet.omega.{u} ∈ M) (a : Ordinal.{u}) (ha : Order.IsSuccLimit a) | |
| (hcut : ∀ c : Ordinal.{u}, c.toZFSet ∈ M ↔ c < a) | |
| (hpow : ∀ c < a, (Ordinal.omega0 ^ c).toZFSet ∈ M ∧ OmegaPowerCertificates M c.toZFSet) | |
| (e : ℕ → ZFSet.{u}) (he : ∀ i, e i ∈ M) : | |
| omegaNextPairSentence.Sat (M : Set ZFSet) e ↔ | |
| ∃ c < a, e 0 = ZFSet.pair c.toZFSet (omegaNext c.toZFSet) := by | |
| rw [omegaNextPairSentence_semantics M hM e he] | |
| constructor | |
| · rintro ⟨x,hx,y,hy,k,hk,⟨ho,hkdef,hz⟩,hp⟩ | |
| have hE : ∀ i, cons k (cons y (cons x e)) i ∈ M := by | |
| intro i; rcases i with _|_|_|i | |
| exact hk; exact hy; exact hx; exact he i | |
| have hv := (codePowerAt_sound M hM hω 1 0 _ hE hp).2 | |
| change y = (Ordinal.omega0 ^ k.rank).toZFSet at hv | |
| have hsucc : k = (x.rank+1).toZFSet := by | |
| rw [Ordinal.toZFSet_add_one,ho.toZFSet_rank_eq,hkdef] | |
| rw [hsucc,Ordinal.rank_toZFSet] at hv | |
| refine ⟨x.rank,(hcut _).mp (ho.toZFSet_rank_eq.symm ▸ hx),?_⟩ | |
| simpa only [ho.toZFSet_rank_eq,omegaNext] using hz.trans (congrArg (ZFSet.pair x) hv) | |
| · rintro ⟨c,hc,hz⟩ | |
| have hs : c+1 < a := ha.succ_lt hc | |
| have hx := (hcut c).mpr hc | |
| have hk := (hcut (c+1)).mpr hs | |
| obtain ⟨hy,hcert⟩ := hpow (c+1) hs | |
| refine ⟨c.toZFSet,hx,(Ordinal.omega0 ^ (c+1)).toZFSet,hy,(c+1).toZFSet,hk, | |
| ⟨ZFSet.isOrdinal_toZFSet _,Ordinal.toZFSet_add_one c,?_⟩,?_⟩ | |
| · simpa only [omegaNext,Ordinal.rank_toZFSet] using hz | |
| · apply codePowerAt_of_certificates M hM hω 1 0 _ (fun i => by | |
| rcases i with _|_|_|i | |
| exact hk; exact hy; exact hx; exact he i) hcert | |
| simp only [cons_zero,cons_succ,Ordinal.rank_toZFSet] | |
| end TuringRigidity.OrdinalArithmetic | |
| end OAI | |