Expected Value - Definition and Properties

Learning Objectives

Historical Context

Historical Insight: The term "expected value" originally meant "what you should expect to win" in a fair game. Today it means the long-run average of any random variable.

What is Expectation Intuitively?

Let this picture be in your mind: If a random variable $X$ produces values—sometimes small, sometimes large, sometimes medium—then the expectation is the single number that summarizes where the outcomes concentrate on average.

The Core Insight: Expectation is the "average destination of randomness." Even though randomness produces chaos moment-to-moment, expectation captures where everything gravitates toward in the long run.

Correcting Common Misconceptions

The Formula: Why Sum and Integral?

For Discrete Random Variables

$\mathbb{E}[X] = \sum_x x \cdot P(X = x)$

For Continuous Random Variables

$\mathbb{E}[X] = \int_{-\infty}^{\infty} x \cdot f_X(x) \\, dx$

Interpretation: You multiply each possible value by how likely it is. Then you add (or integrate) them up. The result is the weighted average of all possibilities.

More Generally: Functions of Random Variables

In reality, we often care about functions of X, not just X itself:

$\mathbb{E}[g(X)] = \int g(x) \cdot f_X(x) \\, dx$

This is necessary because in real systems:

• Power = $g(X) = X^2$
• Loss = $g(X) = \ell(X)$
• Log-likelihood = $g(X) = \log p(X)$

LOTUS: Law of the Unconscious Statistician

One of the most powerful formulas in probability is the Law of the Unconscious Statistician (LOTUS). It lets you compute E[g(X)] without finding the distribution of g(X):

$\mathbb{E}[g(X)] = \sum_x g(x) \cdot P(X = x) \quad \text{(discrete)}$

$\mathbb{E}[g(X)] = \int_{-\infty}^{\infty} g(x) \cdot f_X(x) \\, dx \quad \text{(continuous)}$

LOTUS in Practice

Interactive: Weighted Average

Experiment with this visualization to see how expectation is computed as a weighted average:

Expectation as Center of Mass

Think of your random variable as mass spread on a number line. The expectation is the point where you could balance the distribution on a needle.

This physics analogy is not just a metaphor—it is mathematically exact! Just as center of mass is the weighted average of positions (weighted by mass), expectation is the weighted average of values (weighted by probability).

Expectations of Common Distributions

Here is a quick reference for the expectations of distributions you'll encounter frequently in ML and statistics:

Discrete Distributions

Continuous Distributions

Why Statisticians Love Expectation

Expectation has magical properties that make it the foundation of all statistical analysis:

1. It Compresses the Whole Distribution into One Stable Number

Even if the distribution is complicated, expectation gives a stable center that summarizes the "typical" behavior.

2. It is LINEAR (This is HUGE!)

$\mathbb{E}[aX + bY] = a\mathbb{E}[X] + b\mathbb{E}[Y]$

No other summary behaves this nicely! This makes derivations, proofs, estimators, and ML algorithms beautifully simple.

3. It Connects to Reality Through the Law of Large Numbers

$\frac{1}{n}\sum_{i=1}^{n} X_i \to \mathbb{E}[X] \text{ as } n \to \infty$

This means expectation is not an imaginary math object. It is literally what you observe in the real world if you take enough samples!

Moment Generating Functions

The Moment Generating Function (MGF) is a powerful tool that encodes all moments of a distribution in a single function. It's defined as:

$M_X(t) = \mathbb{E}[e^{tX}]$

The name comes from the remarkable property: derivatives of the MGF give moments.

Why "Moment Generating"?

Expand $e^{tX}$ as a Taylor series:

$e^{tX} = 1 + tX + \frac{(tX)^2}{2!} + \frac{(tX)^3}{3!} + \cdots$

Taking expectation term by term:

$M_X(t) = 1 + t\mathbb{E}[X] + \frac{t^2}{2!}\mathbb{E}[X^2] + \frac{t^3}{3!}\mathbb{E}[X^3] + \cdots$

MGFs of Common Distributions

Why MGFs Matter in ML

• Uniqueness: If two distributions have the same MGF, they're identical. Useful for proving distributional results.
• Sum of independent RVs: $M_{X+Y}(t) = M_X(t) \cdot M_Y(t)$ — products are easier than convolutions!
• Central Limit Theorem: The CLT proof uses MGF convergence.
• Concentration bounds: Chernoff bounds use $P(X > a) \leq \inf_t e^{-ta} M_X(t)$

Jensen's Inequality

Jensen's Inequality is one of the most important results connecting expectation with function transformations. It tells us exactly when E[g(X)] differs from g(E[X]).

Why Jensen's Inequality Matters in ML

Geometric Intuition

For a convex function, the curve lies below any chord (line connecting two points on the curve). This means:

• Points on the curve: $g(x_1), g(x_2), \ldots$
• Average of points: $\mathbb{E}[g(X)]$ (on or above the chord)
• Value at average: $g(\mathbb{E}[X])$ (on the curve)
• Result: Chord is above curve, so $\mathbb{E}[g(X)] \geq g(\mathbb{E}[X])$

Interactive 2D: Drag & Explore

This powerful visualization lets you drag distribution points along the curve, adjust probabilities, and instantly see how Jensen's inequality responds. Try different functions to build deep intuition!

Interactive 3D: Surface View

See Jensen's inequality come alive in 3D! For functions of two variables, convex surfaces curve upward like a bowl, and the weighted average of surface points always lies above the surface at the average point. Rotate the view to see this geometric truth from every angle.

Interactive: Jensen's Inequality (Basic)

Here's a simpler view focusing on the core concept with fewer controls:

Law of Large Numbers in Action

Watch how the sample average converges to the true expectation as you take more samples:

Physical and Engineering Meaning

What does expectation mean in real-world engineering applications?

Engineering Insight: Engineers LOVE expectation because we design for average energy, average power, expected error. It gives us a single number to optimize against.

What Information Does It Give?

Expectation answers one fundamental question:

Expectation also allows us to define other key quantities:

• Variance: $\text{Var}(X) = \mathbb{E}[(X - \mathbb{E}[X])^2]$
• Covariance: $\text{Cov}(X,Y) = \mathbb{E}[(X-\mu_X)(Y-\mu_Y)]$
• Risk in ML: $R(\theta) = \mathbb{E}[\text{Loss}(X, \theta)]$
• KL Divergence: $D_{KL}(p||q) = \mathbb{E}_p\left[\log\frac{p}{q}\right]$

Expectation is the foundation of all statistical learning.

Expectation in Machine Learning

In ML, we always optimize:

$\theta^* = \arg\min_\theta \mathbb{E}_{x,y}[\text{Loss}(f_\theta(x), y)]$

Why expectation? Because:

1. You train a model to minimize the expected loss
2. You never know the real future inputs
3. But expectation gives their "average behavior"

Comprehensive ML Applications

The Reparameterization Trick

In VAEs, we need gradients through expectations. The reparameterization trick rewrites:

$\mathbb{E}_{z \sim q_\phi(z|x)}[f(z)] = \mathbb{E}_{\epsilon \sim \mathcal{N}(0,1)}[f(\mu_\phi(x) + \sigma_\phi(x) \cdot \epsilon)]$

Now the expectation is over ε which doesn't depend on φ, so we can backpropagate through μ and σ!

Population vs Sample World

One of the most important distinctions in statistics and machine learning is between the population world and the sample world. Understanding this distinction is key to understanding why expectation matters so deeply.

What "Expectation under $\theta_0$" ACTUALLY Means

When we write:

$\mathbb{E}_{\theta_0}[\rho(X, \theta)]$

we are doing this thought experiment:

"Imagine the universe is truly generating data using the true but unknown parameter $\theta_0$. If we could repeatedly collect infinite datasets from that universe, and for each dataset compute the loss using our guess $\theta$, what would be the long-run average loss?"

So:

The Risk Function

This expectation has a special name—it's called the risk function:

$R(\theta) = \mathbb{E}_{\theta_0}[\rho(X, \theta)]$

It is a population-level truth curve over all possible data. The risk function tells us: "For any guess $\theta$, what is the true expected error?"

True Risk vs Empirical Risk

So:

• True risk = infinite-world average (what we want)
• Empirical risk = finite-sample average (what we can compute)
• We minimize empirical risk because that's all we have
• Empirical risk converges to true risk by LLN
• Therefore the minimizer converges to $\theta_0$

The Fundamental Theorem of Statistical Learning

Here is the mathematically precise version of your idea:

$\hat{\theta}_n = \arg\min_\theta \frac{1}{n} \sum_{i=1}^{n} \rho(X_i, \theta)$

Then:

$\hat{\theta}_n \xrightarrow{n \to \infty} \theta_0$

Summary: Two Worlds, One Bridge

What Does $\arg\min$ Mean?

Before we dive into examples, let's clarify a notation you'll see everywhere in ML:

$\arg\min_\theta f(\theta)$

It means:

"Choose the value of $\theta$ for which the function $f(\theta)$ becomes as small as possible."

Very important distinction:

• min → gives you the minimum value of the function
• arg min → gives you the argument (input) that achieves that minimum

A Fully Numerical Toy Example

(See empirical risk → true risk → $\theta_0$)

We'll use the simplest possible model so everything is visible.

How This Is EXACTLY What Deep Learning Does

(Cross-entropy, GPT, diffusion, everything)

Let's rewrite the core identity:

Since we don't know the expectation:

$\theta^* \approx \arg\min_\theta \frac{1}{n} \sum_{i=1}^{n} \rho(X_i, \theta)$

• This is Empirical Risk Minimization (ERM)
• Every neural network is trained using this
• GPT, ResNet, Diffusion, everything

How This Explains Overfitting (Perfectly)

Now the most important insight:

Monte Carlo Estimation

In practice, we rarely compute expectations analytically. Instead, we use Monte Carlo estimation: approximate E[g(X)] by averaging samples.

Properties of Monte Carlo Estimators

Variance Reduction Techniques

The challenge with Monte Carlo is high variance. Modern ML uses several techniques to reduce it:

1. Importance Sampling: Sample from a different distribution q(x) and reweight:

   $\mathbb{E}_p[g(X)] = \mathbb{E}_q\left[g(X) \cdot \frac{p(X)}{q(X)}\right]$

   Used in: Off-policy RL, rare event simulation, variational inference
2. Control Variates: Subtract a known-mean variable to reduce variance:

   $\hat{\mu} = \frac{1}{n}\sum_i [g(X_i) - c(h(X_i) - \mathbb{E}[h(X)])]$

   Used in: Policy gradient baselines, variance reduction in REINFORCE
3. Antithetic Variates: Use negatively correlated samples
4. Stratified Sampling: Divide the space into strata and sample from each

When to Use Monte Carlo

Why E[X] is the Best Predictor

Imagine someone tells you: "You MUST predict a random variable X using only one number. What number should you choose?"

This is a compression problem. Examples:

• Predict tomorrow's temperature with one number
• Predict a random lifetime with one number
• Predict sensor noise level with one number

The answer—proved rigorously—is:

$\boxed{\mathbb{E}[X]}$

Mathematical Proof: Expectation Minimizes MSE

We want to choose a number $a$ that best approximates X. Meaning, we want:

$\text{Pick } a \text{ to minimize } \mathbb{E}[(X - a)^2]$

Step 1: Expand the squared error

$\mathbb{E}[(X-a)^2] = \mathbb{E}[X^2] - 2a\mathbb{E}[X] + a^2$

Step 2: Take derivative with respect to $a$

$\frac{d}{da} = -2\mathbb{E}[X] + 2a$

Step 3: Set derivative = 0

$a^* = \mathbb{E}[X]$

Interactive: MSE Minimization

See for yourself! Drag the slider to find the value that minimizes MSE:

Common Pitfalls and Gotchas

Even experienced practitioners fall into these traps. Understanding these pitfalls will save you from subtle bugs in your ML code:

Summary of Common Mistakes

Preview: Conditional Expectation

One of the most powerful extensions of expectation is conditional expectation. This is so important that it gets its own section, but here's a preview:

The Tower Property (Law of Total Expectation)

One of the most useful formulas in all of probability:

$\mathbb{E}[X] = \mathbb{E}[\mathbb{E}[X | Y]]$

This says: "The average of the conditional averages equals the overall average."

Where You'll See This in ML

Tail Expectation and CVaR

In risk-sensitive applications (finance, safety-critical ML), we care not just about the average, but about what happens in the tail—the worst-case scenarios.

Conditional Value at Risk (CVaR)

Also called Expected Shortfall, CVaR answers: "What is the expected value of X given that we're in the worst α% of cases?"

$\text{CVaR}_\alpha(X) = \mathbb{E}[X \mid X > \text{VaR}_\alpha(X)]$

Where VaR_α is the α-quantile (e.g., the 95th percentile for α = 0.95).

Applications in ML

• Safe Reinforcement Learning: Optimize for worst-case outcomes, not just average reward
• Robust Optimization: Minimize expected loss in worst α% of scenarios
• Financial ML: Portfolio risk management using CVaR constraints
• Fairness: Ensure good performance for the worst-off groups

Risk-Aware ML: Standard ML minimizes E[Loss]. Risk-aware ML minimizes CVaR[Loss] to protect against tail events. This is crucial for safety-critical applications!

From Discrete to Continuous

Let's build the continuous expectation formula from scratch, starting with the discrete case.

Step 1: Start with Discrete

For discrete X with values $x_1, x_2, \ldots$ and probabilities $p_1, p_2, \ldots$:

$\mathbb{E}[X] = \sum_i x_i \cdot p_i$

Step 2: Imagine Points Getting Closer

Now imagine many closely spaced values with spacing $\Delta x$. Rewrite each probability as:

$p_i = \underbrace{\frac{p_i}{\Delta x}}_{\text{density}} \cdot \Delta x$

Call $f(x_i) = \frac{p_i}{\Delta x}$. Then:

$\mathbb{E}[X] = \sum_i x_i \cdot f(x_i) \cdot \Delta x$

Step 3: Take the Limit

As $\Delta x \to 0$, the sum becomes a Riemann integral:

$\sum_i x_i \cdot f(x_i) \cdot \Delta x \longrightarrow \int x \cdot f(x) \\, dx$

Key Insight: The density $f(x)$ is probability per unit length, just like mass density is mass per unit length. That's why we call it a "density" function!

Interactive: Riemann Sum to Integral

Watch how the Riemann sum converges to the integral as we use more bins:

Why Density Integrates to 1

This follows directly from probability conservation using the same bin logic:

1. Chop the real line into tiny bins: $[x_i, x_i + \Delta x]$
2. Probability of each bin: $P(X \in [x_i, x_i+\Delta x]) \approx f(x_i) \cdot \Delta x$
3. Total probability must be 1: $\sum_i f(x_i) \cdot \Delta x = 1$
4. Take the limit: $\int_{-\infty}^{\infty} f(x) \, dx = 1$

Advanced: Hilbert Space View

For those who want the deepest insight (PhD-level):

Define an inner product between two random variables:

$\langle U, V \rangle = \mathbb{E}[UV]$

Then:

• The space of square-integrable random variables becomes a Hilbert space
• Expectation becomes: $\mathbb{E}[X] = \langle X, 1 \rangle$

Geometric Meaning: Expectation is the projection of X onto the constant function 1. This explains why expectation minimizes MSE—it's the orthogonal projection!

This explains:

• Why expectation minimizes MSE
• Why variance is squared distance
• Why "uncorrelated" means "orthogonal"
• Why PCA, Kalman filters, and least squares all work

Final Mental Model

When someone says "Take expectation," your mind should see:

Python Implementation

1"""
2Expected Value: Complete Python Implementation
3===============================================
4This module demonstrates all key concepts of expectation with
5comprehensive examples and visualizations.
6"""
7
8import numpy as np
9import matplotlib.pyplot as plt
10from scipy import stats
11from typing import Callable, Tuple
12
13# Set random seed for reproducibility
14np.random.seed(42)
15
16# =============================================================================
17# 1. DISCRETE EXPECTATION
18# =============================================================================
19# Formula: E[X] = Σ x_i * P(X = x_i)
20# This is simply a weighted average where weights are probabilities
21
22def discrete_expectation(values: np.ndarray, probs: np.ndarray) -> float:
23    """
24    Compute expectation for a discrete random variable.
25
26    Args:
27        values: Array of possible values x_i
28        probs: Array of probabilities P(X = x_i)
29
30    Returns:
31        E[X] = sum of value * probability
32    """
33    assert np.isclose(probs.sum(), 1.0), "Probabilities must sum to 1"
34    return np.sum(values * probs)
35
36# Example: Custom discrete distribution
37values = np.array([1, 2, 3, 4, 5])
38probabilities = np.array([0.1, 0.2, 0.4, 0.2, 0.1])
39
40expectation = discrete_expectation(values, probabilities)
41print(f"E[X] (discrete) = {expectation}")  # Output: 3.0
42
43# =============================================================================
44# 2. CONTINUOUS EXPECTATION WITH SCIPY
45# =============================================================================
46# Formula: E[X] = ∫ x * f(x) dx
47# scipy.stats distributions have a .mean() method
48
49distributions = {
50    "Uniform(0, 1)": stats.uniform(0, 1),
51    "Exponential(λ=2)": stats.expon(scale=0.5),  # scale = 1/λ
52    "Normal(μ=0, σ=1)": stats.norm(0, 1),
53    "Beta(α=2, β=5)": stats.beta(2, 5),
54    "Gamma(α=3, β=2)": stats.gamma(a=3, scale=0.5),  # scale = 1/β
55}
56
57print("
58Expectations of common distributions:")
59for name, dist in distributions.items():
60    print(f"  E[X] for {name} = {dist.mean():.4f}")
61
62# =============================================================================
63# 3. LAW OF LARGE NUMBERS VISUALIZATION
64# =============================================================================
65# As n → ∞, sample mean → E[X]
66# This is the fundamental connection between theory and practice
67
68def visualize_lln(n_samples: int = 10000) -> None:
69    """Visualize Law of Large Numbers convergence."""
70    samples = np.random.uniform(0, 1, size=n_samples)
71    running_avg = np.cumsum(samples) / np.arange(1, n_samples + 1)
72    true_mean = 0.5
73
74    plt.figure(figsize=(12, 5))
75
76    # Plot 1: Running average convergence
77    plt.subplot(1, 2, 1)
78    plt.plot(running_avg, "b-", alpha=0.7, linewidth=0.8)
79    plt.axhline(y=true_mean, color="r", linestyle="--",
80                label=f"True E[X] = {true_mean}")
81    plt.xlabel("Number of Samples (n)")
82    plt.ylabel("Sample Mean")
83    plt.title("Law of Large Numbers: Convergence to E[X]")
84    plt.legend()
85    plt.xscale("log")  # Log scale shows convergence better
86
87    # Plot 2: Error decreases as 1/√n
88    plt.subplot(1, 2, 2)
89    errors = np.abs(running_avg - true_mean)
90    n_values = np.arange(1, n_samples + 1)
91    plt.loglog(n_values, errors, "b-", alpha=0.5, label="Actual error")
92    plt.loglog(n_values, 1/np.sqrt(n_values), "r--",
93               label=r"$1/sqrt{n}$ bound")
94    plt.xlabel("Number of Samples (n)")
95    plt.ylabel("|Sample Mean - E[X]|")
96    plt.title("Convergence Rate: O(1/√n)")
97    plt.legend()
98
99    plt.tight_layout()
100    plt.savefig("lln_convergence.png", dpi=150)
101    plt.show()
102
103# Uncomment to run: visualize_lln()
104
105# =============================================================================
106# 4. LOTUS: LAW OF THE UNCONSCIOUS STATISTICIAN
107# =============================================================================
108# E[g(X)] = ∫ g(x) * f(x) dx  (no need to find distribution of g(X))
109
110def monte_carlo_lotus(
111    g: Callable[[np.ndarray], np.ndarray],
112    dist: stats.rv_continuous,
113    n_samples: int = 100000
114) -> Tuple[float, float]:
115    """
116    Estimate E[g(X)] using Monte Carlo (LOTUS in action).
117
118    Args:
119        g: Function to apply to samples
120        dist: scipy distribution to sample from
121        n_samples: Number of Monte Carlo samples
122
123    Returns:
124        (estimate, standard_error)
125    """
126    samples = dist.rvs(size=n_samples)
127    g_samples = g(samples)
128    estimate = np.mean(g_samples)
129    std_error = np.std(g_samples) / np.sqrt(n_samples)
130    return estimate, std_error
131
132# Example: E[X²] for Uniform(0,1) - theoretical value is 1/3
133uniform = stats.uniform(0, 1)
134e_x2, se = monte_carlo_lotus(lambda x: x**2, uniform)
135print(f"
136E[X²] Monte Carlo = {e_x2:.6f} ± {se:.6f}")
137print(f"E[X²] Theoretical = {1/3:.6f}")
138
139# Example: E[log(X)] for Exp(1) - theoretical value is -γ (Euler-Mascheroni)
140exp_dist = stats.expon(scale=1)
141e_log, se = monte_carlo_lotus(lambda x: np.log(x), exp_dist)
142euler_mascheroni = 0.5772156649
143print(f"
144E[log(X)] Monte Carlo = {e_log:.6f} ± {se:.6f}")
145print(f"E[log(X)] Theoretical = {-euler_mascheroni:.6f}")
146
147# =============================================================================
148# 5. MSE MINIMIZATION PROOF
149# =============================================================================
150# E[X] uniquely minimizes E[(X - a)²] over all constants a
151
152def visualize_mse_minimization() -> None:
153    """Show that E[X] minimizes MSE."""
154    # Generate samples from a skewed distribution
155    samples = np.random.gamma(shape=2, scale=2, size=10000)
156    true_mean = np.mean(samples)
157
158    # Compute MSE for different values of a
159    a_values = np.linspace(0, 10, 200)
160    mse_values = [np.mean((samples - a)**2) for a in a_values]
161
162    plt.figure(figsize=(10, 6))
163    plt.plot(a_values, mse_values, "b-", linewidth=2)
164    plt.axvline(x=true_mean, color="r", linestyle="--",
165                label=f"E[X] = {true_mean:.2f}")
166    plt.scatter([true_mean], [np.mean((samples - true_mean)**2)],
167                color="r", s=100, zorder=5)
168    plt.xlabel("Prediction value (a)")
169    plt.ylabel("Mean Squared Error E[(X - a)²]")
170    plt.title("E[X] Minimizes MSE: Proof by Visualization")
171    plt.legend()
172    plt.grid(True, alpha=0.3)
173    plt.savefig("mse_minimization.png", dpi=150)
174    plt.show()
175
176# Uncomment to run: visualize_mse_minimization()
177
178# =============================================================================
179# 6. JENSEN'S INEQUALITY DEMONSTRATION
180# =============================================================================
181# For convex g: E[g(X)] ≥ g(E[X])
182# For concave g: E[g(X)] ≤ g(E[X])
183
184def demonstrate_jensen() -> None:
185    """Demonstrate Jensen's inequality numerically."""
186    samples = np.random.uniform(1, 10, size=100000)
187    mean_x = np.mean(samples)
188
189    # Convex function: x²
190    e_x_squared = np.mean(samples**2)
191    squared_e_x = mean_x**2
192    print(f"
193Jensen's Inequality (convex g(x) = x²):")
194    print(f"  E[X²] = {e_x_squared:.4f}")
195    print(f"  (E[X])² = {squared_e_x:.4f}")
196    print(f"  E[X²] ≥ (E[X])²? {e_x_squared >= squared_e_x}")
197
198    # Concave function: log(x)
199    e_log_x = np.mean(np.log(samples))
200    log_e_x = np.log(mean_x)
201    print(f"
202Jensen's Inequality (concave g(x) = log(x)):")
203    print(f"  E[log(X)] = {e_log_x:.4f}")
204    print(f"  log(E[X]) = {log_e_x:.4f}")
205    print(f"  E[log(X)] ≤ log(E[X])? {e_log_x <= log_e_x}")
206
207demonstrate_jensen()
208
209# =============================================================================
210# 7. VARIANCE VIA EXPECTATION
211# =============================================================================
212# Var(X) = E[X²] - (E[X])² = E[(X - μ)²]
213
214def compute_variance(samples: np.ndarray) -> dict:
215    """Compute variance using both formulas to verify equality."""
216    mean = np.mean(samples)
217
218    # Method 1: E[(X - μ)²]
219    var_method1 = np.mean((samples - mean)**2)
220
221    # Method 2: E[X²] - (E[X])²
222    e_x2 = np.mean(samples**2)
223    var_method2 = e_x2 - mean**2
224
225    return {
226        "E[X]": mean,
227        "E[X²]": e_x2,
228        "Var (centered)": var_method1,
229        "Var (shortcut)": var_method2,
230        "Std Dev": np.sqrt(var_method1)
231    }
232
233samples = np.random.normal(loc=5, scale=2, size=100000)
234stats_dict = compute_variance(samples)
235print("
236Variance computation:")
237for key, value in stats_dict.items():
238    print(f"  {key} = {value:.4f}")