PHYS 130C

Part 2: Quantum Information Theory

From Classical to Quantum Information

Classical Probability

Random Variable and Probability

Only specifying the set 𝒳 of possible values is not enough to define a random variable, assigning the probability p(x) is essential.

Example: X= a random image of muffin. The following images are all possible, but not equally likely.

Probability assignment describes our current state of knowledge about the random variable. (It can be subjective.)

The probability assignment should be updated, if our knowledge has been changed by observations (providing new evidence).

Prior probability before observation

({{x, head, tail}, {p(x), (1/2), (1/2)}})

Posterior probability after observing head up.

({{x, head, tail}, {p(x), 1, 0}})

Positivity:

Normalization:

Expectation Value

⟨f(x)⟩=𝔼[f(X)]=(∑_(x∈𝒳))f(x) p(x).

Double expectation

𝔼[𝔼[X]]=𝔼[X].

Linearity (for two random variables X and Y and a constant α)

𝔼[X+Y]=𝔼[X]+𝔼[Y],
𝔼[α X]=α 𝔼[X].

More generally, for multiple random variables (Subscript[X, i]) (i=1,2,…) linearly combined together,

𝔼[(∑_i)(Subscript[α, i])(Subscript[X, i])]=(∑_i)(Subscript[α, i])𝔼[(Subscript[X, i])].

Information

Sample collection (encoding scheme)

DynamicModule[{n=3,w=2,h=3,a=0.22,lt=0.8,op=0.2,cols,pts,graph,adjmat,focus,highlight},
cols=<|9->Red,10->Green,11->Blue|>;
pts=Range[2^n+n];
graph=Graph[pts,Flatten[Table[i\[DirectedEdge]#&/@DeleteCases[IntegerDigits[i-1,2,n](2^n+Range[n]),0],{i,2^n}]],
VertexCoordinates->Join[Table[{x,0},{x,2^n}],Table[{w x+(2^n+1-w(n+1))/2,-h},{x,n}]]];
adjmat=AdjacencyMatrix[graph];
focus[i_]:=Subgraph[graph,Flatten[First/@Most@ArrayRules[(#+adjmat.#+Transpose[adjmat].#)&@SparseArray[{i->1},Length@pts]]]];
highlight=graph;
Deploy@Dynamic@EventHandler[Graph[graph,VertexShapeFunction->Function[{p,name,bb},EventHandler[#,"MouseMoved":>(highlight=focus[name])]&@{Opacity[If[MemberQ[VertexList[highlight],name],1,op]],If[name<=2^n,{{Black,Circle[p,a]},{Black,Text[name,p,{-0.2,0.2}]}},{Translate[{{EdgeForm[None],Lighter[cols[name],lt],Polygon[{{a,a},{-a,a},{-a,-a},{a,-a}}]},{Black,Line[{{a,a},{-a,a},{-a,-a},{a,-a},{a,a}}]}},p]}]}],
EdgeShapeFunction->Function[{ps,e},
Block[{p1,p2,k1,k2},{p1,p2}=ps;
k1=(Position[#,e[[2]]][[1,1]]-(1+Length@#)/2)&@Flatten[First/@Most@ArrayRules[adjmat[[e[[1]]]]]];k2=(Position[#,e[[1]]][[1,1]]-(1+Length@#)/2)&@Flatten[First/@Most@ArrayRules[adjmat[[All,e[[2]]]]]];
{Opacity[If[MemberQ[EdgeList[highlight],e],1,op]],Arrowheads[{{0.04,0.25}}],cols[e[[2]]],Arrow[BSplineCurve[{p1+{0.1k1,-a},p1+{0.1 k1,-h/2},p2+{0.1k2,h/2},p2+{0.1k2,a}}]]}]],ImageSize->220],"MouseClicked":>(highlight=graph)]
]

Test result analysis (decoding scheme)

DynamicModule[{n=3,a=0.15,b=0.15,lt=0.8,op=0.2,pts,layers,cols,graph,adjmat,focus,highlight},
pts=Range[2^(n+1)-1];layers=First/@Rest@FoldList[TakeDrop[Last@#1,2^#2]&,{{},pts},Range[n,0,-1]];
cols=<|1->White,2->Blue,3->Green,4->Red|>;
graph=Graph[pts,Flatten[Table[#2\[DirectedEdge]i,{i,#1}]&@@@Thread@{Partition[#1,2],#2}&@@@Thread@{Most@layers,Rest@layers}]];
adjmat=AdjacencyMatrix[graph];
focus[i_]:=Subgraph[graph,Flatten[First/@Most@ArrayRules@Sum[Total[NestWhileList[#.mat&,SparseArray[{i->1},Length@pts],Total[#]>0&]],{mat,{adjmat,Transpose@adjmat}}]]];
highlight=graph;
Deploy@Dynamic@EventHandler[Graph[graph,VertexShapeFunction->Function[{p,name,bb},EventHandler[#,"MouseMoved":>(highlight=focus[name])]&@{Opacity[If[MemberQ[VertexList[highlight],name],1,op]],If[Position[layers,name][[1,1]]==1,{{Black,Circle[p,a]},{Black,Text[name,p,{-0.2,0.2}]}},{Translate[{{EdgeForm[None],Lighter[cols[Position[layers,name][[1,1]]],lt],Polygon[{{a,b},{-a,b},{-a,-b},{a,-b}}]},{Black,Line[{{a,b},{-a,b},{-a,-b},{a,-b},{a,b}}]}},p],{Black,Text["?",p,{-0.2,0.3}]}}]}],
EdgeShapeFunction->Function[{ps,e},Block[{f},
f=BSplineFunction[ps];
EventHandler[#,"MouseMoved":>(highlight=focus[e[[2]]])]&@
{Opacity[If[MemberQ[EdgeList[highlight],e],1,op]],Black,Arrow[{f[0.2],f[0.8]}],cols[Position[layers,e[[1]]][[1,1]]],Text[If[OddQ[e[[2]]],"-","+"],f[0.5],{-(-1)^e[[2]],-0.5}]}]],ImageSize->220],"MouseClicked":>(highlight=graph)]]

Identify a unique outcome out of (2^n) equally-likely possibilities,

Collapse the probability from p=((((1/2)))^n) to p=1 for the observed outcome,

Provide n bits of information:

p=((((1/2)))^n)=>n=-(Subscript[log, 2])p=-((log p)/(log 2)).

log 2=1bit is treated as an information unit.

({{x, a, b, c, d}, {p(x), (1/2), (1/4), (1/8), (1/8)}}).

Information gain can be different for different observation outcomes

I(a)=-log(1/2)=log 2=1 bit,
I(b)=-log(1/4)=2log 2=2 bit,
I(c)=-log(1/8)=3 log 2=3 bit,
I(d)=-log(1/8)=3 log 2=3 bit.

However, different outcome happens with different probability. What is average amount of information that we can obtain from observing X (regardless of its outcome)?

I(X)=I(a)p(a)+I(b)p(b)+I(c)p(c)+I(d)p(d)
=(1×(1/2)+2×(1/4)+3×(1/8)+3×(1/8))bit
=1.75 bit.

Entropy

Entropy is always non-negative (follows from 0<=p(x)<=1)

S(X)=0 means the value of X is known for certain (no randomness).

Large S(X) indicates large uncertainty in X.

Entropy can be changed by observation, as observation can remove/reduce uncertainty from a random variable.

A binary random variable X (with 𝒳={false,true})

p(false)=1-p, 
p(true)=p,

where 0<=p<=1. Entropy of X

S(X)=-p log p-(1-p)log (1-p).

Plot[-(p Log[p]+(1-p)Log[1-p])/Log[2],{p,0,1},PlotStyle->Black,FrameLabel->{"\!\( p\)","\!\(S(X)\) [bit]"},GridLines->{{0.5},{0,1}},ImageSize->180]

S(X)=0 when p=0 (X=false for sure) or p=1 (X=true for sure).

S(X) is maximized at p=1/2, where X is most uncertain. The maximum entropy of a binary random variable is 1 bit.

Mutual Information

S(X)=-(∑_x)p(x) log p(x) is the entropy of X — the uncertainty in X regardless of Y, with p(x)=(∑_y)p(x,y) being the marginal distribution of X.

S(Y)=-(∑_y)p(y) log p(y) is the entropy of X — the uncertainty in Y regardless of X, with p(y)=(∑_x)p(x,y) being the marginal distribution of Y.

S(X,Y)=-(∑_(x,y))p(x,y)log p(x,y) is the joint entropy of X and Y — the uncertainty of the joint distribution.

I(X:Y)=S(X)-S(X|Y)=S(Y)-S(Y|X),

S(X|Y)=-(∑_(x,y))p(x,y)log p(x|y) is the conditional entropy of X given Y — the remaining uncertainty in X after knowing Y.

S(Y|X)=-(∑_(x,y))p(x,y)log p(y|x) is the conditional entropy of Y given X — the remaining uncertainty in Y after knowing X.

Show that S(X|Y)=S(X,Y)-S(Y) and S(Y|X)=S(X,Y)-S(X), therefore Eq. () is consistent with the definition in Eq. ().

p(x|y)=((p(x,y))/(p(y))),

S(X|Y)=-(∑_(x,y))p(x,y)log p(x|y)
=-(∑_(x,y))p(x,y)log ((p(x,y))/(p(y)))
=-(∑_(x,y))p(x,y)(log p(x,y)-log p(y))
=-(∑_(x,y))p(x,y)log p(x,y)+(∑_(x,y))p(x,y)log p(y)
=-(∑_(x,y))p(x,y)log p(x,y)+(∑_y)p(y)log p(y)
=S(X,Y)-S(Y),

If X and Y are independent, I(X:Y)=0.

If X and Y are perfectly correlated, I(X:Y) is maximized.

Non-negativity: I(X:Y)≥0,

Symmetry: I(X:Y)=I(Y:X).

({{p(x,y), , x, , p(y)}, {, , 0, 1, }, {y, 0, (1/2), 0, (1/2)}, {, 1, 0, (1/2), (1/2)}, {p(x), , (1/2), (1/2),  }})

S(X)=1bit, S(Y)=1bit, S(X,Y)=1bit,
I(X:Y)=(1+1-1)bit=1bit.

Quantum Density Matrix

Pure and Mixed States

Pure state: A pure state is described by a single state vector (Ket[ψ]), representing maximum knowledge about the system’s quantum state.

Mixed state: A mixed state describes a system in which we have only partial information, typically as a statistical mixture of pure states.

— Meaning that the state of the system will be randomly sampled from an ensemble of states ℰ={(Ket[(Subscript[ψ, 1])]),(Ket[(Subscript[ψ, 2])]),…}, with an assignment of a probability (Subscript[p, i]) to each state (Ket[(Subscript[ψ, i])])∈ℰ, describing the likelihood of the system to be in that state.

Density Matrix

For a pure state (Ket[ψ]), the corresponding density matrix is

which is also the projection operator of the state.

For a mixed state specified by a statistical ensemble of pure states {(Ket[(Subscript[ψ, i])])} with (Subscript[p, i]) being the probability of the system being in the pure state (Ket[(Subscript[ψ, i])]), the corresponding density matrix is

By properties of probability, (Subscript[p, i])>=0 and (∑_i)(Subscript[p, i])=1.

If (Subscript[p, i]) concentrate in one specific state, e.g. (Subscript[p, 1])=1 and (Subscript[p, 2])=(Subscript[p, 3])=…=0, then ρ=(Ket[(Subscript[ψ, 1])])(Bra[(Subscript[ψ, 1])]) reduces to a pure state. 
=> Pure state is a limit (ideal case) of mixed states.

Hermitian: (SuperDagger[ρ])=ρ.

Normalization (trace identity): Tr ρ=1.

Positive (semi)definite: ∀(Ket[ψ]):(Bra[ψ])ρ(Ket[ψ])≥0.

Verify that the mixed state density matrix in Eq. () indeed satisfies all the properties above.

Hermitian:

(SuperDagger[ρ])=(∑_i)(SuperDagger[(Subscript[p, i]^( * ))((Ket[(Subscript[ψ, i])])(Bra[(Subscript[ψ, i])]))])=(∑_i)(Subscript[p, i])(Ket[(Subscript[ψ, i])])(Bra[(Subscript[ψ, i])])=ρ.

Normalization:

Tr ρ=(∑_i)(Subscript[p, i])Tr((Ket[(Subscript[ψ, i])])(Bra[(Subscript[ψ, i])]))
=(∑_i)(Subscript[p, i])(BraKet[(Subscript[ψ, i]), (Subscript[ψ, i])])
=(∑_i)(Subscript[p, i])=1.

Positive (semi)definite: ∀(Ket[ψ])

(Bra[ψ])ρ(Ket[ψ])=(∑_i)(Subscript[p, i])(BraKet[ψ, (Subscript[ψ, i])])(BraKet[(Subscript[ψ, i]), ψ])
=(∑_i)(Subscript[p, i])((|(BraKet[ψ, (Subscript[ψ, i])])|)^2).

Given that

({{(Subscript[p, i])>=0}, {((|(BraKet[ψ, (Subscript[ψ, i])])|)^2)>=0}})}=>(Subscript[p, i])((|(BraKet[ψ, (Subscript[ψ, i])])|)^2)>=0=>(∑_i)(Subscript[p, i])((|(BraKet[ψ, (Subscript[ψ, i])])|)^2)>=0,

(Bra[ψ])ρ(Ket[ψ])>=0 is proven.

Observable Expectation Value

For pure state (Ket[ψ]): there are two equivalent ways to express ⟨O⟩

⟨O⟩=(Bra[ψ])O(Ket[ψ])=Tr(Ket[ψ])(Bra[ψ])O=Tr ρ O.

Block[{ket,bra,opH,opU,opD},
ket[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Polygon[CirclePoints[{1,0},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
bra[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Polygon[CirclePoints[{1,π},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opH[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Red,0.8],Disk[{0,0},0.8]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opU[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Green,0.8],Polygon[CirclePoints[4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opD[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Yellow,0.8],Polygon[CirclePoints[{0.8,0},4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
Graphics[{{EdgeForm[Directive[AbsoluteThickness[1],Dashed]],Lighter[Blue,0.9],Rectangle[{5.5,-1.2},{9.5,1.2},RoundingRadius->.3]},Line[{#,0}&/@{-2,2}],opH["O"],bra["ψ",{-2,0}],ket["ψ",{2,0}],Text["=",{4,0}],BSplineCurve[{{6,0},{6,0},{6,0},{5,0},{5,1.5},{6,1.5},{11,1.5},{12,1.5},{12,0},{11,0},{9,0},{9,0},{9,0}}],ket["ψ",{6.3,0}],bra["ψ",{8.7,0}],opH["O",{10.5,0}],Text["ρ",{7.5,-0.8}]},ImageSize->{Automatic,45}]]

Comment: Introducing ρ does not seem to be necessary in this case, it is sufficient to work with (Ket[ψ]).

For mixed states, what should be the most reasonable approach to calculating ⟨O⟩?

({{with probability:, the system is in the state:, on which ⟨O⟩ should be:}, {(Subscript[p, 1]), (Ket[(Subscript[ψ, 1])]), (Bra[(Subscript[ψ, 1])])O(Ket[(Subscript[ψ, 1])])}, {(Subscript[p, 2]), (Ket[(Subscript[ψ, 2])]), (Bra[(Subscript[ψ, 2])])O(Ket[(Subscript[ψ, 2])])}, {(Subscript[p, 3]), (Ket[(Subscript[ψ, 3])]), (Bra[(Subscript[ψ, 3])])O(Ket[(Subscript[ψ, 3])])}, {⋮, ⋮, ⋮}})

therefore, the ensemble average must be given by

⟨O⟩=(∑_i)(Subscript[p, i])(Bra[(Subscript[ψ, i])])O(Ket[(Subscript[ψ, i])])
=Tr(∑_i)(Subscript[p, i])(Ket[(Subscript[ψ, i])])(Bra[(Subscript[ψ, i])])O.

One can see, the density matrix ρ=(∑_i)(Subscript[p, i])(Ket[(Subscript[ψ, i])])(Bra[(Subscript[ψ, i])]) emerges in the expression exactly as Eq. (), such that all the state-dependent information can be packed into ρ, and the observable expectation value can be universally evaluated by

regardless whether the state ρ is pure or mixed.

For mixed states, the density matrix description is indispensable, because the mixed state density matrix ρ cannot be decomposed into the form of (Ket[ψ])(Bra[ψ]) (rank-1 matrix) in general, meaning that there is no state vector description for mixed states.

Quantum State Tomography

For a single qubit, by measuring ⟨X⟩, ⟨Y⟩, ⟨Z⟩, the density matrix can be reconstructed as

ρ=(1/2)(𝟙+⟨X⟩X+⟨Y⟩Y+⟨Z⟩Z).

It is also convenient to combine Pauli operators into a vector of operators

σ=((σ^x),(σ^y),(σ^z)):=(X,Y,Z),

such that Eq. () can be written in a more compact form as

Show that Eq. () is the density matrix that is consistent with the expectation values and properly normalized.

Normalization

Tr ρ
=Tr(1/2)(𝟙+⟨σ⟩·σ)
=(1/2)(Tr(𝟙)+⟨σ⟩·Tr(σ))
=(1/2)(2+⟨σ⟩·0)
=1.

Reproducing the expectation values

Tr ρ σ
=Tr(1/2)(𝟙+⟨σ⟩·σ) σ
=Tr(1/2)(σ+⟨σ⟩𝟙-i ⟨σ⟩×σ)
=(1/2)(Tr(σ)+⟨σ⟩Tr(𝟙)-i ⟨σ⟩×Tr(σ))
=(1/2)(0+⟨σ⟩2-i ⟨σ⟩×0)
=⟨σ⟩

For multi-qubit system, Eq. () can be generalized

where

P - sums over all Pauli operators in an N-qubit system (there are (4^N) of them, including 𝟙)

⟨P⟩ - the expectation value of the Pauli observable P, inferred from repeated measurement (however, measuring all (4^N) observables requires exponentially amount of resources, hence a full quantum state tomography is not feasible for large systems).

Spectral Decomposition

Every Hermitian operator admits a spectral decomposition, so does the density matrix ρ

(Subscript[p, i]) are eigenvalues of ρ, with the physical meaning of probability for the system to take the (Ket[(Subscript[ϕ, i])]) state, satisfying (Subscript[p, i])≥0 and (∑_i)(Subscript[p, i])=1,

(Ket[(Subscript[ϕ, i])]) are corresponding eigenvectors of ρ, forming a set of orthonormal basis, also known as the natural orbitals.

Note that (Subscript[p, i]) and (Ket[(Subscript[ϕ, i])]) may not necessary coincide with the mixed state ensemble in Eq. () that was originally used to construct the density matrix.

Example: Consider a mixed state of a single qubit with 1/2 probability to be (Ket[0]), and 1/2 probability to be  (Ket[+])=(1/(Sqrt[2]))((Ket[0])+(Ket[1])). Its density matrix is

ρ=(1/2)(Ket[0])(Bra[0])+(1/2)(Ket[+])(Bra[+])
≏(1/4)(({{3, 1}, {1, 1}})).

However, its eigen decomposition can look very different

ρ=(Subscript[p, 1])(Ket[(Subscript[ϕ, 1])])(Bra[(Subscript[ϕ, 1])])+(Subscript[p, 2])(Ket[(Subscript[ϕ, 2])])(Bra[(Subscript[ϕ, 2])]),
({{(Subscript[p, 1])=((2+(Sqrt[2]))/4)≈0.8535533905932737`:, (Ket[(Subscript[ϕ, 1])])≏(({{((Sqrt[2+(Sqrt[2])])/2)}, {(1/(Sqrt[2 (2+(Sqrt[2]))]))}}))≈(({{0.92388}, {0.38268}})),}, {(Subscript[p, 2])=((2-(Sqrt[2]))/4)≈0.1464466094067262`:, (Ket[(Subscript[ϕ, 2])])≏(({{-(1/(Sqrt[2 (2+(Sqrt[2]))]))}, {((Sqrt[2+(Sqrt[2])])/2)}}))≈(({{-0.38268}, {0.9238795325112867`}})).}})

Ambiguity in Mixed State Interpretation: Different sets of pure states with different probabilities can lead to the same resulting density matrix, meaning there can be multiple possible interpretations of a mixed state as a combination of pure states.

Spectral decomposition of density matrix provides a canonical interpretation of mixed state in terms of mixture of distinct (orthogonal) pure states.

Distinction between

Quantum superposition (linear combination of state vectors): (Ket[ψ])=(Subscript[α, 1])(Ket[(Subscript[ψ, 1])])+(Subscript[α, 2])(Ket[(Subscript[ψ, 2])])+… — the result is still a pure state.

Statistical mixture (convex sum of density matrices): ρ=(Subscript[p, 1])(Subscript[ρ, 1])+(Subscript[p, 2])(Subscript[ρ, 2])+… — the result is generally a mixed state.

Example: An equal amplitude quantum superposition of (Ket[0]) and (Ket[1]) states is

(Ket[+])=(1/(Sqrt[2]))((Ket[0])+(Ket[1])).

Its corresponding density matrix is

(Ket[+])(Bra[+])≏(1/2)(({{1, 1}, {1, 1}})).

An equal probability statistical mixture of (Ket[0]) and (Ket[1]) would be

ρ=(1/2)(Ket[0])(Bra[0])+(1/2)(Ket[1])(Bra[1])≏(({{1, 0}, {0, 1}})).

Eq. () and Eq. () differed by the off-diagonal matrix elements — the signature of quantum coherence in the density matrix.

Purity

Pure state: only one eigenvalue (Subscript[p, 1])=1, and all others are zero.

In this case,

(∑_i)(Subscript[p, i]^2)=1+0+0+…=1.

Mixed state: more than one non-zero eigenvalues, i.e. (Subscript[p, i])>0 for multiple i.

In this case, given that (∑_i)(Subscript[p, i])=(Subscript[p, 1])+(Subscript[p, 2])+…=1,

(∑_i)(Subscript[p, i]^2)=(Subscript[p, 1]^2)+(Subscript[p, 2]^2)+…<1.

By construction, Tr (ρ^2)∈[0,1].

Purity Tr (ρ^2) is invariant under basis transformation ρ→U ρ (SuperDagger[U]) (which is also seen from the fact that it only has to do with the eigenvalues {(Subscript[p, i])} not the eigenvectors of ρ)

Purity provides a basis-independent approach to determine if a state ρ is pure or mixed:

ρ is ({{{, ({{pure, if Tr (ρ^2)=1,}, {mixed, if Tr (ρ^2)<1.}})}})

von Neumann and Rényi Entropy

Eq. () should be understood as

(S^((1)))=-(∑_i)(Subscript[p, i])log (Subscript[p, i]),

in terms of the eigenvalues (Subscript[p, i]) of the density matrix ρ. [Note: 0ln 0 should be treated as 0 in this calculation]

This matches the Shannon entropy Eq. () of a probability distribution in the information theory.

(S^((n)))=(1/(1-n))log (∑_i)(Subscript[p, i]^n).

n is the Rényi index.

n=0: max-entropy, simply counts the log of the Hilbert space dimension (S^((0)))=log dim ℋ.

n->1 limit: equivalent to the von Neumann entropy, i.e. (S^((1)))=(lim_(n->1))(S^((n))).

Show that in the n->1 limit, the Rényi entropy reduces to the von Neumann entropy.

(lim_(n->1))(S^((n)))=(lim_(n->1))(1/(1-n))log Tr (ρ^n)
=-(lim_(n->1))(∂_n)log Tr (ρ^n)
=-(lim_(n->1))((Tr (ρ^n)log ρ)/(Tr (ρ^n)))
=-((Tr ρ log ρ)/(Tr ρ))
=-Tr ρ log ρ=(S^((1))).

n=2: the 2nd Rényi entropy is directly related to purity by (S^((2)))=-log Tr (ρ^2).

n=∞: min-entropy, lower bound of all Rényi entropies, (S^((∞)))=-log (max_i) (Subscript[p, i]).

The spectrum of the density matrix, i.e. all eigenvalues (Subscript[p, i]), can be reconstructed from the family of Rényi entropies (by solving the following equations, in principle).

(∑_i)(Subscript[p, i]^n)=(e^((1-n)(S^((n)))))   (for n=1,2,…,dim ℋ).

Entropy and Knowledge

ρ is ({{{, ({{pure, if (S^((n)))=0,}, {mixed, if (S^((n)))>0,}})}}) for n=1,2,….

Jensen’s inequality: Rényi entropy is generally decreasing with the Rényi index,

log dim ℋ=(S^((0)))≥(S^((1)))≥(S^((2)))≥…≥(S^((∞)))≥0.

∀i:(Subscript[p, i])=(1/(dim ℋ))=>∀n≥0:(S^((n)))=log dim ℋ.

ρ=(1/(dim ℋ))𝟙.

ρ=𝟙/2≏(1/2)(({{1, 0}, {0, 1}})).

Application: if the qubit basis corresponds to the left-circular and right-circular photon polarization, then the density matrix in Eq. () describes the natural light ensemble of photons.

All Rényi entropies are identically log 2 for a maximally mixed qubit,

(S^((n)))=(1/(1-n))log ((1/(2^n))+(1/(2^n)))=log 2=1bit.

This is the maximal entropy that a qubit could have: our ignorance about a qubit is at most 1 bit. This is why a qubit is called a quantum bit.

Quantum Entanglement

Product and Entangled States

Pure State Entanglement

(Ket[(Subscript[ψ, A B])]) is a product state, if it can be expressed as

(Ket[(Subscript[ψ, A B])])=(Ket[(Subscript[ψ, A])])⊗(Ket[(Subscript[ψ, B])]),

i.e. tensor product of individual states of its subsystems A and B.

(Ket[(Subscript[ψ, A B])]) is a entangled state, if it is not a product state, i.e.

(Ket[(Subscript[ψ, A B])])≠(Ket[(Subscript[ψ, A])])⊗(Ket[(Subscript[ψ, B])]).

Grid[{{"product state","entangled state"},{"The state of one subsystem can be described independently of the other.","The subsystems are correlated in a way that cannot be described classically."},
{"All information is contained locally in each separate subsystem.","Some information is shared between subsystems, and can not be accessed from either subsystem."},{"Measurement of one subsystem does not affect the state of the other subsystem.","Measurement on one subsystem can instantaneously affect the state of the other subsystem, a phenomenon known as quantum nonlocality."}},Alignment->{Left,Automatic,{{1,1},{1,2}}->Center},Background->{None,{1->GrayLevel[0.92]}},ItemSize->15,Frame->All,FrameStyle->LightGray,ItemStyle->Directive["Text",LineIndent->0]]

Suppose (Ket[(Subscript[ψ, A])])=(Subscript[z, 0])(Ket[0])+(Subscript[z, 1])(Ket[1]), (Ket[(Subscript[ψ, B])])=(Subscript[w, 0])(Ket[0])+(Subscript[w, 1])(Ket[1]), the most general product state must take the form of

(Ket[(Subscript[ψ, A])])⊗(Ket[(Subscript[ψ, B])])=((Subscript[z, 0])(Ket[0])+(Subscript[z, 1])(Ket[1]))⊗((Subscript[w, 0])(Ket[0])+(Subscript[w, 1])(Ket[1]))
=(Subscript[z, 0])(Subscript[w, 0])(Ket[00])+(Subscript[z, 0])(Subscript[w, 1])(Ket[01])+(Subscript[z, 1])(Subscript[w, 0])(Ket[10])+(Subscript[z, 1])(Subscript[w, 1])(Ket[11]).

The following states, known as Bell states, are entangled states:

(Ket[(Subscript[ψ, A B]^(++))])=(((Ket[00])+(Ket[11]))/(Sqrt[2])),(Ket[(Subscript[ψ, A B]^(+-))])=(((Ket[01])+(Ket[10]))/(Sqrt[2])),
(Ket[(Subscript[ψ, A B]^(-+))])=(((Ket[00])-(Ket[11]))/(Sqrt[2])),(Ket[(Subscript[ψ, A B]^(--))])=(((Ket[01])-(Ket[10]))/(Sqrt[2])).

Prove that states in Eq. () can not be written as product states like Eq. ().

(Subscript[z, 0])(Subscript[w, 0])=(1/(Sqrt[2])),(Subscript[z, 0])(Subscript[w, 1])=0,(Subscript[z, 1])(Subscript[w, 0])=0,(Subscript[z, 1])(Subscript[w, 1])=(1/(Sqrt[2])).

Mixed State Entanglement

(Subscript[ρ, A B]) is a product state, if the it can be written as tensor product of density matrices of its subsystems

(Subscript[ρ, A B])=(Subscript[ρ, A])⊗(Subscript[ρ, B]).

(Subscript[ρ, A B]) is a separable state, if the it is a statistical mixture of product states

(Subscript[ρ, A B])=(∑_i)(Subscript[p, i])(Subscript[ρ, A]^((i)))⊗(Subscript[ρ, B]^((i))).

(Subscript[ρ, A B]) is an entangled state, if it is not separable, i.e.

(Subscript[ρ, A B])≠(∑_i)(Subscript[p, i])(Subscript[ρ, A]^((i)))⊗(Subscript[ρ, B]^((i))),

This is a subtle point: sometimes a density matrix may appear entangled, but there might exists a non-trivial decomposition that reveals the state is actually separable.

Determining whether a mixed state is separable or entangled is a computationally challenging task, and is known to be NP-hard!

Reduced Density Matrix

Mathematical definition of partial trace:

(Subscript[Tr, B])(Subscript[ρ, A B])=(∑_i)(Subscript[(Bra[i]), B])(Subscript[ρ, A B])(Subscript[(Ket[i]), B]),

where {(Subscript[(Ket[i]), B])} is any set of orthonormal basis for subsystem B.

Physical meaning: taking partial trace ignores the information related to subsystem B while retaining the information remaining in subsystem A. It corresponds to “tracing out” or averaging over the unobserved degrees of freedom of B.

Existence of (Subscript[ρ, A]): For any observable (Subscript[O, A]) acting only in A, (Subscript[ρ, A]) must provide an equivalent way to evaluate ⟨(Subscript[O, A])⟩ as using (Subscript[ρ, A B]):

⟨(Subscript[O, A])⟩=Tr((Subscript[ρ, A B]) (Subscript[O, A])⊗(Subscript[I, B]))=Tr((Subscript[ρ, A])(Subscript[O, A])).

Block[{ket,bra,opH,opρ,opD},
ket[txt_,pos_:{0,0},θ_:0]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Polygon[CirclePoints[{1,θ},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
bra[txt_,pos_:{0,0},θ_:0]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Polygon[CirclePoints[{1,π+θ},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opH[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Red,0.8],Disk[{0,0},0.8]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opρ[txt_,{w_,h_},pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Orange,0.8],Rectangle[{-w,-h},{w,h},RoundingRadius->0.3]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opD[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Yellow,0.8],Polygon[CirclePoints[{0.8,0},4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
Block[{d=1.5},Graphics[{Translate[{{Translate[BSplineCurve[{{0,-1},{0,3},{0,3.5},{-d,3.5},{-d,3},{-d,-1},{-d,-1.5},{0,-1.5}},SplineClosed->True],{-1,0}],Translate[BSplineCurve[{{0,-1},{0,1},{0,1.5},{d,1.5},{d,1},{d,-1},{d,-1.5},{0,-1.5}},SplineClosed->True],{1,0}]},opH["O\_A",{-1,2}],opρ["ρ\_\(A B\)",{1.5,0.75},{0,0}]},{-3.2,0}],Text["=",{0,0}],Translate[{{Translate[BSplineCurve[{{0,-1},{0,3},{0,3.5},{-d,3.5},{-d,3},{-d,-1},{-d,-1.5},{0,-1.5}},SplineClosed->True],{0,0}]},opH["O\_A",{0,2}],opρ["ρ\_\(A\)",{0.75,0.75},{0,0}]},{2.2,0}]},ImageSize->{Automatic,80}]]]

For Eq. () to hold for any choice of (Subscript[O, A]), we should require

Block[{ket,bra,opH,opρ,opD},
ket[txt_,pos_:{0,0},θ_:0]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Polygon[CirclePoints[{1,θ},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
bra[txt_,pos_:{0,0},θ_:0]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Polygon[CirclePoints[{1,π+θ},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opH[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Red,0.8],Disk[{0,0},0.8]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opρ[txt_,{w_,h_},pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Orange,0.8],Rectangle[{-w,-h},{w,h},RoundingRadius->0.3]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opD[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Yellow,0.8],Polygon[CirclePoints[{0.8,0},4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
Block[{d=1.5},Graphics[{Translate[{{Translate[Line[{0,#}&/@{-1.2,1.2}],{-1,0}],Translate[BSplineCurve[{{0,-1},{0,1},{0,1.5},{d,1.5},{d,1},{d,-1},{d,-1.5},{0,-1.5}},SplineClosed->True],{1,0}]},opρ["ρ\_\(A B\)",{1.5,0.75},{0,0}]},{-3.2,0}],Text["=",{0,0}],Translate[{{Line[{0,#}&/@{-1.2,1.2}]},opρ["ρ\_\(A\)",{0.75,0.75},{0,0}]},{2.2,0}]},ImageSize->{Automatic,50}]]]

which provides a construction: (Subscript[ρ, A])=(Subscript[Tr, B])(Subscript[ρ, A B]).

Uniqueness of (Subscript[ρ, A]): For any different state (Subscript[ρ, A]^′)≠(Subscript[ρ, A]), there must exist at least one observable (Subscript[O, A]), such that Tr (Subscript[ρ, A]^′)(Subscript[O, A])≠Tr (Subscript[ρ, A])(Subscript[O, A]). By matching all observable expectation values ⟨(Subscript[O, A])⟩ in Eq. (), the state (Subscript[ρ, A]) is uniquely determined, meaning that (Subscript[ρ, A])=(Subscript[Tr, B])(Subscript[ρ, A B]) is the only valid construction.

Entanglement Entropy

(Ket[ψ])=(1/(Sqrt[2]))((Ket[↑↓])-(Ket[↓↑])).

Full density matrix

(Ket[ψ])(Bra[ψ])≏(1/2)(({{0}, {1}, {-1}, {0}}))(({{0, 1, -1, 0}}))=(1/2)(({{0, 0, 0, 0}, {0, 1, -1, 0}, {0, -1, 1, 0}, {0, 0, 0, 0}})).

Partial trace over qubit B => reduced density matrix of qubit A

(Subscript[ρ, A])=(Subscript[Tr, B])(Ket[ψ])(Bra[ψ])
≏(1/2)(({{tr(({{0, 0}, {0, 1}})), tr(({{0, 0}, {-1, 0}}))}, {tr(({{0, -1}, {0, 0}})), tr(({{1, 0}, {0, 0}}))}}))=(1/2)(({{1, 0}, {0, 1}})).

Note that (Subscript[ρ, A]) indeed describes a maximally mixed qubit.

Compute the entropy of the reduced density matrix,

S(A)=-Tr (Subscript[ρ, A])ln (Subscript[ρ, A])=ln 2=1 bit.

(Ket[ψ])=(1/2)((Ket[↑↑])+(Ket[↑↓])+(Ket[↓↑])+(Ket[↓↓])).

Full density matrix

ρ=(Ket[ψ])(Bra[ψ])≏(1/4)(({{1}, {1}, {1}, {1}}))(({{1, 1, 1, 1}}))=(1/4)(({{1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}, {1, 1, 1, 1}})).

Partial trace over qubit B => reduced density matrix of qubit A

(Subscript[ρ, A])=(Subscript[Tr, B])ρ
≏(1/4)(({{tr(({{1, 1}, {1, 1}})), tr(({{1, 1}, {1, 1}}))}, {tr(({{1, 1}, {1, 1}})), tr(({{1, 1}, {1, 1}}))}}))=(1/2)(({{1, 1}, {1, 1}})).

Compute the entropy of the reduced density matrix,

S(A)=-Tr (Subscript[ρ, A])ln (Subscript[ρ, A])=-(0ln 0+1 ln 1)=0 bit.

({{(Ket[ψ]) (pure), product, entangled, maximally entangled}, {(Subscript[ρ, A]), pure, mixed, maximally mixed}, {(S^((n)))(A), 0, ↔, ln dim ℋ}, {entanlement, none, ↔, max}})

Mutual Information

(S^((n)))(A)=(S^((n)))(B)=1bit,
(S^((n)))(A⋃B)=0bit,

(I^((n)))(A:B)=(S^((n)))(A)+(S^((n)))(B)-(S^((n)))(A⋃B)=2bit.

For classical systems, the mutual information between two classical bits will never exceed 1bit. How can we tell more than 1bit of information about B by measuring A?

The maximal mutual information between two classical bits is achieved when they are perfectly correlated, e.g.

p(10)=p(01)=1/2, p(11)=p(00)=0.

Entanglement is more than correlation: the extra bit of quantum information shared between qubits A and B is their quantum entanglement, that goes beyond the classical correlation.

(I^((2)))(A:B)=log(1+((||⟨(Subscript[σ, A])⊗(Subscript[σ, B])⟩((||)^2)-||⟨(Subscript[σ, A])⟩((||)^2)||⟨(Subscript[σ, B])⟩((||)^2))/((1+||⟨(Subscript[σ, A])⟩((||)^2))(1+||⟨(Subscript[σ, B])⟩((||)^2))))).

Classical state: statistical superposition

ρ=(1/2)(Ket[↑↓])(Bra[↑↓])+(1/2)(Ket[↓↑])(Bra[↓↑]),

Observables

⟨(Subscript[σ, A])⟩=⟨(Subscript[σ, B])⟩=(0,0,0),
⟨(Subscript[σ, A])⊗(Subscript[σ, B])⟩=(({{0, 0, 0}, {0, 0, 0}, {0, 0, -1}})).

Mutual information

(I^((2)))(A:B)=log(1+||⟨(Subscript[σ, A])⊗(Subscript[σ, B])⟩((||)^2))=log(1+1)=log 2=1bit.

Quantum state: quantum superposition

ρ=(Ket[ψ])(Bra[ψ]),
(Ket[ψ])=(1/(Sqrt[2]))((Ket[↑↓])-(Ket[↓↑])).

Observables

⟨(Subscript[σ, A])⟩=⟨(Subscript[σ, B])⟩=(0,0,0),
⟨(Subscript[σ, A])⊗(Subscript[σ, B])⟩=(({{-1, 0, 0}, {0, -1, 0}, {0, 0, -1}})).

Mutual information

(I^((2)))(A:B)=log(1+||⟨(Subscript[σ, A])⊗(Subscript[σ, B])⟩((||)^2))=log(1+3)=log 4=2bit.

EPR Pair and Bell Inequality

(Ket[ψ])=(1/(Sqrt[2]))((Ket[↑↓])-(Ket[↓↑])).

Graphics[{{LightGray,Disk[{0,5},{6,1}]},Text["EPR state",{0,5}],{Arrowheads[{{0.1,0.8}}],Arrow[{{0,0},{5,5}}],Arrow[{{0,0},{-5,5}}]},{Disk[#,0.5]&/@{{-5,5},{5,5}}},{EdgeForm[Black],LightGray,Rectangle[{-1,-1},{1,1},RoundingRadius->.5]},
{Text["Alice",{-5,5},{0,-1.2}],Text["Bob",{5,5},{0,-1.2}],Text["source",{0,-1},{0,1}]}},ImageSize->120]

⟨(Subscript[σ, A])⟩=⟨(Subscript[σ, B])⟩=(0,0,0),
⟨(Subscript[σ, A])⊗(Subscript[σ, B])⟩=(({{-1, 0, 0}, {0, -1, 0}, {0, 0, -1}})).

(Subscript[σ, A]^z)=-(Subscript[σ, B]^z)=({{{, ({{+1, p=1/2}, {-1, p=1/2}})}}).

Quantum explanation: can be inferred from ⟨(Subscript[σ, A]^z)⟩=⟨(Subscript[σ, B]^z)⟩=0 and ⟨(Subscript[σ, A]^z)(Subscript[σ, B]^z)⟩=-1.

This is not too surprising: just a perfect correlation between two random variables. Classically, one may model the perfect correlation by a hidden variable:

Block[{bg,str},
bg={{Arrowheads[{{0.05,0.85}}],Arrow[{{0,0},{5,5}}],Arrow[{{0,0},{-5,5}}]},{Disk[#,0.5]&/@{{-5,5},{5,5}}},{EdgeForm[Black],LightGray,Rectangle[{-1,-1},{1,1},RoundingRadius->.5]},
{Text["Alice",{-5,5},{0,-1.2}],Text["Bob",{5,5},{0,-1.2}]},
Text["\!\(p=1/2\)",{0,-1},{0,1}]};
str[bsA_,bsB_]:=Inset[Grid[{#2},Alignment->{Center,Center},Frame->All,FrameStyle->Thin,Spacings->{0.05,0}],{#1,3},{-Sign[#1],1}]&@@@{{-3,bsA},{3,bsB}};
Graphics[{Translate[{bg,str[{"0"},{"1"}]},{-8,0}],Translate[{bg,str[{"1"},{"0"}]},{8,0}]},ImageSize->240]]

(Subscript[σ, A]^x)=-(Subscript[σ, B]^x)=({{{, ({{+1, p=1/2}, {-1, p=1/2}})}}).

Quantum explanation: can be inferred from ⟨(Subscript[σ, A]^x)⟩=⟨(Subscript[σ, B]^x)⟩=0 and ⟨(Subscript[σ, A]^x)(Subscript[σ, B]^x)⟩=-1.

To model this classically: we will need to introduce another hidden variable to encode the perfect correlation in (σ^x) channel.

Block[{bg,str},
bg={{Arrowheads[{{0.05,0.85}}],Arrow[{{0,0},{5,5}}],Arrow[{{0,0},{-5,5}}]},{Disk[#,0.5]&/@{{-5,5},{5,5}}},{EdgeForm[Black],LightGray,Rectangle[{-1,-1},{1,1},RoundingRadius->.5]},
{Text["Alice",{-5,5},{0,-1.2}],Text["Bob",{5,5},{0,-1.2}]},
Text["\!\(p=1/2\)",{0,-1},{0,1}]};
str[bsA_,bsB_]:=Inset[Grid[{#2},Alignment->{Center,Center},Frame->All,FrameStyle->Thin,Spacings->{0.05,0}],{#1,3},{-Sign[#1],1}]&@@@{{-3,bsA},{3,bsB}};
Graphics[{Translate[{bg,str[{"?","0"},{"?","1"}]},{-8,0}],Translate[{bg,str[{"?","1"},{"?","0"}]},{8,0}]},ImageSize->240]]

(Subscript[σ, A]^z)=({{{, ({{+1, p=1/2}, {-1, p=1/2}})}}), (Subscript[σ, B]^x)=({{{, ({{+1, p=1/2}, {-1, p=1/2}})}}).

Quantum explanation: can be inferred from ⟨(Subscript[σ, A]^z)⟩=⟨(Subscript[σ, B]^x)⟩=0 and ⟨(Subscript[σ, A]^z)(Subscript[σ, B]^x)⟩=0.

The classical hidden variables can reproduce this behavior only if they follow the joint distribution

({{Alice, Bob, p}, {00, 11, 1/4}, {01, 10, 1/4}, {10, 01, 1/4}, {11, 00, 1/4}})

({{(Subscript[n, A])·(Subscript[σ, A]), (Subscript[n, B])·(Subscript[σ, B]), p}, {+1, +1, (1-(Subscript[n, A])·(Subscript[n, B]))/4}, {+1, -1, (1+(Subscript[n, A])·(Subscript[n, B]))/4}, {-1, +1, (1+(Subscript[n, A])·(Subscript[n, B]))/4}, {-1, -1, (1-(Subscript[n, A])·(Subscript[n, B]))/4}})

p((Subscript[n, A])·(Subscript[σ, A])=-(Subscript[n, B])·(Subscript[σ, B]))=((1+(Subscript[n, A])·(Subscript[n, B]))/2).

Quantum explanation: can be inferred from ⟨(Subscript[n, A])·(Subscript[σ, A])⟩=⟨(Subscript[n, B])·(Subscript[σ, B])⟩=0 and ⟨(Subscript[n, A])·(Subscript[σ, A])(Subscript[n, B])·(Subscript[σ, B])⟩=-(Subscript[n, A])·(Subscript[n, B]).

Classically, to reproduce all these, we will need many (could be infinitely many) hidden variables, one for each choice of the measurement axis n. (This is ugly but not fatal yet.)

Block[{bg,str},
bg={{Arrowheads[{{0.12,0.85}}],Arrow[{{0,0},{5,5}}],Arrow[{{0,0},{-5,5}}]},{Disk[#,0.5]&/@{{-5,5},{5,5}}},{EdgeForm[Black],LightGray,Rectangle[{-1,-1},{1,1},RoundingRadius->.5]},
{Text["Alice",{-5,5},{0,-1.2}],Text["Bob",{5,5},{0,-1.2}]}};
str[bsA_,bsB_]:=Inset[Grid[{#2},Alignment->{Center,Center},Frame->All,FrameStyle->Thin,Spacings->{0.05,0}],{#1,3},{-Sign[#1],1}]&@@@{{-3,bsA},{3,bsB}};
Graphics[{bg,str[{"1","0","0","1","0","…"},{"0","1","1","0","1","…"}],Text["\!\(p(10010…)\)",{0,-1},{0,1}]},ImageSize->160]]

({{Alice, Bob, p}, {…00…, …11…, (1+(Subscript[n, 1])·(Subscript[n, 2]))/4}, {…01…, …10…, (1-(Subscript[n, 1])·(Subscript[n, 2]))/4}, {…10…, …01…, (1-(Subscript[n, 1])·(Subscript[n, 2]))/4}, {…11…, …00…, (1+(Subscript[n, 1])·(Subscript[n, 2]))/4}}).

Classically, there must be three hidden variables associated with the three observables, following some marginal distribution

({{Alice, Bob, p}, {…000…, …111…, (Subscript[p, 1])}, {…001…, …110…, (Subscript[p, 2])}, {…010…, …101…, (Subscript[p, 3])}, {…011…, …100…, (Subscript[p, 4])}, {…100…, …011…, (Subscript[p, 5])}, {…101…, …010…, (Subscript[p, 6])}, {…110…, …001…, (Subscript[p, 7])}, {…111…, …000…, (Subscript[p, 8])}}).

The probability must sum up to 1, i.e.

(Subscript[p, 1])+(Subscript[p, 2])+…+(Subscript[p, 8])=1.

If Alice measures (Subscript[n, 1])·(Subscript[σ, A]) and Bob measures (Subscript[n, 2])·(Subscript[σ, B]), the probability that they obtain opposite outcomes is

p((Subscript[n, 1])·(Subscript[σ, A])=-(Subscript[n, 2])·(Subscript[σ, B]))=(Subscript[p, 1])+(Subscript[p, 2])+(Subscript[p, 7])+(Subscript[p, 8]).

If Alice measures (Subscript[n, 2])·(Subscript[σ, A]) and Bob measures (Subscript[n, 3])·(Subscript[σ, B]), the probability that they obtain opposite outcomes is

p((Subscript[n, 2])·(Subscript[σ, A])=-(Subscript[n, 3])·(Subscript[σ, B]))=(Subscript[p, 1])+(Subscript[p, 4])+(Subscript[p, 5])+(Subscript[p, 8]).

If Alice measures (Subscript[n, 3])·(Subscript[σ, A]) and Bob measures (Subscript[n, 1])·(Subscript[σ, B]), the probability that they obtain opposite outcomes is

p((Subscript[n, 3])·(Subscript[σ, A])=-(Subscript[n, 1])·(Subscript[σ, B]))=(Subscript[p, 1])+(Subscript[p, 3])+(Subscript[p, 6])+(Subscript[p, 8]).

Put together,

p((Subscript[n, 1])·(Subscript[σ, A])=-(Subscript[n, 2])·(Subscript[σ, B]))+p((Subscript[n, 2])·(Subscript[σ, A])=-(Subscript[n, 3])·(Subscript[σ, B]))+p((Subscript[n, 3])·(Subscript[σ, A])=-(Subscript[n, 1])·(Subscript[σ, B]))
=3(Subscript[p, 1])+(Subscript[p, 2])+(Subscript[p, 3])+(Subscript[p, 4])+(Subscript[p, 5])+(Subscript[p, 6])+(Subscript[p, 7])+3(Subscript[p, 8])
=1+2(Subscript[p, 1])+2(Subscript[p, 8])

This leads to a (version of) Bell inequality.

Now what is the quantum mechanical prediction? Recall the quantum result in Eq. (), the Bell inequality would require

((1+(Subscript[n, 1])·(Subscript[n, 2]))/2)+((1+(Subscript[n, 2])·(Subscript[n, 3]))/2)+((1+(Subscript[n, 3])·(Subscript[n, 1]))/2)≥1,

for three unit vectors (Subscript[n, 1]), (Subscript[n, 2]) and (Subscript[n, 3]).

Graphics[{Arrowheads[0.2],{Arrow[{{0,0},#1}],Text["\!\(n\_"<>#2<>"\)",#1,-#1]}&@@@Thread[{CirclePoints[3],ToString/@Range[3]}]},ImageSize->80]

(Subscript[n, 1])·(Subscript[n, 2])=(Subscript[n, 2])·(Subscript[n, 3])=(Subscript[n, 3])·(Subscript[n, 1])=-1/2.

(1/4)+(1/4)+(1/4)=(3/4)≱1,

Style[Grid[{{,SpanFromLeft,SpanFromLeft},{"John S. Bell (1928-1990)",SpanFromLeft,SpanFromLeft},{Style["The Nobel (No\[Hyphen]Bell) Prize in Physics 2022",DarkYellow,FontFamily->"CMU Sans Serif"],SpanFromLeft,SpanFromLeft},{,,},{"Alain Aspect","John F. Clauser","Anton Zeilinger"},{Style["for experiments with entangled photons, establishing the violation of Bell inequalities and pioneering quantum information science",FontSlant->Italic],SpanFromLeft,SpanFromLeft}},ItemSize->{7.8,Automatic}],"Text"]

ParametricPlot[{-Log[2,Cos[α]^4+Sin[α]^4],3/8(3-Sin[2α])},{α,0,π/4},AspectRatio->1,PlotStyle->Black,PlotRangePadding->0.01,Prolog->{Opacity[0.1],{Red,Polygon[{{0,1},{1,1},{1,0},{0,0}}]},{Green,Polygon[{{0,1},{1,1},{1,2},{0,2}}]}},GridLines->{{-Log[2,Cos[#]^4+Sin[#]^4]&[ArcSin[1/3]/2]},{1}},
FrameLabel->{"\!\(S\^(2)(A)\) [bit]","Bell ineq l.h.s."},
Epilog->{{Red,Text["violate",{0.95,1},{1,1}]},{Green,Text["obey",{0.95,1},{1,-1}]}}]

For pure state, such as (Ket[ψ]) in the above example, entanglement entropy (S^((2)))(A)>0 ⇔ the state is entangled. But the Bell inequality is not always violated. => It is an entanglement witness.

For mixed state, entropy no longer provides a good measure of quantum entanglement. We had to rely on Bell inequalities and other entanglement witness.

Quantum Information Processing

Unitary Operations

Time Evolution

Pure state: the state vector (Ket[ψ(t)]) encodes complete information about the quantum system at time t. If (Ket[ψ(0)]) is know at t=0, there must be a deterministic rule to find (Ket[ψ(t)]) at any time t:

where U(t) is the time-evolution operator.

Mixed state: the density matrix ρ(t) describes a statistical ensemble of pure states {(Ket[(Subscript[ψ, i])])} with probabilities {(Subscript[p, i])}

ρ(t)=(∑_i)(Subscript[p, i])(Ket[(Subscript[ψ, i])(t)])(Bra[(Subscript[ψ, i])(t)]).

Assumption: the probabilities {(Subscript[p, i])} remains unchanged under deterministic time-evolution. (The probability transfer process is stochastic.)

Since every pure state (Ket[(Subscript[ψ, i])(t)]) evolves independently under Eq. (), the density matrix evolves as

Distinct states remain distinct:

(BraKet[ϕ(0), ψ(0)])=0=>(BraKet[ϕ(t), ψ(t)])=(Bra[ϕ(0)])(SuperDagger[U(t)])U(t)(Ket[ψ(0)])=0.

Identical states remain identical:

(BraKet[ψ(0), ψ(0)])=1=>(BraKet[ψ(t), ψ(t)])=(Bra[ψ(0)])(SuperDagger[U(t)])U(t)(Ket[ψ(0)])=1.

(Bra[i])(SuperDagger[U(t)])U(t)(Ket[j])=(Subscript[δ, i j])⇔U(SuperDagger[(t)])U(t)=𝟙,

Dynamic Equations

Schrödinger Equation describes the time-evolution dynamics of a pure state

Verify that Eq. () is consistent with Eq. () given Eq. ().

i ℏ(∂_t)(Ket[ψ(t)])=i ℏ(∂_t)U(t)(Ket[ψ(0)])
=i ℏ(∂_t)exp(-(i/ℏ) H t)(Ket[ψ(0)])
=i ℏ(-(i/ℏ) H)exp(-(i/ℏ) H t)(Ket[ψ(0)])
=H U(t)(Ket[ψ(0)])
=H(Ket[ψ(t)]).

von Neumann Equation describes the time-evolution dynamics of a mixed state

where [H,ρ]=H ρ-ρ H denotes the commutator.

Verify that Eq. () is consistent with Eq. () given Eq. ().

i ℏ(∂_t)U(t)=i ℏ(∂_t)exp(-(i/ℏ) H t)
=i ℏ(-(i/ℏ) H)exp(-(i/ℏ) H t)
=H U(t),

i ℏ(∂_t)(SuperDagger[U(t)])=i ℏ(∂_t)exp(+(i/ℏ) H t)
=i ℏ (+(i/ℏ) H)exp(+(i/ℏ) H t)
=-H (SuperDagger[U(t)])=-(SuperDagger[U(t)])H,

i ℏ(∂_t)ρ(t)=i ℏ(∂_t)(U(t)ρ(0)(SuperDagger[U(t)]))
=(i ℏ(∂_t)U(t))ρ(0)(SuperDagger[U(t)])+U(t)ρ(0)(i ℏ(∂_t)(SuperDagger[U(t)]))
=H U(t)ρ(0)(SuperDagger[U(t)])-U(t)ρ(0)(SuperDagger[U(t)])H
=H ρ(t)-ρ(t) H
=[H,ρ(t)].

H=(ω/2)Z≏(ω/2)(({{1, 0}, {0, -1}})).

Initial density matrix (in the diagonal basis of H)

ρ(0)≏(({{(Subscript[ρ, 00]), (Subscript[ρ, 01])}, {(Subscript[ρ, 10]), (Subscript[ρ, 11])}})).

Time-evolved density matrix (set ℏ=1)

ρ(t)≏(({{(Subscript[ρ, 00]), (Subscript[ρ, 01])(e^(-i ω t))}, {(Subscript[ρ, 10])(e^(i ω t)), (Subscript[ρ, 11])}})).

Quantum Circuits

Single-Qubit Gates: acts on a single qubit, represented as 2×2 unitary matrices.

Pauli Gates: implement bit flip or phase flip

X≏(({{0, 1}, {1, 0}})), Y≏(({{0, -i}, {i, 0}})), Z≏(({{1, 0}, {0, -1}})).

Block[{size=28,block},
block[txt_]:=Block[{a=0.3},{{EdgeForm[Black],White,Rectangle[{-a,-a},{a,a},RoundingRadius->0.2 a]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]}];
Row[Prepend[Graphics[{Line[{#,0}&/@{-1,1}],block[#]},ImageSize->2size]&/@{"X","Y","Z"},Spacer[20]],Spacer[1]]]

Hadamard Gate: creates superpositions, transforms between X and Z basis.

H≏(1/(Sqrt[2]))(({{1, 1}, {1, -1}})).

Block[{size=28,block},
block[txt_]:=Block[{a=0.3},{{EdgeForm[Black],White,Rectangle[{-a,-a},{a,a},RoundingRadius->0.2 a]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]}];
Row[Prepend[Graphics[{Line[{#,0}&/@{-1,1}],block[#]},ImageSize->2size]&/@{"H"},Spacer[20]],Spacer[1]]]

Phase Gate: introduces a relative phase rotation between (Ket[0]) and (Ket[1]).

(Subscript[R, ϕ])≏(({{1, 0}, {0, (e^(i ϕ))}})).

Block[{size=28,block},
block[txt_]:=Block[{a=0.3},{{EdgeForm[Black],White,Rectangle[{-a,-a},{a,a},RoundingRadius->0.2 a]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]}];
Row[Prepend[Graphics[{Line[{#,0}&/@{-1,1}],block[#]},ImageSize->2size]&/@{"R\_ϕ"},Spacer[20]],Spacer[1]]]

Two-Qubit Gates: acts on two qubits, represented by 4×4 unitary matrices.

CNOT Gate: the first (control) qubit determines whether the second (target) qubit is bit flipped.

CNOT≏(({{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 0, 1}, {0, 0, 1, 0}})).

Block[{size=28,block,cnot,ctrl},
block[txt_]:=Block[{a=0.3},{{EdgeForm[Black],White,Rectangle[{-a,-a},{a,a},RoundingRadius->0.2 a]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]}];
cnot[i1_,i2_]:=Block[{a=0.25},{{Line[{0,-#}&/@{i1,i2+Sign[i2-i1]a}]},{Circle[{0,-i2},a]},{AbsolutePointSize[8],Point[{0,-i1}]}}];
ctrl[i1_,i2_,txt_]:={{Line[{0,-#}&/@{i1,i2}]},{AbsolutePointSize[8],Point[{0,-i1}]},Translate[block[txt],{0,-i2}]};
Style[Row[{Spacer[21],Graphics[{Translate[Line[{#,0}&/@{-1,1}],{0,#}]&/@{0,-1},ctrl[0,1,"X"]},ImageSize->2size]," or ",Graphics[{Translate[Line[{#,0}&/@{-1,1}],{0,#}]&/@{0,-1},cnot[0,1]},ImageSize->2size]}],"Text"]]

CZ Gate: the first (control) qubit determines whether the second (target) qubit is phase flipped.

CZ≏(({{1, 0, 0, 0}, {0, 1, 0, 0}, {0, 0, 1, 0}, {0, 0, 0, -1}})).

Block[{size=28,block,cz,ctrl},
block[txt_]:=Block[{a=0.3},{{EdgeForm[Black],White,Rectangle[{-a,-a},{a,a},RoundingRadius->0.2 a]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]}];
cz[i1_,i2_]:=Block[{a=0.25},{{Line[{0,-#}&/@{i1,i2}]},{AbsolutePointSize[8],Point[{0,-#}&/@{i1,i2}]}}];
ctrl[i1_,i2_,txt_]:={{Line[{0,-#}&/@{i1,i2}]},{AbsolutePointSize[8],Point[{0,-i1}]},Translate[block[txt],{0,-i2}]};
Style[Row[{Spacer[21],Graphics[{Translate[Line[{#,0}&/@{-1,1}],{0,#}]&/@{0,-1},ctrl[0,1,"Z"]},ImageSize->2size]," or ",Graphics[{Translate[Line[{#,0}&/@{-1,1}],{0,#}]&/@{0,-1},cz[0,1]},ImageSize->2size]}],"Text"]]

SWAP Gate: interchange two qubits.

SWAP≏(({{1, 0, 0, 0}, {0, 0, 1, 0}, {0, 1, 0, 0}, {0, 0, 0, 1}})).

Block[{size=28,block,swap},
block[txt_]:=Block[{a=0.3},{{EdgeForm[Black],White,Rectangle[{-a,-a},{a,a},RoundingRadius->0.2 a]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]}];
swap[i1_,i2_]:=Block[{a=0.14},{{Line[{0,-#}&/@{i1,i2}]},{Translate[{Line[{{-a,-a},{a,a}}],Line[{{-a,a},{a,-a}}]},{0,-#}]&/@{i1,i2}}}];
Style[Row[{Spacer[21],Graphics[{Scale[BSplineCurve[{{-1,-0.5},{-0.4,-0.5},{-0.2,-0.5},{0,0},{0.2,0.5},{0.4,0.5},{1,0.5}}],{1,#},{0,0}]&/@{1,-1}},ImageSize->2size]," or ",Graphics[{Translate[Line[{#,0}&/@{-1,1}],{0,#}]&/@{0,-1},swap[0,1]},ImageSize->2size]}],"Text"]]

Three-Qubit Gates: acts on three qubits, represented by 8×8 unitary matrices.

Toffoli Gate (Controlled-controlled-NOT): the first two (control) qubits jointly determines whether the last (target) qubit is bit flipped.

CCNOT≏(({{1, 0, 0, 0, 0, 0, 0, 0}, {0, 1, 0, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0, 0, 0}, {0, 0, 0, 1, 0, 0, 0, 0}, {0, 0, 0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 0, 1, 0, 0}, {0, 0, 0, 0, 0, 0, 0, 1}, {0, 0, 0, 0, 0, 0, 1, 0}})).

Block[{size=28,block,ccnot},
block[txt_]:=Block[{a=0.3},{{EdgeForm[Black],White,Rectangle[{-a,-a},{a,a},RoundingRadius->0.2 a]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]}];
ccnot[i1_,i2_,i3_]:=Block[{a=0.25},{{Line[{0,-#}&/@{i1,i3+Sign[i3-i1]a}]},{Circle[{0,-i3},a]},{AbsolutePointSize[8],Point[{0,-#}&/@{i1,i2}]}}];
Row[{Spacer[20],Graphics[{Translate[Line[{#,0}&/@{-1,1}],{0,#}]&/@{0,-1,-2},ccnot[0,1,2]},ImageSize->2size]},Spacer[1]]]

This gate is often used in universal quantum computation.

Block[{block,cnot},
block[txt_]:=Block[{a=0.3},{{EdgeForm[Black],White,Rectangle[{-a,-a},{a,a},RoundingRadius->0.2 a]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]}];
cnot[i1_,i2_]:=Block[{a=0.25},{{Line[{0,-#}&/@{i1,i2+Sign[i2-i1]a}]},{Circle[{0,-i2},a]},{AbsolutePointSize[8],Point[{0,-i1}]}}];
Graphics[{Translate[{Line[{#,0}&/@{-2,5}],Text["(Ket[0])",{-2,0},{1.2,0}]},{0,-#}]&/@Range[0,5],Translate[block["H"],{-1,0}],Translate[cnot[#,#+1],{#,0}]&/@Range[0,4],Text["input",{-3,-2.5},{0,-1},{0,1}],Text["output",{5,-2.5},{0,1},{0,1}],Translate[{Gray,Arrowheads[0.06],Arrow[{#,0}&/@{-1,4}],Text["time",{1.5,0},{0,-1}]},{0,0.6}]},ImageSize->210]]

(Ket[GHZ])=(((Ket[000…0])+(Ket[111…1]))/(Sqrt[2])).

Wires:

Horizontal lines represents qubits.

Time flows from left to right.

Gates: Placed along the wires to represent unitary operations acting on the corresponding qubits.

{H,(Subscript[R, ϕ])} ⋃ {CNOT}: Single-qubit rotation + entanglement

{H,S=(Subscript[R, π/2]),CNOT} ⋃ {T=(Subscript[R, π/4])}: Clifford gates + magic

{CCNOT} ⋃ {H}: Classical universality + quantum superposition

Quantum Measurements

Observables

the eigenvalues (Subscript[λ, i])∈ℝ are real numbers, representing the possible measurement outcomes;

the corresponding eigen states are (Ket[(Subscript[λ, i])]), forming an orthonormal basis (BraKet[(Subscript[λ, i]), (Subscript[λ, j])])=(Subscript[δ, i j]), also called the measurement basis of L.

Projective Measurement

Hermiticity: (Subscript[P, λ]^†)=(Subscript[P, λ]),

Orthogonality:

(Subscript[P, λ])(Subscript[P, λ'])=(Subscript[δ, λ λ'])(Subscript[P, λ]).

In particular, (Subscript[P, λ]^2)=(Subscript[P, λ]) is the defining property of projection operators.

Normalization condition:

(∑_λ)(Subscript[P, λ])=𝟙.

Show that the projection operators in Eq. () satisfy Eq. () and Eq. ().

(Subscript[P, λ])(Subscript[P, λ'])=(∑_((Subscript[λ, i])=λ))(Ket[(Subscript[λ, i])])(Bra[(Subscript[λ, i])])(∑_((Subscript[λ, i])=λ'))(Ket[(Subscript[λ, j])])(Bra[(Subscript[λ, j])])
=(∑_((Subscript[λ, i])=λ))(∑_((Subscript[λ, j])=λ'))(Ket[(Subscript[λ, i])])(BraKet[(Subscript[λ, i]), (Subscript[λ, j])])(Bra[(Subscript[λ, j])])

If λ≠λ', we have (Subscript[λ, i])=λ≠λ'=(Subscript[λ, j]), thus (BraKet[(Subscript[λ, i]), (Subscript[λ, j])])=0 since for Hermitian operators the eigenvectors of different eigenvalues are automatically orthogonal to each other. Therefore, (Subscript[P, λ])(Subscript[P, λ'])=0.

If λ=λ',

(Subscript[P, λ])(Subscript[P, λ])=(∑_((Subscript[λ, i])=λ))(∑_((Subscript[λ, j])=λ))(Ket[(Subscript[λ, i])])(Subscript[δ, i j])(Bra[(Subscript[λ, j])])
=(∑_((Subscript[λ, i])=λ))(Ket[(Subscript[λ, i])])(Bra[(Subscript[λ, i])])=(Subscript[P, λ]).

(∑_λ)(Subscript[P, λ])=(∑_λ)(∑_((Subscript[λ, i])=λ))(Ket[(Subscript[λ, i])])(Bra[(Subscript[λ, i])])
=(∑_i)(Ket[(Subscript[λ, i])])(Bra[(Subscript[λ, i])])=𝟙.

Projective measurement on pure states:

Pre-measurement state: (Ket[ψ]).

Probability distribution: Measure L, the probability to observe L=λ is

Post-measurement state (with post-selection):

Projective measurement on mixed states:

Pre-measurement state: ρ.

Probability distribution: Measure L, the probability to observe L=λ is

Post-measurement state (with post-selection):

With post-selection: the system will collapse to the specific post-measurement state

ρ(Underoverscript[→, (observe λ ), (measure L)])ρ'=(((Subscript[P, λ])ρ (Subscript[P, λ]))/(Tr ρ (Subscript[P, λ])))

Without post-selection: the system will be in a statistical mixture of all possible post-measurement states

ρ(Underoverscript[→, (ignore outcome ), (measure L)])ρ'=(∑_λ)p(λ)(((Subscript[P, λ])ρ (Subscript[P, λ]))/(Tr ρ (Subscript[P, λ])))=(∑_λ)(Subscript[P, λ])ρ (Subscript[P, λ]).

Z=(Ket[0])(Bra[0])-(Ket[1])(Bra[1])

(Subscript[P, +1])=(Ket[0])(Bra[0])≏(({{1, 0}, {0, 0}})),
(Subscript[P, -1])=(Ket[1])(Bra[1])≏(({{0, 0}, {0, 1}})).

ρ≏(({{(Subscript[ρ, 00]), (Subscript[ρ, 01])}, {(Subscript[ρ, 10]), (Subscript[ρ, 11])}})),

with probability (Subscript[p, +1])=Tr ρ (Subscript[P, +1])=(Subscript[ρ, 00]), the outcome Z=+1 will be observed, and the system collapses to

ρ'=(((Subscript[P, +1])ρ (Subscript[P, +1]))/(Tr ρ (Subscript[P, +1])))≏(({{1, 0}, {0, 0}}));

with probability (Subscript[p, -1])=Tr ρ (Subscript[P, -1])=(Subscript[ρ, 11]), the outcome Z=-1 will be observed, and the system collapses to

ρ'=(((Subscript[P, -1])ρ (Subscript[P, -1]))/(Tr ρ (Subscript[P, -1])))≏(({{0, 0}, {0, 1}}));

without post selection, the post-measurement state will be

ρ'≏(Subscript[ρ, 00])(({{1, 0}, {0, 0}}))+(Subscript[ρ, 11])(({{0, 0}, {0, 1}}))=(({{(Subscript[ρ, 00]), 0}, {0, (Subscript[ρ, 11])}})),

where the off-diagonal matrix element disappeared in the density matrix ρ', a phenomenon known as measurement-induced decoherence.

Indirect Measurement

({{⊗, , apparatus, , }, {, , (Ket[∅]), (Ket[+]), (Ket[-])}, {system, (Ket[0]), (Ket[0∅]), (Ket[0+]), (Ket[0 -])}, {, (Ket[1]), (Ket[1∅]), (Ket[1+]), (Ket[1 -])}})

Consider the system is a qubit to be measured in Z basis (two basis states: (Ket[0]) and (Ket[1])).

The apparatus has three states: (Ket[∅]) null (before measurement), (Ket[+]) positive (indicating Z=+1 outcome), (Ket[-]) negative (indicating Z=-1 outcome).

The system and apparatus together is a composite quantum system of 6-dimensional Hilbert space, with the 6 basis states in Eq. () arranged in the following order

{(Ket[0∅]),(Ket[0+]),(Ket[0-]),(Ket[1∅]),(Ket[1+]),(Ket[1-])}.

U=(Ket[0+])(Bra[0∅])-(Ket[0∅])(Bra[0+])+(Ket[0-])(Bra[0-])
+(Ket[1-])(Bra[1∅])-(Ket[1∅])(Bra[1-])+(Ket[1+])(Bra[1+]).

Show that U in Eq. () is indeed unitary (and therefore can be realized by a time-evolution in principle).

U≏(({{0, -1, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 0, -1}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 1, 0, 0}})).

U (SuperDagger[U])=(SuperDagger[U])U≏(({{1, 0, 0, 0, 0, 0}, {0, 1, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 0, 1, 0, 0}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 0, 0, 1}}))≏𝟙,

leaves the qubit state unchanged,

and flips the apparatus to (Ket[+]) (or (Ket[-])) state controlled by the state of the qubit being (Ket[0]) (or (Ket[1])),

(Ket[ψ])=(Subscript[ψ, 0])(Ket[0])+(Subscript[ψ, 1])(Ket[1]),

(Ket[ψ])⊗(Ket[∅])=(Subscript[ψ, 0])(Ket[0∅])+(Subscript[ψ, 1])(Ket[1∅]),

U((Ket[ψ])⊗(Ket[∅]))=(Subscript[ψ, 0])(Ket[0+])+(Subscript[ψ, 1])(Ket[1-]).

If the apparatus reads + (or -), the qubit is in the (Ket[0]) (or (Ket[1])) state. Moreover, the probability for the measurement outcome Z=+1 to appear is ((|(Subscript[ψ, 0])|)^2), exactly the same as the probability of the qubit being observed in the (Ket[0]) state. — No explicit collapse is needed. The qubit and the apparatus evolves into an entangled reality under unitary time evolution.

When an external observer reads the apparatus, they will be involved into the entangled state. When the observer publishes their observation to the world, the entire world will be entangled … — This is the multi-worlds interpretation of quantum mechanics.

Observing the apparatus still collapses the joint quantum state: the measurement of the qubit can be equivalently implemented by measuring the apparatus that has interacted with it, i.e. an indirect measurement. Collapsing the apparatus (by projecting the apparatus to (Ket[±]) states) induces a corresponding projection operator (Subscript[P, ±]) acting on the qubit:

Block[{ket,bra,opH,opU,opD},
ket[txt_,pos_:{0,0},θ_:0]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Polygon[CirclePoints[{1,θ},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
bra[txt_,pos_:{0,0},θ_:0]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Polygon[CirclePoints[{1,π+θ},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opH[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Red,0.8],Disk[{0,0},0.8]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opU[txt_,{w_,h_},pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Green,0.8],Polygon[{{w,h},{-w,h},{-w,-h},{w,-h}}]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opD[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Yellow,0.8],Polygon[CirclePoints[{0.8,0},4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
Graphics[{Translate[{Translate[Line[{0,#}&/@{-2,2}],{#,0}]&/@{-1,1},opU["U",{1.5,0.75},{0,0}],ket["ψ",{-1,-2},-π/2],ket["∅",{1,-2},-π/2],bra["±",{1,2},-π/2]},{-3,0}],Text["=",{0,0}],Translate[{Line[{0,#}&/@{-2,2}],ket["ψ",{0,-2},-π/2],opH["P\_±"]},{2,0}]},ImageSize->{Automatic,80}]]

Given U in Eq. (), calculate (Subscript[P, ±]) in Eq. ().

U≏(({{0, -1, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 0, -1}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 1, 0, 0}})).

(Ket[∅])≏(({{1, 0}, {0, 1}}))⊗(({{1}, {0}, {0}}))=(({{1, 0}, {0, 0}, {0, 0}, {0, 1}, {0, 0}, {0, 0}})).

(Bra[+])≏(({{1, 0}, {0, 1}}))⊗(({{0, 1, 0}}))=(({{0, 1, 0, 0, 0, 0}, {0, 0, 0, 0, 1, 0}})),
(Bra[-])≏(({{1, 0}, {0, 1}}))⊗(({{0, 0, 1}}))=(({{0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 0, 1}})).

(SubPlus[P])=(Bra[+])U(Ket[∅])
≏(({{0, 1, 0, 0, 0, 0}, {0, 0, 0, 0, 1, 0}}))(({{0, -1, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 0, -1}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 1, 0, 0}}))(({{1, 0}, {0, 0}, {0, 0}, {0, 1}, {0, 0}, {0, 0}}))
=(({{0, 1, 0, 0, 0, 0}, {0, 0, 0, 0, 1, 0}}))(({{0, 0}, {1, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 1}}))
=(({{1, 0}, {0, 0}}))≏(Ket[0])(Bra[0]).

(SubMinus[P])=(Bra[-])U(Ket[∅])
≏(({{0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 0, 1}}))(({{0, -1, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 0, -1}, {0, 0, 0, 0, 1, 0}, {0, 0, 0, 1, 0, 0}}))(({{1, 0}, {0, 0}, {0, 0}, {0, 1}, {0, 0}, {0, 0}}))
=(({{0, 0, 1, 0, 0, 0}, {0, 0, 0, 0, 0, 1}}))(({{0, 0}, {1, 0}, {0, 0}, {0, 0}, {0, 0}, {0, 1}}))
=(({{0, 0}, {0, 1}}))≏(Ket[1])(Bra[1]).

which are exactly the projection operators describing the projective measurement of the qubit in the Z basis. — State collapse can back propagate from apparatus to system.

The collapse of the system is caused by the collapse of the apparatus, that the causality appears to flow backward in time in quantum measurement.

If the apparatus is subsequently observed by an external observer, the underlying cause of the collapse is further traced back to the observer. This implies a recursive observer hierarchy, such that the origin of collapse can be recursively traced back forever.

Generalized Measurement

Projective measurement is disruptive: providing maximal information about the measurement outcome at the cost of fully collapse the state.

Generalized measurement is a less disruptive form of quantum measurement that only partially disturb the state, but providing only limited information about the observable.

H=i g ((Ket[0+])(Bra[0∅])-(Ket[0∅])(Bra[0+])+(Ket[1-])(Bra[1∅])-(Ket[1∅])(Bra[1-])),

U=(e^(-i H))

Show that H in Eq. () generates U in Eq. () with g=π/2.

H≏i g(({{0, -1, 0, 0, 0, 0}, {1, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 0, 0, -1}, {0, 0, 0, 0, 0, 0}, {0, 0, 0, 1, 0, 0}})).

MatrixExp[-I(I π/2{{0,-1,0,0,0,0},{1,0,0,0,0,0},{0,0,0,0,0,0},{0,0,0,0,0,-1},{0,0,0,0,0,0},{0,0,0,1,0,0}})]//MatrixForm

With generic coupling strength g, the initial states will be transformed by U as

(Ket[0∅])→U(Ket[0∅])=cos g (Ket[0∅])+sin g (Ket[0+]),
(Ket[1∅])→U(Ket[1∅])=cos g (Ket[1∅])+sin g (Ket[1-]).

Now if we observe the apparatus, there are three possible outcomes: (Ket[∅]) null, (Ket[+]) positive, (Ket[-]) negative.

Each outcome on the apparatus is associated with an effective Kraus operator acting on the system:

Block[{ket,bra,opH,opU,opD},
ket[txt_,pos_:{0,0},θ_:0]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Polygon[CirclePoints[{1,θ},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
bra[txt_,pos_:{0,0},θ_:0]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Polygon[CirclePoints[{1,π+θ},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opH[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Red,0.8],Disk[{0,0},0.8]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opU[txt_,{w_,h_},pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Green,0.8],Polygon[{{w,h},{-w,h},{-w,-h},{w,-h}}]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opD[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Yellow,0.8],Polygon[CirclePoints[{0.8,0},4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
Graphics[{Translate[{Translate[Line[{0,#}&/@{-2,2}],{#,0}]&/@{-1,1},opU["U",{1.5,0.75},{0,0}],ket["ψ",{-1,-2},-π/2],ket["∅",{1,-2},-π/2],bra["λ",{1,2},-π/2]},{-3,0}],Text["=",{0,0}],Translate[{Line[{0,#}&/@{-2,2}],ket["ψ",{0,-2},-π/2],opH["K\_λ"]},{2,0}]},ImageSize->{Automatic,80}]]

(Subscript[K, ∅])=(Bra[∅])U(Ket[∅])=cos g (({{1, 0}, {0, 1}})),
(SubPlus[K])=(Bra[+])U(Ket[∅])=sin g (({{1, 0}, {0, 0}})),
(SubMinus[K])=(Bra[-])U(Ket[∅])=sin g (({{0, 0}, {0, 1}})).

Calculate the operator (Subscript[K, λ]).

Block[{H,U,id},
H=I g{{0,-1,0,0,0,0},{1,0,0,0,0,0},{0,0,0,0,0,0},{0,0,0,0,0,-1},{0,0,0,0,0,0},{0,0,0,1,0,0}};
U=MatrixExp[-I H];
id={{1,0},{0,1}};
MatrixForm[KroneckerProduct[id,{#}].U.KroneckerProduct[id,{{1},{0},{0}}]]&/@{{1,0,0},{0,1,0},{0,0,1}}]

The Kraus operator specifies how the system should response to the observation outcome of the apparatus.

The probability to observe apparatus in the state (Ket[μ]) should be given by

The normalization condition (∑_λ)p(λ)=1 requires that

(∑_λ)(Subscript[K, λ]^†)(Subscript[K, λ])=𝟙,

which is indeed satisfied by the Kraus operators (Subscript[K, λ]) in Eq. ().

Weak measurement corresponds to the limit when the coupling strength g→0. In this limit, the probability to read out ± from the apparatus is small:

p(±)∼(g^2),

meaning that

the measurement provides little information about the system,

but the system is also rarely collapsed by measurement.

Quantum Channels

Kraus Theorem

ρ→ρ'=ℰ(ρ).

Completely Positive: the map should preserve the positivity of ρ, even when extended to a larger system.

(ℰ⊗id)(ρ)\[VectorGreaterEqual]0.

Trace-Preserving: the total probability should remains 1.

Tr ℰ(ρ)=1.

(∑_λ)(Subscript[K, λ]^†)(Subscript[K, λ])=𝟙.

Unitary evolution: only one Kraus operator, and it is unitary K=U,

ℰ(ρ)=U ρ (SuperDagger[U]).

Projective measurement (without post-selection): Kraus operators are projection operators (Subscript[K, λ])=(Subscript[P, λ]), see Eq. (), as

ℰ(ρ)=(∑_λ)(Subscript[P, λ])ρ (Subscript[P, λ]).

Generalized measurement (without post-selection): generic Kraus operator, falls back to Eq. ().

Quantum Decoherence

Decoherence explains why quantum system often appear classical.

Decoherence models real-world noise in quantum computation and communication.

(Ket[ψ])=(Subscript[ψ, 0])(Ket[0])+(Subscript[ψ, 1])(Ket[1]),
ρ=(Ket[ψ])(Bra[ψ])≏(({{(Subscript[ψ, 0]^( * ))(Subscript[ψ, 0]), (Subscript[ψ, 1]^( * ))(Subscript[ψ, 0])}, {(Subscript[ψ, 0]^( * ))(Subscript[ψ, 1]), (Subscript[ψ, 1]^( * ))(Subscript[ψ, 1])}}))=(({{(Subscript[ρ, 00]), (Subscript[ρ, 01])}, {(Subscript[ρ, 10]), (Subscript[ρ, 11])}})).

Time-Averaging: Under unitary time evolution driven by the Hamiltonian

H=Z≏(({{1, 0}, {0, -1}})),

the density matrix evolves as

ρ(t)=(e^(-i H t))ρ (e^(i H t))≏(({{(Subscript[ρ, 00]), (Subscript[ρ, 01])(e^(-2i t))}, {(Subscript[ρ, 10])(e^(2i t)), (Subscript[ρ, 11])}})).

Suppose we do not have a good resolution of time, averaging the density matrix over a long enough time window, the effective state is

(OverBar[ρ])=(1/(2T))(∫_(-T)^T)ρ(t)=(({{(Subscript[ρ, 00]), (Subscript[ρ, 01])((sin(2T))/(2T))}, {(Subscript[ρ, 10])((sin(2T))/(2T)), (Subscript[ρ, 11])}})).

The off-diagonal matrix element will decay toward 0 as T→∞:

Plot[Sin[2T]/(2T),{T,0,20},PlotStyle->Black,PlotRange->All,FrameLabel->{"\!\( T\)","\!\(sin(2T)/(2T)\)"},ImageSize->200]

Key points:

Loss of coherence due to the inability to resolve fast oscillations over time.

A classical averaging effect and does not involve an external interaction with the system.

Measurement-Induced: Measure the qubit in Z basis and forget about the measurement outcome (measurement without post-selection). The state will undergo the following channel

ρ→ℰ(ρ)=(∑_(λ=±))(Subscript[P, λ])ρ (Subscript[P, λ]),

where (Subscript[P, ±])=(𝟙±Z)/2. As a result,

ℰ(ρ)≏(({{(Subscript[ρ, 00]), 0}, {0, (Subscript[ρ, 11])}})),

the off-diagonal matrix elements are removed.

Key points:

Loss of coherence due to interaction with environment, effectively “measuring” the system and collapsing it into the Z-basis.

Explicitly involves interaction with an external system.

Depolarizing Channel

For a single qubit:

Krause operators:

(Subscript[K, 0])=(Sqrt[1-p])I,(Subscript[K, 1])=(Sqrt[(p/2)])X,(Subscript[K, 2])=(Sqrt[(p/2)])Y,(Subscript[K, 3])=(Sqrt[(p/2)])Z.

Phase Damping (Dephasing) Channel

For a single qubit:

Krause operators:

(Subscript[K, ±])=(Sqrt[((1-p)/2)])I±(Sqrt[(p/2)])Z.

Lindbladian Dynamics

ρ(t+dt)=ℰ(ρ(t))=(∑_(λ=0)^n)(Subscript[K, λ])ρ(t)(Subscript[K, λ]^†),

(Subscript[K, 0])=𝟙-i H dt-(1/2)(∑_(i=1)^n)(Subscript[L, i]^†)(Subscript[L, i])dt,
(Subscript[K, i])=(Sqrt[dt])(Subscript[L, i])   (for i=1,…,n),

H is the Hamiltonian, driving the unitary time evolution;

(Subscript[L, i]) are Lindblad (jump) operators, describing dissipation effects in open quantum systems.

Show that the set of Kraus operators in Eq. () satisfies the normalization condition (∑_(λ=0)^n)(Subscript[K, λ]^†)(Subscript[K, λ])=𝟙 to the leading order in dt.

(∑_(λ=0)^n)(Subscript[K, λ]^†)(Subscript[K, λ])=(Subscript[K, 0]^†)(Subscript[K, 0])+(∑_(i=1)^n)(Subscript[K, i]^†)(Subscript[K, i])
=(𝟙+i H dt-(1/2)(∑_(i=1)^n)(Subscript[L, i]^†)(Subscript[L, i])dt)(𝟙-i H dt-(1/2)(∑_(i=1)^n)(Subscript[L, i]^†)(Subscript[L, i])dt)+(∑_(i=1)^n)(Subscript[L, i]^†)(Subscript[L, i])dt
=𝟙+i H dt-(1/2)(∑_(i=1)^n)(Subscript[L, i]^†)(Subscript[L, i])dt-i H dt-(1/2)(∑_(i=1)^n)(Subscript[L, i]^†)(Subscript[L, i])dt+(∑_(i=1)^n)(Subscript[L, i]^†)(Subscript[L, i])dt+𝒪(d(t^2))
=𝟙+𝒪(d(t^2)).

Derive Eq. ().

ℰ(ρ)=(∑_(λ=0)^n)(Subscript[K, λ])ρ (Subscript[K, λ]^†)
=(Subscript[K, 0])ρ (Subscript[K, 0]^†)+(∑_(i=0)^n)(Subscript[K, i])ρ (Subscript[K, i]^†)
=(𝟙-i H dt-(1/2)(∑_(i=1)^n)(Subscript[L, i]^†)(Subscript[L, i])dt)ρ (𝟙+i H dt-(1/2)(∑_(i=1)^n)(Subscript[L, i]^†)(Subscript[L, i])dt)+(∑_(i=0)^n)(Subscript[L, i])ρ (Subscript[L, i]^†)dt
=ρ-i H ρ dt-(1/2)(∑_(i=1)^n)(Subscript[L, i]^†)(Subscript[L, i])ρdt+i ρ H dt-(1/2)(∑_(i=1)^n)ρ (Subscript[L, i]^†)(Subscript[L, i])dt+(∑_(i=0)^n)(Subscript[L, i])ρ (Subscript[L, i]^†)dt
=ρ-i [H,ρ]dt+(∑_(i=0)^n)((Subscript[L, i])ρ (Subscript[L, i]^†)-(1/2){(Subscript[L, i]^†)(Subscript[L, i]),ρ})dt

ℰ(ρ)=ρ(t+dt)=ρ+(∂_t)ρdt+….

(∂_t)ρdt=-i [H,ρ]dt+(∑_(i=0)^n)((Subscript[L, i])ρ (Subscript[L, i]^†)-(1/2){(Subscript[L, i]^†)(Subscript[L, i]),ρ})dt,

The first term -i [H,ρ] is inherited from the von Neumann equation of mixed state unitary dynamics.

The second term describes the dissipation effect: (Subscript[L, i])ρ (Subscript[L, i]^†) captures the change of density matrix under dissipation and -(1/2){(Subscript[L, i]^†)(Subscript[L, i]),ρ} takes care of the trace preservation.

Quantum Protocols

Quantum Teleportation

Block[{},
Graphics[{Arrowheads[0.05],Arrow@BSplineCurve[{{0,0},{1,1},{2,1},{5,1}}],
Arrow@BSplineCurve[{{0,0},{1,-1},{2,-1},{3,-1}}],
Arrow[{{#,-1.5}&/@{0,3}}],Arrow[{{#,1}&/@{5,7}}],{Dashed,Line[{{3,-1},{5.2,0.6}}]},Point[{0,0}],{EdgeForm[Black],Lighter[Red,0.7],Rectangle[{3,-1.7},{3.4,-0.8},RoundingRadius->0.2],Lighter[Blue,0.7],Rectangle[{5,1.4},{5.4,0.6},RoundingRadius->0.2]},{Red,Text["Alice",{3.5,-1.3},{-1,0}],Blue,Text["Bob",{5.5,1.2},{-1,0}]},Text["\!\(B,\)",{3,1},{0,1}],Text["\!\(A,\)",{2,-1},{0,-1}],Text["\!\(A\^′\)",{1.5,-1.5},{0,1}],Text[Style["share\nEPR pair",LineSpacing->{0,12}],{0,0},{1.2,0}],Text[Style["classical\ncommunication",LineSpacing->{0,12}],{6.,-0.3}],Text[Style["joint\nmeasurement",LineSpacing->{0,12}],{3.5,-1.7},{0,1}],Text[Style["conditional\noperation",LineSpacing->{0,12}],{5,1.3},{0,-1}],Text["(Ket[?])",{0,-1.5},{1,0}]},ImageSize->250]]

The model involves three qubits: A', A and B.

Establish quantum entanglement: A and B qubits are prepared in an EPR state, and shared between Alice and Bob respectively

(Subscript[(Ket[EPR]), A B])=(1/(Sqrt[2]))((Ket[(Subscript[↑, A])(Subscript[↑, B])])+(Ket[(Subscript[↓, A])(Subscript[↓, B])]))≏(1/(Sqrt[2]))(({{1}, {0}, {0}, {1}})).

A' qubit is in an unknown quantum state in Alice’s possession

(Subscript[(Ket[ψ]), A'])=α(Ket[(Subscript[↑, A'])])+β(Ket[(Subscript[↓, A'])])≏(({{α}, {β}})),

(Alice knowns that the single-qubit pure state must take this form, but does not need to know what α,β are.)

The three-qubit system is in a joint state

(Ket[Ψ])=(Subscript[(Ket[ψ]), A'])⊗(Subscript[(Ket[EPR]), A B])≏(({{α}, {β}}))⊗(1/(Sqrt[2]))(({{1}, {0}, {0}, {1}}))

Goal: to teleport the quantum state (Ket[ψ]) from A' to B without handing the qubit A' to Bob.

Alice makes a joint measurement of A' and A, by observing (Subscript[σ, A']^x)(Subscript[σ, A]^x) and (Subscript[σ, A']^z)(Subscript[σ, A]^z) (note that they are commuting observables that can be measured simultaneously). There are four possible outcomes

({{(Subscript[σ, A']^x)(Subscript[σ, A]^x), +1, +1, -1, -1}, {(Subscript[σ, A']^z)(Subscript[σ, A]^z), +1, -1, +1, -1}, {(Subscript[P, a b]), (Subscript[P, ++]), (Subscript[P, +-]), (Subscript[P, -+]), (Subscript[P, --])}}),

each corresponds to a projection operator (labeled by the measurement outcomes a:=(Subscript[σ, A']^x)(Subscript[σ, A]^x)=±1, b:=(Subscript[σ, A']^z)(Subscript[σ, A]^z)=±1)

(Subscript[P, a b])=((𝟙+a (Subscript[σ, A']^x)(Subscript[σ, A]^x))/2)((𝟙+b (Subscript[σ, A']^z)(Subscript[σ, A]^z))/2)
≏(1/4)(({{1+b, 0, 0, a (1+b)}, {0, 1-b, a(1-b), 0}, {0, a(1-b), 1-b, 0}, {a (1+b), 0, 0, 1+b}}))⊗(({{1, 0}, {0, 1}})).

After the measurement, the three-qubit state will collapse to

(Ket[Ψ])(Overscript[→, (Subscript[σ, A']^x)(Subscript[σ, A]^x)=a, (Subscript[σ, A']^z)(Subscript[σ, A]^z)=b])(((Subscript[P, a b])(Ket[Ψ]))/(normalization...)),

more explicitly as

(Subscript[P, a b])(Ket[Ψ])≏(1/(4(Sqrt[2])))(({{α (1+b)}, {β a (1+b)}, {β a (1-b)}, {α (1-b)}, {β (1-b)}, {α a (1-b)}, {α a (1+b)}, {β (1+b)}})).

Let us enumerate all four cases

({{(Subscript[σ, A']^x)(Subscript[σ, A]^x), +1, +1, -1, -1}, {(Subscript[σ, A']^z)(Subscript[σ, A]^z), +1, -1, +1, -1}, {(Subscript[P, a b])(Ket[Ψ]), (({{α}, {β}, {0}, {0}, {0}, {0}, {α}, {β}})), (({{0}, {0}, {β}, {α}, {β}, {α}, {0}, {0}})), (({{α}, {-β}, {0}, {0}, {0}, {0}, {-α}, {β}})), (({{0}, {0}, {-β}, {α}, {β}, {-α}, {0}, {0}}))}}),

It turns out that they can all be written as the tensor product state between A'A and B as

({{(Subscript[σ, A']^x)(Subscript[σ, A]^x), (Subscript[σ, A']^z)(Subscript[σ, A]^z), (Subscript[P, a b])(Ket[Ψ])}, {+1, +1, (({{1}, {0}, {0}, {1}}))⊗(({{α }, {β}}))}, {+1, -1, (({{0}, {1}, {1}, {0}}))⊗(({{β }, {α}}))}, {-1, +1, (({{1}, {0}, {0}, {-1}}))⊗(({{α }, {-β}}))}, {-1, -1, (({{0}, {1}, {-1}, {0}}))⊗(({{-β }, {α}}))}})

or in terms of ket state notation as

(Subscript[P, ++])(Ket[Ψ])=(1/(Sqrt[2]))((Ket[(Subscript[↑, A'])(Subscript[↑, A])])+(Ket[(Subscript[↓, A'])(Subscript[↓, A])]))⊗(α(Ket[(Subscript[↑, B])])+β(Ket[(Subscript[↓, B])])),
(Subscript[P, +-])(Ket[Ψ])=(1/(Sqrt[2]))((Ket[(Subscript[↑, A'])(Subscript[↓, A])])+(Ket[(Subscript[↓, A'])(Subscript[↑, A])]))⊗(β(Ket[(Subscript[↑, B])])+α(Ket[(Subscript[↓, B])])),
(Subscript[P, -+])(Ket[Ψ])=(1/(Sqrt[2]))((Ket[(Subscript[↑, A'])(Subscript[↑, A])])-(Ket[(Subscript[↓, A'])(Subscript[↓, A])]))⊗(α(Ket[(Subscript[↑, B])])-β(Ket[(Subscript[↓, B])])),
(Subscript[P, --])(Ket[Ψ])=(1/(Sqrt[2]))((Ket[(Subscript[↑, A'])(Subscript[↓, A])])-(Ket[(Subscript[↓, A'])(Subscript[↑, A])]))⊗(-β(Ket[(Subscript[↑, B])])+α(Ket[(Subscript[↓, B])])).

Alice will tell Bob her measurement outcome

((Subscript[σ, A']^x)(Subscript[σ, A]^x)=a,(Subscript[σ, A']^z)(Subscript[σ, A]^z)=b),

via a classical communication channel (e.g. by making a phone call).

If (a,b)=++, the qubit B is in the state

α(Ket[(Subscript[↑, B])])+β(Ket[(Subscript[↓, B])])=(Subscript[(Ket[ψ]), B]).

There is nothing more Bob needs to do. The state (Ket[ψ]) has been teleported to B successfully.

If (a,b)=+-, the qubit B is in the state

β(Ket[(Subscript[↑, B])])+α(Ket[(Subscript[↓, B])]),

Bob will apply a (Subscript[σ, B]^x) operator to the qubit B

(Subscript[σ, B]^x)(β(Ket[(Subscript[↑, B])])+α(Ket[(Subscript[↓, B])]))=α(Ket[(Subscript[↑, B])])+β(Ket[(Subscript[↓, B])])=(Subscript[(Ket[ψ]), B]),

then the qubit B is converted to the state (Ket[ψ]).

If (a,b)=-+, the qubit B is in the state

α(Ket[(Subscript[↑, B])])-β(Ket[(Subscript[↓, B])]),

Bob will apply a (Subscript[σ, B]^z) operator to the qubit B

(Subscript[σ, B]^z)(α(Ket[(Subscript[↑, B])])-β(Ket[(Subscript[↓, B])]))=α(Ket[(Subscript[↑, B])])+β(Ket[(Subscript[↓, B])])=(Subscript[(Ket[ψ]), B]),

then the qubit B is converted to the state (Ket[ψ]).

If (a,b)=+-, the qubit B is in the state

-β(Ket[(Subscript[↑, B])])+α(Ket[(Subscript[↓, B])]),

Bob will apply the composite operator (Subscript[σ, B]^z)(Subscript[σ, B]^x) to the qubit B

(Subscript[σ, B]^z)(Subscript[σ, B]^x)(-β(Ket[(Subscript[↑, B])])+α(Ket[(Subscript[↓, B])]))=α(Ket[(Subscript[↑, B])])+β(Ket[(Subscript[↓, B])])=(Subscript[(Ket[ψ]), B]),

then the qubit B is converted to the state (Ket[ψ]).

Block[{},
Graphics[{Arrowheads[0.05],Arrow@BSplineCurve[{{0,0},{1,1},{2,1},{5,1}}],
Arrow@BSplineCurve[{{0,0},{1,-1},{2,-1},{3,-1}}],
Arrow[{{#,-1.5}&/@{0,3}}],Arrow[{{#,1}&/@{5,7}}],{Dashed,Line[{{3,-1},{5.2,0.6}}]},Point[{0,0}],{EdgeForm[Black],Lighter[Red,0.7],Rectangle[{3,-1.7},{3.4,-0.8},RoundingRadius->0.2],Lighter[Blue,0.7],Rectangle[{5,1.4},{5.4,0.6},RoundingRadius->0.2]},{Red,Text["Alice",{3.5,-1.3},{-1,0}],Blue,Text["Bob",{5.5,1.2},{-1,0}]},Text["\!\(B,\)",{3,1},{0,1}],Text["\!\(A,\)",{2,-1},{0,-1}],Text["\!\(A\^′\)",{1.5,-1.5},{0,1}],Text[Style["share\nEPR pair",LineSpacing->{0,12}],{0,0},{1.2,0}],Text[Style["classical\ncommunication",LineSpacing->{0,12}],{6.,-0.3}],Text[Style["joint\nmeasurement",LineSpacing->{0,12}],{3.5,-1.7},{0,1}],Text[Style["conditional\noperation",LineSpacing->{0,12}],{5,1.3},{0,-1}],Text["(Ket[?])",{0,-1.5},{1,0}]},ImageSize->250]]

Alice and Bob establish shared a entanglement resource (e.g. a EPR pair).

For any unknown state (Subscript[(Ket[ψ]), A']) handed to Alice, she measures  (Subscript[σ, A']^x)(Subscript[σ, A]^x) and (Subscript[σ, A']^z)(Subscript[σ, A]^z).

Alice tells Bob her the measurement outcomes by classical communication.

Depending on the information, Bob performs conditional operation on his qubit

({{(Subscript[σ, A']^x)(Subscript[σ, A]^x), (Subscript[σ, A']^z)(Subscript[σ, A]^z), Bob’s operation}, {+1, +1, (Subscript[𝟙, B])}, {+1, -1, (Subscript[σ, B]^x)}, {-1, +1, (Subscript[σ, B]^z)}, {-1, -1, (Subscript[σ, B]^z)(Subscript[σ, B]^x)}}).

After the operation, the state (Ket[ψ]) will appear on Bob’s qubit.

The original state (Ket[ψ]) on qubit A' is destroyed in the process → No-Cloning Theorem: it is impossible to create an identical copy of an arbitrary unknown state. You can only teleport an unknown state but not duplicate it.

Traversable wormhole ⇔ interstellar quantum teleportation.

Entanglement resource: wormhole ⇔ entangled pairs of black holes

Classical communication: classical interaction between two black holes

Quantum Search

Given a bit string x and a query function Q(x) that tells if x is the target.

({{x,  , Q(x),  }, {0000, →, 0, no}, {0001, →, 0, no}, {⋮,  , ⋮,  }, {0110, →, 1, yes!}, {⋮,  , ⋮,  }})

Assuming there is only one target bit string to look for, the goal is to find it!

Classical computer ∼ 𝒪(N),

Quantum computer (Grover’s algorithm) ∼ 𝒪((N^(1/2))). The quantum speedup can be significant when N is large.

(Ket[s])=(1/(Sqrt[N]))((Ket[0000])+(Ket[0001])+…+(Ket[0110])+…)
=(1/(Sqrt[N]))(∑_x)(Ket[x]).

Initially, all bit string states (Ket[x]) have equal probability 1/N in a uniform superposition state (Ket[s]).

Grover’s algorithm iteratively enhance the probability of the target state by quantum interference.

After about (N^(1/2)) steps, the target state emerges as the probability ~1 state.

Quantum query (in parallel)

(Subscript[U, Q])(Ket[x])=(((-1))^(Q(x)))(Ket[x]).

It simply marks the target state with a minus sign. Let (Ket[t]) be the target state, Eq. () can also be written as

(Subscript[U, Q])(Ket[x])=(Ket[x])-2(Ket[t])(BraKet[t, x]).

Grover diffusion

(Subscript[U, G])(Ket[x])=2(Ket[s])(BraKet[s, x])-(Ket[x]),

which reflect any state about the source state (Ket[s]).

(Ket[(Subscript[t, ⊥])])=(1/(Sqrt[N-1]))(∑_(x≠t))(Ket[x]).

In each iteration, the quantum query (Subscript[U, Q])=𝟙-2(Ket[t])(Bra[t]) reflects any state vector about (Ket[(Subscript[t, ⊥])]), and the Grover diffusion (Subscript[U, G])=2(Ket[s])(Bra[s])-𝟙 reflects any state vector about (Ket[s]).

Block[{θ=2π/32},
Graphics[{{Arrowheads[0.08],#3,Arrow[{{0,0},ReIm@Exp[I θ #1]}],Text["\!\("<>#2<>"\)",1.1ReIm@Exp[I θ #1],{-1,0}]}&@@@{{0,"(Ket[(Subscript[t, ⊥])])",Blue},{1,"(Ket[s])",Red},{-1,"(Subscript[U, Q])(Ket[s])",Black},{3,"(Subscript[U, G])(Subscript[U, Q])(Ket[s])",Black},{-3,"(Subscript[U, Q])(Subscript[U, G])(Subscript[U, Q])(Ket[s])",Black},{5,"(Subscript[U, G])(Subscript[U, Q])(Subscript[U, G])(Subscript[U, Q])(Ket[s])",Black},{8,"(Ket[t])",Green}},
{{AbsoluteThickness[1],Circle[{0,0},0.4#1,θ {#2,#3}],Text[#4,ReIm[(0.4 #1+0.05) Exp[I θ(#2+#3)/2]],{-1,0}]}&@@@{{1,0,1,"θ"},{1,0,-1,"θ"},{0.8,1,3,"2θ"},{1,3,5,"2θ"},{0.8,-1,-3,"2θ"}}}},PlotRangePadding->Scaled[0.05],ImageSize->180]]

Two reflections make a rotation of 2θ angle, where the θ denotes the angle between the two reflection axes (i.e. the angle between (Ket[s]) and (Ket[(Subscript[t, ⊥])])) and is given by

sin θ=(BraKet[s, t])=(1/(Sqrt[N])),

After k steps of Grover iterations, the source state (Ket[s]) is rotated away from (Ket[(Subscript[t, ⊥])]) by (2k+1)θ.

To rotate the state from (Ket[s]) to (Ket[t]) (which is π/2 from (Ket[(Subscript[t, ⊥])])),  the total rotation angle must accumulates to π/2

(π/2)=(2k+1)θ,

such that the solution for k is given by

k=(1/2)((π/(2θ))-1)=(1/2)((π/(2arcsin (N^(-1/2))))-1).

In the large N limit (when there are many bit strings to search),

k≈(π/4)(Sqrt[N]),

which is indeed of order (N^(1/2)) as mentioned.

Block[{L=8,h=2,d=4},
Graphics[{{AbsoluteThickness[1.2],
{Red,Table[Arrow@BSplineCurve[{{x-2,-h-4},{x-1,-h-2.5},{x,-h-1},{x,-h}}],{x,2}]},
{Black,{Arrowheads[{-0.04,0.04}],Table[Arrow@BSplineCurve[{{x,-h},{x,-h-0.1},{x,-h-0.1},{x,-h-2-(L-x)/2},{2L-x+d,-h-2-(L-x)/2},{2L-x+d,-h-0.1},{2L-x+d,-h},{2L-x+d,h+4}}],{x,3,L}]},
Table[Arrow[{{x,h},{x,h+4}}],{x,5}]},
{Blue,Table[Arrow@BSplineCurve[{{x,h},{x,h+0.5},{x,h+1},{x+d-1,h+3},{x+d-1,h+4}}],{x,6,L}]}},{EdgeForm[Directive[Black,AbsoluteThickness[1.2]]],LightGray,Rectangle[{0.5,-h},{L+0.5,h},RoundingRadius->0.5]},
{Red,Text[Style["Alice's",12],{-1,-7}],Text[Style["qudits",12],{-1,-8.5}]},
{Black,Text[Style["EPR pairs",12],{10.5,-7.5}],
Text[Style["black",12],{3,8.5}],Text[Style["hole",12],{3,7}]},
{Blue,Text[Style["radiation",12],{7.5,6.5},{0,0},{1,2}],
Text[Style["Bob's",12],{13,9}],Text[Style["decoding",12],{13,7.5}],
Translate[Block[{a=0.5,l=4.5},{AbsoluteThickness[1],Scale[BSplineCurve[{{0,a},{0,0},{a,0},{l-a,0},{l,0},{l,-a}}],{#,1},{0,0}]&/@{1,-1}}],{13,6.5}]},
{{Red,Text["\!\(A \)",{-0.5,-h-1}]},{Black,Text["\!\(B \)",{3,-h-4.2}],Text["\!\(B\^′\)",{17,-h-4.2}],Text["\!\(C \)",{-0.5,h+0.5}]},
{Blue,Text["\!\(D \)",{L+2,h+0.5}]}},
Text["\!\(U(t)\)",{(L+1)/2,0}]},ImageSize->150]]

Resources needed:

Entanglement resource: the black hole (on Alice’s side) must be entangled with another black hole (on Bob’s side) in the lab (effectively forming a wormhole).

Quantum computation resource: a strong enough quantum computer to simulate the quantum dynamics of black hole and to perform quantum search.

Basic idea: Hawking radiation is an efficient encoding of the object that falls into the black hole (black hole is very much like a quantum hash function).

Collect the Hawking radiation a few moments after the object has fallen into the black hole on Alice’s side.

Try to decode the Hawking radiation to recover the quantum information of the object ⇔ quantum teleportation of the object through the wormhole.

Block[{a=1,gate,pair},
gate[name_,{x_,y_}]:=Translate[{{EdgeForm[Directive[Black,AbsoluteThickness[1.2]]],LightGray,Rectangle[{-2,-1},{2,1},RoundingRadius->0.5]},Text[name]},{x,y}];
pair[{x1_,x2_},y_]:=BSplineCurve[{{x1,0},{x1,0},{x1,y+a},{x1,y},{x1+a,y},{x2-a,y},{x2,y},{x2,y+a},{x2,0},{x2,0}}];
Graphics[{{{Lighter[Blue,0.8],Rectangle[{0,-2.5},{6.5,5},RoundingRadius->.3]},
{Blue,Text["decoder",{3,5},{0,-0.5}]}},
{AbsoluteThickness[1.2],Translate[pair[{-#2,#2},-1],{#1,-1}]&@@@{{0,2},{5,1}},
BSplineCurve[{{-2,1},{-2,1.5},{-2,2},{1,2},{1,2.5},{1,3}}],
Line[{{2,1},{2,3}}],
Line[{{6,-1},{6,5.5}}],
Line[{{-4,-1},{-4,-3}}],
Line[{{#,1},{#,3}}]&/@{-4,4}},{gate["\!\(U(t)\)",{-3,0}],gate["\!\(U\^*(t)\)",{3,0}]},
{{EdgeForm[Directive[Black,AbsoluteThickness[1.2]]],LightYellow,
Triangle[{{0.5,3},{2.5,3},{1.5,4}}]},Text["EPR",{1.5,4},{0,-0.5}]},
{Text["\!\(A\^″\)",{6,6}],
Text["\!\(A \)",{-4.5,-2}],Text["\!\(A\^′\)",{3.6,-2}],
Text["\!\(B \)",{-2.4,-2}],Text["\!\(B\^′\)",{2.4,-2}],
Text["\!\(C \)",{-4.5,1.5}],Text["\!\(C\^′\)",{4.5,1.5}],Text["\!\(D \)",{-2.4,1.5}],Text["\!\(D\^′\)",{1.5,1.5}]}},ImageSize->180]]

The key idea to search for a collision of Hawking radiations (hash keys) between the two entangled black holes. This relies on the quantum search algorithm.

Once the Hawking radiations from both black holes are made the same (same = perfectly entangled), the object will reemerge from Bob’s black hole, as a result of quantum teleportation.

Quantum Error Correction

Five-Qubit Code

Qubits couple to the environment and decohere inevitably.

In the extreme case, a qubit can become maximally mixed => An erasure error: the quantum information of the qubit is fully scrambled with the environment, as if the information has been erased.

one logical qubit(Underoverscript[⇌, (decoded to), (encoded in)])many physical qubits.

Logical qubit: the information theoretic qubit (software level), whose basis states are denoted as (Ket[0]),(Ket[1]) (using boldface).

Physical qubit: the actual qubit implemented on quantum devices (hardware level).

The logical qubit states (Ket[0]),(Ket[1]) span a 2-dimensional code subspace in the (2^5)-dimensional physical qubit Hilbert space.

The code subspace is specified by four commuting Pauli operators on the physical qubits:

(Subscript[M, 1])=(Subscript[X, 1])(Subscript[Z, 2])(Subscript[Z, 3])(Subscript[X, 4]),
(Subscript[M, 2])=(Subscript[X, 2])(Subscript[Z, 3])(Subscript[Z, 4])(Subscript[X, 5]),
(Subscript[M, 3])=(Subscript[X, 3])(Subscript[Z, 4])(Subscript[Z, 5])(Subscript[X, 1]),
(Subscript[M, 4])=(Subscript[X, 4])(Subscript[Z, 5])(Subscript[Z, 1])(Subscript[X, 2]).

What about the last (Subscript[X, 5])(Subscript[Z, 1])(Subscript[Z, 2])(Subscript[X, 3]) in the cyclic arrangement? It turns out to be (∏_(i=1)^4)(Subscript[M, i]) and is therefore not independent.

These operators (Subscript[M, i]) are called stabilizers, as they stabilize the logical qubit as their common eigenstates of eigenvalue +1, i.e.

∀i:(Subscript[M, i])(Ket[0])=(Ket[0]), (Subscript[M, i])(Ket[1])=(Ket[1]).

Recall that we can simultaneously diagonalize commuting operators by constructing a many-body Hamiltonian, e.g.

H=-(Subscript[M, 1])-(Subscript[M, 2])-(Subscript[M, 3])-(Subscript[M, 4])
=-(Subscript[X, 1])(Subscript[Z, 2])(Subscript[Z, 3])(Subscript[X, 4])-(Subscript[X, 2])(Subscript[Z, 3])(Subscript[Z, 4])(Subscript[X, 5])-(Subscript[X, 3])(Subscript[Z, 4])(Subscript[Z, 5])(Subscript[X, 1])-(Subscript[X, 4])(Subscript[Z, 5])(Subscript[Z, 1])(Subscript[X, 2]).

The code subspace = the common eigenspace of stabilizers that ∀i:(Subscript[M, i])=+1 = the ground state subspace of the Hamiltonian H.

The code subspace is two-dimensional => can encode a logical qubit. How do we know? 5 qubits, 4 stabilizers: each stabilizer halves the Hilbert space => the remaining space dimension:

((2^5)/(2^4))=2.

Within the code subspace, a choice of the basis is (can be obtained by diagonalize H)

(Ket[0])=(1/4) ((Ket[(RowDefault[0, 0, 0, 0, 0])])-(Ket[(RowDefault[0, 0, 0, 1, 1])])+(Ket[(RowDefault[0, 0, 1, 0, 1])])-(Ket[(RowDefault[0, 0, 1, 1, 0])])+(Ket[(RowDefault[0, 1, 0, 0, 1])])+(Ket[(RowDefault[0, 1, 0, 1, 0])])-(Ket[(RowDefault[0, 1, 1, 0, 0])])-(Ket[(RowDefault[0, 1, 1, 1, 1])])-(Ket[(RowDefault[1, 0, 0, 0, 1])])+(Ket[(RowDefault[1, 0, 0, 1, 0])])+(Ket[(RowDefault[1, 0, 1, 0, 0])])-(Ket[(RowDefault[1, 0, 1, 1, 1])])-(Ket[(RowDefault[1, 1, 0, 0, 0])])-(Ket[(RowDefault[1, 1, 0, 1, 1])])-(Ket[(RowDefault[1, 1, 1, 0, 1])])-(Ket[(RowDefault[1, 1, 1, 1, 0])])),
(Ket[1])=(1/4) (-(Ket[(RowDefault[0, 0, 0, 0, 1])])-(Ket[(RowDefault[0, 0, 0, 1, 0])])-(Ket[(RowDefault[0, 0, 1, 0, 0])])-(Ket[(RowDefault[0, 0, 1, 1, 1])])-(Ket[(RowDefault[0, 1, 0, 0, 0])])+(Ket[(RowDefault[0, 1, 0, 1, 1])])+(Ket[(RowDefault[0, 1, 1, 0, 1])])-(Ket[(RowDefault[0, 1, 1, 1, 0])])-(Ket[(RowDefault[1, 0, 0, 0, 0])])-(Ket[(RowDefault[1, 0, 0, 1, 1])])+(Ket[(RowDefault[1, 0, 1, 0, 1])])+(Ket[(RowDefault[1, 0, 1, 1, 0])])-(Ket[(RowDefault[1, 1, 0, 0, 1])])+(Ket[(RowDefault[1, 1, 0, 1, 0])])-(Ket[(RowDefault[1, 1, 1, 0, 0])])+(Ket[(RowDefault[1, 1, 1, 1, 1])])).

Block[{U,basis},
U=SparseArray[I Dot@@
(Represent/@{C4[-σ[2,3,3,1,0]],C4[-σ[0,2,3,3,1]],C4[σ[3,3,1,2,3]],C4[σ[3,3,3,1,2]],C4[σ[3,3,3,3,1]],C4[σ[3,0,3,0,2]],C4[-σ[0,0,0,0,1]],C4[-σ[0,0,0,0,3]]})];
basis=Ket[{Row[#]}]&/@Tuples[{0,1},5];
Factor[basis.U.Flatten[{1,0}⊗{1,0}⊗{1,0}⊗{1,0}⊗#]]&/@{{1,0},{0,1}}]

Logical qubit.

Logical gates: quantum gates that effectively operate on the logical qubit

Z(Ket[0])=(Ket[0]),Z(Ket[1])=-(Ket[1]),
X(Ket[0])=(Ket[1]),X(Ket[1])=(Ket[0]).

Z and X must commute with all stabilizers (to remain in the code subspace), yet not any product of stabilizers (to be nontrivial). One canonical choice is

Z=(Subscript[Z, 1])(Subscript[Z, 2])(Subscript[Z, 3])(Subscript[Z, 4])(Subscript[Z, 5]),
X=(Subscript[X, 1])(Subscript[X, 2])(Subscript[X, 3])(Subscript[X, 4])(Subscript[X, 5]),
Y=i X Z=(Subscript[Y, 1])(Subscript[Y, 2])(Subscript[Y, 3])(Subscript[Y, 4])(Subscript[Y, 5])

It is hard to decohere the logical qubit, because X, Y, Z  are  non-local. => Their couplings to the environment are typically weak.

(SuperDagger[U])H U=E.

Block[{n=3.5,ket,bra,opH,opU,opD},
ket[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,0},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
bra[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,π},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opH[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Red,0.8],Rectangle[{-0.8,-n 0.8},{0.8,n 0.8},RoundingRadius->0.8]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opU[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Green,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opD[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Yellow,0.8],Polygon[CirclePoints[{0.8,0},4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
Graphics[{Table[Line[{#,y}&/@{-2,2}],{y,-2,2}],Table[{If[y==-2,Red,Blue],Line[{{#,y}&/@{3,4},{#,y}&/@{-3,-4}}]},{y,-2,2}],opH["H"],opU["U\^†",{-2.5,0}],opU["U",{2.5,0}]},ImageSize->{Automatic,75}]]

(SuperDagger[U])(Subscript[M, 1])U=(Subscript[(OverTilde[Z]), 1]),
(SuperDagger[U])(Subscript[M, 2])U=(Subscript[(OverTilde[Z]), 2]),
(SuperDagger[U])(Subscript[M, 3])U=(Subscript[(OverTilde[Z]), 3]),
(SuperDagger[U])(Subscript[M, 4])U=(Subscript[(OverTilde[Z]), 4]).

Block[{U,encode,decode},
U=SparseArray[I Dot@@
(Represent/@{C4[-σ[2,3,3,1,0]],C4[-σ[0,2,3,3,1]],C4[σ[3,3,1,2,3]],C4[σ[3,3,3,1,2]],C4[σ[3,3,3,3,1]],C4[σ[3,0,3,0,2]],C4[-σ[0,0,0,0,1]],C4[-σ[0,0,0,0,3]]})];
encode[A_]:=Abstract[U.Represent[A].ConjugateTranspose[U]];
decode[A_]:=Abstract[ConjugateTranspose[U].Represent[A].U];
AssociationMap[decode,{σ[1,3,3,1,0],σ[0,1,3,3,1],σ[1,0,1,3,3],σ[3,1,0,1,3],σ[1,1,1,1,1],σ[3,3,3,3,3]}]]

Decoding stabilizers.

(SuperDagger[U])H U=-(Subscript[(OverTilde[Z]), 1])-(Subscript[(OverTilde[Z]), 2])-(Subscript[(OverTilde[Z]), 3])-(Subscript[(OverTilde[Z]), 4]).

The first four qubits are pinned by the Hamiltonian to (Ket[(OverTilde[0])(OverTilde[0])(OverTilde[0])(OverTilde[0])]) to lower the energy => syndrome qubits.

The last qubit is free => logical qubit.

Block[{n=3.5,ket,bra,opH,opU,opD},
ket[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,0},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
bra[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,π},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opH[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Red,0.8],Rectangle[{-0.8,-n 0.8},{0.8,n 0.8},RoundingRadius->0.8]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opU[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Green,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opD[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Yellow,0.8],Polygon[CirclePoints[{0.8,0},4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
Graphics[{Translate[{Text["\!\((Ket[0])=\)"],Translate[{Table[Line[{#,y}&/@{-1.5,0}],{y,-2,2}],Table[{If[y==-2,Red,Blue],Line[{{#,y}&/@{0,1.5}}]},{y,-2,2}],opU["U",{0,0}],Text[If[#>-2,Style["(Ket[0])",Blue],Style["(Ket[0])",Red]],{2,#},{-0.5,0.2}]&/@Range[-2,2]},{3,0}]},{-4,0}],
Translate[{Text["\!\((Ket[1])=\)"],Translate[{Table[Line[{#,y}&/@{-1.5,0}],{y,-2,2}],Table[{If[y==-2,Red,Blue],Line[{{#,y}&/@{0,1.5}}]},{y,-2,2}],opU["U",{0,0}],Text[If[#>-2,Style["(Ket[0])",Blue],Style["(Ket[1])",Red]],{2,#},{-0.5,0.2}]&/@Range[-2,2]},{3,0}]},{4,0}]},ImageSize->{Automatic,75}]]

(SuperDagger[U])Z U=(Subscript[(OverTilde[Z]), 5]),
(SuperDagger[U])X U=(Subscript[(OverTilde[X]), 5]).

Block[{ket,bra,opH,opU,opD},
ket[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,0},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
bra[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,π},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opH[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Red,0.8],Rectangle[{-0.8,-n 0.8},{0.8,n 0.8},RoundingRadius->0.8]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opU[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Green,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opD[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Yellow,0.8],Polygon[CirclePoints[{0.8,0},4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
Graphics[{Translate[{Translate[{Table[Line[{#,y}&/@{-3.5,0}],{y,-2,2}],Table[{If[y==-2,Red,Blue],Line[{{#,y}&/@{0,1.5}}]},{y,-2,2}],opH["Z",3.5,{-2,0}],opU["U",3.5,{0,0}]},{-2.5,0}],
Text["="],
Translate[{Table[Line[{#,y}&/@{-1.5,0}],{y,-2,2}],Table[{If[y==-2,Red,Blue],Line[{{#,y}&/@{0,3.5}}]},{y,-2,2}],opH["Z\&~",1,{2,-2}],opU["U",3.5,{0,0}]},{2.5,0}]},{-7,0}],
Translate[{Translate[{Table[Line[{#,y}&/@{-3.5,0}],{y,-2,2}],Table[{If[y==-2,Red,Blue],Line[{{#,y}&/@{0,1.5}}]},{y,-2,2}],opH["X",3.5,{-2,0}],opU["U",3.5,{0,0}]},{-2.5,0}],
Text["="],
Translate[{Table[Line[{#,y}&/@{-1.5,0}],{y,-2,2}],Table[{If[y==-2,Red,Blue],Line[{{#,y}&/@{0,3.5}}]},{y,-2,2}],opH["X\&~",1,{2,-2}],opU["U",3.5,{0,0}]},{2.5,0}]},{7,0}]},ImageSize->{Automatic,80}]]

Logical gates will not take the system out of the code subspace, as they will not touch the syndrome qubit.

If any of the syndrome qubit is flipped. => The system is carried out of the code subspace (excitation created). => Signals an error. => Correct the error by applying appropriate unitary operations based on the syndrome.

Block[{ket,bra,opH,opU,opD},
ket[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,0},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
bra[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,π},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opH[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Red,0.8],Rectangle[{-0.8,-n 0.8},{0.8,n 0.8},RoundingRadius->0.8]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opU[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Green,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opD[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Yellow,0.8],Polygon[CirclePoints[{0.8,0},4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
Graphics[{Translate[{Table[Line[{#,y}&/@{-1.5,0}],{y,-2,2}],Table[{Blue,Line[{{#,y}&/@{0,1.5}}]},{y,-1,2}],{Red,BSplineCurve[{{0,-2},{1,-2},{1.5,-2},{1.5,-2.5},{1.5,-3},{1,-3},{0,-3},{-1.5,-3}}]},opU["U",3.5,{0,0}],Text[Style["(Ket[0])",Blue],{2,#},{-0.5,0.2}]&/@Range[-1,2]},{-4,0}],Text["="],Translate[{Table[Line[{#,y}&/@{-1.5,0}],{y,-2,2}],{Red,Line[{{#,-3}&/@{-1.5,0}}]},opU["T",4,{0,-0.5}]},{2.5,0}]},ImageSize->{Automatic,80}]]

Block[{ket,bra,opH,opU,opD},
ket[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,0},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
bra[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,π},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opH[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Red,0.8],Rectangle[{-0.8,-n 0.8},{0.8,n 0.8},RoundingRadius->0.8]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opU[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Green,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opD[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Yellow,0.8],Polygon[CirclePoints[{0.8,0},4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
Graphics[{Translate[{Table[Line[{{-1,y},{1,y}}],{y,-0.5,0.5,0.5}],Translate[{Table[{If[y<0.5,Black,Red],Line[{{-1.2,y},{0,y}}]},{y,-0.5,0.5,0.5}],opU["T\^†",1,{0,0}]},{-1,0}],Translate[{Table[{If[y<0.5,Black,Red],Line[{{1.2,y},{0,y}}]},{y,-0.5,0.5,0.5}],opU["T",1,{0,0}]},{1,0}]},{-2.7,0}],
Text["∝"],Translate[Table[{If[y<0.5,Black,Red],Line[{{-1,y},{1,y}}]},{y,-0.5,0.5,0.5}],{1.5,0}]},ImageSize->{Automatic,40}]]

Block[{U,T},
U=SparseArray[I Dot@@
(Represent/@{C4[-σ[2,3,3,1,0]],C4[-σ[0,2,3,3,1]],C4[σ[3,3,1,2,3]],C4[σ[3,3,3,1,2]],C4[σ[3,3,3,3,1]],C4[σ[3,0,3,0,2]],C4[-σ[0,0,0,0,1]],C4[-σ[0,0,0,0,3]]})];
T=ArrayReshape[U.Flatten[{1,0}⊗{1,0}⊗{1,0}⊗{1,0}⊗#],{2,2,2,2,2}]&/@{{1,0},{0,1}};
ArrayRules@tTr[{T,Conjugate[T]},Thread[{#,#+6}&@{1,6,4}]]]

Verification.

(S^((n)))(m)=min(m,6-m)log 2.

Use the perfect tensor property to show Eq. ().

Block[{ket,bra,opH,opU,opD},
ket[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,0},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
bra[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,π},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opH[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Red,0.8],Rectangle[{-0.8,-n 0.8},{0.8,n 0.8},RoundingRadius->0.8]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opU[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Green,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opD[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Yellow,0.8],Polygon[CirclePoints[{0.8,0},4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
Graphics[{Translate[{Table[Line[{{-1,y},{1,y}}],{y,-0.5,0.5,0.5}],Translate[{Table[{Line[{{-1.2,y},{0,y}}]},{y,-0.5,0.5,0.5}],opU["T\^†",1,{0,0}]},{-1,0}],Translate[{Table[{Line[{{1.2,y},{0,y}}]},{y,-0.5,0.5,0.5}],opU["T",1,{0,0}]},{1,0}]},{-3,0}],
Text["\!\(=1\/8\)"],Translate[Table[{Line[{{-1,y},{1,y}}]},{y,-0.5,0.5,0.5}],{2,0}]},ImageSize->{Automatic,40}]]

Block[{ket,bra,opH,opU,opD},
ket[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,0},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
bra[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,π},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opH[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Red,0.8],Rectangle[{-0.8,-n 0.8},{0.8,n 0.8},RoundingRadius->0.8]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opU[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Green,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opD[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Yellow,0.8],Polygon[CirclePoints[{0.8,0},4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
Graphics[{Text["\!\(ρ\_3=\)",{-6,0}],Translate[{Table[Line[{{-1,y},{1,y}}],{y,-0.5,0.5,0.5}],Translate[{Table[{Line[{{-1.2,y},{0,y}}]},{y,-0.5,0.5,0.5}],opU["T\^†",1,{0,0}]},{-1,0}],Translate[{Table[{Line[{{1.2,y},{0,y}}]},{y,-0.5,0.5,0.5}],opU["T",1,{0,0}]},{1,0}]},{-3,0}],
Text["\!\(=1\/2\^3\)"],Translate[Table[{Line[{{-1,y},{1,y}}]},{y,-0.5,0.5,0.5}],{2,0}]},ImageSize->{Automatic,40}]]

Block[{ket,bra,opH,opU,opD},
ket[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,0},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
bra[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,π},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opH[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Red,0.8],Rectangle[{-0.8,-n 0.8},{0.8,n 0.8},RoundingRadius->0.8]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opU[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Green,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opD[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Yellow,0.8],Polygon[CirclePoints[{0.8,0},4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
Graphics[{Text["\!\(ρ\_2=\)",{-6,0}],Translate[{{EdgeForm[Black],Opacity[0],Rectangle[{-2.2,0.5},{2.2,1.2},RoundingRadius->0.35]},Table[Line[{{-1,y},{1,y}}],{y,-0.5,0,0.5}],
Translate[{Table[{Line[{{-1.2,y},{0,y}}]},{y,-0.5,0,0.5}],opU["T\^†",1,{0,0}]},{-1,0}],Translate[{Table[{Line[{{1.2,y},{0,y}}]},{y,-0.5,0,0.5}],opU["T",1,{0,0}]},{1,0}]},{-3,0}],
Text["\!\(=1\/8\)"],Translate[{{EdgeForm[Black],Opacity[0],Rectangle[{-1,0.5},{1,1.2},RoundingRadius->0.35]},Table[{Line[{{-1,y},{1,y}}]},{y,-0.5,0,0.5}]},{2,0}],Text["\!\(=1\/2\^2\)",{4,0}],Translate[{Table[{Line[{{-1,y},{1,y}}]},{y,-0.5,0,0.5}]},{6,0}]},ImageSize->{Automatic,54}]]

Block[{ket,bra,opH,opU,opD},
ket[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,0},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
bra[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Blue,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[{1,π},3]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opH[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Red,0.8],Rectangle[{-0.8,-n 0.8},{0.8,n 0.8},RoundingRadius->0.8]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opU[txt_,n_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Green,0.8],Scale[#,{1,n},{0,0}]&@Polygon[CirclePoints[4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
opD[txt_,pos_:{0,0}]:=Translate[{{EdgeForm[Black],Lighter[Yellow,0.8],Polygon[CirclePoints[{0.8,0},4]]},Text["\!\( "<>txt<>"\)",{0,0},{0,0.2}]},pos];
Graphics[{Text["\!\(ρ\_1=\)",{-6,0}],Translate[{{EdgeForm[Black],Opacity[0],Rectangle[{-2,0.5},{2,1.2},RoundingRadius->0.35],Rectangle[{-2.2,0},{2.2,1.7},RoundingRadius->0.35]},Table[Line[{{-1,y},{1,y}}],{y,{-0.5}}],
Translate[{Table[{Line[{{-1.2,y},{0,y}}]},{y,{-0.5}}],opU["T\^†",1,{0,0}]},{-1,0}],Translate[{Table[{Line[{{1.2,y},{0,y}}]},{y,{-0.5}}],opU["T",1,{0,0}]},{1,0}]},{-3,0}],
Text["\!\(=1\/8\)"],Translate[{{EdgeForm[Black],Opacity[0],Rectangle[{-0.8,0.5},{0.8,1.2},RoundingRadius->0.35],Rectangle[{-1,0},{1,1.7},RoundingRadius->0.35]},Table[{Line[{{-1,y},{1,y}}]},{y,{-0.5}}]},{2,0}],Text["\!\(=1\/2\)",{4,0}],Translate[{Table[{Line[{{-1,y},{1,y}}]},{y,{-0.5}}]},{6,0}]},ImageSize->{Automatic,64}]]

(S^((n)))(m)=-(1/(n-1))log Tr (Subscript[ρ, m]^n)
=-(1/(n-1))((log((1/(2^m))))^n)(2^m)
=-((m-m n)/(n-1))log 2
=m ln 2.

(S^((n)))(m)=min(m,6-m)log 2.

(I^((n)))(1:m)=({{{, ({{0, m≤2,}, {2log 2, m≥3.}})}})

Verify Eq. () given Eq. ().

Block[{S},
S[m_]:=Min[m,6-m];
FullSimplify[S[1]+S[m]-S[1+m],Assumptions->m∈Integers]]

any two (or less) qubits have no information about the logical qubit.

any three (or more) qubits have complete information about the logical qubit.