| import OAI.Computability.FourierTransform.DirectionalWords |
|
|
| namespace OAI |
| namespace PowerSaving.Binary |
| open Matrix Finset |
| noncomputable section |
| variable {α ρ σ : Type*} [Fintype α] [DecidableEq α] |
| [Fintype ρ] [DecidableEq ρ] [Fintype σ] [DecidableEq σ] |
|
|
| / |
| def covered (e : ρ ↪ σ) := univ.map e |
|
|
| omit [DecidableEq ρ] [Fintype σ] [DecidableEq σ] in |
| theorem cover_iff (e : ρ ↪ σ) (i : σ) : i ∈ covered e ↔ ∃ j, e j=i := by simp [covered] |
|
|
| private def src (e : ρ ↪ σ) {i : σ} (h : i∈covered e) : ρ := |
| Classical.choose ((cover_iff ..).mp h) |
|
|
| omit [DecidableEq ρ] [Fintype σ] [DecidableEq σ] in |
| private theorem src_spec (e : ρ ↪ σ) {i : σ} (h : i∈covered e) : |
| e (src e h) = i := Classical.choose_spec ((cover_iff e i).mp h) |
|
|
| omit [DecidableEq ρ] [Fintype σ] [DecidableEq σ] in |
| private theorem src_self (e : ρ ↪ σ) (i : ρ) (h : e i ∈ covered e) : |
| src e h = i := e.injective (src_spec e h) |
|
|
| def wide (e : ρ ↪ σ) (M : Matrix ρ ρ ℚ) : Matrix σ σ ℚ := |
| fun i j => if h : i∈covered e then if h' : j∈covered e then M (src e h) (src e h') else 0 |
| else if i=j then 1 else 0 |
|
|
| omit [DecidableEq ρ] [Fintype σ] in |
| theorem wide_both (e : ρ ↪ σ) (M : Matrix ρ ρ ℚ) (i j : ρ) : |
| wide e M (e i) (e j)=M i j := by simp [wide,src_self,covered] |
|
|
| omit [DecidableEq ρ] in |
| theorem wide_in (e : ρ ↪ σ) (M : Matrix ρ ρ ℚ) (i : ρ) (x : σ→ℂ) : |
| actPoint (wide e M) x (e i) = actPoint M (x ∘ e) i := by |
| unfold actPoint |
| rw [← Finset.sum_add_sum_compl (covered e)] |
| have hz : ∑ j ∈ (covered e)ᶜ, (wide e M (e i) j : ℂ) * x j = 0 := by |
| apply sum_eq_zero |
| intro j hj |
| replace hj := mem_compl.mp hj |
| have h : e i ∈ covered e := by simp [covered] |
| simp [wide,h,hj] |
| rw [hz, add_zero, covered, sum_map] |
| simp [wide_both] |
|
|
| omit [DecidableEq ρ] in |
| theorem wide_out (e : ρ ↪ σ) (M : Matrix ρ ρ ℚ) (x : σ→ℂ) {i : σ} (h : i ∉ covered e) : |
| actPoint (wide e M) x i = x i := by |
| unfold actPoint |
| rw [Finset.sum_eq_single i] |
| · simp [wide,h] |
| · intro j _ g; simp [wide,h, Ne.symm g] |
| · simp |
|
|
| def Move.over (e : ρ ↪ σ) : Move α ρ → Move α σ |
| | .localM M => .localM (wide e M) |
| | .dir r z nz => .dir (e r) z nz |
| | .shift r z => .shift (e r) z |
|
|
| theorem go_over (e : ρ ↪ σ) (m : Move α ρ) (f : ℕ) (x : Data α σ f) : |
| (m.over e |>.go f x) ∘ e = m.go f (x ∘ e) := by |
| funext i |
| cases m with |
| | localM M => |
| funext j; exact wide_in e M i _ |
| | dir => simp [Move.over,Move.go, Function.comp, roleAct] |
| | shift => simp [Move.over,Move.go, Function.comp, roleAct] |
|
|
| omit [DecidableEq ρ] in |
| theorem go_out (e : ρ ↪ σ) (m : Move α ρ) (f : ℕ) |
| (x : Data α σ f) {i : σ} (h : i ∉ covered e) : |
| ((m.over e).go f x) i = x i := by |
| have hh (j : ρ) : i ≠ e j := fun g => h ((cover_iff ..).2 ⟨j,g.symm⟩) |
| cases m with |
| | localM M => funext j; exact wide_out e M _ h |
| | dir => simp [Move.over,Move.go,roleAct, hh] |
| | shift => simp [Move.over,Move.go,roleAct, hh] |
|
|
| theorem walk_over (e : ρ ↪ σ) (p : PWord α ρ) (f : ℕ) (x : Data α σ f) : |
| walk f (p.map (Move.over e)) x ∘ e = walk f p (x ∘ e) := by |
| induction p generalizing x with |
| | nil => rfl |
| | cons m p ih => |
| change walk _ _ _ ∘ e = walk f p (m.go f (x∘e)) |
| rw [← go_over] |
| exact ih _ |
|
|
| omit [DecidableEq ρ] in |
| theorem walk_out (e : ρ ↪ σ) (p : PWord α ρ) (f : ℕ) (x : Data α σ f) |
| {i : σ} (h : i ∉ covered e) : |
| walk f (p.map (Move.over e)) x i = x i := by |
| induction p generalizing x with |
| | nil => rfl |
| | cons m p ih => |
| exact (ih _).trans (go_out e m f _ h) |
|
|
| namespace Path |
|
|
| theorem lift (e : ρ ↪ σ) (A : σ → OBase α) {s t : σ → Finset α} |
| {g : (σ→ℂ) → (σ→ℂ)} {h : (ρ→ℂ) → (ρ→ℂ)} {d : ℕ} |
| (q : Path (A ∘ e) (s ∘ e) (t ∘ e) h d) |
| (hin : ∀ x, (g x) ∘ e = h (x ∘ e)) (hout : ∀ x i, i∉covered e → g x i=x i) |
| (he : ∀ i, i∉covered e → s i = t i) : |
| Path A s t g d := by |
| obtain ⟨p,hp,ha⟩ := q |
| refine ⟨p.map (Move.over e),?_,?_⟩ |
| · have hm (s : σ → Finset α) : |
| mass s = mass (s ∘ e) + ∑ i ∈ (covered e)ᶜ, (s i).card := by |
| unfold mass |
| nth_rw 1 [← Finset.sum_add_sum_compl (covered e)] |
| rw [covered, sum_map] |
| rfl |
| have hh : ∑ i ∈ (covered e)ᶜ, (s i).card = ∑ i ∈ (covered e)ᶜ, (t i).card := by |
| apply sum_congr rfl; intro i hi; rw [he i (mem_compl.mp hi)] |
| rw [hm,hm,hh] |
| have ht : toll ∘ (Move.over (α:=α) e) = toll := funext (fun i => by cases i <;> rfl) |
| have hz : tally (p.map (Move.over e)) = tally p := by simp [tally,ht] |
| rw [hz]; omega |
| · intro f x |
| have frame_cont (s : σ → Finset α) (x : Data α σ f) : |
| withFrame A s f x ∘ e = withFrame (A∘e) (s∘e) f (x∘e) := rfl |
| have point_cont : |
| point f g x ∘ e = point f h (x ∘ e) := by |
| funext i j |
| exact congr_fun (hin _) i |
| funext i |
| by_cases hm : i∈covered e |
| · obtain ⟨j,rfl⟩ := (cover_iff ..).mp hm |
| exact congr_fun (show walk f _ _ ∘ e = withFrame A t f _ ∘ e by |
| rw [walk_over,frame_cont, ha,frame_cont,point_cont]) j |
| · rw [walk_out e p _ _ hm] |
| unfold withFrame multiAct |
| simp only [he i hm] |
| apply congrArg |
| funext j |
| exact (hout (fun r => x r j) i hm).symm |
|
|
| section Parallel |
|
|
| variable {J : Type*} [Fintype J] [DecidableEq J] |
|
|
| / |
| theorem parallel (e : J → ρ ↪ σ) |
| (dis : ∀ i j, i ≠ j → ∀ r ∈ covered (e i), r ∉ covered (e j)) |
| (A : σ → OBase α) {s t : σ → Finset α} {d : J → ℕ} |
| {g : (σ→ℂ)→(σ→ℂ)} {h : J → (ρ→ℂ) → (ρ→ℂ)} |
| (q : ∀ i, Path (A ∘ e i) (s ∘ e i) (t ∘ e i) (h i) (d i)) |
| (hin : ∀ i x, (g x) ∘ e i = h i (x ∘ e i)) |
| (hout : ∀ x r, (∀ i, r∉covered (e i)) → g x r=x r) |
| (he : ∀ r, (∀ i, r∉covered (e i)) → s r=t r) : |
| Path A s t g (∑ i, d i) := by |
| let u (j : Finset J) := j.biUnion fun i => covered (e i) |
| let l (j : Finset J) (r : σ) := if r∈u j then t r else s r |
| let k (j : Finset J) (x : σ→ℂ) (r : σ) := if r∈u j then g x r else x r |
| have hh (j : Finset J) : Path A s (l j) (k j) (∑ i ∈ j, d i) := by |
| induction j using Finset.induction with |
| | empty => |
| simp only [k,l,u,biUnion_empty,notMem_empty,ite_false,sum_empty] |
| exact Path.refl |
| | insert i j hi ih => |
| have hiu (r) (hr : r∈covered (e i)) : r ∉ u j := by |
| intro hg |
| obtain ⟨w,hw,he'⟩ := mem_biUnion.mp hg |
| have hw' : i ≠ w := fun hh => hi (hh ▸ hw) |
| exact dis _ _ hw' r hr he' |
| have hui (r) : r∈u (insert i j) ↔ r∈covered (e i) ∨ r∈u j := by |
| simp [u] |
| let fn (x : σ→ℂ) (r : σ) := if r∈covered (e i) then g x r else x r |
| have compi (x) : fn x ∘ e i = h i (x∘e i) := by |
| rw [← hin] |
| funext j; simp [fn,covered] |
| have gg : Path A (l j) (l (insert i j)) fn (d i) := by |
| apply Path.lift (e i) A (h:=h i) _ compi |
| · intro x l hl; simp [fn,hl] |
| · intro r hr; simp [l,hui,hr] |
| · have eq1 : l j ∘ e i = s ∘ e i := by |
| funext r |
| have h : e i r ∈ covered (e i) := by simp [covered] |
| simp [l, hiu _ h] |
| have eq2 : l (insert i j) ∘ e i = t ∘ e i := by |
| funext r |
| have h : e i r ∈ covered (e i) := by simp [covered] |
| simp [l,hui,h] |
| rw [eq1,eq2]; apply q |
| have cmp : fn ∘ k j = k (insert i j) := by |
| funext x r |
| by_cases hqr : r ∈ covered (e i) |
| · obtain ⟨r,rfl⟩ := (cover_iff ..).mp hqr |
| change fn (k j x) _ = _ |
| have eq : k j x ∘ e i = x ∘ e i := by |
| funext r |
| have h : e i r ∈ covered (e i) := by simp [covered] |
| simp [k,hiu _ h] |
| have H := congr_fun (show fn (k j x) ∘ e i = g x ∘ e i by rw [compi,eq,hin]) r |
| exact H.trans (by simp [k,hui,hqr]) |
| · simp [Function.comp,k,fn,hui,hqr] |
| rw [sum_insert hi,add_comm] |
| rw [← cmp] |
| exact ih.trans gg |
| have ha (r) : r∉u univ ↔ ∀ i, r∉covered (e i) := by simp [u] |
| have eq1 : l univ = t := by |
| funext r; by_cases h : r∈u univ |
| · simp [l,h] |
| · simp [l,h,he r ((ha r).1 h)] |
| have eq2 : k univ = g := by |
| funext x r; by_cases h : r∈u univ |
| · simp [k,h] |
| · simp [k,h,hout x r ((ha r).1 h)] |
| have H := hh univ |
| rwa [eq1,eq2] at H |
|
|
| end Parallel |
| end Path |
| end |
| end PowerSaving.Binary |
|
|
| end OAI |
|
|
