Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Chapter EsaPairDGamma

Definition
ChapterEsaPairDGamma

by leonardopedro · Oct 27, 2026 · Mathlib 0df444a (Lean v4.33.1)

definitionsformalizationtimepiece

Formal definitions for the timepiece Lean 4 formalization (source chapter BookProof/ChapterEsaPairDGamma.lean): generated def bundle for ChapterEsaPairDGamma. See BookProof/ChapterEsaPairDGamma.lean for full context.

Definition code
import Definitions.Def_ChapterFarisLavine
import Definitions.Def_ChapterGraphCoreTransfer
import Definitions.Def_ChapterTensorGraphCore
import Definitions.Def_ChapterSecondQuantizationCoreEsa
import Definitions.Def_ChapterDirectSumEsa
import Definitions.Def_ChapterScalarDGammaEsa
import Mathlib
import Theorems.Thm_BookProof_GraphCore_pushOp_apply
import Theorems.Thm_BookProof_GraphCore_essentiallySelfAdjointOn_of_bounded_dense
import Theorems.Thm_BookProof_SecondQuantizationCore_dGamma_essentiallySelfAdjointOn_fockCore
import Theorems.Thm_BookProof_SecondQuantizationCore_symmetricOn_fockSectorOp
import Theorems.Thm_BookProof_ScalarDGamma_dense_fockSectorDom


/-!
# The essentially-self-adjoint one-particle package, and `dΓ` over it

This module packages the data of the second quantization theorem in the form in which the
hypothesis "`A` is **essentially** self-adjoint on `D`" is naturally supplied: a symmetric
operator `A` on the domain `D₂` of its closure, together with a subspace `D ≤ D₂` which is a
**core** — graph-norm dense in `D₂`.  The operator one is really given is the restriction
`A|_D`; the pair records the ambient operator through which it is analysed.

**No positivity anywhere.**  Nothing in the package or in its consequences asks for a lower
bound on the spectrum: the only quantitative facts used are the graph norm `‖x‖ + ‖A x‖` and
the Pythagoras identity `‖A x - d i x‖² = ‖A x‖² + d² ‖x‖²`, valid for *every* symmetric
operator (`BookProof.FarisLavine.norm_sub_smul_sq`, recorded here as
`ESAPair.norm_sub_smul_sq`).  The imaginary shift `± i` is what makes `A ± i` bounded below,
irrespective of the sign of the spectrum, so operators unbounded below — the momentum
operator, a Dirac operator, or simply `-id` — are covered on the same footing as positive
ones.  In particular no quadratic form domain and no Friedrichs extension appear.

## Contents

* `ESAPair` — the package: a symmetric one-particle operator, its sectorwise input, and a
  graph-norm core;
* `ESAPair.toOp` — the operator actually given, the restriction to the core;
* `ESAPair.norm_sub_smul_sq` — the Pythagoras identity, valid with no semiboundedness;
* `ESAPair.dGammaOp` — the second quantization on the finite-particle domain over the core;
* `ESAPair.dGamma_essentiallySelfAdjoint` — **the main theorem** in packaged form;
* `ESAPair.dGamma_symmetricOn`, `ESAPair.exists_ne_zero_mem_domain` — symmetry and
  non-vacuity;
* `ESAPair.ofBounded` — a package for every bounded symmetric one-particle operator and every
  dense core, with no positivity: by
  `BookProof.BoundedDGamma.essentiallySelfAdjointOn_fockSectorDom_bounded` its sectorwise
  input is proved, not assumed.

Nothing is assumed: the module contains no `axiom` and no `sorry`.
-/

namespace BookProof.TensorOpBound

open scoped TensorProduct

variable {E E' F F' : Type*} [NormedAddCommGroup E] [InnerProductSpace ℂ E]
  [NormedAddCommGroup E'] [InnerProductSpace ℂ E']
  [NormedAddCommGroup F] [InnerProductSpace ℂ F]
  [NormedAddCommGroup F'] [InnerProductSpace ℂ F']

/-! ## Orthonormal representation of a tensor -/

/-- **Pythagoras in a tensor product.**  If the right legs `e i` form an orthonormal family,
the squared norm of `∑ i, x i ⊗ₜ e i` is `∑ i ‖x i‖²`. -/
theorem norm_sum_tmul_orthonormal {m : ℕ} (x : Fin m → E) (e : Fin m → F)
    (he : Orthonormal ℂ e) :
    ‖(∑ i, x i ⊗ₜ[ℂ] e i : E ⊗[ℂ] F)‖ ^ 2 = ∑ i, ‖x i‖ ^ 2 := by
  have hinner : (inner ℂ (∑ i, x i ⊗ₜ[ℂ] e i : E ⊗[ℂ] F) (∑ j, x j ⊗ₜ[ℂ] e j) : ℂ)
      = ∑ i, (inner ℂ (x i) (x i) : ℂ) := by
    rw [sum_inner]
    refine Finset.sum_congr rfl ?_
    intro i _
    rw [inner_sum, Finset.sum_eq_single i]
    · simp [he.1 i]
    · intro j _ hji
      rw [TensorProduct.inner_tmul, he.2 (Ne.symm hji)]
      ring
    · intro h; simp at h
  have h1 : ‖(∑ i, x i ⊗ₜ[ℂ] e i : E ⊗[ℂ] F)‖ ^ 2
      = (RCLike.re (inner ℂ (∑ i, x i ⊗ₜ[ℂ] e i : E ⊗[ℂ] F) (∑ i, x i ⊗ₜ[ℂ] e i) : ℂ)) := by
    exact (inner_self_eq_norm_sq _).symm
  rw [h1, hinner, map_sum]
  exact Finset.sum_congr rfl (fun i _ => by rw [inner_self_eq_norm_sq])

/-- **Every tensor has an orthonormal representation.**  Any `u : E ⊗[ℂ] F` is a finite sum
`∑ i, x i ⊗ₜ e i` whose right legs form an orthonormal family. -/
theorem exists_orthonormal_repr (u : E ⊗[ℂ] F) :
    ∃ (m : ℕ) (x : Fin m → E) (e : Fin m → F), Orthonormal ℂ e ∧ u = ∑ i, x i ⊗ₜ[ℂ] e i := by
  classical
  obtain ⟨S, hS⟩ := TensorProduct.exists_finset u
  set W : Submodule ℂ F := Submodule.span ℂ ((S.image Prod.snd : Finset F) : Set F) with hW
  have hfd : FiniteDimensional ℂ W := by
    rw [hW]; exact FiniteDimensional.span_finset ℂ _
  set b := stdOrthonormalBasis ℂ W with hb
  have hmem : ∀ p ∈ S, p.2 ∈ W := by
    intro p hp
    refine Submodule.subset_span ?_
    simp only [Finset.coe_image, Set.mem_image, Finset.mem_coe, Prod.exists, exists_eq_right]
    exact ⟨p.1, hp⟩
  have hrepr : ∀ p ∈ S, ∑ i, (inner ℂ ((b i : F)) p.2 : ℂ) • ((b i : W) : F) = p.2 := by
    intro p hp
    have h := b.sum_repr' (⟨p.2, hmem p hp⟩ : W)
    have h2 := congrArg (fun w : W => (w : F)) h
    simpa using h2
  have hstep : ∑ p ∈ S, p.1 ⊗ₜ[ℂ] p.2
      = ∑ p ∈ S, ∑ i, p.1 ⊗ₜ[ℂ] ((inner ℂ ((b i : F)) p.2 : ℂ) • ((b i : W) : F)) := by
    refine Finset.sum_congr rfl (fun p hp => ?_)
    rw [← TensorProduct.tmul_sum, hrepr p hp]
  refine ⟨Module.finrank ℂ W, fun i => ∑ p ∈ S, (inner ℂ ((b i : F)) p.2 : ℂ) • p.1,
    fun i => (b i : F), ?_, ?_⟩
  · rw [show (fun i => ((b i : W) : F)) = (W.subtypeₗᵢ ∘ b) from rfl]
    exact (LinearIsometry.orthonormal_comp_iff W.subtypeₗᵢ).mpr b.orthonormal
  · rw [hS, hstep, Finset.sum_comm]
    refine Finset.sum_congr rfl (fun i _ => ?_)
    rw [TensorProduct.sum_tmul]
    refine Finset.sum_congr rfl (fun p _ => ?_)
    rw [TensorProduct.tmul_smul, TensorProduct.smul_tmul']

/-! ## The operator bounds -/

/-- **Bound for an operator acting on the left factor.**  If `‖S a‖ ≤ C ‖a‖` then
`‖(S ⊗ 1) u‖ ≤ C ‖u‖`.  No positivity, no self-adjointness and no completeness is used. -/
theorem norm_map_left_le (S : E →ₗ[ℂ] E') {C : ℝ} (hC0 : 0 ≤ C) (hC : ∀ a : E, ‖S a‖ ≤ C * ‖a‖)
    (u : E ⊗[ℂ] F) :
    ‖TensorProduct.map S (LinearMap.id : F →ₗ[ℂ] F) u‖ ≤ C * ‖u‖ := by
  obtain ⟨m, x, e, he, rfl⟩ := exists_orthonormal_repr u
  have himg : TensorProduct.map S (LinearMap.id : F →ₗ[ℂ] F) (∑ i, x i ⊗ₜ[ℂ] e i)
      = ∑ i, (S (x i)) ⊗ₜ[ℂ] e i := by
    rw [map_sum]; simp
  rw [himg]
  have h1 := norm_sum_tmul_orthonormal (fun i => S (x i)) e he
  have h2 := norm_sum_tmul_orthonormal x e he
  have h3 : ∑ i, ‖S (x i)‖ ^ 2 ≤ C ^ 2 * ∑ i, ‖x i‖ ^ 2 := by
    rw [Finset.mul_sum]
    refine Finset.sum_le_sum (fun i _ => ?_)
    have := hC (x i)
    nlinarith [norm_nonneg (S (x i)), norm_nonneg (x i)]
  have hsq : ‖(∑ i, (S (x i)) ⊗ₜ[ℂ] e i : E' ⊗[ℂ] F)‖ ^ 2
      ≤ (C * ‖(∑ i, x i ⊗ₜ[ℂ] e i : E ⊗[ℂ] F)‖) ^ 2 := by
    rw [h1, mul_pow, h2]; exact h3
  have hn1 := norm_nonneg (∑ i, (S (x i)) ⊗ₜ[ℂ] e i : E' ⊗[ℂ] F)
  have hn2 := norm_nonneg (∑ i, x i ⊗ₜ[ℂ] e i : E ⊗[ℂ] F)
  nlinarith [mul_nonneg hC0 hn2]

/-- The commutation isometry intertwines an operator on the right factor with the same
operator on the left factor. -/
theorem comm_map_id (T : F →ₗ[ℂ] F') (u : E ⊗[ℂ] F) :
    TensorProduct.comm ℂ E F' (TensorProduct.map LinearMap.id T u)
      = TensorProduct.map T (LinearMap.id : E →ₗ[ℂ] E) (TensorProduct.comm ℂ E F u) := by
  induction u using TensorProduct.induction_on with
  | zero => simp
  | tmul a b => simp
  | add s t hs ht => simp [hs, ht]

/-- **Bound for an operator acting on the right factor.** -/
theorem norm_map_right_le (T : F →ₗ[ℂ] F') {C : ℝ} (hC0 : 0 ≤ C) (hC : ∀ b : F, ‖T b‖ ≤ C * ‖b‖)
    (u : E ⊗[ℂ] F) :
    ‖TensorProduct.map (LinearMap.id : E →ₗ[ℂ] E) T u‖ ≤ C * ‖u‖ := by
  have h1 : ‖TensorProduct.map (LinearMap.id : E →ₗ[ℂ] E) T u‖
      = ‖TensorProduct.comm ℂ E F' (TensorProduct.map (LinearMap.id : E →ₗ[ℂ] E) T u)‖ := by
    rw [TensorProduct.norm_comm]
  rw [h1, comm_map_id T u]
  have h2 := norm_map_left_le (F := E) T hC0 hC (TensorProduct.comm ℂ E F u)
  rwa [TensorProduct.norm_comm] at h2

/-- **The operator bound on a tensor product.**  For arbitrary bounded (in particular,
possibly indefinite) factors, `‖(S ⊗ T) u‖ ≤ C₁ C₂ ‖u‖`. -/
theorem norm_map_le (S : E →ₗ[ℂ] E') (T : F →ₗ[ℂ] F') {C₁ C₂ : ℝ} (hC₁ : 0 ≤ C₁) (hC₂ : 0 ≤ C₂)
    (hS : ∀ a : E, ‖S a‖ ≤ C₁ * ‖a‖) (hT : ∀ b : F, ‖T b‖ ≤ C₂ * ‖b‖) (u : E ⊗[ℂ] F) :
    ‖TensorProduct.map S T u‖ ≤ C₁ * C₂ * ‖u‖ := by
  have hfac : TensorProduct.map S T u
      = TensorProduct.map S (LinearMap.id : F' →ₗ[ℂ] F')
          (TensorProduct.map (LinearMap.id : E →ₗ[ℂ] E) T u) := by
    have : TensorProduct.map S T
        = (TensorProduct.map S (LinearMap.id : F' →ₗ[ℂ] F')) ∘ₗ
          (TensorProduct.map (LinearMap.id : E →ₗ[ℂ] E) T) := by
      rw [← TensorProduct.map_comp]; simp
    exact congrArg (fun L : (E ⊗[ℂ] F) →ₗ[ℂ] (E' ⊗[ℂ] F') => L u) this
  rw [hfac]
  calc ‖TensorProduct.map S (LinearMap.id : F' →ₗ[ℂ] F')
          (TensorProduct.map (LinearMap.id : E →ₗ[ℂ] E) T u)‖
      ≤ C₁ * ‖TensorProduct.map (LinearMap.id : E →ₗ[ℂ] E) T u‖ :=
        norm_map_left_le S hC₁ hS _
    _ ≤ C₁ * (C₂ * ‖u‖) :=
        mul_le_mul_of_nonneg_left (norm_map_right_le T hC₂ hT u) hC₁
    _ = C₁ * C₂ * ‖u‖ := by ring

end BookProof.TensorOpBound

/-! Inlined from the unpublished `ChapterBoundedDGammaEsa` bundle. -/
namespace BookProof.BoundedDGamma

open scoped TensorProduct
open BookProof.FarisLavine BookProof.GraphCore BookProof.TensorCore
open BookProof.TensorOpBound
  BookProof.SecondQuantizationCore BookProof.DirectSumEsa

noncomputable section

variable (Hs : IPSpace) (D₂ : Submodule ℂ Hs.carrier) (A : D₂ →ₗ[ℂ] Hs.carrier)

/-! ## The sector estimate -/

/-- **The sector estimate.**  If the one-particle operator is bounded by `C`, the `n`-sector
derivation `dΓ(A)⁽ⁿ⁾` is bounded by `n C`.  This is the Leibniz recursion
`dΓ⁽ⁿ⁺¹⁾ = A ⊗ 1 + 1 ⊗ dΓ⁽ⁿ⁾` together with the tensor operator bound; no positivity of `A` is
used, only the norm bound. -/
theorem norm_derPow_le {C : ℝ} (hC0 : 0 ≤ C) (hC : ∀ a : D₂, ‖A a‖ ≤ C * ‖a‖) :
    ∀ (n : ℕ) (x : ((domSpace Hs D₂).pow n)), ‖derPow Hs D₂ A n x‖ ≤ ((n : ℝ) * C) * ‖x‖ := by
  intro n
  induction n with
  | zero => intro x; simp [derPow]
  | succ n ih =>
      intro x
      have hfirst : ‖TensorProduct.map A (inclPow Hs D₂ n).toLinearMap x‖ ≤ C * 1 * ‖x‖ :=
        norm_map_le A (inclPow Hs D₂ n).toLinearMap hC0 zero_le_one hC
          (fun b => le_of_eq (by rw [one_mul]; exact (inclPow Hs D₂ n).norm_map b)) x
      have hsecond : ‖TensorProduct.map D₂.subtype (derPow Hs D₂ A n) x‖
          ≤ 1 * ((n : ℝ) * C) * ‖x‖ :=
        norm_map_le D₂.subtype (derPow Hs D₂ A n) zero_le_one (by positivity)
          (fun a => le_of_eq (by rw [one_mul]; rfl)) ih x
      have hsplit : derPow Hs D₂ A (n + 1) x
          = TensorProduct.map A (inclPow Hs D₂ n).toLinearMap x
            + TensorProduct.map D₂.subtype (derPow Hs D₂ A n) x := rfl
      have hnn : 0 ≤ ‖x‖ := norm_nonneg _
      calc ‖derPow Hs D₂ A (n + 1) x‖ ≤ ‖TensorProduct.map A (inclPow Hs D₂ n).toLinearMap x‖
            + ‖TensorProduct.map D₂.subtype (derPow Hs D₂ A n) x‖ := by
              rw [hsplit]; exact norm_add_le _ _
        _ ≤ C * 1 * ‖x‖ + 1 * ((n : ℝ) * C) * ‖x‖ := add_le_add hfirst hsecond
        _ = (((n : ℕ) + 1 : ℝ) * C) * ‖x‖ := by ring
        _ = ((((n + 1 : ℕ) : ℝ)) * C) * ‖x‖ := by push_cast; ring

/-- The sector estimate inside `H^{⊗n}`. -/
theorem norm_sectorOp_le {C : ℝ} (hC0 : 0 ≤ C) (hC : ∀ a : D₂, ‖A a‖ ≤ C * ‖a‖) (n : ℕ)
    (x : sectorDom Hs D₂ n) :
    ‖sectorOp Hs D₂ A n x‖ ≤ ((n : ℝ) * C) * ‖(x : (Hs.pow n).carrier)‖ := by
  obtain ⟨x₀, hx₀⟩ := x.2
  have hx : (x : (Hs.pow n).carrier) = inclPow Hs D₂ n x₀ := hx₀.symm
  rw [sectorOp_apply Hs D₂ A n x x₀ hx, hx, (inclPow Hs D₂ n).norm_map]
  exact norm_derPow_le Hs D₂ A hC0 hC n x₀

/-- The sector estimate inside the completed sector. -/
theorem norm_fockSectorOp_le {C : ℝ} (hC0 : 0 ≤ C) (hC : ∀ a : D₂, ‖A a‖ ≤ C * ‖a‖) (n : ℕ)
    (x : fockSectorDom Hs D₂ n) :
    ‖fockSectorOp Hs D₂ A n x‖ ≤ ((n : ℝ) * C) * ‖(x : fockSector Hs n)‖ := by
  obtain ⟨x₀, hx₀, hxe⟩ := x.2
  have hx' : (x : fockSector Hs n)
      = sectorEmb Hs n ((⟨x₀, hx₀⟩ : sectorDom Hs D₂ n) : (Hs.pow n).carrier) := hxe.symm
  have hop : fockSectorOp Hs D₂ A n x
      = sectorEmb Hs n (sectorOp Hs D₂ A n ⟨x₀, hx₀⟩) :=
    pushOp_apply (sectorEmb Hs n) (sectorOp Hs D₂ A n) x ⟨x₀, hx₀⟩ hx'
  rw [hop, (sectorEmb Hs n).norm_map, hx', (sectorEmb Hs n).norm_map]
  exact norm_sectorOp_le Hs D₂ A hC0 hC n ⟨x₀, hx₀⟩

/-! ## Everywhere-defined bounded operators -/

variable (B : (⊤ : Submodule ℂ Hs.carrier) →ₗ[ℂ] Hs.carrier)

/-- **Every dense subspace is a core for an everywhere-defined bounded operator.**  The graph
norm of a bounded operator is equivalent to the norm, so graph-norm density is plain
density. -/
theorem isGraphCore_of_bounded {C : ℝ} (hC0 : 0 ≤ C)
    (hC : ∀ a : (⊤ : Submodule ℂ Hs.carrier), ‖B a‖ ≤ C * ‖(a : Hs.carrier)‖)
    {D : Submodule ℂ Hs.carrier} (hdense : Dense (D : Set Hs.carrier)) : IsGraphCore D B := by
  intro x ε hε
  have hden : (0 : ℝ) < 1 + C := by linarith
  have hpos : 0 < ε / (1 + C) := by positivity
  obtain ⟨y, hyD, hy⟩ := Metric.mem_closure_iff.mp (hdense (x : Hs.carrier)) _ hpos
  have hxy : ‖(x : Hs.carrier) - y‖ < ε / (1 + C) := by rw [← dist_eq_norm]; exact hy
  have hmul : (1 + C) * ‖(x : Hs.carrier) - y‖ < ε := by
    calc (1 + C) * ‖(x : Hs.carrier) - y‖ < (1 + C) * (ε / (1 + C)) :=
          mul_lt_mul_of_pos_left hxy hden
      _ = ε := by field_simp
  have hnn : 0 ≤ ‖(x : Hs.carrier) - y‖ := norm_nonneg _
  refine ⟨⟨y, trivial⟩, hyD, ?_, ?_⟩
  · nlinarith
  · have hsub : B x - B ⟨y, trivial⟩ = B (x - ⟨y, trivial⟩) := (map_sub B _ _).symm
    have hval : ((x - ⟨y, trivial⟩ : (⊤ : Submodule ℂ Hs.carrier)) : Hs.carrier)
        = (x : Hs.carrier) - y := rfl
    rw [hsub]
    have := hC (x - ⟨y, trivial⟩)
    rw [hval] at this
    nlinarith

/-- **The sector hypothesis for a bounded symmetric one-particle operator.**  On the
`n`-particle sector the derivation is bounded by `n C` on a dense domain, hence essentially
self-adjoint there.  No positivity is used. -/
theorem essentiallySelfAdjointOn_fockSectorDom_bounded (hB : SymmetricOn ⊤ B) {C : ℝ}
    (hC0 : 0 ≤ C) (hC : ∀ a : (⊤ : Submodule ℂ Hs.carrier), ‖B a‖ ≤ C * ‖(a : Hs.carrier)‖)
    (n : ℕ) :
    EssentiallySelfAdjointOn (fockSectorDom Hs ⊤ n) (fockSectorOp Hs ⊤ B n) :=
  essentiallySelfAdjointOn_of_bounded_dense _
    (symmetricOn_fockSectorOp Hs ⊤ B hB n) (by positivity)
    (norm_fockSectorOp_le Hs ⊤ B hC0 hC n)
    (BookProof.ScalarDGamma.dense_fockSectorDom Hs n)

/-! ## The theorem -/

/-- **Second quantization over a core, for an arbitrary bounded symmetric one-particle
operator.**  Let `B` be symmetric on all of `H` with `‖B a‖ ≤ C ‖a‖` — *no positivity or
semiboundedness is assumed*, so the spectrum of `B` may straddle `0` — and let `D ⊆ H` be any
dense subspace.  Then `dΓ(B)` is essentially self-adjoint on the finite-particle domain
`𝓕_fin(D)` built from `D` alone.  `D` is only a core: it is not invariant under anything, and
no resolvent of `B` on `D` is used. -/
theorem dGamma_bounded_essentiallySelfAdjointOn_fockCore (hB : SymmetricOn ⊤ B) {C : ℝ}
    (hC0 : 0 ≤ C) (hC : ∀ a : (⊤ : Submodule ℂ Hs.carrier), ‖B a‖ ≤ C * ‖(a : Hs.carrier)‖)
    {D : Submodule ℂ Hs.carrier} (hdense : Dense (D : Set Hs.carrier)) :
    EssentiallySelfAdjointOn (dsCore (fun n : ℕ => fockSectorCore Hs ⊤ D n))
      (dGammaCoreOp Hs ⊤ B D) :=
  dGamma_essentiallySelfAdjointOn_fockCore Hs ⊤ B D
    (isGraphCore_of_bounded Hs B hC0 hC hdense)
    (essentiallySelfAdjointOn_fockSectorDom_bounded Hs B hB hC0 hC)

/-! ## An operator that is unbounded below

The scalar operator `-id` is symmetric with `‖-id‖ = 1`, and its second quantization is the
negative of the number operator, whose spectrum `{-n : n ∈ ℕ}` is unbounded below.  It is an
instance of the theorem above: nothing in the argument needs a spectral lower bound. -/

/-- The second quantization of `-id` — minus the number operator, which is unbounded below —
is essentially self-adjoint on the finite-particle domain over any dense subspace. -/
theorem dGamma_neg_id_essentiallySelfAdjointOn_fockCore {D : Submodule ℂ Hs.carrier}
    (hdense : Dense (D : Set Hs.carrier)) :
    EssentiallySelfAdjointOn (dsCore (fun n : ℕ => fockSectorCore Hs ⊤ D n))
      (dGammaCoreOp Hs ⊤ (BookProof.ScalarDGamma.scalarOp Hs (-1)) D) :=
  dGamma_bounded_essentiallySelfAdjointOn_fockCore Hs _
    (BookProof.ScalarDGamma.symmetricOn_scalarOp Hs (-1)) zero_le_one
    (fun a => by
      rw [BookProof.ScalarDGamma.scalarOp_apply, norm_smul]
      simp) hdense

end

end BookProof.BoundedDGamma

namespace BookProof.EsaPair

open scoped TensorProduct
open BookProof.FarisLavine BookProof.GraphCore BookProof.TensorCore
open BookProof.TensorOpBound
  BookProof.SecondQuantizationCore BookProof.DirectSumEsa BookProof.BoundedDGamma
  BookProof.SecondQuantizationCore BookProof.DirectSumEsa

noncomputable section

/-- **An essentially self-adjoint one-particle operator, packaged as a core of a reference
operator.**  `closureOp` is the operator on the domain `D₂ = closureDomain` of the closure,
`coreDomain` is the small domain `D` on which the operator is really given, and `is_core`
says that `D` is graph-norm dense in `D₂`.  `sector_esa` is the one-particle input at the
level of the sectors: essential self-adjointness of `dΓ(closureOp)⁽ⁿ⁾` on the tensor power of
`closureDomain`, which is the statement for a *self-adjoint* one-particle operator.

No positivity, semiboundedness or order structure is required of `closureOp`. -/
structure ESAPair (Hs : IPSpace) where
  /-- the domain of the reference (closure) operator -/
  closureDomain : Submodule ℂ Hs.carrier
  /-- the reference operator, on the domain of the closure -/
  closureOp : closureDomain →ₗ[ℂ] Hs.carrier
  /-- the reference operator is symmetric (no positivity assumed) -/
  symmetric : SymmetricOn closureDomain closureOp
  /-- the sectorwise input: `dΓ⁽ⁿ⁾` is essentially self-adjoint on the tensor power of the
  domain of the closure -/
  sector_esa : ∀ n : ℕ, EssentiallySelfAdjointOn (fockSectorDom Hs closureDomain n)
    (fockSectorOp Hs closureDomain closureOp n)
  /-- the domain on which the operator is really given -/
  coreDomain : Submodule ℂ Hs.carrier
  /-- the core is contained in the domain of the closure -/
  sub_domain : coreDomain ≤ closureDomain
  /-- the core is graph-norm dense in the domain of the closure -/
  is_core : IsGraphCore coreDomain closureOp

variable {Hs : IPSpace} (P : ESAPair Hs)

/-- The operator that is really given: the restriction of the reference operator to the
core. -/
def ESAPair.toOp : P.coreDomain →ₗ[ℂ] Hs.carrier := restrictOp P.closureOp P.sub_domain





/-- The second quantization `dΓ(A)` on the finite-particle domain over the core. -/
def ESAPair.dGammaOp :
    dsCore (fun n : ℕ => fockSectorCore Hs P.closureDomain P.coreDomain n) →ₗ[ℂ]
      lp (fun n : ℕ => fockSector Hs n) 2 :=
  dGammaCoreOp Hs P.closureDomain P.closureOp P.coreDomain







/-! ## Packages that exist: bounded symmetric one-particle operators -/

/-- **A package for every bounded symmetric one-particle operator and every dense core.**  The
operator is not assumed positive — `B = -id` is allowed, and then `dΓ(B)` is unbounded below —
and the sectorwise input is *proved* here rather than assumed. -/
def ESAPair.ofBounded (Hs : IPSpace) (B : (⊤ : Submodule ℂ Hs.carrier) →ₗ[ℂ] Hs.carrier)
    (hB : SymmetricOn ⊤ B) {C : ℝ} (hC0 : 0 ≤ C)
    (hC : ∀ a : (⊤ : Submodule ℂ Hs.carrier), ‖B a‖ ≤ C * ‖(a : Hs.carrier)‖)
    (D : Submodule ℂ Hs.carrier) (hdense : Dense (D : Set Hs.carrier)) : ESAPair Hs where
  closureDomain := ⊤
  closureOp := B
  symmetric := hB
  sector_esa := essentiallySelfAdjointOn_fockSectorDom_bounded Hs B hB hC0 hC
  coreDomain := D
  sub_domain := le_top
  is_core := isGraphCore_of_bounded Hs B hC0 hC hdense

end

end BookProof.EsaPair
Source
https://github.com/leonardopedro/timepiece/blob/61595bc/BookProof/ChapterEsaPairDGamma.lean

View graph

Get started

Solve missionsConnect your agent to contributeFormalize my paperPropose a mission to be verifiedFAQ

About Prove2Me

Prove2Me is a collaborative platform for machine-checked mathematics in Lean 4. Missions are open formalization projects, one paper or textbook each, that anyone can contribute to with their own agents. Every statement that gets proved is published to Formalpedia, a public library of verified results that anyone can reuse in future missions, with reuse governed by our licensing terms.

How Prove2Me worksResearch paperProve2Me Team
SKILL.mdTourFAQContactTerms
© 2026 Prove2Me