| import OAI.RepresentationTheory.RowColumn.TensorFilter |
| import OAI.RepresentationTheory.RowColumn.HookIsometry |
|
|
| namespace OAI |
|
|
| section |
| noncomputable section |
| open scoped BigOperators Classical |
| namespace RowColumn.Postselection |
| open WordOrbits |
| variable {S L A : Type*} [Fintype S] [DecidableEq S] [Fintype L] [DecidableEq L] |
| [Fintype A] [DecidableEq A] |
|
|
| def allocationPerm (line b : S → L) (hb : counts b = counts line) : Equiv.Perm S := |
| (same_counts_permutation line b hb.symm).choose |
|
|
| omit [DecidableEq S] [Fintype L] in |
| lemma allocationPerm_spec (line b : S → L) (hb : counts b = counts line) (i : S) : |
| b (allocationPerm line b hb i) = line i := |
| (same_counts_permutation line b hb.symm).choose_spec i |
|
|
| omit [DecidableEq S] [Fintype A] in |
| lemma counts_precomp (w : S → A) (p : Equiv.Perm S) : counts (w ∘ p) = counts w := by |
| funext c |
| apply Fin.ext |
| exact Fintype.card_congr |
| { toFun := fun i => ⟨p i.1,i.2⟩ |
| invFun := fun i => ⟨p.symm i.1,by simpa using i.2⟩ |
| left_inv := by intro i; apply Subtype.ext; simp |
| right_inv := by intro i; apply Subtype.ext; simp } |
|
|
| def symExtension (line : S → L) (v : (S → A) → ℂ) (w : S → L × A) : ℂ := |
| if hb : counts (fun i => (w i).1) = counts line then |
| v (fun i => (w (allocationPerm line _ hb i)).2) else 0 |
|
|
| omit [Fintype A] [DecidableEq A] in |
| omit [DecidableEq S] in |
| lemma symExtension_on_line (line : S → L) (v : (S → A) → ℂ) |
| (hv : ∀ p : Equiv.Perm S, (∀ i, line (p i) = line i) → ∀ w, v (w ∘ p) = v w) |
| (w : S → A) : symExtension line v (fun i => (line i,w i)) = v w := by |
| simp only [symExtension] |
| exact hv (allocationPerm line line rfl) (allocationPerm_spec line line rfl) w |
|
|
| omit [Fintype A] [DecidableEq A] in |
| omit [DecidableEq S] in |
| lemma symExtension_invariant (line : S → L) (v : (S → A) → ℂ) |
| (hv : ∀ p : Equiv.Perm S, (∀ i, line (p i) = line i) → ∀ w, v (w ∘ p) = v w) |
| (p : Equiv.Perm S) (w : S → L × A) : symExtension line v (w ∘ p) = symExtension line v w := by |
| have hc : counts (fun i => (w (p i)).1) = counts (fun i => (w i).1) := counts_precomp (fun i => (w i).1) p |
| by_cases hb : counts (fun i => (w i).1) = counts line |
| · have hb' : counts (fun i => (w (p i)).1) = counts line := hc.trans hb |
| simp only [symExtension, Function.comp_apply, dite_eq_left hb, dite_eq_left hb'] |
| let e := allocationPerm line (fun i => (w i).1) hb |
| let e' := allocationPerm line (fun i => (w (p i)).1) hb' |
| let q : Equiv.Perm S := e'.trans (p.trans e.symm) |
| have hq (i : S) : line (q i) = line i := by |
| rw [← allocationPerm_spec line (fun i => (w i).1) hb (q i)] |
| change (w (e (e.symm (p (e' i))))).1 = line i |
| rw [Equiv.apply_symm_apply] |
| exact allocationPerm_spec line (fun i => (w (p i)).1) hb' i |
| have hh := hv q hq (fun i => (w (e i)).2) |
| change v (fun i => (w (p (e' i))).2) = v (fun i => (w (e i)).2) |
| convert hh using 1 |
| congr 1 |
| ext i |
| simp only [q, Equiv.trans_apply, Function.comp_apply, Equiv.apply_symm_apply] |
| · have hb' : ¬ counts (fun i => (w (p i)).1) = counts line := fun hh => hb (hc.symm.trans hh) |
| simp only [symExtension, Function.comp_apply, dite_eq_right hb, dite_eq_right hb'] |
|
|
| omit [Fintype A] in |
| omit [DecidableEq S] in |
| lemma symExtension_counts (line : S → L) (v : (S → A) → ℂ) |
| (hv : ∀ p : Equiv.Perm S, (∀ i, line (p i) = line i) → ∀ w, v (w ∘ p) = v w) |
| (w z : S → L × A) (he : counts w = counts z) : symExtension line v w = symExtension line v z := by |
| obtain ⟨p,hp⟩ := same_counts_permutation w z he |
| have hh : z ∘ p = w := funext hp |
| rw [← hh] |
| exact symExtension_invariant line v hv p z |
|
|
| abbrev Allocations (line : S → L) := {b : S → L |
|
|
| def labelWordEquiv : (S → L × A) ≃ (S → L) × (S → A) where |
| toFun w := (fun i => (w i).1, fun i => (w i).2) |
| invFun w i := (w.1 i,w.2 i) |
| left_inv := by intro w; rfl |
| right_inv := by intro w; rfl |
|
|
| def precompWordEquiv (p : Equiv.Perm S) : Equiv.Perm (S → A) where |
| toFun w := w ∘ p |
| invFun w := w ∘ p.symm |
| left_inv := by intro w; ext i; simp |
| right_inv := by intro w; ext i; simp |
|
|
| omit [DecidableEq A] in |
| lemma symExtension_norm (line : S → L) (v : (S → A) → ℂ) : |
| (∑ w : S → L × A, Complex.normSq (symExtension line v w)) = |
| (Fintype.card (Allocations line) : ℝ) * ∑ w : S → A, Complex.normSq (v w) := by |
| rw [← (labelWordEquiv (S := S) (L := L) (A := A)).symm.sum_comp, |
| Fintype.sum_prod_type] |
| change (∑ b : S → L, ∑ w : S → A, Complex.normSq |
| (if hb : counts b=counts line then v (w ∘ allocationPerm line b hb) else 0)) = _ |
| have he (b : S → L) : (∑ w : S → A, Complex.normSq |
| (if hb : counts b=counts line then v (w ∘ allocationPerm line b hb) else 0)) = |
| if counts b=counts line then ∑ w : S → A, Complex.normSq (v w) else 0 := by |
| split_ifs with hb |
| · exact Equiv.sum_comp (precompWordEquiv (A := A) (allocationPerm line b hb)) (fun w => Complex.normSq (v w)) |
| · simp |
| simp_rw [he] |
| simp [Finset.sum_ite, Fintype.card_subtype, Allocations] |
|
|
|
|
| def labelTest (line : S → L) (x : (S → A) → ℂ) (w : S → L × A) : ℂ := |
| if (fun i => (w i).1)=line then x (fun i => (w i).2) else 0 |
|
|
| omit [DecidableEq A] in |
| lemma labeled_pair (line : S → L) (x : (S → A) → ℂ) (f : (S → L × A) → ℂ) : |
| (∑ w, f w * labelTest line x w) = ∑ w : S → A, f (fun i => (line i,w i)) * x w := by |
| rw [← (labelWordEquiv (S := S) (L := L) (A := A)).symm.sum_comp, |
| Fintype.sum_prod_type] |
| change (∑ b : S → L, ∑ w : S → A, f (fun i => (b i,w i)) * |
| (if b=line then x w else 0)) = _ |
| simp only [mul_ite, mul_zero, Finset.sum_ite_irrel, Finset.sum_const_zero] |
| simp |
|
|
| lemma allocation_probability (line : S → L) (r : L → ℝ) |
| (hr : ∀ l, 0 ≤ r l) (hs : ∑ l, r l ≤ 1) : |
| (Fintype.card (Allocations line) : ℝ) * (∏ i, r (line i)) ≤ 1 := by |
| have he (b : S → L) (hb : counts b=counts line) : |
| (∏ i, r (b i)) = ∏ i, r (line i) := by |
| rw [prod_by_counts, prod_by_counts, hb] |
| have hh : (∑ b : S → L, if counts b=counts line then ∏ i, r (line i) else 0) ≤ |
| ∑ b : S → L, ∏ i, r (b i) := by |
| apply Finset.sum_le_sum |
| intro b _ |
| split_ifs with hb |
| · exact le_of_eq (he b hb).symm |
| · exact Finset.prod_nonneg (fun _ _ => hr _) |
| have hl : (∑ b : S → L, if counts b=counts line then ∏ i, r (line i) else 0) = |
| (Fintype.card (Allocations line) : ℝ) * (∏ i, r (line i)) := by |
| simp [Finset.sum_ite, Fintype.card_subtype, Allocations] |
| rw [hl, ← Fintype.prod_sum] at hh |
| exact hh.trans (Finset.prod_le_one₀ (fun _ _ => Finset.sum_nonneg (fun l _ => hr l)) (fun _ _ => hs)) |
|
|
| def lineMass (z : L × A → ℂ) (l : L) : ℝ := ∑ a, Complex.normSq (z (l,a)) |
| def normalizedLine (z : L × A → ℂ) (l : L) (a : A) : ℂ := |
| (Real.sqrt (lineMass z l) : ℂ)⁻¹ * z (l,a) |
|
|
| omit [Fintype L] [DecidableEq L] [DecidableEq A] in |
| lemma lineMass_nonneg (z : L × A → ℂ) (l : L) : 0 ≤ lineMass z l := |
| Finset.sum_nonneg (fun _ _ => Complex.normSq_nonneg _) |
|
|
| omit [Fintype L] [DecidableEq L] [DecidableEq A] in |
| lemma lineMass_zero (z : L × A → ℂ) (l : L) (h : lineMass z l=0) (a : A) : z (l,a)=0 := by |
| apply Complex.normSq_eq_zero.mp |
| have hh : Complex.normSq (z (l,a)) ≤ lineMass z l := |
| Finset.single_le_sum (fun b _ => Complex.normSq_nonneg (z (l,b))) (Finset.mem_univ a) |
| exact le_antisymm (h ▸ hh) (Complex.normSq_nonneg _) |
|
|
| omit [Fintype L] [DecidableEq L] [DecidableEq A] in |
| lemma line_reconstruction (z : L × A → ℂ) (l : L) (a : A) : |
| z (l,a) = (Real.sqrt (lineMass z l) : ℂ) * normalizedLine z l a := by |
| by_cases hz : lineMass z l=0 |
| · simp [normalizedLine, hz, lineMass_zero z l hz a] |
| · have h : (Real.sqrt (lineMass z l) : ℂ) ≠ 0 := by |
| exact_mod_cast (Real.sqrt_ne_zero'.mpr (lt_of_le_of_ne (lineMass_nonneg z l) (Ne.symm hz))) |
| simp [normalizedLine, h] |
| |
| omit [Fintype L] [DecidableEq L] [DecidableEq A] in |
| lemma normalizedLine_norm (z : L × A → ℂ) (l : L) : |
| (∑ a, Complex.normSq (normalizedLine z l a)) ≤ 1 := by |
| by_cases hz : lineMass z l=0 |
| · simp [normalizedLine, hz] |
| · have hp : 0 < lineMass z l := lt_of_le_of_ne (lineMass_nonneg z l) (Ne.symm hz) |
| simp_rw [normalizedLine, map_mul, map_inv₀, Complex.normSq_ofReal, Real.mul_self_sqrt (le_of_lt hp)] |
| rw [← Finset.mul_sum] |
| change (lineMass z l)⁻¹ * lineMass z l ≤ 1 |
| rw [inv_mul_cancel₀ hz] |
| |
| omit [Fintype L] [DecidableEq L] [DecidableEq A] in |
| lemma labeled_tensor_pair (line : S → L) (z : L × A → ℂ) (x : (S → A) → ℂ) : |
| Complex.normSq (∑ w : S → A, tensorVector z (fun i => (line i,w i)) * x w) = |
| (∏ i, lineMass z (line i)) * |
| Complex.normSq (∑ w : S → A, (∏ i, normalizedLine z (line i) (w i)) * x w) := by |
| have he (w : S → A) : tensorVector z (fun i => (line i,w i)) = |
| (∏ i, (Real.sqrt (lineMass z (line i)) : ℂ)) * ∏ i, normalizedLine z (line i) (w i) := by |
| rw [← Finset.prod_mul_distrib] |
| exact Finset.prod_congr rfl (fun i _ => line_reconstruction z (line i) (w i)) |
| simp_rw [he, mul_assoc] |
| rw [← Finset.mul_sum, map_mul] |
| congr 1 |
| rw [map_prod] |
| apply Finset.prod_congr rfl |
| intro i _ |
| exact (Complex.normSq_ofReal _).trans (Real.mul_self_sqrt (lineMass_nonneg z (line i))) |
| |
| |
| omit [DecidableEq S] [Fintype A] [DecidableEq A] in |
| lemma symExtension_supported (line : S → L) (v : (S → A) → ℂ) |
| (good : A → Prop) [DecidablePred good] |
| (hv : ∀ w, ¬ (∀ i, good (w i)) → v w=0) |
| (w : S → L × A) (hw : ¬ ∀ i, good (w i).2) : symExtension line v w=0 := by |
| unfold symExtension |
| split_ifs with hb |
| · apply hv |
| intro h |
| apply hw |
| intro i |
| simpa using h ((allocationPerm line _ hb).symm i) |
| · rfl |
| |
| def lineAmplitude (line : S → L) (a₀ : S → A) (good : A → Prop) [DecidablePred good] |
| (q : Types (S := S) (A := L × A)) (θ : Phases (L × A) (Fintype.card S)) (l : L) (a : A) : ℂ := |
| normalizedLine (truncateAmplitude (fun c : L × A => good c.2) |
| (twistedAmplitude (typeRepresentative (fun i => (line i,a₀ i)) q) θ)) l a |
| |
| omit [DecidableEq S] in |
| omit [Fintype L] in |
| lemma lineAmplitude_norm (line : S → L) (a₀ : S → A) (good : A → Prop) [DecidablePred good] |
| (q : Types (S := S) (A := L × A)) (θ : Phases (L × A) (Fintype.card S)) (l : L) : |
| (∑ a, Complex.normSq (lineAmplitude line a₀ good q θ l a)) ≤ 1 := |
| normalizedLine_norm _ _ |
| |
| omit [DecidableEq S] [Fintype L] in |
| lemma lineAmplitude_support (line : S → L) (a₀ : S → A) (good : A → Prop) [DecidablePred good] |
| (q : Types (S := S) (A := L × A)) (θ : Phases (L × A) (Fintype.card S)) (l : L) (a : A) |
| (ha : ¬ good a) : lineAmplitude line a₀ good q θ l a=0 := by |
| simp [lineAmplitude, normalizedLine, truncateAmplitude, ha] |
| |
| /-- Independent fibre postselection, with the allocation factorial cancelled |
| by the exact multinomial probability rather than included in the overhead. -/ |
| theorem line_symmetric_postselection (line : S → L) (a₀ : S → A) (hn : 0 < Fintype.card S) |
| (good : A → Prop) [DecidablePred good] (v x : (S → A) → ℂ) |
| (hv : ∀ p : Equiv.Perm S, (∀ i, line (p i)=line i) → ∀ w, v (w ∘ p)=v w) |
| (hsupp : ∀ w, ¬ (∀ i, good (w i)) → v w=0) : |
| Complex.normSq (∑ w, v w*x w) ≤ |
| (∑ w, Complex.normSq (v w)) * |
| (((Fintype.card S+1)^(Fintype.card (L × A)) : ℕ) / |
| (Fintype.card (Phases (L × A) (Fintype.card S)) : ℝ) * |
| ∑ q : Types (S := S) (A := L × A), ∑ θ : Phases (L × A) (Fintype.card S), |
| Complex.normSq (∑ w : S → A, (∏ i, lineAmplitude line a₀ good q θ (line i) (w i)) * x w)) := by |
| let z (q : Types (S := S) (A := L × A)) (θ : Phases (L × A) (Fintype.card S)) := |
| truncateAmplitude (fun c : L × A => good c.2) |
| (twistedAmplitude (typeRepresentative (fun i => (line i,a₀ i)) q) θ) |
| let R (q : Types (S := S) (A := L × A)) (θ : Phases (L × A) (Fintype.card S)) := |
| Complex.normSq (∑ w : S → A, (∏ i, normalizedLine (z q θ) (line i) (w i)) * x w) |
| have hz (q : Types (S := S) (A := L × A)) (θ : Phases (L × A) (Fintype.card S)) : |
| (Fintype.card (Allocations line) : ℝ) * (∏ i, lineMass (z q θ) (line i)) ≤ 1 := by |
| apply allocation_probability line _ (lineMass_nonneg _) |
| rw [show (∑ l, lineMass (z q θ) l) = ∑ c : L × A, Complex.normSq (z q θ c) from |
| (Fintype.sum_prod_type (fun c : L × A => Complex.normSq (z q θ c))).symm] |
| exact truncated_twisted_subnormalized _ _ hn _ |
| have hh := supported_symmetric_postselection (fun i => (line i,a₀ i)) hn |
| (fun c : L × A => good c.2) (symExtension line v) (labelTest line x) |
| (symExtension_counts line v hv) (symExtension_supported line v good hsupp) |
| rw [labeled_pair] at hh |
| simp_rw [symExtension_on_line line v hv] at hh |
| rw [symExtension_norm] at hh |
| simp_rw [labeled_pair, labeled_tensor_pair] at hh |
| let c : ℝ := ((Fintype.card S+1)^(Fintype.card (L × A)) : ℕ) / |
| (Fintype.card (Phases (L × A) (Fintype.card S)) : ℝ) |
| change _ ≤ ((Fintype.card (Allocations line) : ℝ) * ∑ w, Complex.normSq (v w)) * |
| (c * ∑ q, ∑ θ, (∏ i, lineMass (z q θ) (line i)) * R q θ) at hh |
| change _ ≤ (∑ w, Complex.normSq (v w)) * (c * ∑ q, ∑ θ, R q θ) |
| apply hh.trans |
| rw [show ((Fintype.card (Allocations line) : ℝ) * ∑ w, Complex.normSq (v w)) * |
| (c * ∑ q, ∑ θ, (∏ i, lineMass (z q θ) (line i)) * R q θ) = |
| (∑ w, Complex.normSq (v w)) * (c * ((Fintype.card (Allocations line) : ℝ) * |
| ∑ q, ∑ θ, (∏ i, lineMass (z q θ) (line i)) * R q θ)) by ring] |
| apply mul_le_mul_of_nonneg_left _ (Finset.sum_nonneg (fun _ _ => Complex.normSq_nonneg _)) |
| apply mul_le_mul_of_nonneg_left _ (by positivity : 0 ≤ c) |
| simp_rw [Finset.mul_sum, ← mul_assoc] |
| exact Finset.sum_le_sum (fun q _ => Finset.sum_le_sum (fun θ _ => |
| (mul_le_mul_of_nonneg_right (hz q θ) (Complex.normSq_nonneg _)).trans_eq (one_mul _))) |
| |
| end RowColumn.Postselection |
| |
| end |
| end |
| |
| |
| section |
| noncomputable section |
| open scoped BigOperators Classical Matrix.Norms.L2Operator ComplexOrder MatrixOrder |
| namespace RowColumn.Postselection |
| open MatrixState WordOrbits |
| variable {S L C : Type*} [Fintype S] [DecidableEq S] [Fintype L] [DecidableEq L] |
| [Fintype C] [DecidableEq C] |
| |
| def lineState (line : S → L) (a₀ : S → C × C) (odd : C → Prop) [DecidablePred odd] |
| (q : Types (S := S) (A := L × (C × C))) (θ : Phases (L × (C × C)) (Fintype.card S)) |
| (l : L) : Matrix C C ℂ := |
| gramState (lineAmplitude line a₀ (fun p : C × C => odd p.1 ↔ odd p.2) q θ l) |
| |
| omit [DecidableEq S] [Fintype L] in |
| lemma lineState_positive (line : S → L) (a₀ : S → C × C) (odd : C → Prop) [DecidablePred odd] |
| (q : Types (S := S) (A := L × (C × C))) (θ : Phases (L × (C × C)) (Fintype.card S)) (l : L) : |
| (lineState line a₀ odd q θ l).PosSemidef := gramState_posSemidef _ |
| |
| omit [DecidableEq S] in |
| omit [Fintype L] in |
| lemma lineState_trace (line : S → L) (a₀ : S → C × C) (odd : C → Prop) [DecidablePred odd] |
| (q : Types (S := S) (A := L × (C × C))) (θ : Phases (L × (C × C)) (Fintype.card S)) (l : L) : |
| (lineState line a₀ odd q θ l).trace.re ≤ 1 := by |
| rw [lineState, gramState_trace] |
| exact lineAmplitude_norm _ _ _ _ _ _ |
| |
| omit [DecidableEq S] [Fintype L] in |
| lemma lineState_even (line : S → L) (a₀ : S → C × C) (odd : C → Prop) [DecidablePred odd] |
| (q : Types (S := S) (A := L × (C × C))) (θ : Phases (L × (C × C)) (Fintype.card S)) |
| (l : L) (c d : C) (h : ¬ (odd c ↔ odd d)) : lineState line a₀ odd q θ l c d=0 := by |
| apply gramState_parity_supported odd _ _ c d h |
| exact fun c d h => lineAmplitude_support _ _ _ _ _ _ _ h |
| |
| lemma variable_purification_pair (z : S → C × C → ℂ) (x : (S → C) → ℂ) (v : S → C) : |
| (∑ a : S → C × C, (∏ i, z i (a i)) * purificationTest x v a) = |
| ∑ w : S → C, tensorMatrix (fun i => letterMatrix (z i)) w v * x w := by |
| exact purification_pair (tensorMatrix (fun i => letterMatrix (z i))) x v |
| |
| lemma variable_purification_quadratic (z : S → C × C → ℂ) (x : (S → C) → ℂ) : |
| (∑ v : S → C, Complex.normSq (∑ a : S → C × C, |
| (∏ i, z i (a i)) * purificationTest x v a)) = |
| quadratic (tensorMatrix (fun i => gramState (z i))) x := by |
| simp_rw [variable_purification_pair] |
| change factorQuadratic (tensorMatrix (fun i => letterMatrix (z i))) x = _ |
| rw [factorQuadratic_eq, tensorMatrix_star, tensorMatrix_mul] |
| rfl |
| |
| /-- Explicit local domination for independent row/column permutation fibres. |
| All mixture terms are genuine even positive identical-slot substates within |
| each fibre, irrespective of its size and the deletion layout. -/ |
| theorem positive_line_postselection (line : S → L) (a₀ : S → C × C) (hn : 0 < Fintype.card S) |
| (odd : C → Prop) [DecidablePred odd] (A : Matrix (S → C) (S → C) ℂ) |
| (hA : A.PosSemidef) |
| (hinv : ∀ (p : Equiv.Perm S), (∀ i, line (p i)=line i) → ∀ (w v : S → C), |
| A (w ∘ p) (v ∘ p)=A w v) |
| (hsupp : ∀ w v, ¬ (∀ i, odd (w i) ↔ odd (v i)) → A w v=0) |
| (x : (S → C) → ℂ) : |
| quadratic A x ≤ A.trace.re * |
| (((Fintype.card S+1)^(Fintype.card (L × (C × C))) : ℕ) / |
| (Fintype.card (Phases (L × (C × C)) (Fintype.card S)) : ℝ) * |
| ∑ q : Types (S := S) (A := L × (C × C)), |
| ∑ θ : Phases (L × (C × C)) (Fintype.card S), |
| quadratic (tensorMatrix (fun i : S => lineState line a₀ odd q θ (line i))) x) := by |
| let B : Matrix (S → C) (S → C) ℂ := CFC.sqrt A |
| have hi (p : Equiv.Perm S) (hp : ∀ i, line (p i)=line i) (w v : S → C) : |
| B (w ∘ p) (v ∘ p)=B w v := |
| sqrt_permutation_invariant A hA (reindexWord p) (hinv p hp) w v |
| have hz (w v : S → C) (hh : ¬ ∀ i, odd (w i) ↔ odd (v i)) : B w v=0 := by |
| apply sqrt_block_supported (fun u : S → C => fun i => odd (u i)) A hA |
| (fun u v he => hsupp u v (fun ht => he (funext fun i => propext (ht i)))) w v |
| intro he |
| exact hh (fun i => Iff.of_eq (congrFun he i)) |
| have hv (p : Equiv.Perm S) (hp : ∀ i, line (p i)=line i) (w : S → C × C) : |
| purificationVector B (w ∘ p)=purificationVector B w := |
| hi p hp (fun i => (w i).1) (fun i => (w i).2) |
| have hs (w : S → C × C) (hw : ¬ ∀ i, odd (w i).1 ↔ odd (w i).2) : purificationVector B w=0 := |
| hz _ _ hw |
| have hh (v : S → C) := line_symmetric_postselection line a₀ hn |
| (fun p : C × C => odd p.1 ↔ odd p.2) (purificationVector B) (purificationTest x v) hv hs |
| simp only [purification_pair B x, purification_normSq B] at hh |
| have hsum := Finset.sum_le_sum (fun v (_ : v ∈ Finset.univ) => hh v) |
| change factorQuadratic B x ≤ _ at hsum |
| have ht : purifierTrace B=A.trace.re := sqrt_trace A hA |
| rw [ht] at hsum |
| change factorQuadratic (CFC.sqrt A) x ≤ _ at hsum |
| rw [sqrt_factorQuadratic A hA] at hsum |
| apply hsum.trans_eq |
| simp only [Finset.mul_sum] |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro q _ |
| rw [Finset.sum_comm] |
| apply Finset.sum_congr rfl |
| intro θ _ |
| rw [← Finset.mul_sum, ← Finset.mul_sum] |
| congr 2 |
| exact variable_purification_quadratic _ x |
| |
| end RowColumn.Postselection |
| |
| end |
| end |
| |
| end OAI |
| |
