Get AI summaries of any video or article — Sign up free
Unbounded Operators 5 | Example thumbnail

Unbounded Operators 5 | Example

4 min read

Based on The Bright Side of Mathematics's video on YouTube. If you like this content, support the original creators by watching, liking and subscribing to their content.

TL;DR

Define T on ℓ² by setting T(Eⱼ) = j on the dense domain span{Eⱼ} and extending linearly to finite combinations.

Briefing

A concrete example in ℓ² shows how easy it is to build an unbounded linear operator that fails even the basic requirement of closability. The setup uses the Hilbert space X = ℓ² (square-summable complex sequences) and a dense domain consisting of all finite linear combinations of the canonical unit vectors E₁, E₂, E₃, … . The operator T maps each unit vector Eⱼ to the complex number j, and then extends linearly to the whole span of these unit vectors.

The first key result is that T is unbounded. Computing the operator norm means taking the supremum of ||Tx|| over all inputs x with ||x|| = 1. Restricting attention to unit vectors already forces the supremum to blow up: ||T(Eⱼ)|| equals |j| (since the codomain is ℂ with its usual absolute value norm). Because |j| grows without bound as j increases, no finite operator norm exists. So T is unbounded, as expected for many natural “coordinate-like” maps on infinite-dimensional spaces.

The second key result is more striking: T is not closable. Closability can be tested using a sequence criterion: if xₙ in the domain tends to 0 and Txₙ tends to some y, then closability forces y = 0. Here, T is deliberately arranged so that images can converge to a nonzero limit even when the inputs collapse to 0.

To produce the contradiction, one starts with a sequence in the domain that converges to 0 but whose images do not converge to 0. The argument then refines this by selecting a subsequence whose images stay a fixed distance away from 0—so |Txₖ| ≥ ε for some ε > 0. With that safety margin, a new sequence zₖ is defined by normalizing: zₖ = xₖ / (Txₖ). This keeps zₖ inside the domain and ensures zₖ → 0 in ℓ², because dividing by the nonvanishing scalars does not prevent convergence to 0.

Yet the images behave differently: Tzₖ = T(xₖ)/(Txₖ) = 1 for every k. Therefore Txₖ (after normalization) converges to y = 1 in ℂ, while the corresponding inputs converge to 0. The closability criterion would require y = 0, so the nonzero limit produces a direct contradiction. The conclusion is that T is not closable—and consequently it is also not a closed operator.

The broader takeaway is practical: in infinite-dimensional settings, unbounded operators can fail closability with little effort, even when they look simple on a dense domain. This example serves as a warning while setting up later “positive” cases where unbounded operators are closed or closable under additional structure.

Cornell Notes

The example builds a linear operator T on X = ℓ² with dense domain equal to the span of the canonical unit vectors E₁, E₂, … . It defines T(Eⱼ) = j and extends linearly to all finite linear combinations. Since ||T(Eⱼ)|| = |j| grows without bound, T has no finite operator norm and is unbounded. Closability is tested via a sequence criterion: if xₙ → 0 and Txₙ → y, then closability forces y = 0. By normalizing a suitable sequence, one gets zₖ → 0 but Tzₖ = 1 for all k, so Txₖ converges to y = 1 ≠ 0. That contradiction shows T is not closable, and therefore not closed.

Why does T automatically become unbounded once T(Eⱼ) = j is defined on ℓ²?

The operator norm would be sup{||Tx|| : ||x|| = 1}. Taking x = Eⱼ (each has ||Eⱼ|| = 1) gives ||T(Eⱼ)|| = |j| in ℂ. Since |j| → ∞ as j increases, the supremum cannot be finite, so T is unbounded.

What is the sequence-based criterion for closability, and how does it force y = 0?

For a closable operator, whenever a sequence xₙ in the domain satisfies xₙ → 0 in X and Txₙ → y in Y, the limit must be y = 0. Intuitively, images of vectors approaching 0 cannot converge to a nonzero vector if the operator is closable.

How does the construction of zₖ = xₖ/(Txₖ) guarantee zₖ → 0?

One first chooses a sequence xₖ in the domain with xₖ → 0 and arranges (via a subsequence) that |Txₖ| ≥ ε > 0. Dividing by Txₖ is then dividing by scalars bounded away from 0, so zₖ = xₖ/(Txₖ) still converges to 0 in ℓ².

Why does the normalization make the images constant, i.e., Tzₖ = 1?

Linearity gives Tzₖ = T(xₖ/(Txₖ)) = T(xₖ)/(Txₖ). Since Txₖ is a complex number, this simplifies to 1 for every k. Hence Tzₖ converges to y = 1 in ℂ.

What exact contradiction proves T is not closable?

The closability criterion would require that if zₖ → 0 and Tzₖ → y, then y must equal 0. Here zₖ → 0 but Tzₖ = 1 for all k, so the limit y = 1 ≠ 0. That violates the criterion, so T is not closable (and thus not closed).

Review Questions

  1. State the sequence criterion for closability and explain why it forces the limit y to be 0.
  2. Given T(Eⱼ) = j on the dense span of {Eⱼ} in ℓ², compute ||T(Eⱼ)|| and determine whether T can be bounded.
  3. Describe how one can construct a sequence zₖ in the domain such that zₖ → 0 but Tzₖ converges to a nonzero limit.

Key Points

  1. 1

    Define T on ℓ² by setting T(Eⱼ) = j on the dense domain span{Eⱼ} and extending linearly to finite combinations.

  2. 2

    Checking boundedness on unit vectors Eⱼ shows ||T(Eⱼ)|| = |j|, so the operator norm is infinite and T is unbounded.

  3. 3

    Closability can be tested with sequences: if xₙ → 0 and Txₙ → y, then closability requires y = 0.

  4. 4

    A subsequence can be chosen so that |Txₖ| stays uniformly away from 0, enabling safe normalization.

  5. 5

    Normalizing via zₖ = xₖ/(Txₖ) forces zₖ → 0 while making Tzₖ = 1 for all k.

  6. 6

    The nonzero limit y = 1 contradicts the closability criterion, proving T is not closable.

  7. 7

    Since closable operators include closed operators as a special case, failure of closability implies T is not closed either.

Highlights

An operator on ℓ² with T(Eⱼ) = j is unbounded because ||T(Eⱼ)|| = |j| grows without limit.
Closability fails when inputs approach 0 but normalized images converge to a nonzero limit.
The normalization trick zₖ = xₖ/(Txₖ) yields Tzₖ = 1 while zₖ → 0.
In infinite dimensions, unbounded operators can be neither closable nor closed even when defined simply on a dense domain.

Topics