Module 11: Stocks & Equity Valuation

1. What a Stock Actually Is

When you buy a share of stock, you are purchasing a fractional ownership claim on a company. But what does "ownership" mean in concrete, measurable terms? It means you hold a claim on the company's future cash flows — dividends, buyback proceeds, and ultimately the residual value if the company is ever liquidated. From a statistical perspective, each of these future cash flows is a random variable.

This framing immediately clarifies several things that confuse newcomers to finance:

• Stock prices fluctuate because the market is continuously updating its posterior estimate of the distribution of future cash flows as new information (earnings reports, macro data, management changes) arrives.
• Different investors disagree on price because they hold different prior distributions over these cash flows, or they use different discount rates.
• A stock can have positive value even if it pays no dividends because the cash flows include potential future dividends, buybacks, or acquisition proceeds.

1.1 Equity vs. Debt: Random vs. (Nearly) Deterministic

A useful contrast: when you buy a bond (which we cover in Module 12), you receive a nearly deterministic stream of cash flows (fixed coupon payments). When you buy a stock, you receive a random stream. This is the fundamental risk-return tradeoff:

1.2 Common Stock vs. Preferred Stock

There are two main classes of stock. Common stock gives you voting rights and a residual claim on cash flows — but you are last in line during liquidation. Preferred stock is a hybrid: it pays a fixed dividend (like a bond) but has higher priority than common stock in bankruptcy. Think of preferred stock as having a distribution that is less dispersed than common stock but with a lower expected value for upside participation.

2. Discounted Cash Flow (DCF) Valuation

The Discounted Cash Flow model is the foundational framework for valuing any asset that generates future cash flows. The core idea: a dollar received in the future is worth less than a dollar today, so we discount future cash flows back to present value.

where:

• V₀ = intrinsic value of the stock today
• CF_t = cash flow in year t (a random variable)
• r = discount rate (required rate of return)
• T = time horizon (often taken to infinity)

2.1 Free Cash Flow to Equity (FCFE)

The "cash flow" in DCF for equity valuation is typically the Free Cash Flow to Equity (FCFE): the cash available to shareholders after all expenses, taxes, reinvestment, and debt payments. The formula is:

Each component of FCFE is itself a random variable. Net income depends on revenue (random), costs (partially random), and tax rates (subject to policy change). Depreciation follows an accounting schedule but is applied to assets whose useful life is uncertain. Capital expenditure depends on management decisions that respond to market conditions.

2.2 The Gordon Growth Model: A Special Case

If we assume cash flows grow at a constant rate g forever, the infinite DCF sum collapses to a beautifully simple formula:

This is the Gordon Growth Model (or dividend discount model when applied to dividends). It requires r > g for convergence — a condition analogous to requiring a geometric series to have a ratio less than 1.

2.3 Two-Stage DCF Model

A more realistic approach divides the future into two phases: a high-growth stage (say 5–10 years) where we project cash flows individually, and a terminal value stage where we assume steady-state growth and apply the Gordon formula. This is analogous to a mixture model with two regimes.

The terminal value typically accounts for 60–80% of the total DCF value, which should alarm any statistician — most of the valuation depends on a single assumption about perpetual growth.

2.4 Python Example: Simple DCF Model

Pythonimport numpy as np

def dcf_valuation(initial_fcf, growth_rates, terminal_growth, discount_rate):
    """
    Two-stage DCF model.

    Parameters
    ----------
    initial_fcf : float
        Free cash flow in the most recent year (in millions).
    growth_rates : list of float
        Projected growth rates for the explicit forecast period.
    terminal_growth : float
        Perpetual growth rate after the explicit period.
    discount_rate : float
        Required rate of return (WACC or cost of equity).

    Returns
    -------
    dict with intrinsic_value, pv_explicit, pv_terminal
    """
    # Stage 1: Explicit forecast period
    fcfs = []
    fcf = initial_fcf
    for g in growth_rates:
        fcf = fcf * (1 + g)
        fcfs.append(fcf)

    # Discount each projected FCF back to present
    pv_explicit = 0
    for t, cf in enumerate(fcfs, 1):
        pv_explicit += cf / (1 + discount_rate) ** t

    # Stage 2: Terminal value using Gordon Growth Model
    terminal_fcf = fcfs[-1] * (1 + terminal_growth)
    terminal_value = terminal_fcf / (discount_rate - terminal_growth)
    pv_terminal = terminal_value / (1 + discount_rate) ** len(fcfs)

    intrinsic_value = pv_explicit + pv_terminal

    return {
        'intrinsic_value': intrinsic_value,
        'pv_explicit': pv_explicit,
        'pv_terminal': pv_terminal,
        'terminal_pct': pv_terminal / intrinsic_value * 100,
        'projected_fcfs': fcfs
    }

# Example: Value a company with $500M FCF
result = dcf_valuation(
    initial_fcf=500,          # $500M current FCF
    growth_rates=[0.15, 0.12, 0.10, 0.08, 0.06],  # 5 years of slowing growth
    terminal_growth=0.03,     # 3% perpetual growth
    discount_rate=0.10        # 10% required return
)

print(f"Intrinsic Value: ${result['intrinsic_value']:,.0f}M")
print(f"PV of Explicit Period: ${result['pv_explicit']:,.0f}M")
print(f"PV of Terminal Value: ${result['pv_terminal']:,.0f}M")
print(f"Terminal Value Share: {result['terminal_pct']:.1f}%")

# Sensitivity analysis: vary discount rate and terminal growth
print("\n--- Sensitivity Table (Intrinsic Value in $M) ---")
print(f"{'':>12}", end="")
for tg in [0.02, 0.025, 0.03, 0.035, 0.04]:
    print(f"  g={tg:.1%}", end="")
print()
for dr in [0.08, 0.09, 0.10, 0.11, 0.12]:
    print(f"r={dr:.0%}     ", end="")
    for tg in [0.02, 0.025, 0.03, 0.035, 0.04]:
        v = dcf_valuation(500, [0.15,0.12,0.10,0.08,0.06], tg, dr)
        print(f"  {v['intrinsic_value']:>7,.0f}", end="")
    print()

3. The P/E Ratio as a Sufficient Statistic

The Price-to-Earnings (P/E) ratio is the single most widely used metric in equity valuation. It compresses a complex valuation problem into a single number:

Why is P/E so popular? Because under certain conditions, it acts as a sufficient statistic for relative valuation. If two companies have similar growth prospects, risk profiles, and capital structures, then comparing their P/E ratios tells you which is "cheaper" relative to its earnings power.

3.1 Deriving P/E from the Gordon Growth Model

We can derive what determines P/E from first principles. Start with the Gordon Growth Model V₀ = E₁ · k / (r − g), where E₁ is next year's earnings and k is the payout ratio. Then:

This reveals that P/E is driven by three factors:

3.2 Trailing vs. Forward P/E

Trailing P/E uses the last 12 months of actual earnings. Think of it as using the sample mean of past earnings as your estimate. Forward P/E uses analyst consensus estimates of next year's earnings — a forecast or posterior predictive mean. Forward P/E is generally more useful because stock prices are forward-looking.

3.3 Sector P/E Comparisons

P/E ratios vary dramatically across sectors because different industries have different growth and risk profiles:

3.4 Python: Computing P/E Ratios

Pythonimport numpy as np
import pandas as pd

# Sample data for major tech companies (illustrative)
tech_stocks = pd.DataFrame({
    'company': ['Apple', 'Microsoft', 'Google', 'Amazon', 'Meta', 'Nvidia'],
    'price': [195, 420, 175, 185, 510, 130],
    'trailing_eps': [6.42, 11.07, 5.80, 2.90, 14.87, 1.74],
    'forward_eps': [7.10, 12.50, 6.80, 4.20, 17.20, 2.80],
    'growth_rate': [0.08, 0.14, 0.18, 0.25, 0.20, 0.40],
})

# Compute valuation metrics
tech_stocks['trailing_pe'] = tech_stocks['price'] / tech_stocks['trailing_eps']
tech_stocks['forward_pe']  = tech_stocks['price'] / tech_stocks['forward_eps']
tech_stocks['peg_ratio']   = tech_stocks['trailing_pe'] / (tech_stocks['growth_rate'] * 100)

print(tech_stocks[['company', 'trailing_pe', 'forward_pe', 'peg_ratio']].to_string(index=False))

# Rank by PEG ratio (lower = more attractive relative to growth)
print("\n--- Ranked by PEG Ratio (lower = potentially cheaper) ---")
ranked = tech_stocks.sort_values('peg_ratio')
for _, row in ranked.iterrows():
    print(f"  {row['company']:>10}: PEG = {row['peg_ratio']:.2f}  "
          f"(P/E = {row['trailing_pe']:.1f}, Growth = {row['growth_rate']:.0%})")

4. Earnings as a Noisy Signal

A company's reported earnings are not a clean measurement of its true economic profitability. Accounting rules, management discretion, and one-time items all inject noise into the reported figure. A statistician should model this explicitly:

4.1 Sources of Earnings Noise

4.2 Earnings Quality Metrics

Analysts use several metrics to assess "earnings quality" — essentially the SNR of reported earnings:

• Accruals ratio = (Net Income − Operating Cash Flow) / Total Assets. High accruals suggest earnings are driven by accounting entries rather than cash, lowering quality.
• Earnings persistence = autocorrelation of earnings: Corr(E_t, E_t-1). Higher persistence means earnings are more predictable and likely more informative.
• Cash conversion = Operating Cash Flow / Net Income. Values near 1.0 or higher suggest earnings reflect real cash generation.

4.3 Earnings Surprises and Market Reaction

Every quarter, companies report earnings and the market reacts. The key variable is not the level of earnings but the surprise:

This is a standardized prediction error. Positive surprises ("beats") drive stock prices up; negative surprises ("misses") drive them down. Interestingly, the market response is asymmetric — misses are punished more severely than beats are rewarded. This is consistent with prospect theory and loss aversion.

5. Dividends vs. Buybacks

Companies return cash to shareholders through two mechanisms: dividends (regular cash payments per share) and share buybacks (the company buys its own stock on the open market, reducing shares outstanding). Both reduce the company's cash holdings but have different statistical and tax implications.

5.1 Comparison Table

5.2 The Dividend Signaling Hypothesis

Finance theory holds that dividend changes are a signal from management about future prospects. Initiating or increasing a dividend signals confidence in sustained cash flows. Cutting a dividend signals distress. The market reacts accordingly:

• Dividend increase: Average abnormal return of +1% to +3% around announcement
• Dividend cut: Average abnormal return of −5% to −10%
• Asymmetry: Cuts are punished much more than increases are rewarded (loss aversion)

This asymmetry means dividends are a sticky commitment. Once established, companies are reluctant to cut them, making dividend-paying stocks behave somewhat more like bonds in their predictability.

6. Market Cap & Enterprise Value

6.1 Market Capitalization

Market capitalization is the simplest measure of a company's total equity value:

This is the market's consensus estimate of the present value of all future cash flows to equity holders. Companies are classified by market cap:

6.2 Enterprise Value (EV)

Enterprise Value provides a more complete picture by including debt:

Why? Because if you were to acquire the company, you would pay the market cap (to buy all shares) but also assume its debt (which you must repay) while gaining its cash (which you can use). EV represents the total value of the firm's operations, independent of how they are financed.

6.3 EV-Based Multiples

7. Growth vs. Value Stocks

One of the most important distinctions in equity investing is between growth stocks and value stocks. These represent two distinct regimes of the return-generating process.

7.1 Characteristics

7.2 The Value Premium

The value premium is the historical tendency of value stocks to outperform growth stocks over long horizons. This is one of the most robust findings in empirical asset pricing. On average, value stocks have returned 3–5% more per year than growth stocks since the 1930s.

Two competing explanations exist:

• Risk-based: Value stocks are riskier in ways not captured by beta (e.g., they are more sensitive to recessions, have higher financial leverage). The premium is compensation for bearing this risk. Statistically, they have higher tail risk.
• Behavioral: Investors systematically overvalue growth and undervalue boring, struggling companies. The premium reflects systematic mispricing driven by cognitive biases (extrapolation, glamour). Statistically, this is a persistent bias in the market's estimator.

7.3 Python: Classifying Stocks by Growth vs. Value

Pythonimport numpy as np
import pandas as pd

# Simulate a universe of 200 stocks with growth/value characteristics
np.random.seed(42)
n = 200

# Latent regime: 0 = value, 1 = growth
regime = np.random.binomial(1, 0.4, n)  # 40% growth, 60% value

# Generate characteristics conditional on regime
pe_ratio = np.where(regime == 1,
    np.random.lognormal(3.5, 0.4, n),   # Growth: high P/E
    np.random.lognormal(2.5, 0.3, n))   # Value: low P/E

pb_ratio = np.where(regime == 1,
    np.random.lognormal(1.5, 0.5, n),   # Growth: high P/B
    np.random.lognormal(0.3, 0.3, n))   # Value: low P/B

div_yield = np.where(regime == 1,
    np.random.exponential(0.005, n),   # Growth: near-zero dividends
    np.random.exponential(0.03, n))    # Value: meaningful dividends

# Generate returns — growth has higher variance
returns = np.where(regime == 1,
    np.random.normal(0.12, 0.30, n),    # Growth: higher E[r], higher vol
    np.random.normal(0.10, 0.18, n))    # Value: slightly lower E[r], lower vol

stocks = pd.DataFrame({
    'pe_ratio': pe_ratio,
    'pb_ratio': pb_ratio,
    'div_yield': div_yield,
    'annual_return': returns,
    'true_regime': np.where(regime == 1, 'Growth', 'Value')
})

# Summary statistics by regime
print("=== Return Distribution by Regime ===")
print(stocks.groupby('true_regime')['annual_return'].describe().round(3))

print("\n=== Characteristic Means by Regime ===")
print(stocks.groupby('true_regime')[['pe_ratio', 'pb_ratio', 'div_yield']].mean().round(3))

# Simple classification using P/E ratio threshold
# (analogous to a decision tree with a single split)
median_pe = stocks['pe_ratio'].median()
stocks['classified'] = np.where(stocks['pe_ratio'] > median_pe, 'Growth', 'Value')

# Classification accuracy
accuracy = (stocks['classified'] == stocks['true_regime']).mean()
print(f"\nClassification accuracy using median P/E split: {accuracy:.1%}")

8. Putting It All Together: A Valuation Framework

Here is a systematic approach to equity valuation that combines all the concepts in this module:

1. Understand the business: What are the company's cash flow drivers? How stable are they? (Characterize the data-generating process.)
2. Assess earnings quality: Is the signal-to-noise ratio of reported earnings high enough for P/E-based analysis? If not, use cash flow metrics.
3. Apply relative valuation: Compare P/E (or EV/EBITDA) to sector peers. Is the stock cheap or expensive relative to comparable companies?
4. Build a DCF model: Project cash flows, choose a discount rate, estimate terminal value. Run sensitivity analysis on key parameters.
5. Triangulate: If relative and intrinsic valuation agree, you have stronger evidence. If they disagree, investigate why.
6. Quantify uncertainty: Never present a point estimate. Give a range. Better yet, simulate the DCF with distributions on each input and present the distribution of intrinsic values.

8.1 Monte Carlo DCF

Pythonimport numpy as np

def monte_carlo_dcf(base_fcf, n_simulations=10000, n_years=5):
    """
    Monte Carlo DCF with uncertain growth, discount rate, and terminal growth.
    """
    np.random.seed(123)

    # Draw random parameters from prior distributions
    growth_mean = np.random.normal(0.10, 0.03, n_simulations)    # mean growth ~10%
    discount_rate = np.random.normal(0.10, 0.015, n_simulations)  # WACC ~10%
    terminal_g = np.random.normal(0.03, 0.005, n_simulations)    # terminal ~3%

    # Ensure valid parameters
    discount_rate = np.clip(discount_rate, 0.05, 0.20)
    terminal_g = np.clip(terminal_g, 0.01, 0.05)

    values = np.zeros(n_simulations)

    for i in range(n_simulations):
        r = discount_rate[i]
        g = growth_mean[i]
        tg = terminal_g[i]

        # Project FCFs with declining growth
        pv = 0
        fcf = base_fcf
        for t in range(1, n_years + 1):
            annual_g = g * (1 - 0.1 * t) + np.random.normal(0, 0.02)  # declining + noise
            fcf = fcf * (1 + annual_g)
            pv += fcf / (1 + r) ** t

        # Terminal value
        if r > tg:
            tv = fcf * (1 + tg) / (r - tg)
            pv += tv / (1 + r) ** n_years

        values[i] = pv

    # Remove extreme outliers (top/bottom 1%)
    values = values[(values > np.percentile(values, 1)) &
                    (values < np.percentile(values, 99))]

    print(f"Monte Carlo DCF Results (n = {len(values):,} simulations)")
    print(f"  Mean intrinsic value:   ${np.mean(values):>10,.0f}M")
    print(f"  Median:                 ${np.median(values):>10,.0f}M")
    print(f"  Std deviation:          ${np.std(values):>10,.0f}M")
    print(f"  5th percentile:         ${np.percentile(values, 5):>10,.0f}M")
    print(f"  95th percentile:        ${np.percentile(values, 95):>10,.0f}M")
    print(f"  90% confidence width:   ${np.percentile(values, 95) - np.percentile(values, 5):>10,.0f}M")

monte_carlo_dcf(base_fcf=500)

9. Summary

This module has established the statistical foundations of equity valuation:

In the next module, we move to the other side of the capital structure: bonds and fixed income, where cash flows become (nearly) deterministic and the math gets delightfully precise. See you in Module 12.