Download data/lean/OAI/Probability/BinarySweep/MatrixBounds/HilbertBlockTrace.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 6.1 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/BinarySweep/MatrixBounds/HilbertBlockTrace.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/Probability/BinarySweep/MatrixBounds/HilbertBlockTrace.lean
-
curl -L -o HilbertBlockTrace.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/Probability/BinarySweep/MatrixBounds/HilbertBlockTrace.lean
6.1 kB
| import Mathlib | |
| import OAI.Probability.BinarySweep.FiniteLaws.LinearEvenMoment | |
| import OAI.Probability.BinarySweep.YoungTheory.HookInducedMoment | |
| import OAI.Probability.BinarySweep.MatrixBounds.BlockTrace | |
| namespace OAI | |
| noncomputable section | |
| open scoped BigOperators Classical | |
| namespace BinaryCoordinateSweeps.Irrep | |
| open TraceHolder | |
| variable {I W : Type*} [Fintype I] [DecidableEq I] | |
| [NormedAddCommGroup W] [InnerProductSpace β W] [FiniteDimensional β W] | |
| local notation "HW" => CoindHilbertSpace (I:=I) (W:=W) | |
| omit [DecidableEq I] [FiniteDimensional β W] in | |
| lemma fiber_sum (v : HW) : βi, fiberInclude i (v i)=v := by | |
| classical | |
| apply (WithLp.linearEquiv 2 β (I β W)).injective | |
| simp only [map_sum] | |
| ext i | |
| simp only [fiberInclude,LinearMap.comp_apply,LinearEquiv.coe_coe, | |
| LinearEquiv.apply_symm_apply,LinearMap.single_apply,Finset.sum_apply,Pi.single_apply] | |
| simp only [WithLp.coe_linearEquiv] | |
| let : DecidableEq I := fun i j => Classical.propDecidable (i=j) | |
| exact (Finset.sum_ite_eq Finset.univ i (fun x => v x)).trans (ite_eq_left (Finset.mem_univ i)) | |
| omit [DecidableEq I] [FiniteDimensional β W] in | |
| lemma fiber_identity : (βi : I, (fiberInclude i).comp (fiberProject i))=(1 : HW ββ[β] HW) := by | |
| apply LinearMap.ext | |
| intro v | |
| simpa only [LinearMap.sum_apply,LinearMap.comp_apply, fiberProject, Module.End.one_apply, | |
| LinearEquiv.coe_coe, LinearMap.proj_apply, WithLp.coe_linearEquiv] using fiber_sum v | |
| omit [DecidableEq I] [FiniteDimensional β W] in | |
| lemma hilbertBlock_mul (A B : HW ββ[β] HW) (i j : I) : | |
| hilbertBlock (A*B) i j = βa, hilbertBlock A i a * hilbertBlock B a j := by | |
| ext v | |
| change A (B (fiberInclude j v)) i = _ | |
| conv_lhs => rw [β fiber_sum (B (fiberInclude j v))] | |
| simp only [map_sum,LinearMap.sum_apply,Module.End.mul_apply] | |
| change (WithLp.linearEquiv 2 β (I β W)) (β x, A (fiberInclude x (B (fiberInclude j v) x))) i = _ | |
| rw [map_sum,Finset.sum_apply] | |
| rfl | |
| omit [Fintype I] [FiniteDimensional β W] in | |
| lemma hilbertBlock_one (i j : I) : hilbertBlock (1 : HW ββ[β] HW) i j = if i=j then 1 else 0 := by | |
| ext v | |
| change fiberInclude j v i = _ | |
| rw [fiberInclude_apply] | |
| split_ifs <;> rfl | |
| omit [Fintype I] [DecidableEq I] [FiniteDimensional β W] in | |
| lemma hilbertBlock_sum {J : Type*} (s : Finset J) (A : J β HW ββ[β] HW) (i j : I) : | |
| hilbertBlock (βaβs,A a) i j = βaβs,hilbertBlock (A a) i j := by | |
| ext v | |
| simp [hilbertBlock,LinearMap.sum_apply,LinearMap.comp_apply,map_sum] | |
| omit [Fintype I] [DecidableEq I] [FiniteDimensional β W] in | |
| lemma hilbertBlock_smul (r : β) (A : HW ββ[β] HW) (i j : I) : | |
| hilbertBlock (r β’ A) i j=r β’ hilbertBlock A i j := by | |
| ext v | |
| simp [hilbertBlock] | |
| lemma fiber_adjoint (i : I) : (fiberInclude i : W ββ[β] HW).adjoint=fiberProject i := by | |
| symm | |
| apply (LinearMap.eq_adjoint_iff _ _).mpr | |
| intro x y | |
| simp only [PiLp.inner_apply,fiberInclude_apply,apply_ite,inner_zero_right] | |
| change _ = βj, if j=i then inner β (x j) y else 0 | |
| simp only [fiberProject,LinearMap.comp_apply,LinearMap.proj_apply,LinearEquiv.coe_coe, | |
| WithLp.coe_linearEquiv,Finset.sum_ite_eq',Finset.mem_univ,ite_true] | |
| lemma hilbertBlock_adjoint (A : HW ββ[β] HW) (i j : I) : | |
| hilbertBlock A.adjoint i j=(hilbertBlock A j i).adjoint := by | |
| unfold hilbertBlock | |
| rw [LinearMap.adjoint_comp,LinearMap.adjoint_comp,fiber_adjoint, | |
| β fiber_adjoint (W:=W) j,LinearMap.adjoint_adjoint] | |
| rfl | |
| def hilbertBlocksHom : (HW ββ[β] HW) β* Matrix I I (W ββ[β] W) where | |
| toFun A := hilbertBlock A | |
| map_one' := by funext i j; exact hilbertBlock_one i j | |
| map_mul' A B := by funext i j; exact hilbertBlock_mul A B i j | |
| omit [DecidableEq I] in | |
| lemma trace_hilbertBlocks (A : HW ββ[β] HW) : | |
| LinearMap.trace β HW A = βi, LinearMap.trace β W (hilbertBlock A i i) := by | |
| conv_lhs => rw [β mul_one A,β fiber_identity] | |
| rw [Finset.mul_sum,map_sum] | |
| apply Finset.sum_congr rfl | |
| intro i _ | |
| change LinearMap.trace β HW ((A.comp (fiberInclude i)).comp (fiberProject i)) = _ | |
| rw [LinearMap.trace_comp_comm'] | |
| rfl | |
| lemma trace_hilbertBlocks_prod {n : β} (A : Fin (n+1) β HW ββ[β] HW) : | |
| LinearMap.trace β HW (List.ofFn A).prod = | |
| βx : Fin (n+1) β I, LinearMap.trace β W | |
| (List.ofFn (fun j => hilbertBlock (A j) (x j) (x (finRotate (n+1) j)))).prod := by | |
| rw [trace_hilbertBlocks] | |
| rw [β map_sum] | |
| change LinearMap.trace β W (Matrix.trace (hilbertBlocksHom (I:=I) (W:=W) (List.ofFn A).prod)) = _ | |
| have hm := (hilbertBlocksHom (I:=I) (W:=W)).map_list_prod (List.ofFn A) | |
| rw [List.map_ofFn] at hm | |
| rw [hm,trace_prod_eq_sum_cycles,map_sum] | |
| rfl | |
| theorem hilbert_block_trace_holder {q : β} (hq : 0<q) (A : Fin (2*q) β HW ββ[β] HW) : | |
| βLinearMap.trace β HW (List.ofFn A).prodβ β€ | |
| βx : Fin (2*q) β I, βj, | |
| evenMoment q (hilbertBlock (A j) (x j) (x (finRotate (2*q) j)))^(((2*q:β):β)β»ΒΉ) := by | |
| have ht : LinearMap.trace β HW (List.ofFn A).prod = | |
| βx : Fin (2*q) β I, LinearMap.trace β W | |
| (List.ofFn (fun j => hilbertBlock (A j) (x j) (x (finRotate (2*q) j)))).prod := by | |
| generalize hm : 2*q=m at A β’ | |
| cases m with | |
| | zero => omega | |
| | succ n => exact trace_hilbertBlocks_prod A | |
| rw [ht] | |
| exact (norm_sum_le _ _).trans (Finset.sum_le_sum (fun _ _ => linear_trace_holder hq _)) | |
| theorem evenMoment_blocks_le {q : β} (hq : 0<q) (K : HW ββ[β] HW) : | |
| evenMoment q K β€ βx : Fin (2*q) β I, βj, | |
| (if j.val%2=0 then | |
| evenMoment q (hilbertBlock K (x (finRotate (2*q) j)) (x j)) | |
| else evenMoment q (hilbertBlock K (x j) (x (finRotate (2*q) j))))^(((2*q:β):β)β»ΒΉ) := by | |
| have ht := hilbert_block_trace_holder hq | |
| (fun j : Fin (2*q) => if j.val%2=0 then K.adjoint else K) | |
| rw [alternating_prod] at ht | |
| refine (Complex.re_le_norm _).trans (ht.trans_eq ?_) | |
| apply Finset.sum_congr rfl | |
| intro x _ | |
| apply Finset.prod_congr rfl | |
| intro j _ | |
| split_ifs <;> simp only [hilbertBlock_adjoint,evenMoment_adjoint] | |
| end BinaryCoordinateSweeps.Irrep | |
| end | |
| end OAI | |