def one_qubit_unitary(self, bit, symbols):
return cirq.Circuit(
cirq.X(bit)**symbols[0],
cirq.Y(bit)**symbols[1],
cirq.Z(bit)**symbols[2])
pass
undiagrammable_op = UndiagrammableGate()(qbits[1])
c_op = cirq.ControlledOperation(qbits[:1], undiagrammable_op)
assert cirq.circuit_diagram_info(c_op, default=None) is None
@pytest.mark.parametrize(
'gate',
[
cirq.X(cirq.NamedQubit('q1')),
cirq.X(cirq.NamedQubit('q1'))**0.5,
cirq.rx(np.pi)(cirq.NamedQubit('q1')),
cirq.rx(np.pi / 2)(cirq.NamedQubit('q1')),
cirq.Z(cirq.NamedQubit('q1')),
cirq.H(cirq.NamedQubit('q1')),
cirq.CNOT(cirq.NamedQubit('q1'), cirq.NamedQubit('q2')),
cirq.SWAP(cirq.NamedQubit('q1'), cirq.NamedQubit('q2')),
cirq.CCZ(cirq.NamedQubit('q1'), cirq.NamedQubit('q2'),
cirq.NamedQubit('q3')),
cirq.ControlledGate(cirq.ControlledGate(
cirq.CCZ))(*cirq.LineQubit.range(5)),
GateUsingWorkspaceForApplyUnitary()(cirq.NamedQubit('q1')),
GateAllocatingNewSpaceForResult()(cirq.NamedQubit('q1')),
],
)
def test_controlled_operation_is_consistent(gate: cirq.GateOperation):
cb = cirq.NamedQubit('ctr')
cgate = cirq.ControlledOperation([cb], gate)
cirq.testing.assert_implements_consistent_protocols(cgate)
@pytest.mark.parametrize('terms, expected_qubits', (
({}, ()),
({
cirq.I(q0): 1,
cirq.H(q0): 1e-3j
}, (q0, )),
({
cirq.X(q0): 1j,
cirq.H(q1): 2j
}, (q0, q1)),
({
cirq.Y(q0): -1,
cirq.CZ(q0, q1): 3e3
}, (q0, q1)),
({
cirq.Z(q0): -1j,
cirq.CNOT(q1, q2): 0.25
}, (q0, q1, q2)),
))
def test_linear_combination_of_operations_has_correct_qubits(
terms, expected_qubits):
combination = cirq.LinearCombinationOfOperations(terms)
assert combination.qubits == expected_qubits
@pytest.mark.parametrize('terms, expected_matrix', (
({}, np.array([0])),
({
cirq.I(q0): 2,
cirq.X(q0): 3,
cirq.Y(q0): 4,
def test_raises_for_non_commuting_paulis():
with pytest.raises(ValueError, match='commuting'):
cirq.PauliSumExponential(cirq.X(q0) + cirq.Z(q0), np.pi / 2)
def test_pauli_sum_exponential_parameterized_matrix_raises():
with pytest.raises(ValueError, match='parameterized'):
cirq.PauliSumExponential(
cirq.X(q0) + cirq.Z(q1), sympy.Symbol("theta")).matrix()
def generator(depth):
if depth <= 0:
yield cirq.CZ(q0, q1), cirq.Y(q0)
else:
yield cirq.X(q0), generator(depth - 1)
yield cirq.Z(q0)
'LineQid': [cirq.LineQid(0, 1),
cirq.LineQid(123, 2),
cirq.LineQid(-4, 5)],
'MeasurementGate': [
cirq.MeasurementGate(num_qubits=3, key='z'),
cirq.MeasurementGate(num_qubits=3,
key='z',
invert_mask=(True, False, True)),
cirq.MeasurementGate(num_qubits=3,
key='z',
invert_mask=(True, False),
qid_shape=(1, 2, 3)),
],
'Moment': [
cirq.Moment(operations=[cirq.X(Q0), cirq.Y(Q1),
cirq.Z(Q2)]),
],
'NO_NOISE':
cirq.NO_NOISE,
'NamedQubit':
cirq.NamedQubit('hi mom'),
'PauliString': [
cirq.PauliString({
Q0: cirq.X,
Q1: cirq.Y,
Q2: cirq.Z
}),
cirq.X(Q0) * cirq.Y(Q1) * 123
],
'PhaseDampingChannel':
cirq.PhaseDampingChannel(0.5),
def test_custom_circuit_gate():
a, b, c, d, e = cirq.LineQubit.range(5)
# Without name.
assert_url_to_circuit_returns(
'{"cols":[["~d3pq"],["Y"]],'
'"gates":[{"id":"~d3pq","circuit":{"cols":[["H"],["•","X"]]}}]}',
cirq.Circuit(
cirq.H(a),
cirq.X(b).controlled_by(a),
cirq.Y(a),
))
# With name.
assert_url_to_circuit_returns(
'{"cols":[["~d3pq"],["Y"]],'
'"gates":[{"id":"~d3pq","name":"test",'
'"circuit":{"cols":[["H"],["•","X"]]}}]}',
cirq.Circuit(
cirq.H(a),
cirq.X(b).controlled_by(a),
cirq.Y(a),
))
# With internal input.
assert_url_to_circuit_returns(
'{"cols":[["~a5ls"]],"gates":[{"id":"~a5ls",'
'"circuit":{"cols":[["inputA1","+=A1"]]}}]}',
cirq.Circuit(
cirq.contrib.quirk.QuirkArithmeticOperation('+=A1',
target=[b],
inputs=[[a]])))
# With external input.
assert_url_to_circuit_returns(
'{"cols":[["inputA1","~r79k"]],"gates":[{"id":"~r79k",'
'"circuit":{"cols":[["+=A1"]]}}]}',
cirq.Circuit(
cirq.contrib.quirk.QuirkArithmeticOperation('+=A1',
target=[b],
inputs=[[a]])))
# With external control.
assert_url_to_circuit_returns(
'{"cols":[["•",1,"~r79k"]],"gates":[{"id":"~r79k",'
'"circuit":{"cols":[["X"],["Y","Z"]]}}]}',
cirq.Circuit(
cirq.X(c).controlled_by(a),
cirq.Y(c).controlled_by(a),
cirq.Z(d).controlled_by(a)))
# With external and internal control.
assert_url_to_circuit_returns(
'{"cols":[["•",1,"~r79k"]],"gates":[{"id":"~r79k",'
'"circuit":{"cols":[["X"],["⊕","Z"]]}}]}',
cirq.Circuit(
cirq.X(c).controlled_by(a),
cirq.Y(c)**0.5,
cirq.Z(d).controlled_by(a, c),
cirq.Y(c)**-0.5))
# Broadcast input.
assert_url_to_circuit_returns(
'{"cols":[["~q1fh",1,1,"inputA2"]],"gates":[{"id":"~q1fh",'
'"circuit":{"cols":[["+=A2"],[1,"+=A2"],[1,"+=A2"]]}}]}',
cirq.Circuit(
cirq.contrib.quirk.QuirkArithmeticOperation('+=A2',
target=[a, b],
inputs=[[d, e]]),
cirq.contrib.quirk.QuirkArithmeticOperation('+=A2',
target=[b, c],
inputs=[[d, e]]),
cirq.contrib.quirk.QuirkArithmeticOperation('+=A2',
target=[b, c],
inputs=[[d, e]]),
))
# Nested custom gate.
assert_url_to_circuit_returns(
'{"cols":[["~gtnd"]],"gates":[{"id":"~ct36",'
'"circuit":{"cols":[["X"],["X"]]}},{"id":"~gtnd",'
'"circuit":{"cols":[["~ct36"],["~ct36"]]}}]}',
cirq.Circuit(cirq.X(a)) * 4)
# Nested custom gate wrong order.
with pytest.raises(ValueError, match='Unrecognized column entry'):
_ = quirk_json_to_circuit({
"cols": [["~gtnd"]],
"gates": [
{
"id": "~gtnd",
"circuit": {
"cols": [["~ct36"], ["~ct36"]]
}
},
{
"id": "~ct36",
"circuit": {
"cols": [["X"], ["X"]]
}
},
]
})
q0, q1 = cirq.GridQubit.rect(1, 2)
# Create a circuit on these qubits using the parameters you created above.
circuit = cirq.Circuit(
cirq.rx(a).on(q0),
cirq.ry(b).on(q1), cirq.CNOT(control=q0, target=q1))
SVGCircuit(circuit)
# Calculate a state vector with a=0.5 and b=-0.5.
resolver = cirq.ParamResolver({a: 0.5, b: -0.5})
output_state_vector = cirq.Simulator().simulate(circuit,
resolver).final_state_vector
output_state_vector
z0 = cirq.Z(q0)
qubit_map = {q0: 0, q1: 1}
z0.expectation_from_state_vector(output_state_vector, qubit_map).real
z0x1 = 0.5 * z0 + cirq.X(q1)
z0x1.expectation_from_state_vector(output_state_vector, qubit_map).real
# Rank 1 tensor containing 1 circuit.
circuit_tensor = tfq.convert_to_tensor([circuit])
print(circuit_tensor.shape)
print(circuit_tensor.dtype)
# Helper function for viz
def bitstring(bits):
return ''.join('0' if e else '1' for e in bits)
# Create two quantum and classical registers
qreg = [cirq.LineQubit(x) for x in range(2)]
circ = cirq.Circuit()
# Dictionary of operations for each message
message = {
"00": [],
"01": [cirq.X(qreg[0])],
"10": [cirq.Z(qreg[0])],
"11": [cirq.X(qreg[0]), cirq.Z(qreg[0])]
}
# Alice creates a bell pair
circ.append(cirq.H(qreg[0]))
circ.append(cirq.CNOT(qreg[0], qreg[1]))
# Alice picks a message to send
m = "01"
print("Alice's sent message =", m)
# Alice encodes her message with the appropriate quantum operations
circ.append(message[m])
# Bob measures in the Bell basis
qubits = cq.LineQubit(0).range(2)
# create an empty circuit
circuit = cq.Circuit()
# construct a simulator to run the circuit
sim = cq.google.XmonSimulator()
#%%
## The indexing of lineQubits is such that the high-order bit (top wire) is
## index 0.
## initialize starting state to |10>
circuit.append(cq.H(qubits[0]))
circuit.append(cq.Z(qubits[0]))
circuit.append(cq.H(qubits[1]))
# solution to puzzle 1-4
circuit.append(cq.H(qubits[0]))
circuit.append(cq.Z(qubits[0]))
circuit.append(cq.H(qubits[1]))
# finish with standard measurement on both bits
circuit.append(
[cq.MeasurementGate(key="q" + str(1 - i))(qubits[i]) for i in range(2)])
print(circuit)
#%%
(cirq.PhasedXPowGate(exponent=0.25, phase_exponent=0.125)(Q), True),
(cirq.XPowGate(exponent=0.5)(Q), True),
(cirq.YPowGate(exponent=0.25)(Q), True),
(cirq.ZPowGate(exponent=0.125)(Q), True),
(cirq.CZPowGate(exponent=0.5)(Q, Q2), False),
(cirq.CZ(Q, Q2), True),
(cirq.CNOT(Q, Q2), True),
(cirq.SWAP(Q, Q2), False),
(cirq.ISWAP(Q, Q2), False),
(cirq.CCNOT(Q, Q2, Q3), True),
(cirq.CCZ(Q, Q2, Q3), True),
(cirq.ParallelGate(cirq.X, num_copies=3)(Q, Q2, Q3), True),
(cirq.ParallelGate(cirq.Y, num_copies=3)(Q, Q2, Q3), True),
(cirq.ParallelGate(cirq.Z, num_copies=3)(Q, Q2, Q3), True),
(cirq.X(Q).controlled_by(Q2, Q3), True),
(cirq.Z(Q).controlled_by(Q2, Q3), True),
(cirq.ZPowGate(exponent=0.5)(Q).controlled_by(Q2, Q3), False),
],
)
def test_gateset(op: cirq.Operation, expected: bool):
gs = cirq_pasqal.PasqalGateset()
assert gs.validate(op) == expected
assert gs.validate(cirq.Circuit(op)) == expected
@pytest.mark.parametrize(
"op,expected",
[
(cirq.H(Q), True),
(cirq.HPowGate(exponent=0.5)(Q), False),
(cirq.PhasedXPowGate(exponent=0.25, phase_exponent=0.125)(Q), True),
def _all_operations(q0, q1, q2, q3, q4, include_measurments=True):
class DummyOperation(cirq.Operation, cirq.QasmConvertibleOperation,
cirq.CompositeOperation):
qubits = (q0, )
with_qubits = NotImplemented
def known_qasm_output(self, args):
return '// Dummy operation\n'
def default_decompose(self):
# Only used by test_output_unitary_same_as_qiskit
return () # coverage: ignore
class DummyCompositeOperation(cirq.Operation, cirq.CompositeOperation):
qubits = (q0, )
with_qubits = NotImplemented
def default_decompose(self):
return cirq.X(self.qubits[0])
def __repr__(self):
return 'DummyCompositeOperation()'
return (
cirq.Z(q0),
cirq.Z(q0)**.625,
cirq.Y(q0),
cirq.Y(q0)**.375,
cirq.X(q0),
cirq.X(q0)**.875,
cirq.H(q1),
cirq.CZ(q0, q1),
cirq.CZ(q0, q1)**0.25, # Requires 2-qubit decomposition
cirq.CNOT(q0, q1),
cirq.CNOT(q0, q1)**0.5, # Requires 2-qubit decomposition
cirq.SWAP(q0, q1),
cirq.SWAP(q0, q1)**0.75, # Requires 2-qubit decomposition
cirq.CCZ(q0, q1, q2),
cirq.CCX(q0, q1, q2),
cirq.CCZ(q0, q1, q2)**0.5,
cirq.CCX(q0, q1, q2)**0.5,
cirq.CSWAP(q0, q1, q2),
cirq.ISWAP(q2, q0), # Requires 2-qubit decomposition
cirq.google.ExpZGate()(q3),
cirq.google.ExpZGate(half_turns=0.75)(q3),
cirq.google.ExpWGate(axis_half_turns=0.125, half_turns=0.25)(q1),
cirq.google.Exp11Gate()(q0, q1),
# Requires 2-qubit decomposition
cirq.google.Exp11Gate(half_turns=1.25)(q0, q1),
(
cirq.MeasurementGate('xX')(q0),
cirq.MeasurementGate('x_a')(q2),
cirq.MeasurementGate('x?')(q1),
cirq.MeasurementGate('X')(q3),
cirq.MeasurementGate('_x')(q4),
cirq.MeasurementGate('x_a')(q2),
cirq.MeasurementGate('multi', (False, True))(q1, q2, q3),
) if include_measurments else (),
DummyOperation(),
DummyCompositeOperation(),
)
def test_complex_pad(self):
"""Test trickier padding."""
bit = cirq.GridQubit(0, 0)
bit2 = cirq.GridQubit(0, 1)
circuit = cirq.Circuit(
cirq.X(bit)**sympy.Symbol('alpha'),
cirq.Y(bit)**sympy.Symbol('alpha'),
cirq.Z(bit)**sympy.Symbol('alpha'),
cirq.XX(bit, bit2)**sympy.Symbol('alpha'))
circuit2 = cirq.Circuit(
cirq.X(bit)**sympy.Symbol('beta'),
cirq.Y(bit)**sympy.Symbol('beta'),
cirq.Z(bit)**sympy.Symbol('beta'),
cirq.XX(bit, bit2)**sympy.Symbol('alpha'))
circuit3 = cirq.Circuit(
cirq.X(bit)**sympy.Symbol('alpha'),
cirq.Y(bit)**sympy.Symbol('alpha'),
cirq.Z(bit)**sympy.Symbol('alpha'),
cirq.XX(bit, bit2)**sympy.Symbol('alpha'))
inputs = util.convert_to_tensor([circuit, circuit2, circuit3])
symbols = tf.convert_to_tensor(['alpha', 'beta', 'gamma'])
new = tf.convert_to_tensor(['new', 'old', 'nothing'])
res = tfq_ps_util_ops.tfq_ps_symbol_replace(inputs, symbols, new)
output = util.from_tensor(res)
correct_000 = cirq.Circuit(
cirq.X(bit)**sympy.Symbol('new'),
cirq.Y(bit)**sympy.Symbol('alpha'),
cirq.Z(bit)**sympy.Symbol('alpha'),
cirq.XX(bit, bit2)**sympy.Symbol('alpha'))
correct_001 = cirq.Circuit(
cirq.X(bit)**sympy.Symbol('alpha'),
cirq.Y(bit)**sympy.Symbol('new'),
cirq.Z(bit)**sympy.Symbol('alpha'),
cirq.XX(bit, bit2)**sympy.Symbol('alpha'))
correct_002 = cirq.Circuit(
cirq.X(bit)**sympy.Symbol('alpha'),
cirq.Y(bit)**sympy.Symbol('alpha'),
cirq.Z(bit)**sympy.Symbol('new'),
cirq.XX(bit, bit2)**sympy.Symbol('alpha'))
correct_003 = cirq.Circuit(
cirq.X(bit)**sympy.Symbol('alpha'),
cirq.Y(bit)**sympy.Symbol('alpha'),
cirq.Z(bit)**sympy.Symbol('alpha'),
cirq.XX(bit, bit2)**sympy.Symbol('new'))
self.assertEqual(correct_000, output[0][0][0])
self.assertEqual(correct_001, output[0][0][1])
self.assertEqual(correct_002, output[0][0][2])
self.assertEqual(correct_003, output[0][0][3])
self.assertEqual(correct_000, output[2][0][0])
self.assertEqual(correct_001, output[2][0][1])
self.assertEqual(correct_002, output[2][0][2])
self.assertEqual(correct_003, output[2][0][3])
correct_110 = cirq.Circuit(
cirq.X(bit)**sympy.Symbol('old'),
cirq.Y(bit)**sympy.Symbol('beta'),
cirq.Z(bit)**sympy.Symbol('beta'),
cirq.XX(bit, bit2)**sympy.Symbol('alpha'))
correct_111 = cirq.Circuit(
cirq.X(bit)**sympy.Symbol('beta'),
cirq.Y(bit)**sympy.Symbol('old'),
cirq.Z(bit)**sympy.Symbol('beta'),
cirq.XX(bit, bit2)**sympy.Symbol('alpha'))
correct_112 = cirq.Circuit(
cirq.X(bit)**sympy.Symbol('beta'),
cirq.Y(bit)**sympy.Symbol('beta'),
cirq.Z(bit)**sympy.Symbol('old'),
cirq.XX(bit, bit2)**sympy.Symbol('alpha'))
correct_113 = cirq.Circuit()
self.assertEqual(correct_110, output[1][1][0])
self.assertEqual(correct_111, output[1][1][1])
self.assertEqual(correct_112, output[1][1][2])
self.assertEqual(correct_113, output[1][1][3])
correct_100 = cirq.Circuit(
cirq.X(bit)**sympy.Symbol('beta'),
cirq.Y(bit)**sympy.Symbol('beta'),
cirq.Z(bit)**sympy.Symbol('beta'),
cirq.XX(bit, bit2)**sympy.Symbol('new'))
correct_101 = cirq.Circuit()
correct_102 = cirq.Circuit()
correct_103 = cirq.Circuit()
self.assertEqual(correct_100, output[1][0][0])
self.assertEqual(correct_101, output[1][0][1])
self.assertEqual(correct_102, output[1][0][2])
self.assertEqual(correct_103, output[1][0][3])
correct_220 = cirq.Circuit()
correct_221 = cirq.Circuit()
correct_222 = cirq.Circuit()
correct_223 = cirq.Circuit()
self.assertEqual(correct_220, output[2][2][0])
self.assertEqual(correct_221, output[2][2][1])
self.assertEqual(correct_222, output[2][2][2])
self.assertEqual(correct_223, output[2][2][3])
correct = cirq.Circuit()
for i in range(3):
for j in range(3):
for k in range(3):
if i != j and (not (i == 2 and j == 0)) \
and (not (i == 1 and j == 0)):
self.assertEqual(correct, output[i][j][k])
def optimal_givens_decomposition(
qubits: Sequence[cirq.Qid],
unitary: numpy.ndarray) -> Iterable[cirq.Operation]:
r"""
Implement a circuit that provides the unitary that is generated by
single-particle fermion generators
.. math::
U(v) = exp(log(v)_{p,q}(a_{p}^{\dagger}a_{q} - a_{q}^{\dagger}a_{p})
This can be used for implementing an exact single-body basis rotation
Args:
qubits: Sequence of qubits to apply the operations over. The qubits
should be ordered in linear physical order.
unitary:
"""
N = unitary.shape[0]
right_rotations = []
left_rotations = []
for i in range(1, N):
if i % 2 == 1:
for j in range(0, i):
# eliminate U[N - j, i - j] by mixing U[N - j, i - j],
# U[N - j, i - j - 1] by right multiplication
# of a givens rotation matrix in column [i - j, i - j + 1]
gmat = givens_matrix_elements(unitary[N - j - 1, i - j - 1],
unitary[N - j - 1,
i - j - 1 + 1],
which='left')
right_rotations.append((gmat.T, (i - j - 1, i - j)))
givens_rotate(unitary,
gmat.conj(),
i - j - 1,
i - j,
which='col')
else:
for j in range(1, i + 1):
# elimination of U[N + j - i, j] by mixing U[N + j - i, j] and
# U[N + j - i - 1, j] by left multiplication
# of a givens rotation that rotates row space
# [N + j - i - 1, N + j - i
gmat = givens_matrix_elements(unitary[N + j - i - 1 - 1,
j - 1],
unitary[N + j - i - 1, j - 1],
which='right')
left_rotations.append((gmat, (N + j - i - 2, N + j - i - 1)))
givens_rotate(unitary,
gmat,
N + j - i - 2,
N + j - i - 1,
which='row')
new_left_rotations = []
for (left_gmat, (i, j)) in reversed(left_rotations):
phase_matrix = numpy.diag([unitary[i, i], unitary[j, j]])
matrix_to_decompose = left_gmat.conj().T.dot(phase_matrix)
new_givens_matrix = givens_matrix_elements(matrix_to_decompose[1, 0],
matrix_to_decompose[1, 1],
which='left')
new_phase_matrix = matrix_to_decompose.dot(new_givens_matrix.T)
# check if T_{m,n}^{-1}D = D T.
# coverage: ignore
if not numpy.allclose(new_phase_matrix.dot(new_givens_matrix.conj()),
matrix_to_decompose):
raise GivensTranspositionError("Failed to shift the phase matrix "
"from right to left")
# coverage: ignore
unitary[i, i], unitary[j, j] = new_phase_matrix[0,
0], new_phase_matrix[1,
1]
new_left_rotations.append((new_givens_matrix.conj(), (i, j)))
phases = numpy.diag(unitary)
rotations = []
ordered_rotations = []
for (gmat, (i, j)) in list(reversed(new_left_rotations)) + list(
map(lambda x: (x[0].conj().T, x[1]), reversed(right_rotations))):
ordered_rotations.append((gmat, (i, j)))
# if this throws the impossible has happened
# coverage: ignore
if not numpy.isclose(gmat[0, 0].imag, 0.0):
raise GivensMatrixError(
"Givens matrix does not obey our convention that all elements "
"in the first column are real")
if not numpy.isclose(gmat[1, 0].imag, 0.0):
raise GivensMatrixError(
"Givens matrix does not obey our convention that all elements "
"in the first column are real")
# coverage: ignore
theta = numpy.arcsin(numpy.real(gmat[1, 0]))
phi = numpy.angle(gmat[1, 1])
rotations.append((i, j, theta, phi))
for op in reversed(rotations):
i, j, theta, phi = cast(Tuple[int, int, float, float], op)
if not numpy.isclose(phi, 0.0):
yield cirq.Z(qubits[j])**(phi / numpy.pi)
yield Ryxxy(-theta).on(qubits[i], qubits[j])
for idx, phase in enumerate(phases):
yield cirq.Z(qubits[idx])**(numpy.angle(phase) / numpy.pi)
def test_commutes():
assert cirq.commutes(cirq.ZPowGate(exponent=sympy.Symbol('t')), cirq.Z)
assert cirq.commutes(cirq.Z, cirq.Z(cirq.LineQubit(0)),
default=None) is None
assert cirq.commutes(cirq.Z**0.1, cirq.XPowGate(exponent=0))
OPERATIONS = [
(cirq.X(Q0), X_PROTO),
(
cirq.Y(Q0),
op_proto({
'ypowgate': {
'exponent': {
'float_value': 1.0
}
},
'qubit_constant_index': [0],
}),
),
(
cirq.Z(Q0),
op_proto({
'zpowgate': {
'exponent': {
'float_value': 1.0
}
},
'qubit_constant_index': [0],
}),
),
(
cirq.XPowGate(exponent=0.125)(Q1),
op_proto({
'xpowgate': {
'exponent': {
'float_value': 0.125
def bernstein(error_correct=False):
API_TOKEN = '7cf33cd2f0d7044af8518c33321fa74d7380d3ba58d08b271404e8226aa1f5490818ba86e1635f89e6c3cfbf10aa091ff04c1f5ff61f0f391ed780b4484e0b18'
# initialize qiskit
IBMQ.save_account(API_TOKEN)
provider = IBMQ.load_account()
print(provider.backends())
backend = provider.backends.ibmq_16_melbourne
# initialize qubits with architecture in mind
qubits = [cirq.GridQubit(0, 5), cirq.GridQubit(1, 4),\
cirq.GridQubit(0, 6), cirq.GridQubit(2, 5),\
cirq.GridQubit(2, 3), cirq.GridQubit(1, 5),\
cirq.GridQubit(3, 4), cirq.GridQubit(2, 4)]
if error_correct:
error_qubits = [cirq.GridQubit(3, 4), cirq.GridQubit(3, 3),\
cirq.GridQubit(3, 2), cirq.GridQubit(4, 3)]
# construct circuit
circuit = cirq.Circuit()
# error correction setup. error correct qubit (2,3)
if error_correct:
circuit.append([cirq.CNOT(qubits[2], error_qubits[1])])
circuit.append([cirq.SWAP(error_qubits[0], error_qubits[1])])
circuit.append([cirq.CNOT(qubits[2], error_qubits[1])])
circuit.append([cirq.SWAP(error_qubits[0], error_qubits[1])])
# hadamards
circuit.append([cirq.H(q) for q in qubits])
# turn helper qubit to 1
circuit.append([cirq.Z(qubits[7])])
# oracle
circuit.append([cirq.CNOT(qubits[1], qubits[7])])
circuit.append([cirq.CNOT(qubits[3], qubits[7])])
circuit.append([cirq.CNOT(qubits[4], qubits[7])])
circuit.append([cirq.CNOT(qubits[6], qubits[7])])
# hadamards
circuit.append([cirq.H(q) for q in qubits[:-1]])
# error detection and correction
if error_correct:
circuit.append([cirq.SWAP(error_qubits[2], error_qubits[1])])
circuit.append([cirq.CNOT(qubits[2], error_qubits[1])])
circuit.append([cirq.SWAP(error_qubits[2], error_qubits[1])])
circuit.append([cirq.CNOT(error_qubits[1], error_qubits[2])])
circuit.append([cirq.SWAP(error_qubits[3], error_qubits[1])])
circuit.append([cirq.CNOT(qubits[2], error_qubits[1])])
circuit.append([cirq.CNOT(error_qubits[0], error_qubits[1])])
circuit.append([cirq.SWAP(error_qubits[1], error_qubits[3])])
circuit.append(
[cirq.measure(error_qubits[2]),
cirq.measure(error_qubits[3])])
circuit.append(
[cirq.CCNOT(qubits[2], error_qubits[1], error_qubits[0])])
# measure
circuit.append([cirq.measure(q) for q in qubits[:-1]])
# export to qasm
qasm_str = circuit.to_qasm()
# import qiskit from qasm
qiskit_circuit = qiskitqc.from_qasm_str(qasm_str)
# run qiskit
transpiled = transpile(qiskit_circuit, backend)
qobj = assemble(transpiled, backend, shots=100)
job = backend.run(qobj)
print(job.job_id())
result = job.result()
counts = result.get_counts()
delayed_result = backend.retrieve_job(job.job_id()).result()
delayed_counts = delayed_result.get_counts()
print(counts)
print(delayed_counts)
return requests.post(url, json=job_payload)
def test_is_supported():
q0, q1 = cirq.GridQubit.rect(1, 2)
assert MY_GATE_SET.is_supported(cirq.Circuit(cirq.X(q0), cirq.X(q1)))
assert not MY_GATE_SET.is_supported(cirq.Circuit(cirq.X(q0), cirq.Z(q1)))
def _decompose_(self, qs):
for i in range(n):
Rz = cirq.Z(qs[n]) ** (gamma * objs[i])
yield Rz.controlled_by(qs[i])
def test_raises_for_non_commuting_paulis():
with pytest.raises(ValueError, match='commuting'):
cirq.PauliSumExponential(cirq.X(q0) + cirq.Z(q0), np.pi / 2)
def test_raises_for_non_hermitian_pauli():
with pytest.raises(ValueError, match='hermitian'):
cirq.PauliSumExponential(cirq.X(q0) + 1j * cirq.Z(q1), np.pi / 2)
@pytest.mark.parametrize(
'psum_exp, expected_qubits',
(
(cirq.PauliSumExponential(cirq.Z(q1), np.pi / 2), (q1, )),
(
cirq.PauliSumExponential(2j * cirq.X(q0) + 3j * cirq.Y(q2),
sympy.Symbol("theta")),
(q0, q2),
),
(
cirq.PauliSumExponential(
cirq.X(q0) * cirq.Y(q1) + cirq.Y(q2) * cirq.Z(q3), np.pi),
(q0, q1, q2, q3),
),
),
)
def test_pauli_sum_exponential_qubits(psum_exp, expected_qubits):
assert psum_exp.qubits == expected_qubits
circuit = cq.Circuit()
# construct a simulator to run the circuit
sim = cq.google.XmonSimulator()
#%%
## The indexing of lineQubits is such that the high-order bit (top wire) is
## index 0.
## initialize starting state to |11>
circuit.append([cq.X(qubits[0]), cq.X(qubits[1])])
# solution to puzzle 1-9
circuit.append([cq.H(qubits[0]), cq.H(qubits[1])])
circuit.append([cq.Z(qubits[0]), cq.Z(qubits[1])])
circuit.append([cq.H(qubits[0]), cq.H(qubits[1])])
# finish with standard measurement on both bits
circuit.append(
[cq.MeasurementGate(key="q" + str(1 - i))(qubits[i]) for i in range(2)])
print(circuit)
#%%
# "Run" the computation 20 times.
result = sim.run(circuit, repetitions=20)
# view results
print(result)
def test_raises_for_non_hermitian_pauli():
with pytest.raises(ValueError, match='hermitian'):
cirq.PauliSumExponential(cirq.X(q0) + 1j * cirq.Z(q1), np.pi / 2)
def noisy_operation(self, operation: 'cirq.Operation'):
return cirq.Z(operation.qubits[0]).with_tags(ops.VirtualTag())
def _decompose_(self, qubits):
a, b = qubits
yield cirq.Z(a)
yield cirq.S(b)
yield cirq.X(a)
assert props_v2 != props
gpe_op_id_0 = cirq.OpIdentifier(cirq.PhasedXZGate, q0)
gpe_op_id_1 = cirq.OpIdentifier(cirq.PhasedXZGate, q1)
assert props_v2.gate_pauli_errors[gpe_op_id_0] == expected_vals['gate_pauli_errors']
assert props_v2.gate_pauli_errors[gpe_op_id_1] == expected_vals['gate_pauli_errors']
fsim_op_id_0 = cirq.OpIdentifier(cirq.CZPowGate, q0, q1)
fsim_op_id_1 = cirq.OpIdentifier(cirq.CZPowGate, q1, q0)
assert props_v2.fsim_errors[fsim_op_id_0] == expected_vals['fsim_errors']
assert props_v2.fsim_errors[fsim_op_id_1] == expected_vals['fsim_errors']
@pytest.mark.parametrize(
'op',
[
(cirq.Z(cirq.LineQubit(0)) ** 0.3).with_tags(cirq_google.PhysicalZTag),
cirq.PhasedXZGate(x_exponent=0.8, z_exponent=0.2, axis_phase_exponent=0.1).on(
cirq.LineQubit(0)
),
],
)
def test_single_qubit_gates(op):
q0 = cirq.LineQubit(0)
props = sample_noise_properties([q0], [])
model = NoiseModelFromGoogleNoiseProperties(props)
circuit = cirq.Circuit(op)
noisy_circuit = circuit.with_noise(model)
assert len(noisy_circuit.moments) == 3
assert len(noisy_circuit.moments[0].operations) == 1
assert noisy_circuit.moments[0].operations[0] == op.with_tags(PHYSICAL_GATE_TAG)
import time
import cirq
import numpy as np
from functools import reduce
q = [cirq.NamedQubit('q' + str(i)) for i in range(11)]
circuit = cirq.Circuit(cirq.Z(q[0]), cirq.H(q[9]), cirq.H(q[0]),
cirq.CNOT(q[9], q[10]), cirq.CNOT(q[0], q[3]),
cirq.CNOT(q[0], q[6]), cirq.CZ(q[0], q[3]),
cirq.CZ(q[0], q[6]), cirq.H(q[0]), cirq.H(q[3]),
cirq.H(q[6]), cirq.Z(q[0]), cirq.Z(q[3]), cirq.Z(q[6]),
cirq.CNOT(q[0], q[1]), cirq.CNOT(q[3], q[4]),
cirq.CNOT(q[6], q[7]), cirq.CNOT(q[0], q[2]),
cirq.CNOT(q[3], q[5]), cirq.CNOT(q[6], q[8]),
cirq.CZ(q[0], q[1]), cirq.CZ(q[3], q[4]),
cirq.CZ(q[6], q[7]), cirq.CZ(q[0], q[2]),
cirq.CZ(q[3], q[5]), cirq.CZ(q[6], q[8]),
cirq.CNOT(q[0], q[9]), cirq.measure(q[9], key='c9'),
cirq.H(q[0]), cirq.CNOT(q[9], q[10]),
cirq.measure(q[0], key='c0'), cirq.CZ(q[0], q[10]),
cirq.CNOT(q[10], q[1]), cirq.CNOT(q[10], q[2]),
cirq.CNOT(q[3], q[4]), cirq.CNOT(q[6], q[7]),
cirq.CNOT(q[3], q[5]), cirq.CNOT(q[6], q[8]),
cirq.CZ(q[10], q[1]), cirq.CZ(q[10], q[2]),
cirq.CZ(q[3], q[4]), cirq.CZ(q[6], q[7]),
cirq.CZ(q[3], q[5]), cirq.CZ(q[6], q[8]),
cirq.CCX(q[1], q[2], q[10]), cirq.CCX(q[5], q[4], q[3]),
cirq.CCX(q[8], q[7], q[6]), cirq.H(q[10]),
cirq.CCX(q[1], q[2], q[10]), cirq.H(q[3]), cirq.H(q[6]),
cirq.H(q[10]), cirq.CCX(q[5], q[4], q[3]),
cirq.CCX(q[8], q[7], q[6]), cirq.H(q[10]), cirq.H(q[3]),
cirq.H(q[6]), cirq.Z(q[10]), cirq.H(q[3]), cirq.H(q[6]),
def prepare_multiplexed(states,
control_qubits,
target_qubit,
GRAY_CODE=True,
REVERSE_ZS=True):
assert len(states) == 2**len(control_qubits)
assert all(abs(np.linalg.norm(state) - 1.0) < 1e-6 for state in states)
n = len(control_qubits)
thetas = [2 * np.arccos(state[0].real) / np.pi for state in states]
phis = [np.angle(state[1]) / np.pi for state in states]
circuit = cirq.Circuit()
if GRAY_CODE:
# Loading Gray code in bs
bs = [[0]]
nums = [0]
for i in range(n):
bs = [[0] + b for b in bs] + [[1] + b for b in reversed(bs)]
nums += [x + 2**i for x in reversed(nums)]
else:
# Loading regular order of bitstrings in bs
bs = [tuple(map(int, f"{i:0{n}b}")) for i in range(2**n)]
nums = list(range(2**n))
if REVERSE_ZS:
# Implement multiplexed Ry
for b, c in zip(bs[:-1], bs[1:]):
theta = (sum((-1)**sum(x * y for x, y in zip(b, d)) * thetas[j]
for j, d in zip(nums, bs)) / 2**n)
circuit.append(cirq.Y(target_qubit)**theta)
circuit.append(
cirq.CNOT(control_qubits[j], target_qubit)
for j, (x, y) in enumerate(zip(b, c)) if x != y)
b = bs[-1]
theta = (sum((-1)**sum(x * y for x, y in zip(b, d)) * thetas[j]
for j, d in enumerate(bs)) / 2**n)
circuit.append(cirq.Y(target_qubit)**theta)
# Implement reverse of multiplexed Rz
phi = (sum((-1)**sum(x * y for x, y in zip(b, d)) * phis[j]
for j, d in zip(nums, bs)) / 2**n)
circuit.append(cirq.Z(target_qubit)**phi)
for c, b in zip(bs[-1:0:-1], bs[-2::-1]):
circuit.append(
cirq.CNOT(control_qubits[j], target_qubit)
for j, (x, y) in enumerate(zip(b, c)) if x != y)
phi = (sum((-1)**sum(x * y for x, y in zip(b, d)) * phis[j]
for j, d in zip(nums, bs)) / 2**n)
circuit.append(cirq.Z(target_qubit)**phi)
else:
# Implement multiplexed Ry
for b, c in zip(bs, bs[1:] + [bs[0]]):
theta = (sum((-1)**sum(x * y for x, y in zip(b, d)) * thetas[j]
for j, d in zip(nums, bs)) / 2**n)
circuit.append(cirq.Y(target_qubit)**theta)
circuit.append(
cirq.CNOT(control_qubits[j], target_qubit)
for j, (x, y) in enumerate(zip(b, c)) if x != y)
# Implement multiplexed Rz
for b, c in zip(bs, bs[1:] + [bs[0]]):
phi = (sum((-1)**sum(x * y for x, y in zip(b, d)) * phis[j]
for j, d in zip(nums, bs)) / 2**n)
circuit.append(cirq.Z(target_qubit)**phi)
circuit.append(
cirq.CNOT(control_qubits[j], target_qubit)
for j, (x, y) in enumerate(zip(b, c)) if x != y)
return circuit
def test_group_settings_greedy_hydrogen():
qubits = cirq.LineQubit.range(4)
q0, q1, q2, q3 = qubits
terms = [
0.1711977489805745 * cirq.Z(q0),
0.17119774898057447 * cirq.Z(q1),
-0.2227859302428765 * cirq.Z(q2),
-0.22278593024287646 * cirq.Z(q3),
0.16862219157249939 * cirq.Z(q0) * cirq.Z(q1),
0.04532220205777764 * cirq.Y(q0) * cirq.X(q1) * cirq.X(q2) *
cirq.Y(q3),
-0.0453222020577776 * cirq.Y(q0) * cirq.Y(q1) * cirq.X(q2) *
cirq.X(q3),
-0.0453222020577776 * cirq.X(q0) * cirq.X(q1) * cirq.Y(q2) *
cirq.Y(q3),
0.04532220205777764 * cirq.X(q0) * cirq.Y(q1) * cirq.Y(q2) *
cirq.X(q3),
0.12054482203290037 * cirq.Z(q0) * cirq.Z(q2),
0.16586702409067802 * cirq.Z(q0) * cirq.Z(q3),
0.16586702409067802 * cirq.Z(q1) * cirq.Z(q2),
0.12054482203290037 * cirq.Z(q1) * cirq.Z(q3),
0.1743484418396392 * cirq.Z(q2) * cirq.Z(q3),
]
settings = cirq.work.observables_to_settings(terms, qubits)
grouped_settings = cirq.work.group_settings_greedy(settings)
assert len(grouped_settings) == 5
group_max_obs_should_be = [
cirq.Y(q0) * cirq.X(q1) * cirq.X(q2) * cirq.Y(q3),
cirq.Y(q0) * cirq.Y(q1) * cirq.X(q2) * cirq.X(q3),
cirq.X(q0) * cirq.X(q1) * cirq.Y(q2) * cirq.Y(q3),
cirq.X(q0) * cirq.Y(q1) * cirq.Y(q2) * cirq.X(q3),
cirq.Z(q0) * cirq.Z(q1) * cirq.Z(q2) * cirq.Z(q3),
]
group_max_settings_should_be = cirq.work.observables_to_settings(
group_max_obs_should_be, qubits)
assert set(grouped_settings.keys()) == set(group_max_settings_should_be)
groups = list(grouped_settings.values())
assert len(groups[0]) == 1
assert len(groups[1]) == 1
assert len(groups[2]) == 1
assert len(groups[3]) == 1
assert len(groups[4]) == len(terms) - 4
def to_cirq(self, input_cirq_qubits=None):
"""Convert to a cirq gate.
Args:
input_cirq_qubits: list[cirq.LineQubit]
(optional) a list of cirq Qubits that the gate can act on. If not provided
the function will generate new cirq.LineQubit objects.
Returns:
A cirq Circuit object that corresponds to the specification of the quantum gate.
In the special case the gate itself was natively generated from cirq, the function
will faithfully reproduce the original GateOperation object, taking into account
whether the gate acts on GridQubit objects or LineQubit objects.
In the other cases the resulting cirq gate simply assumes that the qubits are
LineQubit objects.
"""
if self.name not in ALL_GATES:
sys.exit("Gate {} currently not supported.".format(self.name))
q_inds = []
q_inds.append(self.qubits[0].index)
if len(self.qubits) >= 2:
q_inds.append(self.qubits[1].index)
if len(self.qubits) >= 3:
q_inds.append(self.qubits[2].index)
cirq_qubits = []
if input_cirq_qubits == None:
for q in self.qubits:
if q.info["label"] == "cirq":
qkey = q.info["QubitKey"]
if q.info["QubitType"] == "GridQubit":
cirq_qubits.append(cirq.GridQubit(qkey[0], qkey[1]))
if q.info["QubitType"] == "LineQubit":
cirq_qubits.append(cirq.LineQubit(qkey))
else:
cirq_qubits.append(cirq.LineQubit(q.index))
else:
cirq_qubits = [
input_cirq_qubits[x] for x in [q.index for q in self.qubits]
]
if len(self.params) > 0:
params = self.params
# single-qubit gates
if self.name == "I": # Identity
return cirq.I(cirq_qubits[0])
if self.name == "X": # Pauli X
return cirq.X(cirq_qubits[0])
if self.name == "Y": # Pauli Y
return cirq.Y(cirq_qubits[0])
if self.name == "Z": # Pauli Z
return cirq.Z(cirq_qubits[0])
if self.name == "H": # Hadamard
return cirq.H(cirq_qubits[0])
if self.name == "S": # S gate
return cirq.S(cirq_qubits[0])
if self.name == "T": # T gate
return cirq.T(cirq_qubits[0])
if self.name == "Rx": # Single-qubit X rotation
return cirq.rx(params[0])(cirq_qubits[0])
if self.name == "Ry": # Single-qubit Y rotation
return cirq.ry(params[0])(cirq_qubits[0])
if self.name == "Rz": # Single-qubit Z rotation
return cirq.rz(params[0])(cirq_qubits[0])
if self.name == "PHASE": # Phase gate
return cirq.Z(cirq_qubits[0])**(params[0] / pi)
if self.name == "ZXZ": # PhasedXPowGate gate
g = cirq.PhasedXPowGate(phase_exponent=params[0] / pi,
exponent=params[1] / pi)
return g(cirq_qubits[0])
if self.name == "RH": # HPowGate
g = cirq.H**(params[0] / pi)
return g(cirq_qubits[0])
if self.name == "Da": # Damping alpha gate
g = DampingAlpha(params[0])
return g(cirq_qubits[0])
if self.name == "Db": # Damping beta gate
g = DampingBeta(params[0])
return g(cirq_qubits[0])
# two-qubit gates
if self.name == "CNOT":
return cirq.CNOT(cirq_qubits[0], cirq_qubits[1])
if self.name == "CZ":
return cirq.CZ(cirq_qubits[0], cirq_qubits[1])
if self.name == "CPHASE":
return cirq.CZPowGate(exponent=params[0] / pi)(cirq_qubits[0],
cirq_qubits[1])
if self.name == "SWAP":
return cirq.SWAP(cirq_qubits[0], cirq_qubits[1])
if self.name == "XX":
return cirq.XX(cirq_qubits[0],
cirq_qubits[1])**(params[0] * 2 / pi)
if self.name == "YY":
return cirq.YY(cirq_qubits[0],
cirq_qubits[1])**(params[0] * 2 / pi)
if self.name == "ZZ":
return cirq.ZZ(cirq_qubits[0],
cirq_qubits[1])**(params[0] * 2 / pi)
