def test_qubits():
a = cirq.QubitId()
b = cirq.QubitId()
assert Moment([cirq.X(a), cirq.X(b)]).qubits == {a, b}
assert Moment([cirq.X(a)]).qubits == {a}
assert Moment([cirq.CZ(a, b)]).qubits == {a, b}
def test_copy():
a = cirq.QubitId()
b = cirq.QubitId()
original = Moment([cirq.CZ(a, b)])
copy = original.__copy__()
assert original == copy
assert id(original) != id(copy)
def _merge_z_moments_func(m1: cirq.Moment,
m2: cirq.Moment) -> Optional[cirq.Moment]:
if any(op.gate != cirq.Z for m in [m1, m2] for op in m):
return None
return cirq.Moment(
cirq.Z(q) for q in (m1.qubits | m2.qubits)
if m1.operates_on([q]) ^ m2.operates_on([q]))
def test_qubits():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
assert Moment([cirq.X(a), cirq.X(b)]).qubits == {a, b}
assert Moment([cirq.X(a)]).qubits == {a}
assert Moment([cirq.CZ(a, b)]).qubits == {a, b}
def solve(self, output_mode=None, output_file_name=None):
result_depth, list_scheduled_gate_name, list_scheduled_gate_qubits, final_mapping = super(
).solve("IR")
circuit = Circuit()
for t in range(result_depth):
moment = Moment()
for i, qubits in enumerate(list_scheduled_gate_qubits[t]):
if isinstance(qubits, int):
moment = moment.with_operation(
GateOperation(list_scheduled_gate_name[t][i],
(self.map_to_cirq_qubit[qubits], )))
else:
if list_scheduled_gate_name[t][i] == "SWAP":
moment = moment.with_operation(
GateOperation(SWAP,
(self.map_to_cirq_qubit[qubits[0]],
self.map_to_cirq_qubit[qubits[1]])))
else:
moment = moment.with_operation(
GateOperation(list_scheduled_gate_name[t][i],
(self.map_to_cirq_qubit[qubits[0]],
self.map_to_cirq_qubit[qubits[1]])))
circuit += moment
final_cirq_mapping = dict()
for i in range(self.count_program_qubit):
final_cirq_mapping[self.map_to_cirq_qubit[
final_mapping[i]]] = self.map_program_qubit_to[i]
return [circuit, final_cirq_mapping]
def test_copy():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
original = Moment([cirq.CZ(a, b)])
copy = original.__copy__()
assert original == copy
assert id(original) != id(copy)
def test_copy():
a = cirq.QubitId()
b = cirq.QubitId()
original = Moment([cirq.CZ(a, b)])
copy = original.__copy__()
assert original == copy
assert id(original) != id(copy)
def test_json_dict():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
mom = Moment([cirq.CZ(a, b)])
assert mom._json_dict_() == {
'cirq_type': 'Moment',
'operations': (cirq.CZ(a, b),)
}
def test_with_operation():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
assert Moment().with_operation(cirq.X(a)) == Moment([cirq.X(a)])
assert (Moment([cirq.X(a)]).with_operation(cirq.X(b)) == Moment(
[cirq.X(a), cirq.X(b)]))
with pytest.raises(ValueError):
_ = Moment([cirq.X(a)]).with_operation(cirq.X(a))
def as_circuit(self):
if self._circuit is not None:
return self._circuit
else:
self._circuit = self.to_circuit()[0]
self._circuit.insert(0,
Moment([
H(LineQubit(i)) for i in range(self.n)
])) # hack to show all qubits
self._circuit.insert(
0, Moment([H(LineQubit(i)) for i in range(self.n)]))
return self._circuit
def merge_func(m1: cirq.Moment, m2: cirq.Moment) -> Optional[cirq.Moment]:
def is_z_moment(m):
return all(op.gate == cirq.Z for op in m)
if not (is_z_moment(m1) and is_z_moment(m2)):
return None
qubits = m1.qubits | m2.qubits
def mul(op1, op2):
return (op1 or op2) if not (op1 and op2) else cirq.decompose_once(
op1 * op2)
return cirq.Moment(
mul(m1.operation_at(q), m2.operation_at(q)) for q in qubits)
def _simplify_circuit_exponents(circuit: Circuit) -> None:
"""Simplifies the gate exponents of the input circuit if possible,
mutating the input circuit.
Args:
circuit: The circuit to simplify.
"""
# Iterate over moments
for moment_idx, moment in enumerate(circuit):
simplified_operations = []
# Iterate over operations in moment
for op in moment:
if not isinstance(op, GateOperation):
simplified_operations.append(op)
continue
if isinstance(op.gate, EigenGate):
simplified_gate: Gate = _simplify_gate_exponent(op.gate)
else:
simplified_gate = op.gate
simplified_operation = op.with_gate(simplified_gate)
simplified_operations.append(simplified_operation)
# Mutate the input circuit
circuit[moment_idx] = Moment(simplified_operations)
def noisy_moment(self, moment: cirq.Moment,
system_qubits: Sequence[cirq.Qid]) -> cirq.OP_TREE:
if self.is_virtual_moment(moment):
return moment
moments = []
if validate_all_measurements(moment):
if self.decay_probs:
moments.append(
cirq.Moment(
cirq.AmplitudeDampingChannel(self.decay_probs[q])(q)
for q in system_qubits))
if self.bitflip_probs:
moments.append(
cirq.Moment(
cirq.BitFlipChannel(self.bitflip_probs[q])(q)
for q in system_qubits))
moments.append(moment)
return moments
else:
moments.append(moment)
if self.depol_probs:
gated_qubits = [
q for q in system_qubits
if moment.operates_on_single_qubit(q)
]
if gated_qubits:
moments.append(
cirq.Moment(
cirq.DepolarizingChannel(self.depol_probs[q])(q)
for q in gated_qubits))
return moments
def test_validation():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
c = cirq.NamedQubit('c')
d = cirq.NamedQubit('d')
_ = Moment([])
_ = Moment([cirq.X(a)])
_ = Moment([cirq.CZ(a, b)])
_ = Moment([cirq.CZ(b, d)])
_ = Moment([cirq.CZ(a, b), cirq.CZ(c, d)])
_ = Moment([cirq.CZ(a, c), cirq.CZ(b, d)])
_ = Moment([cirq.CZ(a, c), cirq.X(b)])
with pytest.raises(ValueError):
_ = Moment([cirq.X(a), cirq.X(a)])
with pytest.raises(ValueError):
_ = Moment([cirq.CZ(a, c), cirq.X(c)])
with pytest.raises(ValueError):
_ = Moment([cirq.CZ(a, c), cirq.CZ(c, d)])
def test_container_methods():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
m = Moment([cirq.H(a), cirq.H(b)])
assert list(m) == list(m.operations)
# __iter__
assert list(iter(m)) == list(m.operations)
# __contains__ for free.
assert cirq.H(b) in m
assert len(m) == 2
def test_validation():
a = cirq.QubitId()
b = cirq.QubitId()
c = cirq.QubitId()
d = cirq.QubitId()
_ = Moment([])
_ = Moment([cirq.X(a)])
_ = Moment([cirq.CZ(a, b)])
_ = Moment([cirq.CZ(b, d)])
_ = Moment([cirq.CZ(a, b), cirq.CZ(c, d)])
_ = Moment([cirq.CZ(a, c), cirq.CZ(b, d)])
_ = Moment([cirq.CZ(a, c), cirq.X(b)])
with pytest.raises(ValueError):
_ = Moment([cirq.X(a), cirq.X(a)])
with pytest.raises(ValueError):
_ = Moment([cirq.CZ(a, c), cirq.X(c)])
with pytest.raises(ValueError):
_ = Moment([cirq.CZ(a, c), cirq.CZ(c, d)])
def test_indexes_by_list_of_qubits():
q = cirq.LineQubit.range(4)
moment = cirq.Moment([cirq.Z(q[0]), cirq.CNOT(q[1], q[2])])
assert moment[[q[0]]] == Moment([cirq.Z(q[0])])
assert moment[[q[1]]] == Moment([cirq.CNOT(q[1], q[2])])
assert moment[[q[2]]] == Moment([cirq.CNOT(q[1], q[2])])
assert moment[[q[3]]] == Moment([])
assert moment[q[0:2]] == moment
assert moment[q[1:3]] == Moment([cirq.CNOT(q[1], q[2])])
assert moment[q[2:4]] == Moment([cirq.CNOT(q[1], q[2])])
assert moment[[q[0], q[3]]] == Moment([cirq.Z(q[0])])
assert moment[q] == moment
def scale_parameters(
circ: Circuit,
scale_factor: float,
sigma: float,
seed: Optional[int] = None,
) -> Circuit:
"""Adds parameter noise to a circuit with level noise.
This adds noise to the actual parameter instead of
adding an parameter channel.
Args:
circ: The quantum program as a Cirq circuit object. All measurements
should be in the last moment of the circuit.
scale_factor: Amount to scale the base noise level of parameters by.
sigma: Base noise level (variance) in parameter rotations
seed: random seed
Returns:
The input circuit with scaled rotation angles
"""
final_moments = []
noise = (scale_factor - 1) * sigma
rng = np.random.RandomState(seed)
for moment in circ:
curr_moment = []
for op in moment.operations:
gate = copy.deepcopy(op.gate)
qubits = op.qubits
if isinstance(gate, MeasurementGate):
curr_moment.append(gate(*qubits))
else:
assert isinstance(gate, EigenGate)
base_gate = _get_base_gate(gate)
param = gate.exponent * np.pi
error = rng.normal(loc=0.0, scale=np.sqrt(noise))
new_param = param + error
curr_moment.append(
base_gate(exponent=new_param / np.pi)(*qubits)
)
final_moments.append(Moment(curr_moment))
return Circuit(final_moments)
def qubit_ops_to_circuit(ops: 'QubitOperator',
qpu: List[LineQubit]) -> 'Circuit':
"""Generate a circuit that can be run on a Cirq simulator from the ops
passed
Args:
ops (Qubit Operator) - a product of operations to compile into a
circuit
qpu (Qid) - the quantum processing unit that this circuit will be run
on
Returns:
(circuit) - returns a circuit to run in cirq
"""
gates = []
for operation in ops:
gate_type = operation[1]
qubit = qpu[operation[0]]
gates.append(qubit_op_to_gate(gate_type, qubit))
moment = [Moment(gates)]
return Circuit(moment)
def scale_parameters(
circuit: QPROGRAM,
scale_factor: float,
base_variance: float,
seed: Optional[int] = None,
) -> Circuit:
"""Applies parameter-noise scaling to the input circuit,
assuming that each gate has the same base level of noise.
Args:
circuit: The circuit to scale as a QPROGRAM. All measurements
should be in the last moment of the circuit.
scale_factor: The amount to scale the base noise level by.
base_variance: The base level (variance) of parameter noise,
assumed to be the same for each gate of the circuit.
seed: Optional seed for random number generator.
Returns:
The parameter noise scaled circuit.
"""
final_moments = []
noise = (scale_factor - 1) * base_variance
rng = np.random.RandomState(seed)
for moment in circuit:
curr_moment = []
for op in moment.operations: # type: ignore
gate = copy.deepcopy(op.gate)
qubits = op.qubits
if isinstance(gate, MeasurementGate):
curr_moment.append(gate(*qubits))
else:
assert isinstance(gate, EigenGate)
base_gate = _get_base_gate(gate)
param = gate.exponent * np.pi
error = rng.normal(loc=0.0, scale=np.sqrt(noise))
new_param = param + error
curr_moment.append(
base_gate(exponent=new_param / np.pi)(*qubits))
final_moments.append(Moment(curr_moment))
return Circuit(final_moments)
def can_add_operation_into_moment(self, operation: cirq.Operation,
moment: cirq.Moment) -> bool:
"""Determines if it's possible to add an operation into a moment.
An operation can be added if the moment with the operation added is
valid.
Args:
operation: The operation being added.
moment: The moment being transformed.
Returns:
Whether or not the moment will validate after adding the operation.
Raises:
ValueError: If either of the given moment or operation is invalid
"""
if not super().can_add_operation_into_moment(operation, moment):
return False
try:
self.validate_moment(moment.with_operation(operation))
except ValueError:
return False
return True
def test_operates_on():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
c = cirq.NamedQubit('c')
# Empty case.
assert not Moment().operates_on([])
assert not Moment().operates_on([a])
assert not Moment().operates_on([b])
assert not Moment().operates_on([a, b])
# One-qubit operation case.
assert not Moment([cirq.X(a)]).operates_on([])
assert Moment([cirq.X(a)]).operates_on([a])
assert not Moment([cirq.X(a)]).operates_on([b])
assert Moment([cirq.X(a)]).operates_on([a, b])
# Two-qubit operation case.
assert not Moment([cirq.CZ(a, b)]).operates_on([])
assert Moment([cirq.CZ(a, b)]).operates_on([a])
assert Moment([cirq.CZ(a, b)]).operates_on([b])
assert Moment([cirq.CZ(a, b)]).operates_on([a, b])
assert not Moment([cirq.CZ(a, b)]).operates_on([c])
assert Moment([cirq.CZ(a, b)]).operates_on([a, c])
assert Moment([cirq.CZ(a, b)]).operates_on([a, b, c])
# Multiple operations case.
assert not Moment([cirq.X(a), cirq.X(b)]).operates_on([])
assert Moment([cirq.X(a), cirq.X(b)]).operates_on([a])
assert Moment([cirq.X(a), cirq.X(b)]).operates_on([b])
assert Moment([cirq.X(a), cirq.X(b)]).operates_on([a, b])
assert not Moment([cirq.X(a), cirq.X(b)]).operates_on([c])
assert Moment([cirq.X(a), cirq.X(b)]).operates_on([a, c])
assert Moment([cirq.X(a), cirq.X(b)]).operates_on([a, b, c])
def test_approx_eq():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
assert not cirq.approx_eq(Moment([cirq.X(a)]), cirq.X(a))
# Default is empty. Iterables get frozen into tuples.
assert cirq.approx_eq(Moment(), Moment([]))
assert cirq.approx_eq(Moment([]), Moment(()))
assert cirq.approx_eq(Moment([cirq.X(a)]), Moment([cirq.X(a)]))
assert not cirq.approx_eq(Moment([cirq.X(a)]), Moment([cirq.X(b)]))
assert cirq.approx_eq(Moment([cirq.XPowGate(exponent=0)(a)]),
Moment([cirq.XPowGate(exponent=1e-9)(a)]))
assert not cirq.approx_eq(Moment([cirq.XPowGate(exponent=0)(a)]),
Moment([cirq.XPowGate(exponent=1e-7)(a)]))
assert cirq.approx_eq(Moment([cirq.XPowGate(exponent=0)(a)]),
Moment([cirq.XPowGate(exponent=1e-7)(a)]),
atol=1e-6)
def test_equality():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
c = cirq.NamedQubit('c')
d = cirq.NamedQubit('d')
eq = cirq.testing.EqualsTester()
# Default is empty. Iterables get frozen into tuples.
eq.add_equality_group(Moment(), Moment([]), Moment(()))
eq.add_equality_group(Moment([cirq.X(d)]), Moment((cirq.X(d), )))
# Equality depends on gate and qubits.
eq.add_equality_group(Moment([cirq.X(a)]))
eq.add_equality_group(Moment([cirq.X(b)]))
eq.add_equality_group(Moment([cirq.Y(a)]))
# Equality depends on order.
eq.add_equality_group(Moment([cirq.X(a), cirq.X(b)]))
eq.add_equality_group(Moment([cirq.X(b), cirq.X(a)]))
# Two qubit gates.
eq.make_equality_group(lambda: Moment([cirq.CZ(c, d)]))
eq.make_equality_group(lambda: Moment([cirq.CZ(a, c)]))
eq.make_equality_group(lambda: Moment([cirq.CZ(a, b), cirq.CZ(c, d)]))
eq.make_equality_group(lambda: Moment([cirq.CZ(a, c), cirq.CZ(b, d)]))
def test_bool():
assert not Moment()
a = cirq.NamedQubit('a')
assert Moment([cirq.X(a)])
def test_repr():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
original = Moment([cirq.CZ(a, b)])
cirq.testing.assert_equivalent_repr(original)
def test_without_operations_touching():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
c = cirq.NamedQubit('c')
# Empty case.
assert Moment().without_operations_touching([]) == Moment()
assert Moment().without_operations_touching([a]) == Moment()
assert Moment().without_operations_touching([a, b]) == Moment()
# One-qubit operation case.
assert (Moment([cirq.X(a)
]).without_operations_touching([]) == Moment([cirq.X(a)]))
assert (Moment([cirq.X(a)]).without_operations_touching([a]) == Moment())
assert (Moment([cirq.X(a)
]).without_operations_touching([b]) == Moment([cirq.X(a)]))
# Two-qubit operation case.
assert (Moment([cirq.CZ(a, b)]).without_operations_touching([]) == Moment(
[cirq.CZ(a, b)]))
assert (Moment([cirq.CZ(a,
b)]).without_operations_touching([a]) == Moment())
assert (Moment([cirq.CZ(a,
b)]).without_operations_touching([b]) == Moment())
assert (Moment([cirq.CZ(a, b)]).without_operations_touching([c]) == Moment(
[cirq.CZ(a, b)]))
# Multiple operation case.
assert (Moment([cirq.CZ(a, b), cirq.X(c)]).without_operations_touching(
[]) == Moment([cirq.CZ(a, b), cirq.X(c)]))
assert (Moment([cirq.CZ(a, b), cirq.X(c)
]).without_operations_touching([a]) == Moment([cirq.X(c)]))
assert (Moment([cirq.CZ(a, b), cirq.X(c)
]).without_operations_touching([b]) == Moment([cirq.X(c)]))
assert (Moment([cirq.CZ(a, b), cirq.X(c)]).without_operations_touching(
[c]) == Moment([cirq.CZ(a, b)]))
assert (Moment([cirq.CZ(a, b), cirq.X(c)
]).without_operations_touching([a,
b]) == Moment([cirq.X(c)]))
assert (Moment([cirq.CZ(a, b),
cirq.X(c)]).without_operations_touching([a,
c]) == Moment())
