| import Mathlib | |
| import OAI.Probability.ParisiFinite.PhysicalGate | |
| namespace OAI | |
| /-! Masked Disorder. -/ | |
| noncomputable section | |
| open scoped BigOperators ComplexConjugate InnerProductSpace Topology ComplexOrder | |
| open Filter | |
| open scoped BigOperators | |
| open scoped Matrix Matrix.Norms.L2Operator ComplexConjugate | |
| open scoped InnerProductSpace ComplexConjugate | |
| open Filter Topology | |
| open Filter Set Topology | |
| open scoped InnerProductSpace ComplexConjugate Topology | |
| open scoped InnerProductSpace | |
| open scoped BigOperators Topology InnerProductSpace | |
| open scoped BigOperators InnerProductSpace | |
| open scoped BigOperators Matrix Topology ComplexConjugate | |
| open MeasureTheory ProbabilityTheory Filter | |
| open scoped BigOperators Topology | |
| open scoped BigOperators Matrix Topology | |
| open scoped BigOperators Matrix Topology Matrix.Norms.Operator | |
| open scoped BigOperators Matrix Topology Matrix.Norms.Operator | |
| open MeasureTheory ProbabilityTheory Filter | |
| namespace SKQAOA.Locality | |
| variable {n : ℕ} | |
| def maskedDisorder (J : Disorder n) (E : Finset (Edge n)) : Disorder n := | |
| fun e => if e ∈ E then J e else 0 | |
| def maskedCost (J : Disorder n) (E : Finset (Edge n)) : Operator n := | |
| cost n (maskedDisorder J E) | |
| @[simp] theorem maskedCost_univ (J : Disorder n) : maskedCost J Finset.univ=cost n J := by | |
| unfold maskedCost | |
| congr 1 | |
| funext e | |
| exact ite_eq_left (Finset.mem_univ e) | |
| @[simp] theorem maskedCost_empty (J : Disorder n) : maskedCost J ∅=0 := by | |
| simp [maskedCost,maskedDisorder,cost] | |
| theorem maskedCost_sum (J : Disorder n) (E : Finset (Edge n)) : | |
| maskedCost J E = ((Real.sqrt (n : ℝ))⁻¹ : ℂ) • | |
| ∑e∈E, (J e : ℂ) • (pauliZ e.1.1*pauliZ e.1.2) := by | |
| simp [maskedCost,cost,maskedDisorder,ite_smul] | |
| theorem maskedCost_hermitian (J : Disorder n) (E : Finset (Edge n)) : | |
| (maskedCost J E).IsHermitian := cost_hermitian _ _ | |
| theorem maskedCost_commute (J K : Disorder n) (E F : Finset (Edge n)) : | |
| Commute (maskedCost J E) (maskedCost K F) := by | |
| simp only [maskedCost,cost_eq_diagonal] | |
| exact Matrix.commute_diagonal _ _ | |
| def touches (S : Finset (Fin n)) (e : Edge n) : Prop := e.1.1 ∈ S ∨ e.1.2 ∈ S | |
| instance (S : Finset (Fin n)) (e : Edge n) : Decidable (touches S e) := | |
| inferInstanceAs (Decidable (_ ∨ _)) | |
| def activeEdges (E : Finset (Edge n)) (S : Finset (Fin n)) : Finset (Edge n) := | |
| E.filter (touches S) | |
| def inactiveEdges (E : Finset (Edge n)) (S : Finset (Fin n)) : Finset (Edge n) := | |
| E.filter (fun e => ¬touches S e) | |
| def neighborhood (E : Finset (Edge n)) (S : Finset (Fin n)) : Finset (Fin n) := | |
| S ∪ (activeEdges E S).biUnion (fun e => {e.1.1,e.1.2}) | |
| theorem subset_neighborhood (E : Finset (Edge n)) (S : Finset (Fin n)) : | |
| S ⊆ neighborhood E S := Finset.subset_union_left | |
| theorem active_endpoints {E : Finset (Edge n)} {S : Finset (Fin n)} {e : Edge n} | |
| (he : e∈activeEdges E S) : | |
| e.1.1∈neighborhood E S ∧ e.1.2∈neighborhood E S := by | |
| constructor <;> apply Finset.mem_union.mpr <;> right <;> | |
| apply Finset.mem_biUnion.mpr <;> exact ⟨e,he,by simp⟩ | |
| theorem maskedCost_active_supported (J : Disorder n) (E : Finset (Edge n)) | |
| (S : Finset (Fin n)) : IsSupported (neighborhood E S) (maskedCost J (activeEdges E S)) := by | |
| rw [maskedCost_sum] | |
| apply IsSupported.smul | |
| apply supported_finsetSum | |
| intro e he | |
| exact ((supported_pauliZ (active_endpoints he).1).mul | |
| (supported_pauliZ (active_endpoints he).2)).smul _ | |
| theorem commute_maskedCost_inactive {S : Finset (Fin n)} {A : Operator n} | |
| (hA : IsSupported S A) (J : Disorder n) (E : Finset (Edge n)) : | |
| Commute A (maskedCost J (inactiveEdges E S)) := by | |
| rw [maskedCost_sum] | |
| apply Commute.smul_right | |
| apply Commute.sum_right | |
| intro e he | |
| have ht : ¬touches S e := (Finset.mem_filter.mp he).2 | |
| exact ((hA e.1.1 (fun h => ht (Or.inl h))).2.mul_right | |
| (hA e.1.2 (fun h => ht (Or.inr h))).2).smul_right _ | |
| theorem maskedCost_split (J : Disorder n) (E : Finset (Edge n)) (S : Finset (Fin n)) : | |
| maskedCost J E = maskedCost J (inactiveEdges E S)+maskedCost J (activeEdges E S) := by | |
| simp only [maskedCost_sum,←smul_add] | |
| congr 1 | |
| rw [add_comm] | |
| exact (Finset.sum_filter_add_sum_filter_not E (touches S) _).symm | |
| theorem evolution_add_of_commute (t : ℝ) {A B : Operator n} (h : Commute A B) : | |
| evolution t (A+B)=evolution t A*evolution t B := by | |
| unfold evolution | |
| rw [smul_add] | |
| exact Matrix.exp_add_of_commute _ _ ((h.smul_left _).smul_right _) | |
| theorem unitary_conjugate_eq_self (U A : Operator n) (hU : U∈unitary (Operator n)) | |
| (h : Commute A U) : Uᴴ*A*U=A := by | |
| have hl : Uᴴ*U=1 := Unitary.star_mul_self_of_mem hU | |
| rw [mul_assoc,h.eq,←mul_assoc,hl,one_mul] | |
| theorem cost_conjugate_local {S : Finset (Fin n)} {A : Operator n} | |
| (hA : IsSupported S A) (J : Disorder n) (E : Finset (Edge n)) (t : ℝ) : | |
| (evolution t (maskedCost J E))ᴴ*A*evolution t (maskedCost J E) = | |
| (evolution t (maskedCost J (activeEdges E S)))ᴴ*A* | |
| evolution t (maskedCost J (activeEdges E S)) := by | |
| have hc := maskedCost_commute J J (inactiveEdges E S) (activeEdges E S) | |
| have hu := evolution_unitary t _ (maskedCost_hermitian J (inactiveEdges E S)) | |
| have ha : Commute A (evolution t (maskedCost J (inactiveEdges E S))) := | |
| ((commute_maskedCost_inactive hA J E).smul_right _).exp_right | |
| conv_lhs => rw [maskedCost_split J E S, evolution_add_of_commute t hc] | |
| rw [Matrix.conjTranspose_mul] | |
| calc | |
| _ = (evolution t (maskedCost J (activeEdges E S)))ᴴ * | |
| ((evolution t (maskedCost J (inactiveEdges E S)))ᴴ*A* | |
| evolution t (maskedCost J (inactiveEdges E S))) * | |
| evolution t (maskedCost J (activeEdges E S)) := by noncomm_ring | |
| _ = _ := by rw [unitary_conjugate_eq_self _ _ hu ha] | |
| theorem IsSupported.cost_conjugate {S : Finset (Fin n)} {A : Operator n} | |
| (hA : IsSupported S A) (J : Disorder n) (E : Finset (Edge n)) (t : ℝ) : | |
| IsSupported (neighborhood E S) | |
| ((evolution t (maskedCost J E))ᴴ*A*evolution t (maskedCost J E)) := by | |
| rw [cost_conjugate_local hA] | |
| exact (((maskedCost_active_supported J E S).evolve t).adjoint.mul | |
| (hA.mono (subset_neighborhood E S))).mul | |
| ((maskedCost_active_supported J E S).evolve t) | |
| end SKQAOA.Locality | |
| open scoped BigOperators Matrix Topology Matrix.Norms.Operator | |
| open MeasureTheory ProbabilityTheory Filter | |
| namespace SKQAOA.Locality | |
| variable {n : ℕ} | |
| theorem activeEdges_mono {E F : Finset (Edge n)} {S T : Finset (Fin n)} | |
| (hEF : E⊆F) (hST : S⊆T) : activeEdges E S⊆activeEdges F T := by | |
| intro e he | |
| rcases Finset.mem_filter.mp he with ⟨he,ht⟩ | |
| refine Finset.mem_filter.mpr ⟨hEF he,?_⟩ | |
| exact ht.elim (fun h => Or.inl (hST h)) (fun h => Or.inr (hST h)) | |
| theorem neighborhood_mono {E F : Finset (Edge n)} {S T : Finset (Fin n)} | |
| (hEF : E⊆F) (hST : S⊆T) : neighborhood E S⊆neighborhood F T := by | |
| apply Finset.union_subset_union hST | |
| intro i hi | |
| rcases Finset.mem_biUnion.mp hi with ⟨e,he,hi⟩ | |
| exact Finset.mem_biUnion.mpr ⟨e,activeEdges_mono hEF hST he,hi⟩ | |
| def relevantEdges (E : Finset (Edge n)) : | |
| List PointedTree.Gate → Finset (Fin n) → Finset (Edge n) | |
| | [], _ => ∅ | |
| | .mixer _ :: w, S => relevantEdges E w S | |
| | .cost _ :: w, S => activeEdges E S ∪ relevantEdges E w (neighborhood E S) | |
| theorem relevantEdges_subset (E : Finset (Edge n)) (w : List PointedTree.Gate) | |
| (S : Finset (Fin n)) : relevantEdges E w S⊆E := by | |
| induction w generalizing S with | |
| | nil => exact Finset.empty_subset E | |
| | cons g w ih => | |
| cases g with | |
| | mixer t => exact ih S | |
| | cost t => exact Finset.union_subset (Finset.filter_subset _ _) (ih _) | |
| theorem relevantEdges_mono {E F : Finset (Edge n)} {S T : Finset (Fin n)} | |
| (hEF : E⊆F) (hST : S⊆T) (w : List PointedTree.Gate) : | |
| relevantEdges E w S⊆relevantEdges F w T := by | |
| induction w generalizing S T with | |
| | nil => exact Finset.Subset.refl _ | |
| | cons g w ih => | |
| cases g with | |
| | mixer t => exact ih hST | |
| | cost t => | |
| exact Finset.union_subset_union (activeEdges_mono hEF hST) | |
| (ih (neighborhood_mono hEF hST)) | |
| def wordConjugate (J : Disorder n) (E : Finset (Edge n)) | |
| (w : List PointedTree.Gate) (A : Operator n) : Operator n := | |
| (physicalWord n (maskedDisorder J E) w)ᴴ*A*physicalWord n (maskedDisorder J E) w | |
| @[simp] theorem wordConjugate_nil (J : Disorder n) (E : Finset (Edge n)) | |
| (A : Operator n) : wordConjugate J E [] A=A := by simp [wordConjugate] | |
| theorem wordConjugate_cons (J : Disorder n) (E : Finset (Edge n)) | |
| (g : PointedTree.Gate) (w : List PointedTree.Gate) (A : Operator n) : | |
| wordConjugate J E (g::w) A = wordConjugate J E w | |
| ((physicalGate n (maskedDisorder J E) g)ᴴ*A*physicalGate n (maskedDisorder J E) g) := by | |
| simp only [wordConjugate,physicalWord_cons,Matrix.conjTranspose_mul] | |
| noncomm_ring | |
| @[simp] theorem wordConjugate_cost (J : Disorder n) (E : Finset (Edge n)) | |
| (t : ℝ) (w : List PointedTree.Gate) (A : Operator n) : | |
| wordConjugate J E (.cost t::w) A = wordConjugate J E w | |
| ((evolution t (maskedCost J E))ᴴ*A*evolution t (maskedCost J E)) := | |
| wordConjugate_cons J E _ w A | |
| @[simp] theorem wordConjugate_mixer (J : Disorder n) (E : Finset (Edge n)) | |
| (t : ℝ) (w : List PointedTree.Gate) (A : Operator n) : | |
| wordConjugate J E (.mixer t::w) A = wordConjugate J E w | |
| ((evolution t (mixer n))ᴴ*A*evolution t (mixer n)) := | |
| wordConjugate_cons J E _ w A | |
| theorem wordConjugate_eq_of_relevant_subset (J : Disorder n) | |
| {E F : Finset (Edge n)} (hFE : F⊆E) (w : List PointedTree.Gate) | |
| {S : Finset (Fin n)} {A : Operator n} (hA : IsSupported S A) | |
| (hrel : relevantEdges E w S⊆F) : | |
| wordConjugate J E w A=wordConjugate J F w A := by | |
| induction w generalizing S A with | |
| | nil => simp | |
| | cons g w ih => | |
| cases g with | |
| | mixer t => | |
| simp only [wordConjugate_mixer] | |
| exact ih (hA.mixer_conjugate t) hrel | |
| | cost t => | |
| have ha : activeEdges E S⊆F := Finset.union_subset_iff.mp hrel |>.1 | |
| have hr : relevantEdges E w (neighborhood E S)⊆F := | |
| Finset.union_subset_iff.mp hrel |>.2 | |
| have heq : activeEdges E S=activeEdges F S := by | |
| apply Finset.Subset.antisymm | |
| · intro e he | |
| exact Finset.mem_filter.mpr ⟨ha he,(Finset.mem_filter.mp he).2⟩ | |
| · exact activeEdges_mono hFE (Finset.Subset.refl _) | |
| have heqA : (evolution t (maskedCost J E))ᴴ*A*evolution t (maskedCost J E) = | |
| (evolution t (maskedCost J F))ᴴ*A*evolution t (maskedCost J F) := by | |
| rw [cost_conjugate_local hA J E,cost_conjugate_local hA J F,heq] | |
| simp only [wordConjugate_cost] | |
| rw [←heqA] | |
| exact ih (hA.cost_conjugate J E t) hr | |
| theorem wordConjugate_insert_irrelevant (J : Disorder n) | |
| {H M : Finset (Edge n)} {e : Edge n} (he : e∈H) (hM : M⊆H) | |
| (w : List PointedTree.Gate) {S : Finset (Fin n)} {A : Operator n} | |
| (hA : IsSupported S A) (hirr : e∉relevantEdges H w S) : | |
| wordConjugate J (insert e M) w A=wordConjugate J M w A := by | |
| apply wordConjugate_eq_of_relevant_subset J (Finset.subset_insert _ _) w hA | |
| intro f hf | |
| have hf' := relevantEdges_subset (insert e M) w S hf | |
| rcases Finset.mem_insert.mp hf' with rfl|hf' | |
| · exact False.elim (hirr (relevantEdges_mono (Finset.insert_subset he hM) | |
| (Finset.Subset.refl S) w hf)) | |
| · exact hf' | |
| end SKQAOA.Locality | |
| open scoped BigOperators | |
| namespace FiniteEdgeExpansion | |
| variable {E R A : Type*} [DecidableEq E] [CommRing R] | |
| def mixedDifference (S : Finset E) (F : Finset E → R) : R := | |
| ∑ T ∈ S.powerset, (-1 : R)^T.card * F (S \ T) | |
| @[simp] theorem mixedDifference_empty (F : Finset E → R) : | |
| mixedDifference ∅ F = F ∅ := by simp [mixedDifference] | |
| theorem mixedDifference_insert (S : Finset E) (e : E) (he : e ∉ S) | |
| (F : Finset E → R) : | |
| mixedDifference (insert e S) F = | |
| mixedDifference S (fun T => F (insert e T)) - mixedDifference S F := by | |
| unfold mixedDifference | |
| rw [Finset.sum_powerset_insert he] | |
| have heT (T : Finset E) (hT : T ∈ S.powerset) : e ∉ T := by | |
| intro h | |
| exact he (Finset.mem_powerset.mp hT h) | |
| have hfirst (T : Finset E) (hT : T ∈ S.powerset) : | |
| insert e S \ T = insert e (S \ T) := by | |
| ext x | |
| by_cases hx : x=e <;> simp [hx, heT T hT] | |
| have hsecond (T : Finset E) (hT : T ∈ S.powerset) : | |
| insert e S \ insert e T = S \ T := by | |
| ext x | |
| by_cases hx : x=e <;> simp [hx,he] | |
| have h₁ : (∑ T ∈ S.powerset, (-1:R)^T.card * F (insert e S \ T)) = | |
| ∑ T ∈ S.powerset, (-1:R)^T.card * F (insert e (S \ T)) := by | |
| apply Finset.sum_congr rfl | |
| intro T hT | |
| rw [hfirst T hT] | |
| have h₂ : (∑ T ∈ S.powerset, (-1:R)^(insert e T).card * F (insert e S \ insert e T)) = | |
| -(∑ T ∈ S.powerset, (-1:R)^T.card * F (S \ T)) := by | |
| rw [←Finset.sum_neg_distrib] | |
| apply Finset.sum_congr rfl | |
| intro T hT | |
| rw [Finset.card_insert_of_notMem (heT T hT), hsecond T hT, pow_succ] | |
| ring | |
| rw [h₁,h₂] | |
| ring | |
| theorem mixedDifference_eq_zero_of_irrelevant {S : Finset E} {e : E} | |
| (he : e ∈ S) (F : Finset E → R) | |
| (hF : ∀ T ⊆ S.erase e, F (insert e T) = F T) : | |
| mixedDifference S F = 0 := by | |
| rw [←Finset.insert_erase he, mixedDifference_insert _ _ (Finset.notMem_erase e S)] | |
| have h : mixedDifference (S.erase e) (fun T => F (insert e T)) = | |
| mixedDifference (S.erase e) F := by | |
| apply Finset.sum_congr rfl | |
| intro T hT | |
| dsimp only | |
| rw [hF _ (Finset.sdiff_subset)] | |
| rw [h,sub_self] | |
| theorem reconstruction (H : Finset E) (F : Finset E → R) : | |
| (∑ S ∈ H.powerset, mixedDifference S F)=F H := by | |
| induction H using Finset.induction_on generalizing F with | |
| | empty => simp | |
| | @insert e H he ih => | |
| rw [Finset.sum_powerset_insert he] | |
| have hs : (∑S ∈ H.powerset, mixedDifference (insert e S) F) = | |
| (∑S ∈ H.powerset, mixedDifference S (fun T => F (insert e T))) - | |
| ∑S ∈ H.powerset, mixedDifference S F := by | |
| rw [←Finset.sum_sub_distrib] | |
| apply Finset.sum_congr rfl | |
| intro S hS | |
| exact mixedDifference_insert S e | |
| (fun h => he (Finset.mem_powerset.mp hS h)) F | |
| rw [hs,ih,ih] | |
| ring | |
| variable [Fintype A] | |
| def partition (q : A → R) (I : A → E → R) (S : Finset E) : R := | |
| ∑ a, q a * ∏ e ∈ S, I a e | |
| def coefficient (q : A → R) (I : A → E → R) (S : Finset E) : R := | |
| ∑ a, q a * ∏ e ∈ S, (I a e - 1) | |
| omit [DecidableEq E] in | |
| theorem partition_expansion (q : A → R) (I : A → E → R) (S : Finset E) : | |
| partition q I S = ∑ T ∈ S.powerset, coefficient q I T := by | |
| unfold partition coefficient | |
| have hp (a : A) : (∏ e ∈ S, I a e) = | |
| ∑ T ∈ S.powerset, ∏ e ∈ T, (I a e-1) := by | |
| simpa using (Finset.prod_one_add (f := fun e => I a e-1) S) | |
| simp_rw [hp,Finset.mul_sum] | |
| exact Finset.sum_comm | |
| theorem coefficient_eq_mixedDifference (q : A → R) (I : A → E → R) (S : Finset E) : | |
| coefficient q I S = mixedDifference S (partition q I) := by | |
| unfold coefficient mixedDifference partition | |
| simp only [Finset.mul_sum] | |
| rw [Finset.sum_comm] | |
| apply Finset.sum_congr rfl | |
| intro a ha | |
| have hp := Finset.prod_sub (fun e => I a e) (fun _ : E => (1:R)) S | |
| simp only [Finset.prod_const_one,mul_one] at hp | |
| rw [hp,Finset.mul_sum] | |
| apply Finset.sum_congr rfl | |
| intro T hT | |
| ring | |
| theorem coefficient_eq_zero_of_irrelevant (q : A → R) (I : A → E → R) | |
| {S : Finset E} {e : E} (he : e ∈ S) | |
| (hF : ∀ T ⊆ S.erase e, partition q I (insert e T) = partition q I T) : | |
| coefficient q I S = 0 := by | |
| rw [coefficient_eq_mixedDifference] | |
| exact mixedDifference_eq_zero_of_irrelevant he _ hF | |
| end FiniteEdgeExpansion | |
| open scoped BigOperators Matrix Topology Matrix.Norms.Operator | |
| open MeasureTheory ProbabilityTheory Filter | |
| namespace SKQAOA.Locality | |
| variable {n : ℕ} | |
| def annealedObservable (μ : Measure (Disorder n)) (a : Disorder n → ℂ) | |
| (B : Finset (Edge n)) (w : List PointedTree.Gate) (A : Disorder n → Operator n) | |
| (E : Finset (Edge n)) : ℂ := | |
| ∫J, a J * quad ((physicalWord n (maskedDisorder J (E∪B)) w).mulVec (plus n)) (A J) ∂μ | |
| theorem annealed_mixedDifference_eq_zero (μ : Measure (Disorder n)) (a : Disorder n → ℂ) | |
| (B : Finset (Edge n)) (w : List PointedTree.Gate) (A : Disorder n → Operator n) | |
| (S : Finset (Fin n)) (hA : ∀J, IsSupported S (A J)) | |
| {H : Finset (Edge n)} {e : Edge n} (he : e∈H) | |
| (hirr : e∉relevantEdges (H∪B) w S) : | |
| FiniteEdgeExpansion.mixedDifference H (annealedObservable μ a B w A)=0 := by | |
| apply FiniteEdgeExpansion.mixedDifference_eq_zero_of_irrelevant he | |
| intro M hM | |
| apply integral_congr_ae | |
| filter_upwards [] with J | |
| congr 1 | |
| rw [quad_mulVec,quad_mulVec] | |
| change quad (plus n) (wordConjugate J (insert e M∪B) w (A J)) = | |
| quad (plus n) (wordConjugate J (M∪B) w (A J)) | |
| rw [Finset.insert_union] | |
| congr 1 | |
| exact wordConjugate_insert_irrelevant J (Finset.mem_union_left B he) | |
| (Finset.union_subset_union (hM.trans (Finset.erase_subset e H)) (Finset.Subset.refl B)) | |
| w (hA J) hirr | |
| def averagedMarkedWord (r : Edge n) (w : List PointedTree.Gate) | |
| (E : Finset (Edge n)) : ℂ := | |
| annealedObservable (disorderLaw n) (fun J => (J r:ℂ)) {r} w | |
| (fun _ => pauliZ r.1.1*pauliZ r.1.2) E | |
| theorem marked_cluster_eq_zero (r : Edge n) (w : List PointedTree.Gate) | |
| {H : Finset (Edge n)} {e : Edge n} (he : e∈H) | |
| (hirr : e∉relevantEdges (H∪{r}) w {r.1.1,r.1.2}) : | |
| FiniteEdgeExpansion.mixedDifference H (averagedMarkedWord r w)=0 := by | |
| apply annealed_mixedDifference_eq_zero (disorderLaw n) (fun J => (J r:ℂ)) | |
| {r} w (fun _ => pauliZ r.1.1*pauliZ r.1.2) {r.1.1,r.1.2} _ he hirr | |
| intro J | |
| exact (supported_pauliZ (by simp)).mul (supported_pauliZ (by simp)) | |
| end SKQAOA.Locality | |
| open scoped BigOperators Matrix Topology ComplexConjugate | |
| open MeasureTheory ProbabilityTheory Filter | |
| namespace SKQAOA | |
| def qaoaWord : (p : ℕ) → (Fin p → ℝ) → (Fin p → ℝ) → List PointedTree.Gate | |
| | 0, _, _ => [] | |
| | p+1, γ, β => .mixer (β (Fin.last p)) :: .cost (γ (Fin.last p)) :: | |
| qaoaWord p (fun i => γ i.castSucc) (fun i => β i.castSucc) | |
| @[simp] theorem physicalWord_qaoaWord (n p : ℕ) (J : Disorder n) (γ β : Fin p → ℝ) : | |
| physicalWord n J (qaoaWord p γ β)=circuit J p γ β := by | |
| induction p with | |
| | zero => rfl | |
| | succ p ih => simp only [qaoaWord,physicalWord,physicalGate,ih,circuit,mul_assoc] | |
| namespace SiteHistories | |
| instance bitsInhabited : (p : ℕ) → Inhabited (Bits p) | |
| | 0 => inferInstanceAs (Inhabited Unit) | |
| | p+1 => @instInhabitedProd Bool (Bits p) inferInstance (bitsInhabited p) | |
| def maskPhase (n p : ℕ) (γ : Fin p → ℝ) (a b : History n p) | |
| (E : Finset (Edge n)) (e : Edge n) : ℂ := | |
| if e∈E then pairedPhase n p γ a b e else 0 | |
| lemma masked_phase_sum (n p : ℕ) (J : Disorder n) (γ : Fin p → ℝ) | |
| (a b : History n p) (E : Finset (Edge n)) : | |
| (∑e, pairedPhase n p γ a b e*(Locality.maskedDisorder J E e:ℂ))= | |
| ∑e, maskPhase n p γ a b E e*(J e:ℂ) := by | |
| apply Finset.sum_congr rfl | |
| intro e he | |
| simp only [Locality.maskedDisorder,maskPhase] | |
| split_ifs <;> simp | |
| lemma coord_masked_history (n p : ℕ) (J : Disorder n) (γ β : Fin p → ℝ) | |
| (σ : Configuration n) (r : Edge n) (E : Finset (Edge n)) : | |
| (J r:ℂ)*(star (qaoaState n p (Locality.maskedDisorder J E) γ β σ)* | |
| qaoaState n p (Locality.maskedDisorder J E) γ β σ)= | |
| ∑a:History n p, ∑b:History n p, pairedMix n p β σ a b * | |
| ((J r:ℂ)*Complex.exp (∑e,maskPhase n p γ a b E e*(J e:ℂ))) := by | |
| rw [qaoaState_pair_history] | |
| simp only [Finset.mul_sum,masked_phase_sum] | |
| apply Finset.sum_congr rfl | |
| intro a ha | |
| apply Finset.sum_congr rfl | |
| intro b hb | |
| ring | |
| lemma integral_coord_masked (n p : ℕ) (γ β : Fin p → ℝ) | |
| (σ : Configuration n) (r : Edge n) (E : Finset (Edge n)) : | |
| (∫J:Disorder n, (J r:ℂ)* | |
| (star (qaoaState n p (Locality.maskedDisorder J E) γ β σ)* | |
| qaoaState n p (Locality.maskedDisorder J E) γ β σ) ∂disorderLaw n)= | |
| ∑a:History n p, ∑b:History n p, pairedMix n p β σ a b * | |
| maskPhase n p γ a b E r * Complex.exp (∑e,(maskPhase n p γ a b E e)^2/2) := by | |
| simp_rw [coord_masked_history] | |
| have hx (a b : History n p) : Integrable (fun J : Disorder n => pairedMix n p β σ a b * | |
| ((J r:ℂ)*Complex.exp (∑e, maskPhase n p γ a b E e*(J e:ℂ)))) (disorderLaw n) := | |
| (GaussianFourier.integrable_coord_exp_sum (maskPhase n p γ a b E) r).const_mul _ | |
| rw [integral_finsetSum _ (fun a _ => integrable_finsetSum _ (fun b _ => hx a b))] | |
| apply Finset.sum_congr rfl | |
| intro a ha | |
| rw [integral_finsetSum _ (fun b _ => hx a b)] | |
| apply Finset.sum_congr rfl | |
| intro b hb | |
| rw [integral_const_mul] | |
| change _ * (∫J:Disorder n, _ ∂GaussianFourier.law (Edge n))=_ | |
| rw [GaussianFourier.integral_coord_exp_sum,mul_assoc] | |
| lemma integrable_coord_masked (n p : ℕ) (γ β : Fin p → ℝ) | |
| (σ : Configuration n) (r : Edge n) (E : Finset (Edge n)) : | |
| Integrable (fun J:Disorder n => (J r:ℂ)* | |
| (star (qaoaState n p (Locality.maskedDisorder J E) γ β σ)* | |
| qaoaState n p (Locality.maskedDisorder J E) γ β σ)) (disorderLaw n) := by | |
| simp_rw [coord_masked_history] | |
| exact integrable_finsetSum _ (fun a _ => integrable_finsetSum _ (fun b _ => | |
| (GaussianFourier.integrable_coord_exp_sum (maskPhase n p γ a b E) r).const_mul _)) | |
| lemma quad_ZZ (n : ℕ) (ψ : State n) (r : Edge n) : | |
| quad ψ (pauliZ r.1.1*pauliZ r.1.2)= | |
| ∑σ:Configuration n,(spin σ r.1.1:ℂ)*(spin σ r.1.2:ℂ)*(star (ψ σ)*ψ σ) := by | |
| simp only [pauliZ,Matrix.diagonal_mul_diagonal,quad,Matrix.mulVec_diagonal, | |
| dotProduct,Pi.star_apply] | |
| apply Finset.sum_congr rfl | |
| intro σ hσ | |
| ring | |
| theorem averagedMarkedWord_history (n p : ℕ) (γ β : Fin p → ℝ) | |
| (r : Edge n) (E : Finset (Edge n)) : | |
| Locality.averagedMarkedWord r (qaoaWord p γ β) E= | |
| ∑σ:Configuration n, ∑a:History n p, ∑b:History n p, | |
| (spin σ r.1.1:ℂ)*(spin σ r.1.2:ℂ)*pairedMix n p β σ a b * | |
| pairedPhase n p γ a b r * | |
| Complex.exp (∑e, (maskPhase n p γ a b (E∪{r}) e)^2/2) := by | |
| unfold Locality.averagedMarkedWord Locality.annealedObservable | |
| simp only [physicalWord_qaoaWord] | |
| change (∫J:Disorder n, (J r:ℂ)*quad | |
| (qaoaState n p (Locality.maskedDisorder J (E∪{r})) γ β) | |
| (pauliZ r.1.1*pauliZ r.1.2) ∂disorderLaw n)=_ | |
| simp only [quad_ZZ,Finset.mul_sum] | |
| have hi (σ : Configuration n) := | |
| (integrable_coord_masked n p γ β σ r (E∪{r})).const_mul | |
| ((spin σ r.1.1:ℂ)*(spin σ r.1.2:ℂ)) | |
| have rearr (J : Disorder n) (σ : Configuration n) : | |
| (J r:ℂ)*((spin σ r.1.1:ℂ)*(spin σ r.1.2:ℂ)* | |
| (star (qaoaState n p (Locality.maskedDisorder J (E∪{r})) γ β σ)* | |
| qaoaState n p (Locality.maskedDisorder J (E∪{r})) γ β σ))= | |
| ((spin σ r.1.1:ℂ)*(spin σ r.1.2:ℂ))*((J r:ℂ)* | |
| (star (qaoaState n p (Locality.maskedDisorder J (E∪{r})) γ β σ)* | |
| qaoaState n p (Locality.maskedDisorder J (E∪{r})) γ β σ)) := by ring | |
| simp_rw [rearr] | |
| rw [integral_finsetSum _ (fun σ _ => hi σ)] | |
| apply Finset.sum_congr rfl | |
| intro σ hσ | |
| rw [integral_const_mul,integral_coord_masked] | |
| simp only [Finset.mul_sum,maskPhase,Finset.mem_union,Finset.mem_singleton, | |
| or_true,ite_true] | |
| apply Finset.sum_congr rfl | |
| intro a ha | |
| apply Finset.sum_congr rfl | |
| intro b hb | |
| ring | |
| end SiteHistories | |
| end SKQAOA | |
| open scoped BigOperators Matrix Topology ComplexConjugate | |
| open MeasureTheory ProbabilityTheory Filter | |
| namespace SKQAOA.SiteHistories | |
| variable {n : ℕ} | |
| def rootFactor (p : ℕ) (γ : Fin p → ℝ) (r : Edge n) (a : Fin n → Site p) : ℂ := | |
| (bitSpin (a r.1.1).1:ℂ)*(bitSpin (a r.1.2).1:ℂ)*Complex.I* | |
| ((Real.sqrt (n:ℝ))⁻¹:ℂ)*(delta p γ (a r.1.1) (a r.1.2):ℂ)* | |
| (edgeKernel n p γ (a r.1.1) (a r.1.2):ℂ) | |
| def factor (p : ℕ) (γ : Fin p → ℝ) (r : Edge n) | |
| (a : Fin n → Site p) (e : Edge n) : ℂ := | |
| if e=r then 1 else (edgeKernel n p γ (a e.1.1) (a e.1.2):ℂ) | |
| def partition (p : ℕ) (γ β : Fin p → ℝ) (r : Edge n) (E : Finset (Edge n)) : ℂ := | |
| FiniteHistory.expectation (weight p β) (fun a => rootFactor p γ r a * ∏e∈E,factor p γ r a e) | |
| def cluster (p : ℕ) (γ β : Fin p → ℝ) (r : Edge n) (H : Finset (Edge n)) : ℂ := | |
| FiniteHistory.expectation (weight p β) | |
| (fun a => rootFactor p γ r a * ∏e∈H,(factor p γ r a e-1)) | |
| lemma exp_maskPhase_sq (p : ℕ) (γ : Fin p → ℝ) | |
| (h : Configuration n × History n p × History n p) (E : Finset (Edge n)) : | |
| Complex.exp (∑e,(maskPhase n p γ h.2.1 h.2.2 E e)^2/2)= | |
| ∏e∈E,(edgeKernel n p γ (trajectoriesEquiv n p h e.1.1) | |
| (trajectoriesEquiv n p h e.1.2):ℂ) := by | |
| rw [Complex.exp_sum] | |
| have he (e : Edge n) : Complex.exp ((maskPhase n p γ h.2.1 h.2.2 E e)^2/2)= | |
| if e∈E then (edgeKernel n p γ (trajectoriesEquiv n p h e.1.1) | |
| (trajectoriesEquiv n p h e.1.2):ℂ) else 1 := by | |
| by_cases he : e∈E | |
| · simp only [maskPhase,he,ite_true,exp_pairedPhase_sq] | |
| · simp [maskPhase,he] | |
| simp_rw [he] | |
| rw [Finset.prod_ite_mem,Finset.univ_inter] | |
| lemma prod_union_root {A : Type*} [DecidableEq A] (E : Finset A) (r : A) (f : A → ℂ) : | |
| (∏e∈E∪{r},f e)=f r*∏e∈E,if e=r then 1 else f e := by | |
| induction E using Finset.induction_on with | |
| | empty => simp | |
| | @insert e E he ih => | |
| by_cases her : e=r | |
| · subst e | |
| rw [Finset.insert_union,Finset.insert_eq_of_mem (by simp), | |
| Finset.prod_insert he,ite_eq_left rfl,one_mul] | |
| exact ih | |
| · rw [Finset.insert_union,Finset.prod_insert (by simpa [her] using he), | |
| Finset.prod_insert he,ite_eq_right her,ih] | |
| ring | |
| theorem partition_eq_marked (p : ℕ) (γ β : Fin p → ℝ) (r : Edge n) | |
| (E : Finset (Edge n)) : | |
| partition p γ β r E=Locality.averagedMarkedWord r (qaoaWord p γ β) E := by | |
| rw [averagedMarkedWord_history] | |
| have hs := (trajectoriesEquiv n p).sum_comp (fun a => | |
| (∏i,weight p β (a i))*(rootFactor p γ r a*∏e∈E,factor p γ r a e)) | |
| rw [Fintype.sum_prod_type] at hs | |
| simp_rw [Fintype.sum_prod_type] at hs | |
| unfold partition FiniteHistory.expectation | |
| rw [←hs] | |
| apply Finset.sum_congr rfl | |
| intro σ hσ | |
| apply Finset.sum_congr rfl | |
| intro a ha | |
| apply Finset.sum_congr rfl | |
| intro b hb | |
| rw [pairedMix_factor,pairedPhase_local n p γ (σ,a,b) r, | |
| exp_maskPhase_sq p γ (σ,a,b),prod_union_root] | |
| simp only [rootFactor,factor,trajectoriesEquiv_apply] | |
| change (∏i, weight p β (σ i,atVertex n p a i,atVertex n p b i))* | |
| ((spin σ r.1.1:ℂ)*(spin σ r.1.2:ℂ)*Complex.I*((Real.sqrt (n:ℝ))⁻¹:ℂ)* | |
| (delta p γ (σ r.1.1,atVertex n p a r.1.1,atVertex n p b r.1.1) | |
| (σ r.1.2,atVertex n p a r.1.2,atVertex n p b r.1.2):ℂ)* | |
| (edgeKernel n p γ (σ r.1.1,atVertex n p a r.1.1,atVertex n p b r.1.1) | |
| (σ r.1.2,atVertex n p a r.1.2,atVertex n p b r.1.2):ℂ)* | |
| ∏e∈E,factor p γ r (trajectoriesEquiv n p (σ,a,b)) e)=_ | |
| ac_rfl | |
| theorem cluster_eq_mixedDifference (p : ℕ) (γ β : Fin p → ℝ) (r : Edge n) | |
| (H : Finset (Edge n)) : | |
| cluster p γ β r H=FiniteEdgeExpansion.mixedDifference H | |
| (Locality.averagedMarkedWord r (qaoaWord p γ β)) := by | |
| have hp (E : Finset (Edge n)) : | |
| FiniteEdgeExpansion.partition (fun a : Fin n → Site p => | |
| (∏i,weight p β (a i))*rootFactor p γ r a) (factor p γ r) E= | |
| partition p γ β r E := by | |
| simp only [FiniteEdgeExpansion.partition,partition,FiniteHistory.expectation,mul_assoc] | |
| have hc : cluster p γ β r H=FiniteEdgeExpansion.coefficient | |
| (fun a : Fin n → Site p => (∏i,weight p β (a i))*rootFactor p γ r a) | |
| (factor p γ r) H := by | |
| simp only [FiniteEdgeExpansion.coefficient,cluster,FiniteHistory.expectation,mul_assoc] | |
| rw [hc,FiniteEdgeExpansion.coefficient_eq_mixedDifference] | |
| congr 1 | |
| funext E | |
| rw [hp,partition_eq_marked] | |
| theorem cluster_eq_zero (p : ℕ) (γ β : Fin p → ℝ) (r : Edge n) | |
| {H : Finset (Edge n)} {e : Edge n} (he : e∈H) | |
| (hirr : e∉Locality.relevantEdges (H∪{r}) (qaoaWord p γ β) {r.1.1,r.1.2}) : | |
| cluster p γ β r H=0 := by | |
| rw [cluster_eq_mixedDifference] | |
| exact Locality.marked_cluster_eq_zero r _ he hirr | |
| theorem marked_eq_sum_clusters (p : ℕ) (γ β : Fin p → ℝ) (r : Edge n) | |
| (E : Finset (Edge n)) : | |
| Locality.averagedMarkedWord r (qaoaWord p γ β) E= | |
| ∑H∈E.powerset,cluster p γ β r H := by | |
| simp_rw [cluster_eq_mixedDifference] | |
| exact (FiniteEdgeExpansion.reconstruction E _).symm | |
| end SKQAOA.SiteHistories | |
| end | |
| end OAI | |