| import Mathlib |
| import OAI.Probability.ParisiFinite.RestrictLeft |
|
|
| namespace OAI |
|
|
| /-! Cost State. -/ |
|
|
| noncomputable section |
|
|
| open scoped BigOperators Matrix Topology |
| open MeasureTheory ProbabilityTheory Filter |
| open scoped BigOperators ComplexConjugate |
| open MeasureTheory ProbabilityTheory |
| namespace SKQAOA |
|
|
| def costState (n : ℕ) (J : Disorder n) (γ : ℝ) : State n := |
| (evolution γ (cost n J)).mulVec (plus n) |
|
|
| theorem costState_apply (n : ℕ) (J : Disorder n) (γ : ℝ) (σ : Configuration n) : |
| costState n J γ σ = Complex.exp (-(γ : ℂ) * Complex.I * (hamiltonian n J σ : ℂ)) * |
| ((Real.sqrt ((2 : ℝ)^n))⁻¹ : ℝ) := by |
| simp [costState, cost_evolution_eq_diagonal, Matrix.mulVec_diagonal, plus] |
|
|
| theorem plus_squared (n : ℕ) : |
| (((Real.sqrt ((2 : ℝ)^n))⁻¹ : ℝ) : ℂ) ^ 2 = ((2 : ℂ)^n)⁻¹ := by |
| have he : ((Real.sqrt ((2 : ℝ)^n))⁻¹)^2 = ((2 : ℝ)^n)⁻¹ := by |
| rw [inv_pow, Real.sq_sqrt (by positivity)] |
| rw [← Complex.ofReal_pow, he, Complex.ofReal_inv, Complex.ofReal_pow] |
| rfl |
|
|
| def phaseCoeff (n : ℕ) (γ : ℝ) (σ τ : Configuration n) (e : Edge n) : ℂ := |
| (γ : ℂ) * Complex.I * ((skCoeff n σ e - skCoeff n τ e : ℝ) : ℂ) |
|
|
| theorem phase_sum (n : ℕ) (J : Disorder n) (γ : ℝ) (σ τ : Configuration n) : |
| ∑ e, phaseCoeff n γ σ τ e * (J e : ℂ) = |
| (γ : ℂ) * Complex.I * ((hamiltonian n J σ : ℂ) - (hamiltonian n J τ : ℂ)) := by |
| simp only [hamiltonian_eq_coeff, Complex.ofReal_sum, Complex.ofReal_mul, |
| ← Finset.sum_sub_distrib, Finset.mul_sum, phaseCoeff, Complex.ofReal_sub] |
| apply Finset.sum_congr rfl |
| intro e _ |
| ring |
|
|
| theorem costState_pair (n : ℕ) (J : Disorder n) (γ : ℝ) (σ τ : Configuration n) : |
| star (costState n J γ σ) * costState n J γ τ = |
| ((2 : ℂ)^n)⁻¹ * Complex.exp (∑ e, phaseCoeff n γ σ τ e * (J e : ℂ)) := by |
| rw [costState_apply, costState_apply, star_mul] |
| have hs : star (Complex.exp (-(γ : ℂ) * Complex.I * (hamiltonian n J σ : ℂ))) = |
| Complex.exp ((γ : ℂ) * Complex.I * (hamiltonian n J σ : ℂ)) := by |
| simp [← Complex.exp_conj] |
| rw [hs] |
| simp only [Complex.star_def, Complex.conj_ofReal] |
| rw [phase_sum, mul_sub, Complex.exp_sub] |
| have hm : Complex.exp (-(γ : ℂ) * Complex.I * (hamiltonian n J τ : ℂ)) = |
| (Complex.exp ((γ : ℂ) * Complex.I * (hamiltonian n J τ : ℂ)))⁻¹ := by |
| rw [neg_mul, neg_mul, Complex.exp_neg] |
| rw [hm, div_eq_mul_inv] |
| have hp := plus_squared n |
| calc |
| _ = ((((Real.sqrt ((2 : ℝ)^n))⁻¹ : ℝ) : ℂ)^2) * |
| (Complex.exp ((γ : ℂ) * Complex.I * (hamiltonian n J σ : ℂ)) * |
| (Complex.exp ((γ : ℂ) * Complex.I * (hamiltonian n J τ : ℂ)))⁻¹) := by ring |
| _ = _ := by rw [hp] |
|
|
| theorem integrable_coord_costState_pair (n : ℕ) (γ : ℝ) (e : Edge n) (σ τ : Configuration n) : |
| Integrable (fun J : Disorder n => (J e : ℂ) * |
| (star (costState n J γ σ) * costState n J γ τ)) (disorderLaw n) := by |
| simp_rw [costState_pair] |
| have h := (GaussianFourier.integrable_coord_exp_sum (phaseCoeff n γ σ τ) e).const_mul |
| (((2 : ℂ)^n)⁻¹) |
| change Integrable _ (GaussianFourier.law (Edge n)) |
| convert h using 1 |
| funext J |
| ring |
|
|
| |
| theorem integral_coord_costState_pair (n : ℕ) (γ : ℝ) (e : Edge n) (σ τ : Configuration n) : |
| (∫ J : Disorder n, (J e : ℂ) * |
| (star (costState n J γ σ) * costState n J γ τ) ∂disorderLaw n) = |
| ((2 : ℂ)^n)⁻¹ * phaseCoeff n γ σ τ e * |
| Complex.exp (∑ f, phaseCoeff n γ σ τ f ^ 2 / 2) := by |
| simp_rw [costState_pair] |
| have he : (fun J : Disorder n => (J e : ℂ) * |
| (((2 : ℂ)^n)⁻¹ * Complex.exp (∑ f, phaseCoeff n γ σ τ f * (J f : ℂ)))) = |
| fun J => ((2 : ℂ)^n)⁻¹ * ((J e : ℂ) * |
| Complex.exp (∑ f, phaseCoeff n γ σ τ f * (J f : ℂ))) := by |
| funext J |
| ring |
| rw [he, integral_const_mul] |
| change _ * (∫ J : Disorder n, _ ∂GaussianFourier.law (Edge n)) = _ |
| rw [GaussianFourier.integral_coord_exp_sum] |
| ring |
|
|
| end SKQAOA |
|
|
| namespace SKQAOA |
|
|
| def flipAt {n : ℕ} (σ : Configuration n) (i : Fin n) : Configuration n := |
| Function.update σ i (!(σ i)) |
|
|
| @[simp] theorem flipAt_self {n : ℕ} (σ : Configuration n) (i : Fin n) : |
| flipAt σ i i = !(σ i) := Function.update_self _ _ _ |
|
|
| @[simp] theorem flipAt_ne {n : ℕ} (σ : Configuration n) (i j : Fin n) (h : j ≠ i) : |
| flipAt σ i j = σ j := Function.update_of_ne h _ _ |
|
|
| @[simp] theorem spin_flipAt_self {n : ℕ} (σ : Configuration n) (i : Fin n) : |
| spin (flipAt σ i) i = -spin σ i := by |
| cases h : σ i <;> simp [spin, h] |
|
|
| @[simp] theorem spin_flipAt_ne {n : ℕ} (σ : Configuration n) (i j : Fin n) (h : j ≠ i) : |
| spin (flipAt σ i) j = spin σ j := by simp [spin, flipAt_ne, h] |
|
|
| @[simp] theorem pauliZ_mulVec {n : ℕ} (i : Fin n) (ψ : State n) (σ : Configuration n) : |
| (pauliZ i).mulVec ψ σ = (spin σ i : ℂ) * ψ σ := by |
| simp [pauliZ, Matrix.mulVec_diagonal] |
|
|
| @[simp] theorem pauliX_mulVec {n : ℕ} (i : Fin n) (ψ : State n) (σ : Configuration n) : |
| (pauliX i).mulVec ψ σ = ψ (flipAt σ i) := by |
| have he : pauliX i σ = fun τ => if τ = flipAt σ i then (1 : ℂ) else 0 := by |
| funext τ |
| unfold pauliX |
| by_cases h : τ = flipAt σ i |
| · have h' : σ = Function.update τ i (!(τ i)) := (flip_eq_iff i σ τ).mpr h |
| simp only [ite_eq_left h, ite_eq_left h'] |
| · have h' : σ ≠ Function.update τ i (!(τ i)) := fun he => h ((flip_eq_iff i σ τ).mp he) |
| simp only [ite_eq_right h, ite_eq_right h'] |
| change (∑ τ, pauliX i σ τ * ψ τ) = _ |
| rw [he] |
| simp |
|
|
| theorem pauliY_eq {n : ℕ} (i : Fin n) : |
| pauliY i = Complex.I • (pauliX i * pauliZ i) := by |
| rw [pauliY, TwoState.y, TensorMatrix.local_smul, TensorMatrix.local_mul, |
| ← pauliX_eq_atSite, ← pauliZ_eq_atSite] |
|
|
| @[simp] theorem pauliY_mulVec {n : ℕ} (i : Fin n) (ψ : State n) (σ : Configuration n) : |
| (pauliY i).mulVec ψ σ = -Complex.I * (spin σ i : ℂ) * ψ (flipAt σ i) := by |
| rw [pauliY_eq, Matrix.smul_mulVec, ← Matrix.mulVec_mulVec] |
| simp only [Pi.smul_apply, smul_eq_mul, pauliX_mulVec, pauliZ_mulVec, |
| spin_flipAt_self, Complex.ofReal_neg] |
| ring |
|
|
| theorem overlapSum_flipAt {n : ℕ} (σ : Configuration n) (i : Fin n) : |
| overlapSum σ (flipAt σ i) = (n : ℝ) - 2 := by |
| have hn : 1 ≤ n := Nat.succ_le_of_lt (lt_of_le_of_lt (Nat.zero_le i.val) i.isLt) |
| unfold overlapSum |
| rw [← Finset.add_sum_erase _ _ (Finset.mem_univ i)] |
| simp only [spin_flipAt_self, mul_neg, ← sq, spin_sq] |
| have he : (∑ j ∈ Finset.univ.erase i, spin σ j * spin (flipAt σ i) j) = (n : ℝ)-1 := by |
| calc |
| _ = ∑ _j ∈ Finset.univ.erase i, (1 : ℝ) := by |
| apply Finset.sum_congr rfl |
| intro j hj |
| rw [spin_flipAt_ne _ _ _ (Finset.ne_of_mem_erase hj), ← sq, spin_sq] |
| _ = _ := by |
| simp only [Finset.sum_const, nsmul_eq_mul, mul_one] |
| rw [Finset.card_erase_of_mem (Finset.mem_univ i), Finset.card_univ, Fintype.card_fin, |
| Nat.cast_sub hn, Nat.cast_one] |
| rw [he] |
| ring |
|
|
| theorem phaseCoeff_flip_edge_left {n : ℕ} (γ : ℝ) (σ : Configuration n) (e : Edge n) : |
| phaseCoeff n γ σ (flipAt σ e.1.1) e = |
| 2 * (γ : ℂ) * Complex.I * ((Real.sqrt (n : ℝ))⁻¹ : ℂ) * |
| (spin σ e.1.1 : ℂ) * (spin σ e.1.2 : ℂ) := by |
| unfold phaseCoeff skCoeff |
| rw [spin_flipAt_self, spin_flipAt_ne _ _ _ (ne_of_gt e.2)] |
| push_cast |
| ring |
|
|
| theorem phaseCoeff_flip_edge_right {n : ℕ} (γ : ℝ) (σ : Configuration n) (e : Edge n) : |
| phaseCoeff n γ σ (flipAt σ e.1.2) e = |
| 2 * (γ : ℂ) * Complex.I * ((Real.sqrt (n : ℝ))⁻¹ : ℂ) * |
| (spin σ e.1.1 : ℂ) * (spin σ e.1.2 : ℂ) := by |
| unfold phaseCoeff skCoeff |
| rw [spin_flipAt_self, spin_flipAt_ne _ _ _ (ne_of_lt e.2)] |
| push_cast |
| ring |
|
|
| @[simp] theorem phaseCoeff_self (n : ℕ) (γ : ℝ) (σ : Configuration n) (e : Edge n) : |
| phaseCoeff n γ σ σ e = 0 := by simp [phaseCoeff] |
|
|
| @[simp] theorem phaseCoeff_flip_both {n : ℕ} (γ : ℝ) (σ : Configuration n) (e : Edge n) : |
| phaseCoeff n γ σ (flipAt (flipAt σ e.1.1) e.1.2) e = 0 := by |
| unfold phaseCoeff skCoeff |
| rw [spin_flipAt_self, spin_flipAt_ne _ _ _ (ne_of_lt e.2), spin_flipAt_self, |
| spin_flipAt_ne _ _ _ (ne_of_gt e.2)] |
| simp |
|
|
| |
| theorem phaseCoeff_square_sum_flip {n : ℕ} (hn : 0 < n) (γ : ℝ) |
| (σ : Configuration n) (i : Fin n) : |
| (∑ e, phaseCoeff n γ σ (flipAt σ i) e ^ 2 / 2) = |
| ((-2 * γ^2 * ((n : ℝ)-1) / (n : ℝ) : ℝ) : ℂ) := by |
| have he : (∑ e, phaseCoeff n γ σ (flipAt σ i) e ^ 2 / 2) = |
| ((-γ^2 / 2 : ℝ) : ℂ) * |
| ((∑ e, (skCoeff n σ e - skCoeff n (flipAt σ i) e)^2 : ℝ) : ℂ) := by |
| rw [Complex.ofReal_sum, Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro e _ |
| simp only [phaseCoeff, Complex.ofReal_div, Complex.ofReal_neg, Complex.ofReal_pow, |
| Complex.ofReal_ofNat, mul_pow, Complex.I_sq] |
| ring |
| rw [he, coeff_increment hn, overlapSum_flipAt] |
| push_cast |
| have hn0 : (n : ℂ) ≠ 0 := Nat.cast_ne_zero.mpr hn.ne' |
| field_simp |
| ring |
|
|
| end SKQAOA |
|
|
| namespace SKQAOA |
|
|
| |
| theorem integrable_coord_quad_transition (n : ℕ) (γ : ℝ) (e : Edge n) (A : Operator n) |
| (a : Configuration n → ℂ) (f : Configuration n → Configuration n) |
| (hA : ∀ (ψ : State n) σ, A.mulVec ψ σ = a σ * ψ (f σ)) : |
| Integrable (fun J : Disorder n => (J e : ℂ) * quad (costState n J γ) A) (disorderLaw n) := by |
| have he : (fun J : Disorder n => (J e : ℂ) * quad (costState n J γ) A) = |
| fun J => ∑ σ, a σ * ((J e : ℂ) * |
| (star (costState n J γ σ) * costState n J γ (f σ))) := by |
| funext J |
| simp only [quad, dotProduct, hA, Pi.star_apply, Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro σ _ |
| ring |
| rw [he] |
| exact integrable_finsetSum _ (fun σ _ => |
| (integrable_coord_costState_pair n γ e σ (f σ)).const_mul (a σ)) |
|
|
| |
| theorem integral_coord_quad_transition (n : ℕ) (γ : ℝ) (e : Edge n) (A : Operator n) |
| (a : Configuration n → ℂ) (f : Configuration n → Configuration n) |
| (hA : ∀ (ψ : State n) σ, A.mulVec ψ σ = a σ * ψ (f σ)) : |
| (∫ J : Disorder n, (J e : ℂ) * quad (costState n J γ) A ∂disorderLaw n) = |
| ∑ σ, a σ * (((2 : ℂ)^n)⁻¹ * phaseCoeff n γ σ (f σ) e * |
| Complex.exp (∑ d, phaseCoeff n γ σ (f σ) d ^ 2 / 2)) := by |
| have he : (fun J : Disorder n => (J e : ℂ) * quad (costState n J γ) A) = |
| fun J => ∑ σ, a σ * ((J e : ℂ) * |
| (star (costState n J γ σ) * costState n J γ (f σ))) := by |
| funext J |
| simp only [quad, dotProduct, hA, Pi.star_apply, Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro σ _ |
| ring |
| rw [he, integral_finsetSum _ (fun σ _ => |
| (integrable_coord_costState_pair n γ e σ (f σ)).const_mul (a σ))] |
| simp_rw [integral_const_mul, integral_coord_costState_pair] |
|
|
| |
| theorem integral_coord_ZZ {n : ℕ} (γ : ℝ) (e : Edge n) : |
| (∫ J : Disorder n, (J e : ℂ) * |
| quad (costState n J γ) (pauliZ e.1.1 * pauliZ e.1.2) ∂disorderLaw n) = 0 := by |
| rw [integral_coord_quad_transition n γ e _ |
| (fun σ => (spin σ e.1.1 : ℂ) * (spin σ e.1.2 : ℂ)) id (by |
| intro ψ σ |
| simp only [← Matrix.mulVec_mulVec, pauliZ_mulVec, id_eq] |
| ring)] |
| simp |
|
|
| |
| theorem integral_coord_YY {n : ℕ} (γ : ℝ) (e : Edge n) : |
| (∫ J : Disorder n, (J e : ℂ) * |
| quad (costState n J γ) (pauliY e.1.1 * pauliY e.1.2) ∂disorderLaw n) = 0 := by |
| rw [integral_coord_quad_transition n γ e _ |
| (fun σ => -(spin σ e.1.1 : ℂ) * (spin σ e.1.2 : ℂ)) |
| (fun σ => flipAt (flipAt σ e.1.1) e.1.2) (by |
| intro ψ σ |
| simp only [← Matrix.mulVec_mulVec, pauliY_mulVec, |
| spin_flipAt_ne _ _ _ (ne_of_gt e.2)] |
| calc |
| _ = Complex.I^2 * (spin σ e.1.1 : ℂ) * (spin σ e.1.2 : ℂ) * |
| ψ (flipAt (flipAt σ e.1.1) e.1.2) := by ring |
| _ = _ := by rw [Complex.I_sq]; ring)] |
| simp |
|
|
| |
| theorem sum_configuration_normalized (n : ℕ) (c : ℂ) : |
| (∑ _σ : Configuration n, ((2 : ℂ)^n)⁻¹ * c) = c := by |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fun, Fintype.card_bool, |
| Fintype.card_fin, nsmul_eq_mul, Nat.cast_pow, Nat.cast_ofNat] |
| rw [← mul_assoc, mul_inv_cancel₀ (pow_ne_zero _ (by norm_num : (2 : ℂ) ≠ 0)), one_mul] |
|
|
| theorem integral_coord_YZ {n : ℕ} (γ : ℝ) (e : Edge n) : |
| (∫ J : Disorder n, (J e : ℂ) * |
| quad (costState n J γ) (pauliY e.1.1 * pauliZ e.1.2) ∂disorderLaw n) = |
| 2 * (γ : ℂ) * ((Real.sqrt (n : ℝ))⁻¹ : ℂ) * |
| Complex.exp ((-2 * γ^2 * ((n : ℝ)-1) / (n : ℝ) : ℝ) : ℂ) := by |
| have hn : 0 < n := lt_of_le_of_lt (Nat.zero_le e.1.1.val) e.1.1.isLt |
| rw [integral_coord_quad_transition n γ e _ |
| (fun σ => -Complex.I * (spin σ e.1.1 : ℂ) * (spin σ e.1.2 : ℂ)) |
| (fun σ => flipAt σ e.1.1) (by |
| intro ψ σ |
| simp only [← Matrix.mulVec_mulVec, pauliY_mulVec, pauliZ_mulVec, |
| spin_flipAt_ne _ _ _ (ne_of_gt e.2)] |
| ring)] |
| simp_rw [phaseCoeff_flip_edge_left, phaseCoeff_square_sum_flip hn] |
| calc |
| _ = ∑ _σ : Configuration n, ((2 : ℂ)^n)⁻¹ * |
| (2 * (γ : ℂ) * ((Real.sqrt (n : ℝ))⁻¹ : ℂ) * |
| Complex.exp ((-2 * γ^2 * ((n : ℝ)-1) / (n : ℝ) : ℝ) : ℂ)) := by |
| apply Finset.sum_congr rfl |
| intro σ _ |
| have hi : (spin σ e.1.1 : ℂ)^2 = 1 := by exact_mod_cast spin_sq σ e.1.1 |
| have hj : (spin σ e.1.2 : ℂ)^2 = 1 := by exact_mod_cast spin_sq σ e.1.2 |
| calc |
| _ = ((2 : ℂ)^n)⁻¹ * (2 * (γ : ℂ) * ((Real.sqrt (n : ℝ))⁻¹ : ℂ) * |
| Complex.exp ((-2 * γ^2 * ((n : ℝ)-1) / (n : ℝ) : ℝ) : ℂ)) * |
| (-Complex.I^2) * (spin σ e.1.1 : ℂ)^2 * (spin σ e.1.2 : ℂ)^2 := by ring |
| _ = _ := by rw [hi, hj, Complex.I_sq]; ring |
| _ = _ := sum_configuration_normalized n _ |
|
|
| theorem integral_coord_ZY {n : ℕ} (γ : ℝ) (e : Edge n) : |
| (∫ J : Disorder n, (J e : ℂ) * |
| quad (costState n J γ) (pauliZ e.1.1 * pauliY e.1.2) ∂disorderLaw n) = |
| 2 * (γ : ℂ) * ((Real.sqrt (n : ℝ))⁻¹ : ℂ) * |
| Complex.exp ((-2 * γ^2 * ((n : ℝ)-1) / (n : ℝ) : ℝ) : ℂ) := by |
| have hn : 0 < n := lt_of_le_of_lt (Nat.zero_le e.1.1.val) e.1.1.isLt |
| rw [integral_coord_quad_transition n γ e _ |
| (fun σ => -Complex.I * (spin σ e.1.1 : ℂ) * (spin σ e.1.2 : ℂ)) |
| (fun σ => flipAt σ e.1.2) (by |
| intro ψ σ |
| simp only [← Matrix.mulVec_mulVec, pauliY_mulVec, pauliZ_mulVec] |
| ring)] |
| simp_rw [phaseCoeff_flip_edge_right, phaseCoeff_square_sum_flip hn] |
| calc |
| _ = ∑ _σ : Configuration n, ((2 : ℂ)^n)⁻¹ * |
| (2 * (γ : ℂ) * ((Real.sqrt (n : ℝ))⁻¹ : ℂ) * |
| Complex.exp ((-2 * γ^2 * ((n : ℝ)-1) / (n : ℝ) : ℝ) : ℂ)) := by |
| apply Finset.sum_congr rfl |
| intro σ _ |
| have hi : (spin σ e.1.1 : ℂ)^2 = 1 := by exact_mod_cast spin_sq σ e.1.1 |
| have hj : (spin σ e.1.2 : ℂ)^2 = 1 := by exact_mod_cast spin_sq σ e.1.2 |
| calc |
| _ = ((2 : ℂ)^n)⁻¹ * (2 * (γ : ℂ) * ((Real.sqrt (n : ℝ))⁻¹ : ℂ) * |
| Complex.exp ((-2 * γ^2 * ((n : ℝ)-1) / (n : ℝ) : ℝ) : ℂ)) * |
| (-Complex.I^2) * (spin σ e.1.1 : ℂ)^2 * (spin σ e.1.2 : ℂ)^2 := by ring |
| _ = _ := by rw [hi, hj, Complex.I_sq]; ring |
| _ = _ := sum_configuration_normalized n _ |
|
|
| end SKQAOA |
|
|
| namespace SKQAOA |
|
|
| theorem integrable_coord_quad (n : ℕ) (γ : ℝ) (e : Edge n) (A : Operator n) : |
| Integrable (fun J : Disorder n => (J e : ℂ) * quad (costState n J γ) A) (disorderLaw n) := by |
| have he : (fun J : Disorder n => (J e : ℂ) * quad (costState n J γ) A) = |
| fun J => ∑ σ, ∑ τ, A σ τ * ((J e : ℂ) * |
| (star (costState n J γ σ) * costState n J γ τ)) := by |
| funext J |
| simp only [quad, dotProduct, Matrix.mulVec, Pi.star_apply, Finset.mul_sum] |
| apply Finset.sum_congr rfl |
| intro σ _ |
| apply Finset.sum_congr rfl |
| intro τ _ |
| ring |
| rw [he] |
| exact integrable_finsetSum _ (fun σ _ => integrable_finsetSum _ (fun τ _ => |
| (integrable_coord_costState_pair n γ e σ τ).const_mul (A σ τ))) |
|
|
| theorem qaoaState_one (n : ℕ) (J : Disorder n) (γ β : Fin 1 → ℝ) : |
| qaoaState n 1 J γ β = (evolution (β 0) (mixer n)).mulVec (costState n J (γ 0)) := by |
| simp [qaoaState, circuit, costState, ← Matrix.mulVec_mulVec] |
|
|
| theorem conjugate_mul {n : ℕ} (U A B : Operator n) (hU : U * Uᴴ = 1) : |
| Uᴴ * (A*B) * U = (Uᴴ*A*U)*(Uᴴ*B*U) := by |
| symm |
| calc |
| _ = Uᴴ*A*(U*Uᴴ)*B*U := by noncomm_ring |
| _ = _ := by rw [hU]; noncomm_ring |
|
|
| theorem quad_qaoaState_one_edge (n : ℕ) (J : Disorder n) (γ β : Fin 1 → ℝ) (e : Edge n) : |
| quad (qaoaState n 1 J γ β) (pauliZ e.1.1 * pauliZ e.1.2) = |
| (Real.cos (2*β 0) : ℂ)^2 * quad (costState n J (γ 0)) (pauliZ e.1.1 * pauliZ e.1.2) + |
| ((Real.cos (2*β 0) : ℂ) * (Real.sin (2*β 0) : ℂ)) * |
| quad (costState n J (γ 0)) (pauliZ e.1.1 * pauliY e.1.2) + |
| ((Real.sin (2*β 0) : ℂ) * (Real.cos (2*β 0) : ℂ)) * |
| quad (costState n J (γ 0)) (pauliY e.1.1 * pauliZ e.1.2) + |
| (Real.sin (2*β 0) : ℂ)^2 * quad (costState n J (γ 0)) (pauliY e.1.1 * pauliY e.1.2) := by |
| rw [qaoaState_one, quad_mulVec, conjugate_mul _ _ _ |
| (Unitary.mul_star_self_of_mem (evolution_unitary _ _ (mixer_hermitian n))), |
| mixer_conjugate_pauliZ, mixer_conjugate_pauliZ] |
| simp only [add_mul, mul_add, smul_mul_assoc, mul_smul_comm, quad_add, quad_smul] |
| ring |
|
|
| theorem integrable_coord_qaoaState_one_edge (n : ℕ) (γ β : Fin 1 → ℝ) (e : Edge n) : |
| Integrable (fun J : Disorder n => (J e : ℂ) * |
| quad (qaoaState n 1 J γ β) (pauliZ e.1.1 * pauliZ e.1.2)) (disorderLaw n) := by |
| simp_rw [quad_qaoaState_one_edge, mul_add] |
| simp_rw [mul_left_comm (G := ℂ) _ (↑(Real.cos (2*β 0))^2), |
| mul_left_comm (G := ℂ) _ (↑(Real.cos (2*β 0)) * ↑(Real.sin (2*β 0))), |
| mul_left_comm (G := ℂ) _ (↑(Real.sin (2*β 0)) * ↑(Real.cos (2*β 0))), |
| mul_left_comm (G := ℂ) _ (↑(Real.sin (2*β 0))^2)] |
| exact ((((integrable_coord_quad n (γ 0) e _).const_mul _).add |
| ((integrable_coord_quad n (γ 0) e _).const_mul _)).add |
| ((integrable_coord_quad n (γ 0) e _).const_mul _)).add |
| ((integrable_coord_quad n (γ 0) e _).const_mul _) |
|
|
| |
| theorem integral_coord_qaoaState_one_edge (n : ℕ) (γ β : Fin 1 → ℝ) (e : Edge n) : |
| (∫ J : Disorder n, (J e : ℂ) * |
| quad (qaoaState n 1 J γ β) (pauliZ e.1.1 * pauliZ e.1.2) ∂disorderLaw n) = |
| 2 * (γ 0 : ℂ) * ((Real.sqrt (n : ℝ))⁻¹ : ℂ) * (Real.sin (4*β 0) : ℂ) * |
| Complex.exp ((-2 * (γ 0)^2 * ((n : ℝ)-1) / (n : ℝ) : ℝ) : ℂ) := by |
| simp_rw [quad_qaoaState_one_edge, mul_add] |
| simp_rw [mul_left_comm (G := ℂ) _ (↑(Real.cos (2*β 0))^2), |
| mul_left_comm (G := ℂ) _ (↑(Real.cos (2*β 0)) * ↑(Real.sin (2*β 0))), |
| mul_left_comm (G := ℂ) _ (↑(Real.sin (2*β 0)) * ↑(Real.cos (2*β 0))), |
| mul_left_comm (G := ℂ) _ (↑(Real.sin (2*β 0))^2)] |
| have hZZ := (integrable_coord_quad n (γ 0) e (pauliZ e.1.1 * pauliZ e.1.2)).const_mul |
| ((Real.cos (2*β 0) : ℂ)^2) |
| have hZY := (integrable_coord_quad n (γ 0) e (pauliZ e.1.1 * pauliY e.1.2)).const_mul |
| ((Real.cos (2*β 0) : ℂ) * (Real.sin (2*β 0) : ℂ)) |
| have hYZ := (integrable_coord_quad n (γ 0) e (pauliY e.1.1 * pauliZ e.1.2)).const_mul |
| ((Real.sin (2*β 0) : ℂ) * (Real.cos (2*β 0) : ℂ)) |
| have hYY := (integrable_coord_quad n (γ 0) e (pauliY e.1.1 * pauliY e.1.2)).const_mul |
| ((Real.sin (2*β 0) : ℂ)^2) |
| have hi1 := integral_add ((hZZ.add hZY).add hYZ) hYY |
| have hi2 := integral_add (hZZ.add hZY) hYZ |
| have hi3 := integral_add hZZ hZY |
| simp only [Pi.add_apply] at hi1 hi2 hi3 |
| rw [hi1, hi2, hi3] |
| simp_rw [integral_const_mul] |
| rw [integral_coord_ZZ, integral_coord_ZY, integral_coord_YZ, integral_coord_YY] |
| have hs : (Real.sin (4*β 0) : ℂ) = |
| 2 * (Real.sin (2*β 0) : ℂ) * (Real.cos (2*β 0) : ℂ) := by |
| rw [show 4*β 0 = 2*(2*β 0) by ring, Real.sin_two_mul] |
| push_cast |
| rfl |
| rw [hs] |
| ring |
|
|
| end SKQAOA |
|
|
| namespace SKQAOA |
|
|
| @[simp] theorem quad_finsetSum {n : ℕ} {ι : Type*} (s : Finset ι) |
| (ψ : State n) (A : ι → Operator n) : |
| quad ψ (∑ i ∈ s, A i) = ∑ i ∈ s, quad ψ (A i) := by |
| classical |
| induction s using Finset.induction_on with |
| | empty => simp [quad] |
| | @insert i s hi ih => simp [hi, ih] |
|
|
| theorem quad_cost (n : ℕ) (J : Disorder n) (ψ : State n) : |
| quad ψ (cost n J) = ((Real.sqrt (n : ℝ))⁻¹ : ℂ) * |
| ∑ e : Edge n, (J e : ℂ) * quad ψ (pauliZ e.1.1 * pauliZ e.1.2) := by |
| simp only [cost, quad_smul, quad_finsetSum] |
|
|
| theorem integrable_quad_cost_one (n : ℕ) (γ β : Fin 1 → ℝ) : |
| Integrable (fun J : Disorder n => quad (qaoaState n 1 J γ β) (cost n J)) (disorderLaw n) := by |
| simp_rw [quad_cost] |
| exact (integrable_finsetSum _ (fun e _ => integrable_coord_qaoaState_one_edge n γ β e)).const_mul _ |
|
|
| theorem integral_quad_cost_one (n : ℕ) (γ β : Fin 1 → ℝ) : |
| (∫ J : Disorder n, quad (qaoaState n 1 J γ β) (cost n J) ∂disorderLaw n) = |
| ((Real.sqrt (n : ℝ))⁻¹ : ℂ) * (Fintype.card (Edge n) : ℂ) * |
| (2 * (γ 0 : ℂ) * ((Real.sqrt (n : ℝ))⁻¹ : ℂ) * (Real.sin (4*β 0) : ℂ) * |
| Complex.exp ((-2 * (γ 0)^2 * ((n : ℝ)-1) / (n : ℝ) : ℝ) : ℂ)) := by |
| simp_rw [quad_cost] |
| rw [integral_const_mul, integral_finsetSum _ (fun e _ => integrable_coord_qaoaState_one_edge n γ β e)] |
| simp_rw [integral_coord_qaoaState_one_edge] |
| simp [mul_assoc] |
|
|
| theorem card_edges_real (n : ℕ) : |
| 2 * (Fintype.card (Edge n) : ℝ) = (n : ℝ) * ((n : ℝ)-1) := by |
| have h := sum_symmetric_pairs n (fun _ _ => 1) (by intros; rfl) |
| simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fin, nsmul_eq_mul, mul_one] at h |
| nlinarith |
|
|
| |
| theorem expectedEnergy_one (n : ℕ) (γ β : Fin 1 → ℝ) : |
| expectedEnergy n 1 γ β = |
| γ 0 * ((n : ℝ)-1) / (n : ℝ) * Real.sin (4*β 0) * |
| Real.exp (-2 * (γ 0)^2 * ((n : ℝ)-1) / (n : ℝ)) := by |
| unfold expectedEnergy energyDensity |
| change (∫ J : Disorder n, (quad (qaoaState n 1 J γ β) (cost n J)).re / (n : ℝ) ∂disorderLaw n) = _ |
| have hi : (∫ J : Disorder n, (quad (qaoaState n 1 J γ β) (cost n J)).re ∂disorderLaw n) = |
| (∫ J : Disorder n, quad (qaoaState n 1 J γ β) (cost n J) ∂disorderLaw n).re := |
| integral_re (integrable_quad_cost_one n γ β) |
| rw [integral_div, hi, integral_quad_cost_one] |
| simp only [← Complex.ofReal_inv, ← Complex.ofReal_natCast, ← Complex.ofReal_ofNat, |
| ← Complex.ofReal_exp, ← Complex.ofReal_mul, Complex.ofReal_re] |
| by_cases hn : n = 0 |
| · subst n; simp |
| · have hn' : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr hn |
| have hs2 : ((Real.sqrt (n : ℝ))⁻¹)^2 = (n : ℝ)⁻¹ := by |
| rw [inv_pow, Real.sq_sqrt (Nat.cast_nonneg n)] |
| calc |
| _ = γ 0 * (2 * (Fintype.card (Edge n) : ℝ)) * ((Real.sqrt (n : ℝ))⁻¹)^2 * |
| Real.sin (4*β 0) * Real.exp (-2 * (γ 0)^2 * ((n : ℝ)-1)/(n : ℝ)) / (n : ℝ) := by ring |
| _ = _ := by rw [hs2, card_edges_real]; field_simp |
|
|
| end SKQAOA |
|
|
| namespace SKQAOA |
|
|
| theorem tendsto_sizeCorrection : |
| Tendsto (fun n : ℕ => ((n : ℝ)-1)/(n : ℝ)) atTop (𝓝 1) := by |
| have h : Tendsto (fun n : ℕ => 1 - 1/(n : ℝ)) atTop (𝓝 (1-0 : ℝ)) := |
| tendsto_const_nhds.sub tendsto_one_div_atTop_nhds_zero_nat |
| simp only [sub_zero] at h |
| apply h.congr' |
| filter_upwards [eventually_gt_atTop 0] with n hn |
| have hn' : (n : ℝ) ≠ 0 := Nat.cast_ne_zero.mpr (Nat.ne_zero_of_lt hn) |
| field_simp |
|
|
| theorem tendsto_expectedEnergy_one (γ β : Fin 1 → ℝ) : |
| Tendsto (fun n => expectedEnergy n 1 γ β) atTop |
| (𝓝 (γ 0 * Real.sin (4*β 0) * Real.exp (-2 * (γ 0)^2))) := by |
| have h := (((tendsto_const_nhds (x := γ 0)).mul tendsto_sizeCorrection).mul |
| (tendsto_const_nhds (x := Real.sin (4*β 0)))).mul |
| (Real.continuous_exp.tendsto (-2 * (γ 0)^2 * 1) |>.comp |
| (tendsto_const_nhds.mul tendsto_sizeCorrection)) |
| simp only [mul_one] at h |
| convert h using 1 |
| funext n |
| rw [expectedEnergy_one] |
| simp only [Function.comp_apply, mul_div_assoc] |
|
|
| theorem value_one (γ β : Fin 1 → ℝ) : |
| value 1 γ β = γ 0 * Real.sin (4*β 0) * Real.exp (-2 * (γ 0)^2) := by |
| exact (tendsto_expectedEnergy_one γ β).limUnder_eq |
|
|
| |
| theorem explicit_one_layer_value : |
| value 1 (fun _ => 1/2) (fun _ => Real.pi/8) = Real.exp (-1/2) / 2 := by |
| rw [value_one] |
| norm_num |
| rw [show 4*(Real.pi/8) = Real.pi/2 by ring, Real.sin_pi_div_two] |
| ring |
|
|
| end SKQAOA |
|
|
| namespace SKGaussian |
| variable {ι : Type*} [Fintype ι] [Nonempty ι] |
|
|
| |
| theorem expected_field_logPartition_le_of_orthogonal {κ : Type*} [Fintype κ] |
| (A B : ι → κ → ℝ) |
| (hAB : ∀ i j, ∑ k, A i k * B j k = 0) |
| (hinc : ∀ i j, (∑ k, (A i k - A j k)^2) ≤ ∑ k, (B i k - B j k)^2) : |
| (∫ x, logPartition (field A x) ∂gaussianLaw κ) ≤ |
| ∫ x, logPartition (field B x) ∂gaussianLaw κ := by |
| rw [← integral_reindex_field A logPartition, ← integral_reindex_field B logPartition] |
| apply expected_logPartition_le |
| · intro i j |
| exact ((Fintype.equivFin κ).symm.sum_comp (fun k => A i k * B j k)).trans (hAB i j) |
| · intro i j |
| exact ((Fintype.equivFin κ).symm.sum_comp (fun k => (A i k - A j k)^2)).le.trans |
| ((hinc i j).trans ((Fintype.equivFin κ).symm.sum_comp (fun k => (B i k - B j k)^2)).symm.le) |
|
|
| theorem expected_field_logPartition_le {κ κ₂ : Type*} [Fintype κ] [Fintype κ₂] |
| (A : ι → κ → ℝ) (B : ι → κ₂ → ℝ) |
| (hinc : ∀ i j, (∑ k, (A i k - A j k)^2) ≤ ∑ k, (B i k - B j k)^2) : |
| (∫ x, logPartition (field A x) ∂gaussianLaw κ) ≤ |
| ∫ x, logPartition (field B x) ∂gaussianLaw κ₂ := by |
| rw [← integral_field_inl (κ₂ := κ₂) A logPartition, |
| ← integral_field_inr (κ := κ) B logPartition] |
| apply expected_field_logPartition_le_of_orthogonal |
| · intro i j |
| simp [Fintype.sum_sum_type] |
| · intro i j |
| simpa only [Fintype.sum_sum_type,Sum.elim_inl,Sum.elim_inr,sub_self, |
| sq,mul_zero,Finset.sum_const_zero,add_zero,zero_add] using hinc i j |
|
|
| end SKGaussian |
|
|
| namespace SKQAOA |
| open SKGaussian |
|
|
| |
| def pressure (β : ℝ) (n : ℕ) : ℝ := |
| ∫ J, logPartition (fun σ => β * hamiltonian n J σ) ∂disorderLaw n |
|
|
| def freeEnergy (β : ℝ) (n : ℕ) : ℝ := pressure β n / (n : ℝ) / β |
|
|
| def limitingFreeEnergy (β : ℝ) : ℝ := limUnder atTop (freeEnergy β) |
|
|
| theorem field_scale {ι κ : Type*} [Fintype κ] (β : ℝ) (A : ι → κ → ℝ) (J : κ → ℝ) : |
| field (fun i k => β * A i k) J = fun i => β * field A J i := by |
| funext i |
| simp only [field,mul_assoc,Finset.mul_sum] |
|
|
| theorem scaled_increment {ι κ : Type*} [Fintype κ] (β : ℝ) (A : ι → κ → ℝ) (i j : ι) : |
| (∑ k, (β*A i k-β*A j k)^2) = β^2 * ∑ k, (A i k-A j k)^2 := by |
| simp_rw [← mul_sub,mul_pow] |
| rw [Finset.mul_sum] |
|
|
| theorem field_skCoeff (n : ℕ) (J : Disorder n) : field (skCoeff n) J = hamiltonian n J := |
| funext fun σ => (hamiltonian_eq_coeff n J σ).symm |
|
|
| theorem pressure_integrable (β : ℝ) (n : ℕ) : |
| Integrable (fun J => logPartition (fun σ => β * hamiltonian n J σ)) (disorderLaw n) := by |
| have : IsProbabilityMeasure (disorderLaw n) := by unfold disorderLaw; infer_instance |
| apply integrable_logPartition |
| intro σ |
| simpa only [field,← hamiltonian_eq_coeff,gaussianLaw,disorderLaw] using (integrable_field (skCoeff n) σ).const_mul β |
|
|
| theorem block_partition (β : ℝ) (n m : ℕ) (J : (Edge n ⊕ Edge m) → ℝ) : |
| partition (fun σ => β * field (blockCoeff n m) J σ) = |
| partition (fun σ => β * hamiltonian n (fun e => J (Sum.inl e)) σ) * |
| partition (fun τ => β * hamiltonian m (fun e => J (Sum.inr e)) τ) := by |
| let e : (Configuration n × Configuration m) ≃ Configuration (n+m) := Fin.appendEquiv n m |
| rw [partition, ← e.sum_comp] |
| simp only [Fintype.sum_prod_type, e] |
| change (∑ σ : Configuration n, ∑ τ : Configuration m, |
| Real.exp (β * field (blockCoeff n m) J (Fin.append σ τ))) = _ |
| have he (σ : Configuration n) (τ : Configuration m) : |
| field (blockCoeff n m) J (Fin.append σ τ) = |
| hamiltonian n (fun e => J (Sum.inl e)) σ + hamiltonian m (fun e => J (Sum.inr e)) τ := by |
| simp only [field,blockCoeff,Fintype.sum_sum_type,Sum.elim_inl,Sum.elim_inr, |
| restrictLeft_append,restrictRight_append] |
| rw [← field, ← field] |
| rw [field_skCoeff,field_skCoeff] |
| simp_rw [he,mul_add,Real.exp_add] |
| simp only [partition,Finset.sum_mul,Finset.mul_sum] |
| rw [Finset.sum_comm] |
|
|
| theorem block_logPartition (β : ℝ) (n m : ℕ) (J : (Edge n ⊕ Edge m) → ℝ) : |
| logPartition (fun σ => β * field (blockCoeff n m) J σ) = |
| logPartition (fun σ => β * hamiltonian n (fun e => J (Sum.inl e)) σ) + |
| logPartition (fun τ => β * hamiltonian m (fun e => J (Sum.inr e)) τ) := by |
| rw [logPartition,block_partition,Real.log_mul (partition_pos _).ne' (partition_pos _).ne'] |
| rfl |
|
|
| theorem expected_block_logPartition (β : ℝ) (n m : ℕ) : |
| (∫ J, logPartition (fun σ => β * field (blockCoeff n m) J σ) |
| ∂gaussianLaw (Edge n ⊕ Edge m)) = pressure β n + pressure β m := by |
| let T : ((Disorder n) × (Disorder m)) ≃ᵐ ((Edge n ⊕ Edge m) → ℝ) := |
| (MeasurableEquiv.sumPiEquivProdPi (fun _ : Edge n ⊕ Edge m => ℝ)).symm |
| have hp : MeasurePreserving T ((disorderLaw n).prod (disorderLaw m)) |
| (gaussianLaw (Edge n ⊕ Edge m)) := |
| measurePreserving_sumPiEquivProdPi_symm (fun _ => gaussianReal 0 1) |
| rw [← hp.integral_comp' (fun J => logPartition (fun σ => β * field (blockCoeff n m) J σ))] |
| simp_rw [block_logPartition] |
| change (∫ J, logPartition (fun σ => β * hamiltonian n J.1 σ) + |
| logPartition (fun τ => β * hamiltonian m J.2 τ) ∂(disorderLaw n).prod (disorderLaw m)) = _ |
| have : IsProbabilityMeasure (disorderLaw n) := by unfold disorderLaw; infer_instance |
| have : IsProbabilityMeasure (disorderLaw m) := by unfold disorderLaw; infer_instance |
| rw [integral_add ((pressure_integrable β n).comp_fst _) ((pressure_integrable β m).comp_snd _)] |
| rw [integral_fun_fst (fun J : Disorder n => logPartition (fun σ => β * hamiltonian n J σ)), |
| integral_fun_snd (fun J : Disorder m => logPartition (fun σ => β * hamiltonian m J σ))] |
| simp [pressure] |
|
|
| theorem pressure_superadditive_pos (β : ℝ) {n m : ℕ} (hn : 0 < n) (hm : 0 < m) : |
| pressure β n + pressure β m ≤ pressure β (n+m) := by |
| have hinc (σ τ : Configuration (n+m)) : |
| (∑ k, (β*blockCoeff n m σ k-β*blockCoeff n m τ k)^2) ≤ |
| ∑ k, (β*skCoeff (n+m) σ k-β*skCoeff (n+m) τ k)^2 := by |
| rw [scaled_increment,scaled_increment] |
| exact mul_le_mul_of_nonneg_left (blockCoeff_increment hn hm σ τ) (sq_nonneg β) |
| have h := expected_field_logPartition_le (fun σ k => β*blockCoeff n m σ k) |
| (fun σ k => β*skCoeff (n+m) σ k) hinc |
| simp_rw [field_scale,field_skCoeff] at h |
| rw [expected_block_logPartition] at h |
| exact h |
|
|
| @[simp] theorem pressure_zero (β : ℝ) : pressure β 0 = 0 := by |
| simp [pressure,logPartition,partition,hamiltonian] |
|
|
| theorem pressure_superadditive (β : ℝ) (n m : ℕ) : |
| pressure β n + pressure β m ≤ pressure β (n+m) := by |
| rcases Nat.eq_zero_or_pos n with rfl | hn |
| · simp |
| rcases Nat.eq_zero_or_pos m with rfl | hm |
| · simp |
| exact pressure_superadditive_pos β hn hm |
|
|
| end SKQAOA |
|
|
| end |
|
|
| end OAI |
|
|
