Unambiguous Quantum State Discrimination

Maximizing the Error-Free Success Probability

Introduction

Suppose someone hands you a qubit and tells you it is in one of two known pure states, $|\psi_1\rangle$ or $|\psi_2\rangle$. If the states are not orthogonal, no measurement can tell them apart perfectly. Two philosophies exist for dealing with this limitation:

  • Minimum-error discrimination always gives an answer, but accepts that the answer is sometimes wrong. The optimum is given by the Helstrom bound.
  • Unambiguous state discrimination (USD) never gives a wrong answer, but accepts that the measurement sometimes returns “I don’t know”. The goal is to maximize the probability of a conclusive and correct result.

USD is the right tool whenever a wrong answer is far more costly than no answer at all, as in quantum key distribution or quantum money verification. In this article we formulate USD as a small constrained optimization problem, derive the closed-form optimum, verify it by brute-force search, simulate the measurement with Monte Carlo sampling, and visualize everything, including 3D landscapes.

Problem Formulation

Let the two states be prepared with prior probabilities $\eta_1$ and $\eta_2 = 1-\eta_1$, and let their overlap be

$$
s = \langle \psi_1 | \psi_2 \rangle, \qquad 0 \le |s| < 1 .
$$

We look for a three-outcome POVM ${\Pi_1, \Pi_2, \Pi_?}$ with

$$
\Pi_1 + \Pi_2 + \Pi_? = I, \qquad \Pi_1,\Pi_2,\Pi_? \succeq 0 .
$$

Outcome “1” means “the state was $\psi_1$”, outcome “2” means “the state was $\psi_2$”, and outcome “?” means “inconclusive”. Error-free discrimination requires

$$
\langle \psi_2 | \Pi_1 | \psi_2 \rangle = 0, \qquad \langle \psi_1 | \Pi_2 | \psi_1 \rangle = 0 .
$$

The objective is the total probability of a conclusive result:

$$
P_{\mathrm{succ}} = \eta_1 \langle \psi_1 | \Pi_1 | \psi_1 \rangle + \eta_2 \langle \psi_2 | \Pi_2 | \psi_2 \rangle .
$$

The problem is therefore: maximize $P_{\mathrm{succ}}$ over POVMs subject to the zero-error constraints.

Reduction to a Two-Variable Optimization

The zero-error constraints force $\Pi_1$ to be proportional to the projector onto the vector orthogonal to $|\psi_2\rangle$, and $\Pi_2$ to be proportional to the projector onto the vector orthogonal to $|\psi_1\rangle$:

$$
\Pi_1 = p_1 |\psi_2^{\perp}\rangle\langle\psi_2^{\perp}|, \qquad
\Pi_2 = p_2 |\psi_1^{\perp}\rangle\langle\psi_1^{\perp}|, \qquad p_1,p_2 \in [0,1].
$$

Since $|\langle \psi_2^{\perp}|\psi_1\rangle|^2 = 1-|s|^2$, the objective becomes

$$
P_{\mathrm{succ}}(p_1,p_2) = (1-|s|^2),(\eta_1 p_1 + \eta_2 p_2).
$$

The remaining requirement is positivity of the inconclusive operator

$$
\Pi_? = I - p_1 |\psi_2^{\perp}\rangle\langle\psi_2^{\perp}| - p_2 |\psi_1^{\perp}\rangle\langle\psi_1^{\perp}| \succeq 0 .
$$

For a $2\times 2$ Hermitian matrix, positive semidefiniteness is equivalent to a non-negative trace and a non-negative determinant:

$$
\operatorname{tr}\Pi_? = 2 - p_1 - p_2 \ge 0, \qquad
\det \Pi_? = 1 - p_1 - p_2 + p_1 p_2 ,(1-|s|^2) \ge 0 .
$$

We have reduced the quantum problem to maximizing a linear function over a convex region in the $(p_1,p_2)$ plane.

Closed-Form Solution

Let $r = \sqrt{\eta_2/\eta_1}$. The optimum lies on the curve $\det\Pi_? = 0$, and solving the Lagrange conditions gives two regimes.

Regime I (moderate overlap), $|s| \le \min\left(r,, 1/r\right)$:

$$
p_1 = \frac{1 - r|s|}{1-|s|^2}, \qquad
p_2 = \frac{1 - |s|/r}{1-|s|^2}, \qquad
P_{\mathrm{succ}} = 1 - 2\sqrt{\eta_1\eta_2},|s| .
$$

Regime II (large overlap, strongly biased priors), $|s| > \min\left(r,,1/r\right)$. It is best to only identify the more probable state:

$$
P_{\mathrm{succ}} = \max(\eta_1,\eta_2),\bigl(1-|s|^2\bigr).
$$

For equal priors the answer simplifies to the famous Ivanovic–Dieks–Peres limit

$$
P_{\mathrm{succ}} = 1 - |\langle\psi_1|\psi_2\rangle| .
$$

For comparison, the minimum-error (Helstrom) success probability is

$$
P_{\mathrm{Hel}} = \frac{1}{2}\left(1 + \sqrt{1 - 4\eta_1\eta_2,|s|^2}\right),
$$

which is always larger than $P_{\mathrm{succ}}$. The difference is the price paid for certainty.

Concrete Example

We use two real qubit states in the plane,

$$
|\psi_1\rangle = \begin{pmatrix}1\0\end{pmatrix}, \qquad
|\psi_2\rangle = \begin{pmatrix}\cos\theta\ \sin\theta\end{pmatrix}, \qquad s = \cos\theta,
$$

and the orthogonal partners

$$
|\psi_2^{\perp}\rangle = \begin{pmatrix}-\sin\theta\ \cos\theta\end{pmatrix}, \qquad
|\psi_1^{\perp}\rangle = \begin{pmatrix}0\1\end{pmatrix}.
$$

Three scenarios are examined:

Case Angle $\theta$ Prior $\eta_1$ Expected regime
A $60^\circ$ $0.5$ Regime I, $P_{\mathrm{succ}} = 0.5$
B $60^\circ$ $0.3$ Regime I, $P_{\mathrm{succ}} \approx 0.5417$
C $30^\circ$ $0.2$ Regime II, $P_{\mathrm{succ}} = 0.2$

For each case we (1) evaluate the closed-form optimum, (2) verify it with a brute-force search over the feasible region, and (3) run a Monte Carlo simulation of the optimal POVM.

Python Source Code

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec

plt.style.use("dark_background")


# ------------------------------------------------------------
# Theory: closed-form USD optimum and Helstrom bound
# ------------------------------------------------------------
def usd_success(eta1, x):
"""Optimal unambiguous-discrimination success probability (vectorized)."""
eta1 = np.asarray(eta1, dtype=float)
x = np.asarray(x, dtype=float)
eta2 = 1.0 - eta1
thr = np.sqrt(np.minimum(eta1, eta2) / np.maximum(eta1, eta2))
low = 1.0 - 2.0 * np.sqrt(eta1 * eta2) * x
high = np.maximum(eta1, eta2) * (1.0 - x ** 2)
return np.where(x <= thr, low, high)


def helstrom_success(eta1, x):
"""Minimum-error (Helstrom) success probability (vectorized)."""
eta1 = np.asarray(eta1, dtype=float)
x = np.asarray(x, dtype=float)
return 0.5 * (1.0 + np.sqrt(1.0 - 4.0 * eta1 * (1.0 - eta1) * x ** 2))


def usd_optimal_weights(eta1, s):
"""Optimal POVM weights (p1, p2) for the two zero-error elements."""
eta1 = float(eta1)
eta2 = 1.0 - eta1
x = abs(float(s))
r = np.sqrt(eta2 / eta1)
if x <= min(r, 1.0 / r):
p1 = (1.0 - r * x) / (1.0 - x ** 2)
p2 = (1.0 - x / r) / (1.0 - x ** 2)
return max(p1, 0.0), max(p2, 0.0)
if eta1 >= eta2:
return 1.0, 0.0
return 0.0, 1.0


# ------------------------------------------------------------
# Brute-force verification over the (p1, p2) square
# ------------------------------------------------------------
def brute_force_success(eta1, s, n=1201):
eta2 = 1.0 - eta1
p = np.linspace(0.0, 1.0, n)
P1, P2 = np.meshgrid(p, p, indexing="ij")
tr = 2.0 - P1 - P2
det = 1.0 - P1 - P2 + P1 * P2 * (1.0 - s ** 2)
feas = (tr >= -1e-12) & (det >= -1e-12)
obj = (1.0 - s ** 2) * (eta1 * P1 + eta2 * P2)
obj_masked = np.where(feas, obj, -np.inf)
idx = np.unravel_index(np.argmax(obj_masked), obj_masked.shape)
return float(obj_masked[idx]), float(P1[idx]), float(P2[idx]), feas, obj, p


# ------------------------------------------------------------
# Explicit POVM and Monte Carlo simulation
# ------------------------------------------------------------
def build_povm(theta, p1, p2):
psi1 = np.array([1.0, 0.0])
psi2 = np.array([np.cos(theta), np.sin(theta)])
a = np.array([-np.sin(theta), np.cos(theta)]) # orthogonal to psi2
b = np.array([0.0, 1.0]) # orthogonal to psi1
E1 = p1 * np.outer(a, a)
E2 = p2 * np.outer(b, b)
E0 = np.eye(2) - E1 - E2
return psi1, psi2, E1, E2, E0


def simulate(theta, eta1, n_shots, rng):
s = np.cos(theta)
p1, p2 = usd_optimal_weights(eta1, s)
psi1, psi2, E1, E2, E0 = build_povm(theta, p1, p2)
truth = np.where(rng.random(n_shots) < eta1, 1, 2)
outcome = np.empty(n_shots, dtype=int)
for k, psi in ((1, psi1), (2, psi2)):
probs = np.array([psi @ E1 @ psi, psi @ E2 @ psi, psi @ E0 @ psi])
probs = np.clip(probs, 0.0, None)
probs = probs / probs.sum()
mask = truth == k
outcome[mask] = rng.choice(3, size=int(mask.sum()), p=probs)
# outcome 0 -> declare "1", 1 -> declare "2", 2 -> inconclusive
correct = ((outcome == 0) & (truth == 1)) | ((outcome == 1) & (truth == 2))
error = ((outcome == 0) & (truth == 2)) | ((outcome == 1) & (truth == 1))
inconclusive = outcome == 2
min_eig = float(np.linalg.eigvalsh(E0).min())
return correct.mean(), error.mean(), inconclusive.mean(), p1, p2, min_eig


# ------------------------------------------------------------
# Run the three cases
# ------------------------------------------------------------
rng = np.random.default_rng(2024)
N_SHOTS = 400_000
cases = [
("A", 60.0, 0.5),
("B", 60.0, 0.3),
("C", 30.0, 0.2),
]

results = []
print("=" * 118)
print("Unambiguous Quantum State Discrimination: theory vs brute force vs Monte Carlo")
print("=" * 118)
print(f"{'Case':<5}{'theta':>7}{'eta1':>7}{'|s|':>8}{'p1':>9}{'p2':>9}"
f"{'Theory':>10}{'BruteF.':>10}{'MC succ':>10}{'MC error':>10}"
f"{'MC inconc.':>12}{'Helstrom':>10}{'min eig':>11}")
print("-" * 118)

for name, th_deg, eta1 in cases:
theta = np.deg2rad(th_deg)
s = np.cos(theta)
theory = float(usd_success(eta1, abs(s)))
brute, bp1, bp2, _, _, _ = brute_force_success(eta1, s, n=1201)
succ, err, inc, p1, p2, min_eig = simulate(theta, eta1, N_SHOTS, rng)
hel = float(helstrom_success(eta1, abs(s)))
results.append(dict(name=name, theory=theory, succ=succ, err=err, inc=inc, hel=hel))
print(f"{name:<5}{th_deg:>7.1f}{eta1:>7.2f}{abs(s):>8.4f}{p1:>9.4f}{p2:>9.4f}"
f"{theory:>10.4f}{brute:>10.4f}{succ:>10.4f}{err:>10.4f}"
f"{inc:>12.4f}{hel:>10.4f}{min_eig:>11.2e}")

print("=" * 118)
print(f"Shots per case: {N_SHOTS:,}")

# ------------------------------------------------------------
# Visualization (single combined figure)
# ------------------------------------------------------------
fig = plt.figure(figsize=(22, 13))
gs = GridSpec(2, 3, figure=fig)
fig.suptitle("Unambiguous Quantum State Discrimination of Two Qubit States",
fontsize=20, fontweight="bold")

# (0,0) 3D surface: optimal USD success probability
x_vals = np.linspace(0.0, 0.99, 70)
e_vals = np.linspace(0.02, 0.98, 70)
X, E = np.meshgrid(x_vals, e_vals)
P_usd = usd_success(E, X)
P_hel = helstrom_success(E, X)

ax1 = fig.add_subplot(gs[0, 0], projection="3d")
surf1 = ax1.plot_surface(X, E, P_usd, cmap="viridis", edgecolor="none", alpha=0.95)
ax1.set_xlabel(r"$|\langle\psi_1|\psi_2\rangle|$", labelpad=8)
ax1.set_ylabel(r"$\eta_1$", labelpad=8)
ax1.set_zlabel(r"$P_{\mathrm{succ}}$", labelpad=8)
ax1.set_title("Optimal USD success probability", fontsize=13)
ax1.view_init(elev=28, azim=-125)
fig.colorbar(surf1, ax=ax1, shrink=0.6, pad=0.1)

# (0,1) 3D surface: price of certainty (Helstrom - USD)
ax2 = fig.add_subplot(gs[0, 1], projection="3d")
surf2 = ax2.plot_surface(X, E, P_hel - P_usd, cmap="magma", edgecolor="none", alpha=0.95)
ax2.set_xlabel(r"$|\langle\psi_1|\psi_2\rangle|$", labelpad=8)
ax2.set_ylabel(r"$\eta_1$", labelpad=8)
ax2.set_zlabel(r"$P_{\mathrm{Hel}} - P_{\mathrm{succ}}$", labelpad=8)
ax2.set_title("Price of certainty (Helstrom minus USD)", fontsize=13)
ax2.view_init(elev=28, azim=-125)
fig.colorbar(surf2, ax=ax2, shrink=0.6, pad=0.1)

# (0,2) geometry of states and POVM directions (case A)
ax3 = fig.add_subplot(gs[0, 2])
th = np.deg2rad(60.0)
circle_t = np.linspace(0.0, 2.0 * np.pi, 400)
ax3.plot(np.cos(circle_t), np.sin(circle_t), color="gray", lw=1, ls=":")
vecs = [
(r"$|\psi_1\rangle$", (1.0, 0.0), "#00e5ff"),
(r"$|\psi_2\rangle$", (np.cos(th), np.sin(th)), "#ffb300"),
(r"$|\psi_2^{\perp}\rangle$", (-np.sin(th), np.cos(th)), "#69f0ae"),
(r"$|\psi_1^{\perp}\rangle$", (0.0, 1.0), "#ff4081"),
]
for label, (vx, vy), col in vecs:
ax3.annotate("", xy=(vx, vy), xytext=(0.0, 0.0),
arrowprops=dict(arrowstyle="-|>", color=col, lw=2.5))
ax3.text(1.17 * vx, 1.17 * vy, label, color=col, fontsize=15,
ha="center", va="center")
ax3.set_xlim(-1.4, 1.4)
ax3.set_ylim(-0.4, 1.4)
ax3.set_aspect("equal")
ax3.grid(alpha=0.25)
ax3.set_title(r"State geometry (case A, $\theta=60^\circ$)", fontsize=13)

# (1,0) success probability curves vs overlap
ax4 = fig.add_subplot(gs[1, 0])
xs = np.linspace(0.0, 0.999, 500)
for eta, col in zip((0.5, 0.3, 0.1), ("#00e5ff", "#ffb300", "#ff4081")):
ax4.plot(xs, usd_success(eta, xs), color=col, lw=2.5,
label=rf"USD, $\eta_1={eta}$")
ax4.plot(xs, helstrom_success(eta, xs), color=col, lw=1.8, ls="--",
label=rf"Helstrom, $\eta_1={eta}$")
ax4.set_xlabel(r"$|\langle\psi_1|\psi_2\rangle|$")
ax4.set_ylabel("Success probability")
ax4.set_title("USD (solid) vs minimum-error (dashed)", fontsize=13)
ax4.grid(alpha=0.25)
ax4.legend(fontsize=9, loc="lower left")

# (1,1) feasible region in the (p1, p2) plane (case B)
s_b = np.cos(np.deg2rad(60.0))
eta_b = 0.3
_, _, _, feas, obj, pgrid = brute_force_success(eta_b, s_b, n=401)
Z = np.ma.masked_where(~feas, obj)
ax5 = fig.add_subplot(gs[1, 1])
mesh = ax5.pcolormesh(pgrid, pgrid, Z.T, shading="auto", cmap="plasma")
p1_line = np.linspace(0.0, 1.0, 400)
p2_line = (1.0 - p1_line) / (1.0 - (1.0 - s_b ** 2) * p1_line)
ax5.plot(p1_line, p2_line, color="white", ls="--", lw=1.8, label=r"$\det\Pi_?=0$")
bp1, bp2 = usd_optimal_weights(eta_b, s_b)
ax5.scatter([bp1], [bp2], marker="*", s=420, color="#00e5ff",
edgecolor="white", zorder=5, label="Optimum")
ax5.set_xlabel(r"$p_1$")
ax5.set_ylabel(r"$p_2$")
ax5.set_title(r"Feasible region and objective (case B)", fontsize=13)
ax5.legend(loc="upper right", fontsize=10)
fig.colorbar(mesh, ax=ax5, shrink=0.85, label=r"$P_{\mathrm{succ}}$")

# (1,2) Monte Carlo outcome statistics
ax6 = fig.add_subplot(gs[1, 2])
idx = np.arange(len(results))
w = 0.2
series = [
("Simulated success", [r["succ"] for r in results], "#00e5ff"),
("Theoretical success", [r["theory"] for r in results], "#ffb300"),
("Simulated inconclusive", [r["inc"] for r in results], "#9575cd"),
("Simulated error", [r["err"] for r in results], "#ff4081"),
]
for k, (lab, vals, col) in enumerate(series):
bars = ax6.bar(idx + (k - 1.5) * w, vals, width=w, color=col, label=lab)
for bar, v in zip(bars, vals):
ax6.text(bar.get_x() + bar.get_width() / 2.0, v + 0.01, f"{v:.3f}",
ha="center", va="bottom", fontsize=8, rotation=90)
ax6.set_xticks(idx)
ax6.set_xticklabels([f"Case {r['name']}" for r in results])
ax6.set_ylim(0.0, 1.2)
ax6.set_ylabel("Probability")
ax6.set_title(f"Monte Carlo outcomes ({N_SHOTS:,} shots per case)", fontsize=13)
ax6.legend(fontsize=9, loc="upper right")
ax6.grid(alpha=0.25, axis="y")

fig.subplots_adjust(left=0.04, right=0.97, top=0.92, bottom=0.07, wspace=0.28, hspace=0.30)
plt.show()

Code Walkthrough

Theory functions

usd_success implements the two-regime formula. It computes the threshold $\sqrt{\eta_{\min}/\eta_{\max}}$ with NumPy broadcasting and selects between

$$
1 - 2\sqrt{\eta_1\eta_2},|s| \qquad\text{and}\qquad \max(\eta_1,\eta_2)(1-|s|^2)
$$

through np.where. Because it accepts arrays, the same function produces both the 3D surface and the 2D curves without a single Python loop. helstrom_success evaluates the minimum-error bound for the comparison.

usd_optimal_weights returns the pair $(p_1,p_2)$. In Regime I it applies the closed-form expressions. In Regime II it sets the weight of the more probable state to $1$ and the other to $0$, which means the measurement only ever tries to identify the likelier state.

Brute-force verification

brute_force_success scans a $1201\times1201$ grid over $(p_1,p_2)$. Instead of calling an eigenvalue solver 1.4 million times, it uses the fact that a $2\times 2$ Hermitian matrix is positive semidefinite exactly when its trace and determinant are both non-negative. With $|\langle\psi_2^{\perp}|\psi_1^{\perp}\rangle| = |s|$, these are

$$
\operatorname{tr}\Pi_? = 2-p_1-p_2, \qquad \det\Pi_? = 1-p_1-p_2+p_1p_2(1-s^2).
$$

Both quantities are computed for the whole grid at once, so the search finishes almost instantly. Infeasible points are assigned $-\infty$, and np.argmax finds the best feasible point. The grid result agrees with the closed form up to the grid resolution.

POVM construction and Monte Carlo simulation

build_povm creates the explicit operators

$$
\Pi_1 = p_1|\psi_2^{\perp}\rangle\langle\psi_2^{\perp}|, \quad
\Pi_2 = p_2|\psi_1^{\perp}\rangle\langle\psi_1^{\perp}|, \quad
\Pi_? = I-\Pi_1-\Pi_2 .
$$

simulate draws the true state of every shot according to the priors. For each true state, the Born-rule outcome probabilities $\langle\psi|\Pi_j|\psi\rangle$ are computed once, and all shots of that state are sampled in a single vectorized rng.choice call. Each shot is then classified as correct, erroneous, or inconclusive with boolean masks. The smallest eigenvalue of $\Pi_?$ is reported as a sanity check that the POVM is valid. A value of order $10^{-16}$ or $0$ means the inconclusive operator sits exactly on the boundary of positivity, which is the signature of optimality.

Visualization

The single figure contains six panels:

  1. A 3D surface of the optimal success probability over overlap and prior.
  2. A 3D surface of the gap between the Helstrom bound and USD.
  3. The geometry of the states and the POVM directions.
  4. Success-probability curves for several priors.
  5. The feasible region in the $(p_1,p_2)$ plane.
  6. The Monte Carlo statistics for the three cases.

The vectorized design (grid evaluation with broadcasting, trace and determinant instead of eigendecomposition, and mask-based sampling) keeps the whole script fast enough to run in a few seconds.

Execution Results

======================================================================================================================
Unambiguous Quantum State Discrimination: theory vs brute force vs Monte Carlo
======================================================================================================================
Case   theta   eta1     |s|       p1       p2    Theory   BruteF.   MC succ  MC error  MC inconc.  Helstrom    min eig
----------------------------------------------------------------------------------------------------------------------
A       60.0   0.50  0.5000   0.6667   0.6667    0.5000    0.5000    0.4996    0.0000      0.5004    0.9330  -4.16e-17
B       60.0   0.30  0.5000   0.3150   0.8969    0.5417    0.5417    0.5413    0.0000      0.4587    0.9444   5.20e-17
C       30.0   0.20  0.8660   0.0000   1.0000    0.2000    0.2000    0.2006    0.0000      0.7994    0.8606   0.00e+00
======================================================================================================================
Shots per case: 400,000

Detailed Discussion of the Results

The success-probability surface

The first 3D panel shows $P_{\mathrm{succ}}$ as a function of the overlap $|s|$ and the prior $\eta_1$. Along the edge $|s|=0$ the surface sits at height $1$, because orthogonal states can be distinguished perfectly. As the overlap grows, the height falls toward $0$ along the edge $|s|\to 1$, where the two states become physically identical. The surface is highest along the central ridge $\eta_1 = 0.5$ at small overlap and bends differently near the edges $\eta_1\to 0$ and $\eta_1 \to 1$. There, the more probable state dominates and the Regime II formula $\max(\eta_1,\eta_2)(1-|s|^2)$ takes over. The kink between the two regimes is where the optimal strategy changes qualitatively.

The price of certainty

The second surface plots $P_{\mathrm{Hel}} - P_{\mathrm{succ}}$. It vanishes at $|s|=0$, since both strategies are perfect for orthogonal states. It also shrinks again near $|s|\to1$, where neither strategy can do much. The largest gap appears at intermediate overlaps and balanced priors. For case A, the theory gives $P_{\mathrm{Hel}}\approx 0.933$ against $P_{\mathrm{succ}}=0.5$. The Helstrom measurement always answers and is right about 93% of the time, whereas the unambiguous measurement answers only half the time but is never wrong.

The geometry panel

The geometry panel shows why the measurement works. The vector $|\psi_2^{\perp}\rangle$ is perpendicular to $|\psi_2\rangle$, so the projector onto it can never fire when the state is $\psi_2$. A click therefore proves the state was $\psi_1$. The same argument applies to $|\psi_1^{\perp}\rangle$ and $\psi_2$. The price is that these two directions are not orthogonal to each other, so they cannot be combined into a complete measurement. The leftover element $\Pi_?$ must absorb the remainder, and that is where the inconclusive outcomes come from.

The curves

The solid curves are the USD optimum and the dashed curves are the Helstrom bound for the same priors. Each dashed curve lies above its solid partner. For $\eta_1 = 0.5$ the solid curve is the straight line $1-|s|$. For biased priors the solid curves follow the Regime I line at first and then switch to the downward parabola $\max(\eta_1,\eta_2)(1-|s|^2)$ after the threshold overlap. The curve is continuous at the threshold, and its slope is continuous there as well, which makes the transition smooth.

The feasible region

The heatmap shows the objective over the feasible region for case B. The white dashed curve is the boundary $\det\Pi_?=0$, and the region below it is feasible. Because the objective is linear, its maximum must lie on this boundary, and the star marks the optimum, with $p_1\approx0.315$ and $p_2\approx 0.897$. The solution gives a larger weight to the less probable state’s identifier, which is a counterintuitive but correct feature of USD with unequal priors: a state that is rarely prepared needs a more aggressive unambiguous test to extract its share of the success probability.

The Monte Carlo statistics

The bar chart compares simulated and theoretical success probabilities for the three cases: $0.5$, about $0.5417$, and $0.2$. The simulated bars agree with the theoretical bars to within statistical fluctuations of order $1/\sqrt{N}$. The most important bar is the pink one. The simulated error rate is exactly zero in all three cases, because the forbidden outcomes have probability zero by construction. The rest of the probability is the inconclusive fraction, so the three bars for each case, success, inconclusive and error, add up to one.

Case C illustrates Regime II. With a small angle and a strongly biased prior, the optimal strategy abandons any attempt to identify the rare state. The measurement only tries to confirm the likely state, with $p_1=0$ and $p_2=1$ in the notation above, and it succeeds with probability $0.8\times(1-0.75)=0.2$. This is a good reminder that the “best” unambiguous measurement is not always symmetric.

Conclusion

Unambiguous state discrimination turns a fundamental quantum limitation into a clean optimization problem. By trading some certainty about whether we get an answer for absolute certainty about what the answer is, we obtain the closed-form optimum

$$
P_{\mathrm{succ}} = 1 - 2\sqrt{\eta_1\eta_2},|\langle\psi_1|\psi_2\rangle|
$$

in the balanced regime, and the simpler $\max(\eta_1,\eta_2)(1-|s|^2)$ in the strongly biased regime. Brute-force search over the feasible region and a Monte Carlo simulation of the explicit POVM both confirm the analysis, and the 3D landscapes show how the optimum depends on both the overlap and the priors. The same framework extends to more than two states, to mixed states, and to discrimination under noise, where the optimization is usually solved numerically with semidefinite programming.