ptolemy

Market Cap Is Not Shares Outstanding Times Price

Published April 25, 2019

Market capitalization is normally implemented as price * shares_outstanding. That line is wrong often enough to change the output of a stock screener.

A company can have legal shares outstanding, weighted-average basic shares, weighted-average diluted shares, unvested restricted stock units, employee options, warrants, convertible securities, and multiple common-stock classes. Each number is valid for a different question. None is a universal denominator.

Recent technology IPO filings make the problem difficult to ignore. The cover page can support one market capitalization, the earnings-per-share note can support another share count, and the equity-compensation note can disclose millions of additional claims that appear in neither number.

Legal market capitalization ignores RSUs and the in-the-money portion of options and warrants. The difference is price-dependent.

The gap in the chart is not an accounting footnote. It is an omitted equity claim. At a $36 stock price, the synthetic company has a legal market capitalization of $3.6 billion and a treasury-stock-method diluted market capitalization of approximately $4.166 billion. A naive screener misses $566 million.

The first rule is therefore simple:

A production valuation engine must store several share counts and label the economic question answered by each one.

There Are at Least Three Valid Share Counts

For a public company, these denominators should not be collapsed into one field.

This is the number of issued shares held by stockholders at a specific date. It is usually disclosed on the cover page of a Form 10-K or Form 10-Q and tagged with dei:EntityCommonStockSharesOutstanding.

Use it for conventional market capitalization:

legal market cap=share price×legal shares outstanding\text{legal market cap} = \text{share price} \times \text{legal shares outstanding}

This figure is point-in-time. It is not an average over the reporting period.

2. Weighted-average basic shares

This denominator is used for basic earnings per share. It weights the share count by the fraction of the reporting period during which each share was outstanding.

It is appropriate for matching an income-statement numerator to a period-average denominator. It is usually wrong for point-in-time market capitalization.

A company that issued 20 million shares on the last day of a quarter may report a basic weighted-average count that barely reflects the issuance. Multiplying the current price by that average understates current equity value.

3. Weighted-average diluted shares

This is the denominator used for diluted earnings per share. It starts with weighted-average basic shares and includes potential common shares only when the accounting rules classify them as dilutive for that period.

This is also a period average. It is not a point-in-time capitalization measure.

More importantly, it can exclude the largest sources of future dilution.

GAAP Diluted Shares Can Be Least Useful When Dilution Matters Most

A loss-making company normally reports the same basic and diluted share count because adding potential common shares would reduce the loss per share. That result is anti-dilutive under the earnings-per-share rules, so options, RSUs, and warrants are omitted from the diluted denominator.

The arithmetic is correct for GAAP diluted EPS. It is dangerous for valuation.

A newly public company can report:

A screener that treats GAAP diluted shares as fully diluted shares concludes that dilution is zero. The conclusion is exactly backward. The securities were omitted because the company lost money, not because the claims disappeared.

This produces a recurring failure mode:

net loss⇒basic shares=diluted shares\text{net loss} \Rightarrow \text{basic shares} = \text{diluted shares}

The correct interpretation is:

net loss⇒GAAP diluted EPS denominator is not a capitalization denominator\text{net loss} \Rightarrow \text{GAAP diluted EPS denominator is not a capitalization denominator}

A fundamental stock screener should never infer the absence of dilution from equality between basic and diluted EPS shares.

Fully Diluted Shares Are a Function, Not a Static Number

Restricted stock units are usually straightforward. One vested RSU generally becomes one common share, subject to award terms and tax withholding.

Options and warrants are price-dependent. A $40 option is not economically dilutive when the stock trades at $20. It becomes increasingly dilutive above $40.

For a plain option or warrant, the treasury stock method assumes:

  1. the instrument is exercised;
  2. the company receives the exercise proceeds;
  3. those proceeds repurchase shares at the current market price.

For NN options, strike price KK, and market price PP, incremental shares are:

incremental shares={N×P−KP,P>K0,P≤K\text{incremental shares} = \begin{cases} N \times \frac{P-K}{P}, & P > K \\ 0, & P \le K \end{cases}

The same result can be written as:

N−N×KPN - \frac{N \times K}{P}

At a $36 market price, 6 million options with a $20 strike add:

6,000,000×36−2036=2,666,6676{,}000{,}000 \times \frac{36-20}{36} = 2{,}666{,}667

incremental shares.

The option grant contains 6 million potential shares, but its current economic dilution is approximately 2.67 million shares after accounting for exercise proceeds.

This distinction matters for fully diluted market capitalization and enterprise value. Adding every option one-for-one overstates dilution. Ignoring all options understates it.

A Period-Correct Python Implementation

The calculation should operate on normalized security records, not directly on presentation labels from one filing. The following implementation uses Python 3.7-compatible dataclasses and Decimal arithmetic.

from dataclasses import dataclass
from decimal import Decimal
from typing import Iterable


ZERO = Decimal("0")


@dataclass(frozen=True)
class OptionLikeSecurity:
    shares: Decimal
    strike_price: Decimal


@dataclass(frozen=True)
class EquitySnapshot:
    basic_shares: Decimal
    unvested_rsus: Decimal
    option_like_securities: Iterable[OptionLikeSecurity]


def treasury_stock_increment(
    security: OptionLikeSecurity,
    market_price: Decimal,
) -> Decimal:
    if market_price <= ZERO:
        raise ValueError("market_price must be positive")

    if market_price <= security.strike_price:
        return ZERO

    exercise_proceeds = security.shares * security.strike_price
    assumed_repurchases = exercise_proceeds / market_price
    return security.shares - assumed_repurchases


def diluted_shares(
    snapshot: EquitySnapshot,
    market_price: Decimal,
) -> Decimal:
    option_increment = sum(
        (
            treasury_stock_increment(security, market_price)
            for security in snapshot.option_like_securities
        ),
        ZERO,
    )

    return (
        snapshot.basic_shares
        + snapshot.unvested_rsus
        + option_increment
    )


def diluted_market_cap(
    snapshot: EquitySnapshot,
    market_price: Decimal,
) -> Decimal:
    return diluted_shares(snapshot, market_price) * market_price


snapshot = EquitySnapshot(
    basic_shares=Decimal("100000000"),
    unvested_rsus=Decimal("8000000"),
    option_like_securities=(
        OptionLikeSecurity(Decimal("5000000"), Decimal("8")),
        OptionLikeSecurity(Decimal("6000000"), Decimal("20")),
        OptionLikeSecurity(Decimal("4000000"), Decimal("40")),
        OptionLikeSecurity(Decimal("2000000"), Decimal("15")),
    ),
)

price = Decimal("36")
legal_market_cap = snapshot.basic_shares * price
economic_market_cap = diluted_market_cap(snapshot, price)

print("legal market cap:", legal_market_cap)
print("diluted shares:", diluted_shares(snapshot, price))
print("diluted market cap:", economic_market_cap)
print("omitted equity value:", economic_market_cap - legal_market_cap)

The output is approximately:

legal market cap: 3600000000
diluted shares: 115722222.2222222222222222222
diluted market cap: 4166000000
omitted equity value: 566000000

The decimal share count is expected. The treasury stock method is an economic calculation, not a prediction that a fractional legal share will be issued.

Why the Treasury Stock Method Works for Equity Value

There are two equivalent ways to model an in-the-money option grant.

The first approach adds every exercised share to the share count and adds exercise proceeds to cash:

P×(basic shares+N)−N×KP \times (\text{basic shares} + N) - N \times K

The second approach adds treasury-stock-method incremental shares:

P×(basic shares+N−N×KP)P \times \left( \text{basic shares} + N - \frac{N \times K}{P} \right)

Expanding the second expression produces the first.

This equivalence is useful in an enterprise-value engine. It prevents double counting. Do one of the following:

Do not add incremental shares and exercise proceeds. That understates enterprise value.

RSUs, Restricted Stock, and Performance Awards

RSUs generally have no exercise price, so there are no exercise proceeds available to repurchase shares. A simple conservative model adds unvested RSUs one-for-one.

That model still requires judgment.

Some awards are subject only to continued service. Others require revenue, profit, market-price, or liquidity conditions. Performance awards may disclose a target number, a maximum number, or both. Tax withholding can reduce the number of shares actually delivered, but the withheld shares fund an employee tax obligation and should not automatically be treated as if the economic claim never existed.

A scalable screener should preserve the award type and confidence level:

from dataclasses import dataclass
from decimal import Decimal
from typing import Optional


@dataclass(frozen=True)
class ShareClaim:
    security_type: str
    gross_shares: Decimal
    strike_price: Optional[Decimal]
    vesting_status: str
    performance_basis: Optional[str]
    source_filing: str
    snapshot_date: str
    filed_at: str
    confidence: str

Do not reduce this record to a single diluted_shares field during ingestion. Store the source claims and calculate the denominator at query time.

That design supports several policies:

The correct policy depends on the screen.

Multiple Share Classes Must Be Combined by Economic Claim

Many technology companies have Class A and Class B common stock. The classes may have different voting rights but the same economic rights.

A market-cap calculation that includes only the publicly traded Class A shares can be materially wrong. The non-traded Class B shares still represent ownership claims.

For each class, determine:

When the economic rights are equivalent and conversion is one-for-one:

economic common shares=Class A shares+Class B shares\text{economic common shares} = \text{Class A shares} + \text{Class B shares}

The price of the traded class can then be applied to both classes.

Do not assume every preferred or non-traded class is equivalent. Redeemable preferred stock, participating securities, and convertible instruments can require separate treatment.

Where the Inputs Appear in SEC Filings

No single XBRL fact contains a complete fully diluted share count.

The useful sources are distributed across the filing.

Cover page

The cover page usually provides legal shares outstanding as of a recent date. This date often differs from the balance-sheet date.

Useful tag:

For multiple classes, inspect dimensions and class-specific facts. Issuers also use custom extensions.

Earnings-per-share note

The EPS reconciliation provides weighted-average basic shares, incremental dilutive securities, and weighted-average diluted shares.

Common tags include:

These facts validate the filing’s period calculation. They do not replace a point-in-time capitalization model.

Share-based compensation note

This note usually contains option counts, weighted-average exercise prices, RSUs, restricted stock, and activity tables.

Important rows include:

These tables are frequently tagged with issuer extensions. A production parser needs table semantics and text fallback, not only a fixed list of standard tags.

Capitalization and dilution sections in registration statements

An IPO prospectus may provide the clearest reconciliation among pre-offering shares, offering shares, option exercises, preferred-stock conversion, private placements, and pro forma shares.

It may also disclose outstanding options and RSUs excluded from the displayed offering share count.

This is useful data, but it must be stored with its pro forma assumptions. A pro forma post-offering denominator is not interchangeable with the historical balance-sheet share count.

Point-in-Time Storage Is Mandatory

Every equity snapshot needs at least two dates:

A third date is often needed:

The calculation must not combine an April stock price with an option table that was not filed until May when running a historical screen for April.

A defensible record therefore looks like:

equity_snapshot = {
    "issuer": "EXAMPLE",
    "snapshot_date": "2018-12-31",
    "filed_at": "2019-03-22",
    "price_date": "2019-04-24",
    "legal_common_shares": 100_000_000,
    "unvested_rsus": 8_000_000,
    "options": [
        {"shares": 5_000_000, "strike": 8.00},
        {"shares": 6_000_000, "strike": 20.00},
        {"shares": 4_000_000, "strike": 40.00},
    ],
    "warrants": [
        {"shares": 2_000_000, "strike": 15.00},
    ],
}

The valuation engine should select the newest snapshot whose filed_at is not later than the screen’s as-of timestamp.

That rule is more important than small differences in the dilution formula. A perfectly implemented treasury stock method applied to future filing data is still a contaminated backtest.

Dilution Can Reverse Screener Rankings

Suppose two software companies each report $500 million of trailing revenue.

Company A has a lower legal enterprise value but a large RSU and option overhang. Company B has little equity compensation.

A legal-share screen can rank A as cheaper. A diluted screen can reverse the result.

import pandas as pd


companies = pd.DataFrame(
    [
        {
            "ticker": "A",
            "revenue": 500_000_000,
            "debt": 100_000_000,
            "cash": 300_000_000,
            "legal_market_cap": 3_600_000_000,
            "diluted_market_cap": 4_166_000_000,
        },
        {
            "ticker": "B",
            "revenue": 500_000_000,
            "debt": 50_000_000,
            "cash": 150_000_000,
            "legal_market_cap": 3_800_000_000,
            "diluted_market_cap": 3_900_000_000,
        },
    ]
)

companies["legal_ev"] = (
    companies["legal_market_cap"]
    + companies["debt"]
    - companies["cash"]
)

companies["diluted_ev"] = (
    companies["diluted_market_cap"]
    + companies["debt"]
    - companies["cash"]
)

companies["legal_ev_to_sales"] = (
    companies["legal_ev"] / companies["revenue"]
)

companies["diluted_ev_to_sales"] = (
    companies["diluted_ev"] / companies["revenue"]
)

print(
    companies[
        ["ticker", "legal_ev_to_sales", "diluted_ev_to_sales"]
    ].sort_values("diluted_ev_to_sales")
)

Result:

Ticker Legal EV / Sales Diluted EV / Sales
B 7.40x 7.60x
A 6.80x 7.93x

The naive screen selects A. The diluted screen selects B.

This is not a cosmetic adjustment. It changes portfolio membership.

Common Implementation Errors

Using weighted-average shares for current market cap

Weighted-average shares belong with period earnings. Current market cap requires a point-in-time share count.

Treating GAAP diluted shares as fully diluted shares

GAAP diluted shares exclude anti-dilutive instruments. Loss-making companies can report no diluted-share increase while having substantial equity overhang.

Adding all options one-for-one

Out-of-the-money options do not have the same current economic claim as common stock. Use a price-sensitive method or disclose that the result is a maximum-share scenario.

Ignoring non-traded common classes

Voting differences do not eliminate economic ownership.

Adding exercise proceeds twice

Treasury-stock-method incremental shares already net exercise proceeds. Do not also increase cash.

Mixing snapshot dates

The cover-page share count, balance-sheet date, option-table date, filing date, and stock-price date can all differ.

Parsing only standard XBRL tags

Equity-compensation tables commonly use custom extensions. Preserve filing tables, labels, dimensions, and source text.

Hiding assumptions in one database column

A field named shares_outstanding is not enough. Store raw claims and generate named denominator policies.

The Production Rule

A serious stock screener should expose at least these fields:

It should calculate both legal and diluted market capitalization.

It should also make the price input explicit because treasury-stock-method dilution changes with price. For fair-value work, calculate dilution at the estimated fair value as well as the current market price. Otherwise the denominator changes after the valuation target is produced.

Market capitalization is not one number. It is a function of security terms, dates, price, and policy.

A screener that stores only price * shares_outstanding has discarded the information needed to value the company.