def test_transform_cirq_circuit_with_explicit_decompose(
parametric_circuit_with_params: Tuple[cirq.Circuit, cirq.Linspace],
) -> None:
"""test that a user add a custom circuit decomposition function"""
parametric_circuit, param_resolvers = parametric_circuit_with_params
parametric_circuit.append(cirq.I(cirq.GridQubit(0, 0)))
parametric_circuit.append(cirq.I(cirq.GridQubit(0, 1)))
parametric_circuit.append(
cirq.measure(cirq.GridQubit(0, 0), cirq.GridQubit(0, 1), key='m'),
)
circuit = cirq.protocols.resolve_parameters(parametric_circuit, param_resolvers[1])
def decompose_operation(operation: cirq.Operation) -> List[cirq.Operation]:
operations = [operation]
if isinstance(operation.gate, cirq.MeasurementGate) and operation.gate.num_qubits() == 1:
operations.append(cirq.I(operation.qubits[0]))
return operations
program, _ = transformers.build(
decompose_operation=decompose_operation,
)(circuit=circuit)
assert (
RX(np.pi / 2, 2) in program.instructions
), "executable should contain an RX(pi) 0 instruction"
assert I(0) in program.instructions, "executable should contain an I(0) instruction"
assert I(1) in program.instructions, "executable should contain an I(1) instruction"
assert I(2) in program.instructions, "executable should contain an I(2) instruction"
assert DECLARE("m0") in program.instructions, "executable should declare a read out bit"
assert (
MEASURE(0, ("m0", 0)) in program.instructions
), "executable should measure the read out bit"
def make_data(qubits):
train, train_label = [], []
# 0 XOR 0
cir = cirq.Circuit()
cir.append([cirq.I(qubits[0])])
cir.append([cirq.I(qubits[1])])
train.append(cir)
train_label.append(-1)
# 1 XOR 0
cir = cirq.Circuit()
cir.append([cirq.X(qubits[0])])
cir.append([cirq.I(qubits[1])])
train.append(cir)
train_label.append(1)
# 0 XOR 1
cir = cirq.Circuit()
cir.append([cirq.I(qubits[0])])
cir.append([cirq.X(qubits[1])])
train.append(cir)
train_label.append(1)
# 1 XOR 1
cir = cirq.Circuit()
cir.append([cirq.X(qubits[0])])
cir.append([cirq.X(qubits[1])])
train.append(cir)
train_label.append(-1)
return tfq.convert_to_tensor(train), np.array(
train_label), tfq.convert_to_tensor(train), np.array(train_label)
def test_simulate_global_phase_operation():
q1, q2 = cirq.LineQubit.range(2)
circuit = cirq.Circuit([cirq.I(q1), cirq.I(q2), cirq.global_phase_operation(-1j)])
simulator = cirq.CliffordSimulator()
result = simulator.simulate(circuit).final_state.state_vector()
assert np.allclose(result, [-1j, 0, 0, 0])
def test_identity_multiplication():
a, b, c = cirq.LineQubit.range(3)
assert cirq.X(a) * cirq.I(a) == cirq.X(a)
assert cirq.X(a) * cirq.I(b) == cirq.X(a)
assert cirq.X(a) * cirq.Y(b) * cirq.I(c) == cirq.X(a) * cirq.Y(b)
assert cirq.I(c) * cirq.X(a) * cirq.Y(b) == cirq.X(a) * cirq.Y(b)
with pytest.raises(TypeError):
_ = cirq.H(c) * cirq.X(a) * cirq.Y(b)
with pytest.raises(TypeError):
_ = cirq.X(a) * cirq.Y(b) * cirq.H(c)
with pytest.raises(TypeError):
_ = cirq.I(a) * str(cirq.Y(b))
def test_identity_multiplication():
a, b, c = cirq.LineQubit.range(3)
assert cirq.I(a) * cirq.CX(a, b) == cirq.CX(a, b)
assert cirq.CX(a, b) * cirq.I(a) == cirq.CX(a, b)
assert cirq.CZ(a, b) * cirq.I(c) == cirq.CZ(a, b)
assert cirq.CX(a, b)**0.5 * cirq.I(c) == cirq.CX(a, b)**0.5
assert cirq.I(c) * cirq.CZ(b, c)**0.5 == cirq.CZ(b, c)**0.5
assert cirq.T(a) * cirq.I(a) == cirq.T(a)
assert cirq.T(b) * cirq.I(c) == cirq.T(b)
assert cirq.T(a)**0.25 * cirq.I(c) == cirq.T(a)**0.25
assert cirq.I(c) * cirq.T(b)**0.25 == cirq.T(b)**0.25
def test_measure_single_paulistring():
# Correct application
q = cirq.LineQubit.range(3)
ps = cirq.X(q[0]) * cirq.Y(q[1]) * cirq.Z(q[2])
assert cirq.measure_single_paulistring(ps, key='a') == cirq.PauliMeasurementGate(
ps.values(), key='a'
).on(*ps.keys())
# Empty application
with pytest.raises(ValueError, match='should be an instance of cirq.PauliString'):
_ = cirq.measure_single_paulistring(cirq.I(q[0]) * cirq.I(q[1]))
# Wrong type
with pytest.raises(ValueError, match='should be an instance of cirq.PauliString'):
_ = cirq.measure_single_paulistring(q)
def test_mul_scalar():
a, b = cirq.LineQubit.range(2)
p = cirq.PauliString({a: cirq.X, b: cirq.Y})
assert -p == -1 * p == -1.0 * p == p * -1 == p * complex(-1)
assert -p != 1j * p
assert +p == 1 * p
assert p * cirq.I(a) == p
assert cirq.I(a) * p == p
with pytest.raises(TypeError,
match="sequence by non-int of type 'PauliString'"):
_ = p * 'test'
with pytest.raises(TypeError,
match="sequence by non-int of type 'PauliString'"):
_ = 'test' * p
def get_match_circuit() -> cirq.Circuit:
qubits = [cirq.LineQubit(i) for i in range(9)]
g = cirq.CZPowGate(exponent=0.1)
zz = cirq.ZZPowGate(exponent=0.3)
px = cirq.PhasedXPowGate(phase_exponent=0.6, exponent=0.2)
circ = cirq.Circuit(
[
cirq.H(qubits[0]),
cirq.X(qubits[1]),
cirq.Y(qubits[2]),
cirq.Z(qubits[3]),
cirq.S(qubits[4]),
cirq.CNOT(qubits[1], qubits[4]),
cirq.T(qubits[3]),
cirq.CNOT(qubits[6], qubits[8]),
cirq.I(qubits[5]),
cirq.XPowGate(exponent=0.1)(qubits[5]),
cirq.YPowGate(exponent=0.1)(qubits[6]),
cirq.ZPowGate(exponent=0.1)(qubits[7]),
g(qubits[2], qubits[3]),
zz(qubits[3], qubits[4]),
px(qubits[6]),
cirq.CZ(qubits[2], qubits[3]),
cirq.ISWAP(qubits[4], qubits[5]),
cirq.FSimGate(1.4, 0.7)(qubits[6], qubits[7]),
cirq.google.SYC(qubits[3], qubits[0]),
cirq.PhasedISwapPowGate(phase_exponent=0.7, exponent=0.8)(
qubits[3], qubits[4]),
cirq.GlobalPhaseOperation(1j),
cirq.measure_each(*qubits[3:-2]),
],
strategy=InsertStrategy.EARLIEST,
)
return circ
def bit_flip_bell(qubits):
eb = cirq.Circuit()
bitflip_1 = [cirq.GridQubit(1, i) for i in range(2)]
bitflip_2 = [cirq.GridQubit(2, i) for i in range(2)]
eb.append(cirq.CNOT(qubits[0], bitflip_1[0]))
eb.append(cirq.CNOT(qubits[0], bitflip_1[1]))
eb.append(cirq.CNOT(qubits[1], bitflip_2[0]))
eb.append(cirq.CNOT(qubits[1], bitflip_2[1]))
eb.append(cirq.H(qubits[0]))
for i in range(2):
r = random.random()
if r < 1 / 3:
eb.append(cirq.I(qubits[i]))
elif r < 2 / 3:
eb.append(cirq.X(qubits[i]))
else:
eb.append(cirq.Z(qubits[i]))
eb.append(cirq.CNOT(qubits[0], qubits[1]))
eb.append(cirq.CNOT(qubits[0], bitflip_1[0]))
eb.append(cirq.CNOT(qubits[0], bitflip_1[1]))
eb.append(cirq.X(qubits[0]).controlled_by(*bitflip_1))
eb.append(cirq.CNOT(qubits[1], bitflip_2[0]))
eb.append(cirq.CNOT(qubits[1], bitflip_2[1]))
eb.append(cirq.X(qubits[1]).controlled_by(*bitflip_2))
eb.append(cirq.measure(*qubits, key='result'))
return eb
def main():
circuit = cirq.Circuit()
message, alice, bob = cirq.LineQubit.range(3)
# Prepare the Bell state of Alice's and Bob's qubits
# That is, making the entangled state of them
circuit.append([cirq.H(alice), cirq.CNOT(alice, bob)])
# Mock up the message state that will be sent by Alice
# TODO: mocking in the random way
circuit.append(cirq.I(message))
# Bell measurement and get two classical bits
circuit.append([cirq.CNOT(message, alice), cirq.H(message)])
circuit.append(cirq.measure(message))
circuit.append(cirq.measure(alice))
# decode the state of the qubit owned by bob
circuit.append([cirq.CNOT(alice, bob), cirq.CZ(message, bob)])
# simulate the circuit
simulator = cirq.Simulator()
final_result = simulator.simulate(circuit)
print(circuit)
# The final_state should be one of the computation basis
# |000> + |001> + |010> + |011> +
# |100> + |101> + |110> + |111>
#
# Because the initial state of message is |0> and cirq.I does not change its state,
# so the final_state should be 1x|000>
print(final_result.final_state)
def test_init():
d = ion_device(3)
ms = 1000 * cirq.Duration(nanos=1)
q0 = cirq.LineQubit(0)
q1 = cirq.LineQubit(1)
q2 = cirq.LineQubit(2)
assert d.qubits == {q0, q1, q2}
assert d.duration_of(cirq.Z(q0)) == 10 * ms
assert d.duration_of(cirq.measure(q0)) == 100 * ms
assert d.duration_of(cirq.measure(q0, q1)) == 100 * ms
assert d.duration_of(cirq.ops.XX(q0, q1)) == 200 * ms
with pytest.raises(ValueError, match="Unsupported gate type"):
_ = d.duration_of(cirq.I(q0))
with pytest.raises(TypeError, match="NamedQubit"):
with cirq.testing.assert_deprecated(
"Use cirq_aqt.aqt_device.AQTDevice", deadline='v0.16'):
_ = cirq.IonDevice(
measurement_duration=ms,
twoq_gates_duration=ms,
oneq_gates_duration=ms,
qubits=[cirq.LineQubit(0),
cirq.NamedQubit("a")],
)
def test_serialize_circuit_with_identity(self):
"""A more generous error message for circuits containing cirq.I."""
q0 = cirq.GridQubit(0, 0)
unsupported_circuit = cirq.Circuit.from_ops(cirq.I(q0))
with self.assertRaisesRegex(ValueError, expected_regex="cirq.I"):
serializer.serialize_circuit(unsupported_circuit)
def test_on_each_bad_types():
ideal = cirq.Circuit(cirq.I(cirq.LineQubit(0)))
real = np.identity(4)
with pytest.raises(TypeError, match="must be iterable"):
NoisyOperation.on_each(ideal,
qubits=cirq.NamedQubit("new"),
channel_matrix=real)
def test_constructor_flexibility():
a, b = cirq.LineQubit.range(2)
with pytest.raises(TypeError, match='Not a `cirq.PAULI_STRING_LIKE`'):
_ = cirq.PauliString(cirq.CZ(a, b))
with pytest.raises(TypeError, match='Not a `cirq.PAULI_STRING_LIKE`'):
_ = cirq.PauliString('test')
with pytest.raises(TypeError, match='S is not a Pauli'):
_ = cirq.PauliString(qubit_pauli_map={a: cirq.S})
assert cirq.PauliString(
cirq.X(a)) == cirq.PauliString(qubit_pauli_map={a: cirq.X})
assert cirq.PauliString(
[cirq.X(a)]) == cirq.PauliString(qubit_pauli_map={a: cirq.X})
assert cirq.PauliString(
[[[cirq.X(a)]]]) == cirq.PauliString(qubit_pauli_map={a: cirq.X})
assert cirq.PauliString([[[cirq.I(a)]]]) == cirq.PauliString()
assert cirq.PauliString(1, 2, 3, cirq.X(a), cirq.Y(a)) == cirq.PauliString(
qubit_pauli_map={a: cirq.Z}, coefficient=6j)
assert cirq.PauliString(cirq.X(a), cirq.X(a)) == cirq.PauliString()
assert cirq.PauliString(cirq.X(a),
cirq.X(b)) == cirq.PauliString(qubit_pauli_map={
a: cirq.X,
b: cirq.X
})
assert cirq.PauliString(0) == cirq.PauliString(coefficient=0)
assert cirq.PauliString(1, 2, 3, {a: cirq.X},
cirq.Y(a)) == cirq.PauliString(
qubit_pauli_map={a: cirq.Z}, coefficient=6j)
def decompose_operation(operation: cirq.Operation) -> List[cirq.Operation]:
operations = [operation]
if isinstance(
operation.gate,
cirq.MeasurementGate) and operation.gate.num_qubits() == 1:
operations.append(cirq.I(operation.qubits[0]))
return operations
def test_superoperator():
cnot = cirq.unitary(cirq.CNOT)
a, b = cirq.LineQubit.range(2)
m = cirq.Moment()
assert m._has_superoperator_()
s = m._superoperator_()
assert np.allclose(s, np.array([[1.0]]))
m = cirq.Moment(cirq.I(a))
assert m._has_superoperator_()
s = m._superoperator_()
assert np.allclose(s, np.eye(4))
m = cirq.Moment(cirq.IdentityGate(2).on(a, b))
assert m._has_superoperator_()
s = m._superoperator_()
assert np.allclose(s, np.eye(16))
m = cirq.Moment(cirq.S(a))
assert m._has_superoperator_()
s = m._superoperator_()
assert np.allclose(s, np.diag([1, -1j, 1j, 1]))
m = cirq.Moment(cirq.CNOT(a, b))
assert m._has_superoperator_()
s = m._superoperator_()
assert np.allclose(s, np.kron(cnot, cnot))
m = cirq.Moment(cirq.depolarize(0.75).on(a))
assert m._has_superoperator_()
s = m._superoperator_()
assert np.allclose(s, np.array([[1, 0, 0, 1], [0, 0, 0, 0], [0, 0, 0, 0], [1, 0, 0, 1]]) / 2)
def test_rigetti_qcs_aspen_device_valid_qubit(
qubit: cirq.Qid, qcs_aspen8_isa: InstructionSetArchitecture
):
"""test RigettiQCSAspenDevice throws no error on valid qubits or operations on those qubits"""
device = RigettiQCSAspenDevice(isa=qcs_aspen8_isa)
device.validate_qubit(qubit)
device.validate_operation(cirq.I(qubit))
def get_FTTS_circuits(N):
freqs = np.linspace(0, np.pi, N // 2 + 1)[:-1]
q = cirq.GridQubit.rect(1, 1)
mod_funs = []
for i, ww in enumerate(freqs):
mod_fun = np.sign(np.cos(ww * np.arange(1, N + 1)))
mod_fun[mod_fun == 0] = 1
mod_fun = (mod_fun + 1) / 2
mod_funs.append(mod_fun)
circuits = []
for mod_fun in mod_funs:
circuit = cirq.Circuit()
circuit.append(cirq.rx(np.pi / 2).on(q[0]))
flip = np.concatenate(([0], np.abs(mod_fun[1:] - mod_fun[:-1])))
for f in flip:
if f == 1:
circuit.append(cirq.rx(np.pi).on(q[0]))
else:
circuit.append(cirq.I(q[0]))
if np.mod(np.sum(flip), 2) == 1:
circuit.append(cirq.rx(np.pi / 2).on(q[0]))
else:
circuit.append(cirq.rx(-np.pi / 2).on(q[0]))
circuits.append(circuit)
return circuits
def test_text_diagrams():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
circuit = cirq.Circuit(cirq.X(a), cirq.Y(a), cirq.Z(a),
cirq.Z(a)**sympy.Symbol('x'),
cirq.rx(sympy.Symbol('x')).on(a), cirq.CZ(a, b),
cirq.CNOT(a, b), cirq.CNOT(b, a),
cirq.H(a)**0.5, cirq.I(a),
cirq.IdentityGate(2)(a, b),
cirq.cphase(sympy.pi * sympy.Symbol('t')).on(a, b))
cirq.testing.assert_has_diagram(
circuit, """
a: ───X───Y───Z───Z^x───Rx(x)───@───@───X───H^0.5───I───I───@─────
│ │ │ │ │
b: ─────────────────────────────@───X───@───────────────I───@^t───
""")
cirq.testing.assert_has_diagram(circuit,
"""
a: ---X---Y---Z---Z^x---Rx(x)---@---@---X---H^0.5---I---I---@-----
| | | | |
b: -----------------------------@---X---@---------------I---@^t---
""",
use_unicode_characters=False)
def test_identity_mul():
class UnknownGate(cirq.SingleQubitGate):
pass
class UnknownOperation(cirq.Operation):
@property
def qubits(self):
raise NotImplementedError()
def with_qubits(self, *new_qubits):
raise NotImplementedError()
q = cirq.LineQubit(0)
g = UnknownGate().on(q)
i = cirq.I(q)
p = UnknownOperation()
assert g * i is g is i * g
assert p * i is p is i * p
assert i * i is i
with pytest.raises(TypeError):
_ = "test" * i
assert i * 2 == cirq.PauliString(coefficient=2)
assert 1j * i == cirq.PauliString(coefficient=1j)
def test_SequentialSchWARMAFier(self):
q0 = cirq.GridQubit(0,0)
q1 = cirq.GridQubit(1,0)
q2 = cirq.GridQubit(2,0)
circ = [cirq.CX(q0,q1),cirq.CX(q1,q2), cirq.I(q0), cirq.Z(q0)**.5,cirq.Z(q1)**.5,cirq.Z(q2)**.5, cirq.CX(q2,q1), cirq.CX(q1,q0),cirq.I(q2), cirq.Z(q0)**.25,cirq.Z(q1)**.25, cirq.Z(q2)**.25]
circ = cirq.Circuit(circ)
S1 = msim.SingleQubitControlSchWARMAFier([.1],[1],[cirq.ops.common_gates.ZPowGate, cirq.ops.pauli_gates._PauliZ],msim.cirq_gate_multiplicative)
Ss = [msim.GateQubitDependentSchWARMAFier([.1],[1], cirq.ops.common_gates.CXPowGate, qq, msim.cirq_gate_multiplicative, sym=sym) for sym, qq in zip(['a','b','c','d'],[(q0,q1),(q1,q2),(q2,q1),(q1,q0)])]
Stot = msim.SequentialSchWARMAFier([S1]+Ss)
circ = Stot.gen_noisy_circuit(circ)
self.assertIsInstance(circ, cirq.Circuit)
out = cirq.Simulator().simulate(circ).final_state_vector
circs = Stot.gen_noisy_circuit(circ, 3)
self.assertIsInstance(circs[0], cirq.Circuit)
self.assertEqual(len(circs), 3)
out = [cirq.Simulator().simulate(circ).final_state_vector for circ in circs]
def test_text_diagrams():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
circuit = cirq.Circuit.from_ops(
cirq.SWAP(a, b),
cirq.X(a),
cirq.Y(a),
cirq.Z(a),
cirq.Z(a)**sympy.Symbol('x'),
cirq.Rx(sympy.Symbol('x')).on(a),
cirq.CZ(a, b),
cirq.CNOT(a, b),
cirq.CNOT(b, a),
cirq.H(a)**0.5,
cirq.ISWAP(a, b)**-1,
cirq.I(a),
cirq.IdentityGate(2)(a, b))
cirq.testing.assert_has_diagram(circuit, """
a: ───×───X───Y───Z───Z^x───Rx(x)───@───@───X───H^0.5───iSwap──────I───I───
│ │ │ │ │ │
b: ───×─────────────────────────────@───X───@───────────iSwap^-1───────I───
""")
cirq.testing.assert_has_diagram(circuit, """
a: ---swap---X---Y---Z---Z^x---Rx(x)---@---@---X---H^0.5---iSwap------I---I---
| | | | | |
b: ---swap-----------------------------@---X---@-----------iSwap^-1-------I---
""", use_unicode_characters=False)
def test_direct_fidelity_estimation_intermediate_results():
qubits = cirq.LineQubit.range(1)
circuit = cirq.Circuit(cirq.I(qubits[0]))
no_noise_simulator = cirq.DensityMatrixSimulator()
_, intermediate_result = dfe.direct_fidelity_estimation(
circuit,
qubits,
no_noise_simulator,
n_measured_operators=1,
samples_per_term=0)
# We only test a few fields to be sure that they are set properly. In
# particular, some of them are random, and so we don't test them.
np.testing.assert_allclose(
intermediate_result.clifford_state.ch_form.gamma, [0])
np.testing.assert_equal(len(intermediate_result.pauli_traces), 1)
assert np.isclose(intermediate_result.pauli_traces[0].rho_i, 1.0)
assert np.isclose(intermediate_result.pauli_traces[0].Pr_i, 0.5)
np.testing.assert_equal(len(intermediate_result.trial_results), 1)
assert np.isclose(intermediate_result.trial_results[0].sigma_i, 1.0)
assert np.isclose(intermediate_result.std_dev_estimate, 0.0)
assert np.isclose(intermediate_result.std_dev_bound, 0.5)
def test_identity_on_each():
q0, q1, q2 = cirq.LineQubit.range(3)
assert cirq.I.on_each(q0, q1, q2) == [cirq.I(q0), cirq.I(q1), cirq.I(q2)]
assert cirq.I.on_each([q0, [q1],
q2]) == [cirq.I(q0),
cirq.I(q1),
cirq.I(q2)]
assert cirq.I.on_each(iter([q0, [q1],
q2])) == [cirq.I(q0),
cirq.I(q1),
cirq.I(q2)]
with pytest.raises(ValueError, match='str'):
cirq.I.on_each('abc')
def test_rigetti_qcs_aspen_device_invalid_qubit(
qubit: cirq.Qid, qcs_aspen8_isa: InstructionSetArchitecture):
"""test RigettiQCSAspenDevice throws error on invalid qubits"""
device = RigettiQCSAspenDevice(isa=qcs_aspen8_isa)
with pytest.raises(UnsupportedQubit):
device.validate_qubit(qubit)
with pytest.raises(UnsupportedQubit):
device.validate_operation(cirq.I(qubit))
def test_measure_paulistring_terms():
# Correct application
q = cirq.LineQubit.range(3)
ps = cirq.X(q[0]) * cirq.Y(q[1]) * cirq.Z(q[2])
assert cirq.measure_paulistring_terms(ps) == [
cirq.PauliMeasurementGate([cirq.X], key=str(q[0])).on(q[0]),
cirq.PauliMeasurementGate([cirq.Y], key=str(q[1])).on(q[1]),
cirq.PauliMeasurementGate([cirq.Z], key=str(q[2])).on(q[2]),
]
# Empty application
with pytest.raises(ValueError, match='should be an instance of cirq.PauliString'):
_ = cirq.measure_paulistring_terms(cirq.I(q[0]) * cirq.I(q[1]))
# Wrong type
with pytest.raises(ValueError, match='should be an instance of cirq.PauliString'):
_ = cirq.measure_paulistring_terms(q)
def generate_state(state, qubits):
circuit = cirq.Circuit()
for i in range(len(state)):
if state[i] == 1:
circuit.append(cirq.X(qubits[i]))
else:
circuit.append(cirq.I(qubits[i]))
return circuit
def UGate(umat):
"""Realises the specified unitary digonal matrix in a Qiskit quantum cricuit
Parameters:
umat (matrix): unitary diagonal matrix to realise
Returns:
QuantumCircuit which implements the unitary
"""
# Check input
nbits = np.log2(umat.shape[0])
if umat.shape[0] != umat.shape[1] or not nbits.is_integer:
raise Exception('Matrix has incorrect dimensions')
elif not np.allclose(np.matmul(umat, np.conj(umat)),
np.identity(umat.shape[0])):
raise Exception('Matrix is not unitary')
elif not np.allclose(umat, np.diag(np.diagonal(umat))):
raise Exception('matrix is not diagonal')
nbits = int(nbits) # n classical bits 1 < n < 8
# Pauli Decompose
hmat = np.angle(
umat
) # Tells us the complex argument of the matrix, thereby parameterizing the circuit
components = PauliDecompose(
hmat) # Decomposing the circuit according to the decomposing method
# order to implement Pauli component (reduces CNOTs used)
# iteratively add each pauli component
# Define the qubits in Cirq
circuit = cirq.Circuit()
circuit.append(cirq.I(q) for q in cirq.LineQubit.range(nbits))
for operator, coeff in components.items():
# find qubits CX-RZ-CX
cxlist = []
for i in range(len(operator)):
cxlist.append(i) if operator[i] == 'Z' else None
cxlist = [nbits - 1 - i for i in cxlist]
if coeff == 0 or len(cxlist) == 0:
continue
elif len(cxlist) == 1:
circuit.append(
cirq.ops.rz(-2 * coeff).on(cirq.LineQubit(cxlist[0])))
else:
for ctrl in cxlist[:-1]:
circuit.append(
cirq.ops.CNOT(control=ctrl,
target=cirq.LineQubit(cxlist[:-1])))
circuit.append(
cirq.ops.rz(-2 * coeff).on(cirq.LineQubit(cxlist[-1])))
for ctrl in reversed(cxlist[:-1]):
circuit.append(
cirq.ops.CNOT(control=ctrl,
target=cirq.LineQubit(cxlist[:-1])))
return circuit
def test_nondeterministic_mixture_noise():
q = cirq.LineQubit(0)
circuit = cirq.Circuit(cirq.I(q), cirq.measure(q))
simulator = cirq.Simulator(noise=cirq.ConstantQubitNoiseModel(cirq.depolarize(0.5)))
result1 = simulator.run(circuit, repetitions=50)
result2 = simulator.run(circuit, repetitions=50)
assert result1 != result2
def execute_cirq(cirq_gates, nqubits, initial_state=None) -> np.ndarray:
"""Executes a Cirq circuit with the given list of gates."""
c = cirq.Circuit()
q = [cirq.LineQubit(i) for i in range(nqubits)]
# apply identity gates to all qubits so that they become part of the circuit
c.append([cirq.I(qi) for qi in q])
for gate, targets in cirq_gates:
c.append(gate(*[q[i] for i in targets]))
result = cirq.Simulator().simulate(c, initial_state=initial_state)
return result.final_state
