量子计算-示例代码


这是几个使用 projectq 写的最最最基础的量子算法例子，用来帮助理解量子计算

随机硬币

coin.pyview raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#!/usr/bin/env python3
# Author: Armit
# Create Time: 2019/11/24 

from projectq import MainEngine
from projectq.ops import H, Measure

def randb(engine):
  q = engine.allocate_qubit()
  H | q
  Measure | q
  engine.flush()
  return int(q)

if __name__ == "__main__":
  ITER = 1000
  OK = 0

  engine = MainEngine()
  for _ in range(ITER):
    if randb(engine): OK += 1
  
  print('Prob: %f' % (OK / ITER))

Deutsch算法

deutsch.pyview raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
#!/usr/bin/env python3
# Author: Armit
# Create Time: 2019/11/17 

# Deutsch算法
#
# |0>-----|H|-|    |-|H|-|M|--
#             | Uf |
# |0>-|X|-|H|-|    |----------   // 辅助比特
#
# (*Uf包装了输入函数)
#

from projectq import MainEngine
from projectq.ops import *

def deutsch(fn):
  engine = MainEngine()
  qs = engine.allocate_qureg(2)
  
  def wrapper():
    # pre op
    X | qs[1]
    All(H) | qs
  
    # the quantum black box `Uf`/`Ox`
    # conventional definition: `Uf|xy>=|x,y^f(y)>`
    fn(qs)
    
    # post op
    H | qs[0]
    All(Measure) | qs
    
    engine.flush()
    print('r = %d' % bool(qs[0]))
  return wrapper

@deutsch
def ZERO(qs):
  # 即输入为函数`f(x) = 0`
  # 要使得 Uf|xy> = |x,y^0> = |x,y> = |xy>
  # 因有 I|xy> = |xy>
  # 所以取Uf为I⊗I
  pass
  
@deutsch
def ONE(qs):
  # 即输入为函数`f(x) = 1`
  # 要使得 Uf|xy> = |x,y^1> = |x,~y>
  # 因有 X|y> = |~y>
  # 所以取Uf为I⊗X
  X | qs[1]

@deutsch
def ID(qs):
  # 即输入为函数`f(x) = x`
  # 要使得 Uf|xy> = |x,y^f(x)> = |x,y^x>
  # 因有 CNOT|xy> = |x,x^y>
  # 所以取Uf为CNOT
  CNOT | (qs[0], qs[1])
  
@deutsch
def NOT(qs):
  # 即输入为函数`f(x) = ~x`
  # 要使得 Uf|xy> = |x,y^f(x)> = |x,y^(~x)> = |x,~y^x>
  # 因有 CNOT|xy> = |x,x^y>
  # 所以取Uf为CNOT(I⊗X)
  CNOT | (qs[0], qs[1])
  X | qs[1]


if __name__ == '__main__':
  print("ZERO and ONE are constant:")
  ZERO()
  ONE()
  print("ID and NOT are balanced:")
  ID()
  NOT()

Grover算法

grover.pyview raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
#!/usr/bin/env python3
# Author: Armit
# Create Time: 2019/11/13 

# Grover算法(N=4, M=1的例子)
#
# |0>-----|H|-|    |-|H|-|X|-----|CNOT|-----|X|-|H|-------
# |0>-----|H|-| Uf |-|H|-|X|-|H|-|CNOT|-|H|-|X|-|H|-------
# |0>-|X|-|H|-|    |---------------------------------|H|--
#
# <  初始化 > <标记> <          相位调整          > <收尾>
#             |        这两个部分重复多次↑        |

from projectq import MainEngine
from projectq.ops import *

def grover(fn):
  engine = MainEngine()
  qs = engine.allocate_qureg(3)
  
  def wrapper():
    # 初始化、打散
    X | qs[2]
    All(H) | qs

    # 黑箱变换Uf：|x> -> (-1)^f(x)|x>
    fn(qs)
    
    # 相位调整：|0> -> |0>, |x> -> -|x>（对|0^n>均匀打散的|U>进行反射）
    All(H) | [qs[0], qs[1]]
    All(X) | [qs[0], qs[1]]
    H | qs[1]
    CNOT   | (qs[0], qs[1])
    H | qs[1]
    All(X) | [qs[0], qs[1]]
    All(H) | [qs[0], qs[1]]
    
    # 还原、测量
    H | qs[2]
    All(Measure) | qs
    
    engine.flush()
    print('%d%d' % (bool(qs[0]), bool(qs[1])))
  return wrapper

@grover
def ALL_ONES(qs):
  # 输入函数为`f(x,y) = x&y`
  # 要使得Uf|xyz>=|x,z^(x&y)>
  # 所以取Uf为CCNOT
  '''
  H | qs[2]  
  CNOT | (qs[1], qs[2])
  Tdagger | qs[2]
  CNOT | (qs[0], qs[2])
  T | qs[2]
  
  CNOT | (qs[1], qs[2])
  Tdagger | qs[2]
  CNOT | (qs[0], qs[2])
  Tdagger | qs[1]
  T | qs[2]  

  CNOT | (qs[0], qs[1])
  H | qs[2]
  Tdagger | qs[1]
  CNOT | (qs[0], qs[1])
  T | qs[0]
  S | qs[1]
  '''
  # 标记目标元素（对|B>反射？）
  Toffoli | (qs[0], qs[1], qs[2])

@grover
def ALL_ZEROS(qs):
  # 输入函数为`f(x,y) = ~x&~y`
  # 要使得Uf|xyz>=|x,z^(~x&~y)>
  # 所以取Uf为(X⊗X⊗I)CCNOT(X⊗X⊗I)

  All(X) | [qs[0], qs[1]]
  Toffoli | (qs[0], qs[1], qs[2])
  All(X) | [qs[0], qs[1]]   # UNCOMPUTE!!

@grover
def ZERO_ONE(qs):
  # 输入函数为`f(x,y) = ~x&y`
  # 要使得Uf|xyz>=|x,z^(~x&y)>
  # 所以取Uf为(X⊗I⊗I)CCNOT(X⊗I⊗I)

  X | qs[0]
  Toffoli | (qs[0], qs[1], qs[2])
  X | qs[0]   # UNCOMPUTE!!

@grover
def ONE_ZERO(qs):
  # 输入函数为`f(x,y) = x&~y`
  # 要使得Uf|xyz>=|x,z^(x&~y)>
  # 所以取Uf为(I⊗X⊗I)CCNOT(I⊗X⊗I)

  X | qs[1]
  Toffoli | (qs[0], qs[1], qs[2])
  X | qs[1]   # UNCOMPUTE!!

if __name__ == '__main__':
  ALL_ZEROS()
  ZERO_ONE()
  ONE_ZERO()
  ALL_ONES()

Grover算法(projectq官方example)

grover_alt.pyview raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
#!/usr/bin/env python3
# Author: Armit
# Create Time: 2019/11/24
 
import math

from projectq import MainEngine
from projectq.ops import H, Z, X, Measure, All
from projectq.meta import Loop, Compute, Uncompute, Control


def run_grover(eng, n, Ox):
  # start in uniform superposition
  x = eng.allocate_qureg(n)
  All(H) | x

  # the auxiliary indicator qbit, prepare it as '|->'
  y = eng.allocate_qubit()
  X | y
  H | y

  # number of iterations we have to run:
  ITER = int(math.pi / 4.0 * math.sqrt(1 << n))
  with Loop(eng, ITER):
    # oracle adds a (-1)-phase to the solution(s)
    Ox(eng, x, y)

    # reflection across uniform superposition
    with Compute(eng):
      All(H) | x
      All(X) | x

    with Control(eng, x[:-1]):  # Z == H-CNOT(x[-1])-H ??
      Z | x[-1]

    Uncompute(eng)

  All(Measure) | x
  Measure | y

  eng.flush()
  return ''.join([str(int(q)) for q in x])

def Ox_alter_bits(eng, x, y):
  with Compute(eng):
    All(X) | x[1::2]
  with Control(eng, x):
    X | y
  Uncompute(eng)

def Ox_half(eng, x, y):
  with Compute(eng):
    All(X) | x[0:len(x)//2]
  with Control(eng, x):
    X | y
  Uncompute(eng)

if __name__ == '__main__':
  eng = MainEngine()
  print(run_grover(eng, 7, Ox_alter_bits))
  print(run_grover(eng, 7, Ox_half))

隐形传态(projectq官方example)

teleport.pyview raw
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#!/usr/bin/env python3
# Author: Armit
# Create Time: 2019/11/24 

from projectq import MainEngine
from projectq.ops import All, CNOT, H, Measure, Rz, X, Z
from projectq.meta import Dagger, Control

def teleport(eng, init_phi_fn):
  # make bell-state pair
  b1, b2 = eng.allocate_qubit(), eng.allocate_qubit()
  H | b1
  CNOT | (b1, b2)

  # Alice creates a nice state to send
  print("Alice is creating her state from scratch, i.e. |0>.")
  psi = eng.allocate_qubit()
  init_phi_fn(eng, psi)

  # entangle it with Alice's b1
  print("Alice entangled her qubit with her share of the Bell-pair.")
  CNOT | (psi, b1)

  # measure two values (once in Hadamard basis) and send the bits to Bob
  H | psi
  All(Measure) | [psi, b1]
  msg_to_bob = [int(psi), int(b1)]  # classical
  print("Alice is sending the message {} to Bob.".format(msg_to_bob))

  # Bob may have to apply up to two operation depending on the message sent by Alice:
  with Control(eng, b1):    # if int(b1) == 1: ...
    X | b2
  with Control(eng, psi):
    Z | b2

  #########################################
  # TELEPORTATION HAS BEEN DONE TILL HERE #
  #########################################
  
  # try to uncompute the psi state
  print("Bob is trying to uncompute the state.")
  with Dagger(eng):
    init_phi_fn(eng, b2)

  # check whether the uncompute was successful. The simulator only allows to
  # delete qubits which are in a computational basis state.
  del b2
  eng.flush()

  print("Bob successfully arrived at |0>")


if __name__ == "__main__":
  eng = MainEngine()

  # define our state-creation routine, which transforms a |0> to the state
  # we would like to send. Bob can then try to uncompute it and, if he
  # arrives back at |0>, we know that the teleportation worked.
  def init_phi(eng, q):
    H | q
    Rz(1.21) | q

  teleport(eng, init_phi)

by Armit
2019年11月24日