| import OAI.Computability.StarHeight.EndSearch |
|
|
| namespace OAI |
|
|
| namespace GeneralizedStarHeight |
|
|
| universe u |
| universe uM uQ uQ2 uM2 |
|
|
| namespace PeriodicTemplates |
|
|
| open scoped Computability Classical |
|
|
| variable {Alphabet : Type u} |
|
|
| def wordPower (c : List Alphabet) (i : ℕ) : List Alphabet := |
| ((FreeMonoid.ofList c) ^ i).toList |
|
|
| @[simp] lemma wordPower_zero (c : List Alphabet) : wordPower c 0 = [] := rfl |
|
|
| lemma wordPower_add (c : List Alphabet) (i j : ℕ) : |
| wordPower c (i + j) = wordPower c i ++ wordPower c j := by |
| simp only [wordPower, pow_add, FreeMonoid.toList_mul] |
|
|
| @[simp] lemma wordPower_one (c : List Alphabet) : wordPower c 1 = c := by |
| simp [wordPower] |
|
|
| lemma wordPower_mul (c : List Alphabet) (i j : ℕ) : |
| wordPower (wordPower c i) j = wordPower c (i * j) := by |
| simp only [wordPower, FreeMonoid.ofList_toList, pow_mul] |
|
|
| lemma wordPower_replicate (c : List Alphabet) (i : ℕ) : |
| wordPower c i = (List.replicate i c).flatten := by |
| induction i with |
| | zero => rfl |
| | succ i hi => simp [wordPower_add, List.replicate_add, hi] |
|
|
| lemma singleton_star (c : List Alphabet) (w : List Alphabet) : |
| w ∈ ({c} : Language Alphabet)∗ ↔ ∃ i, w = wordPower c i := by |
| rw [Language.mem_kstar] |
| constructor |
| · rintro ⟨pieces, rfl, hp⟩ |
| have he : pieces = List.replicate pieces.length c := |
| List.eq_replicate_iff.mpr ⟨rfl, fun v hv => hp v hv⟩ |
| exact ⟨pieces.length, by rw [wordPower_replicate, he]; simp⟩ |
| · rintro ⟨i, rfl⟩ |
| refine ⟨List.replicate i c, wordPower_replicate c i, ?_⟩ |
| intro v hv |
| change v = c |
| exact (List.mem_replicate.mp hv).2 |
|
|
| def progression (a c b : List Alphabet) (i p : ℕ) : Language Alphabet := |
| {a ++ wordPower c i} * ({wordPower c p} : Language Alphabet)∗ * {b} |
|
|
| lemma mem_progression (a c b : List Alphabet) (i p : ℕ) (w : List Alphabet) : |
| w ∈ progression a c b i p ↔ ∃ q, w = a ++ wordPower c (i + q * p) ++ b := by |
| simp only [progression, Language.mem_mul] |
| constructor |
| · rintro ⟨v, ⟨a', ha, mid, hm, rfl⟩, b', hb, rfl⟩ |
| subst a' |
| subst b' |
| obtain ⟨q, rfl⟩ := (singleton_star _ _).mp hm |
| exact ⟨q, by rw [wordPower_mul, wordPower_add, Nat.mul_comm q p]; simp only [List.append_assoc]⟩ |
| · rintro ⟨q, rfl⟩ |
| refine ⟨(a ++ wordPower c i) ++ wordPower c (p * q), ?_, b, rfl, ?_⟩ |
| · refine ⟨a ++ wordPower c i, rfl, wordPower c (p * q), ?_, rfl⟩ |
| apply (singleton_star _ _).mpr |
| exact ⟨q, (wordPower_mul c p q).symm⟩ |
| · rw [wordPower_add, Nat.mul_comm q p] |
| simp only [List.append_assoc] |
|
|
| lemma progression_height (a c b : List Alphabet) (i p : ℕ) : |
| HasHeightAtMost (progression a c b i p) 1 := |
| ((HasHeightAtMost.singleton _ 1).concat |
| ((HasHeightAtMost.singleton _ 0).star)).concat (HasHeightAtMost.singleton _ 1) |
|
|
| def accepted (a c b : List Alphabet) (P : ℕ → Prop) : Language Alphabet := |
| {w | ∃ i, P i ∧ w = a ++ wordPower c i ++ b} |
|
|
| lemma accepted_height (a c b : List Alphabet) (P : ℕ → Prop) (N p : ℕ) |
| (hp : 0 < p) (hperiod : ∀ i, N ≤ i → ∀ q, P (i + q * p) ↔ P i) : |
| HasHeightAtMost (accepted a c b P) 1 := by |
| classical |
| let small := (Finset.range N).filter P |
| let residues := (Finset.range p).filter (fun r => P (N + r)) |
| let L₀ : Language Alphabet := ⨆ i ∈ small, {a ++ wordPower c i ++ b} |
| let L₁ : Language Alphabet := ⨆ r ∈ residues, progression a c b (N + r) p |
| have h₀ : HasHeightAtMost L₀ 1 := HasHeightAtMost.finset_iSup small _ |
| (fun i _ => HasHeightAtMost.singleton _ 1) |
| have h₁ : HasHeightAtMost L₁ 1 := HasHeightAtMost.finset_iSup residues _ |
| (fun r _ => progression_height a c b (N + r) p) |
| have he : accepted a c b P = L₀ + L₁ := by |
| ext w |
| change (∃ i, P i ∧ w = a ++ wordPower c i ++ b) ↔ w ∈ L₀ ∨ w ∈ L₁ |
| constructor |
| · rintro ⟨i, hi, rfl⟩ |
| by_cases hsmall : i < N |
| · left |
| exact Language.mem_iSup.mpr ⟨i, Language.mem_iSup.mpr |
| ⟨Finset.mem_filter.mpr ⟨Finset.mem_range.mpr hsmall, hi⟩, rfl⟩⟩ |
| · right |
| let r := (i - N) % p |
| let q := (i - N) / p |
| have hir : i = N + r + q * p := by |
| have hd := Nat.mod_add_div (i - N) p |
| rw [Nat.mul_comm p] at hd |
| dsimp [r, q] |
| omega |
| have hr : r < p := Nat.mod_lt _ hp |
| have hrP : P (N + r) := by |
| apply (hperiod (N + r) (by omega) q).mp |
| rwa [← hir] |
| exact Language.mem_iSup.mpr ⟨r, Language.mem_iSup.mpr |
| ⟨Finset.mem_filter.mpr ⟨Finset.mem_range.mpr hr, hrP⟩, |
| (mem_progression _ _ _ _ _ _).mpr ⟨q, by rw [← hir]⟩⟩⟩ |
| · rintro (hw | hw) |
| · obtain ⟨i, hw⟩ := Language.mem_iSup.mp hw |
| obtain ⟨hi, he⟩ := Language.mem_iSup.mp hw |
| exact ⟨i, (Finset.mem_filter.mp hi).2, he⟩ |
| · obtain ⟨r, hw⟩ := Language.mem_iSup.mp hw |
| obtain ⟨hr, hw⟩ := Language.mem_iSup.mp hw |
| obtain ⟨q, he⟩ := (mem_progression _ _ _ _ _ _).mp hw |
| exact ⟨N + r + q * p, (hperiod _ (by omega) q).mpr |
| (Finset.mem_filter.mp hr).2, he⟩ |
| rw [he] |
| exact h₀.union h₁ |
|
|
| lemma recognized_template_height {M : Type uM} [Monoid M] [Fintype M] |
| (T : FreeMonoid Alphabet →* M) (F : Set M) (a c b : List Alphabet) : |
| HasHeightAtMost (accepted a c b (fun i => |
| T (FreeMonoid.ofList a) * (T (FreeMonoid.ofList c)) ^ i * T (FreeMonoid.ofList b) ∈ F)) 1 := by |
| apply accepted_height a c b _ (Fintype.card M) (Fintype.card M).factorial |
| (Nat.factorial_pos _) |
| intro i hi q |
| rw [FiniteMonoidPeriod.pow_factorial _ hi] |
|
|
| end PeriodicTemplates |
|
|
| namespace FiniteRecognition |
|
|
| open scoped Computability |
|
|
| variable {Alphabet : Type u} |
|
|
| def transition {Q : Type uQ} (A : DFA Alphabet Q) : |
| FreeMonoid Alphabet →* (Function.End Q)ᵐᵒᵖ where |
| toFun w := MulOpposite.op (fun q => A.evalFrom q w.toList) |
| map_one' := by apply MulOpposite.unop_injective; funext q; rfl |
| map_mul' x y := by |
| apply MulOpposite.unop_injective |
| funext q |
| exact A.evalFrom_of_append q x.toList y.toList |
|
|
| @[simp] lemma transition_apply {Q : Type uQ2} (A : DFA Alphabet Q) (w : List Alphabet) (q : Q) : |
| (transition A (FreeMonoid.ofList w)).unop q = A.evalFrom q w := rfl |
|
|
| lemma of_regular {L : Language Alphabet} (hL : L.IsRegular) : |
| ∃ (M : Type) (_ : Monoid M) (_ : Fintype M) (T : FreeMonoid Alphabet →* M) (F : Set M), |
| ∀ w, w ∈ L ↔ T (FreeMonoid.ofList w) ∈ F := by |
| classical |
| obtain ⟨Q, hQ, A, rfl⟩ := hL |
| let : Fintype Q := hQ |
| let : Fintype (Function.End Q)ᵐᵒᵖ := |
| Fintype.ofEquiv (Q → Q) (Equiv.refl _ |>.trans MulOpposite.opEquiv) |
| exact ⟨(Function.End Q)ᵐᵒᵖ, inferInstance, inferInstance, transition A, |
| {f | f.unop A.start ∈ A.accept}, fun _ => Iff.rfl⟩ |
|
|
| end FiniteRecognition |
|
|
| namespace PeriodicTemplates |
|
|
| open scoped Computability Classical |
|
|
| variable {Alphabet : Type u} |
|
|
| abbrev Template (Alphabet : Type u) := List Alphabet × List Alphabet × List Alphabet |
|
|
| def instanceWord (t : Template Alphabet) (i : ℕ) : List Alphabet := |
| t.1 ++ wordPower t.2.1 i ++ t.2.2 |
|
|
| lemma recognized_cover_height {M : Type uM2} [Monoid M] [Fintype M] |
| (T : FreeMonoid Alphabet →* M) (F : Set M) |
| (L : Language Alphabet) (hL : ∀ w, w ∈ L ↔ T (FreeMonoid.ofList w) ∈ F) |
| (templates : Finset (Template Alphabet)) |
| (hcover : ∀ w ∈ L, ∃ t ∈ templates, ∃ i, w = instanceWord t i) : |
| HasHeightAtMost L 1 := by |
| let component := fun t : Template Alphabet => accepted t.1 t.2.1 t.2.2 (fun i => |
| T (FreeMonoid.ofList t.1) * (T (FreeMonoid.ofList t.2.1)) ^ i * |
| T (FreeMonoid.ofList t.2.2) ∈ F) |
| have hc : ∀ t ∈ templates, HasHeightAtMost (component t) 1 := |
| fun t _ => recognized_template_height T F t.1 t.2.1 t.2.2 |
| have beq : ∀ t i, T (FreeMonoid.ofList (instanceWord t i)) = |
| T (FreeMonoid.ofList t.1) * (T (FreeMonoid.ofList t.2.1)) ^ i * |
| T (FreeMonoid.ofList t.2.2) := by |
| intro t i |
| simp only [instanceWord, wordPower, FreeMonoid.ofList_append, |
| FreeMonoid.ofList_toList, map_mul, map_pow] |
| have he : L = ⨆ t ∈ templates, component t := by |
| ext w |
| constructor |
| · intro hw |
| obtain ⟨t, ht, i, rfl⟩ := hcover w hw |
| refine Language.mem_iSup.mpr ⟨t, Language.mem_iSup.mpr ⟨ht, i, ?_, rfl⟩⟩ |
| change T (FreeMonoid.ofList t.1) * T (FreeMonoid.ofList t.2.1) ^ i * |
| T (FreeMonoid.ofList t.2.2) ∈ F |
| rw [← beq] |
| exact (hL _).mp hw |
| · intro hw |
| obtain ⟨t, hw⟩ := Language.mem_iSup.mp hw |
| obtain ⟨ht, i, hi, rfl⟩ := Language.mem_iSup.mp hw |
| apply (hL _).mpr |
| exact (beq t i).symm ▸ hi |
| rw [he] |
| exact HasHeightAtMost.finset_iSup templates component hc |
|
|
| lemma regular_cover_height (L : Language Alphabet) (hL : L.IsRegular) |
| (templates : Finset (Template Alphabet)) |
| (hcover : ∀ w ∈ L, ∃ t ∈ templates, ∃ i, w = instanceWord t i) : |
| HasHeightAtMost L 1 := by |
| obtain ⟨M, hM, hF, T, F, hT⟩ := FiniteRecognition.of_regular hL |
| exact recognized_cover_height T F L hT templates hcover |
|
|
| end PeriodicTemplates |
|
|
| end GeneralizedStarHeight |
|
|
| end OAI |
|
|
