| import OAI.Computability.FourierCircuit.CircuitCost |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| open scoped Kronecker |
| namespace ExactFourier |
| namespace CircuitCost |
| variable {α β γ : Type} [Fintype α] [Fintype β] [Fintype γ] |
| [DecidableEq α] [DecidableEq β] [DecidableEq γ] |
|
|
| theorem tensor_comm (M : Matrix α α ℂ) (N : Matrix β β ℂ) : cost (M⊗ₖN)=cost (N⊗ₖM) := by |
| have he : Matrix.reindex (Equiv.prodComm α β) (Equiv.prodComm α β) (M⊗ₖN)=N⊗ₖM := by |
| ext i j; exact mul_comm _ _ |
| rw [← he,cost_reindex] |
|
|
| theorem tensor_assoc (M : Matrix α α ℂ) (N : Matrix β β ℂ) (P : Matrix γ γ ℂ) : |
| cost ((M⊗ₖN)⊗ₖP)=cost (M⊗ₖ(N⊗ₖP)) := by |
| have he : Matrix.reindex (Equiv.prodAssoc α β γ) (Equiv.prodAssoc α β γ) ((M⊗ₖN)⊗ₖP)=M⊗ₖ(N⊗ₖP) := by |
| ext i j; exact mul_assoc _ _ _ |
| rw [← he,cost_reindex] |
|
|
| theorem tensor_sum (M : Matrix α α ℂ) (N : Matrix β β ℂ) (P : Matrix γ γ ℂ) : |
| cost (Matrix.fromBlocks M 0 0 N⊗ₖP)≤cost (M⊗ₖP)+cost (N⊗ₖP) := by |
| have he : Matrix.reindex (Equiv.sumProdDistrib α β γ) (Equiv.sumProdDistrib α β γ) |
| (Matrix.fromBlocks M 0 0 N⊗ₖP)=Matrix.fromBlocks (M⊗ₖP) 0 0 (N⊗ₖP) := by |
| ext i j; cases i <;> cases j <;> simp [Matrix.reindex_apply,Equiv.sumProdDistrib] |
| rw [← cost_reindex (Equiv.sumProdDistrib α β γ),he] |
| exact cost_sum _ _ |
|
|
| theorem tensor_one_le (M : Matrix α α ℂ) : cost (M⊗ₖ(1 : Matrix β β ℂ))≤Fintype.card β*cost M := by |
| simpa using cost_tensor M (1 : Matrix β β ℂ) |
|
|
| theorem tensor_punit (M : Matrix α α ℂ) : cost (M⊗ₖ(1 : Matrix PUnit PUnit ℂ))=cost M := by |
| have he : Matrix.reindex (Equiv.prodPUnit α) (Equiv.prodPUnit α) (M⊗ₖ(1 : Matrix PUnit PUnit ℂ))=M := by |
| ext i j; simp [Matrix.reindex_apply] |
| exact (cost_reindex (Equiv.prodPUnit α) _).symm.trans (congrArg cost he) |
|
|
| theorem tensor_exchange (M : Matrix α α ℂ) (N : Matrix β β ℂ) (P : Matrix γ γ ℂ) : |
| cost ((M⊗ₖN)⊗ₖP)=cost ((M⊗ₖP)⊗ₖN) := by |
| let e : ((α×β)×γ)≃((α×γ)×β) := |
| ((Equiv.prodAssoc α β γ).trans ((Equiv.refl α).prodCongr (Equiv.prodComm β γ))).trans (Equiv.prodAssoc α γ β).symm |
| have he : Matrix.reindex e e ((M⊗ₖN)⊗ₖP)=(M⊗ₖP)⊗ₖN := by |
| ext i j |
| change (M i.1.1 j.1.1*N i.2 j.2)*P i.1.2 j.1.2=(M i.1.1 j.1.1*P i.1.2 j.1.2)*N i.2 j.2 |
| ring |
| exact (cost_reindex e _).symm.trans (congrArg cost he) |
|
|
| end CircuitCost |
|
|
| namespace TensorAxis |
| variable {α : Type} [Fintype α] [DecidableEq α] |
| def funCoordinates : (k : ℕ)→Space α k≃(Fin k→α) |
| | 0 => {toFun:=fun _ i=>Fin.elim0 i,invFun:=fun _=>PUnit.unit, |
| left_inv:=by intro x; cases x; rfl,right_inv:=by intro x; funext i; exact Fin.elim0 i} |
| | k+1 => {toFun:=fun z=>Fin.snoc (funCoordinates k z.1) z.2, |
| invFun:=fun f=>((funCoordinates k).symm (Fin.init f),f (Fin.last k)), |
| left_inv:=by rintro ⟨x,y⟩; simp, |
| right_inv:=by intro f; simp} |
|
|
| theorem power_entries |
| {α : Type} [Fintype α] [DecidableEq α] (M : Matrix α α ℂ) (k : ℕ) (x y : Space α k) : |
| power M k x y=∏ i : Fin k,M (funCoordinates (α := α) k x i) (funCoordinates (α := α) k y i) := by |
| induction k with |
| | zero => simp [power,funCoordinates] |
| | succ k ih => |
| change power M k x.1 y.1*M x.2 y.2=_ |
| rw [Fin.prod_univ_castSucc,ih] |
| simp [funCoordinates] |
|
|
| theorem power_fun_reindex (M : Matrix α α ℂ) (k : ℕ) : |
| Matrix.reindex (funCoordinates (α := α) k) (funCoordinates (α := α) k) (power M k)= |
| fun x y=>∏i,M (x i) (y i) := by |
| ext x y |
| simp [Matrix.reindex_apply,power_entries] |
|
|
| / |
| def appendCoordinates (k : ℕ) : (l : ℕ)→Space α (k+l)≃(Space α k×Space α l) |
| | 0 => (Equiv.prodPUnit _).symm |
| | l+1 => ((appendCoordinates k l).prodCongr (Equiv.refl α)).trans (Equiv.prodAssoc _ _ _) |
|
|
| theorem power_append |
| {α : Type} [Fintype α] [DecidableEq α] (M : Matrix α α ℂ) (k l : ℕ) : |
| Matrix.reindex (appendCoordinates (α := α) k l) (appendCoordinates (α := α) k l) (power M (k+l))= |
| power M k⊗ₖpower M l := by |
| induction l with |
| | zero => ext i j; simp [appendCoordinates,power,Matrix.reindex_apply] |
| | succ l ih => |
| ext i j |
| change power M (k+l) ((appendCoordinates (α := α) k l).symm (i.1,i.2.1)) |
| ((appendCoordinates (α := α) k l).symm (j.1,j.2.1))*M i.2.2 j.2.2=_ |
| have h := congrFun (congrFun ih (i.1,i.2.1)) (j.1,j.2.1) |
| dsimp [Matrix.reindex_apply] at h |
| rw [h] |
| exact mul_assoc _ _ _ |
|
|
| theorem power_reindex {β : Type} [Fintype β] [DecidableEq β] (e : α≃β) (M : Matrix α α ℂ) (k : ℕ) : |
| ∃ f : Space α k≃Space β k,Matrix.reindex f f (power M k)=power (Matrix.reindex e e M) k := by |
| induction k with |
| | zero => exact ⟨Equiv.refl _,rfl⟩ |
| | succ k ih => |
| obtain ⟨f,hf⟩ := ih |
| refine ⟨f.prodCongr e,?_⟩ |
| change Matrix.reindex (f.prodCongr e) (f.prodCongr e) (Matrix.kronecker (power M k) M)=_ |
| rw [ExactFourier.reindex_tensor,hf] |
| rfl |
| end TensorAxis |
| end ExactFourier |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| namespace ExactFourier.Amplification |
| / |
| def avg (p : ℝ) (f : ℕ→ℝ) : ℕ→ℕ→ℝ |
| | 0,r => f r |
| | j+1,r => p*avg p f j (r+1)+(1-p)*avg p f j r |
|
|
| theorem avg_mono {p : ℝ} (hp : 0≤p) (hp1 : p≤1) (f g : ℕ→ℝ) (j r : ℕ) |
| (h : ∀ i, r ≤ i → i ≤ r+j → f i ≤ g i) : avg p f j r≤avg p g j r := by |
| induction j generalizing r with |
| | zero => exact h r le_rfl (by omega) |
| | succ j ih => |
| dsimp only [avg] |
| apply add_le_add |
| · apply mul_le_mul_of_nonneg_left _ hp |
| apply ih (r+1) |
| intro i hi hj; exact h i (by omega) (by omega) |
| · apply mul_le_mul_of_nonneg_left _ (by linarith) |
| apply ih r |
| intro i hi hj; exact h i hi (by omega) |
|
|
| theorem avg_const_mul (p C : ℝ) (f : ℕ→ℝ) (j r : ℕ) : |
| avg p (fun i=>C*f i) j r=C*avg p f j r := by |
| induction j generalizing r with |
| | zero => rfl |
| | succ j ih => simp only [avg,ih]; ring |
|
|
| theorem avg_rpow {p a : ℝ} (hp : 0≤p) (hp1 : p≤1) (ha : 0≤a) (ha1 : a≤1) (j r : ℕ) : |
| avg p (fun i=>(i+1 : ℝ)^a) j r≤((r : ℝ)+p*j+1)^a := by |
| induction j generalizing r with |
| | zero => simp [avg] |
| | succ j ih => |
| have hc := (Real.concaveOn_rpow ha ha1).2 |
| (show (r+1 : ℝ)+p*j+1∈Set.Ici (0:ℝ) from (show (0:ℝ) ≤ (r+1 : ℝ)+p*j+1 by positivity)) |
| (show (r : ℝ)+p*j+1∈Set.Ici (0:ℝ) from (show (0:ℝ) ≤ (r : ℝ)+p*j+1 by positivity)) |
| hp (show 0≤1-p by linarith) (by ring : p+(1-p)=1) |
| simp only [smul_eq_mul] at hc |
| have he : p*((r+1 : ℝ)+p*j+1)+(1-p)*((r : ℝ)+p*j+1)=(r : ℝ)+p*(j+1)+1 := by ring |
| rw [he] at hc |
| dsimp only [avg] |
| have h1 := mul_le_mul_of_nonneg_left (ih (r+1)) hp |
| have h2 := mul_le_mul_of_nonneg_left (ih r) (show 0≤1-p by linarith) |
| push_cast at h1 ⊢ |
| exact (add_le_add h1 h2).trans hc |
| end ExactFourier.Amplification |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| open scoped Kronecker |
| namespace ExactFourier.Amplification |
| open CircuitCost TensorAxis |
|
|
| def sectorCost (l : ℕ→ℕ) (s : ℕ) : ℕ→ℕ→ℕ |
| | 0,r => l r |
| | j+1,r => sectorCost l s j (r+1)+s*sectorCost l s j r |
|
|
| variable {α δ : Type} [Fintype α] [Fintype δ] [DecidableEq α] [DecidableEq δ] |
|
|
| theorem cost_sectors (A : Matrix α α ℂ) (j r : ℕ) : |
| cost (power (Matrix.fromBlocks A 0 0 (1 : Matrix δ δ ℂ)) j⊗ₖpower A r)≤ |
| sectorCost (fun k=>cost (power A k)) (Fintype.card δ) j r := by |
| induction j generalizing r with |
| | zero => |
| change cost ((1 : Matrix PUnit PUnit ℂ)⊗ₖpower A r)≤_ |
| rw [tensor_comm,tensor_punit] |
| rfl |
| | succ j ih => |
| let B := Matrix.fromBlocks A 0 0 (1 : Matrix δ δ ℂ) |
| change cost ((power B j⊗ₖB)⊗ₖpower A r)≤_ |
| rw [tensor_exchange,tensor_comm] |
| have h := tensor_sum A (1 : Matrix δ δ ℂ) (power B j⊗ₖpower A r) |
| rw [tensor_comm A _,tensor_assoc,tensor_comm (1 : Matrix δ δ ℂ) _] at h |
| have h1 := ih (r+1) |
| have h2 := (tensor_one_le (β := δ) (power B j⊗ₖpower A r)).trans |
| (Nat.mul_le_mul_left (Fintype.card δ) (ih r)) |
| exact h.trans (Nat.add_le_add h1 h2) |
|
|
| theorem cost_call_power (A : Matrix α α ℂ) (e : α ↪ δ) (j : ℕ) : |
| cost (power (Embedded.matrix e A) j)≤ |
| sectorCost (fun k=>cost (power A k)) (Fintype.card (Embedded.complement e)) j 0 := by |
| obtain ⟨f,hf⟩ := power_reindex (Embedded.coordinates e) |
| (Matrix.fromBlocks A 0 0 (1 : Matrix (Embedded.complement e) (Embedded.complement e) ℂ)) j |
| have h := cost_sectors (δ := Embedded.complement e) A j 0 |
| rw [power,tensor_punit] at h |
| change cost (power (Matrix.reindex (Embedded.coordinates e) (Embedded.coordinates e) _) j) ≤ _ |
| rw [← hf,cost_reindex] |
| exact h |
|
|
| theorem sectorCost_avg (l : ℕ→ℕ) {q s : ℕ} (hq : 0<q) (j r : ℕ) : |
| (sectorCost l s j r : ℝ)=(q : ℝ)^r*(q+s : ℝ)^j * |
| avg ((q : ℝ)/(q+s)) (fun i=>(l i : ℝ)/(q : ℝ)^i) j r := by |
| have hq' : (q : ℝ)≠0 := by positivity |
| have hQ : (q+s : ℝ)≠0 := by positivity |
| induction j generalizing r with |
| | zero => simp only [sectorCost,avg,pow_zero,mul_one]; field_simp |
| | succ j ih => |
| simp only [sectorCost,Nat.cast_add,Nat.cast_mul,ih,avg,pow_succ] |
| field_simp |
| ring |
| end ExactFourier.Amplification |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| open scoped Kronecker |
| namespace ExactFourier |
| namespace TensorAxis |
| variable {α : Type} [Fintype α] [DecidableEq α] |
| theorem power_group (A : Matrix α α ℂ) (b j : ℕ) : |
| ∃ e : Space α (b*j)≃Space (Space α b) j, |
| Matrix.reindex e e (power A (b*j))=power (power A b) j := by |
| induction j with |
| | zero => exact ⟨Equiv.refl _,rfl⟩ |
| | succ j ih => |
| obtain ⟨e,he⟩ := ih |
| rw [Nat.mul_succ] |
| refine ⟨(appendCoordinates (α := α) (b*j) b).trans (e.prodCongr (Equiv.refl _)),?_⟩ |
| rw [← reindex_comp,power_append] |
| change Matrix.reindex (e.prodCongr (Equiv.refl _)) (e.prodCongr (Equiv.refl _)) |
| (Matrix.kronecker (power A (b*j)) (power A b))=_ |
| rw [reindex_tensor,he] |
| rfl |
|
|
| theorem power_monomial (A : Matrix α α ℂ) (hA : MonomialMatrix A) (j : ℕ) : |
| MonomialMatrix (power A j) := by |
| induction j with |
| | zero => exact MonomialMatrix.one |
| | succ j ih => exact ih.tensor hA |
|
|
| theorem source_power_reindex {q : ℕ} (A : Matrix (Fin q) (Fin q) ℂ) (b : ℕ) : |
| Matrix.reindex ((funCoordinates (α := Fin q) b).trans (tensorCoordinates q b).symm) |
| ((funCoordinates (α := Fin q) b).trans (tensorCoordinates q b).symm) (power A b)=tensorPower A b := by |
| rw [← reindex_comp,power_fun_reindex] |
| ext i j |
| rfl |
| end TensorAxis |
|
|
| namespace Amplification |
| open CircuitCost TensorAxis |
|
|
| theorem cost_source_power {q : ℕ} (A : Matrix (Fin q) (Fin q) ℂ) (b : ℕ) : |
| cost (tensorPower A b)=cost (power A b) := by |
| rw [← source_power_reindex,cost_reindex] |
|
|
| theorem cost_group {α : Type} [Fintype α] [DecidableEq α] (A : Matrix α α ℂ) (b j : ℕ) : |
| cost (power A (b*j))=cost (power (power A b) j) := by |
| obtain ⟨e,he⟩ := power_group A b j |
| rw [← he,cost_reindex] |
|
|
| theorem cost_reindexed_power {α β : Type} [Fintype α] [Fintype β] [DecidableEq α] [DecidableEq β] |
| (e : α≃β) (A : Matrix α α ℂ) (j : ℕ) : |
| cost (power (Matrix.reindex e e A) j)=cost (power A j) := by |
| obtain ⟨f,hf⟩ := power_reindex e A j |
| rw [← hf,cost_reindex] |
|
|
| theorem complement_card {q Q : ℕ} (e : Fin q↪Fin Q) : Fintype.card (Embedded.complement e)=Q-q := by |
| have hh := Fintype.card_congr (Embedded.coordinates e) |
| simp only [Fintype.card_sum,Fintype.card_fin] at hh |
| omega |
|
|
| theorem cost_word_power {q Q : ℕ} (A : Matrix (Fin q) (Fin q) ℂ) |
| (W : List (WordStep A Q)) (j : ℕ) : |
| cost (power (wordMatrix W) j)≤W.length*Q^j+ |
| wordCalls W*sectorCost (fun k=>cost (power A k)) (Q-q) j 0 := by |
| induction W with |
| | nil => simp [wordMatrix,wordCalls] |
| | cons s W ih => |
| have he : wordMatrix (s::W)=wordMatrix W*s.matrix := by |
| simp [wordMatrix,List.prod_append] |
| rw [he,← mul_power] |
| have h := cost_mul (power (wordMatrix W) j) (power s.matrix j) |
| apply h.trans |
| cases s with |
| | monomial M hM => |
| have hm := cost_monomial (power M j) (power_monomial M hM j) |
| simp only [card_space,Fintype.card_fin] at hm |
| simp only [WordStep.matrix] at h ⊢ |
| simp only [List.length_cons,wordCalls,List.map_cons,List.sum_cons,WordStep.calls,zero_add] |
| change _≤(W.length+1)*Q^j+wordCalls W*sectorCost _ _ _ _ |
| nlinarith |
| | call e => |
| have hc := cost_call_power A e j |
| rw [complement_card] at hc |
| simp only [WordStep.matrix,Packing.embeddedCall_eq] |
| simp only [List.length_cons,wordCalls,List.map_cons,List.sum_cons,WordStep.calls] |
| change _≤(W.length+1)*Q^j+(1+wordCalls W)*sectorCost _ _ _ _ |
| exact (Nat.add_le_add ih hc).trans (by simp only [Nat.add_mul,one_mul]; omega) |
| end Amplification |
| end ExactFourier |
|
|
| end |
| end |
|
|
| section |
| noncomputable section |
| open scoped Kronecker |
| namespace ExactFourier.Amplification |
| open CircuitCost TensorAxis |
|
|
| def normalizedCost {q : ℕ} (A : Matrix (Fin q) (Fin q) ℂ) (k : ℕ) : ℝ := |
| (cost (power A k) : ℝ)/(q : ℝ)^k |
|
|
| theorem normalized_add {q : ℕ} (hq : 0<q) (A : Matrix (Fin q) (Fin q) ℂ) (k l : ℕ) : |
| normalizedCost A (k+l)≤normalizedCost A k+normalizedCost A l := by |
| have hqR : (q : ℝ) ≠ 0 := by positivity |
| have hc := cost_tensor (power A k) (power A l) |
| rw [← power_append, cost_reindex] at hc |
| simp only [card_space,Fintype.card_fin] at hc |
| have hcR : (cost (power A (k+l)) : ℝ) ≤ |
| (q : ℝ)^l*(cost (power A k) : ℝ)+(q : ℝ)^k*(cost (power A l) : ℝ) := by exact_mod_cast hc |
| dsimp only [normalizedCost] |
| rw [div_le_iff₀ (by positivity : (0 : ℝ)<(q : ℝ)^(k+l))] |
| have he : (cost (power A k) / (q : ℝ)^k + cost (power A l) / (q : ℝ)^l) * (q : ℝ)^(k+l) = |
| (q : ℝ)^l*cost (power A k)+(q : ℝ)^k*cost (power A l) := by |
| rw [pow_add]; field_simp |
| rw [he] |
| exact hcR |
|
|
| theorem normalized_linear {q : ℕ} (hq : 0<q) (A : Matrix (Fin q) (Fin q) ℂ) (k : ℕ) : |
| normalizedCost A k≤2*q*k := by |
| have hc := cost_le (power A k) (TypedDAG.tensorPower A k) (TypedDAG.eval_tensorPower A k) |
| rw [TypedDAG.size_tensorPower,Fintype.card_fin] at hc |
| have hcR : (cost (power A k) : ℝ)≤2*q*k*(q : ℝ)^k := by exact_mod_cast hc |
| exact (div_le_iff₀ (by positivity : (0 : ℝ)<(q : ℝ)^k)).mpr hcR |
|
|
| theorem normalized_word {q b : ℕ} (hq : 0<q) (A : Matrix (Fin q) (Fin q) ℂ) |
| (hb : 1≤b) (W : List (WordStep A (q^b))) (hW : wordMatrix W=tensorPower A b) (j : ℕ) : |
| normalizedCost A (b*j) ≤ W.length+(wordCalls W : ℝ)* |
| avg ((q : ℝ)/(q^b : ℕ)) (normalizedCost A) j 0 := by |
| have hqQ : q≤q^b := Nat.le_self_pow (by omega : b≠0) q |
| have hc := cost_word_power A W j |
| rw [hW,← source_power_reindex,cost_reindexed_power,← cost_group] at hc |
| have he : q+(q^b-q)=q^b := by omega |
| have ha := sectorCost_avg (fun k=>cost (power A k)) (s := q^b-q) hq j 0 |
| simp only [pow_zero,one_mul] at ha |
| have heR : (q : ℝ)+(q^b-q : ℕ)=(q^b : ℕ) := by exact_mod_cast he |
| rw [heR] at ha |
| have hcR : (cost (power A (b*j)) : ℝ)≤W.length*((q^b : ℕ) : ℝ)^j+ |
| (wordCalls W : ℝ)*(sectorCost (fun k=>cost (power A k)) (q^b-q) j 0 : ℝ) := by exact_mod_cast hc |
| rw [ha] at hcR |
| change (cost (power A (b*j)) : ℝ)/(q : ℝ)^(b*j) ≤ |
| W.length+(wordCalls W : ℝ)*avg ((q : ℝ)/(q^b : ℕ)) |
| (fun i => (cost (power A i) : ℝ)/(q : ℝ)^i) j 0 |
| rw [div_le_iff₀ (by positivity : (0 : ℝ)<(q : ℝ)^(b*j))] |
| push_cast at hcR ⊢ |
| rw [pow_mul] |
| nlinarith only [hcR] |
|
|
| theorem normalized_recurrence {q b : ℕ} (hq : 0<q) (A : Matrix (Fin q) (Fin q) ℂ) |
| (hb : 1≤b) (W : List (WordStep A (q^b))) (hW : wordMatrix W=tensorPower A b) (k : ℕ) : |
| normalizedCost A k ≤ (W.length+2*q*b : ℝ)+(wordCalls W : ℝ)* |
| avg ((q : ℝ)/(q^b : ℕ)) (normalizedCost A) (k/b) 0 := by |
| have hsum := normalized_add hq A (b*(k/b)) (k%b) |
| rw [Nat.mul_comm b (k/b),Nat.div_add_mod'] at hsum |
| rw [Nat.mul_comm (k/b) b] at hsum |
| have hw := normalized_word hq A hb W hW (k/b) |
| have hr := normalized_linear hq A (k%b) |
| have hmod : ((k%b : ℕ) : ℝ)≤b := by exact_mod_cast (Nat.mod_lt k (by omega : 0<b)).le |
| have hn : (0 : ℝ)≤2*q := by positivity |
| nlinarith |
| end ExactFourier.Amplification |
|
|
| end |
| end |
|
|
| end OAI |
|
|
