| import Mathlib |
| import OAI.Probability.BinarySweep.YoungTheory.YoungHilbert |
| import OAI.Probability.BinarySweep.TensorBounds.TensorReduction |
| import OAI.Probability.BinarySweep.MatrixBounds.MatrixSqrtBlocks |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| section |
|
|
| open scoped BigOperators Classical ComplexOrder MatrixOrder |
| open Matrix |
|
|
| namespace BinaryCoordinateSweeps.Density |
| variable {K A B : Type*} [Fintype K] [DecidableEq K] [Fintype A] [DecidableEq A] |
| [Fintype B] [DecidableEq B] |
|
|
| lemma reduced_postselection (n : ℕ) (hn : 0 < n) (e : K → A × B) |
| (v : (Fin n → K) → ℂ) |
| (hv : ∀ w u, wordCounts w = wordCounts u → v w = v u) : |
| ((rankOne v).trace • (∑ c : WordType K n, ∑ t : K → ZMod (n+1), |
| matrixTensorPower n (reducedPhaseDensity n e c t)) - |
| reshape (wordPair n e) v * (reshape (wordPair n e) v).conjTranspose).PosSemidef := by |
| have h := densityChannel_psd (wordPair n e) (symmetric_vector_postselection n hn v hv) |
| rw [densityChannel_sub, densityChannel_smul, densityChannel_sum] at h |
| simp only [phaseAverage, densityChannel_smul, densityChannel_sum, |
| densityChannel_tensorRankOne, ← Finset.smul_sum, smul_smul] at h |
| have hd : (((n+1 : ℕ) : ℂ)^Fintype.card K) ≠ 0 := |
| pow_ne_zero _ (by exact_mod_cast Nat.succ_ne_zero n) |
| rw [mul_assoc, mul_inv_cancel₀ hd, mul_one, densityChannel_rankOne] at h |
| exact h |
|
|
| variable {P : Type*} [DecidableEq P] |
|
|
| def MatchedPair (p : A → P) := {x : A × A // p x.1 = p x.2} |
| instance (p : A → P) : Fintype (MatchedPair p) := |
| inferInstanceAs (Fintype {pair : A × A // p pair.1 = p pair.2}) |
| instance (p : A → P) : DecidableEq (MatchedPair p) := |
| inferInstanceAs (DecidableEq {pair : A × A // p pair.1 = p pair.2}) |
| |
| def matchedEmbedding (p : A → P) : MatchedPair p → A × A := Subtype.val |
| |
| omit [Fintype A] [DecidableEq A] [DecidableEq P] in |
| lemma matchedEmbedding_injective (p : A → P) : Function.Injective (matchedEmbedding p) := |
| Subtype.val_injective |
| |
| def pairVector (n : ℕ) (p : A → P) (Q : Matrix (Fin n → A) (Fin n → A) ℂ) : |
| (Fin n → MatchedPair p) → ℂ := |
| fun w => Q (fun i => (w i).val.1) (fun i => (w i).val.2) |
| |
| lemma reshape_pairVector (n : ℕ) (p : A → P) (Q : Matrix (Fin n → A) (Fin n → A) ℂ) |
| (hQ : ∀ x y, (fun i => p (x i)) ≠ (fun i => p (y i)) → Q x y = 0) : |
| reshape (wordPair n (matchedEmbedding p)) (pairVector n p Q) = Q := by |
| ext x y |
| by_cases h : (fun i => p (x i)) = (fun i => p (y i)) |
| · let w : Fin n → MatchedPair p := fun i => ⟨(x i,y i), congrFun h i⟩ |
| have hw : wordPair n (matchedEmbedding p) w = (x,y) := rfl |
| have ht := reshape_injective_apply (wordPair n (matchedEmbedding p)) |
| (wordPair_injective n _ (matchedEmbedding_injective p)) (pairVector n p Q) w |
| rw [hw] at ht |
| exact ht |
| · have hn : (x,y) ∉ Set.range (wordPair n (matchedEmbedding p)) := by |
| rintro ⟨w,hw⟩ |
| apply h |
| funext i |
| have hi := (wordPair_eq_iff n _ w x y).mp hw i |
| have hh := (w i).property |
| change p (matchedEmbedding p (w i)).1 = p (matchedEmbedding p (w i)).2 at hh |
| rw [hi] at hh |
| exact hh |
| rw [reshape_outside _ _ x y hn, hQ x y h] |
| |
| def wordPerm (n : ℕ) (g : Equiv.Perm (Fin n)) : Equiv.Perm (Fin n → A) where |
| toFun x := x ∘ g |
| invFun x := x ∘ g.symm |
| left_inv x := by funext i; simp |
| right_inv x := by funext i; simp |
|
|
| omit [Fintype A] [DecidableEq P] in |
| lemma pairVector_symmetric (n : ℕ) (p : A → P) (Q : Matrix (Fin n → A) (Fin n → A) ℂ) |
| (hQ : ∀ (g : Equiv.Perm (Fin n)) x y, Q (x ∘ g) (y ∘ g) = Q x y) : |
| ∀ w u, wordCounts w = wordCounts u → pairVector n p Q w = pairVector n p Q u := by |
| intro w u h |
| obtain ⟨g,hg⟩ := exists_perm_eq_of_wordCounts h |
| have hw : w = u ∘ g := (funext hg).symm |
| rw [hw] |
| simpa only [pairVector, Function.comp_def] using |
| hQ g (fun i => (u i).val.1) (fun i => (u i).val.2) |
|
|
| theorem even_block_postselection (n : ℕ) (hn : 0 < n) (p : A → P) |
| (Q : Matrix (Fin n → A) (Fin n → A) ℂ) (hQ : Q.PosSemidef) |
| (hblock : ∀ x y, (p ∘ x) ≠ (p ∘ y) → Q x y = 0) |
| (hperm : ∀ (g : Equiv.Perm (Fin n)) x y, Q (x ∘ g) (y ∘ g) = Q x y) : |
| (Q.trace • (∑ c : WordType (MatchedPair p) n, ∑ t : MatchedPair p → ZMod (n+1), |
| matrixTensorPower n (reducedPhaseDensity n (matchedEmbedding p) c t)) - Q).PosSemidef := by |
| let S := CFC.sqrt Q |
| have hSblock : ∀ x y, (p ∘ x) ≠ (p ∘ y) → S x y = 0 := |
| sqrt_block_diagonal (fun x => p ∘ x) Q hblock |
| have hSperm (g : Equiv.Perm (Fin n)) (x y) : S (x ∘ g) (y ∘ g) = S x y := by |
| have hh := sqrt_submatrix_invariant Q hQ (wordPerm n g) (by |
| ext u v; exact hperm g u v) |
| exact congrFun (congrFun hh x) y |
| let v := pairVector n p S |
| have hr : reshape (wordPair n (matchedEmbedding p)) v = S := |
| reshape_pairVector n p S hSblock |
| have ht : (rankOne v).trace = Q.trace := by |
| rw [← reshape_trace (wordPair n (matchedEmbedding p)) |
| (wordPair_injective n _ (matchedEmbedding_injective p)) v, hr, sqrt_gram Q hQ] |
| have hh := reduced_postselection n hn (matchedEmbedding p) v (pairVector_symmetric n p S hSperm) |
| rw [ht, hr, sqrt_gram Q hQ] at hh |
| exact hh |
|
|
| end BinaryCoordinateSweeps.Density |
|
|
| end |
|
|
| open scoped BigOperators Classical ComplexOrder |
| open Equiv Equiv.Perm Matrix |
|
|
| namespace BinaryCoordinateSweeps.Signed |
| variable {A : Type*} {n : ℕ} |
|
|
| def signC (β : Fin n → Bool) (g : Equiv.Perm (Fin n)) : ℂ := |
| ((koszulSign β g : ℤ) : ℂ) |
|
|
| @[simp] lemma signC_one (β : Fin n → Bool) : signC β 1 = 1 := by simp [signC] |
| lemma signC_mul (β : Fin n → Bool) (f g : Equiv.Perm (Fin n)) : |
| signC β (f*g) = signC (β ∘ g.symm) f * signC β g := by |
| simp only [signC, koszulSign_mul, Units.val_mul, Int.cast_mul] |
| lemma signC_sq (β : Fin n → Bool) (g : Equiv.Perm (Fin n)) : |
| signC β g * signC β g = 1 := by |
| unfold signC |
| rw [← Int.cast_mul, ← Units.val_mul, koszulSign_sq] |
| norm_num |
| @[simp] lemma signC_star (β : Fin n → Bool) (g : Equiv.Perm (Fin n)) : |
| star (signC β g) = signC β g := by simp [signC] |
| lemma signC_swap (β : Fin n → Bool) (a b : Fin n) (hab : a ≠ b) (hβ : β a = β b) : |
| signC β (Equiv.swap a b) = if β a = true then -1 else 1 := by |
| simp only [signC, koszulSign_swap β a b hab hβ] |
| split_ifs <;> norm_num |
|
|
| def act (p : A → Bool) (g : Equiv.Perm (Fin n)) : |
| ((Fin n → A) → ℂ) →ₗ[ℂ] ((Fin n → A) → ℂ) where |
| toFun v x := signC (p ∘ x) g⁻¹ * v (x ∘ g) |
| map_add' u v := by ext x; simp only [Pi.add_apply, mul_add] |
| map_smul' c v := by ext x; simp only [Pi.smul_apply, smul_eq_mul, mul_left_comm, |
| RingHom.id_apply] |
|
|
| @[simp] lemma act_apply (p : A → Bool) (g : Equiv.Perm (Fin n)) (v : (Fin n → A) → ℂ) (x) : |
| act p g v x = signC (p ∘ x) g⁻¹ * v (x ∘ g) := rfl |
|
|
| lemma act_one (p : A → Bool) : act (n := n) p 1 = 1 := by |
| ext v x |
| simp [act] |
|
|
| lemma act_mul (p : A → Bool) (g h : Equiv.Perm (Fin n)) : |
| act p (g*h) = act p g * act p h := by |
| apply LinearMap.ext |
| intro v |
| funext x |
| change signC (p ∘ x) (g*h)⁻¹ * v (x ∘ ⇑(g*h)) = |
| signC (p ∘ x) g⁻¹ * (signC (p ∘ (x ∘ g)) h⁻¹ * v ((x ∘ g) ∘ h)) |
| simp only [_root_.mul_inv_rev, signC_mul] |
| have he : (p ∘ x) ∘ (Equiv.symm g⁻¹) = p ∘ (x ∘ g) := rfl |
| rw [he] |
| have hw : x ∘ ⇑(g*h) = (x ∘ g) ∘ h := rfl |
| rw [hw] |
| ring |
|
|
| def tensorRep (p : A → Bool) (n : ℕ) : Representation ℂ (Equiv.Perm (Fin n)) ((Fin n → A) → ℂ) where |
| toFun := act p |
| map_one' := act_one p |
| map_mul' := act_mul p |
|
|
| def Invariant (p : A → Bool) (M : Matrix (Fin n → A) (Fin n → A) ℂ) : Prop := |
| ∀ (g : Equiv.Perm (Fin n)) x y, |
| M (x ∘ g) (y ∘ g) = signC (p ∘ x) g⁻¹ * signC (p ∘ y) g⁻¹ * M x y |
|
|
| lemma invariant_same_parity (p : A → Bool) (M : Matrix (Fin n → A) (Fin n → A) ℂ) |
| (hM : Invariant p M) (g : Equiv.Perm (Fin n)) (x y : Fin n → A) |
| (h : p ∘ x = p ∘ y) : M (x ∘ g) (y ∘ g) = M x y := by |
| rw [hM g x y, h, signC_sq, one_mul] |
|
|
| lemma comp_swap_eq {T : Type*} (x : Fin n → T) (i j : Fin n) (h : x i = x j) : |
| x ∘ Equiv.swap i j = x := by |
| funext k |
| simp only [Function.comp_apply, Equiv.swap_apply_def] |
| split_ifs <;> simp_all |
|
|
| lemma invariant_repeated_mismatch_zero (p : A → Bool) |
| (M : Matrix (Fin n → A) (Fin n → A) ℂ) (hM : Invariant p M) |
| (x y : Fin n → A) (i j : Fin n) (hij : i ≠ j) |
| (hx : x i = x j) (hy : y i = y j) (hp : p (x i) ≠ p (y i)) : M x y = 0 := by |
| have h := hM (Equiv.swap i j) x y |
| rw [comp_swap_eq x i j hx, comp_swap_eq y i j hy, Equiv.swap_inv, |
| signC_swap _ i j hij (by change p (x i)=p (x j); rw [hx]), |
| signC_swap _ i j hij (by change p (y i)=p (y j); rw [hy])] at h |
| simp only [Function.comp_apply] at h |
| cases hx' : p (x i) <;> cases hy' : p (y i) |
| · exact False.elim (hp (hx'.trans hy'.symm)) |
| · simp only [hx', hy', Bool.false_eq_true, ↓reduceIte, one_mul, neg_one_mul] at h |
| linear_combination (1/2 : ℂ) * h |
| · simp only [hx', hy', Bool.false_eq_true, ↓reduceIte, mul_one, neg_one_mul] at h |
| linear_combination (1/2 : ℂ) * h |
| · exact False.elim (hp (hx'.trans hy'.symm)) |
|
|
| variable [Fintype A] |
|
|
| lemma invariant_mismatch_card (p : A → Bool) |
| (M : Matrix (Fin n → A) (Fin n → A) ℂ) (hM : Invariant p M) |
| (x y : Fin n → A) (hxy : M x y ≠ 0) : |
| (Finset.univ.filter (fun i => p (x i) ≠ p (y i))).card ≤ (Fintype.card A)^2 := by |
| let T := {i : Fin n // p (x i) ≠ p (y i)} |
| let f : T → A × A := fun i => (x i.val,y i.val) |
| have hf : Function.Injective f := by |
| intro i j hij |
| apply Subtype.ext |
| by_contra h |
| have hx := congrArg Prod.fst hij |
| have hy := congrArg Prod.snd hij |
| exact hxy (invariant_repeated_mismatch_zero p M hM x y i j h hx hy i.property) |
| have hc := Fintype.card_le_of_injective f hf |
| simpa only [T, Fintype.card_subtype, Fintype.card_prod, pow_two] using hc |
|
|
| end BinaryCoordinateSweeps.Signed |
|
|
| end |
|
|
| end OAI |
|
|
