def make_accred_system(seed=None):
"""generate accred circuits"""
# Create a Quantum Register with n_qb qubits.
q_reg = QuantumRegister(4, 'q')
# Create a Classical Register with n_qb bits.
c_reg = ClassicalRegister(4, 's')
# Create a Quantum Circuit acting on the q register
target_circuit = QuantumCircuit(q_reg, c_reg)
target_circuit.h(0)
target_circuit.h(1)
target_circuit.h(2)
target_circuit.h(3)
target_circuit.cx(0, 1)
target_circuit.cx(0, 2)
target_circuit.h(1)
target_circuit.h(2)
target_circuit.cx(0, 3)
target_circuit.cx(1, 2)
target_circuit.h(1)
target_circuit.h(2)
target_circuit.h(3)
target_circuit.measure(q_reg, c_reg)
return AccreditationCircuits(target_circuit, seed=seed)
def test_readout_order(self):
"""Test one circuit, one register, out-of-order readout.
"""
qr = QuantumRegister(4)
cr = ClassicalRegister(4)
circuit = QuantumCircuit(qr, cr)
circuit.x(qr[0])
circuit.x(qr[2])
circuit.measure(qr[0], cr[2])
circuit.measure(qr[1], cr[0])
circuit.measure(qr[2], cr[1])
circuit.measure(qr[3], cr[3])
qobj_local = assemble(transpile(circuit, backend=self._local_backend))
result_local = self._local_backend.run(qobj_local).result()
for remote_backend in self._remote_backends:
with self.subTest(backend=remote_backend):
qobj_remote = assemble(
transpile(circuit, backend=remote_backend))
result_remote = remote_backend.run(qobj_remote).result()
self.assertDictAlmostEqual(result_remote.get_counts(circuit),
result_local.get_counts(circuit),
delta=50)
def make_circuit(n: int) -> QuantumCircuit:
# circuit begin
input_qubit = QuantumRegister(n, "qc")
prog = QuantumCircuit(input_qubit)
prog.h(input_qubit[0]) # number=1
prog.h(input_qubit[1]) # number=2
prog.h(input_qubit[2]) # number=3
prog.rx(2.7457519792374794, input_qubit[2]) # number=5
prog.h(input_qubit[3]) # number=4
for edge in E:
k = edge[0]
l = edge[1]
prog.cp(-2 * gamma, input_qubit[k - 1], input_qubit[l - 1])
prog.p(gamma, k)
prog.p(gamma, l)
prog.rx(2 * beta, range(len(V)))
prog.cx(input_qubit[1], input_qubit[0]) # number=6
prog.cx(input_qubit[1], input_qubit[0]) # number=7
# circuit end
return prog
def test_permute_wires_6(self):
"""
qr0:--(+)-------.--
| |
qr1:---|--------|--
|
qr2:---|--------|--
| |
qr3:---.--[H]--(+)-
Coupling map: [0]--[1]--[2]--[3]
"""
coupling = CouplingMap([[0, 1], [1, 2], [2, 3]])
qr = QuantumRegister(4, 'q')
circuit = QuantumCircuit(qr)
circuit.cx(qr[3], qr[0])
circuit.h(qr[3])
circuit.cx(qr[0], qr[3])
dag = circuit_to_dag(circuit)
pass_ = StochasticSwap(coupling, None, 20, 13)
after = pass_.run(dag)
self.assertEqual(dag, after)
def test_non_commutative_circuit_2(self):
"""A simple circuit where no gates commute
qr0:----.-------------
|
qr1:---(+)------.-----
|
qr2:---[H]-----(+)----
"""
qr = QuantumRegister(3, 'qr')
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.h(qr[2])
circuit.cx(qr[1], qr[2])
dag = circuit_to_dag(circuit)
self.pass_.run(dag)
expected = {
'qr[0]': [[1], [7], [2]],
'qr[1]': [[3], [7], [9], [4]],
'qr[2]': [[5], [8], [9], [6]]
}
self.assertCommutationSet(self.pset["commutation_set"], expected)
def _construct_circuit(x,
feature_map,
measurement,
is_statevector_sim=False):
"""
If `is_statevector_sim` is True, we only build the circuits for Psi(x1)|0> rather than
Psi(x2)^dagger Psi(x1)|0>.
"""
x1, x2 = x
if len(x1) != len(x2):
raise ValueError("x1 and x2 must be the same dimension.")
q = QuantumRegister(feature_map.num_qubits, 'q')
c = ClassicalRegister(feature_map.num_qubits, 'c')
qc = QuantumCircuit(q, c)
# write input state from sample distribution
qc += feature_map.construct_circuit(x1, q)
if not is_statevector_sim:
qc += feature_map.construct_circuit(x2, q).inverse()
if measurement:
qc.barrier(q)
qc.measure(q, c)
return qc
def test_permute_wires_1(self):
"""All of the test_permute_wires tests are derived
from the basic mapper tests. In this case, the
stochastic mapper handles a single
layer by qubit label permutations so as not to
introduce additional swap gates. The new
initial layout is found in pass_.initial_layout.
q0:-------
q1:--(+)--
|
q2:---.---
Coupling map: [1]--[0]--[2]
"""
coupling = CouplingMap([[0, 1], [0, 2]])
qr = QuantumRegister(3, 'q')
circuit = QuantumCircuit(qr)
circuit.cx(qr[1], qr[2])
dag = circuit_to_dag(circuit)
pass_ = StochasticSwap(coupling, None, 20, 13)
after = pass_.run(dag)
self.assertEqual(dag, after)
def test_unitary(self):
"""Test unitary gate instruction"""
max_qubits = 4
x_mat = np.array([[0, 1], [1, 0]])
# Test 1 to max_qubits for random n-qubit unitary gate
for i in range(max_qubits):
num_qubits = i + 1
# Apply X gate to all qubits
multi_x = x_mat
for _ in range(i):
multi_x = np.kron(multi_x, x_mat)
# Target counts
shots = 100
target_counts = {num_qubits * '1': shots}
# Test circuit
qr = QuantumRegister(num_qubits, 'qr')
cr = ClassicalRegister(num_qubits, 'cr')
circuit = QuantumCircuit(qr, cr)
circuit.unitary(multi_x, qr)
circuit.measure(qr, cr)
job = execute(circuit, self.backend, shots=shots)
result = job.result()
counts = result.get_counts(0)
self.assertEqual(counts, target_counts)
def test_iqae_circuits(self, efficient_circuit):
"""Test circuits resulting from iterative amplitude estimation.
Build the circuit manually and from the algorithm and compare the resulting unitaries.
"""
prob = 0.5
for k in range(2, 7):
qae = IterativeAmplitudeEstimation(0.01, 0.05, a_factory=BernoulliAFactory(prob))
angle = 2 * np.arcsin(np.sqrt(prob))
# manually set up the inefficient AE circuit
q_objective = QuantumRegister(1, 'q')
circuit = QuantumCircuit(q_objective)
# A operator
circuit.ry(angle, q_objective)
if efficient_circuit:
qae.q_factory = BernoulliQFactory(qae.a_factory)
# for power in range(k):
# circuit.ry(2 ** power * angle, q_objective[0])
circuit.ry(2 * k * angle, q_objective[0])
else:
q_factory = QFactory(qae.a_factory, i_objective=0)
for _ in range(k):
q_factory.build(circuit, q_objective)
expected_unitary = self._unitary.execute(circuit).get_unitary()
actual_circuit = qae.construct_circuit(k, measurement=False)
actual_unitary = self._unitary.execute(actual_circuit).get_unitary()
diff = np.sum(np.abs(actual_unitary - expected_unitary))
self.assertAlmostEqual(diff, 0)
def test_true_map_in_same_layer(self):
""" Two CXs distance_qubits 1 to each other, in the same layer
qr0:--(+)--
|
qr1:---.---
qr2:--(+)--
|
qr3:---.---
CouplingMap map: [0]->[1]->[2]->[3]
"""
qr = QuantumRegister(4, 'qr')
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[1])
circuit.cx(qr[2], qr[3])
coupling = CouplingMap([(0, 1), (1, 2), (2, 3)])
dag = circuit_to_dag(circuit)
pass_ = CheckMap(coupling)
pass_.run(dag)
self.assertTrue(pass_.property_set['is_swap_mapped'])
self.assertTrue(pass_.property_set['is_direction_mapped'])
def init_quantum(nhood):
v=nhood
a = (v[0][0]+v[0][1]+v[0][2]+v[1][0]+v[1][2]+v[2][0]+v[2][1]+v[2][2])/8
a = a/np.linalg.norm(a)
qr = QuantumRegister(3,'qr')
qc = QuantumCircuit(qr,name='conway')
counter = 0
initial_state = (1/np.sqrt(6))*np.array([2,1,0,1])
qc.initialize(initial_state,[qr[1],qr[2]])
qc.initialize(a,[qr[0]])
qc.cx(qr[0],qr[1])
qc.initialize(a,[qr[0]])
qc.cx(qr[0],qr[1])
qc.cx(qr[0],qr[2])
qc.cx(qr[1],qr[0])
qc.cx(qr[2],qr[0])
job = execute(qc,Aer.get_backend('statevector_simulator'))
results = job.result().get_statevector()
del qr
del qc
del job
value = partial_trace(results,[1,2])[0]
value = np.real(value)
return value
def test_true_map(self):
""" Mapped is easy to check
qr0:--X-[H]-X--
| |
qr1:--X-----|--
|
qr2:--------X--
CouplingMap map: [1]<-[0]->[2]
"""
qr = QuantumRegister(3, 'qr')
circuit = QuantumCircuit(qr)
circuit.swap(qr[0], qr[1])
circuit.h(qr[0])
circuit.swap(qr[0], qr[2])
coupling = CouplingMap([(0, 1), (0, 2)])
dag = circuit_to_dag(circuit)
pass_ = CheckMap(coupling)
pass_.run(dag)
self.assertTrue(pass_.property_set['is_swap_mapped'])
self.assertFalse(pass_.property_set['is_direction_mapped'])
def test_text_pager(self):
""" The pager breaks the circuit when the drawing does not fit in the console."""
expected = '\n'.join([" ┌───┐ »",
"q_0: |0>┤ X ├──■──»",
" └─┬─┘┌─┴─┐»",
"q_1: |0>──■──┤ X ├»",
" └───┘»",
" c_0: 0 ══════════»",
" »",
"« ┌─┐┌───┐ »",
"«q_0: ┤M├┤ X ├──■──»",
"« └╥┘└─┬─┘┌─┴─┐»",
"«q_1: ─╫───■──┤ X ├»",
"« ║ └───┘»",
"«c_0: ═╩═══════════»",
"« »",
"« ┌─┐┌───┐ ",
"«q_0: ┤M├┤ X ├──■──",
"« └╥┘└─┬─┘┌─┴─┐",
"«q_1: ─╫───■──┤ X ├",
"« ║ └───┘",
"«c_0: ═╩═══════════",
"« "])
qr = QuantumRegister(2, 'q')
cr = ClassicalRegister(1, 'c')
circuit = QuantumCircuit(qr, cr)
circuit.cx(qr[1], qr[0])
circuit.cx(qr[0], qr[1])
circuit.measure(qr[0], cr[0])
circuit.cx(qr[1], qr[0])
circuit.cx(qr[0], qr[1])
circuit.measure(qr[0], cr[0])
circuit.cx(qr[1], qr[0])
circuit.cx(qr[0], qr[1])
self.assertEqual(str(_text_circuit_drawer(circuit, line_length=20)), expected)
def test_circuit_count_ops(self):
"""Tet circuit count ops
"""
size = 6
q = QuantumRegister(size, 'q')
qc = QuantumCircuit(q)
ans = {}
num_gates = np.random.randint(50)
# h = 0, x = 1, y = 2, z = 3, cx = 4, ccx = 5
lookup = {0: 'h', 1: 'x', 2: 'y', 3: 'z', 4: 'cx', 5: 'ccx'}
for _ in range(num_gates):
item = np.random.randint(6)
if item in [0, 1, 2, 3]:
idx = np.random.randint(size)
if item == 0:
qc.h(q[idx])
elif item == 1:
qc.x(q[idx])
elif item == 2:
qc.y(q[idx])
elif item == 3:
qc.z(q[idx])
else:
idx = np.random.permutation(size)
if item == 4:
qc.cx(q[int(idx[0])], q[int(idx[1])])
elif item == 5:
qc.ccx(q[int(idx[0])], q[int(idx[1])], q[int(idx[2])])
if lookup[item] not in ans.keys():
ans[lookup[item]] = 1
else:
ans[lookup[item]] += 1
self.assertEqual(ans, qc.count_ops())
def test_3q_schedule(self):
"""Test a schedule that was recommended by David McKay :D """
backend = FakeOpenPulse3Q()
inst_map = backend.defaults().circuit_instruction_map
q = QuantumRegister(3)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, c)
qc.cx(q[0], q[1])
qc.u2(0.778, 0.122, q[2])
qc.u3(3.14, 1.57, 0., q[0])
qc.u2(3.14, 1.57, q[1])
qc.cx(q[1], q[2])
qc.u2(0.778, 0.122, q[2])
sched = schedule(qc, backend)
expected = Schedule(inst_map.get('cx', [0, 1]),
(22, inst_map.get('u2', [1], 3.14, 1.57)),
(46, inst_map.get('u2', [2], 0.778, 0.122)),
(50, inst_map.get('cx', [1, 2])),
(72, inst_map.get('u2', [2], 0.778, 0.122)),
(74, inst_map.get('u3', [0], 3.14, 1.57)))
for actual, expected in zip(sched.instructions, expected.instructions):
self.assertEqual(actual[0], expected[0])
self.assertEqual(actual[1].command, expected[1].command)
self.assertEqual(actual[1].channels, expected[1].channels)
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.rx(-0.09738937226128368, input_qubit[2]) # number=2
prog.h(input_qubit[1]) # number=3
# 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
def test_combine_circuit_extension_instructions(self):
"""Test combining circuits containing barrier, initializer, snapshot
"""
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qc1 = QuantumCircuit(qr)
desired_vector = [0.5, 0.5, 0.5, 0.5]
qc1.initialize(desired_vector, qr)
qc1.barrier()
qc2 = QuantumCircuit(qr, cr)
qc2.snapshot(slot='1')
qc2.measure(qr, cr)
new_circuit = qc1 + qc2
backend = Aer.get_backend('qasm_simulator_py')
shots = 1024
result = execute(new_circuit, backend=backend, shots=shots, seed=78).result()
snapshot_vectors = result.get_snapshot()
fidelity = state_fidelity(snapshot_vectors[0], desired_vector)
self.assertGreater(fidelity, 0.99)
counts = result.get_counts()
target = {'00': shots/4, '01': shots/4, '10': shots/4, '11': shots/4}
threshold = 0.04 * shots
self.assertDictAlmostEqual(counts, target, threshold)
def test_with_extension(self):
"""There are 2 idle physical bits to extend."""
layout = Layout([(self.qr3, 0),
None,
(self.qr3, 1),
None,
(self.qr3, 2)])
pass_ = EnlargeWithAncilla(layout)
after = pass_.run(self.dag)
final_layout = {0: (QuantumRegister(3, 'qr'), 0), 1: (QuantumRegister(2, 'ancilla'), 0),
2: (QuantumRegister(3, 'qr'), 1), 3: (QuantumRegister(2, 'ancilla'), 1),
4: (QuantumRegister(3, 'qr'), 2)}
qregs = list(after.qregs.values())
self.assertEqual(2, len(qregs))
self.assertEqual(self.qr3, qregs[0])
self.assertEqual(QuantumRegister(2, name='ancilla'), qregs[1])
self.assertEqual(final_layout, pass_.property_set['layout'].get_physical_bits())
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.rx(-0.1602212253330796, input_qubit[1]) # number=36
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.x(input_qubit[0]) # number=9
prog.cx(input_qubit[0], input_qubit[1]) # number=28
prog.h(input_qubit[4]) # number=31
prog.x(input_qubit[1]) # number=29
prog.h(input_qubit[1]) # number=37
prog.cz(input_qubit[0], input_qubit[1]) # number=38
prog.h(input_qubit[1]) # number=39
prog.cx(input_qubit[0], input_qubit[2]) # number=22
prog.cx(input_qubit[0], input_qubit[2]) # number=25
prog.x(input_qubit[2]) # number=26
prog.cx(input_qubit[0], input_qubit[2]) # number=27
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[1]) # number=18
prog.h(input_qubit[2]) # number=19
prog.h(input_qubit[3]) # number=20
prog.cx(input_qubit[1], input_qubit[0]) # number=33
prog.z(input_qubit[1]) # number=34
prog.cx(input_qubit[1], input_qubit[0]) # number=35
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
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.h(input_qubit[2]) # number=71
prog.cz(input_qubit[0], input_qubit[2]) # number=72
prog.h(input_qubit[2]) # number=73
prog.cx(input_qubit[0], input_qubit[2]) # number=74
prog.x(input_qubit[2]) # number=75
prog.cx(input_qubit[0], input_qubit[2]) # number=76
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.z(input_qubit[1]) # number=41
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
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[0]) # number=57
prog.cz(input_qubit[4],input_qubit[0]) # number=58
prog.h(input_qubit[0]) # number=59
prog.cx(input_qubit[4],input_qubit[0]) # number=66
prog.z(input_qubit[4]) # number=67
prog.cx(input_qubit[4],input_qubit[0]) # number=68
prog.cx(input_qubit[4],input_qubit[0]) # number=56
prog.h(input_qubit[2]) # number=50
prog.cz(input_qubit[4],input_qubit[2]) # number=51
prog.h(input_qubit[2]) # number=52
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=60
prog.z(input_qubit[3]) # number=61
prog.cx(input_qubit[3],input_qubit[0]) # number=62
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.h(input_qubit[0]) # number=63
prog.cz(input_qubit[1],input_qubit[0]) # number=64
prog.h(input_qubit[0]) # number=65
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
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.cx(input_qubit[1], input_qubit[0]) # number=56
prog.z(input_qubit[1]) # number=57
prog.cx(input_qubit[1], input_qubit[0]) # number=58
prog.cx(input_qubit[1], input_qubit[0]) # number=54
prog.cx(input_qubit[1], input_qubit[0]) # number=47
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.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 __init__(self, nbqbits, *args, **kwargs):
super().__init__(nbqbits)
self.qr = QuantumRegister(self.nbqbits, 'qr')
self.qc = QuantumCircuit(self.qr)
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=52
prog.z(input_qubit[4]) # number=53
prog.cx(input_qubit[4], input_qubit[0]) # number=54
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.x(input_qubit[0]) # number=41
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=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, x, parameters, q=None):
"""
Construct the variational form, given its parameters.
Args:
parameters (Union(numpy.ndarray, list[Parameter], ParameterVector)): circuit parameters
q (QuantumRegister): Quantum Register for the circuit.
Returns:
QuantumCircuit: a quantum circuit with given `parameters`
Raises:
ValueError: the number of parameters is incorrect.
"""
if len(parameters) != self._num_parameters:
raise ValueError('The number of parameters has to be {}'.format(
self._num_parameters))
print(x)
if len(x) != 3 * self._num_dis:
raise ValueError(
'The length of the bitstring should be num_qubit * 3')
if q is None:
q = QuantumRegister(self._num_qubits, name='q')
if self._initial_state is not None:
circuit = self._initial_state.construct_circuit('circuit', q)
else:
circuit = QuantumCircuit(q)
mapping = {
'000': 0,
'001': 1,
'010': 2,
'011': 3,
'100': 4,
'101': 5,
'110': 6,
'111': 7
}
# TE only discrete qubit
for qubit in range(self._num_dis):
st = x[qubit * 3:(qubit + 1) * 3]
circuit.u3(parameters[qubit * 16 + 2 * mapping[st]],
parameters[qubit * 16 + 2 * mapping[st] + 1], 0,
q[qubit])
param_idx = 16 * self._num_dis
# Skip to varform params
param_idx = self._pre_params
for qubit in range(self._num_qubits):
if not self._skip_unentangled_qubits or qubit in self._entangled_qubits:
circuit.u3(parameters[param_idx], 0.0, 0.0, q[qubit]) # ry
circuit.u1(parameters[param_idx + 1], q[qubit]) # rz
param_idx += 2
for _ in range(self._depth):
circuit.barrier(q)
for src, targ in self._entangler_map:
if self._entanglement_gate == 'cz':
circuit.u2(0.0, np.pi, q[targ]) # h
circuit.cx(q[src], q[targ])
circuit.u2(0.0, np.pi, q[targ]) # h
else:
circuit.cx(q[src], q[targ])
circuit.barrier(q)
for qubit in self._entangled_qubits:
circuit.u3(parameters[param_idx], 0.0, 0.0, q[qubit]) # ry
circuit.u1(parameters[param_idx + 1], q[qubit]) # rz
param_idx += 2
circuit.barrier(q)
return circuit
def test_mapping_correction(self):
"""Test mapping works in previous failed case.
"""
backend = FakeRueschlikon()
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)
circuits = transpile(circuit, backend)
self.assertIsInstance(circuits, QuantumCircuit)
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit, execute, Aer from qiskit import IBMQ IBMQ.load_account() S_simulator = Aer.backends(name='statevector_simulator')[0] M_simulator = Aer.backends(name='qasm_simulator')[0] q = QuantumRegister(2) c = ClassicalRegister(2) qc = QuantumCircuit(q, c) qc.h(q[0]) qc.h(q[1]) qc.measure(q[0], c[0]) job = execute(qc, M_simulator, shots=1000) result = job.result() result.get_counts(qc)
# -*- coding: utf-8 -*- # @Time : 2019/1/7 9:36 # @Author : Tan Zhijie # @Email : [email protected] # @File : testOffice01.py # @Software: PyCharm import numpy as np from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister from qiskit import execute # Create a Quantum Register with 3 qubits. q = QuantumRegister(3, 'q') # Create a Quantum Circuit acting on the q register circ = QuantumCircuit(q) # Add a H gate on qubit 0, putting this qubit in superposition. circ.h(q[0]) # Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting # the qubits in a Bell state. circ.cx(q[0], q[1]) # Add a CX (CNOT) gate on control qubit 0 and target qubit 2, putting # the qubits in a GHZ state. circ.cx(q[0], q[2]) circ.draw() # Import Aer from qiskit import BasicAer
def cx_gate_circuits_deterministic(final_measure=True):
"""CX-gate test circuits with deterministic counts."""
circuits = []
qr = QuantumRegister(2)
if final_measure:
cr = ClassicalRegister(2)
regs = (qr, cr)
else:
regs = (qr, )
# CX01, |00> state
circuit = QuantumCircuit(*regs)
circuit.cx(qr[0], qr[1])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX10, |00> state
circuit = QuantumCircuit(*regs)
circuit.cx(qr[1], qr[0])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX01.(X^I), |10> state
circuit = QuantumCircuit(*regs)
circuit.x(qr[1])
circuit.barrier(qr)
circuit.cx(qr[0], qr[1])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX10.(I^X), |01> state
circuit = QuantumCircuit(*regs)
circuit.x(qr[0])
circuit.barrier(qr)
circuit.cx(qr[1], qr[0])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX01.(I^X), |11> state
circuit = QuantumCircuit(*regs)
circuit.x(qr[0])
circuit.barrier(qr)
circuit.cx(qr[0], qr[1])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX10.(X^I), |11> state
circuit = QuantumCircuit(*regs)
circuit.x(qr[1])
circuit.barrier(qr)
circuit.cx(qr[1], qr[0])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX01.(X^X), |01> state
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.barrier(qr)
circuit.cx(qr[0], qr[1])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX10.(X^X), |10> state
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.barrier(qr)
circuit.cx(qr[1], qr[0])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
return circuits
def test_circuit_sampler2(self, method):
"""Test the probability gradient with the circuit sampler
dp0/da = cos(a)sin(b) / 2
dp1/da = - cos(a)sin(b) / 2
dp0/db = sin(a)cos(b) / 2
dp1/db = - sin(a)cos(b) / 2
"""
a = Parameter("a")
b = Parameter("b")
params = [a, b]
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(params[0], q[0])
qc.rx(params[1], q[0])
op = CircuitStateFn(primitive=qc, coeff=1.0)
shots = 8000
if method == "fin_diff":
np.random.seed(8)
prob_grad = Gradient(grad_method=method,
epsilon=shots**(-1 / 6.0)).convert(
operator=op, params=params)
else:
prob_grad = Gradient(grad_method=method).convert(operator=op,
params=params)
values_dict = [
{
a: [np.pi / 4],
b: [0]
},
{
params[0]: [np.pi / 4],
params[1]: [np.pi / 4]
},
{
params[0]: [np.pi / 2],
params[1]: [np.pi]
},
]
correct_values = [
[[0, 0], [1 / (2 * np.sqrt(2)), -1 / (2 * np.sqrt(2))]],
[[1 / 4, -1 / 4], [1 / 4, -1 / 4]],
[[0, 0], [-1 / 2, 1 / 2]],
]
backend = BasicAer.get_backend("qasm_simulator")
q_instance = QuantumInstance(backend=backend, shots=shots)
for i, value_dict in enumerate(values_dict):
sampler = CircuitSampler(backend=q_instance).convert(
prob_grad, params=value_dict)
result = sampler.eval()[0]
self.assertTrue(
np.allclose(result[0].toarray(),
correct_values[i][0],
atol=0.1))
self.assertTrue(
np.allclose(result[1].toarray(),
correct_values[i][1],
atol=0.1))
