def test_reused_custom_gate_parameter(self):
"""Test reused custom gate with parameter."""
parameter_a = Parameter("a")
custom = QuantumCircuit(1)
custom.rx(parameter_a, 0)
circuit = QuantumCircuit(1)
circuit.append(
custom.bind_parameters({
parameter_a: 0.5
}).to_gate(), [0])
circuit.append(custom.bind_parameters({parameter_a: 1}).to_gate(), [0])
circuit_name_0 = circuit.data[0][0].definition.name
circuit_name_1 = circuit.data[1][0].definition.name
expected_qasm = "\n".join([
"OPENQASM 3;",
'include "stdgates.inc";',
f"gate {circuit_name_0} q_0 {{",
" rx(0.5) q_0;",
"}",
f"gate {circuit_name_1} q_0 {{",
" rx(1) q_0;",
"}",
"qubit[1] _q;",
"let q = _q[0];",
f"{circuit_name_0} q[0];",
f"{circuit_name_1} q[0];",
"",
])
self.assertEqual(Exporter().dumps(circuit), expected_qasm)
def test_fix_variable(self):
"""Test setting a varaible to a constant value"""
theta = Parameter('θ')
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
qc.rx(theta, qr)
qc.u3(0, theta, 0, qr)
bqc = qc.bind_parameters({theta: 0.5})
self.assertEqual(bqc.data[0][0].params[0], 0.5)
self.assertEqual(bqc.data[1][0].params[1], 0.5)
bqc = qc.bind_parameters({theta: 0.6})
self.assertEqual(bqc.data[0][0].params[0], 0.6)
self.assertEqual(bqc.data[1][0].params[1], 0.6)
def test_unbound_parameters_in_rzx_template(self):
"""
Test that rzx template ('zz2') functions correctly for a simple
circuit with an unbound ParameterExpression. This uses the same
Parameter (theta) as the template, so this also checks that template
substitution handle this correctly.
"""
theta = Parameter("ϴ")
circuit_in = QuantumCircuit(2)
circuit_in.cx(0, 1)
circuit_in.p(2 * theta, 1)
circuit_in.cx(0, 1)
pass_ = TemplateOptimization(**rzx_templates(["zz2"]))
circuit_out = PassManager(pass_).run(circuit_in)
# these are NOT equal if template optimization works
self.assertNotEqual(circuit_in, circuit_out)
# however these are equivalent if the operators are the same
theta_set = 0.42
self.assertTrue(
Operator(circuit_in.bind_parameters({theta: theta_set})).equiv(
circuit_out.bind_parameters({theta: theta_set})))
def PerformManySTsteps(self,STEPS=200,dt=1.7/200):
'''
Quantum circuit that performs time evolution from t=0 to t=simul_time
using STEPS.
'''
## Define parameter values for gates
## Values for theta parameters
th1 = 2*self.ExchangeIntegrals[0]*dt
th2 = 2*self.ExchangeIntegrals[1]*dt
th3 = 2*self.ExchangeIntegrals[2]*dt
## Values for alpha parameters
aH = 2*np.sqrt(sum(comps**2 for comps in self.ExternalField))*dt
## Define dictionary for parameter substitution
params = {
theta1:th1,
theta2:th2,
theta3:th3,
alphaH:aH,
}
## Create spin chain
spinChain = QuantumRegister(self.num_spins,name='s')
## Create measurement register
measureReg = ClassicalRegister(self.num_spins,name='b')
## Create quantum circuit
qc_MST = QuantumCircuit(spinChain,measureReg)
## Append ST steps to circuit
for _ in range(STEPS):
qc_MST.append(self.SuzukiTrotter(spinChain),spinChain)
## Perform measurement for further simulation
qc_MST.measure(spinChain,measureReg)
## Return circuit with binded parameters
try:
return qc_MST.bind_parameters(params)
except exceptions.CircuitError:
return qc_MST
def test_from_qasm_str_custom_gate4(self):
"""Test load custom gates (parameterized)
See: https://github.com/Qiskit/qiskit-terra/pull/3393#issuecomment-551307250
"""
qasm_string = """OPENQASM 2.0;
include "qelib1.inc";
gate my_gate(phi,lambda) q {u(1.5707963267948966,phi,lambda) q;}
qreg qr[1];
my_gate(pi, pi) qr[0];"""
circuit = QuantumCircuit.from_qasm_str(qasm_string)
my_gate_circuit = QuantumCircuit(1, name="my_gate")
phi = Parameter("phi")
lam = Parameter("lambda")
my_gate_circuit.u(1.5707963267948966, phi, lam, 0)
my_gate = my_gate_circuit.to_gate()
qr = QuantumRegister(1, name="qr")
expected = QuantumCircuit(qr, name="circuit")
expected.append(my_gate, [qr[0]])
expected = expected.bind_parameters({
phi: 3.141592653589793,
lam: 3.141592653589793
})
self.assertEqualUnroll("u", circuit, expected)
def test_decompose_propagates_deeply_bound_parameters(self, target_type):
"""Verify bind-before-decompose preserves deeply bound values."""
theta = Parameter('th')
qc1 = QuantumCircuit(1)
qc1.rx(theta, 0)
if target_type == 'gate':
inst = qc1.to_gate()
elif target_type == 'instruction':
inst = qc1.to_instruction()
qc2 = QuantumCircuit(1)
qc2.append(inst, [0])
if target_type == 'gate':
inst = qc2.to_gate()
elif target_type == 'instruction':
inst = qc2.to_instruction()
qc3 = QuantumCircuit(1)
qc3.append(inst, [0])
bound_qc3 = qc3.bind_parameters({theta: 0.5})
self.assertEqual(qc3.parameters, {theta})
self.assertEqual(bound_qc3.parameters, set())
decomposed_qc3 = bound_qc3.decompose()
deep_decomposed_qc3 = decomposed_qc3.decompose()
expected_qc3 = QuantumCircuit(1)
expected_qc3.rx(0.5, 0)
self.assertEqual(deep_decomposed_qc3.parameters, set())
self.assertEqual(deep_decomposed_qc3, expected_qc3)
def test_big_gates(self):
"""Test large gates with params"""
qr = QuantumRegister(6, "q")
circuit = QuantumCircuit(qr)
circuit.append(IQP([[6, 5, 3], [5, 4, 5], [3, 5, 1]]), [0, 1, 2])
desired_vector = [
1 / math.sqrt(16) * complex(0, 1),
1 / math.sqrt(8) * complex(1, 0),
1 / math.sqrt(16) * complex(1, 1),
0,
0,
1 / math.sqrt(8) * complex(1, 2),
1 / math.sqrt(16) * complex(1, 0),
0,
]
circuit.initialize(desired_vector, [qr[3], qr[4], qr[5]])
circuit.unitary([[1, 0], [0, 1]], [qr[0]])
matrix = np.zeros((4, 4))
theta = Parameter("theta")
circuit.append(HamiltonianGate(matrix, theta), [qr[1], qr[2]])
circuit = circuit.bind_parameters({theta: 1})
circuit.isometry(np.eye(4, 4), list(range(3, 5)), [])
self.circuit_drawer(circuit, filename="big_gates.png")
def test_custom_gate_with_bound_parameter(self):
"""Test custom gate with bound parameter."""
parameter_a = Parameter("a")
custom = QuantumCircuit(1)
custom.rx(parameter_a, 0)
custom_gate = custom.bind_parameters({parameter_a: 0.5}).to_gate()
custom_gate.name = "custom"
circuit = QuantumCircuit(1)
circuit.append(custom_gate, [0])
expected_qasm = "\n".join(
[
"OPENQASM 3;",
'include "stdgates.inc";',
"gate custom q_0 {",
" rx(0.5) q_0;",
"}",
"qubit[1] _q;",
"let q = _q[0];",
"custom q[0];",
"",
]
)
self.assertEqual(Exporter().dumps(circuit), expected_qasm)
def test_from_qasm_str_custom_gate6(self):
""" Test load custom gates (parameters used in expressions)
See: https://github.com/Qiskit/qiskit-terra/pull/3393#issuecomment-591668924
"""
qasm_string = """OPENQASM 2.0;
include "qelib1.inc";
gate my_gate(phi,lambda) q
{u2(phi+pi,lambda/2) q;} // parameters used in expressions
qreg qr[1];
my_gate(pi, pi) qr[0];"""
circuit = QuantumCircuit.from_qasm_str(qasm_string)
my_gate_circuit = QuantumCircuit(1, name='my_gate')
phi = Parameter('phi')
lam = Parameter('lambda')
my_gate_circuit.u2(phi + 3.141592653589793, lam / 2, 0)
my_gate = my_gate_circuit.to_gate()
qr = QuantumRegister(1, name='qr')
expected = QuantumCircuit(qr, name='circuit')
expected.append(my_gate, [qr[0]])
expected = expected.bind_parameters({
phi: 3.141592653589793,
lam: 3.141592653589793
})
self.assertEqualUnroll('u2', circuit, expected)
def test_executing_parameterized_instruction_bound_early(self, target_type):
"""Verify bind-before-execute preserves bound values."""
# ref: https://github.com/Qiskit/qiskit-terra/issues/2482
theta = Parameter('theta')
sub_qc = QuantumCircuit(2)
sub_qc.h(0)
sub_qc.cx(0, 1)
sub_qc.rz(theta, [0, 1])
sub_qc.cx(0, 1)
sub_qc.h(0)
if target_type == 'gate':
sub_inst = sub_qc.to_gate()
elif target_type == 'instruction':
sub_inst = sub_qc.to_instruction()
unbound_qc = QuantumCircuit(2, 1)
unbound_qc.append(sub_inst, [0, 1], [])
unbound_qc.measure(0, 0)
bound_qc = unbound_qc.bind_parameters({theta: numpy.pi/2})
shots = 1024
job = execute(bound_qc, backend=BasicAer.get_backend('qasm_simulator'), shots=shots)
self.assertDictAlmostEqual(job.result().get_counts(), {'1': shots}, 0.05 * shots)
def test_from_qasm_str_custom_gate5(self):
""" Test load custom gates (parametrized, with biop and constant)
See: https://github.com/Qiskit/qiskit-terra/pull/3393#issuecomment-551307250
"""
qasm_string = """OPENQASM 2.0;
include "qelib1.inc";
gate my_gate(phi,lambda) q {u3(pi/2,phi,lambda) q;} // biop with pi
qreg qr[1];
my_gate(pi, pi) qr[0];"""
circuit = QuantumCircuit.from_qasm_str(qasm_string)
my_gate_circuit = QuantumCircuit(1, name='my_gate')
phi = Parameter('phi')
lam = Parameter('lambda')
my_gate_circuit.u3(1.5707963267948966, phi, lam, 0)
my_gate = my_gate_circuit.to_gate()
qr = QuantumRegister(1, name='qr')
expected = QuantumCircuit(qr, name='circuit')
expected.append(my_gate, [qr[0]])
expected = expected.bind_parameters({
phi: 3.141592653589793,
lam: 3.141592653589793
})
self.assertEqualUnroll('u3', circuit, expected)
def test_decompose_propagates_bound_parameters(self, target_type):
"""Verify bind-before-decompose preserves bound values."""
# ref: https://github.com/Qiskit/qiskit-terra/issues/2482
theta = Parameter('th')
qc = QuantumCircuit(1)
qc.rx(theta, 0)
if target_type == 'gate':
inst = qc.to_gate()
elif target_type == 'instruction':
inst = qc.to_instruction()
qc2 = QuantumCircuit(1)
qc2.append(inst, [0])
bound_qc2 = qc2.bind_parameters({theta: 0.5})
self.assertEqual(qc2.parameters, {theta})
self.assertEqual(bound_qc2.parameters, set())
decomposed_qc2 = bound_qc2.decompose()
expected_qc2 = QuantumCircuit(1)
expected_qc2.rx(0.5, 0)
self.assertEqual(decomposed_qc2.parameters, set())
self.assertEqual(decomposed_qc2, expected_qc2)
def _check_circuit_and_bind_parameters(quantum_circuit: QuantumCircuit,
params: dict,
diff_params: dict) -> QuantumCircuit:
"""Utility function for checking for a valid quantum circuit and then binding parameters.
Args:
quantum_circuit (QuantumCircuit): the quantum circuit to check and bind the parameters for
params (dict): dictionary of the parameters in the circuit to their corresponding values
diff_params (dict): dictionary mapping the differentiable parameters to PennyLane
Variable instances
Returns:
QuantumCircuit: quantum circuit with bound parameters
"""
if not isinstance(quantum_circuit, QuantumCircuit):
raise ValueError(
"The circuit {} is not a valid Qiskit QuantumCircuit.".format(
quantum_circuit))
if params is None:
return quantum_circuit
for k in diff_params:
# Since we cannot bind Variables to Qiskit circuits,
# we must remove them from the binding dictionary before binding.
del params[k]
return quantum_circuit.bind_parameters(params)
def test_binding_across_broadcast_instruction(self):
"""Bind a parameter which was included via a broadcast instruction."""
# ref: https://github.com/Qiskit/qiskit-terra/issues/3008
from qiskit.extensions.standard import RZGate
theta = Parameter('θ')
n = 5
qc = QuantumCircuit(n, 1)
qc.h(0)
for i in range(n-1):
qc.cx(i, i+1)
qc.barrier()
qc.rz(theta, range(n))
qc.barrier()
for i in reversed(range(n-1)):
qc.cx(i, i+1)
qc.h(0)
qc.measure(0, 0)
theta_range = numpy.linspace(0, 2 * numpy.pi, 128)
circuits = [qc.bind_parameters({theta: theta_val})
for theta_val in theta_range]
self.assertEqual(len(circuits), len(theta_range))
for theta_val, bound_circ in zip(theta_range, circuits):
rz_gates = [inst for inst, qargs, cargs in bound_circ.data
if isinstance(inst, RZGate)]
self.assertEqual(len(rz_gates), n)
self.assertTrue(all(float(gate.params[0]) == theta_val
for gate in rz_gates))
def err(params: collections.abc.Collection, circ: qk.QuantumCircuit,
u_params: collections.abc.Collection) -> float:
tmp_circ_loc = circ.bind_parameters(
{u_params[i]: params[i]
for i in range(len(u_params))})
res = swap_test(tmp_circ_loc)
return (1 - res)**2
def test_big_gates(self):
"""Test large gates with params"""
filename = self._get_resource_path('test_latex_big_gates.tex')
qr = QuantumRegister(6, 'q')
circuit = QuantumCircuit(qr)
circuit.append(IQP([[6, 5, 3], [5, 4, 5], [3, 5, 1]]), [0, 1, 2])
desired_vector = [
1 / math.sqrt(16) * complex(0, 1),
1 / math.sqrt(8) * complex(1, 0),
1 / math.sqrt(16) * complex(1, 1),
0,
0,
1 / math.sqrt(8) * complex(1, 2),
1 / math.sqrt(16) * complex(1, 0),
0]
circuit.initialize(desired_vector, [qr[3], qr[4], qr[5]])
circuit.unitary([[1, 0], [0, 1]], [qr[0]])
matrix = np.zeros((4, 4))
theta = Parameter('theta')
circuit.append(HamiltonianGate(matrix, theta), [qr[1], qr[2]])
circuit = circuit.bind_parameters({theta: 1})
circuit.isometry(np.eye(4, 4), list(range(3, 5)), [])
circuit_drawer(circuit, filename=filename, output='latex_source')
self.assertEqualToReference(filename)
def __init__(self):
theta, phi = Parameter('theta'), Parameter('phi')
theta_values = np.arange(start=0,
stop=2 * np.pi,
step=np.pi / accuracy).tolist()
phi_values = np.arange(start=0, stop=np.pi,
step=np.pi / accuracy).tolist()
controls = QuantumRegister(4)
circuit3 = QuantumCircuit(controls)
circuit3.x(1)
circuit3.x(3)
circuit3.ry(theta=-theta, qubit=2, label='PMNS_H')
circuit3.ry(theta=-theta, qubit=3, label='PMNS_H')
# circuit3.unitary(PMNS_H, [2], label='PMNS_H')
# circuit3.unitary(PMNS_H, [3], label='PMNS_H')
# circuit3.unitary(U_t, [0], label='U(t)')
# circuit3.unitary(U_t, [1], label='U(t)')
# circuit3.unitary(U_t, [2], label='U(t)')
# circuit3.unitary(U_t, [3], label='U(t)')
bound_circuit = circuit3.bind_parameters({theta: theta_values})
circuit3.measure([0, 1, 2, 3], [0, 1, 2, 3])
circuit3.draw(output="mpl")
def test_bind_global_phase(self):
"""Test binding global phase."""
x = Parameter("x")
circuit = QuantumCircuit(1, global_phase=x)
self.assertEqual(circuit.parameters, {x})
bound = circuit.bind_parameters({x: 2})
self.assertEqual(bound.global_phase, 2)
self.assertEqual(bound.parameters, set())
def test_decomposes_into_correct_unitary(self):
"""test 2 qubit hamiltonian """
qc = QuantumCircuit(2)
matrix = Operator.from_label('XY')
theta = Parameter('theta')
uni2q = HamiltonianGate(matrix, theta)
qc.append(uni2q, [0, 1])
qc = qc.bind_parameters({theta: -np.pi / 2}).decompose()
decomposed_ham = qc.data[0][0]
self.assertEqual(decomposed_ham,
UnitaryGate(Operator.from_label('XY')))
def test_to_instruction_with_expression(self, target_type, order):
"""Test preservation of expressions via parameterized instructions.
┌───────┐┌──────────┐┌───────────┐
qr1_0: |0>┤ Rx(θ) ├┤ Rz(pi/2) ├┤ Ry(phi*θ) ├
└───────┘└──────────┘└───────────┘
┌───────────┐
qr2_0: |0>───┤ Ry(delta) ├───
┌──┴───────────┴──┐
qr2_1: |0>┤ Circuit0(phi,θ) ├
└─────────────────┘
qr2_2: |0>───────────────────
"""
theta = Parameter('θ')
phi = Parameter('phi')
qr1 = QuantumRegister(1, name='qr1')
qc1 = QuantumCircuit(qr1)
qc1.rx(theta, qr1)
qc1.rz(numpy.pi/2, qr1)
qc1.ry(theta * phi, qr1)
if target_type == 'gate':
gate = qc1.to_gate()
elif target_type == 'instruction':
gate = qc1.to_instruction()
self.assertEqual(gate.params, [phi, theta])
delta = Parameter('delta')
qr2 = QuantumRegister(3, name='qr2')
qc2 = QuantumCircuit(qr2)
qc2.ry(delta, qr2[0])
qc2.append(gate, qargs=[qr2[1]])
self.assertEqual(qc2.parameters, {delta, theta, phi})
binds = {delta: 1, theta: 2, phi: 3}
expected_qc = QuantumCircuit(qr2)
expected_qc.rx(2, 1)
expected_qc.rz(numpy.pi/2, 1)
expected_qc.ry(3 * 2, 1)
expected_qc.r(1, numpy.pi/2, 0)
if order == 'bind-decompose':
decomp_bound_qc = qc2.bind_parameters(binds).decompose()
elif order == 'decompose-bind':
decomp_bound_qc = qc2.decompose().bind_parameters(binds)
self.assertEqual(decomp_bound_qc.parameters, set())
self.assertEqual(decomp_bound_qc, expected_qc)
def test_gate_multiplicity_binding(self):
"""Test binding when circuit contains multiple references to same gate"""
from qiskit.extensions.standard import RZGate
qc = QuantumCircuit(1)
theta = Parameter('theta')
gate = RZGate(theta)
qc.append(gate, [0], [])
qc.append(gate, [0], [])
qc2 = qc.bind_parameters({theta: 1.0})
self.assertEqual(len(qc2._parameter_table), 0)
for gate, _, _ in qc2.data:
self.assertEqual(float(gate.params[0]), 1.0)
def test_bind_parameter_in_phase_and_gate(self):
"""Test binding a parameter present in the global phase and the gates."""
x = Parameter("x")
circuit = QuantumCircuit(1, global_phase=x)
circuit.rx(x, 0)
self.assertEqual(circuit.parameters, {x})
ref = QuantumCircuit(1, global_phase=2)
ref.rx(2, 0)
bound = circuit.bind_parameters({x: 2})
self.assertEqual(bound, ref)
self.assertEqual(bound.parameters, set())
def test_decompose_propagates_deeply_bound_parameters(
self, target_type, parameter_type):
"""Verify bind-before-decompose preserves deeply bound values."""
theta = Parameter('th')
qc1 = QuantumCircuit(1)
qc1.rx(theta, 0)
if target_type == 'gate':
inst = qc1.to_gate()
elif target_type == 'instruction':
inst = qc1.to_instruction()
qc2 = QuantumCircuit(1)
qc2.append(inst, [0])
if target_type == 'gate':
inst = qc2.to_gate()
elif target_type == 'instruction':
inst = qc2.to_instruction()
qc3 = QuantumCircuit(1)
qc3.append(inst, [0])
if parameter_type == 'numbers':
bound_qc3 = qc3.bind_parameters({theta: 0.5})
expected_parameters = set()
expected_qc3 = QuantumCircuit(1)
expected_qc3.rx(0.5, 0)
else:
phi = Parameter('ph')
bound_qc3 = qc3.copy()
bound_qc3._substitute_parameters({theta: phi})
expected_parameters = {phi}
expected_qc3 = QuantumCircuit(1)
expected_qc3.rx(phi, 0)
deep_decomposed_qc3 = bound_qc3.decompose().decompose()
with self.subTest(msg='testing parameters of initial circuit'):
self.assertEqual(qc3.parameters, {theta})
with self.subTest(msg='testing parameters of bound circuit'):
self.assertEqual(bound_qc3.parameters, expected_parameters)
with self.subTest(
msg='testing parameters of deep decomposed bound circuit'):
self.assertEqual(deep_decomposed_qc3.parameters,
expected_parameters)
with self.subTest(msg='testing deep decomposed circuit'):
self.assertEqual(deep_decomposed_qc3, expected_qc3)
def test_partial_binding(self):
"""Test that binding a subset of circuit parameters returns a new parameterized circuit."""
theta = Parameter('θ')
x = Parameter('x')
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
qc.rx(theta, qr)
qc.u3(0, theta, x, qr)
pqc = qc.bind_parameters({theta: 2})
self.assertEqual(pqc.parameters, {x})
self.assertEqual(pqc.data[0][0].params[0], 2)
self.assertEqual(pqc.data[1][0].params[1], 2)
def test_to_instruction_expression_parameter_map(self, target_type, order):
"""Test preservation of expressions via instruction parameter_map."""
theta = Parameter('θ')
phi = Parameter('phi')
qr1 = QuantumRegister(1, name='qr1')
qc1 = QuantumCircuit(qr1)
qc1.rx(theta, qr1)
qc1.rz(numpy.pi / 2, qr1)
qc1.ry(theta * phi, qr1)
theta_p = Parameter('theta')
phi_p = Parameter('phi')
if target_type == 'gate':
gate = qc1.to_gate(parameter_map={theta: theta_p, phi: phi_p})
elif target_type == 'instruction':
gate = qc1.to_instruction(parameter_map={
theta: theta_p,
phi: phi_p
})
self.assertEqual(gate.params, [phi_p, theta_p])
delta = Parameter('delta')
qr2 = QuantumRegister(3, name='qr2')
qc2 = QuantumCircuit(qr2)
qc2.ry(delta, qr2[0])
qc2.append(gate, qargs=[qr2[1]])
self.assertEqual(qc2.parameters, {delta, theta_p, phi_p})
binds = {delta: 1, theta_p: 2, phi_p: 3}
expected_qc = QuantumCircuit(qr2)
expected_qc.rx(2, 1)
expected_qc.rz(numpy.pi / 2, 1)
expected_qc.ry(3 * 2, 1)
expected_qc.r(1, numpy.pi / 2, 0)
if order == 'bind-decompose':
decomp_bound_qc = qc2.bind_parameters(binds).decompose()
elif order == 'decompose-bind':
decomp_bound_qc = qc2.decompose().bind_parameters(binds)
self.assertEqual(decomp_bound_qc.parameters, set())
self.assertEqual(decomp_bound_qc, expected_qc)
def test_qobj_with_hamiltonian(self):
"""test qobj output with hamiltonian"""
qr = QuantumRegister(4)
qc = QuantumCircuit(qr)
qc.rx(np.pi / 4, qr[0])
matrix = Operator.from_label('XIZ')
theta = Parameter('theta')
uni = HamiltonianGate(matrix, theta, label='XIZ')
qc.append(uni, [qr[0], qr[1], qr[3]])
qc.cx(qr[3], qr[2])
qc = qc.bind_parameters({theta: np.pi / 2})
qobj = qiskit.compiler.assemble(qc)
instr = qobj.experiments[0].instructions[1]
self.assertEqual(instr.name, 'hamiltonian')
# Also test label
self.assertEqual(instr.label, 'XIZ')
np.testing.assert_array_almost_equal(
np.array(instr.params[0]).astype(np.complex64), matrix.data)
def test_quantum_circuit_with_bound_parameters(self, recorder):
"""Tests loading a quantum circuit that already had bound parameters."""
theta = Parameter("θ")
qc = QuantumCircuit(3, 1)
qc.rz(theta, [0])
qc_1 = qc.bind_parameters({theta: 0.5})
quantum_circuit = load(qc_1)
with recorder:
quantum_circuit()
assert len(recorder.queue) == 1
assert recorder.queue[0].name == "RZ"
assert recorder.queue[0].parameters == [0.5]
assert recorder.queue[0].wires == Wires([0])
def test_decompose_propagates_bound_parameters(self, target_type,
parameter_type):
"""Verify bind-before-decompose preserves bound values."""
# ref: https://github.com/Qiskit/qiskit-terra/issues/2482
theta = Parameter('th')
qc = QuantumCircuit(1)
qc.rx(theta, 0)
if target_type == 'gate':
inst = qc.to_gate()
elif target_type == 'instruction':
inst = qc.to_instruction()
qc2 = QuantumCircuit(1)
qc2.append(inst, [0])
if parameter_type == 'numbers':
bound_qc2 = qc2.bind_parameters({theta: 0.5})
expected_parameters = set()
expected_qc2 = QuantumCircuit(1)
expected_qc2.rx(0.5, 0)
else:
phi = Parameter('ph')
bound_qc2 = qc2.copy()
bound_qc2._substitute_parameters({theta: phi})
expected_parameters = {phi}
expected_qc2 = QuantumCircuit(1)
expected_qc2.rx(phi, 0)
decomposed_qc2 = bound_qc2.decompose()
with self.subTest(msg='testing parameters of initial circuit'):
self.assertEqual(qc2.parameters, {theta})
with self.subTest(msg='testing parameters of bound circuit'):
self.assertEqual(bound_qc2.parameters, expected_parameters)
with self.subTest(
msg='testing parameters of deep decomposed bound circuit'):
self.assertEqual(decomposed_qc2.parameters, expected_parameters)
with self.subTest(msg='testing deep decomposed circuit'):
self.assertEqual(decomposed_qc2, expected_qc2)
def test_bind_ryrz_vector(self):
"""Test binding a list of floats to a ParamterVector"""
qc = QuantumCircuit(4)
depth = 4
theta = ParameterVector('θ', length=len(qc.qubits) * depth * 2)
theta_iter = iter(theta)
for _ in range(depth):
for q in qc.qubits:
qc.ry(next(theta_iter), q)
qc.rz(next(theta_iter), q)
for i, q in enumerate(qc.qubits[:-1]):
qc.cx(qc.qubits[i], qc.qubits[i+1])
qc.barrier()
theta_vals = numpy.linspace(0, 1, len(theta)) * numpy.pi
self.assertEqual(set(qc.parameters), set(theta.params))
bqc = qc.bind_parameters({theta: theta_vals})
for gate_tuple in bqc.data:
if hasattr(gate_tuple[0], 'params') and gate_tuple[0].params:
self.assertIn(gate_tuple[0].params[0], theta_vals)
def test_1q_hamiltonian(self):
"""test 1 qubit hamiltonian"""
qr = QuantumRegister(1, 'q0')
cr = ClassicalRegister(1, 'c0')
qc = QuantumCircuit(qr, cr)
matrix = np.zeros((2, 2))
qc.x(qr[0])
theta = Parameter('theta')
qc.append(HamiltonianGate(matrix, theta), [qr[0]])
qc = qc.bind_parameters({theta: 1})
# test of text drawer
self.log.info(qc)
dag = circuit_to_dag(qc)
dag_nodes = dag.named_nodes('hamiltonian')
self.assertTrue(len(dag_nodes) == 1)
dnode = dag_nodes[0]
self.assertIsInstance(dnode.op, HamiltonianGate)
self.assertListEqual(dnode.qargs, qc.qubits)
assert_allclose(dnode.op.to_matrix(), np.eye(2))
