File size: 5,638 Bytes
e5a97c6 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 | 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 <;> exact hh
have hs : S ∘ e=![S (e 0),S (e 1),S (e 2)] := by funext i; fin_cases i <;> rfl
have ht : T ∘ e=![T (e 0),T (e 1),T (e 2)] := by funext i; fin_cases i <;> rfl
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; fin_cases i <;> rfl
@[simp] lemma vector_p02 (A B C : List Bool) : ![A,B,C] ∘ p02=![C,B,A] := by
funext i; fin_cases i <;> rfl
@[simp] lemma vector_p12 (A B C : List Bool) : ![A,B,C] ∘ p12=![A,C,B] := by
funext i; fin_cases i <;> rfl
@[simp] lemma vector_p201 (A B C : List Bool) : ![A,B,C] ∘ p201=![C,A,B] := by
funext i; fin_cases i <;> rfl
@[simp] lemma vector_p120 (A B C : List Bool) : ![A,B,C] ∘ p120=![B,C,A] := by
funext i; fin_cases i <;> rfl
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; fin_cases i <;> simp
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; fin_cases i <;> simp
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
|