def test_evolved_op_to_instruction(self):
"""Test calling `to_instruction` on a plain EvolvedOp.
Regression test of Qiskit/qiskit-terra#8025.
"""
op = EvolvedOp(0.5 * X)
circuit = op.to_instruction()
unitary = scipy.linalg.expm(-0.5j * X.to_matrix())
expected = UnitaryGate(unitary)
self.assertEqual(circuit, expected)
def test_trotter_with_identity(self):
""" trotterization of operator with identity term """
op = (2.0 * I ^ I) + (Z ^ Y)
exact_matrix = scipy.linalg.expm(-1j * op.to_matrix())
evo = PauliTrotterEvolution(trotter_mode='suzuki', reps=2)
with self.subTest('all PauliOp terms'):
circ_op = evo.convert(EvolvedOp(op))
circuit_matrix = qiskit.quantum_info.Operator(circ_op.to_circuit()).data
np.testing.assert_array_almost_equal(exact_matrix, circuit_matrix)
with self.subTest('MatrixOp identity term'):
op = (2.0 * I ^ I).to_matrix_op() + (Z ^ Y)
circ_op = evo.convert(EvolvedOp(op))
circuit_matrix = qiskit.quantum_info.Operator(circ_op.to_circuit()).data
np.testing.assert_array_almost_equal(exact_matrix, circuit_matrix)
with self.subTest('CircuitOp identity term'):
op = (2.0 * I ^ I).to_circuit_op() + (Z ^ Y)
circ_op = evo.convert(EvolvedOp(op))
circuit_matrix = qiskit.quantum_info.Operator(circ_op.to_circuit()).data
np.testing.assert_array_almost_equal(exact_matrix, circuit_matrix)
def test_coder_operators(self):
"""Test runtime encoder and decoder for operators."""
x = Parameter("x")
y = x + 1
qc = QuantumCircuit(1)
qc.h(0)
coeffs = np.array([1, 2, 3, 4, 5, 6])
table = PauliTable.from_labels(
["III", "IXI", "IYY", "YIZ", "XYZ", "III"])
op = (2.0 * I ^ I)
z2_symmetries = Z2Symmetries(
[Pauli("IIZI"), Pauli("ZIII")],
[Pauli("IIXI"), Pauli("XIII")], [1, 3], [-1, 1])
isqrt2 = 1 / np.sqrt(2)
sparse = scipy.sparse.csr_matrix([[0, isqrt2, 0, isqrt2]])
subtests = (
PauliSumOp(SparsePauliOp(Pauli("XYZX"), coeffs=[2]), coeff=3),
PauliSumOp(SparsePauliOp(Pauli("XYZX"), coeffs=[1]), coeff=y),
PauliSumOp(SparsePauliOp(Pauli("XYZX"), coeffs=[1 + 2j]),
coeff=3 - 2j),
PauliSumOp.from_list([("II", -1.052373245772859),
("IZ", 0.39793742484318045)]),
PauliSumOp(SparsePauliOp(table, coeffs), coeff=10),
MatrixOp(primitive=np.array([[0, -1j], [1j, 0]]), coeff=x),
PauliOp(primitive=Pauli("Y"), coeff=x),
CircuitOp(qc, coeff=x),
EvolvedOp(op, coeff=x),
TaperedPauliSumOp(SparsePauliOp(Pauli("XYZX"), coeffs=[2]),
z2_symmetries),
StateFn(qc, coeff=x),
CircuitStateFn(qc, is_measurement=True),
DictStateFn("1" * 3, is_measurement=True),
VectorStateFn(np.ones(2**3, dtype=complex)),
OperatorStateFn(CircuitOp(QuantumCircuit(1))),
SparseVectorStateFn(sparse),
Statevector([1, 0]),
CVaRMeasurement(Z, 0.2),
ComposedOp([(X ^ Y ^ Z), (Z ^ X ^ Y ^ Z).to_matrix_op()]),
SummedOp([X ^ X * 2, Y ^ Y], 2),
TensoredOp([(X ^ Y), (Z ^ I)]),
(Z ^ Z) ^ (I ^ 2),
)
for op in subtests:
with self.subTest(op=op):
encoded = json.dumps(op, cls=RuntimeEncoder)
self.assertIsInstance(encoded, str)
decoded = json.loads(encoded, cls=RuntimeDecoder)
self.assertEqual(op, decoded)
def test_compose_with_indices(self):
"""Test compose method using its permutation feature."""
pauli_op = X ^ Y ^ Z
circuit_op = T ^ H
matrix_op = (X ^ Y ^ H ^ T).to_matrix_op()
evolved_op = EvolvedOp(matrix_op)
# composition of PrimitiveOps
num_qubits = 4
primitive_op = pauli_op @ circuit_op @ matrix_op
composed_op = pauli_op @ circuit_op @ evolved_op
self.assertEqual(primitive_op.num_qubits, num_qubits)
self.assertEqual(composed_op.num_qubits, num_qubits)
# with permutation
num_qubits = 5
indices = [1, 4]
permuted_primitive_op = evolved_op @ circuit_op.permute(
indices) @ pauli_op @ matrix_op
composed_primitive_op = (evolved_op @ pauli_op.compose(
circuit_op, permutation=indices, front=True) @ matrix_op)
self.assertTrue(
np.allclose(permuted_primitive_op.to_matrix(),
composed_primitive_op.to_matrix()))
self.assertEqual(num_qubits, permuted_primitive_op.num_qubits)
# ListOp
num_qubits = 6
tensored_op = TensoredOp([pauli_op, circuit_op])
summed_op = pauli_op + circuit_op.permute([2, 1])
composed_op = circuit_op @ evolved_op @ matrix_op
list_op = summed_op @ composed_op.compose(
tensored_op, permutation=[1, 2, 3, 5, 4], front=True)
self.assertEqual(num_qubits, list_op.num_qubits)
num_qubits = 4
circuit_fn = CircuitStateFn(primitive=circuit_op.primitive,
is_measurement=True)
operator_fn = OperatorStateFn(primitive=circuit_op ^ circuit_op,
is_measurement=True)
no_perm_op = circuit_fn @ operator_fn
self.assertEqual(no_perm_op.num_qubits, num_qubits)
indices = [0, 4]
perm_op = operator_fn.compose(circuit_fn,
permutation=indices,
front=True)
self.assertEqual(perm_op.num_qubits, max(indices) + 1)
# StateFn
num_qubits = 3
dim = 2**num_qubits
vec = [1.0 / (i + 1) for i in range(dim)]
dic = {
format(i, "b").zfill(num_qubits): 1.0 / (i + 1)
for i in range(dim)
}
is_measurement = True
op_state_fn = OperatorStateFn(
matrix_op, is_measurement=is_measurement) # num_qubit = 4
vec_state_fn = VectorStateFn(vec, is_measurement=is_measurement) # 3
dic_state_fn = DictStateFn(dic, is_measurement=is_measurement) # 3
circ_state_fn = CircuitStateFn(circuit_op.to_circuit(),
is_measurement=is_measurement) # 2
composed_op = op_state_fn @ vec_state_fn @ dic_state_fn @ circ_state_fn
self.assertEqual(composed_op.num_qubits, op_state_fn.num_qubits)
# with permutation
perm = [2, 4, 6]
composed = (op_state_fn @ dic_state_fn.compose(
vec_state_fn, permutation=perm, front=True) @ circ_state_fn)
self.assertEqual(composed.num_qubits, max(perm) + 1)
