| import Mathlib |
| import OAI.Combinatorics.MatchingCount.Machines.RegisterProc |
|
|
| namespace OAI |
|
|
| namespace MatchingFPRAS.RegisterProc |
| open Turing MachineCost TreeData |
|
|
| lemma exec_perm (P : Proc (Fin 3)) (e : Fin 3 ≃ Fin 3) (S T : Stack (Fin 3)) |
| (n : ℕ) (h : Exec P (S ∘ e) (T ∘ e) n) : Exec (reindex P e.toEmbedding) S T n := by |
| have hf (S : Stack (Fin 3)) : frame e.toEmbedding (S (e 0)) (S (e 1)) (S (e 2)) S=S := by |
| funext j |
| obtain ⟨i,rfl⟩:=e.surjective j |
| have hh:=StackEmbedding.extend_on e.toEmbedding ![S (e 0),S (e 1),S (e 2)] S i |
| fin_cases i < |
| have hs : S ∘ e=![S (e 0),S (e 1),S (e 2)] := by funext i |
| have ht : T ∘ e=![T (e 0),T (e 1),T (e 2)] := by funext i |
| rw [hs,ht] at h |
| have hh:=exec_reindex P e.toEmbedding S _ _ _ _ _ _ n h |
| rw [hf] at hh |
| have hf' : frame e.toEmbedding (T (e 0)) (T (e 1)) (T (e 2)) S=T := by |
| funext j |
| obtain ⟨i,rfl⟩:=e.surjective j |
| have he:=StackEmbedding.extend_on e.toEmbedding ![T (e 0),T (e 1),T (e 2)] S i |
| fin_cases i <;> exact he |
| rwa [hf'] at hh |
|
|
| def p02 : Fin 3 ≃ Fin 3 := Equiv.swap 0 2 |
| def p01 : Fin 3 ≃ Fin 3 := Equiv.swap 0 1 |
| def p12 : Fin 3 ≃ Fin 3 := Equiv.swap 1 2 |
| def p201 : Fin 3 ≃ Fin 3 := p02.trans p01 |
|
|
| def p120 : Fin 3 ≃ Fin 3 := p201.symm |
| @[simp] lemma vector_p01 (A B C : List Bool) : ![A,B,C] ∘ p01=![B,A,C] := by |
| funext i |
| @[simp] lemma vector_p02 (A B C : List Bool) : ![A,B,C] ∘ p02=![C,B,A] := by |
| funext i |
| @[simp] lemma vector_p12 (A B C : List Bool) : ![A,B,C] ∘ p12=![A,C,B] := by |
| funext i |
| @[simp] lemma vector_p201 (A B C : List Bool) : ![A,B,C] ∘ p201=![C,A,B] := by |
| funext i |
| @[simp] lemma vector_p120 (A B C : List Bool) : ![A,B,C] ∘ p120=![B,C,A] := by |
| funext i |
|
|
| def reverse02 : Proc (Fin 3) := reindex reverseRaw p12.toEmbedding |
| def reverse10 : Proc (Fin 3) := reindex reverseRaw p01.toEmbedding |
| def reverse20 : Proc (Fin 3) := reindex reverseRaw p201.toEmbedding |
| def reverse21 : Proc (Fin 3) := reindex reverseRaw p02.toEmbedding |
| lemma reverse02_exec (A B C : List Bool) : |
| Exec reverse02 ![A,B,C] ![[],B,A.reverse++C] (A.length+1) := by |
| apply exec_perm |
| simpa only [vector_p12] using reverseRaw_exec A C B |
| lemma reverse10_exec (A B C : List Bool) : |
| Exec reverse10 ![A,B,C] ![B.reverse++A,[],C] (B.length+1) := by |
| apply exec_perm |
| simpa only [vector_p01] using reverseRaw_exec B A C |
| lemma reverse20_exec (A B C : List Bool) : |
| Exec reverse20 ![A,B,C] ![C.reverse++A,B,[]] (C.length+1) := by |
| apply exec_perm |
| simpa only [vector_p201] using reverseRaw_exec C A B |
| lemma reverse21_exec (A B C : List Bool) : |
| Exec reverse21 ![A,B,C] ![A,C.reverse++B,[]] (C.length+1) := by |
| apply exec_perm |
| simpa only [vector_p02] using reverseRaw_exec C B A |
|
|
| def finishCons : Proc (Fin 3) := atom (.push 0 (fun _=>false) (.push 1 (fun _=>true) .halt)) |
| lemma finishCons_exec (A : List Bool) : Exec finishCons ![[],A,[]] ![[false],true::A,[]] 1 := by |
| apply exec_atom |
| simp only [TM2.stepAux] |
| congr 1 |
| funext i |
|
|
| def cons : Proc (Fin 3) := seq reverse02 (seq reverse21 finishCons) |
| lemma cons_exec (x y : Data) : |
| Exec cons ![encode x,encode y,[]] ![encode .nil,encode (.cons x y),[]] |
| (2*(encode x).length+3) := by |
| have h₁:=reverse02_exec (encode x) (encode y) [] |
| have h₂:=reverse21_exec [] (encode y) (encode x).reverse |
| simp only [List.append_nil,List.reverse_reverse,List.length_reverse] at h₁ h₂ |
| have hh:=h₁.seq (h₂.seq (finishCons_exec (encode x++encode y))) |
| exact hh.mono (by omega) |
|
|
| def clear1 : Proc (Fin 3) := reindex clearRaw p01.toEmbedding |
| lemma clear1_exec (A B C : List Bool) : Exec clear1 ![A,B,C] ![A,[],C] (B.length+1) := by |
| apply exec_perm |
| simpa only [vector_p01] using clearRaw_exec B A C |
|
|
| def copy : Proc (Fin 3) := seq clear1 (seq duplicateRaw (seq reverse10 reverse21)) |
| lemma copy_exec (A B : List Bool) : Exec copy ![A,B,[]] ![A,A,[]] |
| (B.length+3*A.length+4) := by |
| have h₁:=clear1_exec A B [] |
| have h₂:=duplicateRaw_exec A [] [] |
| have h₃:=reverse10_exec [] A.reverse A.reverse |
| have h₄:=reverse21_exec A [] A.reverse |
| simp only [List.reverse_reverse,List.append_nil,List.length_reverse] at h₂ h₃ h₄ |
| have hh:=h₁.seq (h₂.seq (h₃.seq h₄)) |
| exact hh.mono (by omega) |
|
|
| def startSplit : Proc (Fin 3) := atom (.pop 1 (fun v _=>v) (.push 0 (fun _=>false) .halt)) |
| lemma startSplit_exec (A : List Bool) : Exec startSplit ![[],true::A,[]] ![[false],A,[]] 1 := by |
| apply exec_atom |
| simp only [TM2.stepAux] |
| congr 1 |
| funext i |
| def transfer12 : Proc (Fin 3) := reindex transferRaw p120.toEmbedding |
| lemma transfer12_exec (x : Data) (A B : List Bool) : |
| Exec transfer12 ![[false],encode x++A,B] ![[],A,(encode x).reverse++B] |
| ((encode x).length+1) := by |
| apply exec_perm |
| simpa only [vector_p120] using transferRaw_exec x A B |
| |
| def split : Proc (Fin 3) := seq clearRaw (seq startSplit (seq transfer12 reverse20)) |
| lemma split_exec (A : List Bool) (x y : Data) : |
| Exec split ![A,encode (.cons x y),[]] ![encode x,encode y,[]] |
| (A.length+2*(encode x).length+4) := by |
| have h₁:=clearRaw_exec A (encode (.cons x y)) [] |
| have h₂:=startSplit_exec (encode x++encode y) |
| have h₃:=transfer12_exec x (encode y) [] |
| have h₄:=reverse20_exec [] (encode y) (encode x).reverse |
| simp only [List.reverse_reverse,List.append_nil,List.length_reverse] at h₃ h₄ |
| have hh:=h₁.seq (h₂.seq (h₃.seq h₄)) |
| exact hh.mono (by omega) |
| end MatchingFPRAS.RegisterProc |
|
|
| end OAI |
|
|
