def test_gate_equality():
eq = cirq.testing.EqualsTester()
eq.add_equality_group(cirq.CSwapGate(), cirq.CSwapGate())
eq.add_equality_group(cirq.CZPowGate(), cirq.CZPowGate())
eq.add_equality_group(cirq.CCXPowGate(), cirq.CCXPowGate(),
cirq.CCNotPowGate())
eq.add_equality_group(cirq.CCZPowGate(), cirq.CCZPowGate())
def test_rot_gates_eq():
eq = cirq.testing.EqualsTester()
gates = [
lambda p: cirq.CZ**p,
lambda p: cirq.X**p,
lambda p: cirq.Y**p,
lambda p: cirq.Z**p,
lambda p: cirq.CNOT**p,
]
for gate in gates:
eq.add_equality_group(gate(3.5),
gate(-0.5))
eq.make_equality_group(lambda: gate(0))
eq.make_equality_group(lambda: gate(0.5))
eq.add_equality_group(cirq.XPowGate(), cirq.XPowGate(exponent=1), cirq.X)
eq.add_equality_group(cirq.YPowGate(), cirq.YPowGate(exponent=1), cirq.Y)
eq.add_equality_group(cirq.ZPowGate(), cirq.ZPowGate(exponent=1), cirq.Z)
eq.add_equality_group(cirq.ZPowGate(exponent=1,
global_shift=-0.5),
cirq.ZPowGate(exponent=5,
global_shift=-0.5))
eq.add_equality_group(cirq.ZPowGate(exponent=3,
global_shift=-0.5))
eq.add_equality_group(cirq.ZPowGate(exponent=1,
global_shift=-0.1))
eq.add_equality_group(cirq.ZPowGate(exponent=5,
global_shift=-0.1))
eq.add_equality_group(cirq.CNotPowGate(),
cirq.CNotPowGate(exponent=1),
cirq.CNOT)
eq.add_equality_group(cirq.CZPowGate(),
cirq.CZPowGate(exponent=1), cirq.CZ)
def test_not_decompose_czs():
circuit = cirq.Circuit(
cirq.CZPowGate(exponent=1, global_shift=-0.5).on(*cirq.LineQubit.range(2))
)
circ_orig = circuit.copy()
cirq.MergeInteractions(allow_partial_czs=False).optimize_circuit(circuit)
assert circ_orig == circuit
def test_dont_allow_partial_czs():
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
cirq.CZ(q0, q1),
cirq.CZPowGate(exponent=1, global_shift=-0.5).on(q0, q1),
)
c_orig = cirq.Circuit(circuit)
with cirq.testing.assert_deprecated("Use cirq.optimize_for_target_gateset",
deadline='v1.0'):
cirq.ConvertToCzAndSingleGates().optimize_circuit(circuit)
assert circuit == c_orig
circuit = cirq.Circuit(cirq.CZ(q0, q1)**0.5, )
c_orig = cirq.Circuit(circuit)
with cirq.testing.assert_deprecated("Use cirq.optimize_for_target_gateset",
deadline='v1.0'):
cirq.ConvertToCzAndSingleGates(
ignore_failures=True).optimize_circuit(circuit)
assert sum(1 for op in circuit.all_operations() if len(op.qubits) > 1) == 2
assert sum(1 for op in circuit.all_operations()
if isinstance(op.gate, cirq.CZPowGate)) == 2
assert all(op.gate.exponent % 2 == 1 for op in circuit.all_operations()
if isinstance(op.gate, cirq.CZPowGate))
cirq.testing.assert_allclose_up_to_global_phase(circuit.unitary(),
c_orig.unitary(),
atol=1e-7)
def rot_11_layer(jc, jr, half_turns):
rot1 = cirq.CZPowGate(exponent=half_turns)
for i, r in enumerate(jr):
for j, jr_ij in enumerate(r):
if jr_ij < 0:
yield (cirq.X(cirq.GridQubit(i, j)))
yield (cirq.X(cirq.GridQubit(i + 1, j)))
yield (rot1(cirq.GridQubit(i, j), cirq.GridQubit(i + 1, j)))
yield (cirq.CZ(cirq.GridQubit(i, j), cirq.GridQubit(i + 1,
j))) #change 1
yield (cirq.CZ(cirq.GridQubit(i, j), cirq.GridQubit(i + 1,
j))) #chang 2
if jr_ij < 0:
yield (cirq.X(cirq.GridQubit(i, j)))
yield (cirq.X(cirq.GridQubit(i + 1, j)))
for i, c in enumerate(jc):
for j, jc_ij in enumerate(c):
if jc_ij < 0:
yield (cirq.X(cirq.GridQubit(i, j)))
yield (cirq.X(cirq.GridQubit(i, j + 1)))
yield (rot1(cirq.GridQubit(i, j), cirq.GridQubit(i, j + 1)))
yield (cirq.CZ(cirq.GridQubit(i, j),
cirq.GridQubit(i, j + 1))) #change 3
yield (cirq.CZ(cirq.GridQubit(i, j),
cirq.GridQubit(i, j + 1))) #chang 4
if jc_ij < 0:
yield (cirq.X(cirq.GridQubit(i, j)))
yield (cirq.X(cirq.GridQubit(i, j + 1)))
def test_serialize_deserialize_cz_gate(gate, exponent):
gate_set = cg.SerializableGateSet('test', [cgc.CZ_SERIALIZER],
[cgc.CZ_POW_DESERIALIZER])
proto = op_proto({
'gate': {
'id': 'cz'
},
'args': {
'half_turns': {
'arg_value': {
'float_value': exponent
}
}
},
'qubits': [{
'id': '5_4'
}, {
'id': '5_5'
}]
})
q1 = cirq.GridQubit(5, 4)
q2 = cirq.GridQubit(5, 5)
op = cirq.CZPowGate(exponent=exponent)
assert gate_set.serialize_op(gate(q1, q2)) == proto
cirq.testing.assert_allclose_up_to_global_phase(
cirq.unitary(gate_set.deserialize_op(proto)),
cirq.unitary(op),
atol=1e-7,
)
def export_to_cirq(obj):
"""Imports a gate, operation or circuit from Cirq.
Args:
obj: the object to be exported to Cirq.
Returns:
the exported Cirq object (an instance of cirq.Circuit, cirq.GateOperation,
or a subclass of cirq.Gate).
Raises:
TypeError: if export is not supported for the given type.
ValueError: if the object cannot be exported successfully.
"""
if isinstance(obj, circuit.PhasedXGate):
return cirq.PhasedXPowGate(exponent=obj.get_rotation_angle() / np.pi,
phase_exponent=obj.get_phase_angle() /
np.pi)
elif isinstance(obj, circuit.RotZGate):
return cirq.ZPowGate(exponent=obj.get_rotation_angle() / np.pi)
elif isinstance(obj, circuit.ControlledZGate):
return cirq.CZPowGate(exponent=1.0)
elif isinstance(obj, circuit.MatrixGate):
return cirq.MatrixGate(obj.get_operator())
elif isinstance(obj, circuit.Operation):
return cirq.GateOperation(
export_to_cirq(obj.get_gate()),
[cirq.LineQubit(qubit) for qubit in obj.get_qubits()])
elif isinstance(obj, circuit.Circuit):
return cirq.Circuit(export_to_cirq(operation) for operation in obj)
else:
raise TypeError('unknown type: %s' % type(obj).__name__)
def test_deserialize_exp_11(half_turns):
with cirq.testing.assert_deprecated('SerializableGateSet',
deadline='v0.16',
count=1):
serialized_op = op_proto({
'gate': {
'id': 'cz'
},
'args': {
'half_turns': {
'arg_value': {
'float_value': half_turns
}
}
},
'qubits': [{
'id': '1_2'
}, {
'id': '2_2'
}],
})
c = cirq.GridQubit(1, 2)
t = cirq.GridQubit(2, 2)
expected = cirq.CZPowGate(exponent=half_turns)(c, t)
assert cg.XMON.deserialize_op(serialized_op) == expected
def test_fsim_iswap_cphase(theta, phi):
q0, q1 = cirq.NamedQubit('q0'), cirq.NamedQubit('q1')
iswap = cirq.ISWAP**(-theta * 2 / np.pi)
cphase = cirq.CZPowGate(exponent=-phi / np.pi)
iswap_cphase = cirq.Circuit((iswap.on(q0, q1), cphase.on(q0, q1)))
fsim = cirq.FSimGate(theta=theta, phi=phi)
assert np.allclose(cirq.unitary(iswap_cphase), cirq.unitary(fsim))
def test_import_partial_cz_error(self):
partial_cz = cirq.CZPowGate(exponent=0.37)
with self.assertRaisesRegex(
ValueError,
r'partial ControlledZ gates are not supported'):
cirq_converter.import_from_cirq(partial_cz)
def test_serialize_deserialize_cz_gate(gate, exponent, phys_z):
gate_set = cg.SerializableGateSet('test', [cgc.CZ_SERIALIZER],
[cgc.CZ_POW_DESERIALIZER])
proto = op_proto({
'gate': {
'id': 'cz'
},
'args': {
'half_turns': {
'arg_value': {
'float_value': exponent
}
},
**_phys_z_args(phys_z),
},
'qubits': [{
'id': '5_4'
}, {
'id': '5_5'
}],
})
q1 = cirq.GridQubit(5, 4)
q2 = cirq.GridQubit(5, 5)
op = gate(q1, q2)
if phys_z:
op = op.with_tags(cg.PhysicalZTag())
assert gate_set.serialize_op(op) == proto
deserialized_op = gate_set.deserialize_op(proto)
expected_gate = cirq.CZPowGate(exponent=exponent)
cirq.testing.assert_allclose_up_to_global_phase(
cirq.unitary(deserialized_op),
cirq.unitary(expected_gate),
atol=1e-7,
)
assert_phys_z_tag(phys_z, deserialized_op)
def test_equivalent_unitaries():
"""This test covers the factor of pi change. However, it will be skipped
if pyquil is unavailable for import.
References:
https://docs.pytest.org/en/latest/skipping.html#skipping-on-a-missing-import-dependency
"""
pyquil = pytest.importorskip("pyquil")
pyquil_simulation_tools = pytest.importorskip("pyquil.simulation.tools")
q0, q1 = _make_qubits(2)
operations = [
cirq.XPowGate(exponent=0.5, global_shift=-0.5)(q0),
cirq.YPowGate(exponent=0.5, global_shift=-0.5)(q0),
cirq.ZPowGate(exponent=0.5, global_shift=-0.5)(q0),
cirq.CZPowGate(exponent=0.5)(q0, q1),
cirq.ISwapPowGate(exponent=0.5)(q0, q1),
]
output = cirq.QuilOutput(operations, (q0, q1))
program = pyquil.Program(str(output))
pyquil_unitary = pyquil_simulation_tools.program_unitary(program,
n_qubits=2)
# Qubit ordering differs between pyQuil and Cirq.
cirq_unitary = cirq.Circuit(cirq.SWAP(q0, q1), operations,
cirq.SWAP(q0, q1)).unitary()
assert np.allclose(pyquil_unitary, cirq_unitary)
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 test_valid_cphase_exponents(theta, phi):
fsim_gate = cirq.FSimGate(theta=theta, phi=phi)
valid_exponent_intervals = cirq.compute_cphase_exponents_for_fsim_decomposition(fsim_gate)
assert valid_exponent_intervals
for min_exponent, max_exponent in valid_exponent_intervals:
margin = 1e-8
min_exponent += margin
max_exponent -= margin
assert min_exponent < max_exponent
for exponent in np.linspace(min_exponent, max_exponent, 3):
for d in (-2, 0, 4):
cphase_gate = cirq.CZPowGate(exponent=exponent + d)
assert_decomposition_valid(cphase_gate, fsim_gate=fsim_gate)
cphase_gate = cirq.CZPowGate(exponent=-exponent + d)
assert_decomposition_valid(cphase_gate, fsim_gate=fsim_gate)
def test_allow_partial_czs():
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
cirq.CZ(q0, q1)**0.5,
cirq.CZPowGate(exponent=0.5, global_shift=-0.5).on(q0, q1),
)
c_orig = cirq.Circuit(circuit)
cirq.ConvertToCzAndSingleGates(
allow_partial_czs=True).optimize_circuit(circuit)
assert circuit == c_orig
# yapf: disable
circuit2 = cirq.Circuit(
cirq.MatrixGate((np.array([[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[0, 0, 0, 1j]]))).on(q0, q1))
# yapf: enable
cirq.ConvertToCzAndSingleGates(
allow_partial_czs=True).optimize_circuit(circuit2)
two_qubit_ops = list(
circuit2.findall_operations(lambda e: len(e.qubits) == 2))
assert len(two_qubit_ops) == 1
gate = two_qubit_ops[0][1].gate
assert isinstance(gate, cirq.ops.CZPowGate) and gate.exponent == 0.5
def controlled(self,
num_controls: int = None,
control_values: Optional[Sequence[
Union[int, Collection[int]]]] = None,
control_qid_shape: Optional[Tuple[int, ...]] = None
) -> raw_types.Gate:
"""
Constructs CZPowGate from controlled ZPowGate when applicable.
This method is a specialized controlled method for ZPowGate. It
overrides the default behavior of returning a ControlledGate by
transforming the underlying controlled gate to a CZPowGate and
removing the last specified control qubit (which acts first
semantically). If this is a gate with multiple control qubits, it will
now be a ControlledGate with one less control.
This behavior only occurs when the last control qubit is a default-type
control qubit. A default-type control qubit is one with shape of 2 (not
a generic qudit) and where the control is satisfied by the qubit being
ON, as opposed to OFF.
(Note that a CZPowGate is, by definition, a controlled-ZPowGate.)
"""
result = super().controlled(num_controls, control_values,
control_qid_shape)
if (isinstance(result, controlled_gate.ControlledGate) and
result.control_values[-1] == (1,) and
result.control_qid_shape[-1] == 2):
return cirq.CZPowGate(exponent=self._exponent,
global_shift=self._global_shift).controlled(
result.num_controls() - 1,
result.control_values[:-1],
result.control_qid_shape[:-1])
return result
def rot_11_layer(jr, jc, half_turns):
"""Yields rotations about |11> conditioned on the jr and jc fields."""
cz_gate = cirq.CZPowGate(exponent=half_turns)
for i, jr_row in enumerate(jr):
for j, jr_ij in enumerate(jr_row):
q = cirq.GridQubit(i, j)
q_1 = cirq.GridQubit(i + 1, j)
if jr_ij == -1:
yield cirq.X(q)
yield cirq.X(q_1)
yield cz_gate(q, q_1)
if jr_ij == -1:
yield cirq.X(q)
yield cirq.X(q_1)
for i, jc_row in enumerate(jc):
for j, jc_ij in enumerate(jc_row):
q = cirq.GridQubit(i, j)
q_1 = cirq.GridQubit(i, j + 1)
if jc_ij == -1:
yield cirq.X(q)
yield cirq.X(q_1)
yield cz_gate(q, q_1)
if jc_ij == -1:
yield cirq.X(q)
yield cirq.X(q_1)
def _convert_to_cz(self,
g: POSSIBLE_FSIM_GATES) -> Optional[cirq.CZPowGate]:
if isinstance(g, cirq.CZPowGate):
return g
cg = self._convert_to_fsim(g)
return (None if
(cg is None or not self._approx_eq_or_symbol(cg.theta, 0)) else
cirq.CZPowGate(exponent=-cg.phi / np.pi))
def _decompose_(self, qubits):
r = 2 * abs(self.weights[0]) / np.pi
theta = _arg(self.weights[0]) / np.pi
yield cirq.Z(qubits[0])**-theta
yield cirq.ISwapPowGate(exponent=-r * self.exponent)(*qubits)
yield cirq.Z(qubits[0])**theta
yield cirq.CZPowGate(exponent=-self.weights[1] * self.exponent /
np.pi)(*qubits)
def fsim_gate(a, b, theta, phi):
"""FSimGate has a default decomposition in cirq to XXPowGate and YYPowGate,
which is an awkward decomposition for this gate set.
Decompose into ISWAP and CZ instead."""
if theta != 0.0:
yield cirq.ISWAP(a, b)**(-2 * theta / np.pi)
if phi != 0.0:
yield cirq.CZPowGate(exponent=-phi / np.pi)(a, b)
def _decompose_(self, qubits):
a, b, c, d = qubits
weights_to_exponents = (self._exponent / 4.) * np.array([
[1, -1, 1],
[1, 1, -1],
[-1, 1, 1]
])
exponents = weights_to_exponents.dot(self.weights)
basis_change = list(cirq.flatten_op_tree([
cirq.CNOT(b, a),
cirq.CNOT(c, b),
cirq.CNOT(d, c),
cirq.CNOT(c, b),
cirq.CNOT(b, a),
cirq.CNOT(a, b),
cirq.CNOT(b, c),
cirq.CNOT(a, b),
[cirq.X(c), cirq.X(d)],
[cirq.CNOT(c, d), cirq.CNOT(d, c)],
[cirq.X(c), cirq.X(d)],
]))
controlled_Zs = list(cirq.flatten_op_tree([
cirq.CZPowGate(exponent=exponents[0])(b, c),
cirq.CNOT(a, b),
cirq.CZPowGate(exponent=exponents[1])(b, c),
cirq.CNOT(b, a),
cirq.CNOT(a, b),
cirq.CZPowGate(exponent=exponents[2])(b, c)
]))
controlled_swaps = [
[cirq.CNOT(c, d), cirq.H(c)],
cirq.CNOT(d, c),
controlled_Zs,
cirq.CNOT(d, c),
[cirq.inverse(op) for op in reversed(controlled_Zs)],
[cirq.H(c), cirq.CNOT(c, d)],
]
yield basis_change
yield controlled_swaps
yield basis_change[::-1]
def test_gate_matrices_ising(self, t):
"""Verify that the Ising gates work as expected."""
CZ = cirq.CZPowGate(exponent=t)._unitary_()
s = 1 - t / 2
L = cirq.rz(-np.pi * s)._unitary_()
assert np.allclose(
np.exp(-1j * np.pi / 2 * s) *
np.kron(L, L) @ ig.IsingGate(exponent=s)._unitary_(), CZ)
def controlled(
self,
num_controls: int = None,
control_values: Optional[Sequence[Union[int, Collection[int]]]] = None,
control_qid_shape: Optional[Tuple[int, ...]] = None,
) -> 'cirq.Gate':
ret = super().controlled(num_controls, control_values, control_qid_shape)
if num_controls == 1 and control_values is None:
return cirq.CZPowGate(exponent=self._exponent, global_shift=self._global_shift)
return ret
def one_and_two_body_interaction(p, q, a, b) -> cirq.OP_TREE:
t_symbol = LetterWithSubscripts('T', p, q, i)
w_symbol = LetterWithSubscripts('W', p, q, i)
v_symbol = LetterWithSubscripts('V', p, q, i)
if t_symbol in param_set:
yield cirq.ISwapPowGate(exponent=-t_symbol).on(a, b)
if w_symbol in param_set:
yield cirq.PhasedISwapPowGate(exponent=w_symbol).on(a, b)
if v_symbol in param_set:
yield cirq.CZPowGate(exponent=v_symbol).on(a, b)
def test_cphase():
"""Test if the sqrt_iswap synthesis for a cphase rotation is correct"""
thetas = np.linspace(0, 2 * np.pi, 100)
qubits = [cirq.NamedQubit('a'), cirq.NamedQubit('b')]
for theta in thetas:
expected = cirq.CZPowGate(exponent=theta)
decomposition = cgoc.cphase_to_sqrt_iswap(qubits[0], qubits[1], theta)
actual = cirq.Circuit(decomposition)
expected_unitary = cirq.unitary(expected)
actual_unitary = cirq.unitary(actual)
np.testing.assert_allclose(expected_unitary, actual_unitary, atol=1e-7)
def test_z_control():
# Single qubit control on Z gives a CZ
assert cirq.Z.controlled() == cirq.CZ
assert cirq.Z.controlled(num_controls=1) == cirq.CZ
assert cirq.Z.controlled(control_values=((1, ), )) == cirq.CZ
assert cirq.Z.controlled(control_qid_shape=(2, )) == cirq.CZ
# Also works for any ZPow.
assert cirq.ZPowGate(exponent=5).controlled() == cirq.CZPowGate(exponent=5)
# For multi-qudit controls, if the last control is a qubit with control
# value 1, construct a CZ leaving the rest of the controls as is.
assert cirq.Z.controlled().controlled() == cirq.ControlledGate(
cirq.CZ, num_controls=1)
assert cirq.Z.controlled(num_controls=2) == cirq.ControlledGate(
cirq.CZ, num_controls=1)
assert cirq.Z.controlled(control_values=((0, ), (0, ),
(1, ))) == cirq.ControlledGate(
cirq.CZ,
num_controls=2,
control_values=((0, ), (0, )))
assert cirq.Z.controlled(control_qid_shape=(3, 3,
2)) == cirq.ControlledGate(
cirq.CZ,
num_controls=2,
control_qid_shape=(3, 3))
assert cirq.Z.controlled(control_qid_shape=(2, )).controlled(
control_qid_shape=(3, )).controlled(
control_qid_shape=(4, )) == cirq.ControlledGate(
cirq.CZ, num_controls=2, control_qid_shape=(3, 4))
# When a control_value 1 qubit is not acting first, results in a regular
# ControlledGate on Z instance.
assert cirq.Z.controlled(num_controls=1,
control_qid_shape=(3, )) == cirq.ControlledGate(
cirq.Z,
num_controls=1,
control_qid_shape=(3, ))
assert cirq.Z.controlled(control_values=((0, ), (1, ),
(0, ))) == cirq.ControlledGate(
cirq.Z,
num_controls=3,
control_values=((0, ), (1, ),
(0, )))
assert cirq.Z.controlled(control_qid_shape=(3, 2,
3)) == cirq.ControlledGate(
cirq.Z,
num_controls=3,
control_qid_shape=(3, 2,
3))
assert cirq.Z.controlled(control_qid_shape=(3, )).controlled(
control_qid_shape=(2, )).controlled(
control_qid_shape=(4, )) == cirq.ControlledGate(
cirq.Z, num_controls=3, control_qid_shape=(3, 2, 4))
def sycamore_circuit(num_qubits, depth, reg):
gateSequence = [0, 3, 2, 1, 2, 1, 0, 3]
single_bit_gates = sqrtx, sqrty, sqrtw
circ = cirq.Circuit()
colLen = math.floor(math.sqrt(num_qubits))
while (((num_qubits / colLen) * colLen) != num_qubits):
colLen = colLen - 1
rowLen = num_qubits // colLen
lastSingleBitGates = []
for i in range(depth):
# Single bit gates
singleBitGates = []
for j in range(num_qubits):
gate = random.choice(single_bit_gates)
if len(lastSingleBitGates) > 0:
while gate == lastSingleBitGates[j]:
gate = random.choice(single_bit_gates)
circ.append(gate(reg[j]))
singleBitGates.append(gate)
lastSingleBitGates = singleBitGates
gate = gateSequence[0]
gateSequence.pop(0)
gateSequence.append(gate)
for row in range(1, rowLen, 2):
for col in range(0, colLen):
tempRow = row
tempCol = col
tempRow = tempRow + (1 if (gate & 2) else -1)
if colLen != 1:
tempCol = tempCol + (1 if (gate & 1) else 0)
if (tempRow < 0) or (tempCol < 0) or (tempRow >= rowLen) or (
tempCol >= colLen):
continue
b1 = row * colLen + col
b2 = tempRow * colLen + tempCol
# Two bit gates
circ.append(
cirq.CZPowGate(exponent=1 / 6).on(reg[b1], reg[b2]))
circ.append(cirq.ISWAP(reg[b1], reg[b2]))
for j in range(num_qubits):
circ.append(cirq.measure(reg[j]))
return circ
def test_not_decompose_czs():
circuit = cirq.Circuit(
cirq.CZPowGate(exponent=1,
global_shift=-0.5).on(*cirq.LineQubit.range(2)))
circ_orig = circuit.copy()
with cirq.testing.assert_deprecated("Use cirq.optimize_for_target_gateset",
deadline='v1.0',
count=2):
cirq.MergeInteractions(
allow_partial_czs=False).optimize_circuit(circuit)
assert circ_orig == circuit
def one_and_two_body_interaction_reversed_order(p, q, a,
b) -> cirq.OP_TREE:
t_symbol = LetterWithSubscripts('T', p, q, i)
w_symbol = LetterWithSubscripts('W', p, q, i)
v_symbol = LetterWithSubscripts('V', p, q, i)
if v_symbol in param_set:
yield cirq.CZPowGate(exponent=v_symbol).on(a, b)
if w_symbol in param_set:
yield YXXYPowGate(exponent=w_symbol).on(a, b)
if t_symbol in param_set:
yield XXYYPowGate(exponent=t_symbol).on(a, b)
def one_and_two_body_interaction(p, q, a, b) -> cirq.OP_TREE:
th_symbol = LetterWithSubscripts('Th', i)
tv_symbol = LetterWithSubscripts('Tv', i)
v_symbol = LetterWithSubscripts('V', i)
if _is_horizontal_edge(p, q, self.x_dim, self.y_dim,
self.periodic):
yield cirq.ISwapPowGate(exponent=-th_symbol).on(a, b)
if _is_vertical_edge(p, q, self.x_dim, self.y_dim,
self.periodic):
yield cirq.ISwapPowGate(exponent=-tv_symbol).on(a, b)
if _are_same_site_opposite_spin(p, q, self.x_dim * self.y_dim):
yield cirq.CZPowGate(exponent=v_symbol).on(a, b)
