| import OAI.SetTheory.PartitionPrinciple.Definability.DepthSlotCodes |
| import OAI.SetTheory.PartitionPrinciple.Definability.FiniteWordMapCodes |
|
|
| namespace OAI |
|
|
|
|
| namespace PartitionPilot.Forcing |
| open SetRealization |
| universe u |
|
|
| def FiniteWordAppendCode (A omega add f g h : ZFSet.{u}) : Prop := |
| ∃ m ∈ omega, ∃ n ∈ omega, ∃ p ∈ omega, |
| ZFSet.IsFunc m A f ∧ ZFSet.IsFunc n A g ∧ ZFSet.IsFunc p A h ∧ |
| ZFSet.pair (ZFSet.pair m n) p ∈ add ∧ |
| ∀ i ∈ p, ∀ a ∈ A, ZFSet.pair i a ∈ h ↔ |
| ZFSet.pair i a ∈ f ∨ ∃ j ∈ n, |
| ZFSet.pair (ZFSet.pair m j) i ∈ add ∧ ZFSet.pair j a ∈ g |
|
|
| def FiniteWordReverseCode (A omega add f h : ZFSet.{u}) : Prop := |
| ∃ n ∈ omega, ZFSet.IsFunc n A f ∧ ZFSet.IsFunc n A h ∧ |
| ∀ i ∈ n, ∀ a ∈ A, ZFSet.pair i a ∈ h ↔ |
| ∃ j ∈ n, ∃ k ∈ n, ZFSet.pair (ZFSet.pair i j) k ∈ add ∧ |
| n = insert k k ∧ ZFSet.pair j a ∈ f |
|
|
| theorem finiteWordGraph_append_entry {B : Type u} (s : Presentation B) |
| (xs ys : List B) (k : Nat) (a : ZFSet.{u}) : |
| ZFSet.pair (natSetCode k) a ∈ finiteWordGraph s (xs ++ ys) ↔ |
| ZFSet.pair (natSetCode k) a ∈ finiteWordGraph s xs ∨ |
| ∃ j, k = xs.length + j ∧ ZFSet.pair (natSetCode j) a ∈ finiteWordGraph s ys := by |
| constructor |
| · intro entry |
| obtain ⟨hk, value⟩ := (pair_mem_finiteWordGraph s (xs ++ ys) k a).1 entry |
| by_cases left : k < xs.length |
| · apply Or.inl |
| apply (pair_mem_finiteWordGraph s xs k a).2 |
| refine ⟨left, ?_⟩ |
| simpa only [List.get_eq_getElem, List.getElem_append_left left] using value |
| · have right : xs.length ≤ k := Nat.le_of_not_gt left |
| have hj : k - xs.length < ys.length := by simp only [List.length_append] at hk; omega |
| refine Or.inr ⟨k - xs.length, by omega, (pair_mem_finiteWordGraph s ys _ a).2 ⟨hj, ?_⟩⟩ |
| simpa only [List.get_eq_getElem, List.getElem_append_right right] using value |
| · rintro (entry | ⟨j, equal, entry⟩) |
| · obtain ⟨hk, value⟩ := (pair_mem_finiteWordGraph s xs k a).1 entry |
| apply (pair_mem_finiteWordGraph s (xs ++ ys) k a).2 |
| have bound : k < (xs ++ ys).length := by simp only [List.length_append]; omega |
| refine ⟨bound, ?_⟩ |
| simpa only [List.get_eq_getElem, List.getElem_append_left hk] using value |
| · subst k |
| obtain ⟨hj, value⟩ := (pair_mem_finiteWordGraph s ys j a).1 entry |
| apply (pair_mem_finiteWordGraph s (xs ++ ys) (xs.length + j) a).2 |
| have bound : xs.length + j < (xs ++ ys).length := by simp only [List.length_append]; omega |
| refine ⟨bound, ?_⟩ |
| simpa only [List.get_eq_getElem, |
| List.getElem_append_right (Nat.le_add_right xs.length j), Nat.add_sub_cancel_left] using value |
| |
| theorem finiteWordGraph_reverse_entry {B : Type u} (s : Presentation B) |
| (xs : List B) (i : Nat) (a : ZFSet.{u}) : |
| ZFSet.pair (natSetCode i) a ∈ finiteWordGraph s xs.reverse ↔ |
| ∃ j, i + j + 1 = xs.length ∧ ZFSet.pair (natSetCode j) a ∈ finiteWordGraph s xs := by |
| constructor |
| · intro entry |
| obtain ⟨hi, value⟩ := (pair_mem_finiteWordGraph s xs.reverse i a).1 entry |
| have bound : i < xs.length := by simpa only [List.length_reverse] using hi |
| have hj : xs.length - 1 - i < xs.length := by omega |
| refine ⟨xs.length - 1 - i, by omega, (pair_mem_finiteWordGraph s xs _ a).2 ⟨hj, ?_⟩⟩ |
| simpa only [List.get_eq_getElem, List.getElem_reverse] using value |
| · rintro ⟨j, sum, entry⟩ |
| obtain ⟨hj, value⟩ := (pair_mem_finiteWordGraph s xs j a).1 entry |
| have hi : i < xs.reverse.length := by simp only [List.length_reverse]; omega |
| have equal : xs.length - 1 - i = j := by omega |
| apply (pair_mem_finiteWordGraph s xs.reverse i a).2 |
| refine ⟨hi, ?_⟩ |
| simpa only [List.get_eq_getElem, List.getElem_reverse, equal] using value |
|
|
| theorem finiteWordGraph_append_code {B : Type u} (s : Presentation B) (xs ys : List B) : |
| FiniteWordAppendCode s.carrier ZFSet.omega natAddGraph |
| (finiteWordGraph s xs) (finiteWordGraph s ys) (finiteWordGraph s (xs ++ ys)) := by |
| refine ⟨natSetCode xs.length, natSetCode_mem_omega _, natSetCode ys.length, natSetCode_mem_omega _, |
| natSetCode (xs.length + ys.length), natSetCode_mem_omega _, finiteWordGraph_function s xs, |
| finiteWordGraph_function s ys, ?_, (pair_mem_natAddGraph _ _ _).2 rfl, ?_⟩ |
| · simpa only [List.length_append] using finiteWordGraph_function s (xs ++ ys) |
| · intro i hi a _ |
| obtain ⟨k, _, rfl⟩ := (mem_natSetCode i (xs.length + ys.length)).1 hi |
| rw [finiteWordGraph_append_entry] |
| apply or_congr Iff.rfl |
| constructor |
| · rintro ⟨j, equal, entry⟩ |
| have hj := (ZFSet.pair_mem_prod.1 ((finiteWordGraph_function s ys).1 entry)).1 |
| exact ⟨natSetCode j, hj, (pair_mem_natAddGraph _ _ _).2 equal, entry⟩ |
| · rintro ⟨j, hj, sum, entry⟩ |
| obtain ⟨l, _, rfl⟩ := (mem_natSetCode j ys.length).1 hj |
| exact ⟨l, (pair_mem_natAddGraph _ _ _).1 sum, entry⟩ |
|
|
| theorem finiteWordGraph_reverse_code {B : Type u} (s : Presentation B) (xs : List B) : |
| FiniteWordReverseCode s.carrier ZFSet.omega natAddGraph |
| (finiteWordGraph s xs) (finiteWordGraph s xs.reverse) := by |
| refine ⟨natSetCode xs.length, natSetCode_mem_omega _, finiteWordGraph_function s xs, ?_, ?_⟩ |
| · simpa only [List.length_reverse] using finiteWordGraph_function s xs.reverse |
| · intro i hi a _ |
| obtain ⟨k, _, rfl⟩ := (mem_natSetCode i xs.length).1 hi |
| rw [finiteWordGraph_reverse_entry] |
| constructor |
| · rintro ⟨j, sum, entry⟩ |
| have hj := (ZFSet.pair_mem_prod.1 ((finiteWordGraph_function s xs).1 entry)).1 |
| refine ⟨natSetCode j, hj, natSetCode (k + j), (natSetCode_mem_iff _ _).2 (by omega), |
| (pair_mem_natAddGraph _ _ _).2 rfl, ?_, entry⟩ |
| exact (congrArg natSetCode sum).symm |
| · rintro ⟨j, hj, l, hl, sum, successor, entry⟩ |
| obtain ⟨j, _, rfl⟩ := (mem_natSetCode j xs.length).1 hj |
| obtain ⟨l, _, rfl⟩ := (mem_natSetCode l xs.length).1 hl |
| have added := (pair_mem_natAddGraph _ _ _).1 sum |
| have length : xs.length = l + 1 := natSetCode_injective successor |
| exact ⟨j, by omega, entry⟩ |
|
|
| theorem FiniteWordAppendCode.unique {A f g h h' : ZFSet.{u}} |
| (first : FiniteWordAppendCode A ZFSet.omega natAddGraph f g h) |
| (second : FiniteWordAppendCode A ZFSet.omega natAddGraph f g h') : h = h' := by |
| obtain ⟨m, hm, n, hn, p, hp, fm, gn, funH, sum, entries⟩ := first |
| obtain ⟨m', hm', n', hn', p', hp', fm', gn', funH', sum', entries'⟩ := second |
| obtain ⟨m, rfl⟩ := (mem_omega_iff_natSetCode _).1 hm |
| obtain ⟨n, rfl⟩ := (mem_omega_iff_natSetCode _).1 hn |
| obtain ⟨p, rfl⟩ := (mem_omega_iff_natSetCode _).1 hp |
| obtain ⟨m', rfl⟩ := (mem_omega_iff_natSetCode _).1 hm' |
| obtain ⟨n', rfl⟩ := (mem_omega_iff_natSetCode _).1 hn' |
| obtain ⟨p', rfl⟩ := (mem_omega_iff_natSetCode _).1 hp' |
| have mEqual := finiteWord_domain_unique fm' fm |
| have nEqual := finiteWord_domain_unique gn' gn |
| subst m' n' |
| have pEqual := ((pair_mem_natAddGraph _ _ _).1 sum').trans ((pair_mem_natAddGraph _ _ _).1 sum).symm |
| subst p' |
| apply ZFSet.ext |
| intro z |
| constructor |
| · intro hz |
| obtain ⟨i, hi, a, ha, rfl⟩ := ZFSet.mem_prod.1 (funH.1 hz) |
| exact (entries' i hi a ha).2 ((entries i hi a ha).1 hz) |
| · intro hz |
| obtain ⟨i, hi, a, ha, rfl⟩ := ZFSet.mem_prod.1 (funH'.1 hz) |
| exact (entries i hi a ha).2 ((entries' i hi a ha).1 hz) |
|
|
| theorem FiniteWordReverseCode.unique {A f h h' : ZFSet.{u}} |
| (first : FiniteWordReverseCode A ZFSet.omega natAddGraph f h) |
| (second : FiniteWordReverseCode A ZFSet.omega natAddGraph f h') : h = h' := by |
| obtain ⟨n, hn, funF, funH, entries⟩ := first |
| obtain ⟨n', hn', funF', funH', entries'⟩ := second |
| obtain ⟨n, rfl⟩ := (mem_omega_iff_natSetCode _).1 hn |
| obtain ⟨n', rfl⟩ := (mem_omega_iff_natSetCode _).1 hn' |
| have same := finiteWord_domain_unique funF' funF |
| subst n' |
| apply ZFSet.ext |
| intro z |
| constructor |
| · intro hz |
| obtain ⟨i, hi, a, ha, rfl⟩ := ZFSet.mem_prod.1 (funH.1 hz) |
| exact (entries' i hi a ha).2 ((entries i hi a ha).1 hz) |
| · intro hz |
| obtain ⟨i, hi, a, ha, rfl⟩ := ZFSet.mem_prod.1 (funH'.1 hz) |
| exact (entries i hi a ha).2 ((entries' i hi a ha).1 hz) |
|
|
| theorem finiteWordAppendCode_iff {B : Type u} (s : Presentation B) (xs ys : List B) (h : ZFSet.{u}) : |
| FiniteWordAppendCode s.carrier ZFSet.omega natAddGraph |
| (finiteWordGraph s xs) (finiteWordGraph s ys) h ↔ h = finiteWordGraph s (xs ++ ys) := |
| ⟨fun code => code.unique (finiteWordGraph_append_code s xs ys), |
| fun equal => equal.symm ▸ finiteWordGraph_append_code s xs ys⟩ |
|
|
| theorem finiteWordReverseCode_iff {B : Type u} (s : Presentation B) (xs : List B) (h : ZFSet.{u}) : |
| FiniteWordReverseCode s.carrier ZFSet.omega natAddGraph (finiteWordGraph s xs) h ↔ |
| h = finiteWordGraph s xs.reverse := |
| ⟨fun code => code.unique (finiteWordGraph_reverse_code s xs), |
| fun equal => equal.symm ▸ finiteWordGraph_reverse_code s xs⟩ |
|
|
| end PartitionPilot.Forcing |
|
|
| end OAI |
|
|
