Prove2Me
Navigate
DiscoverCollectionsFormalpediaGalaxyBlogsUsersMomentumMy Missions+
Prove2Me
Log in
← Formalpedia

Chapter TensorSumChain

Definition
ChapterTensorSumChain

by leonardopedro · Nov 4, 2026 · Mathlib 0df444a (Lean v4.33.1)

definitionsformalizationtimepiece

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

Definition code




import Theorems.Thm_BookProof_FriedrichsSquare_IsFriedrichsSqExtension_symmetric

import Definitions.Def_ChapterTensorSumEsa
import Definitions.Def_ChapterStoneSeparable
import Definitions.Def_ChapterUnboundedPosition
import Definitions.Def_ChapterFarisLavine
import Definitions.Def_ChapterTensorGraphCore
import Definitions.Def_ChapterEsaOneParticleDGamma
import Mathlib


/-!
# Finitely many factors: the total tensor sum `∑ᵢ 1 ⊗ ⋯ ⊗ Aᵢ ⊗ ⋯ ⊗ 1`

`BookProof/ChapterTensorSumEsa.lean` proves the two-factor statement: for symmetric,
essentially self-adjoint `A` on `H` and `B` on `K`, the tensor sum `A ⊗ 1 + 1 ⊗ B` is
essentially self-adjoint on the algebraic tensor product of the two domains inside `H ⊗̂ K`.
Crucially the *conclusion* is of the same shape as the two *hypotheses* — symmetric,
essentially self-adjoint, densely defined on a Hilbert space — so the statement iterates.

This module performs the iteration.  `EsaOp` bundles exactly the data the two-factor theorem
consumes and produces (a Hilbert space, a dense domain, a symmetric operator on it, and
essential self-adjointness), `pair` is the two-factor theorem in that vocabulary, and `chain`
folds `pair` along a list.  The result is the total tensor sum of an arbitrary finite family
of *different* operators on *different* Hilbert spaces:

`H = A₁ ⊗ 1 ⊗ ⋯ ⊗ 1 + 1 ⊗ A₂ ⊗ 1 ⊗ ⋯ ⊗ 1 + ⋯ + 1 ⊗ ⋯ ⊗ 1 ⊗ A_n`,

the Hamiltonian of `n` non-interacting degrees of freedom, essentially self-adjoint on the
algebraic tensor product of the `n` domains, with a complete unitary flow.

## Contents

* `EsaOp` — the bundle; `pair` — the two-factor step; `pair_op_tmul` — the operator really is
  `(x ⊗ y) ↦ A x ⊗ y + x ⊗ B y`.
* `chain`, `chain_dense`, `chain_symmetric`, **`chain_esa`** — the `n`-factor tensor sum is
  densely defined, symmetric and essentially self-adjoint; `chain_stone_flow` — its unitary
  group.
* `chain_singleton`, `chain_cons` — the two recursion equations.
* `posEsaOp`, `positionChain_esa` — the concrete instance: `n` copies of the (unbounded)
  position operator of `ℓ²(ℤ)`, whose total tensor sum `k₁ + k₂ + ⋯ + kₙ` is essentially
  self-adjoint.

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

namespace BookProof.TensorSumChain

open scoped TensorProduct
open BookProof.FarisLavine BookProof.TensorCore BookProof.TensorSumEsa
  BookProof.ChapterStoneResolvent BookProof.StoneBridge BookProof.GraphCore
  BookProof.EsaClosure

noncomputable section

/-- A symmetric operator, essentially self-adjoint on a dense domain of a Hilbert space:
exactly the data the two-factor tensor-sum theorem consumes, and exactly what it produces. -/
structure EsaOp where
  /-- the Hilbert space -/
  space : IPSpace
  /-- it is complete -/
  complete : CompleteSpace space.carrier
  /-- the domain -/
  dom : Submodule ℂ space.carrier
  /-- the operator -/
  op : dom →ₗ[ℂ] space.carrier
  /-- the domain is dense -/
  dense : Dense (dom : Set space.carrier)
  /-- the operator is symmetric -/
  sym : SymmetricOn dom op
  /-- and essentially self-adjoint -/
  esa : EssentiallySelfAdjointOn dom op

/-- **The two-factor step.**  The tensor sum `A ⊗ 1 + 1 ⊗ B` of two members of the class is
again a member of the class, on the completed tensor product of the two spaces. -/
def pair (E F : EsaOp) : EsaOp :=
  haveI := E.complete
  haveI := F.complete
  { space := ⟨ctensor E.space F.space⟩
    complete := inferInstanceAs (CompleteSpace (ctensor E.space F.space))
    dom := cpairDom E.space F.space E.dom F.dom
    op := cpairOp E.space F.space E.dom F.dom E.op F.op
    dense := dense_cpairDom E.space F.space E.dom F.dom E.dense F.dense
    sym := symmetricOn_cpairOp E.space F.space E.dom F.dom E.op F.op E.sym F.sym
    esa := essentiallySelfAdjointOn_cpairDom_esa E.op F.op E.dense F.dense E.sym F.sym
      E.esa F.esa }

@[simp] theorem pair_space (E F : EsaOp) :
    (pair E F).space = ⟨ctensor E.space F.space⟩ := rfl

@[simp] theorem pair_dom (E F : EsaOp) :
    (pair E F).dom = cpairDom E.space F.space E.dom F.dom := rfl



/-- The total tensor sum of a nonempty finite family, by folding the two-factor step. -/
def chain : EsaOp → List EsaOp → EsaOp
  | E, [] => E
  | E, (F :: rest) => pair E (chain F rest)

@[simp] theorem chain_singleton (E : EsaOp) : chain E [] = E := rfl

@[simp] theorem chain_cons (E F : EsaOp) (L : List EsaOp) :
    chain E (F :: L) = pair E (chain F L) := rfl









/-! ## A genuinely unbounded instance: `n` copies of the position operator -/

section Position

open BookProof.ChapterStoneSeparable BookProof.ChapterUnboundedPosition
  BookProof.FlowDGamma BookProof.EsaOneParticle

/-- The position operator of `ℓ²(ℤ)` as a member of the class. -/
def posEsaOp : EsaOp where
  space := L2ZSpace
  complete := inferInstanceAs (CompleteSpace L2ZSpace.carrier)
  dom := (mulSA positionField).domain
  op := (mulSA positionField).op
  dense := (mulSA positionField).denseDomain
  sym := (mulSA positionField).symmetric
  esa := essentiallySelfAdjointOn_of_selfAdjoint (Hs := L2ZSpace) (mulSA positionField)





end Position

end

end BookProof.TensorSumChain
Source
https://github.com/leonardopedro/timepiece/blob/61595bc/BookProof/ChapterTensorSumChain.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