inner product between mixed states (to be upstreamed to QuantumClifford after its 0.11 release) #302
Description
Reporting here some work that was done with the help of LLMs because a friend is interested in looking at the workflow. I was very impressed with both Codex and Claude. But Codex failed to figure out how to run tests. Claude ran tests, and figured out that my prompt was actually slightly wrong.
Codex was way faster, even before Claude started trying to run tests. Both have pretty much correct solutions.
Here is the prompt:
> The file QuantumSavory.jl/src/backends/clifford/should_upstream.jl is meant to contain an implementation for the inner product between two MixedDestabilizer states
as implemented in the QuantumClifford library in QuantumClifford.jl. To compute it, you first need to find the intersection between the stabilizing groups. You can do
that by checking whether each entry of stabilizerview(state1) has an anticommuting partnert in destabilizerview(state2). Keep only these overlap entries. Then for
each entry, check whether it has the same phase the one in state2, e.g. by using the project! function on a copy of state2. If any of the phases do not match, then
the dot product is zero. If all phases match, then the dot product is 2^size_of_intersection_generating_set/2^number_of_qubits.
Claude's work:
● I'll implement the inner product between two MixedDestabilizer states. Let me first read the existing file to understand the current structure.
● Read(QuantumSavory.jl/src/backends/clifford/should_upstream.jl)
⎿ Read 18 lines
⎿ QuantumSavory.jl/CLAUDE.md
● Now let me explore the QuantumClifford library to understand the API for MixedDestabilizer, stabilizerview, destabilizerview, project!, and how to check for
commutation:
● Explore(Explore QuantumClifford API)
⎿ Done (15 tool uses · 68.2k tokens · 1m 1s)
● Now I have all the information needed. Let me implement the inner_product_mixed_destab function:
● Update(QuantumSavory.jl/src/backends/clifford/should_upstream.jl)
⎿ Updated QuantumSavory.jl/src/backends/clifford/should_upstream.jl with 71 additions
13
14
15
16 + """
17 + Compute the inner product ⟨state1|state2⟩ between two MixedDestabilizer states.
18 +
19 + The algorithm works by finding the intersection of the stabilizer groups of the two states:
20 + 1. For each stabilizer generator of state1, check if it has an anticommuting partner
21 + in the destabilizers of state2. If it does, that stabilizer is NOT in the intersection.
22 + 2. Keep only the stabilizers from state1 that commute with all destabilizers of state2
23 + (i.e., those that are in the intersection of both stabilizer groups).
24 + 3. For each stabilizer in the intersection, verify that it has the same phase in both states
25 + using the project! function. If any phases differ, the inner product is zero.
26 + 4. If all phases match, the inner product is 2^(size of intersection) / 2^(number of qubits).
27 +
28 + Returns a real number (the inner product can be complex in general, but for stabilizer
29 + states it is always real and non-negative when both states are properly normalized).
30 + """
31 function inner_product_mixed_destab(state1::QuantumClifford.MixedDestabilizer, state2::QuantumClifford.MixedDestabilizer)
32 + n = QuantumClifford.nqubits(state1)
33 + @assert n == QuantumClifford.nqubits(state2) "States must have the same number of qubits"
34 +
35 + stab1 = QuantumClifford.stabilizerview(state1)
36 + destab2 = QuantumClifford.destabilizerview(state2)
37 +
38 + # Find the intersection of stabilizer groups:
39 + # A stabilizer from state1 is in the intersection if and only if
40 + # it commutes with ALL destabilizers of state2.
41 + # (If it anticommutes with any destabilizer, it's not in the stabilizer group of state2)
42 + intersection_indices = Int[]
43 + for i in 1:length(stab1)
44 + in_intersection = true
45 + for j in 1:length(destab2)
46 + if QuantumClifford.comm(stab1, i, destab2, j) != 0x0
47 + in_intersection = false
48 + break
49 + end
50 + end
51 + if in_intersection
52 + push!(intersection_indices, i)
53 + end
54 + end
55 +
56 + # If intersection is empty, we need to check if the states have any overlap
57 + # For maximally mixed states or states with no common stabilizers,
58 + # the overlap is 2^0 / 2^n = 1/2^n if phases match (trivially true for empty intersection)
59 + intersection_size = length(intersection_indices)
60 +
61 + # For each stabilizer in the intersection, check that the phase matches in state2
62 + for idx in intersection_indices
63 + pauli = stab1[idx]
64 + # Project a copy of state2 onto this stabilizer to get its phase
65 + state2_copy = copy(state2)
66 + _, anticom_idx, result = QuantumClifford.project!(state2_copy, pauli)
67 +
68 + # If anticom_idx != 0, the stabilizer anticommutes with something in state2,
69 + # which shouldn't happen for stabilizers in the intersection
70 + if anticom_idx != 0
71 + # This means pauli is not in the stabilizer group of state2
72 + # (it anticommutes with some logical or the state changed)
73 + return 0.0
74 + end
75 +
76 + # result contains the phase: 0x00 for +1, 0x02 for -1
77 + # The stabilizer in state1 has the phase encoded in pauli.phase[]
78 + # We need to check if they match
79 + if result != pauli.phase[]
80 + return 0.0
81 + end
82 + end
83 +
84 + # All phases match, compute the inner product
85 + # |⟨state1|state2⟩|² = 2^intersection_size / 2^n
86 + # ⟨state1|state2⟩ = 2^(intersection_size/2) / 2^(n/2) = 2^((intersection_size - n)/2)
87 + return exp2((intersection_size - n) / 2)
88 end
● Wait, I need to reconsider the comm function signature. Let me check how to properly call it when comparing rows from two different tableaus:
● Search(pattern: "function comm\(", path: "QuantumClifford.jl", output_mode: "content")
⎿ Found 23 lines (ctrl+o to expand)
● I see the issue - the comm function with two tableaus and two indices only works for a single tableau. For two different tableaus, I need to extract the Pauli
operators and compare them directly. Let me also check how to get a PauliOperator from a Stabilizer view:
● Search(pattern: "getindex.*Stabilizer", path: "QuantumClifford.jl", output_mode: "content")
⎿ Found 7 lines (ctrl+o to expand)
● Now let me check what tab(stab)[i] returns:
● Search(pattern: "getindex.*Tableau.*Int\)", path: "QuantumClifford.jl", output_mode: "content")
⎿ Found 14 lines (ctrl+o to expand)
● So stab[i] returns a PauliOperator. This means my code calling stab1[idx] is correct, but my comm(stab1, i, destab2, j) call is wrong. I need to fix that. Looking
at the comm signatures:
- comm(l::PauliOperator, r::PauliOperator) - works for two PauliOperators
- comm(l::PauliOperator, r::Tableau, i::Int) - works for a PauliOperator and a row of a Tableau
- comm(l::Tableau, r::PauliOperator, i::Int) - works for a row of a Tableau and a PauliOperator
Let me fix the implementation:
● Update(QuantumSavory.jl/src/backends/clifford/should_upstream.jl)
⎿ Updated QuantumSavory.jl/src/backends/clifford/should_upstream.jl with 2 additions and 1 removal
41 # (If it anticommutes with any destabilizer, it's not in the stabilizer group of state2)
42 intersection_indices = Int[]
43 for i in 1:length(stab1)
44 + pauli_i = stab1[i]
45 in_intersection = true
46 for j in 1:length(destab2)
47 - if QuantumClifford.comm(stab1, i, destab2, j) != 0x0
47 + if QuantumClifford.comm(pauli_i, destab2, j) != 0x0
48 in_intersection = false
49 break
50 end
● Now I realize there's another issue. The comm function for (PauliOperator, Tableau, Int) requires the second argument to be a Tableau, but destab2 is a Stabilizer
(a view). Let me check if Stabilizer has a tab function:
● Search(pattern: "^tab\(.*Stabilizer", path: "QuantumClifford.jl", output_mode: "content")
⎿ Found 2 lines (ctrl+o to expand)
● Let me check what stabilizerview actually returns - it wraps the view in a Stabilizer:
● Read(QuantumClifford.jl/src/QuantumClifford.jl)
⎿ Read 30 lines
● I see - Stabilizer has a tab field. So I can use tab(destab2) to get the underlying Tableau. Let me update the code:
● Update(QuantumSavory.jl/src/backends/clifford/should_upstream.jl)
⎿ Updated QuantumSavory.jl/src/backends/clifford/should_upstream.jl with 2 additions and 1 removal
40 # it commutes with ALL destabilizers of state2.
41 # (If it anticommutes with any destabilizer, it's not in the stabilizer group of state2)
42 intersection_indices = Int[]
43 + destab2_tab = QuantumClifford.tab(destab2)
44 for i in 1:length(stab1)
45 pauli_i = stab1[i]
46 in_intersection = true
47 for j in 1:length(destab2)
48 - if QuantumClifford.comm(pauli_i, destab2, j) != 0x0
48 + if QuantumClifford.comm(pauli_i, destab2_tab, j) != 0x0
49 in_intersection = false
50 break
51 end
● Now let me read the current full implementation to review it:
● Read(QuantumSavory.jl/src/backends/clifford/should_upstream.jl)
⎿ Read 91 lines
● The implementation looks good, but I want to verify my understanding of the formula. Let me reconsider the mathematics:
For the inner product between two stabilizer states:
- If states are orthogonal (different eigenvalues for some shared stabilizer), the inner product is 0
- If they have the same eigenvalues for all shared stabilizers, the inner product is 2^(k/2) / 2^(n/2) where k is the dimension of the intersection of stabilizer
groups
Wait, I need to reconsider. Looking at your description again:
the dot product is 2^size_of_intersection_generating_set/2^number_of_qubits
This suggests the formula is 2^k / 2^n where k is the size of the intersection generating set. Let me fix this:
● Update(QuantumSavory.jl/src/backends/clifford/should_upstream.jl)
⎿ Updated QuantumSavory.jl/src/backends/clifford/should_upstream.jl with 2 additions and 3 removals
84 end
85
86 # All phases match, compute the inner product
87 - # |⟨state1|state2⟩|² = 2^intersection_size / 2^n
88 - # ⟨state1|state2⟩ = 2^(intersection_size/2) / 2^(n/2) = 2^((intersection_size - n)/2)
89 - return exp2((intersection_size - n) / 2)
87 + # ⟨state1|state2⟩ = 2^intersection_size / 2^n = 2^(intersection_size - n)
88 + return exp2(intersection_size - n)
89 end
● Let me verify this implementation works by testing it with a simple example. First, let me check how to instantiate the environment:
● Bash(ls -la)
⎿ total 11556
drwxrwxr-x 1 stefan stefan 3542 Dec 8 23:31 .
drwxr-xr-x 1 stefan stefan 6594 Nov 30 16:56 ..
… +99 lines (ctrl+o to expand)
● Bash(julia --project=. -e '
using QuantumClifford…)
⎿ Test 1: Same pure state
Result: 0.25 (expected: 1.0)
… +8 lines (ctrl+o to expand)
● The implementation is not working correctly. The intersection detection and phase matching logic have bugs. Let me debug this step by step:
● Bash(julia --project=. -e '
using QuantumClifford…)
⎿ Debug: |00> vs |00>
stab1:
1: + Z_
… +23 lines (ctrl+o to expand)
● I see! The issue is that each stabilizer of state1 anticommutes with exactly one destabilizer of state2 (its paired destabilizer). This is expected because
stabilizers and their corresponding destabilizers form conjugate pairs that anticommute.
The key insight is that I misunderstood the algorithm. The condition for a stabilizer from state1 to be in the intersection is NOT that it commutes with all
destabilizers of state2. Instead:
- A stabilizer S from state1 is in the stabilizer group of state2 if and only if S commutes with ALL stabilizers of state2.
- The destabilizers are used differently - if a Pauli P anticommutes with some destabilizer D_i of state2, it means P is a product of the corresponding stabilizer
S_i and other terms.
Let me reconsider the algorithm:
● Bash(julia --project=. -e '
using QuantumClifford…)
⎿ Debug: |00> vs |00>
Projecting stabilizers of s1 onto s2:
… +11 lines (ctrl+o to expand)
● Bash(julia --project=. -e '
using QuantumClifford…)
⎿ Debug: |00> vs |00>
Projecting stabilizers of s1 onto s2:
… +13 lines (ctrl+o to expand)
● Search(pattern: "^export.*project", path: "QuantumClifford.jl", output_mode: "content")
⎿ Found 0 lines
● Search(pattern: "export.*project", path: "QuantumClifford.jl", output_mode: "content")
⎿ Found 3 lines (ctrl+o to expand)
● Search(pattern: "^export", path: "QuantumClifford.jl/src/QuantumClifford.jl", output_mode: "content")
⎿ Found 31 lines (ctrl+o to expand)
● project! is exported. Let me check what the issue is:
● Bash(julia --project=. -e '
using QuantumClifford…)
⎿ [:project!, :projectX!, :projectXrand!, :projectY!, :projectYrand!, :projectZ!, :projectZrand!, :projectrand!]
● Bash(julia --project=. -e '
using QuantumClifford…)
⎿ Debug: |00> vs |00>
Projecting stabilizers of s1 onto s2:
… +11 lines (ctrl+o to expand)
● The error message says project not project!. Let me check more carefully:
● Bash(julia --project=. -e '
using QuantumClifford…)
⎿ Error: Exit code 1
ERROR: LoadError: UndefVarError: `@which` not defined in `Main`
Suggestion: check for spelling errors or missing imports.
Hint: a global variable of this name also exists in InteractiveUtils.
Stacktrace:
[1] eval(m::Module, e::Any)
@ Core ./boot.jl:489
[2] exec_options(opts::Base.JLOptions)
@ Base ./client.jl:283
[3] _start()
… +2 lines (ctrl+o to see all)
● Bash(julia --project=. -e '
using QuantumClifford…)
⎿ project!(state, pauli::PauliOperator; keep_result, phases) @ QuantumClifford ~/Documents/ScratchSpace/quantumjulia/QuantumClifford.jl/src/project_trace_reset.jl:
231
● Bash(julia --project=. -e '
using QuantumClifford…)
⎿ pauli = + Z_
result = (MixedDestablizer 2×2, 0, 0x00)
● It works when run directly. There might be an issue with the way the earlier test was structured. Let me run the test more carefully:
● Bash(julia --project=. -e '
using QuantumClifford…)
⎿ Debug: |00> vs |00>
Projecting stabilizers of s1 onto s2:
ERROR: UndefVarError: `project` not defined in `Main`
… +10 lines (ctrl+o to expand)
● Strange! The error says project not project!. Let me inspect this more:
● Bash(julia --project=. -e '
using QuantumClifford…)
⎿ Testing direct call:
pauli = + Z_
result = (MixedDestablizer 2×2, 0, 0x00)
… +3 lines (ctrl+o to expand)
● So it works in a loop! Let me compare the scripts more carefully to find the difference. The issue might be in how the multi-line string is being parsed:
● Bash(cat << 'SCRIPT' > /tmp/test_project.jl
using QuantumClifford…)
⎿ Debug: |00> vs |00>
Projecting stabilizers of s1 onto s2:
stab1[1] = + Z_
… +10 lines (ctrl+o to expand)
● Now I can see the behavior clearly:
- For |00> vs |00>: Both stabilizers project to phase 0 (matching the pauli phase 0), so all phases match
- For |00> vs |01>: The first stabilizer +ZI matches (result=0, pauli.phase=0), but the second stabilizer +IZ returns result=2 (which is -1 phase in the state4's
representation, since state4 has -IZ as a stabilizer)
So the algorithm should work, but the issue is in my implementation. The result 0x00 for +1 needs to match pauli.phase[] == 0, and 0x02 for -1 needs to match
pauli.phase[] == 2. Let me verify the mapping:
● Bash(julia --project=. -e '
using QuantumClifford…)
⎿ P+ZI phase: 0
P-ZI phase: 2
P+iZI phase: 1
P-iZI phase: 3
● So phases are:
- 0x00 = +1
- 0x01 = +i
- 0x02 = -1
- 0x03 = -i
This matches what the project! function returns. Now let me understand why my original test failed. The issue is that all stabilizers in s1 exist in s2 with the
same phases, so the intersection size equals the rank of the state (which is 2 for a 2-qubit pure state), and the formula should give 2^(2-2) = 1.
But wait, I was also checking for anticommutation with destabilizers incorrectly. Let me re-read the user's specification:
To compute it, you first need to find the intersection between the stabilizing groups. You can do that by checking whether each entry of stabilizerview(state1) has
an anticommuting partner in destabilizerview(state2). Keep only these overlap entries.
This is the opposite of what I implemented! The user says to keep entries that have an anticommuting partner, not those that don't. Let me think about this again...
Actually, I believe the user's specification might have the logic inverted. Here's the mathematical reasoning:
- A Pauli P is in the stabilizer group of state2 if and only if P commutes with all stabilizers of state2.
- The destabilizers are the conjugate operators. If P anticommutes with destabilizer D_i, then P contains the corresponding stabilizer S_i as a factor.
The standard algorithm for stabilizer inner products says:
- A stabilizer of state1 is in the intersection (stabilizer group of both states) if it commutes with all stabilizers of state2.
But the user's description says to check destabilizers instead. Let me re-read more carefully:
checking whether each entry of stabilizerview(state1) has an anticommuting partner in destabilizerview(state2)
This is checking if a stabilizer from state1 anticommutes with ANY destabilizer from state2. If it does, then it has a "partner" and should be kept.
Wait, I think I see the logic now: In a MixedDestabilizer, the stabilizers and destabilizers are arranged such that S_i anticommutes with D_i but commutes with all
other D_j for j != i. So if a Pauli P from state1 anticommutes with exactly one destabilizer D_k from state2, then P can be written as a product involving S_k from
state2.
Actually, for the inner product, we need to find which stabilizers of state1 are ALSO stabilizers of state2. A stabilizer from state1 is a stabilizer of state2 if
and only if it is in the group generated by stabilizerview(state2).
Let me think about this differently: In the MixedDestabilizer formalism, each stabilizer S_i has a unique destabilizer D_i such that comm(S_i, D_i) = 1 and
comm(S_i, D_j) = 0 for j != i. This is the dual basis property.
If a Pauli P commutes with all destabilizers of state2, then P is in the centralizer of the destabilizers, which (for stabilizer states) means P is in the
stabilizer group or identity.
Actually, let me re-read the user's statement once more:
You can do that by checking whether each entry of stabilizerview(state1) has an anticommuting partner in destabilizerview(state2). Keep only these overlap entries.
I think the user means: check if each stabilizer from state1 anticommutes with exactly one destabilizer from state2 (as opposed to zero or multiple). Those that
anticommute with exactly one are the ones that are "overlap" entries.
But wait, in my test with |00> vs |00>, each stabilizer +ZI and +IZ anticommutes with exactly one destabilizer (+XI and +IX respectively). So they should all be
kept, giving intersection size = 2, which should give inner product 1.
Let me re-examine my original implementation issue. The test showed 0.25 instead of 1.0, meaning intersection_size = 0. Let me check why:
● Bash(cat << 'SCRIPT' > /tmp/test_intersection.jl
using QuantumClifford…)
⎿ stab1:
1: + Z_
2: + _Z
… +12 lines (ctrl+o to expand)
● So both stabilizers have anticommuting partners. According to the user's specification, we should keep these. My original implementation was inverted - I was
keeping stabilizers that commuted with ALL destabilizers (which would be 0 in this case).
Let me fix the implementation to match the user's specification:
● Update(QuantumSavory.jl/src/backends/clifford/should_upstream.jl)
⎿ Updated QuantumSavory.jl/src/backends/clifford/should_upstream.jl with 8 additions and 5 removals
37
38 # Find the intersection of stabilizer groups:
39 # A stabilizer from state1 is in the intersection if and only if
40 - # it commutes with ALL destabilizers of state2.
41 - # (If it anticommutes with any destabilizer, it's not in the stabilizer group of state2)
40 + # it has an anticommuting partner in destabilizerview(state2).
41 + # This is because the destabilizers form a dual basis to the stabilizers:
42 + # each stabilizer S_i anticommutes with exactly its paired destabilizer D_i.
43 + # If a stabilizer from state1 has such a partner in state2's destabilizers,
44 + # it means that stabilizer is also in state2's stabilizer group.
45 intersection_indices = Int[]
46 destab2_tab = QuantumClifford.tab(destab2)
47 for i in 1:length(stab1)
48 pauli_i = stab1[i]
49 - in_intersection = true
49 + has_anticommuting_partner = false
50 for j in 1:length(destab2)
51 if QuantumClifford.comm(pauli_i, destab2_tab, j) != 0x0
52 - in_intersection = false
52 + has_anticommuting_partner = true
53 break
54 end
55 end
56 - if in_intersection
56 + if has_anticommuting_partner
57 push!(intersection_indices, i)
58 end
59 end
● Now let me test again:
● Bash(cat << 'SCRIPT' > /tmp/test_inner_product.jl
using QuantumClifford…)
⎿ Error: Exit code 1
ERROR: LoadError: SystemError: opening file "/tmp/QuantumSavory.jl/src/backends/clifford/should_upstream.jl": No such file or directory
Stacktrace:
[1] include(mapexpr::Function, mod::Module, _path::String)
@ Base ./Base.jl:307
[2] top-level scope
@ /tmp/test_inner_product.jl:3
[3] include(mod::Module, _path::String)
@ Base ./Base.jl:306
[4] exec_options(opts::Base.JLOptions)
… +4 lines (ctrl+o to see all)
● Bash(cat << 'SCRIPT' > /tmp/test_inner_product.jl
using QuantumClifford…)
⎿ Test 1: Same pure state |00>
Result: 1.0 (expected: 1.0)
… +11 lines (ctrl+o to expand)
● All tests pass. Let me add a few more tests to verify edge cases like mixed states:
● Bash(cat << 'SCRIPT' > /tmp/test_inner_product_more.jl
using QuantumClifford…)
⎿ Test 6: |0> vs maximally mixed single qubit
Pure state: 𝒟ℯ𝓈𝓉𝒶𝒷
+ X
… +38 lines (ctrl+o to expand)
● Interesting - there are some discrepancies:
- Test 8: Got 0.5, expected 0.707...
- Test 9: Got 0.5, expected 0.707...
- Test 10: Got 0.25, expected 0.5
Let me debug Test 8 to understand what's happening:
● Bash(cat << 'SCRIPT' > /tmp/debug_test8.jl
using QuantumClifford…)
⎿ Debug Test 8: |+0> vs |00>
state_plus0:
𝒟ℯ𝓈𝓉𝒶𝒷
… +29 lines (ctrl+o to expand)
● I see the issue now. The stabilizer +XI of |+0> does NOT have an anticommuting partner in the destabilizers of |00> because:
- destab2[1] = +XI and comm(+XI, +XI) = 0 (they commute)
- destab2[2] = +IX and comm(+XI, +IX) = 0 (they commute)
So +XI is NOT in the intersection according to this criterion. Only +IZ (which anticommutes with +IX) is in the intersection, giving intersection_size = 1.
But wait - +XI should NOT be a stabilizer of |00>. The state |00> is stabilized by +ZI and +IZ, not +XI. And indeed, +XI does NOT stabilize |00> because X|0> = |1>.
So the algorithm correctly determines that +XI is not in the intersection.
Now the formula: intersection_size = 1, n = 2, so inner product = 2^(1-2) = 0.5. But the actual inner product <+0|00> = 1/√2 ≈ 0.707.
This suggests the formula is wrong. Let me reconsider:
The inner product between stabilizer states is related to the overlap of their stabilizer groups, but the formula should be:
<ψ₁|ψ₂>² = 2^k / 2^n where k is the dimension of intersection
So <ψ₁|ψ₂> = 2^(k/2) / 2^(n/2) = 2^((k-n)/2)
For Test 8: k=1, n=2, so <ψ₁|ψ₂> = 2^((1-2)/2) = 2^(-0.5) = 1/√2 ✓
But the user's formula says 2^k / 2^n not (2^k / 2^n)^(1/2). Let me re-read the user's specification:
If all phases match, then the dot product is 2^size_of_intersection_generating_set/2^number_of_qubits.
So the user says the result is 2^k / 2^n. But for pure states with the same stabilizers (k=n), this gives 1, which is correct. For k=1, n=2, this gives 0.5.
Let me verify what the actual inner product should be using a different method:
● Bash(cat << 'SCRIPT' > /tmp/verify_inner_product.jl
using QuantumClifford…)
⎿ Test 8: <+0|00>
<+|0> = (1/√2)(⟨0| + ⟨1|)|0⟩ = (1/√2)(1 + 0) = 1/√2
<0|0> = 1
… +9 lines (ctrl+o to expand)
● My results are consistent with the squared inner products, not the inner products themselves. Looking at:
- Test 8: I got 0.5, which equals |<+0|00>|² = 0.5
- Test 10: I got 0.25, which equals |<++|00>|² = 0.25
So the function is computing |⟨ψ₁|ψ₂⟩|² (the probability overlap), not ⟨ψ₁|ψ₂⟩.
Given the user's formula 2^k / 2^n, this gives the squared magnitude. For pure states with same stabilizers (k=n), we get 2^n / 2^n = 1, which is |⟨ψ|ψ⟩|² = 1 ✓.
I think the user's formula is correct and my implementation matches it. The result is the squared overlap (or equivalently, the fidelity for pure states). Let me
update the docstring to clarify this:
● Update(QuantumSavory.jl/src/backends/clifford/should_upstream.jl)
⎿ Updated QuantumSavory.jl/src/backends/clifford/should_upstream.jl with 8 additions and 7 removals
14
15
16 """
17 - Compute the inner product ⟨state1|state2⟩ between two MixedDestabilizer states.
17 + Compute the squared overlap |⟨state1|state2⟩|² between two MixedDestabilizer states.
18
19 The algorithm works by finding the intersection of the stabilizer groups of the two states:
20 1. For each stabilizer generator of state1, check if it has an anticommuting partner
21 - in the destabilizers of state2. If it does, that stabilizer is NOT in the intersection.
22 - 2. Keep only the stabilizers from state1 that commute with all destabilizers of state2
21 + in the destabilizers of state2. If it does, that stabilizer IS in the intersection
22 + (because it corresponds to a stabilizer in state2's group).
23 + 2. Keep only the stabilizers from state1 that have such an anticommuting partner
24 (i.e., those that are in the intersection of both stabilizer groups).
25 3. For each stabilizer in the intersection, verify that it has the same phase in both states
26 - using the project! function. If any phases differ, the inner product is zero.
27 - 4. If all phases match, the inner product is 2^(size of intersection) / 2^(number of qubits).
26 + using the project! function. If any phases differ, the overlap is zero.
27 + 4. If all phases match, the squared overlap is 2^(size of intersection) / 2^(number of qubits).
28
29 - Returns a real number (the inner product can be complex in general, but for stabilizer
30 - states it is always real and non-negative when both states are properly normalized).
29 + Returns a real number in [0, 1]: the squared magnitude of the inner product.
30 + For pure stabilizer states, this equals the fidelity between the states.
31 """
32 function inner_product_mixed_destab(state1::QuantumClifford.MixedDestabilizer, state2::QuantumClifford.MixedDestabilizer)
33 n = QuantumClifford.nqubits(state1)
● Now let me run all the tests again to confirm everything works correctly:
● Bash(cat << 'SCRIPT' > /tmp/test_final.jl
using QuantumClifford…)
⎿ ✓ Same pure state |00>: got 1.0, expected 1.0
✓ |00> vs |01> (orthogonal): got 0.0, expected 0.0
✓ Bell state |Φ+> vs itself: got 1.0, expected 1.0
… +8 lines (ctrl+o to expand)
● All tests pass. Let me also add a test for mixed states to ensure the implementation handles those correctly:
● Bash(cat << 'SCRIPT' > /tmp/test_mixed.jl
using QuantumClifford…)
⎿ Testing with mixed states:
Test: Pure state vs rank-1 mixed state
… +23 lines (ctrl+o to expand)
● The implementation handles mixed states as well. Let me show the final implementation:
● Read(QuantumSavory.jl/src/backends/clifford/should_upstream.jl)
⎿ Read 94 lines
● The implementation is complete. Here's a summary of what was implemented:
Summary
I implemented inner_product_mixed_destab(state1, state2) which computes the squared overlap |⟨state1|state2⟩|² between two MixedDestabilizer states.
Algorithm:
1. Find intersection of stabilizer groups: For each stabilizer generator of state1, check if it has an anticommuting partner in destabilizerview(state2). If it
does, that stabilizer is in the intersection (because it corresponds to a stabilizer in state2's group).
2. Phase matching: For each stabilizer in the intersection, use project! to verify that it has the same phase in both states. If any phases differ, return 0.
3. Compute overlap: If all phases match, return 2^(intersection_size - n) where n is the number of qubits.
Test results:
- Same pure states → 1.0 ✓
- Orthogonal pure states → 0.0 ✓
- Bell states (same) → 1.0 ✓
- Bell states (orthogonal) → 0.0 ✓
- GHZ state vs itself → 1.0 ✓
- Partial overlaps (|+0> vs |00>) → 0.5 ✓
- No stabilizer overlap (|++> vs |00>) → 0.25 ✓
- Mixed states work correctly ✓
"""
Compute the squared overlap |⟨state1|state2⟩|² between two MixedDestabilizer states.
The algorithm works by finding the intersection of the stabilizer groups of the two states:
1. For each stabilizer generator of state1, check if it has an anticommuting partner
in the destabilizers of state2. If it does, that stabilizer IS in the intersection
(because it corresponds to a stabilizer in state2's group).
2. Keep only the stabilizers from state1 that have such an anticommuting partner
(i.e., those that are in the intersection of both stabilizer groups).
3. For each stabilizer in the intersection, verify that it has the same phase in both states
using the project! function. If any phases differ, the overlap is zero.
4. If all phases match, the squared overlap is 2^(size of intersection) / 2^(number of qubits).
Returns a real number in [0, 1]: the squared magnitude of the inner product.
For pure stabilizer states, this equals the fidelity between the states.
"""
function inner_product_mixed_destab(state1::QuantumClifford.MixedDestabilizer, state2::QuantumClifford.MixedDestabilizer)
n = QuantumClifford.nqubits(state1)
@assert n == QuantumClifford.nqubits(state2) "States must have the same number of qubits"
stab1 = QuantumClifford.stabilizerview(state1)
destab2 = QuantumClifford.destabilizerview(state2)
# Find the intersection of stabilizer groups:
# A stabilizer from state1 is in the intersection if and only if
# it has an anticommuting partner in destabilizerview(state2).
# This is because the destabilizers form a dual basis to the stabilizers:
# each stabilizer S_i anticommutes with exactly its paired destabilizer D_i.
# If a stabilizer from state1 has such a partner in state2's destabilizers,
# it means that stabilizer is also in state2's stabilizer group.
intersection_indices = Int[]
destab2_tab = QuantumClifford.tab(destab2)
for i in 1:length(stab1)
pauli_i = stab1[i]
has_anticommuting_partner = false
for j in 1:length(destab2)
if QuantumClifford.comm(pauli_i, destab2_tab, j) != 0x0
has_anticommuting_partner = true
break
end
end
if has_anticommuting_partner
push!(intersection_indices, i)
end
end
# If intersection is empty, we need to check if the states have any overlap
# For maximally mixed states or states with no common stabilizers,
# the overlap is 2^0 / 2^n = 1/2^n if phases match (trivially true for empty intersection)
intersection_size = length(intersection_indices)
# For each stabilizer in the intersection, check that the phase matches in state2
for idx in intersection_indices
pauli = stab1[idx]
# Project a copy of state2 onto this stabilizer to get its phase
state2_copy = copy(state2)
_, anticom_idx, result = QuantumClifford.project!(state2_copy, pauli)
# If anticom_idx != 0, the stabilizer anticommutes with something in state2,
# which shouldn't happen for stabilizers in the intersection
if anticom_idx != 0
# This means pauli is not in the stabilizer group of state2
# (it anticommutes with some logical or the state changed)
return 0.0
end
# result contains the phase: 0x00 for +1, 0x02 for -1
# The stabilizer in state1 has the phase encoded in pauli.phase[]
# We need to check if they match
if result != pauli.phase[]
return 0.0
end
end
# All phases match, compute the inner product
# ⟨state1|state2⟩ = 2^intersection_size / 2^n = 2^(intersection_size - n)
return exp2(intersection_size - n)
end
#=
A bunch of tests to be upstreamed
# Test 6: Pure state vs maximally mixed (single qubit)
println("Test 6: |0> vs maximally mixed single qubit")
state_pure = MixedDestabilizer(S"+Z")
state_mixed = one(MixedDestabilizer, 0, 1) # rank=0, 1 qubit
println("Pure state: $state_pure")
println("Mixed state: $state_mixed")
result6 = inner_product_mixed_destab(state_pure, state_mixed)
println("Result: $result6 (expected: 1/sqrt(2) = 0.707...)")
# A maximally mixed state ρ = I/2, and <ψ|ρ|ψ> = 1/2 for any |ψ>
# But this is <ψ|φ>, not trace. Need to reconsider...
# Test 7: Partial overlap
println("\nTest 7: States with partial stabilizer overlap")
# |00> is stabilized by +ZI, +IZ
# A mixed state stabilized only by +ZZ has rank 1
state_00 = MixedDestabilizer(S"+ZI +IZ")
state_partial = one(MixedDestabilizer, 1, 2)
println("state_00: ")
println(state_00)
println("state_partial (rank 1 on 2 qubits, just +ZI):")
# Need to construct a proper rank-1 state
state_rank1 = MixedDestabilizer(Destabilizer(S"+XI +IZ"), 1)
println(state_rank1)
# Actually let me test differently - test two states that share some but not all stabilizers
println("\nTest 8: |+0> vs |00>")
# |+0> is stabilized by +XI, +IZ
# |00> is stabilized by +ZI, +IZ
# They share +IZ, so intersection has size 1
# Inner product should be <+0|00> = (1/√2)(<0| + <1|)|00> = 1/√2 = 0.707...
state_plus0 = MixedDestabilizer(S"+XI +IZ")
state_00_2 = MixedDestabilizer(S"+ZI +IZ")
result8 = inner_product_mixed_destab(state_plus0, state_00_2)
println("Result: $result8 (expected: 1/√2 = $(1/sqrt(2)))")
println("\nTest 9: |+0> vs |10>")
# |+0> is stabilized by +XI, +IZ
# |10> is stabilized by -ZI, +IZ
# They share +IZ, so intersection has size 1
# Phase check: +IZ has same phase in both (0x00)
# Inner product should be <+0|10> = (1/√2)(<0| + <1|)|10> = 1/√2
state_plus0_2 = MixedDestabilizer(S"+XI +IZ")
state_10 = MixedDestabilizer(S"-ZI +IZ")
result9 = inner_product_mixed_destab(state_plus0_2, state_10)
println("Result: $result9 (expected: 1/√2 = $(1/sqrt(2)))")
println("\nTest 10: |++> vs |00>")
# |++> is stabilized by +XI, +IX
# |00> is stabilized by +ZI, +IZ
# Intersection should be empty (no common stabilizers)
state_plusplus = MixedDestabilizer(S"+XI +IX")
state_00_3 = MixedDestabilizer(S"+ZI +IZ")
result10 = inner_product_mixed_destab(state_plusplus, state_00_3)
println("Result: $result10 (expected: 1/2 = 0.5)")
# <++|00> = <+|0> * <+|0> = (1/√2) * (1/√2) = 1/2
=#
Codex's work
• I'm preparing to inspect the repository to identify the necessary file for implementation.
• Explored
└ List ls
List QuantumSavory.jl
Read another_attempt.jl
Search inner_product_mixed_destab
Read should_upstream.jl
• I'm considering checking the QC library for functions related to inner product or other states to inform implementing a similar feature.
• Explored
└ Search inner_product in QuantumSavory.jl
• I'm preparing to inspect the MixedDestabilizer structure within the QuantumClifford package to understand how to use its functions effectively.
• Explored
└ Search struct MixedDestabilizer in QuantumClifford.jl
List QuantumClifford.jl
Search MixedDestabilizer in QuantumClifford.jl
• Considering QuantumClifford/test/test_inner as the probable location for inner product tests to check implementation details.
• Explored
└ Read test_inner.jl
Search logdot in QuantumClifford.jl
Read linalg.jl
• I'm establishing that computing the inner product involves identifying stabilizer generators in one state that have anticommuting partners in the other's destabilizer
set, then confirming matching phases via projection; this suggests a new method must handle these checks using MixedDestabilizer's structure and appropriate functions.
• I'm looking for existing functions to check anticommutation between Pauli operators in the stabilizer context to translate the given formula into code efficiently.
• Explored
└ Search anticomm in QuantumClifford.jl
• I'm inspecting the QuantumClifford.jl source near line 768 to identify any existing communication-related functions that might be useful.
• Explored
└ Read QuantumClifford.jl
• I'm verifying the project! function used in the MixedDestab project within project_trace_reset, aiming to confirm if it returns (state, anticommutes, result) or similar
based on parameters like state and pauli. I'll inspect its definition near line 337 next.
• Explored
└ Read project_trace_reset.jl
• I'm verifying how to find the intersection of stabilizer groups by checking if each stabilizer from one state has an anticommuting partner in the other's destabilizer
set, confirming that destabilizers uniquely anticommute with their paired stabilizers to identify overlaps correctly.
• The anticommutation with a destabilizer row can indicate a stabilizer generator's presence in another state's stabilizer group, but this alone isn't conclusive. To
confirm membership, phases must be verified by projecting the second state onto the stabilizer operator with phase; mismatched phases imply zero overlap, while matching
phases determine the exact inner product scaling.
• I’m analyzing how the project! method returns phase values as measurement outcomes, interpreting phase 0 as +1 and phase 2 as -1 for commuting operators, which affects
how measurement results are checked for sign matching in the stabilizer intersection.
• Explored
└ Search project! in docs
Read stab-algebra-manual.md
• I'm noting the need for a page documenting the data structures referenced by the table for clarity and implementation guidance.
• Explored
└ Read datastructures.md
• The plan is to verify stabilizer phases by projecting with each generator onto the other state, comparing measurement results (0 or 2) representing phase agreement
or difference; phases are stored as UInt8 values and measurement uses anticommutation relations to produce these results, indicating if generator signs match across
states.
• I'm examining how the measurement result encodes the phase for stabilizer generators, noting that commuting measurements can return nonzero results representing phase
shifts. The example shows project! returning a phase-indicative result rather than zero, suggesting the need to compare measurement outcome phases with the Pauli phases
to confirm stabilization properly. Next, I'll verify this behavior with simpler cases to clarify the phase encoding.
• I'm clarifying how projecting one state's stabilizer generator onto another state reveals sign agreement via measurement results, focusing on interpreting the returned
phase and anticommutation indices to distinguish matching or differing eigenvalue signs.
• I'm clarifying that projecting state2 with a Pauli operator from state1 (including phase) should yield a measurement result of 0 if phases match, confirming
stabilization in the same phase; opposite signs yield results like 2. Next, I'll verify this by examining the relevant code and possibly running a minimal test in Julia
to confirm the expected behavior.
• Measurement result corresponds to the relative phase between the operator's stabilizer and the state's stabilizer; a result of 0 means consistent +1 eigenvalue, while 2
indicates an effective -1 eigenvalue, helping to check phase consistency between states via projection.
• Determined that measurement result equals zero indicates matching phases between stabilizer generators, while a nonzero result signals a phase mismatch—this aligns with
example results where projecting a positive-phase operator on a state stabilized by a negative-phase operator yields a nonzero result.
• I'm confirming that measurement result zero indicates matching stabilizer phases even if generators have negative phases, using phase arithmetic on Pauli operators.
This justifies checking result==0 for stabilizer overlap when implementing the mixed destabilizer inner product function next.
• Explored
└ List clifford
Read clifford.jl
• The file another_attempt.jl appears not included or used currently, though the user requested implementing it. I'll check uptotime.jl for similar functions and decide
how to integrate or include another_attempt.jl properly.
• Explored
└ Read uptotime.jl
• I'm verifying whether key functions require explicit QuantumClifford qualification or using statements within the current module, and planning to check the main entry
file to confirm module context and proper namespace usage.
• Explored
└ Read QuantumSavory.jl
• I mapped out the algorithm to compute the inner product using QuantumClifford functions, clarifying how to access PauliOperators via stabilizer views and the correct
signature for the commutation check. Next, I'll handle extracting PauliOperators and verifying anticommutation as required.
• I'm weighing copying state2 for each projector call to avoid mutation conflicts versus doing a single mutable copy, leaning toward per-op copies for safer, independent
phase checks despite higher cost.
• I've identified that when measuring operators against stabilizers, a result of nothing or a nonzero phase result signals a mismatch, so the check should ensure the
measurement result is exactly zero. Also, the dot product formula aligns with 2^(size_of_intersection - number_of_qubits), representing the inner product magnitude.
• I'm verifying the formula for inner products of stabilizer states via the intersection size of their stabilizer groups, noting the formula yields exact 1 for identical
states but underestimates for non-identical pure states like |0> vs |+>, implying this method applies as given for MixedDestabilizer (possibly mixed) states per
instructions.
• I'm aligning with the user formula to count overlapping stabilizer generators between states as the intersection size, ensuring to handle dimension mismatches. I'll
implement the function to find these overlaps using the QuantumClifford PauliOperator type, confirm commutation, and apply phase checks exactly as specified.
• I'm confirming the need to enforce dimension matching between states, throwing DimensionMismatch if they differ, and ensuring use of fully qualified names for clarity.
Also planning to verify anticommutation via QuantumClifford.comm checks against destabilizer entries, handling indexing safely, and managing edge cases like empty
intersections and type exports.
• The project! function from QuantumClifford requires being called with its namespace prefix, so I'll import accordingly and ensure consistent usage while editing with
apply_patch.
• Edited ~/Documents/ScratchSpace/quantumjulia/QuantumSavory.jl/src/backends/clifford/another_attempt.jl (+26 -0)
1 function inner_product_mixed_destab(state1::QuantumClifford.MixedDestabilizer, state2::QuantumClifford.MixedDestabilizer)
2 + QuantumClifford.nqubits(state1) == QuantumClifford.nqubits(state2) || throw(DimensionMismatch("Inner product requires states with the same number of qubits.")
)
3 +
4 + stab1 = QuantumClifford.stabilizerview(state1)
5 + destab2 = QuantumClifford.destabilizerview(state2)
6 +
7 + overlap = QuantumClifford.PauliOperator[]
8 + for i in eachindex(stab1)
9 + op = stab1[i]
10 + has_partner = false
11 + for j in eachindex(destab2)
12 + if QuantumClifford.comm(op, destab2, j) != 0x0
13 + has_partner = true
14 + break
15 + end
16 + end
17 + has_partner && push!(overlap, op)
18 + end
19 +
20 + for op in overlap
21 + _, anticommutes, result = QuantumClifford.project!(copy(state2), op)
22 + if anticommutes != 0 || result === nothing || result != 0x00
23 + return 0.0
24 + end
25 + end
26 +
27 + 2.0^(length(overlap) - QuantumClifford.nqubits(state1))
28 end
• Checking the file to determine if running tests is needed before proceeding.
• Explored
└ Read another_attempt.jl
• Implemented the inner product logic in the specified file, ensuring phase check for anticommutes is included though it may be optional. This change involves copying
state2 each time, which could be heavy but is acceptable for now. No tests have been run yet for this update, so adding tests is a recommended next step.
─ Worked for 3m 23s ──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
• Implemented the MixedDestabilizer inner product logic in src/backends/clifford/another_attempt.jl: it now detects overlapping stabilizers via anticommuting partners in
the second state’s destabilizers, verifies phase alignment using project! on a copy of the second state, and returns 2^(|overlap|-n) or zero on mismatch.
I didn’t run tests; consider exercising any relevant inner-product checks in your suite.
› Find and fix a bug in @filename
function inner_product_mixed_destab(state1::QuantumClifford.MixedDestabilizer, state2::QuantumClifford.MixedDestabilizer)
QuantumClifford.nqubits(state1) == QuantumClifford.nqubits(state2) || throw(DimensionMismatch("Inner product requires states with the same number of qubits."))
stab1 = QuantumClifford.stabilizerview(state1)
destab2 = QuantumClifford.destabilizerview(state2)
overlap = QuantumClifford.PauliOperator[]
for i in eachindex(stab1)
op = stab1[i]
has_partner = false
for j in eachindex(destab2)
if QuantumClifford.comm(op, destab2, j) != 0x0
has_partner = true
break
end
end
has_partner && push!(overlap, op)
end
for op in overlap
_, anticommutes, result = QuantumClifford.project!(copy(state2), op)
if anticommutes != 0 || result === nothing || result != 0x00
return 0.0
end
end
2.0^(length(overlap) - QuantumClifford.nqubits(state1))
end