Exact operator identity for the quartic logarithm of a Gibbs minimizer
ProvedOAI.EntropyPhotonNumber.GibbsData.exact_logarithmic_identityLet be the -mode Fock space with number basis , total number , annihilation operators , and the diagonal weight , i.e. . A state is a positive bounded operator on whose number-basis diagonal sums to . For a state write , and ; has finite -th moment if .
A Kraus flow consists of bounded operators on with for all , a constant with (where , both sides in ), and a map on states such that whenever with , and preserves finite energy. Its Heisenberg dual is .
A Gibbs representation of with quartic coefficient consists of a positive bounded operator , a Hilbert basis of and numbers with such that for all and (moreover is injective and has finite seventh moment). Formally with . Its quartic logarithm is the bounded operator
formally .
Theorem. Let have a Gibbs representation with quartic coefficient , let be a Kraus flow and a state. Let and with in operator order, where is the thermal state with mean photon number per mode. Let be a Hilbert basis and , , with . Let and suppose that for all , in ,
Then there exist positive bounded operators on such that for all
(in ), and
Formally and , so the identity is the bounded, sandwiched version of the Euler–Lagrange equation . Having it as an exact identity of bounded operators lets one pair with unbounded generators rigorously.
Formalization Note The Gibbs representation is GibbsData n k ρ and is G.quarticLogarithm; quadratic forms are compared in ℝ≥0∞ via ENNReal.ofReal; and are inversePower rootNumberWeight _ 1 and _ 4 (with rootNumberWeight ).
import Mathlib
import Definitions.Def_EntropyPhotonNumber
import Definitions.Def_OAI_MathematicalPhysics_Fock_Beam
import Definitions.Def_OAI_Analysis_QuantumTrace_Basic
import Definitions.Def_OAI_MathematicalPhysics_Fock_Operators
import Definitions.Def_OAI_InformationTheory_PhotonNumber_Gibbs
import Definitions.Def_OAI_Analysis_TensorLp
import Definitions.Def_OAI_InformationTheory_PhotonNumber_BeamTrace
import Definitions.Def_OAI_InformationTheory_PhotonNumber_Functions
import Definitions.Def_OAI_Analysis_DiagonalForms
import Definitions.Def_OAI_InformationTheory_PhotonNumber_ThermalMetric
import Definitions.Def_OAI_InformationTheory_PhotonNumber_BeamForms
import Definitions.Def_OAI_InformationTheory_PhotonNumber_Generator
import Definitions.Def_OAI_InformationTheory_PhotonNumber_SpectralLog
import Definitions.Def_OAI_InformationTheory_PhotonNumber_Continuity
import Definitions.Def_OAI_InformationTheory_PhotonNumber_Entropy
import Definitions.Def_OAI_InformationTheory_PhotonNumber_GibbsVariational
import Definitions.Def_OAI_Analysis_Herglotz
import Definitions.Def_OAI_InformationTheory_PhotonNumber_Interpolation
import Definitions.Def_OAI_InformationTheory_PhotonNumber_SpectralForms
import Definitions.Def_OAI_InformationTheory_PhotonNumber_Contraction
import Definitions.Def_OAI_InformationTheory_PhotonNumber_FiniteVariation
open OAI OAI.EntropyPhotonNumber OAI.EntropyPhotonNumber.GibbsData
open scoped ComplexConjugate
open scoped BigOperators ComplexConjugate
open scoped BigOperators ComplexConjugate ENNReal Topology
open MeasureTheory
open scoped BigOperators
open MvPolynomial
open scoped BigOperators ComplexConjugate Classical
open Submodule
open scoped ENNReal
open Module
open scoped ComplexConjugate BigOperators Matrix
open NormedSpace
open scoped Matrix.Norms.Operator
open scoped Topology
open MeasureTheory NormedSpace
open Filter Asymptotics Topology
open ContinuousLinearMap
open QuantumTrace
variable {n : ℕ} {k : ℝ} {ρ : State n} (G : GibbsData n k ρ)theorem OAI.EntropyPhotonNumber.GibbsData.exact_logarithmic_identity {J : Type*}
(F : KrausFlow n) (τ : State n) {r δ : ℝ} (hr : 0<r) (hδ : 0<δ) (hδ1 : δ≤1)
(hle : (δ:ℂ) • (thermalState n r hr).op ≤ τ.op)
(b : HilbertBasis J ℂ (Fock n)) (p : J → ℝ) (hp : ∀j, 0<p j) (hs : HasSum p 1)
(he : ∀j, τ.op (b j)=(p j:ℂ) • b j)
{α β : ℝ} (hα : 0≤α) (hβ : 0≤β)
(hform : ∀ x, ENNReal.ofReal (inner ℂ x (G.B x)).re = ENNReal.ofReal α*
sliceMoment b (fun j => ENNReal.ofReal (-Real.log (p j))) F.V (energyInverse n x)+
ENNReal.ofReal β*numberVectorMoment (energyInverse n x)) :
∃ C D : Fock n →L[ℂ] Fock n, C.IsPositive ∧ D.IsPositive ∧
(∀ x, ENNReal.ofReal (inner ℂ x (C x)).re =
sliceMoment b (fun j => ENNReal.ofReal (-Real.log (p j))) F.V
(inversePower rootNumberWeight rootNumberWeight_one_le 4 x)) ∧
(∀ x, ENNReal.ofReal (inner ℂ x (D x)).re =
numberVectorMoment (inversePower rootNumberWeight rootNumberWeight_one_le 4 x)) ∧
G.quarticLogarithm = (k:ℂ) • (1 : Fock n →L[ℂ] Fock n)+(α:ℂ) • C+(β:ℂ) • D+
(Real.log (heatPartition G.eigenval):ℂ) •
(inversePower rootNumberWeight rootNumberWeight_one_le 4 *
inversePower rootNumberWeight rootNumberWeight_one_le 4) := by sorry