def mainGame(movementInfo):
quantumGateStatus = True # set dynamically based on a new measurement
score = playerIndex = loopIter = 0
playerIndexGen = movementInfo['playerIndexGen']
playerx, playery = int(SCREENWIDTH * 0.2), movementInfo['playery']
basex = movementInfo['basex']
baseShift = IMAGES['base'].get_width() - IMAGES['background'].get_width()
# get 2 new pipes to add to upperPipes lowerPipes list
newPipe1 = getRandomPipe(quantumGateStatus)
newPipe2 = getRandomPipe(quantumGateStatus)
# list of upper pipes
upperPipes = [
{
'x': SCREENWIDTH + 200,
'y': newPipe1[0]['y']
},
{
'x': SCREENWIDTH + 200 + (SCREENWIDTH / 2),
'y': newPipe2[0]['y']
},
]
# list of lowerpipe
lowerPipes = [
{
'x': SCREENWIDTH + 200,
'y': newPipe1[1]['y']
},
{
'x': SCREENWIDTH + 200 + (SCREENWIDTH / 2),
'y': newPipe2[1]['y']
},
]
pipeVelX = -4
# player velocity, max velocity, downward accleration, accleration on flap
playerVelY = -9 # player's velocity along Y, default same as playerFlapped
playerMaxVelY = 10 # max vel along Y, max descend speed
playerMinVelY = -8 # min vel along Y, max ascend speed
playerAccY = 1 # players downward accleration
playerRot = 45 # player's rotation
playerVelRot = 3 # angular speed
playerRotThr = 20 # rotation threshold
playerFlapAcc = -9 # players speed on flapping
playerFlapped = False # True when player flaps
# LEVEL = 1
q = QuantumRegister(levels[LEVEL]['qubits']) # |0>
c = ClassicalRegister(levels[LEVEL]['qubits'])
circuit = QuantumCircuit(q, c)
desired_state = get_desired_state(LEVEL)
print("Desired state is: " + desired_state)
# goal_blochs = getGoalBlochs(desired_state)
# goal_blochs.savefig("desierd_sphere.png")
# cblochs = getGoalBlochs(''.zfill(levels[LEVEL]['qubits']))
# cblochs.savefig("current_sphere.png")
rgates = get_random_gates(LEVEL)
# define gate labels
firstGateLabel = rgates[0][0].__name__ + str(rgates[0][1])
secondGateLabel = rgates[1][0].__name__ + str(rgates[1][1])
cstate = ''.zfill(levels[LEVEL]['qubits'])
circuit_str = ''
while True:
for event in pygame.event.get():
if event.type == QUIT or (event.type == KEYDOWN
and event.key == K_ESCAPE):
pygame.quit()
sys.exit()
if event.type == KEYDOWN and (event.key == K_SPACE
or event.key == K_UP):
if playery > -2 * IMAGES['player'][0].get_height():
playerVelY = playerFlapAcc
playerFlapped = True
# check for crash here
crashTest = checkCrash(
{
'x': playerx,
'y': playery,
'index': playerIndex
}, upperPipes, lowerPipes)
if crashTest[0]:
return {
'y': playery,
'groundCrash': crashTest[1],
'basex': basex,
'upperPipes': upperPipes,
'lowerPipes': lowerPipes,
'score': score,
'playerVelY': playerVelY,
'playerRot': playerRot
}
# check for score
playerMidPos = playerx + IMAGES['player'][0].get_width() / 2
for pipe in upperPipes:
pipeMidPos = pipe['x'] + IMAGES['pipe'][0].get_width() / 2
if pipeMidPos <= playerMidPos < pipeMidPos + 4:
# NOTE: adding a check here for gate choice
if 'quantum' in pipe.keys() and pipe['quantum'] == True:
gateno = checkGateChoice(upperPipes[0], lowerPipes[0],
playery)
gate = rgates[gateno][0]
target = rgates[gateno][1]
gate(circuit, q[target - 1])
print("Applying gate: " + gate.__name__ + " on " +
str(target))
p, cstate = check(desired_state, circuit, q, c)
print("Probabilaty for desired state is: " + str(p))
print("Current state: |" + cstate + ">")
circuit_str += gate.__name__ + str(target) + ' > '
# cblochs = getGoalBlochs(cstate)
# cblochs.savefig("current_sphere.png")
if p > 0.99:
return {'score': p}
# Get new gates
rgates = get_random_gates(LEVEL)
firstGateLabel = rgates[0][0].__name__ + str(rgates[0][1])
secondGateLabel = rgates[1][0].__name__ + str(rgates[1][1])
score += 1
# playerIndex basex change
if (loopIter + 1) % 3 == 0:
playerIndex = next(playerIndexGen)
loopIter = (loopIter + 1) % 30
basex = -((-basex + 100) % baseShift)
# rotate the player
if playerRot > -90:
playerRot -= playerVelRot
# player's movement
if playerVelY < playerMaxVelY and not playerFlapped:
playerVelY += playerAccY
if playerFlapped:
playerFlapped = False
# more rotation to cover the threshold (calculated in visible rotation)
playerRot = 45
playerHeight = IMAGES['player'][playerIndex].get_height()
playery += min(playerVelY, BASEY - playery - playerHeight)
# move pipes to left
for uPipe, lPipe in zip(upperPipes, lowerPipes):
uPipe['x'] += pipeVelX
lPipe['x'] += pipeVelX
# add new pipe when first pipe is about to touch left of screen
if 0 < upperPipes[0]['x'] < 5:
newPipe = getRandomPipe(quantumGateStatus)
upperPipes.append(newPipe[0])
lowerPipes.append(newPipe[1])
# remove first pipe if its out of the screen
if upperPipes[0]['x'] < -IMAGES['pipe'][0].get_width():
upperPipes.pop(0)
lowerPipes.pop(0)
# draw sprites
SCREEN.blit(IMAGES['background'], (0, 0))
for uPipe, lPipe in zip(upperPipes, lowerPipes):
if 'quantum' in uPipe.keys() and uPipe['quantum'] == True:
SCREEN.blit(IMAGES['quantum_pipe'][0],
(uPipe['x'], uPipe['y']))
SCREEN.blit(IMAGES['quantum_pipe'][1],
(lPipe['x'], lPipe['y']))
# gate label text is written here
font = pygame.font.Font('freesansbold.ttf', 32)
upperText = font.render(firstGateLabel, True, white)
lowerText = font.render(secondGateLabel, True, white)
if ((uPipe['x'] == upperPipes[0]['x'] and playerx < uPipe['x']) or \
('quantum' in upperPipes[1].keys() and upperPipes[1]['quantum'] == True and \
'quantum' in upperPipes[0].keys() and upperPipes[0]['quantum'] == False and \
playerx < upperPipes[1]['x'])): # compare against player x pos as well
SCREEN.blit(upperText,
(uPipe['x'] + 10,
uPipe['y'] + 250)) # upper pipe label
SCREEN.blit(
lowerText,
(lPipe['x'] + 10, lPipe['y'] + 25)) # lower pipe label
# boundary line gets drawn here
SCREEN.blit(
IMAGES['boundary'],
(uPipe['x'], uPipe['y'] + 420)) # draw boundary
else:
SCREEN.blit(IMAGES['pipe'][0], (uPipe['x'], uPipe['y']))
SCREEN.blit(IMAGES['pipe'][1], (lPipe['x'], lPipe['y']))
SCREEN.blit(IMAGES['base'], (basex, BASEY))
# print score so player overlaps the score
showScore(score)
showState(cstate, desired_state, circuit_str)
# Player rotation has a threshold
visibleRot = playerRotThr
if playerRot <= playerRotThr:
visibleRot = playerRot
playerSurface = pygame.transform.rotate(IMAGES['player'][playerIndex],
visibleRot)
SCREEN.blit(playerSurface, (playerx, playery))
pygame.display.update()
FPSCLOCK.tick(FPS)
def make_circuit(n:int,f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n,"qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[4]) # number=21
prog.rx(-0.03141592653589796,input_qubit[1]) # number=37
Zf = build_oracle(n, f)
repeat = floor(sqrt(2 ** n) * pi / 4)
for i in range(1):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[4]) # number=27
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.cx(input_qubit[1],input_qubit[0]) # number=28
prog.x(input_qubit[0]) # number=29
prog.h(input_qubit[0]) # number=38
prog.cz(input_qubit[1],input_qubit[0]) # number=39
prog.h(input_qubit[0]) # number=40
prog.x(input_qubit[1]) # number=10
prog.h(input_qubit[2]) # number=31
prog.cz(input_qubit[0],input_qubit[2]) # number=32
prog.h(input_qubit[2]) # number=33
prog.x(input_qubit[2]) # number=23
prog.cx(input_qubit[0],input_qubit[2]) # number=24
prog.x(input_qubit[3]) # number=12
if n>=2:
prog.mcu1(pi,input_qubit[1:],input_qubit[0])
prog.x(input_qubit[0]) # number=13
prog.x(input_qubit[1]) # number=14
prog.cx(input_qubit[0],input_qubit[2]) # number=34
prog.x(input_qubit[2]) # number=35
prog.cx(input_qubit[0],input_qubit[2]) # number=36
prog.y(input_qubit[1]) # number=26
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[0]) # number=17
prog.cx(input_qubit[4],input_qubit[2]) # number=25
prog.h(input_qubit[1]) # number=18
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[3]) # number=20
prog.h(input_qubit[0])
prog.h(input_qubit[1])
prog.h(input_qubit[2])
prog.h(input_qubit[3])
# circuit end
return prog
def make_circuit(n:int,f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n,"qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.rx(-1.3603096190043806,input_qubit[2]) # number=28
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[4]) # number=21
Zf = build_oracle(n, f)
repeat = floor(sqrt(2 ** n) * pi / 4)
for i in range(repeat):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.h(input_qubit[3]) # number=34
prog.cz(input_qubit[4],input_qubit[3]) # number=35
prog.h(input_qubit[3]) # number=36
prog.h(input_qubit[0]) # number=38
prog.cz(input_qubit[1],input_qubit[0]) # number=39
prog.h(input_qubit[0]) # number=40
prog.x(input_qubit[0]) # number=32
prog.cx(input_qubit[1],input_qubit[0]) # number=33
prog.cx(input_qubit[0],input_qubit[1]) # number=24
prog.x(input_qubit[1]) # number=25
prog.x(input_qubit[1]) # number=41
prog.cx(input_qubit[0],input_qubit[1]) # number=26
prog.x(input_qubit[2]) # number=11
prog.cx(input_qubit[2],input_qubit[3]) # number=30
prog.x(input_qubit[3]) # number=12
prog.h(input_qubit[2]) # number=42
if n>=2:
prog.mcu1(pi,input_qubit[1:],input_qubit[0])
prog.x(input_qubit[0]) # number=13
prog.x(input_qubit[1]) # number=14
prog.x(input_qubit[2]) # number=15
prog.x(input_qubit[4]) # number=46
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[0]) # number=17
prog.h(input_qubit[1]) # number=18
prog.cx(input_qubit[0],input_qubit[2]) # number=43
prog.cx(input_qubit[0],input_qubit[2]) # number=47
prog.x(input_qubit[2]) # number=48
prog.cx(input_qubit[0],input_qubit[2]) # number=49
prog.cx(input_qubit[0],input_qubit[2]) # number=45
prog.rx(-1.9697785938008003,input_qubit[1]) # number=37
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[3]) # number=20
prog.x(input_qubit[1]) # number=22
prog.x(input_qubit[1]) # number=23
# circuit end
for i in range(n):
prog.measure(input_qubit[i], classical[i])
return prog
def make_circuit(n: int, f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n, "qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[0]) # number=38
prog.cz(input_qubit[1], input_qubit[0]) # number=39
prog.h(input_qubit[0]) # number=40
prog.h(input_qubit[0]) # number=49
prog.cz(input_qubit[1], input_qubit[0]) # number=50
prog.h(input_qubit[0]) # number=51
prog.cx(input_qubit[1], input_qubit[0]) # number=52
prog.z(input_qubit[1]) # number=53
prog.h(input_qubit[0]) # number=57
prog.cz(input_qubit[1], input_qubit[0]) # number=58
prog.h(input_qubit[0]) # number=59
prog.h(input_qubit[0]) # number=60
prog.cz(input_qubit[1], input_qubit[0]) # number=61
prog.h(input_qubit[0]) # number=62
prog.h(input_qubit[0]) # number=32
prog.cz(input_qubit[1], input_qubit[0]) # number=33
prog.h(input_qubit[0]) # number=34
prog.x(input_qubit[4]) # number=48
prog.h(input_qubit[4]) # number=21
Zf = build_oracle(n, f)
repeat = floor(sqrt(2**n) * pi / 4)
for i in range(repeat):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.cx(input_qubit[3], input_qubit[0]) # number=41
prog.z(input_qubit[3]) # number=42
prog.cx(input_qubit[3], input_qubit[0]) # number=43
prog.cx(input_qubit[1], input_qubit[3]) # number=44
prog.x(input_qubit[0]) # number=9
prog.h(input_qubit[1]) # number=56
prog.x(input_qubit[1]) # number=10
prog.x(input_qubit[2]) # number=11
prog.rx(-2.9845130209103035, input_qubit[4]) # number=55
prog.cx(input_qubit[0], input_qubit[3]) # number=35
prog.x(input_qubit[3]) # number=36
prog.cx(input_qubit[0], input_qubit[3]) # number=37
if n >= 2:
prog.mcu1(pi, input_qubit[1:], input_qubit[0])
prog.cx(input_qubit[1], input_qubit[0]) # number=24
prog.x(input_qubit[0]) # number=25
prog.cx(input_qubit[1], input_qubit[0]) # number=26
prog.x(input_qubit[1]) # number=14
prog.x(input_qubit[2]) # number=15
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[0]) # number=17
prog.h(input_qubit[1]) # number=18
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[3]) # number=20
prog.x(input_qubit[1]) # number=22
prog.x(input_qubit[1]) # number=23
# circuit end
for i in range(n):
prog.measure(input_qubit[i], classical[i])
return prog
def make_circuit(n:int,f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n,"qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[4]) # number=21
Zf = build_oracle(n, f)
repeat = floor(sqrt(2 ** n) * pi / 4)
for i in range(repeat):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.h(input_qubit[0]) # number=28
prog.cx(input_qubit[3],input_qubit[0]) # number=49
prog.z(input_qubit[3]) # number=50
prog.cx(input_qubit[3],input_qubit[0]) # number=51
prog.cz(input_qubit[1],input_qubit[0]) # number=29
prog.h(input_qubit[0]) # number=30
prog.h(input_qubit[0]) # number=43
prog.cz(input_qubit[1],input_qubit[0]) # number=44
prog.h(input_qubit[0]) # number=45
prog.cx(input_qubit[1],input_qubit[0]) # number=35
prog.cx(input_qubit[1],input_qubit[0]) # number=38
prog.x(input_qubit[0]) # number=39
prog.cx(input_qubit[1],input_qubit[0]) # number=40
prog.cx(input_qubit[1],input_qubit[0]) # number=37
prog.h(input_qubit[0]) # number=46
prog.cz(input_qubit[1],input_qubit[0]) # number=47
prog.h(input_qubit[0]) # number=48
prog.cx(input_qubit[1],input_qubit[0]) # number=27
prog.x(input_qubit[1]) # number=10
prog.x(input_qubit[2]) # number=11
prog.x(input_qubit[3]) # number=12
if n>=2:
prog.mcu1(pi,input_qubit[1:],input_qubit[0])
prog.x(input_qubit[0]) # number=13
prog.cx(input_qubit[0],input_qubit[1]) # number=22
prog.y(input_qubit[2]) # number=41
prog.x(input_qubit[1]) # number=23
prog.cx(input_qubit[0],input_qubit[1]) # number=24
prog.rx(1.0398671683382215,input_qubit[2]) # number=31
prog.x(input_qubit[2]) # number=15
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[0]) # number=17
prog.h(input_qubit[1]) # number=18
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[3]) # number=20
# circuit end
for i in range(n):
prog.measure(input_qubit[i], classical[i])
return prog
# import all necessary objects and methods for quantum circuits
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
all_pairs = ['00', '01', '10', '11']
for pair in all_pairs:
# create a quantum curcuit with two qubits: Asja's and Balvis' qubits.
# both are initially set to |0>.
qreg = QuantumRegister(2) # quantum register with 2 qubits
creg = ClassicalRegister(2) # classical register with 2 bits
mycircuit = QuantumCircuit(
qreg, creg) # quantum circuit with quantum and classical registers
# apply h-gate (Hadamard) to the first qubit.
mycircuit.h(qreg[0])
# apply cx-gate (CNOT) with parameters first-qubit and second-qubit.
mycircuit.cx(qreg[0], qreg[1])
# they are separated now.
# if a is 1, then apply z-gate to the first qubit.
if pair[0] == '1':
mycircuit.z(qreg[0])
# if b is 1, then apply x-gate (NOT) to the first qubit.
if pair[1] == '1':
mycircuit.x(qreg[0])
# Asja sends her qubit to Balvis.
def make_circuit(n: int, f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n, "qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[4]) # number=21
prog.h(input_qubit[0]) # number=43
prog.cz(input_qubit[4], input_qubit[0]) # number=44
prog.h(input_qubit[0]) # number=45
prog.cx(input_qubit[4], input_qubit[0]) # number=46
prog.cx(input_qubit[4], input_qubit[0]) # number=56
prog.z(input_qubit[4]) # number=57
prog.cx(input_qubit[4], input_qubit[0]) # number=58
prog.cx(input_qubit[4], input_qubit[0]) # number=48
prog.h(input_qubit[0]) # number=37
prog.cz(input_qubit[4], input_qubit[0]) # number=38
prog.h(input_qubit[0]) # number=39
Zf = build_oracle(n, f)
repeat = floor(sqrt(2**n) * pi / 4)
for i in range(repeat):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.rx(-1.0430087609918113, input_qubit[4]) # number=36
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.cx(input_qubit[1], input_qubit[0]) # number=40
prog.cx(input_qubit[1], input_qubit[0]) # number=52
prog.x(input_qubit[0]) # number=53
prog.cx(input_qubit[1], input_qubit[0]) # number=54
prog.h(input_qubit[0]) # number=49
prog.cz(input_qubit[1], input_qubit[0]) # number=50
prog.h(input_qubit[0]) # number=51
prog.x(input_qubit[1]) # number=10
prog.rx(-0.06597344572538572, input_qubit[3]) # number=27
prog.cx(input_qubit[0], input_qubit[2]) # number=22
prog.x(input_qubit[2]) # number=23
prog.h(input_qubit[2]) # number=28
prog.cz(input_qubit[0], input_qubit[2]) # number=29
prog.h(input_qubit[2]) # number=30
prog.x(input_qubit[3]) # number=12
if n >= 2:
prog.mcu1(pi, input_qubit[1:], input_qubit[0])
prog.x(input_qubit[0]) # number=13
prog.x(input_qubit[1]) # number=14
prog.x(input_qubit[2]) # number=15
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[4]) # number=35
prog.h(input_qubit[0]) # number=17
prog.rx(2.4912829742967055, input_qubit[2]) # number=26
prog.h(input_qubit[1]) # number=18
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[2]) # number=55
prog.h(input_qubit[2]) # number=25
prog.h(input_qubit[3]) # number=20
# circuit end
for i in range(n):
prog.measure(input_qubit[i], classical[i])
return prog
def construct_circuit(self, mode, inreg):
"""Construct the Lookup Rotation circuit.
Args:
mode (str): consctruction mode, 'matrix' not supported
inreg (QuantumRegister): input register, typically output register of Eigenvalues
Returns:
QuantumCircuit containing the Lookup Rotation circuit.
"""
# initialize circuit
if mode == 'matrix':
raise NotImplementedError('The matrix mode is not supported.')
if self._lambda_min:
self._scale = self._lambda_min / 2 / np.pi * self._evo_time
if self._scale == 0:
self._scale = 2**-len(inreg)
self._ev = inreg
self._workq = QuantumRegister(1, 'work')
self._msq = QuantumRegister(1, 'msq')
self._anc = QuantumRegister(1, 'anc')
qc = QuantumCircuit(self._ev, self._workq, self._msq, self._anc)
self._circuit = qc
self._reg_size = len(inreg)
if self._pat_length is None:
if self._reg_size <= 6:
self._pat_length = self._reg_size - \
(2 if self._negative_evals else 1)
else:
self._pat_length = 5
if self._reg_size <= self._pat_length:
self._pat_length = self._reg_size - \
(2 if self._negative_evals else 1)
if self._subpat_length is None:
self._subpat_length = int(np.ceil(self._pat_length / 2))
m = self._subpat_length
n = self._pat_length
k = self._reg_size
neg_evals = self._negative_evals
# get classically precomputed eigenvalue binning
approx_dict = LookupRotation._classic_approx(k,
n,
m,
negative_evals=neg_evals)
fo = None
old_fo = None
# for negative EV, we pass a pseudo register ev[1:] ign. sign bit
ev = [self._ev[i] for i in range(len(self._ev))]
for _, fo in enumerate(list(approx_dict.keys())):
# read m-bit and (n-m) bit patterns for current first-one and
# correct Lambdas
pattern_map = approx_dict[fo]
# set most-significant-qbit register and uncompute previous
if self._negative_evals:
if old_fo != fo:
if old_fo is not None:
self._set_msq(self._msq, ev[1:], int(old_fo - 1))
old_fo = fo
if fo + n == k:
self._set_msq(self._msq,
ev[1:],
int(fo - 1),
last_iteration=True)
else:
self._set_msq(self._msq,
ev[1:],
int(fo - 1),
last_iteration=False)
else:
if old_fo != fo:
if old_fo is not None:
self._set_msq(self._msq, self._ev, int(old_fo))
old_fo = fo
if fo + n == k:
self._set_msq(self._msq,
self._ev,
int(fo),
last_iteration=True)
else:
self._set_msq(self._msq,
self._ev,
int(fo),
last_iteration=False)
# offset = start idx for ncx gate setting and unsetting m-bit
# long bitstring
offset_mpat = fo + (n - m) if fo < k - n else fo + n - m - 1
for mainpat, subpat, lambda_ar in pattern_map:
# set m-bit pattern in register workq
self._set_bit_pattern(mainpat, self._workq[0], offset_mpat + 1)
# iterate of all 2**(n-m) combinations for fixed m-bit
for subpattern, lambda_ in zip(subpat, lambda_ar):
# calculate rotation angle
theta = 2 * np.arcsin(min(1, self._scale / lambda_))
# offset for ncx gate checking subpattern
offset = fo + 1 if fo < k - n else fo
# rotation is happening here
# 1. rotate by half angle
qc.mcu3(theta / 2, 0, 0, [self._workq[0], self._msq[0]],
self._anc[0])
# 2. mct gate to reverse rotation direction
self._set_bit_pattern(subpattern, self._anc[0], offset)
# 3. rotate by inverse of halfangle to uncompute / complete
qc.mcu3(-theta / 2, 0, 0, [self._workq[0], self._msq[0]],
self._anc[0])
# 4. mct gate to uncompute first mct gate
self._set_bit_pattern(subpattern, self._anc[0], offset)
# uncompute m-bit pattern
self._set_bit_pattern(mainpat, self._workq[0], offset_mpat + 1)
last_fo = fo
# uncompute msq register
if self._negative_evals:
self._set_msq(self._msq,
ev[1:],
int(last_fo - 1),
last_iteration=True)
else:
self._set_msq(self._msq,
self._ev,
int(last_fo),
last_iteration=True)
# rotate by pi to fix sign for negative evals
if self._negative_evals:
qc.cu3(2 * np.pi, 0, 0, self._ev[0], self._anc[0])
self._circuit = qc
return self._circuit
from qiskit import ClassicalRegister, QuantumRegister
from qiskit import QuantumCircuit, execute
from qiskit.tools.visualization import plot_histogram, circuit_drawer
qr = QuantumRegister(16)
cr = ClassicalRegister(16)
qc = QuantumCircuit(qr,cr)
qc.x(qr[0])
qc.x(qr[3])
qc.x(qr[5])
qc.h(qr[9])
qc.cx(qr[9], qr[8])
qc.x(qr[11])
qc.x(qr[12])
qc.x(qr[13])
for j in range(16):
qc.measure(qr[j],cr[j])
print("Done\n")
#Sign onto IBM UE
from qiskit import register, available_backends, get_backend
#import Qconfig and set APIToken and API url
try:
import sys
sys.path.append("../") #go to parent directory
import Qconfig
def test_circuit_depth_empty(self):
"""Test depth of empty circuity
"""
q = QuantumRegister(5, 'q')
qc = QuantumCircuit(q)
self.assertEqual(qc.depth(), 0)
def test_evaluate_single_pauli_statevector(self):
""" evaluate single pauli statevector test """
# X
op = WeightedPauliOperator.from_list([Pauli.from_label('X')])
qr = QuantumRegister(1, name='q')
wave_function = QuantumCircuit(qr)
# + 1 eigenstate
wave_function.h(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(1.0, actual_value[0].real, places=5)
# - 1 eigenstate
wave_function = QuantumCircuit(qr)
wave_function.x(qr[0])
wave_function.h(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(-1.0, actual_value[0].real, places=5)
# Y
op = WeightedPauliOperator.from_list([Pauli.from_label('Y')])
qr = QuantumRegister(1, name='q')
wave_function = QuantumCircuit(qr)
# + 1 eigenstate
wave_function.h(qr[0])
wave_function.s(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(1.0, actual_value[0].real, places=5)
# - 1 eigenstate
wave_function = QuantumCircuit(qr)
wave_function.x(qr[0])
wave_function.h(qr[0])
wave_function.s(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(-1.0, actual_value[0].real, places=5)
# Z
op = WeightedPauliOperator.from_list([Pauli.from_label('Z')])
qr = QuantumRegister(1, name='q')
wave_function = QuantumCircuit(qr)
# + 1 eigenstate
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(1.0, actual_value[0].real, places=5)
# - 1 eigenstate
wave_function = QuantumCircuit(qr)
wave_function.x(qr[0])
circuits = op.construct_evaluation_circuit(wave_function=wave_function,
statevector_mode=True)
result = self.quantum_instance_statevector.execute(circuits)
actual_value = op.evaluate_with_result(result=result,
statevector_mode=True)
self.assertAlmostEqual(-1.0, actual_value[0].real, places=5)
def test_mapping_correction(self):
"""Test mapping works in previous failed case.
"""
backend = FakeBackend()
qr = QuantumRegister(name='qr', size=11)
cr = ClassicalRegister(name='qc', size=11)
circuit = QuantumCircuit(qr, cr)
circuit.u3(1.564784764685993, -1.2378965763410095, 2.9746763177861713,
qr[3])
circuit.u3(1.2269835563676523, 1.1932982847014162, -1.5597357740824318,
qr[5])
circuit.cx(qr[5], qr[3])
circuit.u1(0.856768317675967, qr[3])
circuit.u3(-3.3911273825190915, 0.0, 0.0, qr[5])
circuit.cx(qr[3], qr[5])
circuit.u3(2.159209321625547, 0.0, 0.0, qr[5])
circuit.cx(qr[5], qr[3])
circuit.u3(0.30949966910232335, 1.1706201763833217, 1.738408691990081,
qr[3])
circuit.u3(1.9630571407274755, -0.6818742967975088, 1.8336534616728195,
qr[5])
circuit.u3(1.330181833806101, 0.6003162754946363, -3.181264980452862,
qr[7])
circuit.u3(0.4885914820775024, 3.133297443244865, -2.794457469189904,
qr[8])
circuit.cx(qr[8], qr[7])
circuit.u1(2.2196187596178616, qr[7])
circuit.u3(-3.152367609631023, 0.0, 0.0, qr[8])
circuit.cx(qr[7], qr[8])
circuit.u3(1.2646005789809263, 0.0, 0.0, qr[8])
circuit.cx(qr[8], qr[7])
circuit.u3(0.7517780502091939, 1.2828514296564781, 1.6781179605443775,
qr[7])
circuit.u3(0.9267400575390405, 2.0526277839695153, 2.034202361069533,
qr[8])
circuit.u3(2.550304293455634, 3.8250017126569698, -2.1351609599720054,
qr[1])
circuit.u3(0.9566260876600556, -1.1147561503064538, 2.0571590492298797,
qr[4])
circuit.cx(qr[4], qr[1])
circuit.u1(2.1899329069137394, qr[1])
circuit.u3(-1.8371715243173294, 0.0, 0.0, qr[4])
circuit.cx(qr[1], qr[4])
circuit.u3(0.4717053496327104, 0.0, 0.0, qr[4])
circuit.cx(qr[4], qr[1])
circuit.u3(2.3167620677708145, -1.2337330260253256,
-0.5671322899563955, qr[1])
circuit.u3(1.0468499525240678, 0.8680750644809365, -1.4083720073192485,
qr[4])
circuit.u3(2.4204244021892807, -2.211701932616922, 3.8297006565735883,
qr[10])
circuit.u3(0.36660280497727255, 3.273119149343493, -1.8003362351299388,
qr[6])
circuit.cx(qr[6], qr[10])
circuit.u1(1.067395863586385, qr[10])
circuit.u3(-0.7044917541291232, 0.0, 0.0, qr[6])
circuit.cx(qr[10], qr[6])
circuit.u3(2.1830003849921527, 0.0, 0.0, qr[6])
circuit.cx(qr[6], qr[10])
circuit.u3(2.1538343756723917, 2.2653381826084606, -3.550087952059485,
qr[10])
circuit.u3(1.307627685019188, -0.44686656993522567,
-2.3238098554327418, qr[6])
circuit.u3(2.2046797998462906, 0.9732961754855436, 1.8527865921467421,
qr[9])
circuit.u3(2.1665254613904126, -1.281337664694577, -1.2424905413631209,
qr[0])
circuit.cx(qr[0], qr[9])
circuit.u1(2.6209599970201007, qr[9])
circuit.u3(0.04680566321901303, 0.0, 0.0, qr[0])
circuit.cx(qr[9], qr[0])
circuit.u3(1.7728411151289603, 0.0, 0.0, qr[0])
circuit.cx(qr[0], qr[9])
circuit.u3(2.4866395967434443, 0.48684511243566697,
-3.0069186877854728, qr[9])
circuit.u3(1.7369112924273789, -4.239660866163805, 1.0623389015296005,
qr[0])
circuit.barrier(qr)
circuit.measure(qr, cr)
try:
dags = transpiler.transpile(circuit, backend)
except QISKitError:
dags = None
self.assertIsInstance(dags[0], DAGCircuit)
a = get_value_a(N)
""" If user wants to force some values, he can do that here, please make sure to update the print and that N and a are coprime"""
print('Forcing N=15 and a=4 because its the fastest case, please read top of source file for more info')
N = 15
a = 4
""" Get n value used in Shor's algorithm, to know how many qubits are used """
n = math.ceil(math.log(N, 2))
print('Total number of qubits used: {0}\n'.format(4 * n + 2))
""" Create quantum and classical registers """
"""auxilliary quantum register used in addition and multiplication"""
aux = QuantumRegister(n + 2)
"""quantum register where the sequential QFT is performed"""
up_reg = QuantumRegister(2 * n)
"""quantum register where the multiplications are made"""
down_reg = QuantumRegister(n)
"""classical register where the measured values of the QFT are stored"""
up_classic = ClassicalRegister(2 * n)
""" Create Quantum Circuit """
circuit = QuantumCircuit(down_reg, up_reg, aux, up_classic)
""" Initialize down register to 1 and create maximal superposition in top register """
circuit.h(up_reg)
circuit.x(down_reg[0])
""" Apply the multiplication gates as showed in the report in order to create the exponentiation """
def compute_circuit(self):
qr = QuantumRegister(self.max_wires, 'q')
qc = QuantumCircuit(qr)
for column_num in range(self.max_columns):
for wire_num in range(self.max_wires):
node = self.nodes[wire_num][column_num]
if node:
if node.node_type == node_types.IDEN:
# Identity gate
qc.id(qr[wire_num])
elif node.node_type == node_types.X:
if node.radians == 0:
if node.ctrl_a != -1:
if node.ctrl_b != -1:
# Toffoli gate
qc.ccx(qr[node.ctrl_a], qr[node.ctrl_b],
qr[wire_num])
else:
# Controlled X gate
qc.cx(qr[node.ctrl_a], qr[wire_num])
else:
# Pauli-X gate
qc.x(qr[wire_num])
else:
# Rotation around X axis
qc.rx(node.radians, qr[wire_num])
elif node.node_type == node_types.Y:
if node.radians == 0:
if node.ctrl_a != -1:
# Controlled Y gate
qc.cy(qr[node.ctrl_a], qr[wire_num])
else:
# Pauli-Y gate
qc.y(qr[wire_num])
else:
# Rotation around Y axis
qc.ry(node.radians, qr[wire_num])
elif node.node_type == node_types.Z:
if node.radians == 0:
if node.ctrl_a != -1:
# Controlled Z gate
qc.cz(qr[node.ctrl_a], qr[wire_num])
else:
# Pauli-Z gate
qc.z(qr[wire_num])
else:
if node.ctrl_a != -1:
# Controlled rotation around the Z axis
qc.crz(node.radians, qr[node.ctrl_a],
qr[wire_num])
else:
# Rotation around Z axis
qc.rz(node.radians, qr[wire_num])
elif node.node_type == node_types.S:
# S gate
qc.s(qr[wire_num])
elif node.node_type == node_types.SDG:
# S dagger gate
qc.sdg(qr[wire_num])
elif node.node_type == node_types.T:
# T gate
qc.t(qr[wire_num])
elif node.node_type == node_types.TDG:
# T dagger gate
qc.tdg(qr[wire_num])
elif node.node_type == node_types.H:
if node.ctrl_a != -1:
# Controlled Hadamard
qc.ch(qr[node.ctrl_a], qr[wire_num])
else:
# Hadamard gate
qc.h(qr[wire_num])
elif node.node_type == node_types.SWAP:
if node.ctrl_a != -1:
# Controlled Swap
qc.cswap(qr[node.ctrl_a], qr[wire_num],
qr[node.swap])
else:
# Swap gate
qc.swap(qr[wire_num], qr[node.swap])
return qc
def conditional_circuits_2bit(final_measure=True, conditional_type='gate'):
"""Conditional test circuits on 2-bit classical register."""
circuits = []
qr = QuantumRegister(1)
cond = ClassicalRegister(2, 'cond')
if final_measure:
cr = ClassicalRegister(1, 'meas')
regs = (qr, cr, cond)
else:
regs = (qr, cond)
# Conditional on 00 (cr = 00)
circuit = QuantumCircuit(*regs)
circuit.barrier(qr)
add_conditional_x(circuit, qr[0], cond, 0, conditional_type)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# Conditional on 00 (cr = 01)
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.measure(qr[0], cond[0])
circuit.x(qr)
circuit.barrier(qr)
add_conditional_x(circuit, qr[0], cond, 0, conditional_type)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# Conditional on 00 (cr = 10)
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.measure(qr[0], cond[1])
circuit.x(qr)
circuit.barrier(qr)
add_conditional_x(circuit, qr[0], cond, 0, conditional_type)
circuits.append(circuit)
# Conditional on 00 (cr = 11)
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.measure(qr[0], cond[0])
circuit.measure(qr[0], cond[1])
circuit.x(qr)
circuit.barrier(qr)
add_conditional_x(circuit, qr[0], cond, 0, conditional_type)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# Conditional on 01 (cr = 00)
circuit = QuantumCircuit(*regs)
add_conditional_x(circuit, qr[0], cond, 1, conditional_type)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# Conditional on 01 (cr = 01)
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.measure(qr[0], cond[0])
circuit.x(qr)
circuit.barrier(qr)
add_conditional_x(circuit, qr[0], cond, 1, conditional_type)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# Conditional on 01 (cr = 10)
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.measure(qr[0], cond[1])
circuit.x(qr)
circuit.barrier(qr)
add_conditional_x(circuit, qr[0], cond, 1, conditional_type)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# Conditional on 01 (cr = 11)
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.measure(qr[0], cond[0])
circuit.measure(qr[0], cond[1])
circuit.x(qr)
circuit.barrier(qr)
add_conditional_x(circuit, qr[0], cond, 1, conditional_type)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# Conditional on 10 (cr = 00)
circuit = QuantumCircuit(*regs)
circuit.x(qr).c_if(cond, 2)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# Conditional on 10 (cr = 01)
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.measure(qr[0], cond[0])
circuit.x(qr)
circuit.barrier(qr)
add_conditional_x(circuit, qr[0], cond, 2, conditional_type)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# Conditional on 10 (cr = 10)
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.measure(qr[0], cond[1])
circuit.x(qr)
circuit.barrier(qr)
add_conditional_x(circuit, qr[0], cond, 2, conditional_type)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# Conditional on 10 (cr = 11)
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.measure(qr[0], cond[0])
circuit.measure(qr[0], cond[1])
circuit.x(qr)
circuit.barrier(qr)
add_conditional_x(circuit, qr[0], cond, 2, conditional_type)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# Conditional on 11 (cr = 00)
circuit = QuantumCircuit(*regs)
circuit.barrier(qr)
add_conditional_x(circuit, qr[0], cond, 3, conditional_type)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# Conditional on 11 (cr = 01)
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.measure(qr[0], cond[0])
circuit.x(qr)
circuit.barrier(qr)
add_conditional_x(circuit, qr[0], cond, 3, conditional_type)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# Conditional on 11 (cr = 10)
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.measure(qr[0], cond[1])
circuit.x(qr)
circuit.barrier(qr)
add_conditional_x(circuit, qr[0], cond, 3, conditional_type)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# Conditional on 11 (cr = 11)
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.measure(qr[0], cond[0])
circuit.measure(qr[0], cond[1])
circuit.x(qr)
circuit.barrier(qr)
add_conditional_x(circuit, qr[0], cond, 3, conditional_type)
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
return circuits
def make_circuit(n:int,f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n,"qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[0]) # number=41
prog.cz(input_qubit[1],input_qubit[0]) # number=42
prog.h(input_qubit[0]) # number=43
prog.z(input_qubit[1]) # number=37
prog.h(input_qubit[0]) # number=51
prog.cz(input_qubit[1],input_qubit[0]) # number=52
prog.h(input_qubit[0]) # number=53
prog.h(input_qubit[4]) # number=21
prog.x(input_qubit[2]) # number=39
Zf = build_oracle(n, f)
repeat = floor(sqrt(2 ** n) * pi / 4)
for i in range(repeat):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.h(input_qubit[0]) # number=56
prog.cz(input_qubit[3],input_qubit[0]) # number=57
prog.h(input_qubit[0]) # number=58
prog.h(input_qubit[0]) # number=48
prog.cz(input_qubit[3],input_qubit[0]) # number=49
prog.h(input_qubit[0]) # number=50
prog.z(input_qubit[3]) # number=46
prog.cx(input_qubit[3],input_qubit[0]) # number=47
prog.x(input_qubit[4]) # number=40
prog.cx(input_qubit[3],input_qubit[0]) # number=35
prog.x(input_qubit[0]) # number=9
prog.cx(input_qubit[0],input_qubit[1]) # number=29
prog.x(input_qubit[1]) # number=30
prog.cx(input_qubit[0],input_qubit[1]) # number=31
prog.x(input_qubit[2]) # number=11
prog.x(input_qubit[1]) # number=44
prog.x(input_qubit[3]) # number=12
if n>=2:
prog.mcu1(pi,input_qubit[1:],input_qubit[0])
prog.cx(input_qubit[1],input_qubit[0]) # number=24
prog.x(input_qubit[0]) # number=25
prog.cx(input_qubit[1],input_qubit[0]) # number=26
prog.x(input_qubit[1]) # number=14
prog.x(input_qubit[2]) # number=15
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[0]) # number=17
prog.h(input_qubit[1]) # number=18
prog.cx(input_qubit[4],input_qubit[3]) # number=54
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[3]) # number=20
prog.x(input_qubit[1]) # number=22
prog.y(input_qubit[1]) # number=32
prog.x(input_qubit[1]) # number=23
prog.cx(input_qubit[4],input_qubit[3]) # number=55
# circuit end
return prog
def evolution_instruction(pauli_list, evo_time, num_time_slices,
controlled=False, power=1,
use_basis_gates=True, shallow_slicing=False,
barrier=False):
"""
Construct the evolution circuit according to the supplied specification.
Args:
pauli_list (list([[complex, Pauli]])): The list of pauli terms corresponding
to a single time slice to be evolved
evo_time (Union(complex, float, Parameter, ParameterExpression)): The evolution time
num_time_slices (int): The number of time slices for the expansion
controlled (bool, optional): Controlled circuit or not
power (int, optional): The power to which the unitary operator is to be raised
use_basis_gates (bool, optional): boolean flag for indicating only using basis
gates when building circuit.
shallow_slicing (bool, optional): boolean flag for indicating using shallow
qc.data reference repetition for slicing
barrier (bool, optional): whether or not add barrier for every slice
Returns:
Instruction: The Instruction corresponding to specified evolution.
Raises:
AquaError: power must be an integer and greater or equal to 1
ValueError: Unrecognized pauli
"""
if not isinstance(power, (int, np.int)) or power < 1:
raise AquaError("power must be an integer and greater or equal to 1.")
state_registers = QuantumRegister(pauli_list[0][1].num_qubits)
if controlled:
inst_name = 'Controlled-Evolution^{}'.format(power)
ancillary_registers = QuantumRegister(1)
qc_slice = QuantumCircuit(state_registers, ancillary_registers, name=inst_name)
else:
inst_name = 'Evolution^{}'.format(power)
qc_slice = QuantumCircuit(state_registers, name=inst_name)
# for each pauli [IXYZ]+, record the list of qubit pairs needing CX's
cnot_qubit_pairs = [None] * len(pauli_list)
# for each pauli [IXYZ]+, record the highest index of the nontrivial pauli gate (X,Y, or Z)
top_xyz_pauli_indices = [-1] * len(pauli_list)
for pauli_idx, pauli in enumerate(reversed(pauli_list)):
n_qubits = pauli[1].num_qubits
# changes bases if necessary
nontrivial_pauli_indices = []
for qubit_idx in range(n_qubits):
# pauli I
if not pauli[1].z[qubit_idx] and not pauli[1].x[qubit_idx]:
continue
if cnot_qubit_pairs[pauli_idx] is None:
nontrivial_pauli_indices.append(qubit_idx)
if pauli[1].x[qubit_idx]:
# pauli X
if not pauli[1].z[qubit_idx]:
if use_basis_gates:
qc_slice.u2(0.0, pi, state_registers[qubit_idx])
else:
qc_slice.h(state_registers[qubit_idx])
# pauli Y
elif pauli[1].z[qubit_idx]:
if use_basis_gates:
qc_slice.u3(pi / 2, -pi / 2, pi / 2, state_registers[qubit_idx])
else:
qc_slice.rx(pi / 2, state_registers[qubit_idx])
# pauli Z
elif pauli[1].z[qubit_idx] and not pauli[1].x[qubit_idx]:
pass
else:
raise ValueError('Unrecognized pauli: {}'.format(pauli[1]))
if nontrivial_pauli_indices:
top_xyz_pauli_indices[pauli_idx] = nontrivial_pauli_indices[-1]
# insert lhs cnot gates
if cnot_qubit_pairs[pauli_idx] is None:
cnot_qubit_pairs[pauli_idx] = list(zip(
sorted(nontrivial_pauli_indices)[:-1],
sorted(nontrivial_pauli_indices)[1:]
))
for pair in cnot_qubit_pairs[pauli_idx]:
qc_slice.cx(state_registers[pair[0]], state_registers[pair[1]])
# insert Rz gate
if top_xyz_pauli_indices[pauli_idx] >= 0:
# Because Parameter does not support complexity number operation; thus, we do
# the following tricks to generate parameterized instruction.
# We assume the coefficient in the pauli is always real. and can not do imaginary time
# evolution
if isinstance(evo_time, (Parameter, ParameterExpression)):
lam = 2.0 * pauli[0] / num_time_slices
lam = lam.real if lam.imag == 0 else lam
lam = lam * evo_time
else:
lam = (2.0 * pauli[0] * evo_time / num_time_slices).real
if not controlled:
if use_basis_gates:
qc_slice.u1(lam, state_registers[top_xyz_pauli_indices[pauli_idx]])
else:
qc_slice.rz(lam, state_registers[top_xyz_pauli_indices[pauli_idx]])
else:
if use_basis_gates:
qc_slice.u1(lam / 2, state_registers[top_xyz_pauli_indices[pauli_idx]])
qc_slice.cx(ancillary_registers[0],
state_registers[top_xyz_pauli_indices[pauli_idx]])
qc_slice.u1(-lam / 2, state_registers[top_xyz_pauli_indices[pauli_idx]])
qc_slice.cx(ancillary_registers[0],
state_registers[top_xyz_pauli_indices[pauli_idx]])
else:
qc_slice.crz(lam, ancillary_registers[0],
state_registers[top_xyz_pauli_indices[pauli_idx]])
# insert rhs cnot gates
for pair in reversed(cnot_qubit_pairs[pauli_idx]):
qc_slice.cx(state_registers[pair[0]], state_registers[pair[1]])
# revert bases if necessary
for qubit_idx in range(n_qubits):
if pauli[1].x[qubit_idx]:
# pauli X
if not pauli[1].z[qubit_idx]:
if use_basis_gates:
qc_slice.u2(0.0, pi, state_registers[qubit_idx])
else:
qc_slice.h(state_registers[qubit_idx])
# pauli Y
elif pauli[1].z[qubit_idx]:
if use_basis_gates:
qc_slice.u3(-pi / 2, -pi / 2, pi / 2, state_registers[qubit_idx])
else:
qc_slice.rx(-pi / 2, state_registers[qubit_idx])
# repeat the slice
if shallow_slicing:
logger.info('Under shallow slicing mode, the qc.data reference is repeated shallowly. '
'Thus, changing gates of one slice of the output circuit might affect '
'other slices.')
if barrier:
qc_slice.barrier(state_registers)
qc_slice.data *= (num_time_slices * power)
qc = qc_slice
else:
qc = QuantumCircuit(name=inst_name)
for _ in range(num_time_slices * power):
qc += qc_slice
if barrier:
qc.barrier(state_registers)
return qc.to_instruction()
def make_circuit(n: int, f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n, "qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[1]) # number=29
prog.cz(input_qubit[3], input_qubit[1]) # number=30
prog.h(input_qubit[1]) # number=31
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[4]) # number=21
Zf = build_oracle(n, f)
repeat = floor(sqrt(2**n) * pi / 4)
for i in range(repeat):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.h(input_qubit[0]) # number=38
prog.cz(input_qubit[1], input_qubit[0]) # number=39
prog.h(input_qubit[0]) # number=40
prog.h(input_qubit[0]) # number=51
prog.cz(input_qubit[1], input_qubit[0]) # number=52
prog.h(input_qubit[0]) # number=53
prog.h(input_qubit[0]) # number=64
prog.cz(input_qubit[1], input_qubit[0]) # number=65
prog.h(input_qubit[0]) # number=66
prog.x(input_qubit[0]) # number=49
prog.h(input_qubit[0]) # number=57
prog.cz(input_qubit[1], input_qubit[0]) # number=58
prog.h(input_qubit[0]) # number=59
prog.h(input_qubit[0]) # number=54
prog.cz(input_qubit[1], input_qubit[0]) # number=55
prog.h(input_qubit[0]) # number=56
prog.h(input_qubit[4]) # number=41
prog.h(input_qubit[0]) # number=61
prog.cz(input_qubit[1], input_qubit[0]) # number=62
prog.h(input_qubit[0]) # number=63
prog.x(input_qubit[1]) # number=10
prog.h(input_qubit[2]) # number=25
prog.cz(input_qubit[0], input_qubit[2]) # number=26
prog.h(input_qubit[2]) # number=27
prog.x(input_qubit[2]) # number=23
prog.cx(input_qubit[0], input_qubit[2]) # number=24
prog.h(input_qubit[3]) # number=67
prog.cz(input_qubit[0], input_qubit[3]) # number=68
prog.h(input_qubit[3]) # number=69
prog.x(input_qubit[3]) # number=33
prog.h(input_qubit[3]) # number=42
prog.cz(input_qubit[0], input_qubit[3]) # number=43
prog.h(input_qubit[3]) # number=44
if n >= 2:
prog.mcu1(pi, input_qubit[1:], input_qubit[0])
prog.x(input_qubit[0]) # number=13
prog.rx(0.6157521601035993, input_qubit[1]) # number=60
prog.x(input_qubit[1]) # number=14
prog.x(input_qubit[2]) # number=15
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[0]) # number=17
prog.h(input_qubit[1]) # number=18
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[3]) # number=20
# circuit end
return prog
def make_circuit(n:int,f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n,"qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[4]) # number=21
Zf = build_oracle(n, f)
repeat = floor(sqrt(2 ** n) * pi / 4)
for i in range(1):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.h(input_qubit[0]) # number=33
prog.cz(input_qubit[1],input_qubit[0]) # number=34
prog.h(input_qubit[0]) # number=35
prog.rx(-0.7822565707438585,input_qubit[2]) # number=31
prog.cx(input_qubit[1],input_qubit[0]) # number=40
prog.x(input_qubit[0]) # number=41
prog.cx(input_qubit[1],input_qubit[0]) # number=42
prog.cx(input_qubit[1],input_qubit[0]) # number=30
prog.cx(input_qubit[0],input_qubit[1]) # number=25
prog.x(input_qubit[1]) # number=26
prog.cx(input_qubit[0],input_qubit[1]) # number=27
prog.cx(input_qubit[0],input_qubit[2]) # number=22
prog.x(input_qubit[2]) # number=23
prog.cx(input_qubit[0],input_qubit[2]) # number=24
prog.x(input_qubit[3]) # number=12
if n>=2:
prog.mcu1(pi,input_qubit[1:],input_qubit[0])
prog.x(input_qubit[0]) # number=13
prog.x(input_qubit[1]) # number=14
prog.x(input_qubit[2]) # number=15
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[0]) # number=17
prog.h(input_qubit[3]) # number=37
prog.cz(input_qubit[2],input_qubit[3]) # number=38
prog.h(input_qubit[3]) # number=39
prog.h(input_qubit[1]) # number=18
prog.h(input_qubit[2]) # number=19
prog.rx(2.5761059759436304,input_qubit[3]) # number=32
prog.h(input_qubit[3]) # number=20
prog.h(input_qubit[0])
prog.h(input_qubit[1])
prog.h(input_qubit[2])
prog.h(input_qubit[3])
# circuit end
for i in range(n):
prog.measure(input_qubit[i], classical[i])
return prog
circuit.cx(register[0], register[1])
circuit.h(register[1])
circuit.x(register)
circuit.h(register)
def calculate_cost(qc):
pass_ = Unroller(['u3', 'cx'])
pm = PassManager(pass_)
new_circuit = pm.run(qc)
structure = new_circuit.count_ops()
print(structure)
print('Cost: ' + str(structure['u3'] + structure['cx'] * 10))
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
groverCircuit = QuantumCircuit(qr, cr)
groverCircuit.h(qr)
phase_oracle(groverCircuit, qr)
inversion_about_average(groverCircuit, qr)
groverCircuit.measure(qr, cr)
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
results = execute(groverCircuit, backend=backend, shots=shots).result()
answer = results.get_counts()
print(answer)
def build_circuit(n: int, f: Callable[[str], str]) -> QuantumCircuit:
# implement the Bernstein-Vazirani circuit
zero = np.binary_repr(0, n)
b = f(zero)
# initial n + 1 bits
input_qubit = QuantumRegister(n+1, "qc")
classicals = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classicals)
# inverse last one (can be omitted if using O_f^\pm)
prog.x(input_qubit[n])
# circuit begin
prog.h(input_qubit[1]) # number=1
prog.h(input_qubit[2]) # number=38
prog.cz(input_qubit[0],input_qubit[2]) # number=39
prog.h(input_qubit[2]) # number=40
prog.h(input_qubit[2]) # number=59
prog.cz(input_qubit[0],input_qubit[2]) # number=60
prog.h(input_qubit[2]) # number=61
prog.h(input_qubit[2]) # number=42
prog.cz(input_qubit[0],input_qubit[2]) # number=43
prog.h(input_qubit[2]) # number=44
prog.h(input_qubit[2]) # number=48
prog.cz(input_qubit[0],input_qubit[2]) # number=49
prog.h(input_qubit[2]) # number=50
prog.cx(input_qubit[0],input_qubit[2]) # number=54
prog.x(input_qubit[2]) # number=55
prog.h(input_qubit[2]) # number=67
prog.cz(input_qubit[0],input_qubit[2]) # number=68
prog.h(input_qubit[2]) # number=69
prog.h(input_qubit[2]) # number=64
prog.cz(input_qubit[0],input_qubit[2]) # number=65
prog.h(input_qubit[2]) # number=66
prog.cx(input_qubit[0],input_qubit[2]) # number=37
prog.h(input_qubit[2]) # number=51
prog.cz(input_qubit[0],input_qubit[2]) # number=52
prog.h(input_qubit[2]) # number=53
prog.h(input_qubit[2]) # number=25
prog.cz(input_qubit[0],input_qubit[2]) # number=26
prog.h(input_qubit[2]) # number=27
prog.h(input_qubit[1]) # number=7
prog.cz(input_qubit[2],input_qubit[1]) # number=8
prog.rx(0.17592918860102857,input_qubit[2]) # number=34
prog.rx(-0.3989822670059037,input_qubit[1]) # number=30
prog.h(input_qubit[1]) # number=9
prog.h(input_qubit[1]) # number=18
prog.rx(2.3310617489636263,input_qubit[2]) # number=58
prog.cz(input_qubit[2],input_qubit[1]) # number=19
prog.h(input_qubit[1]) # number=20
prog.x(input_qubit[1]) # number=62
prog.y(input_qubit[1]) # number=14
prog.h(input_qubit[1]) # number=22
prog.cz(input_qubit[2],input_qubit[1]) # number=23
prog.rx(-0.9173450548482197,input_qubit[1]) # number=57
prog.cx(input_qubit[2],input_qubit[1]) # number=63
prog.h(input_qubit[1]) # number=24
prog.z(input_qubit[2]) # number=3
prog.cx(input_qubit[2],input_qubit[1]) # number=70
prog.cx(input_qubit[1],input_qubit[0]) # number=71
prog.z(input_qubit[1]) # number=72
prog.cx(input_qubit[1],input_qubit[0]) # number=73
prog.x(input_qubit[1]) # number=17
prog.y(input_qubit[2]) # number=5
prog.x(input_qubit[2]) # number=21
# apply H to get superposition
for i in range(n):
prog.h(input_qubit[i])
prog.h(input_qubit[n])
prog.barrier()
# apply oracle O_f
oracle = build_oracle(n, f)
prog.append(
oracle.to_gate(),
[input_qubit[i] for i in range(n)] + [input_qubit[n]])
# apply H back (QFT on Z_2^n)
for i in range(n):
prog.h(input_qubit[i])
prog.barrier()
# measure
return prog
# QISKITのクラス、関数をインポート from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister from qiskit import register, execute #from qiskit.tools.visualization import plot_histogram # 量子オラクル from bernstein_vazirani_oracle import * # 回路の作成 q = QuantumRegister(3) # q = QuantumRegister(4) c = ClassicalRegister(2) # c = ClassicalRegister(3) qc = QuantumCircuit(q, c) qc.x(q[2]) #qc.x(q[3]) qc.h(q[0]) qc.h(q[1]) qc.h(q[2]) #qc.h(q[3]) Uf_2(qc, q, c) # Uf_3(qc, q, c) qc.h(q[0]) qc.h(q[1]) qc.h(q[2]) # qc.h(q[3]) qc.measure(q[0], c[0]) qc.measure(q[1], c[1]) # qc.measure(q[2], c[2])
# Batch size
batch_size = 100
# Initialize qGAN
qgan = QGAN(real_data, bounds, num_qubits, batch_size, num_epochs, snapshot_dir=None)
qgan.seed = 1
# Set quantum instance to run the quantum generator
quantum_instance = QuantumInstance(backend=Aer.get_backend('statevector_simulator'))
# Set entangler map
entangler_map = [[0, 1]]
# Set an initial state for the generator circuit
init_dist = UniformDistribution(sum(num_qubits), low=bounds[0], high=bounds[1])
print(init_dist.probabilities)
q = QuantumRegister(sum(num_qubits), name='q')
qc = QuantumCircuit(q)
init_dist.build(qc, q)
init_distribution = Custom(num_qubits=sum(num_qubits), circuit=qc)
var_form = RY(int(np.sum(num_qubits)), depth=1, initial_state = init_distribution,
entangler_map=entangler_map, entanglement_gate='cz')
# Set generator's initial parameters
init_params = aqua_globals.random.rand(var_form._num_parameters) * 2 * np.pi
# Set generator circuit
g_circuit = UnivariateVariationalDistribution(int(sum(num_qubits)), var_form, init_params,
low=bounds[0], high=bounds[1])
# Set quantum generator
qgan.set_generator(generator_circuit=g_circuit)
# Set classical discriminator neural network
discriminator = NumpyDiscriminator(len(num_qubits))
qgan.set_discriminator(discriminator)
def make_circuit(n: int, f) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n, "qc")
classical = ClassicalRegister(n, "qm")
prog = QuantumCircuit(input_qubit, classical)
prog.h(input_qubit[0]) # number=3
prog.h(input_qubit[1]) # number=4
prog.h(input_qubit[2]) # number=5
prog.h(input_qubit[3]) # number=6
prog.h(input_qubit[4]) # number=21
prog.h(input_qubit[0]) # number=44
prog.cz(input_qubit[3], input_qubit[0]) # number=45
prog.h(input_qubit[0]) # number=46
prog.cx(input_qubit[3], input_qubit[0]) # number=48
prog.z(input_qubit[3]) # number=49
prog.cx(input_qubit[3], input_qubit[0]) # number=50
prog.h(input_qubit[0]) # number=51
prog.cz(input_qubit[3], input_qubit[0]) # number=52
prog.h(input_qubit[0]) # number=53
prog.rx(0.11938052083641225, input_qubit[1]) # number=36
prog.cx(input_qubit[1], input_qubit[2]) # number=47
Zf = build_oracle(n, f)
repeat = floor(sqrt(2**n) * pi / 4)
for i in range(repeat):
prog.append(Zf.to_gate(), [input_qubit[i] for i in range(n)])
prog.h(input_qubit[0]) # number=1
prog.rx(1.4765485471872026, input_qubit[2]) # number=35
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=7
prog.h(input_qubit[3]) # number=8
prog.cx(input_qubit[1], input_qubit[0]) # number=41
prog.x(input_qubit[0]) # number=42
prog.cx(input_qubit[1], input_qubit[0]) # number=43
prog.x(input_qubit[4]) # number=30
prog.x(input_qubit[1]) # number=10
prog.x(input_qubit[2]) # number=11
prog.rx(0.45238934211692994, input_qubit[3]) # number=38
prog.y(input_qubit[1]) # number=39
prog.rx(-2.5258404934861938, input_qubit[1]) # number=25
prog.h(input_qubit[3]) # number=29
prog.cx(input_qubit[0], input_qubit[3]) # number=22
prog.x(input_qubit[3]) # number=23
prog.cx(input_qubit[0], input_qubit[3]) # number=24
if n >= 2:
prog.mcu1(pi, input_qubit[1:], input_qubit[0])
prog.x(input_qubit[0]) # number=13
prog.rx(-0.0722566310325653, input_qubit[4]) # number=37
prog.x(input_qubit[1]) # number=14
prog.cx(input_qubit[0], input_qubit[2]) # number=26
prog.x(input_qubit[2]) # number=27
prog.h(input_qubit[4]) # number=40
prog.cx(input_qubit[0], input_qubit[2]) # number=28
prog.x(input_qubit[3]) # number=16
prog.h(input_qubit[0]) # number=17
prog.h(input_qubit[1]) # number=18
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[3]) # number=20
# circuit end
for i in range(n):
prog.measure(input_qubit[i], classical[i])
return prog
# import all necessary objects and methods for quantum circuits
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
from math import acos, pi
# after Hadamard operators
u = [(63/64)**0.5,(1/64)**0.5]
def angle_between_two_states(u1,u2):
dot_product = u1[0]*u2[0]+u1[1]*u2[1]
return acos(dot_product)
theta = angle_between_two_states(u,[1,0])
all_visited_quantum_states =[]
qreg3 = QuantumRegister(1) # quantum register with 1 qubit
creg3 = ClassicalRegister(1) # classical register with 1 bit
mycircuit3 = QuantumCircuit(qreg3,creg3) # quantum circuit with quantum and classical registers
# set the qubit to |u> by rotating it by theta
mycircuit3.ry(2*theta,qreg3[0])
# read and store the current quantum state
current_state = execute(mycircuit3,Aer.get_backend('statevector_simulator')).result().get_statevector(mycircuit3)
[x,y] = [current_state[0].real,current_state[1].real]
all_visited_quantum_states.append([x,y,'u'])
# three iterations
for i in range(3): # 4,5,6,7,8,9,10
