Analysis of a Quantum Error Correcting Code using Quantum ...spitters/QPL/Puthoor.pdf · Quantum...

Analysis of a Quantum Error Correcting Code using

Quantum Process CalculusTimothy A. S. Davidson1 Simon J. Gay2

Rajagopal Nagarajan1 Ittoop Vergheese Puthoor2,3

Department of Computer Science, University of Warwick1 School of Computing Science, University of Glasgow2

School of Physics and Astronomy, University of Glasgow3

QPL Workshop27-29th October ’11

Thursday, 3 November 11

Outline

Explain quantum process calculus, using quantum error correction code.

Behavioural equivalences

Labelled transition systems

Mixed configuration and Congruence

Conclusion


Process Calculus

• Process Calculus or Process Algebra are diverse family of related approaches to formally modelling Concurrent Systems.

• These include:

• Specification language for the precise definition of a system.

• Semantics to describe the behaviour of a system.

• Concept of behavioural equivalence, which helps us to analyse the system.


Quantum Process Calculus

• Process calculus is used for the analysis classical concurrent systems.

• Quantum versions of process calculus, are designed for describing the interactions between different components of a system

• Analysing the behaviour of systems arising from the combination of classical and quantum information is interesting.

• Quantum Process Calculi that have been developed to date are called QPAlg, CQP and qCCS.


Communicating Quantum Processes (CQP)

• Communicating Quantum Processes (CQP) [Gay & Nagarajan, 2005,2006] is based on the classical π-calculus, with extra rules for quantum information.

• CQP is a language defined for modelling systems which combine quantum and classical systems.

• CQP has a formal syntax, operational semantics and a type system.


Quantum Error Correction Code(Circuit model)

• Three qubit flip code.

• Noise causes either one of the qubit to be flipped.

• Error code cannot correct for two or more qubits to be flipped.

Bob

|0i

|0i

M

M

Xj’k

|0i

|0i

| i

Alice| i

|0i

|0i

Noise

M

M

Xjk

Xjk’’

Xj’k

H

H

Xjk’

Xjk


Quantum Error Correction Code system

QECC (a :b[Qbit], d :b[Qbit]) = (new b, c)(Alice(a, b) | Noise(b, c) | Bob(c, d))

Alice Noise Boba b c d

| i | i

Identity(a :b[Qbit], d :b[Qbit]) = a?[x :Qbit] . d![x] .0

Identitya d | i| i


• Alice receives qubit x in state

• (qbit y, z): Create new qubits y and z.

• : Receive qubit x on channel a.

• { } : Apply the CNOT operator.

a?[x :Qbit]

↵|0i+ �|1i

x, z ⇤= CNot

Alice

Alice(a :b[Qbit], b :b[Qbit,Qbit,Qbit]) = (qbit y, z)a?[x :Qbit] . {x, z ⇤= CNot} . {x, y ⇤= CNot} . b![x, y, z] .0

Alice

| i

|0i

|0i

Alicea b

| i


Noise

• Noise receives qubit in state

• (qbit u, v): Create new qubits u and v.

• { } : Apply the Hadamard operator to qubit v.

• (new p): create a new channel which is shared by the processes NoiseRnd and NoiseErr

• : Send the (classical) result of measuring u and v on channel p.

• X transform performs the bit flip operation.

NoiseRnd(p :b[bit, bit]) = (qbit u, v){u ⇤= H} . {v ⇤= H} . p![measure u,measure v] .0

NoiseErr(b :b[Qbit,Qbit,Qbit], p :b[bit, bit], c :b[Qbit,Qbit,Qbit]) =

b?[x :Qbit, y :Qbit, z :Qbit] . p?[j :bit, k :bit] . {x ⇤= Xjk} . {y ⇤= Xjk} . {z ⇤= Xjk} . c![x, y, z] .0

Noise(b :b[Qbit,Qbit,Qbit], c :b[Qbit,Qbit,Qbit]) = (new p)(NoiseRnd(p) | NoiseErr(b, p, c))

|000i+ |111i

v ⇤= H

p![measure u,measure v]M

M

Xjk

Xjk’

Xj’k

H

H

|0i

|0i

NoiseRndb c

NoiseErrp

Noise

Noise


Bob

BobRec(c :b[Qbit,Qbit,Qbit], p :b[Qbit,Qbit,Qbit, bit, bit]) = (qbit s, t)c?[x :Qbit, y :Qbit, z :Qbit] .

{x, s ⇤= CNot} . {y, s ⇤= CNot} . {x, t ⇤= CNot} . {z, t ⇤= CNot} . p![x, y, z,measure s,measure t] .0

BobCorr(p :b[Qbit,Qbit,Qbit, bit, bit], d :b[Qbit]) = p?[x :Qbit, y :Qbit, z :Qbit, j :bit, k :bit] .

{x ⇤= X

jk} . {y ⇤= X

jk} . {z ⇤= X

jk} . {x, y ⇤= CNot} . {x, z ⇤= CNot} . d![x] .0

Bob(c :b[Qbit,Qbit,Qbit], d :b[Qbit]) = (new p)(BobRec(c, p) | BobCorr(p, d))

• Bob receives the qubit which may or may not have the error through channel c.

• (qbit s, t): Create new qubits s and t.

• (new p): create a new channel which is shared by the processes BobRec and BobCorr.

• Process BobRec receives the qubits and measures the error syndrome.

• BobCorr applies the appropriate correction.

M

M

Xj’k

|0i

|0i

| i

Xjk’

Xjk

Bob

BobRecc d | iBobCorrp

Bob


Execution of QECC

• Process configurations include a quantum store (σ) in addition to a process term (P) since the quantum state is a determining factor in the behaviour of quantum processes:

C = (σ;ω;P)

• The quantum store maps qubit names to the global quantum state:

• The initial configuration is: .

• The semantics of CQP specifies transitions between configurations. Each transition is a communication or an operation of the quantum state.

• Global quantum state is :

• Alice receives qubit through transition .

� = (q1, . . . .., qn = | i)

(;; ;;Alice | Noise | Bob)

([y, z, u, v, s, t 7! |000000i]; y, z, u, v, s, t;Alice 0 | Noise 0 | Bob0)

↵|0i+ �|1i a?[x]�!


Execution of QECC

• After some transitions, the global quantum state becomes

where, has already done its qbit).

• The measurements in gives a mixed configuration, since results are communicated internally, to .

• After transitions, from the controlled X operations, we have the mixed configuration

• Finally, we get a mixed state, where the reduced density matrix of x, when x is output is the same as the original density matrix of x.

⌧

([eq 7! ↵|0000000i+ �|1110000i]; eq; b![x, y, z] .0 | Noise 0 | Bob0)

NoiseRnd

NoiseErr

�j,k2{0,1}1

4([eq 7! ↵|000jk00i+ �|111jk00i]; eq;�jk • {x ⇤= Xjk}{y ⇤= Xjk}{z ⇤= Xjk} . c![x, y, z] .0 | Bob0; j, k)

Noise

0 = NoiseErr | NoiseRnd 0(NoiseRnd 0

⌧1

4([eq 7! ↵|0000000i+ �|1110000i]; eq; c![x, y, z] .0 | Bob0)

�1

4([eq 7! ↵|0010100i+ �|1100100i]; eq; c![x, y, z] .0 | Bob0)

�1

4([eq 7! ↵|0101000i+ �|1011000i]; eq; c![x, y, z] .0 | Bob0)

�1

4([eq 7! ↵|1001100i+ �|0111100i]; eq; c![x, y, z] .0 | Bob0)

�j,k2{0,1}1

4[x, y, z, u, v, s, t 7! ↵|000jkjki+ �|100jkjki]


Correctness of QECC

From our definition, Quantum Error Correction Code system, QECC(a,d) receives a qubit in state through channel a, then sends the qubit in an identical state through channel d.

The following process has the same effect as error correction therefore we consider it as a specification process for QECC. (Process-oriented specification)

Our correctness requirement is that

QECC Identity

Therefore, we need a theory that defines the relation and helps us prove this

| i

Identity(a :b[Qbit], d :b[Qbit]) = a?[x :Qbit] . d![x] .0

⇠=⇠=


Behavioural Equivalence

The relation is a behavioural equivalence. That is, if P Q then P and Q have the same behaviour.

There are many variations on the theory of behavioural equivalence that have been developed for classical process calculus since the 1980s (Milner and others).

Our main interest is in congruence properties:

P Q C[P] C[Q]

for all process contexts C. This supports equational reasoning.

=)

⇠=

⇠= ⇠=

⇠=


Labelled Transition RulesTo consider behavioural equivalence we must be able to describe the behaviour of a process configuration. The semantics of process expressions are defined in terms of labelled transition rules.

Example

(�;!; c![2] . P )c![2]�! (�;!;P ).

(�;!; c?[x] . Q)c?[v]�! (�;!;Q{v/x}).

(�;!;P )c![v]�! �;!;P 0 (�;!;Q)

c?[v]�! (�;!;Q0)

��

(�;!;P |Q)⌧�! (�;!;P 0 |Q0)

(�;!; c![2] . P | c?[x] . Q)⌧�! (�;!;P |Q{2/x}).


Labelled Transition System

The labelled transition rules give rise to a directed graph in which the vertices are process configurations and the edges are labelled with actions, α.

Actions can be

• input actions on a channel c: c?[x].

• output actions on a channel c: c![x].

• internal actions:

(�;!;P )↵�! (�0;!0;P 0)

⌧

This directed graph is a labelled transition system.


Bisimulation

The notion of bisimulation equivalence is based upon the concept of simulation due to Milner [1982].

Bisimulation requires the simulation relation to be symmetric.

Many variants of bisimulation: Strong, Weak and Probabilistic Branching.

Often strong bisimulation is too strong, because it requires 𝜏 to be matched by exactly one 𝜏 .

Weak bisimulations allow 𝜏 to be matched by a sequence of zero or more 𝜏.

P P‘ P P‘

Q Q‘ Q Q‘ Q’’

Strong Weak

α

α

α

𝜏 α


Probabilistic Branching Bisimulation

• Branching bisimulation [van Glabbeeek, 1990] is stronger than weak bisimulation:

P P’

Q Q‘ Q’’

• Probabilistic bisimulation is used to take into account the probabilistic behaviour arising from quantum measurements.

• Technically, we use probabilistic branching bisimulation (van Glabeek and Weijland 1996; quantum version by Lalire 2006).

ID ID‘ ID’’

QC QC‘ QC’‘ QC’’’

a?[x] d![x]

𝜏*

α

𝜏 α

a?[x] d![x]


Congruence for CQPObtaining a congruence relation is an important task in quantum process calculus.

Probabilistic branching bisimulation is a congruence for CQP. (Tim Davidson’s PhD thesis, 2011).

This requires a careful treatment of measurement and output.

• Measuring a qubit produces a mixed quantum state.

• Outputting the result of a measurement produces a probability distribution over pure states, which then reduces probabilistically.

We can show that QECC(a,d) Identity(a,d) and hence the equivalence is valid in all contexts.

Correctness of error code correction is a standard but this formulation is a valuable new perspective.

⇠=


Mixed Configuration and Congruence

A mixed quantum state is a probability distribution over pure quantum states, representing classical uncertainty.

We introduce mixed CQP configurations, distinct from probabilistic configurations. A measurement produces a mixed configuration. If the measurement result is output then a probabilistic configuration is produced.

Internal communication of a measurement result, however, does not remove mixedness.

In quantum error code correction model, there are no probabilistic configurations, because the measurement result is never output.



Consider

They are equivalent, in all quantum states, just because they produce no output.

Put them in parallel with in the state p,q = |00⟩+|11⟩ .

We get configurations

If the measurement produces a probabilistic configuration, and R outputs afterwards, then the possible reduced density matrices for q, produced by P | R and Q | R, are different.

After measurement, the states become

For P | R is either |00⟩ or |11⟩ and for Q | R is either or with equal probability.

This means that P | R and Q | R do not have matching output transitions.

([p, q 7! 1p2(|00i+ |11i)]; p, q;P |R) ([p, q 7! 1p

2(|00i+ |11i)]; p, q;Q |R)

P (a :b[Qbit]) = a?[x :Qbit] . {measure x} .0Q(a :b[Qbit]) = a?[x :Qbit] . {x ⇤= H}{measure x} .0

R(b :b[Qbit]) = b![q] .0

1p2(|00i+ |01i) 1p

2(|10i � |11i)



In the modified semantics, the measurement produces a mixed configuration and because the result is not output, it never becomes a probabilistic configuration.

After measurement, the we get mixed configurations,

From P | R

From Q | R

Then the output of q has the same reduced density matrix for both P | R and Q | R.

This enables P | R and Q | R to match each other’s outputs.

1

2([p, q 7! |00i]; p, q;0 | b![q] .0)� 1

2([p, q 7! |11i]; p, q;0 | b![q] .0)

1

2([p, q 7! 1p

2(|00i+ |01i)]; p, q;0 | b![q] .0)� 1

2([p, q 7! 1p

2(|10i � |11i)]; p, q;0 | b![q] .0).


Quantum Error Correction Code(Second model)

NoiseAlice Bob

| i

|0i

|0i

M

M

Xj

Xk

Xl

|0i

|0i

M

Xjk

Xjk’

M

Xj’k

|0i

|0i

| i

H

H

|0i MH

NoiseRnd(p :b[bit, bit, bit]) = (qbit u, v, w) . {u ⇤= H} . {v ⇤= H} . {w ⇤= H}. p![measure u,measure v,measure w] .0

NoiseErr(b :b[Qbit,Qbit,Qbit], p :b[bit, bit, bit], c :b[Qbit,Qbit,Qbit]) =b?[x :Qbit, y :Qbit, z :Qbit] . p?[j :bit, k :bit, l :bit] . {x ⇤= Xj} . {y ⇤= Xk} . {z ⇤= Xl} . c![x, y, z] .0

Noise(b :b[Qbit,Qbit,Qbit], c :b[Qbit,Qbit,Qbit]) = (new p)(NoiseRnd(p) | NoiseErr(b, p, c))

QECC2(a :b[Qbit], d :b[Qbit]) = (new b, c)(Alice(a, b) | Noise(b, c) | Bob(c, d))Rnd(p :b[bit]) = (qbit u){u ⇤= H} . p![measure u] .0

Flip(a :b[Qbit], p :b[bit], d :b[Qbit]) = a?[x :Qbit] . p?[j :bit] . {x ⇤= Xi} . d![x] .0

BitFlip(a :b[Qbit], d :b[Qbit]) = (new p)(Rnd(p) | Flip(a, p, d))

QECC2 ⇠= BitFlip


Related Work

• Other quantum process calculi have been proposed:

• QPAlg (Jorrand & Lalire, 2004).

• qCCS (Ying et al., 2006-2011).

• There are equivalence relations for both process calculi.

• Congruence relation in qCCS have been solved (POPL 2011).


Conclusion and Future work

The use of process calculus CQP and its theory of behavioural equivalence.

Analysis of quantum error correction.

Congruence property of behavioural equivalence guarantees that equivalent processes remain equivalent in any context and supports equational reasoning.

To make reasoning about processes easier and more practical:

equational axiomatization of equivalence

automated equivalence checking


Thank You


Analysis of a Quantum Error Correcting Code using Quantum ...spitters/QPL/Puthoor.pdf · Quantum...

Documents

Transcript of Analysis of a Quantum Error Correcting Code using Quantum ...spitters/QPL/Puthoor.pdf · Quantum...