| import Mathlib |
| import OAI.Analysis.TracialSplitting.PreparedBlocks |
| import OAI.Analysis.JiangSu.Comparison.PackingRounds |
|
|
| namespace OAI |
|
|
| noncomputable section |
| open Pureness |
| open scoped ComplexOrder |
|
|
| namespace DirectPacking |
| open CurrentMain |
|
|
| variable {D : Type} [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] [TraceFamily D] |
|
|
| lemma PackingStepBounds.mono_quality {p z y t : D} {c σ η δ : ℝ} |
| {K : Finset (unitary D)} (H : PackingStepBounds p z y t c σ δ K) |
| (hp : IsStarProjection p) (hy : IsStarProjection y) (hc : 0 ≤ c) (hση : σ ≤ η) : |
| PackingStepBounds p z y t c η δ K := by |
| refine { H with sampled_linear := ?_, sampled_energy := ?_ } |
| · intro x hx τ |
| exact (H.sampled_linear x hx τ).trans (by |
| gcongr |
| exact add_nonneg (τ.functional.map_nonneg hy.nonneg).1 |
| (mul_nonneg hc (τ.functional.map_nonneg hp.nonneg).1)) |
| · intro x hx τ |
| exact (H.sampled_energy x hx τ).trans (by |
| gcongr |
| exact add_nonneg (τ.functional.map_nonneg hy.nonneg).1 |
| (mul_nonneg hc (τ.functional.map_nonneg hp.nonneg).1)) |
|
|
| lemma exists_precise_packing_round (hcoef : CoefficientSupply (D := D)) (hinsert : InsertionSupply (D := D)) |
| {z₀ r : D} (hz₀ : IsStarProjection z₀) (F : WeightedBlockFamily r) |
| (K : Finset (unitary D)) {η σ δ : ℝ} (hη : 0 < η) (hη1 : η < 1) |
| (hση : σ ≤ η) (hδ : 0 < δ) |
| (happrox : ∀ j, ∀ x ∈ K, ∃ H : Matrix (Fin (F.columns j)) (Fin (F.columns j)) ℂ, |
| ‖F.range j*(x : D)*F.range j-(F.row j).matrix (F.base j) H‖ < σ) : |
| ∃ R : SampledPackingRound F z₀ K η δ, ∀ a, |
| PackingStepBounds (F.range a.1) (R.occupied a) (R.sampled a) (R.inserted a) |
| (η*F.weight a.1/2) σ δ K := by |
| classical |
| let e := Fintype.equivFin (F.Index × Bool) |
| let Q := fun (a : Fin (Fintype.card (F.Index × Bool))) (z y t : D) => |
| PackingStepBounds (F.range (e.symm a).1) z y t (η*F.weight (e.symm a).1/2) σ δ K |
| have hc (a : F.Index × Bool) : η*F.weight a.1/2 ∈ Set.Icc (0 : ℝ) 1 := by |
| have hw := F.weight_le_one a.1 |
| have hw0 := F.weight_pos a.1 |
| constructor |
| · positivity |
| · nlinarith |
| have hstep (a : Fin (Fintype.card (F.Index × Bool))) (z : D) (hz : IsStarProjection z) : |
| ∃ y t, IsStarProjection y ∧ IsStarProjection t ∧ t ≤ 1-z ∧ Q a z y t := |
| exists_packing_step (F.row (e.symm a).1) hcoef hinsert hz K (hc _) (hση.trans_lt hη1) hδ (happrox _) |
| obtain ⟨S,hS⟩ := exists_projection_insertion _ hz₀ Q hstep |
| let R : SampledPackingRound F z₀ K η δ := { |
| final := S.occupied (Fin.last _) |
| occupied := fun a => S.occupied (e a).castSucc |
| sampled := fun a => S.sampled (e a) |
| inserted := fun a => S.inserted (e a) |
| final_projection := S.occupied_projection _ |
| occupied_projection := fun a => S.occupied_projection _ |
| sampled_projection := fun a => S.sampled_projection _ |
| inserted_projection := fun a => S.inserted_projection _ |
| occupied_le_final := fun a => S.monotone (Fin.le_last _) |
| inserted_orthogonal := fun a b hab => S.orthogonal (e.injective.ne hab) |
| initial_orthogonal := fun a => S.initial_orthogonal _ |
| final_eq := by rw [e.sum_comp S.inserted]; exact S.final_eq |
| bounds := by |
| intro a |
| have h : PackingStepBounds (F.range a.1) (S.occupied (e a).castSucc) |
| (S.sampled (e a)) (S.inserted (e a)) (η*F.weight a.1/2) σ δ K := by |
| simpa only [Q,Equiv.symm_apply_apply] using hS (e a) |
| exact h.mono_quality (F.range_projection a.1) (S.sampled_projection _) (hc a).1 hση } |
| refine ⟨R,?_⟩ |
| intro a |
| simpa only [Q,Equiv.symm_apply_apply] using hS (e a) |
|
|
| namespace SampledPackingRound |
| variable {z₀ r : D} {F : WeightedBlockFamily r} {K : Finset (unitary D)} {η σ δ : ℝ} |
| variable (R : SampledPackingRound F z₀ K η δ) |
|
|
| lemma precise_sampled_energy_sum |
| (H : ∀ a, PackingStepBounds (F.range a.1) (R.occupied a) (R.sampled a) (R.inserted a) |
| (η*F.weight a.1/2) σ δ K) (τ : RestrictedTracialState D) (x : unitary D) (hx : x ∈ K) : |
| (∑ a, traceTwoNorm τ ((x : D)*R.sampled a-R.sampled a*(x : D))^2) ≤ |
| η*(∑ j, F.weight j*traceTwoNorm τ ((x : D)*F.range j-F.range j*(x : D))^2)+ |
| 6*σ*(R.sampledMass τ+R.targetMass τ)+10*R.totalError := by |
| have h := Finset.sum_le_sum fun a (_ : a ∈ Finset.univ) => (H a).sampled_energy x hx τ |
| apply h.trans_eq |
| simp only [Finset.sum_add_distrib,← Finset.mul_sum, |
| Finset.sum_const,Finset.card_univ,nsmul_eq_mul,sampledMass,targetMass,totalError] |
| rw [signed_weighted_sum F η (fun j => traceTwoNorm τ ((x : D)*F.range j-F.range j*(x : D))^2), |
| signed_weighted_sum F η (fun j => (τ.functional (F.range j)).re)] |
|
|
| lemma inserted_row_energy (V : BistochasticTest D) (τ : RestrictedTracialState D) : |
| (∑ a, V.energy τ (R.inserted a)) ≤ |
| 2*(∑ a, V.energy τ (R.sampled a))+40*R.overlap τ := by |
| have hd := Finset.sum_le_sum fun a (_ : a ∈ Finset.univ) => (R.bounds a).inserted_distance τ |
| have he := Finset.sum_le_sum fun a (_ : a ∈ Finset.univ) => V.energy_perturb τ (R.inserted a) (R.sampled a) |
| simp only [Finset.sum_add_distrib,← Finset.mul_sum] at hd he |
| dsimp [overlap] |
| linarith |
|
|
| end SampledPackingRound |
| end DirectPacking |
| end |
|
|
| noncomputable section |
| namespace DirectPacking |
| open CurrentMain |
|
|
| variable {A D : Type*} [CStarAlgebra A] [CStarAlgebra D] [PartialOrder D] [StarOrderedRing D] [TraceFamily D] |
| namespace OrthogonalProjectionPair |
|
|
| def zero : OrthogonalProjectionPair D where |
| left := 0 |
| right := 0 |
| left_projection := IsStarProjection.zero D |
| right_projection := IsStarProjection.zero D |
| orthogonal := mul_zero 0 |
|
|
| end OrthogonalProjectionPair |
|
|
| structure PackingBounds (ι : A →⋆ₐ[ℂ] D) (Q : OrthogonalProjectionPair D) |
| (K : Finset (unitary A)) (η : ℝ) (n : ℕ) : Prop where |
| energy : ∀ x ∈ K, ∀ τ : RestrictedTracialState D, Q.energy τ (ι (x : A)) ≤ packingEnergy η n |
| remaining : ∀ τ : RestrictedTracialState D, Q.remaining τ ≤ packingRemainder η n |
| balance : ∀ x ∈ K, ∀ τ : RestrictedTracialState D, Q.balance τ (ι (x : A)) ≤ packingBalance η n |
|
|
| end DirectPacking |
| end |
|
|
| end OAI |
|
|
