📊 statistics

On the Capacity of Distinguishable Synthetic Identity Generation under Face Verification

This paper formalizes and analyzes the capacity of distinguishable synthetic identity generation for face verification by characterizing the maximum number of latent identities that satisfy verification constraints as a spherical-code problem, deriving both deterministic and stochastic bounds on this capacity under varying assumptions of angular expressivity and prior distributions.

Original authors: Behrooz Razeghi

Published 2026-04-14

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Behrooz Razeghi

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are the head of a massive, high-security digital ID system. Your job is to verify people's faces. But instead of using real people, you are generating fake (synthetic) identities using an AI artist.

Your goal is simple but tricky: How many unique fake people can you create so that your security scanner never gets confused?

You need the scanner to say:

"Yes, these two photos are the same person!" (when they are).
"No, these two photos are different people!" (when they are not).

This paper, written by Behrooz Razeghi from Harvard, asks a fundamental question: What is the absolute limit on how many unique fake people we can generate before the system starts making mistakes?

Here is the breakdown using simple analogies.

1. The "Face Space" is a Giant Ball

Imagine all possible faces exist on the surface of a giant, invisible ball (a hypersphere).

Real faces are just dots scattered on this ball.
Fake faces are also dots on this ball, created by your AI.
The Security Scanner has a rule: "If two dots are close enough (within a certain angle), they are the same person. If they are far apart, they are different."

2. The Problem: The "Fuzzy" Identity

In the real world, a person's face changes. They look different in the morning, in the dark, or when they smile. In the AI world, this is called noise or variability.

Deterministic (Perfect) World: Imagine your AI creates a "perfect" face that never changes. Every time you ask for "Person A," you get the exact same dot on the ball.
- The Limit: This is like a classic geometry puzzle: How many dots can you put on a ball so none of them touch? This is a known math problem called "Spherical Coding."
Stochastic (Realistic) World: In reality, your AI creates "Person A" with a little bit of randomness. Sometimes "Person A" looks slightly left, sometimes slightly right. On the ball, "Person A" isn't a single dot; it's a fuzzy cloud or a fuzzy cap.
- The Limit: Now, the question is harder. How many of these fuzzy clouds can you fit on the ball so that:
  1. The clouds don't overlap with each other (so different people don't look alike).
  2. The clouds are tight enough that the same person doesn't look like a stranger.

3. The "Safety Buffer" Rule

The paper derives a simple rule for how far apart these fuzzy clouds must be.

Imagine the security scanner has a "danger zone" angle (let's call it $\tau$ ). If two faces are closer than this angle, the scanner thinks they are the same person.

To be safe, the paper says you need a Safety Buffer:

The Gap: You need a gap between the centers of two different people's clouds.
The Formula: The gap must be the Scanner's Danger Zone + Twice the Size of the Fuzzy Cloud.

Analogy: Imagine you are parking cars (identities) in a circular lot (the ball).

The scanner is a guard who says, "If two cars are within 5 feet, I can't tell them apart."

Your cars aren't perfect points; they are fuzzy blobs of paint that wiggle 2 feet in any direction.

To be safe, you can't just park them 5 feet apart. You have to park them 9 feet apart (5 feet guard rule + 2 feet wiggle room for car A + 2 feet wiggle room for car B).

4. The Magic of Dimensions (The "Room" Analogy)

The paper also looks at what happens if you change the size of the ball (the embedding dimension).

In a 2D world (a flat circle), you can only fit a few dots before they crowd each other.
In a 3D world (a sphere), you can fit many more.
In a 100-dimensional world (which computers use for faces), the "surface" is so huge that you can fit an astronomical number of identities.

The paper proves that as the dimension gets bigger, the number of fake people you can generate grows exponentially. It's like going from a small closet to a massive warehouse; you can fit way more stuff in there.

5. Two Ways to Generate People

The paper compares two strategies for creating these fake identities:

The "Planner" (Fixed Code): You carefully hand-pick every single identity to make sure they are perfectly spaced out. This gives you the maximum possible number of identities.
The "Randomizer" (Random Code): You just throw darts at the board randomly and hope you don't hit the same spot twice.
- The Result: The "Planner" is always better. If you pick randomly, you will run out of safe spots much faster because you might accidentally pick two spots that are too close. The paper calculates exactly how much "capacity" you lose by being random.

Why Does This Matter?

This isn't just about math; it's about the future of AI and security.

For AI Creators: If you want to train a face-recognition system using fake data, you need to know how many unique fake people you can generate before the system gets confused. This paper gives you the formula.
For Security: It tells us the limits of how many unique identities can exist in a system before the system becomes unreliable.

The Bottom Line

The paper says: "You can generate a huge number of fake identities, but only if you keep them far enough apart on the 'face ball' to account for their natural wiggles and your scanner's strictness."

It turns a complex computer science problem into a simple geometry problem: How many fuzzy clouds can you fit on a ball without them touching?

1. Problem Statement

The paper addresses a fundamental operational question in synthetic face generation: How many distinct synthetic identities can be generated such that a face verifier correctly classifies same-identity pairs as matches and different-identity pairs as non-matches at a fixed decision threshold $\tau$ ?

While existing literature focuses on visual realism, feature spread, or mutual information, these metrics do not directly quantify the number of identities that satisfy specific verification constraints (True Match Rate and False Match Rate) simultaneously. The author argues that the "capacity" of a generative system must be defined relative to the verifier's decision rule, specifically the cosine-similarity threshold $\tau$ , rather than just the statistical properties of the generated data.

2. Methodology and System Model

System Architecture

The paper models a generative face-recognition pipeline consisting of:

Generator ( $g$ ): Maps a latent identity code $c \in \mathcal{Z}$ and a nuisance variable (view) $U \in \mathcal{U}$ to a face image $Y$ .
Recognition Map ( $\phi$ ): A deterministic feature extractor that maps the image $Y$ to a unit-norm embedding $E$ on the hypersphere $\mathbb{S}^{D-1}$ .

The core object of study is the identity-conditional embedding distribution $P_c = \text{Law}(\phi(g(c, U)))$ , which represents the distribution of embeddings for a specific latent identity $c$ across different views.

Capacity Definitions

The author defines two primary capacity metrics:

Fixed-Code Capacity ( $C_D$ ): The maximum number of latent identities ( $M$ $M$ ) for which there exists a deterministic set of codes $\{c_1, \dots, c_M\}$ ${c_{1}, \dots, c_{M}}$ such that the induced distributions satisfy:
- Genuine Constraint: $P(\langle E_i^{(1)}, E_i^{(2)} \rangle \ge \tau) \ge 1 - \epsilon_{in}$ (Same identity matches).
- Impostor Constraint: $P(\langle E_i^{(1)}, E_j^{(1)} \rangle \le \tau) \ge 1 - \epsilon_{out}$ (Different identities do not match).
Prior-Constrained Random-Code Capacity ( $C_{D,\delta}^{rnd}$ ): The maximum $M$ such that if codes are sampled i.i.d. from a prior distribution, the resulting set of identities is admissible with probability at least $1-\delta$ .

3. Key Contributions

Operational Definition: Introduced a verifier-centered capacity definition tied directly to threshold-based decision rules, distinct from average similarity or mutual information.
Deterministic Regime Characterization: Showed that in a noiseless, view-invariant regime, the capacity is exactly characterized by the spherical code packing problem over the set of realizable embeddings. Under "full angular expressivity" (the generator can produce any direction on the sphere), this reduces to the classical spherical code quantity $A_D(\psi)$ .
Stochastic Centered Model: For stochastic generation (where embeddings vary due to view/nuisance), the author introduced a $(\rho, \eta)$ -centered model. In this model, each identity's embedding distribution is concentrated within a geodesic cap of radius $\rho$ around a center $u_i$ with high probability ( $1-\eta$ ).
Sufficient Admissibility Condition: Derived a geometric condition for admissibility in the stochastic regime: the angular separation between identity centers must be at least $\psi_\tau(\rho) = \arccos(\tau) + 2\rho$ . This accounts for the "spread" of the identity distribution.
Asymptotic Analysis: Established that the number of distinguishable identities grows exponentially with the embedding dimension $D$ $D$ .
- Fixed-Code Rate: $\liminf \frac{1}{D} \log C_D \ge -\log(\sin \psi_\tau(\rho))$ .
- Random-Code Rate: Under uniform sampling of centers, the rate is halved: $\liminf \frac{1}{D} \log C_{D,\delta}^{rnd} \ge -\frac{1}{2} \log(\sin \psi_\tau(\rho))$ . This "factor of two" gap represents the cost of random sampling versus optimal codebook design.
Converse and Exact Characterization: Under a stronger "full-cap-support" model, the paper derives a converse, proving that the spherical code characterization is exact.

4. Key Results

Geometric Interpretation: The problem of generating distinguishable identities is mathematically equivalent to packing spherical caps on the unit hypersphere.
- The required separation angle is $\psi_\tau(\rho) = \arccos(\tau) + 2\rho$ .
- $\tau$ (Threshold): A lower threshold (stricter verification) increases $\arccos(\tau)$ , requiring larger separation and reducing capacity.
- $\rho$ (Concentration): A larger within-identity spread ( $\rho$ ) increases the required separation, reducing capacity.
Dimensionality Scaling: The capacity scales exponentially with the embedding dimension $D$ . The paper explicitly treats $D$ as a variable, showing that higher-dimensional embeddings allow for significantly more distinguishable synthetic identities.
Random vs. Fixed Coding: Randomly sampling latent codes (common in GANs/Diffusion models) incurs a penalty compared to optimally selecting a codebook. The asymptotic rate for random coding is exactly half that of fixed coding when centers are uniformly distributed.
Relation to MMCR: The findings align with Maximum Manifold Capacity Representations (MMCR) objectives: high capacity requires both concentration of embeddings for the same identity (low $\rho$ ) and broad spread of identity centers (large angular separation).

5. Significance and Implications

Theoretical Benchmark: Provides a rigorous, non-asymptotic framework to evaluate the scalability of synthetic identity generation, moving beyond empirical "visual" checks to information-theoretic limits.
Design Guidelines for Generators: Suggests that to maximize the number of usable synthetic identities, generative models should be trained to minimize intra-class variance (concentration radius $\rho$ ) while ensuring inter-class centers are well-separated.
Role of Embedding Dimension: Highlights that the dimensionality of the feature space is not just an architectural detail but a fundamental variable determining the scalability of synthetic data.
Validation: The theoretical bounds were validated via synthetic experiments on the unit sphere, confirming that the observed packing numbers and separation probabilities align with the derived spherical code bounds and asymptotic rates.

In summary, this paper formalizes the limits of synthetic identity generation by mapping it to a geometric packing problem on a hypersphere, providing precise bounds on how many identities can be generated before a face verifier can no longer distinguish them.