def test_axis_angle():
assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.Ry(1e-10))),
cirq.AxisAngleDecomposition(angle=0,
axis=(1, 0, 0),
global_phase=1),
atol=1e-8)
assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.Rx(np.pi))),
cirq.AxisAngleDecomposition(angle=np.pi,
axis=(1, 0, 0),
global_phase=1),
atol=1e-8)
assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.X)),
cirq.AxisAngleDecomposition(angle=np.pi,
axis=(1, 0, 0),
global_phase=1j),
atol=1e-8)
assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.X**0.5)),
cirq.AxisAngleDecomposition(angle=np.pi / 2,
axis=(1, 0, 0),
global_phase=np.exp(
1j * np.pi / 4)),
atol=1e-8)
assert cirq.approx_eq(
cirq.axis_angle(cirq.unitary(cirq.X**-0.5)),
cirq.AxisAngleDecomposition(angle=-np.pi / 2,
axis=(1, 0, 0),
global_phase=np.exp(-1j * np.pi / 4)))
assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.Y)),
cirq.AxisAngleDecomposition(angle=np.pi,
axis=(0, 1, 0),
global_phase=1j),
atol=1e-8)
assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.Z)),
cirq.AxisAngleDecomposition(angle=np.pi,
axis=(0, 0, 1),
global_phase=1j),
atol=1e-8)
assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.H)),
cirq.AxisAngleDecomposition(angle=np.pi,
axis=(np.sqrt(0.5), 0,
np.sqrt(0.5)),
global_phase=1j),
atol=1e-8)
assert cirq.approx_eq(cirq.axis_angle(cirq.unitary(cirq.H**0.5)),
cirq.AxisAngleDecomposition(
angle=np.pi / 2,
axis=(np.sqrt(0.5), 0, np.sqrt(0.5)),
global_phase=np.exp(1j * np.pi / 4)),
atol=1e-8)
def UCRy(ctrls, target, alphas, S_T_inv, seq):
thetas = np.matmul(S_T_inv, alphas)
gates = []
for i in range(len(seq)):
theta_i = thetas[i]
q_i = ctrls[int(seq[i])]
gates += [cirq.Ry(rads=theta_i)(target)]
gates += [cirq.CNOT(q_i, target)]
return gates
def test_ry_unitary():
s = np.sqrt(0.5)
np.testing.assert_allclose(
cirq.unitary(cirq.Ry(np.pi / 2)),
np.array([[s, -s], [s, s]]))
np.testing.assert_allclose(
cirq.unitary(cirq.Ry(-np.pi / 2)),
np.array([[s, s], [-s, s]]))
np.testing.assert_allclose(
cirq.unitary(cirq.Ry(0)),
np.array([[1, 0], [0, 1]]))
np.testing.assert_allclose(
cirq.unitary(cirq.Ry(2 * np.pi)),
np.array([[-1, 0], [0, -1]]))
np.testing.assert_allclose(
cirq.unitary(cirq.Ry(np.pi)),
np.array([[0, -1], [1, 0]]))
np.testing.assert_allclose(
cirq.unitary(cirq.Ry(-np.pi)),
np.array([[0, 1], [-1, 0]]))
def test_formulaic_gates():
a, b = cirq.LineQubit.range(2)
t = sympy.Symbol('t')
assert_url_to_circuit_returns(
'{"cols":[["X^ft",{"id":"X^ft","arg":"t*t"}]]}',
cirq.Circuit(
cirq.X(a)**sympy.sin(sympy.pi * t),
cirq.X(b)**(t * t),
))
assert_url_to_circuit_returns(
'{"cols":[["Y^ft",{"id":"Y^ft","arg":"t*t"}]]}',
cirq.Circuit(
cirq.Y(a)**sympy.sin(sympy.pi * t),
cirq.Y(b)**(t * t),
))
assert_url_to_circuit_returns(
'{"cols":[["Z^ft",{"id":"Z^ft","arg":"t*t"}]]}',
cirq.Circuit(
cirq.Z(a)**sympy.sin(sympy.pi * t),
cirq.Z(b)**(t * t),
))
assert_url_to_circuit_returns(
'{"cols":[["Rxft",{"id":"Rxft","arg":"t*t"}]]}',
cirq.Circuit(
cirq.Rx(sympy.pi * t * t).on(a),
cirq.Rx(t * t).on(b),
))
assert_url_to_circuit_returns(
'{"cols":[["Ryft",{"id":"Ryft","arg":"t*t"}]]}',
cirq.Circuit(
cirq.Ry(sympy.pi * t * t).on(a),
cirq.Ry(t * t).on(b),
))
assert_url_to_circuit_returns(
'{"cols":[["Rzft",{"id":"Rzft","arg":"t*t"}]]}',
cirq.Circuit(
cirq.Rz(sympy.pi * t * t).on(a),
cirq.Rz(t * t).on(b),
))
def test_decomposition():
d = ion_device(3)
q0 = cirq.LineQubit(0)
q1 = cirq.LineQubit(1)
assert d.decompose_operation(cirq.H(q0)) == [
cirq.Rx(np.pi*1.0).on(cirq.LineQubit(0)),
cirq.Ry(np.pi*-0.5).on(cirq.LineQubit(0))]
circuit = cirq.Circuit()
circuit.append([cirq.X(q0), cirq.CNOT(q0, q1)])
ion_circuit = d.decompose_circuit(circuit)
d.validate_circuit(ion_circuit)
cirq.testing.assert_circuits_with_terminal_measurements_are_equivalent(
circuit, ion_circuit, atol=1e-6)
def test_consistency_with_qasm_output():
a, b, c, d = [cirq.NamedQubit('q_{}'.format(i)) for i in range(4)]
circuit1 = cirq.Circuit.from_ops(
cirq.Rx(np.pi / 2).on(a),
cirq.Ry(np.pi / 2).on(b),
cirq.Rz(np.pi / 2).on(b),
cirq.IdentityGate(1).on(c),
cirq.circuits.qasm_output.QasmUGate(1.0, 2.0, 3.0).on(d),
)
qasm1 = cirq.qasm(circuit1)
circuit2 = cirq.contrib.qasm_import.qasm.QasmCircuitParser().parse(qasm1)
ct.assert_same_circuits(circuit1, circuit2)
def test_resolve_scalar_placeholder():
"""Resolve scalar placeholders via feed_dict."""
wf = cirq.testing.random_superposition(4).astype(np.complex64)
params = [0.83, 1.2]
theta_x = tf.placeholder(tf.complex64, shape=(), name="theta_x")
theta_y = tf.placeholder(tf.complex64, shape=(), name="theta_y")
placeholder_circuit = cirq.Circuit.from_ops([
cirq.Rx(theta_x)(q(0)),
cirq.Ry(theta_y)(q(1)),
])
circuit_op = TFWaveFunctionSimulator(dtype=tf.complex64).simulate(
placeholder_circuit, initial_state=wf)
feed_dict = dict(zip([theta_x, theta_y], params))
with tf.Session() as sess:
tf_result = sess.run(circuit_op, feed_dict=feed_dict).reshape(-1)
circuit = cirq.Circuit.from_ops([
cirq.Rx(params[0])(q(0)),
cirq.Ry(params[1])(q(1)),
])
cirq_result = cirq.Simulator().simulate(
circuit, initial_state=np.copy(wf)).final_state
np.testing.assert_array_almost_equal(tf_result, cirq_result)
def test_init():
b, c, d, e, f = cirq.LineQubit.range(1, 6)
assert_url_to_circuit_returns(
'{"cols":[],"init":[0,1,"+","-","i","-i"]}',
cirq.Circuit(cirq.X(b),
cirq.Ry(np.pi / 2).on(c),
cirq.Ry(-np.pi / 2).on(d),
cirq.Rx(-np.pi / 2).on(e),
cirq.Rx(np.pi / 2).on(f)))
assert_url_to_circuit_returns('{"cols":[],"init":["+"]}',
output_amplitudes_from_quirk=[{
"r": 0.7071067690849304,
"i": 0
}, {
"r": 0.7071067690849304,
"i": 0
}])
assert_url_to_circuit_returns('{"cols":[],"init":["i"]}',
output_amplitudes_from_quirk=[{
"r": 0.7071067690849304,
"i": 0
}, {
"r":
0,
"i":
0.7071067690849304
}])
with pytest.raises(ValueError, match="init must be a list"):
_ = cirq.quirk_url_to_circuit(
'http://algassert.com/quirk#circuit={"cols":[],"init":0}')
with pytest.raises(ValueError, match="Unrecognized init state"):
_ = cirq.quirk_url_to_circuit(
'http://algassert.com/quirk#circuit={"cols":[],"init":[2]}')
def test_str():
assert str(cirq.X) == 'X'
assert str(cirq.X**0.5) == 'X**0.5'
assert str(cirq.Rx(np.pi)) == 'Rx(π)'
assert str(cirq.Rx(0.5 * np.pi)) == 'Rx(0.5π)'
assert str(cirq.XPowGate(
global_shift=-0.25)) == 'XPowGate(exponent=1.0, global_shift=-0.25)'
assert str(cirq.Z) == 'Z'
assert str(cirq.Z**0.5) == 'S'
assert str(cirq.Z**0.125) == 'Z**0.125'
assert str(cirq.Rz(np.pi)) == 'Rz(π)'
assert str(cirq.Rz(1.4 * np.pi)) == 'Rz(1.4π)'
assert str(cirq.ZPowGate(
global_shift=0.25)) == 'ZPowGate(exponent=1.0, global_shift=0.25)'
assert str(cirq.S) == 'S'
assert str(cirq.S**-1) == 'S**-1'
assert str(cirq.T) == 'T'
assert str(cirq.T**-1) == 'T**-1'
assert str(cirq.Y) == 'Y'
assert str(cirq.Y**0.5) == 'Y**0.5'
assert str(cirq.Ry(np.pi)) == 'Ry(π)'
assert str(cirq.Ry(3.14 * np.pi)) == 'Ry(3.14π)'
assert str(cirq.YPowGate(
exponent=2,
global_shift=-0.25)) == 'YPowGate(exponent=2, global_shift=-0.25)'
assert str(cirq.CX) == 'CNOT'
assert str(cirq.CNOT**0.5) == 'CNOT**0.5'
assert str(cirq.SWAP) == 'SWAP'
assert str(cirq.SWAP**0.5) == 'SWAP**0.5'
assert str(cirq.ISWAP) == 'ISWAP'
assert str(cirq.ISWAP**0.5) == 'ISWAP**0.5'
def compile_tensorboard_session():
theta = tf.Variable(np.pi)
circuit = cirq.Circuit.from_ops(
cirq.Ry(theta)(q(0)), cirq.CNOT(q(0), q(1)))
tf.summary.scalar('theta', theta)
initial_state = np.asarray([1, 0, 0, 0])
circuit_op = TFWaveFunctionSimulator(dtype=tf.complex64).simulate(
circuit, initial_state=initial_state)
# with tf.Session() as sess:
# sess.run(tf.global_variables_initializer())
# wf = sess.run(circuit_op)
# return
tensorboard_session(circuit_op, {theta: np.pi / 2})
def test_decomposition():
d = ion_device(3)
q0 = cirq.LineQubit(0)
q1 = cirq.LineQubit(1)
assert d.decompose_operation(cirq.H(q0)) == [
cirq.Rx(np.pi*1.0).on(cirq.LineQubit(0)),
cirq.Ry(np.pi*-0.5).on(cirq.LineQubit(0))]
circuit = cirq.Circuit()
circuit.append([cirq.X(q0), cirq.CNOT(q0, q1)])
ion_circuit = d.decompose_circuit(circuit)
cirq.testing.assert_has_diagram(ion_circuit, """
0: ───X───Ry(0.5π)───MS(0.25π)───Rx(-0.5π)───Ry(-0.5π)───
│
1: ──────────────────MS(0.25π)───Rx(-0.5π)───────────────
""", use_unicode_characters=True)
def test_apply_not_parametrized(self):
"""Tests that the proper error is raised if an Operation is applied
that was not parametrized before."""
operation = CirqOperation(
lambda a, b, c:
[cirq.X, cirq.Ry(a),
cirq.Rx(b), cirq.Z,
cirq.Rz(c)])
qubit = cirq.LineQubit(1)
with pytest.raises(
qml.DeviceError,
match=
"CirqOperation must be parametrized before it can be applied."
):
operation.apply(qubit)
def test_phase_by_xy():
assert cirq.phase_by(cirq.X, 0.25, 0) == cirq.Y
assert cirq.phase_by(cirq.Y, 0.25, 0) == cirq.X
assert cirq.phase_by(cirq.X**0.5, 0.25, 0) == cirq.Y**0.5
assert cirq.phase_by(cirq.Y**0.5, 0.25, 0) == cirq.X**-0.5
assert cirq.phase_by(cirq.X**-0.5, 0.25, 0) == cirq.Y**-0.5
assert cirq.phase_by(cirq.Y**-0.5, 0.25, 0) == cirq.X**0.5
cirq.testing.assert_phase_by_is_consistent_with_unitary(cirq.X)
cirq.testing.assert_phase_by_is_consistent_with_unitary(cirq.Y)
cirq.testing.assert_phase_by_is_consistent_with_unitary(cirq.X**0.5)
cirq.testing.assert_phase_by_is_consistent_with_unitary(cirq.Y**0.5)
cirq.testing.assert_phase_by_is_consistent_with_unitary(cirq.Rx(1))
cirq.testing.assert_phase_by_is_consistent_with_unitary(cirq.Ry(1))
cirq.testing.assert_phase_by_is_consistent_with_unitary(cirq.Rz(1))
def test_convert_to_ion_gates():
q0 = cirq.GridQubit(0, 0)
q1 = cirq.GridQubit(0, 1)
op = cirq.CNOT(q0, q1)
circuit = cirq.Circuit()
with pytest.raises(TypeError):
cirq.ion.ConvertToIonGates().convert_one(circuit)
with pytest.raises(TypeError):
cirq.ion.ConvertToIonGates().convert_one(NoUnitary().on(q0))
no_unitary_op = NoUnitary().on(q0)
assert cirq.ion.ConvertToIonGates(
ignore_failures=True).convert_one(no_unitary_op) == [no_unitary_op]
rx = cirq.ion.ConvertToIonGates().convert_one(OtherX().on(q0))
rop = cirq.ion.ConvertToIonGates().convert_one(op)
rcnot = cirq.ion.ConvertToIonGates().convert_one(OtherCNOT().on(q0, q1))
assert rx == [
cirq.PhasedXPowGate(phase_exponent=1).on(cirq.GridQubit(0, 0))
]
assert rop == [
cirq.Ry(np.pi / 2).on(op.qubits[0]),
cirq.ion.MS(np.pi / 4).on(op.qubits[0], op.qubits[1]),
cirq.ops.Rx(-1 * np.pi / 2).on(op.qubits[0]),
cirq.ops.Rx(-1 * np.pi / 2).on(op.qubits[1]),
cirq.ops.Ry(-1 * np.pi / 2).on(op.qubits[0])
]
assert rcnot == [
cirq.PhasedXPowGate(phase_exponent=-0.75,
exponent=0.5).on(cirq.GridQubit(0, 0)),
cirq.PhasedXPowGate(phase_exponent=1,
exponent=0.25).on(cirq.GridQubit(0, 1)),
cirq.T.on(cirq.GridQubit(0, 0)),
cirq.MS(-0.5 * np.pi / 2).on(cirq.GridQubit(0,
0), cirq.GridQubit(0, 1)),
(cirq.Y**0.5).on(cirq.GridQubit(0, 0)),
cirq.PhasedXPowGate(phase_exponent=1,
exponent=0.25).on(cirq.GridQubit(0, 1)),
(cirq.Z**-0.75).on(cirq.GridQubit(0, 0))
]
def test_formulaic_rotation_xyz_export():
a = cirq.LineQubit(0)
t = sympy.Symbol('t')
assert_links_to(cirq.Circuit(
cirq.Rx(sympy.pi / 2).on(a),
cirq.Ry(sympy.pi * t).on(a),
cirq.Rz(-sympy.pi * t).on(a),
),
"""
http://algassert.com/quirk#circuit={"cols":[
[{"arg":"(1/2)pi","id":"Rxft"}],
[{"arg":"(t)pi","id":"Ryft"}],
[{"arg":"(-t)pi","id":"Rzft"}]
]}
""",
escape_url=False)
with pytest.raises(ValueError, match='unsupported'):
_ = circuit_to_quirk_url(
cirq.Circuit(cirq.Rx(sympy.FallingFactorial(t, t)).on(a)))
def test_transformations():
pi = np.pi
initialRx = cirq.Rx(0.4)
expectedPowx = cirq.X**(0.4 / pi)
receivedPowx = initialRx.with_canonical_global_phase()
backToRx = receivedPowx.in_su2()
assert receivedPowx == expectedPowx
assert backToRx == initialRx
initialRy = cirq.Ry(0.123)
expectedPowy = cirq.Y**(0.123 / pi)
receivedPowy = initialRy.with_canonical_global_phase()
backToRy = receivedPowy.in_su2()
assert receivedPowy == expectedPowy
assert backToRy == initialRy
initialRz = cirq.Rz(-1.53)
expectedPowz = cirq.Z**(-1.53 / pi)
receivedPowz = initialRz.with_canonical_global_phase()
backToRz = receivedPowz.in_su2()
assert receivedPowz == expectedPowz
assert backToRz == initialRz
def test_exponentiate_single_value_as_exponent():
q = cirq.LineQubit(0)
assert cirq.approx_eq(math.e**(-0.25j * math.pi * cirq.X(q)),
cirq.Rx(0.25 * math.pi).on(q))
assert cirq.approx_eq(math.e**(-0.25j * math.pi * cirq.Y(q)),
cirq.Ry(0.25 * math.pi).on(q))
assert cirq.approx_eq(math.e**(-0.25j * math.pi * cirq.Z(q)),
cirq.Rz(0.25 * math.pi).on(q))
assert cirq.approx_eq(np.exp(-0.3j * math.pi * cirq.X(q)),
cirq.Rx(0.3 * math.pi).on(q))
assert cirq.approx_eq(cirq.X(q)**0.5, cirq.XPowGate(exponent=0.5).on(q))
assert cirq.approx_eq(cirq.Y(q)**0.5, cirq.YPowGate(exponent=0.5).on(q))
assert cirq.approx_eq(cirq.Z(q)**0.5, cirq.ZPowGate(exponent=0.5).on(q))
def generate_random_circuit(
num_qubits=5,
circuit_len=10,
):
qubits = cirq.LineQubit.range(num_qubits)
circuit = cirq.Circuit()
param_index = 0
for _ in range(circuit_len):
indices = np.arange(num_qubits)
np.random.shuffle(indices)
ops = []
i = 0
while i < num_qubits:
param = sympy.Symbol("θ{}".format(param_index))
gate_set = [
cirq.Rx(param),
cirq.Ry(param),
cirq.Rz(param), cirq.CNOT
]
gate = np.random.choice([
g for g in gate_set if i - 1 + g.num_qubits() <= num_qubits - 1
],
size=1)[0] # type: cirq.Gate
if gate.num_qubits() == 2:
op = gate.on(qubits[indices[i]], qubits[indices[i + 1]])
i += 1
else:
op = gate.on(qubits[indices[i]])
param_index += 1
ops.append(op)
i += 1
circuit.append(ops)
return circuit
def test_create_layer_of_gates_parameterized(self):
# Given
single_qubit_gate = "Ry"
n_qubits_list = [2, 3, 4, 10]
for n_qubits in n_qubits_list:
# Given
params = [x for x in range(0, n_qubits)]
test = cirq.Circuit()
qubits = [cirq.LineQubit(x) for x in range(0, n_qubits)]
for i in range(0, n_qubits):
test.append(cirq.Ry(params[i]).on(qubits[i]))
u_cirq = test._unitary_()
# When
circ = create_layer_of_gates(n_qubits, single_qubit_gate, params)
unitary = circ.to_cirq()._unitary_()
# Then
self.assertEqual(circ.n_multiqubit_gates, 0)
self.assertEqual(compare_unitary(unitary, u_cirq, tol=1e-10), True)
def test_consistency_with_qasm_output_and_qiskit():
qubits = [cirq.NamedQubit('q_{}'.format(i)) for i in range(4)]
a, b, c, d = qubits
circuit1 = cirq.Circuit.from_ops(
cirq.Rx(np.pi / 2).on(a),
cirq.Ry(np.pi / 2).on(b),
cirq.Rz(np.pi / 2).on(b),
cirq.X.on(a),
cirq.Y.on(b),
cirq.Z.on(c),
cirq.H.on(d),
cirq.S.on(a),
cirq.T.on(b),
cirq.S.on(c)**-1,
cirq.T.on(d)**-1,
cirq.X.on(d)**0.125,
cirq.TOFFOLI.on(a, b, c),
cirq.CSWAP.on(d, a, b),
cirq.SWAP.on(c, d),
cirq.CX.on(a, b),
cirq.ControlledGate(cirq.Y).on(c, d),
cirq.CZ.on(a, b),
cirq.ControlledGate(cirq.H).on(b, c),
cirq.IdentityGate(1).on(c),
cirq.circuits.qasm_output.QasmUGate(1.0, 2.0, 3.0).on(d),
)
qasm = cirq.qasm(circuit1)
circuit2 = cirq.contrib.qasm_import.qasm.QasmCircuitParser().parse(qasm)
cirq_unitary = cirq.unitary(circuit2)
ct.assert_allclose_up_to_global_phase(cirq_unitary,
cirq.unitary(circuit1),
atol=1e-8)
cq.assert_qiskit_parsed_qasm_consistent_with_unitary(qasm, cirq_unitary)
def convolution(self, index, window):
# initiation
qubits = cirq.LineQubit.range(self.num_window_qubits)
circuit = cirq.Circuit()
simulator = cirq.Simulator()
# encode the current window (vector) into a superposition state
circuit.append(superposition(window, qubits))
# first layer w/o measurement
circuit.append(
cirq.Ry(self.parameters[index][0][i]).on(qubits[i])
for i in range(self.num_window_qubits))
circuit.append(
cirq.CZ(qubits[2 * i], qubits[2 * i + 1])
for i in range(int(self.num_window_qubits / 2)))
circuit.append(cirq.CZ(qubits[1], qubits[2]))
# Bell measurement, removing every second qubits from contention
# current: measure 0,2 then conditional Z gate on 1,3
circuit.append(cirq.measure(qubits[0], qubits[2]))
circuit.append(
[cirq.CNOT(qubits[0], qubits[1]),
cirq.CNOT(qubits[2], qubits[3])])
# fully connected layer
circuit.append(cirq.CZ(qubits[1], qubits[3]))
# measure final qubits
circuit.append(cirq.measure(qubits[1], qubits[3]))
# simulate the partial circuit and return the measured values
result = simulator.run(circuit)
# return measurement on qubit 1, measurement on qubit 3
return result.measurements['1,3'][0][0], result.measurements['1,3'][0][
1]
def convert_dds_to_cirq_circuit(dynamic_decoupling_sequence,
target_qubits=None,
gate_time=0.1,
add_measurement=True,
algorithm=INSTANT_UNITARY):
"""Converts a Dynamic Decoupling Sequence into quantum circuit
as defined in cirq
Parameters
----------
dynamic_decoupling_sequence : DynamicDecouplingSequence
The dynamic decoupling sequence
target_qubits : list, optional
List of target qubits for the sequence operation; the qubits must be
cirq.Qid type; defaults to None in which case a 1-D lattice of one
qubit is used (indexed as 0).
gate_time : float, optional
Time (in seconds) delay introduced by a gate; defaults to 0.1
add_measurement : bool, optional
If True, the circuit contains a measurement operation for each of the
target qubits. Measurement from each of the qubits is associated
with a string as key. The string is formatted as 'qubit-X' where
X is a number between 0 and len(target_qubits).
algorithm : str, optional
One of 'fixed duration unitary' or 'instant unitary'; In the case of
'fixed duration unitary', the sequence operations are assumed to be
taking the amount of gate_time while 'instant unitary' assumes the sequence
operations are instantaneous (and hence does not contribute to the delay between
offsets). Defaults to 'instant unitary'.
Returns
-------
cirq.Circuit
The circuit containing gates corresponding to sequence operation.
Raises
------
ArgumentsValueError
If any of the input parameters result in an invalid operation.
Notes
-----
Dynamic Decoupling Sequences (DDS) consist of idealized pulse operation. Theoretically,
these operations (pi-pulses in X,Y or Z) occur instantaneously. However, in practice,
pulses require time. Therefore, this method of converting an idealized sequence
results to a circuit that is only an approximate implementation of the idealized sequence.
In idealized definition of DDS, `offsets` represents the instances within sequence
`duration` where a pulse occurs instantaneously. A series of appropriate circuit components
is placed in order to represent these pulses.
In 'standard circuit', the `gaps` or idle time in between active pulses are filled up
with `identity` gates. Each identity gate introduces a delay of `gate_time`. In this
implementation, the number of identity gates is determined by
:math:`np.int(np.floor(offset\\_distance / gate\\_time))`. As a consequence,
:math:`np.int(np.floor(offset\\_distance / gate\\_time))`. As a consequence,
the duration of the real-circuit is :math:`gate\\_time \\times number\\_of\\_identity\\_gates +
pulse\\_gate\\_time \\times number\\_of\\_pulses`.
Q-CTRL Cirq Adapter supports operation resulting in rotation around at most one axis at
any offset.
"""
if dynamic_decoupling_sequence is None:
raise ArgumentsValueError(
'No dynamic decoupling sequence provided.',
{'dynamic_decoupling_sequence': dynamic_decoupling_sequence})
if not isinstance(dynamic_decoupling_sequence, DynamicDecouplingSequence):
raise ArgumentsValueError(
'Dynamical decoupling sequence is not recognized.'
'Expected DynamicDecouplingSequence instance', {
'type(dynamic_decoupling_sequence)':
type(dynamic_decoupling_sequence)
})
if gate_time <= 0:
raise ArgumentsValueError(
'Time delay of gates must be greater than zero.',
{'gate_time': gate_time})
target_qubits = target_qubits or [cirq.LineQubit(0)]
if algorithm not in [FIX_DURATION_UNITARY, INSTANT_UNITARY]:
raise ArgumentsValueError(
'Algorithm must be one of {} or {}'.format(INSTANT_UNITARY,
FIX_DURATION_UNITARY),
{'algorithm': algorithm})
unitary_time = 0.
if algorithm == FIX_DURATION_UNITARY:
unitary_time = gate_time
rabi_rotations = dynamic_decoupling_sequence.rabi_rotations
azimuthal_angles = dynamic_decoupling_sequence.azimuthal_angles
detuning_rotations = dynamic_decoupling_sequence.detuning_rotations
offsets = dynamic_decoupling_sequence.offsets
time_covered = 0
circuit = cirq.Circuit()
for offset, rabi_rotation, azimuthal_angle, detuning_rotation in zip(
list(offsets), list(rabi_rotations), list(azimuthal_angles),
list(detuning_rotations)):
offset_distance = offset - time_covered
if np.isclose(offset_distance, 0.0):
offset_distance = 0.0
if offset_distance < 0:
raise ArgumentsValueError(
"Offsets cannot be placed properly. Spacing between the rotations"
"is smaller than the time required to perform the rotation. Provide"
"a longer dynamic decoupling sequence or shorted gate time.", {
'dynamic_decoupling_sequence': dynamic_decoupling_sequence,
'gate_time': gate_time
})
while (time_covered + gate_time) <= offset:
gate_list = []
for qubit in target_qubits:
gate_list.append(cirq.I(qubit))
time_covered += gate_time
circuit.append(gate_list)
rotations = np.array([
rabi_rotation * np.cos(azimuthal_angle),
rabi_rotation * np.sin(azimuthal_angle), detuning_rotation
])
if np.sum(np.isclose(rotations, 0.0).astype(np.int)) == 1:
raise ArgumentsValueError(
'Open Controls support a sequence with one '
'valid rotation at any offset. Found a sequence '
'with multiple rotation operations at an offset.',
{'dynamic_decoupling_sequence': dynamic_decoupling_sequence},
extras={
'offset': offset,
'rabi_rotation': rabi_rotation,
'azimuthal_angle': azimuthal_angle,
'detuning_rotation': detuning_rotation
})
gate_list = []
for qubit in target_qubits:
if np.sum(np.isclose(rotations, 0.0).astype(np.int)) == 3:
gate_list.append(cirq.I(qubit))
else:
if not np.isclose(rotations[0], 0.0):
gate_list.append(cirq.Rx(rotations[0])(qubit))
elif not np.isclose(rotations[1], 0.0):
gate_list.append(cirq.Ry(rotations[1])(qubit))
elif not np.isclose(rotations[2], 0.):
gate_list.append(cirq.Rz(rotations[2])(qubit))
circuit.append(gate_list)
time_covered = offset + unitary_time
if add_measurement:
gate_list = []
for idx, qubit in enumerate(target_qubits):
gate_list.append(cirq.measure(qubit, key='qubit-{}'.format(idx)))
circuit.append(gate_list)
return circuit
actual_expansion = cirq.pauli_expansion(actual)
expected_expansion = cirq.pauli_expansion(expected)
assert set(actual_expansion.keys()) == set(expected_expansion.keys())
for name in actual_expansion.keys():
assert abs(actual_expansion[name] - expected_expansion[name]) < 1e-12
@pytest.mark.parametrize('expression, expected_result', (
((cirq.X + cirq.Z) / np.sqrt(2), cirq.H),
(cirq.X - cirq.Y, -cirq.Y + cirq.X),
(cirq.X + cirq.S - cirq.X, cirq.S),
(cirq.Y - 2 * cirq.Y, -cirq.Y),
(cirq.Rx(0.2), np.cos(0.1) * cirq.I - 1j * np.sin(0.1) * cirq.X),
(1j * cirq.H * 1j, -cirq.H),
(-1j * cirq.Y, cirq.Ry(np.pi)),
(np.sqrt(-1j) * cirq.S, cirq.Rz(np.pi / 2)),
(0.5 * (cirq.IdentityGate(2) + cirq.XX + cirq.YY + cirq.ZZ), cirq.SWAP),
((cirq.IdentityGate(2) + 1j *
(cirq.XX + cirq.YY) + cirq.ZZ) / 2, cirq.ISWAP),
(cirq.CNOT + 0 * cirq.SWAP, cirq.CNOT),
(0.5 * cirq.FREDKIN, cirq.FREDKIN / 2),
(cirq.FREDKIN * 0.5, cirq.FREDKIN / 2),
(((cirq.X + cirq.Y) / np.sqrt(2))**2, cirq.I),
((cirq.X + cirq.Z)**3, 2 * (cirq.X + cirq.Z)),
((cirq.X + 1j * cirq.Y)**2, cirq.LinearCombinationOfGates({})),
((cirq.X - 1j * cirq.Y)**2, cirq.LinearCombinationOfGates({})),
(((3 * cirq.X - 4 * cirq.Y + 12 * cirq.Z) / 13)**24, cirq.I),
(((3 * cirq.X - 4 * cirq.Y + 12 * cirq.Z) / 13)**25,
(3 * cirq.X - 4 * cirq.Y + 12 * cirq.Z) / 13),
((cirq.X + cirq.Y + cirq.Z)**0, cirq.I),
})),
(HasUnitary(np.eye(2)), cirq.LinearDict({'I': 1})),
(HasUnitary(np.array([[1, -1j], [1j, -1]
])), cirq.LinearDict({
'Y': 1,
'Z': 1
})),
(HasUnitary(np.array([[0., 1.], [0., 0.]
])), cirq.LinearDict({
'X': 0.5,
'Y': 0.5j
})),
(HasUnitary(np.eye(16)), cirq.LinearDict({'IIII': 1.0})),
(cirq.H, cirq.LinearDict({
'X': np.sqrt(0.5),
'Z': np.sqrt(0.5)
})),
(cirq.Ry(np.pi / 2),
cirq.LinearDict({
'I': np.cos(np.pi / 4),
'Y': -1j * np.sin(np.pi / 4)
})),
))
def test_pauli_expansion(val, expected_expansion):
actual_expansion = cirq.pauli_expansion(val)
assert cirq.approx_eq(actual_expansion, expected_expansion, atol=1e-12)
assert set(actual_expansion.keys()) == set(expected_expansion.keys())
for name in actual_expansion.keys():
assert np.abs(actual_expansion[name] -
expected_expansion[name]) < 1e-12
def test_deprecated_rxyz_rotations(rads):
assert np.all(cirq.unitary(cirq.Rx(rads)) == cirq.unitary(cirq.rx(rads)))
assert np.all(cirq.unitary(cirq.Ry(rads)) == cirq.unitary(cirq.ry(rads)))
assert np.all(cirq.unitary(cirq.Rz(rads)) == cirq.unitary(cirq.rz(rads)))
def _get_valid_circuit_proto_pairs():
q0 = cirq.GridQubit(0, 0)
q1 = cirq.GridQubit(0, 1)
pairs = [
# HPOW and aliases.
(cirq.Circuit(cirq.HPowGate(exponent=0.3)(q0)),
_build_gate_proto("HP",
['exponent', 'exponent_scalar', 'global_shift'],
[0.3, 1.0, 0.0], ['0_0'])),
(cirq.Circuit(cirq.HPowGate(exponent=sympy.Symbol('alpha'))(q0)),
_build_gate_proto("HP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 1.0, 0.0], ['0_0'])),
(cirq.Circuit(cirq.HPowGate(exponent=3.0 * sympy.Symbol('alpha'))(q0)),
_build_gate_proto("HP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.0, 0.0], ['0_0'])),
(cirq.Circuit(cirq.H(q0)),
_build_gate_proto("HP",
['exponent', 'exponent_scalar', 'global_shift'],
[1.0, 1.0, 0.0], ['0_0'])),
# XPOW and aliases.
(cirq.Circuit(cirq.XPowGate(exponent=0.3)(q0)),
_build_gate_proto("XP",
['exponent', 'exponent_scalar', 'global_shift'],
[0.3, 1.0, 0.0], ['0_0'])),
(cirq.Circuit(cirq.XPowGate(exponent=sympy.Symbol('alpha'))(q0)),
_build_gate_proto("XP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 1.0, 0.0], ['0_0'])),
(cirq.Circuit(cirq.XPowGate(exponent=3.0 * sympy.Symbol('alpha'))(q0)),
_build_gate_proto("XP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.0, 0.0], ['0_0'])),
(cirq.Circuit(cirq.X(q0)),
_build_gate_proto("XP",
['exponent', 'exponent_scalar', 'global_shift'],
[1.0, 1.0, 0.0], ['0_0'])),
# YPOW and aliases
(cirq.Circuit(cirq.YPowGate(exponent=0.3)(q0)),
_build_gate_proto("YP",
['exponent', 'exponent_scalar', 'global_shift'],
[0.3, 1.0, 0.0], ['0_0'])),
(cirq.Circuit(cirq.YPowGate(exponent=sympy.Symbol('alpha'))(q0)),
_build_gate_proto("YP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 1.0, 0.0], ['0_0'])),
(cirq.Circuit(cirq.YPowGate(exponent=3.0 * sympy.Symbol('alpha'))(q0)),
_build_gate_proto("YP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.0, 0.0], ['0_0'])),
(cirq.Circuit(cirq.Y(q0)),
_build_gate_proto("YP",
['exponent', 'exponent_scalar', 'global_shift'],
[1.0, 1.0, 0.0], ['0_0'])),
# ZPOW and aliases.
(cirq.Circuit(cirq.ZPowGate(exponent=0.3)(q0)),
_build_gate_proto("ZP",
['exponent', 'exponent_scalar', 'global_shift'],
[0.3, 1.0, 0.0], ['0_0'])),
(cirq.Circuit(cirq.ZPowGate(exponent=sympy.Symbol('alpha'))(q0)),
_build_gate_proto("ZP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 1.0, 0.0], ['0_0'])),
(cirq.Circuit(cirq.ZPowGate(exponent=3.0 * sympy.Symbol('alpha'))(q0)),
_build_gate_proto("ZP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.0, 0.0], ['0_0'])),
(cirq.Circuit(cirq.Z(q0)),
_build_gate_proto("ZP",
['exponent', 'exponent_scalar', 'global_shift'],
[1.0, 1.0, 0.0], ['0_0'])),
# XXPow and aliases
(cirq.Circuit(cirq.XXPowGate(exponent=0.3)(q0, q1)),
_build_gate_proto("XXP",
['exponent', 'exponent_scalar', 'global_shift'],
[0.3, 1.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(cirq.XXPowGate(exponent=sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("XXP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 1.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(
cirq.XXPowGate(exponent=3.0 * sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("XXP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(cirq.XX(q0, q1)),
_build_gate_proto("XXP",
['exponent', 'exponent_scalar', 'global_shift'],
[1.0, 1.0, 0.0], ['0_0', '0_1'])),
# YYPow and aliases
(cirq.Circuit(cirq.YYPowGate(exponent=0.3)(q0, q1)),
_build_gate_proto("YYP",
['exponent', 'exponent_scalar', 'global_shift'],
[0.3, 1.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(cirq.YYPowGate(exponent=sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("YYP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 1.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(
cirq.YYPowGate(exponent=3.0 * sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("YYP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(cirq.YY(q0, q1)),
_build_gate_proto("YYP",
['exponent', 'exponent_scalar', 'global_shift'],
[1.0, 1.0, 0.0], ['0_0', '0_1'])),
# ZZPow and aliases
(cirq.Circuit(cirq.ZZPowGate(exponent=0.3)(q0, q1)),
_build_gate_proto("ZZP",
['exponent', 'exponent_scalar', 'global_shift'],
[0.3, 1.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(cirq.ZZPowGate(exponent=sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("ZZP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 1.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(
cirq.ZZPowGate(exponent=3.0 * sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("ZZP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(cirq.ZZ(q0, q1)),
_build_gate_proto("ZZP",
['exponent', 'exponent_scalar', 'global_shift'],
[1.0, 1.0, 0.0], ['0_0', '0_1'])),
# CZPow and aliases
(cirq.Circuit(cirq.CZPowGate(exponent=0.3)(q0, q1)),
_build_gate_proto("CZP",
['exponent', 'exponent_scalar', 'global_shift'],
[0.3, 1.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(cirq.CZPowGate(exponent=sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("CZP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 1.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(
cirq.CZPowGate(exponent=3.0 * sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("CZP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(cirq.CZ(q0, q1)),
_build_gate_proto("CZP",
['exponent', 'exponent_scalar', 'global_shift'],
[1.0, 1.0, 0.0], ['0_0', '0_1'])),
# CNOTPow and aliases
(cirq.Circuit(cirq.CNotPowGate(exponent=0.3)(q0, q1)),
_build_gate_proto("CNP",
['exponent', 'exponent_scalar', 'global_shift'],
[0.3, 1.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(
cirq.CNotPowGate(exponent=sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("CNP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 1.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(
cirq.CNotPowGate(exponent=3.0 * sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("CNP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(cirq.CNOT(q0, q1)),
_build_gate_proto("CNP",
['exponent', 'exponent_scalar', 'global_shift'],
[1.0, 1.0, 0.0], ['0_0', '0_1'])),
# SWAPPow and aliases
(cirq.Circuit(cirq.SwapPowGate(exponent=0.3)(q0, q1)),
_build_gate_proto("SP",
['exponent', 'exponent_scalar', 'global_shift'],
[0.3, 1.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(
cirq.SwapPowGate(exponent=sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("SP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 1.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(
cirq.SwapPowGate(exponent=3.0 * sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("SP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(cirq.SWAP(q0, q1)),
_build_gate_proto("SP",
['exponent', 'exponent_scalar', 'global_shift'],
[1.0, 1.0, 0.0], ['0_0', '0_1'])),
# ISWAPPow and aliases
(cirq.Circuit(cirq.ISwapPowGate(exponent=0.3)(q0, q1)),
_build_gate_proto("ISP",
['exponent', 'exponent_scalar', 'global_shift'],
[0.3, 1.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(
cirq.ISwapPowGate(exponent=sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("ISP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 1.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(
cirq.ISwapPowGate(exponent=3.0 * sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("ISP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.0, 0.0], ['0_0', '0_1'])),
(cirq.Circuit(cirq.ISWAP(q0, q1)),
_build_gate_proto("ISP",
['exponent', 'exponent_scalar', 'global_shift'],
[1.0, 1.0, 0.0], ['0_0', '0_1'])),
# PhasedXPow and aliases
(cirq.Circuit(
cirq.PhasedXPowGate(phase_exponent=0.9,
exponent=0.3,
global_shift=0.2)(q0)),
_build_gate_proto("PXP", [
'phase_exponent', 'phase_exponent_scalar', 'exponent',
'exponent_scalar', 'global_shift'
], [0.9, 1.0, 0.3, 1.0, 0.2], ['0_0'])),
(cirq.Circuit(
cirq.PhasedXPowGate(phase_exponent=sympy.Symbol('alpha'),
exponent=0.3)(q0)),
_build_gate_proto("PXP", [
'phase_exponent', 'phase_exponent_scalar', 'exponent',
'exponent_scalar', 'global_shift'
], ['alpha', 1.0, 0.3, 1.0, 0.0], ['0_0'])),
(cirq.Circuit(
cirq.PhasedXPowGate(phase_exponent=3.0 * sympy.Symbol('alpha'),
exponent=0.3)(q0)),
_build_gate_proto("PXP", [
'phase_exponent', 'phase_exponent_scalar', 'exponent',
'exponent_scalar', 'global_shift'
], ['alpha', 3.0, 0.3, 1.0, 0.0], ['0_0'])),
(cirq.Circuit(
cirq.PhasedXPowGate(phase_exponent=0.9,
exponent=sympy.Symbol('beta'))(q0)),
_build_gate_proto("PXP", [
'phase_exponent', 'phase_exponent_scalar', 'exponent',
'exponent_scalar', 'global_shift'
], [0.9, 1.0, 'beta', 1.0, 0.0], ['0_0'])),
(cirq.Circuit(
cirq.PhasedXPowGate(phase_exponent=0.9,
exponent=5.0 * sympy.Symbol('beta'))(q0)),
_build_gate_proto("PXP", [
'phase_exponent', 'phase_exponent_scalar', 'exponent',
'exponent_scalar', 'global_shift'
], [0.9, 1.0, 'beta', 5.0, 0.0], ['0_0'])),
(cirq.Circuit(
cirq.PhasedXPowGate(phase_exponent=3.0 * sympy.Symbol('alpha'),
exponent=5.0 * sympy.Symbol('beta'))(q0)),
_build_gate_proto("PXP", [
'phase_exponent', 'phase_exponent_scalar', 'exponent',
'exponent_scalar', 'global_shift'
], ['alpha', 3.0, 'beta', 5.0, 0.0], ['0_0'])),
# RX, RY, RZ with symbolization is tested in special cases as the
# string comparison of the float converted sympy.pi does not happen
# smoothly. See: test_serialize_deserialize_special_case_one_qubit
(cirq.Circuit(cirq.Rx(np.pi)(q0)),
_build_gate_proto("XP",
['exponent', 'exponent_scalar', 'global_shift'],
[1.0, 1.0, -0.5], ['0_0'])),
(cirq.Circuit(cirq.Ry(np.pi)(q0)),
_build_gate_proto("YP",
['exponent', 'exponent_scalar', 'global_shift'],
[1.0, 1.0, -0.5], ['0_0'])),
(cirq.Circuit(cirq.Rz(np.pi)(q0)),
_build_gate_proto("ZP",
['exponent', 'exponent_scalar', 'global_shift'],
[1.0, 1.0, -0.5], ['0_0'])),
# FSimGate
(cirq.Circuit(cirq.FSimGate(theta=0.1, phi=0.2)(q0, q1)),
_build_gate_proto("FSIM",
['theta', 'theta_scalar', 'phi', 'phi_scalar'],
[0.1, 1.0, 0.2, 1.0], ['0_0', '0_1'])),
(cirq.Circuit(
cirq.FSimGate(theta=2.0 * sympy.Symbol("alpha"),
phi=1.3 * sympy.Symbol("beta"))(q0, q1)),
_build_gate_proto("FSIM",
['theta', 'theta_scalar', 'phi', 'phi_scalar'],
['alpha', 2.0, 'beta', 1.3], ['0_0', '0_1'])),
]
return pairs
class SerializerTest(tf.test.TestCase, parameterized.TestCase):
"""Tests basic serializer functionality"""
@parameterized.parameters([{
'circ_proto_pair': v
} for v in _get_valid_circuit_proto_pairs()])
def test_serialize_circuit_valid(self, circ_proto_pair):
"""Test conversion of cirq Circuits to tfq_gate_set proto."""
self.assertProtoEquals(
serializer.serialize_circuit(circ_proto_pair[0]),
circ_proto_pair[1])
@parameterized.parameters([{
'circ_proto_pair': v
} for v in _get_valid_circuit_proto_pairs()])
def test_deserialize_circuit_valid(self, circ_proto_pair):
"""Test deserialization of protos in tfq_gate_set."""
# String casting is done here to round floating point values.
# cirq.testing.assert_same_circuits will call break and think
# cirq.Z^0.30000001 is different from cirq.Z^0.3
self.assertEqual(circ_proto_pair[0],
serializer.deserialize_circuit(circ_proto_pair[1]))
@parameterized.parameters([{
'circ_proto_pair': v
} for v in _get_valid_circuit_proto_pairs()])
def test_serialize_deserialize_circuit_consistency(self, circ_proto_pair):
"""Ensure that serializing followed by deserializing works."""
# String casting is done here to round floating point values.
# cirq.testing.assert_same_circuits will call break and think
# cirq.Z^0.30000001 is different from cirq.Z^0.3
self.assertProtoEquals(
serializer.serialize_circuit(
serializer.deserialize_circuit(circ_proto_pair[1])),
circ_proto_pair[1])
self.assertEqual(
serializer.deserialize_circuit(
serializer.serialize_circuit(circ_proto_pair[0])),
circ_proto_pair[0])
def test_serialize_circuit_unsupported_gate(self):
"""Ensure we error on unsupported gates."""
q0 = cirq.GridQubit(0, 0)
q1 = cirq.GridQubit(0, 1)
unsupported_circuit = cirq.Circuit(cirq.QFT(q0, q1))
with self.assertRaises(ValueError):
serializer.serialize_circuit(unsupported_circuit)
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)
@parameterized.parameters([
{
"gate_with_param": g(p)
}
# Use a gate from each category of serializer
for g in [
# eigen
lambda p: cirq.Circuit(
cirq.HPowGate(exponent=p, global_shift=p)
(cirq.GridQubit(0, 0))),
# phased eigen
lambda p: cirq.Circuit(
cirq.PhasedXPowGate(
phase_exponent=p, exponent=p, global_shift=p)
(cirq.GridQubit(0, 0))),
# fsim
lambda p: cirq.Circuit(
cirq.FSimGate(theta=p, phi=p)
(cirq.GridQubit(0, 0), cirq.GridQubit(0, 1))),
]
# Attempt parameterization with a variety of numeric types
for p in
[0.35, float(0.35), 35e-2,
np.float32(0.35),
np.float64(0.35), 7]
])
def test_serialize_circuit_valid_number_types(self, gate_with_param):
"""Tests number datatype support by our serializer."""
self.assertAllClose(
gate_with_param.unitary(),
serializer.deserialize_circuit(
serializer.serialize_circuit(gate_with_param)).unitary())
def test_serialize_circuit_unsupported_value(self):
"""Ensure we error on unsupported arithmetic expressions."""
q0 = cirq.GridQubit(0, 0)
unsupported_circuit = cirq.Circuit(
cirq.HPowGate()(q0)**(sympy.Symbol('alpha') + 1))
q1 = cirq.NamedQubit('wont work')
unsupported_circuit2 = cirq.Circuit(cirq.H(q1))
with self.assertRaises(ValueError):
serializer.serialize_circuit(unsupported_circuit)
with self.assertRaises(ValueError):
serializer.serialize_circuit(unsupported_circuit2)
@parameterized.parameters([{'inp': v} for v in ['wrong', 1.0, None, []]])
def test_serialize_circuit_wrong_type(self, inp):
"""Attempt to serialize invalid objects types."""
with self.assertRaises(TypeError):
serializer.serialize_circuit(input)
@parameterized.parameters([{'inp': v} for v in ['wrong', 1.0, None, []]])
def test_deserialize_circuit_wrong_type(self, inp):
"""Attempt to deserialize invalid objects types."""
with self.assertRaises(TypeError):
serializer.deserialize_circuit(input)
@parameterized.parameters([{'inp': v} for v in ['wrong', 1.0, None, []]])
def test_serialize_paulisum_wrong_type(self, inp):
"""Attempt to serialize invalid object types."""
with self.assertRaises(TypeError):
serializer.serialize_paulisum(inp)
@parameterized.parameters([{'inp': v} for v in ['wrong', 1.0, None, []]])
def test_deserialize_paulisum_wrong_type(self, inp):
"""Attempt to deserialize invalid object types."""
with self.assertRaises(TypeError):
serializer.deserialize_paulisum(inp)
def test_serialize_paulisum_invalid(self):
"""Ensure we don't support anything but GridQubits."""
q0 = cirq.NamedQubit('wont work')
a = 3.0 * cirq.Z(q0) - 2.0 * cirq.X(q0)
with self.assertRaises(ValueError):
serializer.serialize_paulisum(a)
@parameterized.parameters([{
'sum_proto_pair': v
} for v in _get_valid_pauli_proto_pairs()])
def test_serialize_paulisum_simple(self, sum_proto_pair):
"""Ensure serialization is correct."""
self.assertProtoEquals(
sum_proto_pair[1],
serializer.serialize_paulisum(sum_proto_pair[0]))
@parameterized.parameters([{
'sum_proto_pair': v
} for v in _get_valid_pauli_proto_pairs()])
def test_deserialize_paulisum_simple(self, sum_proto_pair):
"""Ensure deserialization is correct."""
self.assertEqual(serializer.deserialize_paulisum(sum_proto_pair[1]),
sum_proto_pair[0])
@parameterized.parameters([{
'sum_proto_pair': v
} for v in _get_valid_pauli_proto_pairs()])
def test_serialize_deserialize_paulisum_consistency(self, sum_proto_pair):
"""Serialize and deserialize and ensure nothing changed."""
self.assertEqual(
serializer.serialize_paulisum(
serializer.deserialize_paulisum(sum_proto_pair[1])),
sum_proto_pair[1])
self.assertEqual(
serializer.deserialize_paulisum(
serializer.serialize_paulisum(sum_proto_pair[0])),
sum_proto_pair[0])
@parameterized.parameters([
{
'gate': cirq.Rx(3.0 * sympy.Symbol('alpha'))
},
{
'gate': cirq.Ry(-1.0 * sympy.Symbol('alpha'))
},
{
'gate': cirq.Rz(sympy.Symbol('alpha'))
},
])
def test_serialize_deserialize_special_case_one_qubit(self, gate):
"""Check output state equality."""
q0 = cirq.GridQubit(0, 0)
c = cirq.Circuit(gate(q0))
c = c._resolve_parameters_(cirq.ParamResolver({"alpha": 0.1234567}))
before = c.unitary()
c2 = serializer.deserialize_circuit(serializer.serialize_circuit(c))
after = c2.unitary()
self.assertAllClose(before, after)
def test_terminal_measurement_support(self):
"""Test that non-terminal measurements error during serialization."""
q0 = cirq.GridQubit(0, 0)
q1 = cirq.GridQubit(0, 1)
simple_circuit = cirq.Circuit(cirq.H(q0), cirq.measure(q0), cirq.H(q1),
cirq.Z(q1), cirq.measure(q1))
simple_circuit_before_call = copy.deepcopy(simple_circuit)
expected_circuit = cirq.Circuit(cirq.Moment([cirq.H(q0),
cirq.H(q1)]),
cirq.Moment([cirq.Z(q1)]),
cirq.Moment([]))
self.assertEqual(serializer.serialize_circuit(simple_circuit),
serializer.serialize_circuit(expected_circuit))
# Check that serialization didn't modify existing circuit.
self.assertEqual(simple_circuit, simple_circuit_before_call)
invalid_circuit = cirq.Circuit(cirq.H(q0), cirq.measure(q0),
cirq.measure(q0))
with self.assertRaisesRegex(ValueError, expected_regex="non-terminal"):
serializer.serialize_circuit(invalid_circuit)
def test_serialize_deserialize_identity(self):
"""Confirm that identity gates can be serialized and deserialized."""
q0 = cirq.GridQubit(0, 0)
q1 = cirq.GridQubit(0, 1)
paulisum_with_identity = cirq.PauliSum.from_pauli_strings([
cirq.PauliString(cirq.I(q0)),
cirq.PauliString(cirq.Z(q0), cirq.Z(q1)),
])
self.assertEqual(
paulisum_with_identity,
serializer.deserialize_paulisum(
serializer.serialize_paulisum(paulisum_with_identity)))
def test_arbitrary_rotation(self):
"""
This tests arbitrary rotations around the Y axis (so the X-Z plane) to make sure Cirq
can deal with any given superposition.
"""
# This test will perform rotations around the Bloch sphere so that each qubit has an evenly-
# incrementing chance of being in the |0〉 state. For example, for 3 qubits, it will be
# 0% for the first, 50% for the second, and 100% for the third. For 4 qubits, it will be
# 0%, 33%, 66%, and 100%.
#
# This test is run a bunch of times on various intervals, ranging from 50% to 1/6
# (16.667%).
for i in range(2, 7):
interval = 1 / i # The amount to increase each qubit's probability by, relative to the previous qubit
target_probabilities = [0] * (
i + 1
) # This will store the desired probabilities of each qubit
step_string = "{:.4f}".format(
100 /
i) # The decimal representation of the interval, as a percent
# Construct the circuit
qubits = cirq.NamedQubit.range(len(target_probabilities),
prefix="qubit")
circuit = cirq.Circuit()
# Calculate the probabilities for each qubit, and add the rotation gates
for j in range(0, i + 1):
target_probability = j * interval
target_probabilities[j] = target_probability
# To get this probability, we have to rotate around the Y axis
# (AKA just moving around on the X and Z plane) by this angle.
# The Bloch equation is |q> = cos(θ/2)|0> + e^iΦ*sin(θ/2)|1>,
# where θ is the angle from the +Z axis on the Z-X plane, and Φ
# is the angle from the +X axis on the X-Y plane. Since we aren't
# going to bring imaginary numbers into the picture for this test,
# we can leave Φ at 0 and ignore it entirely. We just want to rotate
# along the unit circle defined by the Z-X plane, thus a rotation
# around the Y axis.
#
# The amplitude of |0> is given by cos(θ/2) as shown above. The
# probability of measuring |0> is the amplitude squared, so
# P = cos²(θ/2). So to get the angle, it's:
# √P = cos(θ/2)
# cos⁻¹(√P) = θ/2
# θ = 2cos⁻¹(√P)
# Then we just rotate the qubit by that angle around the Y axis,
# and we should be good.
#
# See https://en.wikipedia.org/wiki/Bloch_sphere for more info on
# the Bloch sphere, and how rotations around it affect the qubit's
# probabilities of measurement.
angle = 2 * math.acos(math.sqrt(target_probability))
circuit.append(cirq.Ry(angle).on(qubits[j]))
# Run the test
self.run_test(circuit, qubits,
f"Rotation with steps of 1/{i} ({step_string}%)",
2000, target_probabilities, 0.05)
import cirq
import matplotlib.pyplot as plt
import numpy as np
# probability for |1>
p = 0.125
# angle
theta_p = 2 * np.arcsin(np.sqrt(p))
print(theta_p)
# make a rotation operator (matrix)
# (This is denoted A in the papers)
rotation = cirq.Ry(theta_p)
print(rotation)
# grab some qubits
# ONLY n=2 is supported right now in the adder
n = 2
qubits = [None] * n
for i in range(len(qubits)):
qubits[i] = cirq.GridQubit(0, i)
print(qubits)
#### Simple addition of the 2 qubits ( AND / XOR )
# Idea is explained in https://quantumcomputing.stackexchange.com/questions/1654/how-do-i-add-11-using-a-quantum-computer
circuit_with_addition = cirq.Circuit()
for qubit in qubits:
'C1MinusOne',
'C2PlusOne',
'C2MinusOne',
)
PlusOne = qudit.PlusGate(3)
MinusOne = qudit.PlusGate(3, -1)
Chrest_3 = qudit.Chrestenson(3)
Z1 = qudit.ZGate(3, increment=1)
Z2 = qudit.ZGate(3, increment=2)
F01 = qudit.FlipGate(3, 0, 1) # or SingleQuditSubspaceGate(cirq.X, 3, (0, 1))
F02 = qudit.FlipGate(3, 0, 2) # or SingleQuditSubspaceGate(cirq.X, 3, (0, 2))
F12 = qudit.FlipGate(3, 1, 2) # or SingleQuditSubspaceGate(cirq.X, 3, (1, 2))
SWAP2 = qudit.SubspaceSwapGate(3, 3, 2, 2)
SWAP3 = qudit.SubspaceSwapGate(3, 3, 3, 3)
Ry01 = lambda theta: qudit.SingleQuditSubspaceGate(cirq.Ry(theta), 3, (0, 1))
Ry02 = lambda theta: qudit.SingleQuditSubspaceGate(cirq.Ry(theta), 3, (0, 2))
Ry12 = lambda theta: qudit.SingleQuditSubspaceGate(cirq.Ry(theta), 3, (1, 2))
C0F01 = cirq.ControlledGate(F01, control_values=(0, ), control_qid_shape=(3, ))
C1F01 = cirq.ControlledGate(F01, control_values=(1, ), control_qid_shape=(3, ))
C2F01 = cirq.ControlledGate(F01, control_values=(2, ), control_qid_shape=(3, ))
C0F02 = cirq.ControlledGate(F02, control_values=(0, ), control_qid_shape=(3, ))
C1F02 = cirq.ControlledGate(F02, control_values=(1, ), control_qid_shape=(3, ))
C2F02 = cirq.ControlledGate(F02, control_values=(2, ), control_qid_shape=(3, ))
C0F12 = cirq.ControlledGate(F12, control_values=(0, ), control_qid_shape=(3, ))
C1F12 = cirq.ControlledGate(F12, control_values=(1, ), control_qid_shape=(3, ))
C2F12 = cirq.ControlledGate(F12, control_values=(2, ), control_qid_shape=(3, ))
C0PlusOne = cirq.ControlledGate(PlusOne,
control_values=(0, ),
control_qid_shape=(3, ))
C0MinusOne = cirq.ControlledGate(MinusOne,
