two_qubit_candidate_fidelity_bound_at_zero
At adjusted entropy deficit ε = 0, the candidate fidelity bound equals 1.
Statement
theorem two_qubit_candidate_fidelity_bound_at_zero :
two_qubit_candidate_fidelity_bound 0 = 1- Formalizes
- OP-1552; arXiv:2409.01966
- Verified
- 12 Nov 2026
- Axioms
Classical.choiceQuot.soundpropext- Built on 2
- two_qubit_candidate_fidelity_boundFor ε ≥ 0, two_qubit_candidate_fidelity_bound ε is the infimum over 0 ≤ p, q ≤ 1 of max{ p(1 + 2 sqrt(q(1 - q)))/2, (1 - p)/2 } subject to…
- binary_entropy_natsThe binary entropy function in natural units (nats) is -x ln x - (1 - x) ln (1 - x) with the convention 0 ln 0 = 0.
Read back from the Lean
The value two_qubit_candidate_fidelity_bound 0 is equal to 1. That is, the infimum (sInf) over all real numbers F for which there exist real numbers p and q such that:
1. 0 ≤ p ≤ 1,
2. 0 ≤ q ≤ 1,
3. Real.log 2 + binary_entropy_nats p - binary_entropy_nats (p * q) ≤ 0, and
4. F = max (p * (1 + 2 * Real.sqrt (q * (1 - q))) / 2) ((1 - p) / 2)
is equal to 1.
Written by a model that saw only the Lean, never the English above. If the two disagree, that is worth a challenge.
The proof, explained
The theorem proves that at zero deficit ε = 0, the two-qubit candidate fidelity bound equals 1. The bound is defined as the infimum of fidelities F achievable under the entropy deficit constraint log 2 + H(p) - H(pq) ≤ 0 for p, q ∈ [0, 1]. Because binary entropy is non-negative and bounded above by log 2, this constraint forces H(p) = 0 and H(pq) = log 2, which uniquely fixes p = 1 and q = 1/2 (since p = 0 would contradict pq = 1/2). Evaluating the fidelity formula at these parameters yields F = 1, showing the set of feasible fidelities is the singleton {1}, whose infimum is 1.
The binary entropy function `binary_entropy_nats` coincides with Mathlib's `Real.binEntropy`.
Rewriting with the definition of `binary_entropy_nats` and the library characterization `Real.binEntropy_eq_negMulLog_add_negMulLog_one_sub` shows both represent the function x ↦ -x log x - (1 - x) log(1 - x).
uses
Real.binEntropy_eq_negMulLog_add_negMulLog_one_sublemma two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq (x : ℝ) : binary_entropy_nats x = Real.binEntropy x := by rw [binary_entropy_nats, Real.binEntropy_eq_negMulLog_add_negMulLog_one_sub]
The binary entropy in nats at 1 is 0.
This follows by converting `binary_entropy_nats` to `Real.binEntropy` and using the standard evaluation `Real.binEntropy 1 = 0`.
uses
two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq,Real.binEntropy_onelemma two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_one : binary_entropy_nats 1 = 0 := by rw [two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq, Real.binEntropy_one]
The binary entropy in nats at 1/2 is log 2.
Rewriting 1/2 as 2⁻¹ and using the library result `Real.binEntropy 2⁻¹ = log 2` gives the value.
uses
two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq,Real.binEntropy_two_invlemma two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_half : binary_entropy_nats (1 / 2) = Real.log 2 := by rw [two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq] have h : (1 : ℝ) / 2 = 2⁻¹ := by norm_num rw [h, Real.binEntropy_two_inv]
Unfold the candidate fidelity bound definition and reduce the theorem to showing that the feasible set is the singleton {1}.
Unfolding `two_qubit_candidate_fidelity_bound` at deficit ε = 0 expresses it as the infimum of the set of fidelities F = max (p(1 + 2√(q(1 - q)))/2) ((1 - p)/2) subject to p, q ∈ [0, 1] and log 2 + H(p) - H(pq) ≤ 0. By extensionality, showing this set equals {1} reduces to two directions: every feasible fidelity must be 1, and 1 is achievable.
uses
Set.mem_ofPred_eq,Set.mem_singleton_iff/-- At zero deficit epsilon = 0, the candidate fidelity bound achieves the maximally entangled Bell state fidelity of 1. -/ theorem two_qubit_candidate_fidelity_bound_at_zero : two_qubit_candidate_fidelity_bound 0 = 1 := by unfold two_qubit_candidate_fidelity_bound have hS : { F : ℝ | ∃ p q : ℝ, 0 ≤ p ∧ p ≤ 1 ∧ 0 ≤ q ∧ q ≤ 1 ∧ Real.log 2 + binary_entropy_nats p - binary_entropy_nats (p * q) ≤ 0 ∧ F = max (p * (1 + 2 * Real.sqrt (q * (1 - q))) / 2) ((1 - p) / 2) } = {1} := by ext F simp only [Set.mem_ofPred_eq, Set.mem_singleton_iff] constructor
Any feasible parameters (p, q) satisfy p ∈ {0, 1} and pq = 1/2.
Rewriting `binary_entropy_nats` as `Real.binEntropy`, the entropy inequality is log 2 + H(p) - H(pq) ≤ 0. Because H(p) ≥ 0 for p ∈ [0, 1] and H(pq) ≤ log 2 universally, linear arithmetic forces H(p) = 0 and H(pq) = log 2. The only roots of H are p = 0 and p = 1, and the unique maximum of H is at pq = 1/2.
uses
two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq,Real.binEntropy_nonneg,Real.binEntropy_le_log_two,Real.binEntropy_eq_zero.mp,Real.binEntropy_eq_log_two.mp· rintro ⟨p, q, hp0, hp1, -, -, h_entropy, rfl⟩ rw [two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq, two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq] at h_entropy have hp_nonneg : 0 ≤ Real.binEntropy p := Real.binEntropy_nonneg hp0 hp1 have hpq_le : Real.binEntropy (p * q) ≤ Real.log 2 := Real.binEntropy_le_log_two have h_eq : Real.binEntropy p = 0 ∧ Real.binEntropy (p * q) = Real.log 2 := by constructor <;> linarith have hp_cases : p = 0 ∨ p = 1 := Real.binEntropy_eq_zero.mp h_eq.1 have hpq_eq : p * q = 2⁻¹ := Real.binEntropy_eq_log_two.mp h_eq.2
The case p = 0 is impossible, while p = 1 uniquely determines q = 1/2 and yields fidelity F = 1.
If p = 0, then pq = 0, contradicting pq = 1/2. Hence p = 1, which implies 1 * q = q = 1/2. Substituting p = 1 and q = 1/2 into the fidelity formula, q(1 - q) = (1/2)², so √(q(1 - q)) = 1/2, making the first term max (1 * (1 + 2(1/2)) / 2) = 1 and the second term (1 - 1)/2 = 0. Therefore F = max 1 0 = 1.
uses
zero_mul,one_mul,Real.sqrt_sqcases hp_cases with | inl hp0' => subst hp0' simp only [zero_mul] at hpq_eq have : (0 : ℝ) ≠ 2⁻¹ := by norm_num contradiction | inr hp1' => subst hp1' simp only [one_mul] at hpq_eq have hq : q = 1 / 2 := by linarith subst hq have hs : (1 / 2 : ℝ) * (1 - 1 / 2) = (1 / 2) ^ 2 := by ring rw [hs, Real.sqrt_sq (by norm_num)] norm_num
The candidate fidelity 1 is feasible, achieved by p = 1 and q = 1/2.
For p = 1 and q = 1/2, the bounds 0 ≤ p ≤ 1 and 0 ≤ q ≤ 1 hold trivially. The entropy difference log 2 + H(1) - H(1/2) equals log 2 + 0 - log 2 = 0 ≤ 0. Finally, evaluating the formula with √(1/4) = 1/2 gives fidelity 1.
uses
one_mul,two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_one,two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_half,Real.sqrt_sq· rintro rfl refine ⟨1, 1 / 2, by norm_num, by norm_num, by norm_num, by norm_num, ?_, ?_⟩ · rw [one_mul, two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_one, two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_half] linarith · have hs : (1 / 2 : ℝ) * (1 - 1 / 2) = (1 / 2) ^ 2 := by ring rw [hs, Real.sqrt_sq (by norm_num)] norm_num
The candidate fidelity bound at ε = 0 equals 1.
Substituting the set equality {F | ...} = {1} into the goal, the infimum sInf {1} evaluates to 1 by `csInf_singleton`.
uses
csInf_singletonrw [hS] exact csInf_singleton 1
Real.binEntropy_eq_negMulLog_add_negMulLog_one_sub- The binary entropy of p is p.negMulLog + (1 - p).negMulLog.
two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq- The binary entropy in nats binary_entropy_nats x equals Mathlib's Real.binEntropy x.
Real.binEntropy_one- The binary entropy of 1 is 0.
Real.binEntropy_two_inv- The binary entropy of 2⁻¹ = 1/2 is log 2.
Set.mem_ofPred_eq- Membership of x in a set-builder defined set {y | P y} is equivalent to P x.
Set.mem_singleton_iff- An element x is in {a} if and only if x = a.
Real.binEntropy_nonneg- For 0 ≤ p ≤ 1, the binary entropy binEntropy p is non-negative.
Real.binEntropy_le_log_two- For any real p, the binary entropy binEntropy p is at most log 2.
Real.binEntropy_eq_zero.mp- If binEntropy p = 0, then p = 0 or p = 1.
Real.binEntropy_eq_log_two.mp- If binEntropy p = log 2, then p = 2⁻¹.
zero_mul- Multiplication of zero by any element gives zero (0 * b = 0).
one_mul- Multiplication of any element by one on the left preserves it (1 * a = a).
Real.sqrt_sq- For x ≥ 0, √(x²) = x.
two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_one- The binary entropy in nats evaluated at 1 is 0.
two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_half- The binary entropy in nats evaluated at 1/2 is log 2.
csInf_singleton- The infimum of a singleton set {a} in a conditionally complete lattice is a.
Written by a model (gemini-3.8-flash) from the Lean proof and the goal states Lean reported at each step. Lean verified the proof; this explanation is a reading aid and is not itself machine-checked.
Lean source view module on GitHub
Choose a tactic — a marked line — to see the goals Lean had before and after it, as in Lean’s infoview. Step with ← → or j k.
lemma two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq (x : ℝ) : binary_entropy_nats x = Real.binEntropy x := by rw [binary_entropy_nats, Real.binEntropy_eq_negMulLog_add_negMulLog_one_sub]lemma two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_one : binary_entropy_nats 1 = 0 := by rw [two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq, Real.binEntropy_one]lemma two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_half : binary_entropy_nats (1 / 2) = Real.log 2 := by rw [two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq] have h : (1 : ℝ) / 2 = 2⁻¹ := by norm_num rw [h, Real.binEntropy_two_inv]/-- At zero deficit epsilon = 0, the candidate fidelity bound achieves the maximally entangled Bell state fidelity of 1. -/theorem two_qubit_candidate_fidelity_bound_at_zero : two_qubit_candidate_fidelity_bound 0 = 1 := by unfold two_qubit_candidate_fidelity_bound have hS : { F : ℝ | ∃ p q : ℝ, 0 ≤ p ∧ p ≤ 1 ∧ 0 ≤ q ∧ q ≤ 1 ∧ Real.log 2 + binary_entropy_nats p - binary_entropy_nats (p * q) ≤ 0 ∧ F = max (p * (1 + 2 * Real.sqrt (q * (1 - q))) / 2) ((1 - p) / 2) } = {1} := by ext F simp only [Set.mem_ofPred_eq, Set.mem_singleton_iff] constructor · rintro ⟨p, q, hp0, hp1, -, -, h_entropy, rfl⟩ rw [two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq, two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_eq] at h_entropy have hp_nonneg : 0 ≤ Real.binEntropy p := Real.binEntropy_nonneg hp0 hp1 have hpq_le : Real.binEntropy (p * q) ≤ Real.log 2 := Real.binEntropy_le_log_two have h_eq : Real.binEntropy p = 0 ∧ Real.binEntropy (p * q) = Real.log 2 := by constructor <;> linarith have hp_cases : p = 0 ∨ p = 1 := Real.binEntropy_eq_zero.mp h_eq.1 have hpq_eq : p * q = 2⁻¹ := Real.binEntropy_eq_log_two.mp h_eq.2 cases hp_cases with | inl hp0' => subst hp0' simp only [zero_mul] at hpq_eq have : (0 : ℝ) ≠ 2⁻¹ := by norm_num contradiction | inr hp1' => subst hp1' simp only [one_mul] at hpq_eq have hq : q = 1 / 2 := by linarith subst hq have hs : (1 / 2 : ℝ) * (1 - 1 / 2) = (1 / 2) ^ 2 := by ring rw [hs, Real.sqrt_sq (by norm_num)] norm_num · rintro rfl refine ⟨1, 1 / 2, by norm_num, by norm_num, by norm_num, by norm_num, ?_, ?_⟩ · rw [one_mul, two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_one, two_qubit_candidate_fidelity_bound_at_zero_entropy_nats_half] linarith · have hs : (1 / 2 : ℝ) * (1 - 1 / 2) = (1 / 2) ^ 2 := by ring rw [hs, Real.sqrt_sq (by norm_num)] norm_num rw [hS] exact csInf_singleton 1