def cphase_symbols_to_sqrt_iswap(a, b, turns):
"""Version of cphase_to_sqrt_iswap that works with symbols.
Note that the formulae contained below will need to be flattened
into a sweep before serializing.
"""
theta = sympy.Mod(turns, 2.0) * sympy.pi
# -1 if theta > pi. Adds a hacky fudge factor so theta=pi is not 0
sign = sympy.sign(sympy.pi - theta + 1e-9)
# For sign = 1: theta. For sign = -1, 2pi-theta
theta_prime = (sympy.pi - sign * sympy.pi) + sign * theta
phi = sympy.asin(np.sqrt(2) * sympy.sin(theta_prime / 4))
xi = sympy.atan(sympy.tan(phi) / np.sqrt(2))
yield cirq.Rz(sign * 0.5 * theta_prime).on(a)
yield cirq.Rz(sign * 0.5 * theta_prime).on(b)
yield cirq.Rx(xi).on(a)
yield cirq.X(b)**(-sign * 0.5)
yield SQRT_ISWAP_INV(a, b)
yield cirq.Rx(-2 * phi).on(a)
yield SQRT_ISWAP(a, b)
yield cirq.Rx(xi).on(a)
yield cirq.X(b)**(sign * 0.5)
def test_resolve_named_placeholder():
"""Resolve named placeholders via feed_dict."""
wf = cirq.testing.random_superposition(2).astype(np.complex64)
# placeholders can be instantiated without references in circuit gates!
var_names = ["v_{}".format(i) for i in range(5)]
params = np.random.randn(5)
placeholder_circuit = cirq.Circuit()
for i in range(5):
placeholder_circuit += cirq.Rx(
tf.placeholder(tf.complex64, shape=(), name=f"theta_{i}"))(q(0))
circuit_op = TFWaveFunctionSimulator(dtype=tf.complex64).simulate(
placeholder_circuit, initial_state=wf)
placeholder_names = ["theta_{}:0".format(i) for i in range(5)]
feed_dict = dict(zip(placeholder_names, params))
with tf.Session() as sess:
tf_result = sess.run(circuit_op, feed_dict=feed_dict).reshape(-1)
circuit = cirq.Circuit()
for theta in params:
circuit += cirq.Rx(theta)(q(0))
cirq_result = cirq.Simulator().simulate(
circuit, initial_state=np.copy(wf)).final_state
np.testing.assert_array_almost_equal(tf_result, cirq_result)
def _many_clifford_to_many_z(pauli_sum):
"""Convert many clifford to many Z.
Returns the gate set required for transforming an arbitrary tensor product
of paulis into a product of all pauli -Z's.
Args:
pauli_sum: `cirq.PauliSum` object to be converted to all z's.
Returns:
gate_list: List of required gates to complete the transformation.
conjugate_list: List of gates, but reversed and complex conjugate
applied to each rotation gate
"""
# TODO(jaeyoo): investigate how to apply cirq.PauliString.to_z_basis_ops
gate_list = []
# Hermitian conjugate
conjugate_list = []
for qubit, pauli in pauli_sum.items():
if isinstance(pauli, cirq.ZPowGate):
continue
elif isinstance(pauli, cirq.XPowGate):
gate_list.append(cirq.H(qubit))
conjugate_list.append(cirq.H(qubit))
elif isinstance(pauli, cirq.YPowGate):
# It is identical to the conjugate of Phase and Hadamard gate up to
# global phase. This global phase difference is gone with
# multiplication of hermition conjugate later.
gate_list.append(cirq.Rx(np.pi / 2)(qubit))
conjugate_list.append(cirq.Rx(-np.pi / 2)(qubit))
return gate_list, conjugate_list[::-1]
def _apply_unitary_(self, args: cirq.ApplyUnitaryArgs
) -> Optional[np.ndarray]:
if cirq.is_parameterized(self):
return None
am = cirq.unitary(cirq.Rx(-np.pi * self.exponent * self.weights[0]))
bm = cirq.unitary(cirq.Rx(-np.pi * self.exponent * self.weights[1]))
cm = cirq.unitary(cirq.Rx(-np.pi * self.exponent * self.weights[2]))
a1 = args.subspace_index(0b1001)
b1 = args.subspace_index(0b0101)
c1 = args.subspace_index(0b0011)
a2 = args.subspace_index(0b0110)
b2 = args.subspace_index(0b1010)
c2 = args.subspace_index(0b1100)
cirq.apply_matrix_to_slices(args.target_tensor,
am,
slices=[a1, a2],
out=args.available_buffer)
cirq.apply_matrix_to_slices(args.available_buffer,
bm,
slices=[b1, b2],
out=args.target_tensor)
return cirq.apply_matrix_to_slices(args.target_tensor,
cm,
slices=[c1, c2],
out=args.available_buffer)
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'
def test_dynamic_single_qubit_rotations():
a, b, c = cirq.LineQubit.range(3)
t = sympy.Symbol('t')
# Dynamic single qubit rotations.
assert_url_to_circuit_returns(
'{"cols":[["X^t","Y^t","Z^t"],["X^-t","Y^-t","Z^-t"]]}',
cirq.Circuit(
cirq.X(a)**t,
cirq.Y(b)**t,
cirq.Z(c)**t,
cirq.X(a)**-t,
cirq.Y(b)**-t,
cirq.Z(c)**-t,
))
assert_url_to_circuit_returns(
'{"cols":[["e^iXt","e^iYt","e^iZt"],["e^-iXt","e^-iYt","e^-iZt"]]}',
cirq.Circuit(
cirq.Rx(2 * sympy.pi * t).on(a),
cirq.Ry(2 * sympy.pi * t).on(b),
cirq.Rz(2 * sympy.pi * t).on(c),
cirq.Rx(2 * sympy.pi * -t).on(a),
cirq.Ry(2 * sympy.pi * -t).on(b),
cirq.Rz(2 * sympy.pi * -t).on(c),
))
def test_rxyz_exponent(theta, exp):
def resolve(gate):
return cirq.resolve_parameters(gate, {'theta': np.pi / 4}, {'exp': 1 / 4})
assert resolve(cirq.Rx(rads=theta) ** exp) == resolve(cirq.Rx(rads=theta * exp))
assert resolve(cirq.Ry(rads=theta) ** exp) == resolve(cirq.Ry(rads=theta * exp))
assert resolve(cirq.Rz(rads=theta) ** exp) == resolve(cirq.Rz(rads=theta * exp))
def test_many_clifford_to_many_z(self):
"""Confirm correct basis transformations of input PauliSums."""
q = cirq.GridQubit.rect(1, 4)
test_term = 0.2277 * cirq.Z(q[1]) * cirq.X(q[2]) * cirq.Y(q[3])
test_basis_gates = [cirq.H(q[2]), cirq.Rx(np.pi / 2)(q[3])]
test_conj_gates = [cirq.Rx(-np.pi / 2)(q[3]), cirq.H(q[2])]
gate_list, conj_gate_list = util._many_clifford_to_many_z(test_term)
self.assertEqual(gate_list, test_basis_gates)
self.assertEqual(conj_gate_list, test_conj_gates)
def _gen_single_bit_rotation_problem(bit, symbols):
"""Generate a toy problem on 1 qubit."""
starting_state = np.random.uniform(0, 2 * np.pi, 3)
circuit = cirq.Circuit(
cirq.Rx(starting_state[0])(bit),
cirq.Ry(starting_state[1])(bit),
cirq.Rz(starting_state[2])(bit),
cirq.Rz(symbols[2])(bit),
cirq.Ry(symbols[1])(bit),
cirq.Rx(symbols[0])(bit))
return circuit
def test_parametrize(self):
"""Tests that parametrize yields the correct queue of operations."""
operation = CirqOperation(
lambda a, b, c:
[cirq.X, cirq.Ry(a),
cirq.Rx(b), cirq.Z,
cirq.Rz(c)])
operation.parametrize(0.1, 0.2, 0.3)
assert operation.parametrized_cirq_gates[0] == cirq.X
assert operation.parametrized_cirq_gates[1] == cirq.Ry(0.1)
assert operation.parametrized_cirq_gates[2] == cirq.Rx(0.2)
assert operation.parametrized_cirq_gates[3] == cirq.Z
assert operation.parametrized_cirq_gates[4] == cirq.Rz(0.3)
def main():
"""
HHL을 행렬 입력과 결과 큐비트 상태인 |x>의 파울리 측정 출력을 시뮬레이션하기.
기대되는 해 |x>로 부터 기대되는 관측량을 계산합니다.
"""
# 고유값분해 결과:
# >>> import numpy as np
# >>> x, y = np.linalg.eig(A)
# >>> [z for z in zip(list(x.astype(np.float32)), list(y))]
# [(4.537, array([ 0.9715551 +0.j , -0.05783371-0.22964251j])),
# (0.349, array([0.05783391-0.22964302j, 0.97155524+0.j ]))]
# |b> = (0.64510-0.47848j, 0.35490-0.47848j)
# |x> = (-0.0662724-0.214548j, 0.784392-0.578192j)
A = np.array([[4.30213466 - 6.01593490e-08j, 0.23531802 + 9.34386156e-01j],
[0.23531882 - 9.34388383e-01j,
0.58386534 + 6.01593489e-08j]])
t = 0.358166 * math.pi
register_size = 4
input_prep_gates = [cirq.Rx(1.276359), cirq.Rz(1.276359)]
expected = (0.144130, 0.413217, -0.899154)
# C를 회로에서 표현가능한 최소의 고유값에 맞춥니다.
C = 2 * math.pi / (2**register_size * t)
# 회로를 시뮬레이션합니다.
print("Expected observable outputs:")
print("X =", expected[0])
print("Y =", expected[1])
print("Z =", expected[2])
print("Actual: ")
simulate(hhl_circuit(A, C, t, register_size, *input_prep_gates))
def main():
"""
Simulates HHL with matrix input, and outputs Pauli observables of the
resulting qubit state |x>.
Expected observables are calculated from the expected solution |x>.
"""
# Eigendecomposition:
# (4.537, [-0.971555, -0.0578339+0.229643j])
# (0.349, [-0.236813, 0.237270-0.942137j])
# |b> = (0.64510-0.47848j, 0.35490-0.47848j)
# |x> = (-0.0662724-0.214548j, 0.784392-0.578192j)
A = np.array([[4.30213466-6.01593490e-08j,
0.23531802+9.34386156e-01j],
[0.23531882-9.34388383e-01j,
0.58386534+6.01593489e-08j]])
t = 0.358166*math.pi
register_size = 4
input_prep_gates = [cirq.Rx(1.276359), cirq.Rz(1.276359)]
expected = (0.144130, 0.413217, -0.899154)
# Set C to be the smallest eigenvalue that can be represented by the
# circuit.
C = 2*math.pi / (2**register_size * t)
# Simulate circuit
print("Expected observable outputs:")
print("X =", expected[0])
print("Y =", expected[1])
print("Z =", expected[2])
print("Actual: ")
simulate(hhl_circuit(A, C, t, register_size, *input_prep_gates))
def test_repr():
assert repr(cirq.X) == 'cirq.X'
assert repr(cirq.X**0.5) == '(cirq.X**0.5)'
assert repr(cirq.Z) == 'cirq.Z'
assert repr(cirq.Z**0.5) == 'cirq.S'
assert repr(cirq.Z**0.25) == 'cirq.T'
assert repr(cirq.Z**0.125) == '(cirq.Z**0.125)'
assert repr(cirq.S) == 'cirq.S'
assert repr(cirq.S**-1) == '(cirq.S**-1)'
assert repr(cirq.T) == 'cirq.T'
assert repr(cirq.T**-1) == '(cirq.T**-1)'
assert repr(cirq.Y) == 'cirq.Y'
assert repr(cirq.Y**0.5) == '(cirq.Y**0.5)'
assert repr(cirq.CNOT) == 'cirq.CNOT'
assert repr(cirq.CNOT**0.5) == '(cirq.CNOT**0.5)'
cirq.testing.assert_equivalent_repr(cirq.X**(sympy.Symbol('a') / 2 -
sympy.Symbol('c') * 3 + 5))
cirq.testing.assert_equivalent_repr(cirq.Rx(rads=sympy.Symbol('theta')))
cirq.testing.assert_equivalent_repr(cirq.Ry(rads=sympy.Symbol('theta')))
cirq.testing.assert_equivalent_repr(cirq.Rz(rads=sympy.Symbol('theta')))
# There should be no floating point error during initialization, and repr
# should be using the "shortest decimal value closer to X than any other
# floating point value" strategy, as opposed to the "exactly value in
# decimal" strategy.
assert repr(cirq.CZ**0.2) == '(cirq.CZ**0.2)'
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_controlled_pqc_simple_learn(self, backend, repetitions):
"""Test a simple learning scenario using analytic and sample expectation
on many backends."""
bit = cirq.GridQubit(0, 0)
circuit = \
cirq.Circuit(cirq.Rx(sympy.Symbol('theta'))(bit))
inputs = tf.keras.Input(shape=(1, ), dtype=tf.dtypes.float32)
quantum_datum = tf.keras.Input(shape=(), dtype=tf.dtypes.string)
l1 = tf.keras.layers.Dense(10)(inputs)
l2 = tf.keras.layers.Dense(1)(l1)
outputs = controlled_pqc.ControlledPQC(circuit,
cirq.Z(bit),
repetitions=repetitions,
backend=backend)(
[quantum_datum, l2])
model = tf.keras.Model(inputs=[quantum_datum, inputs], outputs=outputs)
data_in = np.array([[1], [0]], dtype=np.float32)
data_out = np.array([[1], [-1]], dtype=np.float32)
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.05),
loss=tf.keras.losses.mean_squared_error)
data_circuits = util.convert_to_tensor(
[cirq.Circuit(cirq.X(bit)),
cirq.Circuit()])
history = model.fit(x=[data_circuits, data_in], y=data_out, epochs=30)
self.assertAllClose(history.history['loss'][-1], 0, atol=1e-1)
def main():
"""
Simulates HHL with matrix input, and outputs Pauli observables of the
resulting qubit state |x>.
Expected observables are calculated from the expected solution |x>.
"""
# Eigendecomposition:
# >>> import numpy as np
# >>> x, y = np.linalg.eigh(A) # Eigendecomposition for a complex Hermitian matrix.
# >>> [z for z in zip(list(x.astype(np.float32)), list(np.transpose(y)))]
# [(0.34899944, array([-0.23681357+0.j, 0.23727026-0.94213702j])),
# (4.5370007, array([-0.97155511+0.j, -0.05783389+0.229643j]))]
# |b> = (0.64510-0.47848j, 0.35490-0.47848j)
# |x> = (-0.0662724-0.214548j, 0.784392-0.578192j)
A = np.array([[4.30213466 - 6.01593490e-08j, 0.23531802 + 9.34386156e-01j],
[0.23531882 - 9.34388383e-01j,
0.58386534 + 6.01593489e-08j]])
t = 0.358166 * math.pi
register_size = 4
input_prep_gates = [cirq.Rx(1.276359), cirq.Rz(1.276359)]
expected = (0.144130, 0.413217, -0.899154)
# Set C to be the smallest eigenvalue that can be represented by the
# circuit.
C = 2 * math.pi / (2**register_size * t)
# Simulate circuit
print("Expected observable outputs:")
print("X =", expected[0])
print("Y =", expected[1])
print("Z =", expected[2])
print("Actual: ")
simulate(hhl_circuit(A, C, t, register_size, *input_prep_gates))
def test_deprecated_rxyz_rotations(rads):
with capture_logging():
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 test_op_roundtrip_filename(tmpdir):
filename = f'{tmpdir}/op.json'
q = cirq.LineQubit(5)
op1 = cirq.Rx(.123).on(q)
cirq.to_json(op1, filename)
assert os.path.exists(filename)
op2 = cirq.read_json(filename)
assert op1 == op2
def cphase_to_sqrt_iswap(a, b, turns):
"""Implement a C-Phase gate using two sqrt ISWAP gates and single-qubit
operations. The circuit is equivalent to cirq.CZPowGate(exponent=turns).
Output unitary:
[1 0 0 0],
[0 1 0 0],
[0 0 1 0],
[0 0 0 e^{i turns pi}].
Args:
a: the first qubit
b: the second qubit
turns: Exponent specifying the evolution time in number of rotations.
"""
theta = (turns % 2) * np.pi
if 0 <= theta <= np.pi:
sign = 1.
theta_prime = theta
elif np.pi < theta < 2 * np.pi:
sign = -1.
theta_prime = 2 * np.pi - theta
if np.isclose(theta, np.pi):
# If we are close to pi, just set values manually to avoid possible
# numerical errors with arcsin of greater than 1.0 (Ahem, Windows).
phi = np.pi / 2
xi = np.pi / 2
else:
phi = np.arcsin(np.sqrt(2) * np.sin(theta_prime / 4))
xi = np.arctan(np.tan(phi) / np.sqrt(2))
yield cirq.Rz(sign * 0.5 * theta_prime).on(a)
yield cirq.Rz(sign * 0.5 * theta_prime).on(b)
yield cirq.Rx(xi).on(a)
yield cirq.X(b)**(-sign * 0.5)
yield SQRT_ISWAP_INV(a, b)
yield cirq.Rx(-2 * phi).on(a)
yield SQRT_ISWAP(a, b)
yield cirq.Rx(xi).on(a)
yield cirq.X(b)**(sign * 0.5)
# Corrects global phase
yield cirq.GlobalPhaseOperation(np.exp(sign * theta_prime * 0.25j))
def rot(qubit, params):
"""Helper function to return an arbitrary rotation of the form
R = Rz(params[2]) * Ry(params[1]) * Rx(params[0])
on the qubit.
"""
rx = cirq.Rx(rads=params[0])
ry = cirq.Ry(rads=params[1])
rz = cirq.Rz(rads=params[2])
yield (rx(qubit), ry(qubit), rz(qubit))
def test_apply(self):
"""Tests that the operations in the queue are correctly applied."""
operation = CirqOperation(
lambda a, b, c:
[cirq.X, cirq.Ry(a),
cirq.Rx(b), cirq.Z,
cirq.Rz(c)])
operation.parametrize(0.1, 0.2, 0.3)
qubit = cirq.LineQubit(1)
gate_applications = list(operation.apply(qubit))
assert gate_applications[0] == cirq.X.on(qubit)
assert gate_applications[1] == cirq.Ry(0.1).on(qubit)
assert gate_applications[2] == cirq.Rx(0.2).on(qubit)
assert gate_applications[3] == cirq.Z.on(qubit)
assert gate_applications[4] == cirq.Rz(0.3).on(qubit)
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.ms(np.pi / 4).on(op.qubits[0], op.qubits[1]),
cirq.Rx(-1 * np.pi / 2).on(op.qubits[0]),
cirq.Rx(-1 * np.pi / 2).on(op.qubits[1]),
cirq.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_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 _apply_unitary_(self, args: cirq.ApplyUnitaryArgs
) -> Optional[np.ndarray]:
if cirq.is_parameterized(self):
return None
inner_matrix = cirq.unitary(cirq.Rx(-2 * np.pi * self.exponent))
a = args.subspace_index(0b0011)
b = args.subspace_index(0b1100)
return cirq.apply_matrix_to_slices(args.target_tensor,
inner_matrix,
slices=[a, b],
out=args.available_buffer)
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_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 test_rx_unitary():
s = np.sqrt(0.5)
np.testing.assert_allclose(
cirq.unitary(cirq.Rx(np.pi / 2)),
np.array([[s, -s*1j], [-s*1j, s]]))
np.testing.assert_allclose(
cirq.unitary(cirq.Rx(-np.pi / 2)),
np.array([[s, s*1j], [s*1j, s]]))
np.testing.assert_allclose(
cirq.unitary(cirq.Rx(0)),
np.array([[1, 0], [0, 1]]))
np.testing.assert_allclose(
cirq.unitary(cirq.Rx(2 * np.pi)),
np.array([[-1, 0], [0, -1]]))
np.testing.assert_allclose(
cirq.unitary(cirq.Rx(np.pi)),
np.array([[0, -1j], [-1j, 0]]))
np.testing.assert_allclose(
cirq.unitary(cirq.Rx(-np.pi)),
np.array([[0, 1j], [1j, 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_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)
