def your_circuit(oracle):
# Phase kickback
yield cirq.X(q2), cirq.H(q2)
# Superposition over input bits
yield cirq.H(q0), cirq.H(q1)
# Query the function
yield oracle
# Interference to get result,
# put last qubit in to |1> state
yield cirq.H(q0), cirq.H(q1), cirq.H(q2)
# A final OR gate to put the result
# in to the final qubit
yield cirq.X(q0), cirq.X(q1), cirq.CCX(q0, q1, q2)
# Perform measurement
yield cirq.measure(q2)
def test_assert_same_circuits():
a, b = cirq.LineQubit.range(2)
cirq.testing.assert_same_circuits(cirq.Circuit(cirq.H(a)),
cirq.Circuit(cirq.H(a)))
with pytest.raises(AssertionError) as exc_info:
cirq.testing.assert_same_circuits(cirq.Circuit(cirq.H(a)),
cirq.Circuit())
assert 'differing moment:\n0\n' in exc_info.value.args[0]
with pytest.raises(AssertionError) as exc_info:
cirq.testing.assert_same_circuits(
cirq.Circuit(cirq.H(a), cirq.H(a)),
cirq.Circuit(cirq.H(a), cirq.CZ(a, b)))
assert 'differing moment:\n1\n' in exc_info.value.args[0]
with pytest.raises(AssertionError):
cirq.testing.assert_same_circuits(
cirq.Circuit(cirq.CNOT(a, b)),
cirq.Circuit(cirq.ControlledGate(cirq.X).on(a, b)))
def test_basic_inputs(self):
"""Test that State layer outputs work end to end."""
simple_circuit = cirq.Circuit(cirq.H(cirq.GridQubit(0, 0)))
cirq_u = cirq.unitary(simple_circuit)
tfq_u = unitary.Unitary()(simple_circuit)
self.assertAllClose(tfq_u, [cirq_u])
def correct(self, qubits: List[cirq.Qid],
ancillas: List[cirq.Qid]) -> cirq.Circuit:
"""Corrects the code word.
Creates a correction circuit by computing the syndrome on the ancillas, and then using this
syndrome to correct the qubits.
Args:
qubits: a vector of self.n qubits that contains (potentially corrupted) code words
ancillas: a vector of self.n - self.k qubits that are set to zero and will contain the
syndrome once the circuit is applied.
Returns:
The circuit that both computes the syndrome and uses this syndrome to correct errors.
"""
circuit = cirq.Circuit()
gate_dict = {'X': cirq.X, 'Y': cirq.Y, 'Z': cirq.Z}
# We set the ancillas so that measuring them directly would be the same
# as measuring the qubits with Pauli strings. In other words, we store
# the syndrome inside the ancillas.
for r in range(self.n - self.k):
for n in range(self.n):
if self.M[r][n] == 'Z':
circuit.append(
cirq.ControlledOperation([qubits[n]],
cirq.X(ancillas[r])))
elif self.M[r][n] == 'X':
circuit.append(cirq.H(qubits[n]))
circuit.append(
cirq.ControlledOperation([qubits[n]],
cirq.X(ancillas[r])))
circuit.append(cirq.H(qubits[n]))
elif self.M[r][n] == 'Y':
circuit.append(cirq.S(qubits[n])**-1)
circuit.append(cirq.H(qubits[n]))
circuit.append(
cirq.ControlledOperation([qubits[n]],
cirq.X(ancillas[r])))
circuit.append(cirq.H(qubits[n]))
circuit.append(cirq.S(qubits[n]))
# At this stage, the ancillas are equal to the syndrome. Now, we apply
# the errors back to correct the code.
for syndrome, correction in self.syndromes_to_corrections.items():
op = gate_dict[correction[0]]
n = correction[1]
# We do a Boolean operation on the ancillas (i.e. syndrome).
for r in range(self.n - self.k):
if syndrome[r] == 1:
circuit.append(cirq.X(ancillas[r]))
circuit.append(cirq.ControlledOperation(ancillas, op(qubits[n])))
for r in range(self.n - self.k):
if syndrome[r] == 1:
circuit.append(cirq.X(ancillas[r]))
return circuit
def get_circuit():
"""Gets circuit."""
q = cirq.LineQubit.range(12)
circuit = cirq.Circuit.from_ops(*[
[cirq.X(q[0])**0.5,
cirq.H(q[0])**0.5,
cirq.X(q[0])**-0.5],
[cirq.X(q[1])**0.5,
cirq.H(q[1])**0.5,
cirq.X(q[1])**-0.5],
[cirq.X(q[2])**0.5,
cirq.H(q[2])**0.5,
cirq.X(q[2])**-0.5],
cirq.Y(q[3])**0.5,
[cirq.X(q[4])**0.5,
cirq.H(q[4])**0.5,
cirq.X(q[4])**-0.5],
cirq.Y(q[5])**0.5,
cirq.X(q[6])**0.5,
cirq.X(q[7])**0.5,
cirq.X(q[8])**0.5,
cirq.X(q[9])**0.5,
cirq.Y(q[10])**0.5,
[cirq.X(q[11])**0.5,
cirq.H(q[11])**0.5,
cirq.X(q[11])**-0.5],
cirq.Rz(rads=0.2767373377033284 * np.pi).on(q[1]),
cirq.Rz(rads=-0.18492941569567625 * np.pi).on(q[2]),
cirq.Rz(rads=-1.00125113388313 * np.pi).on(q[5]),
cirq.Rz(rads=1.1224546746752684 * np.pi).on(q[6]),
cirq.Rz(rads=-0.33113463396189063 * np.pi).on(q[9]),
cirq.Rz(rads=0.40440704518468423 * np.pi).on(q[10]),
[
cirq.ISWAP(q[1], q[2])**-1.009868884178167,
cirq.CZ(q[1], q[2])**-0.16552586798219657,
],
[
cirq.ISWAP(q[5], q[6])**-0.9733750299685556,
cirq.CZ(q[5], q[6])**-0.16091330726740966,
],
[
cirq.ISWAP(q[9], q[10])**-0.9769678680475263,
cirq.CZ(q[9], q[10])**-0.16332605888196952,
],
cirq.Rz(rads=-0.6722145774944012 * np.pi).on(q[1]),
cirq.Rz(rads=0.7640224995020534 * np.pi).on(q[2]),
cirq.Rz(rads=0.7990757781248072 * np.pi).on(q[5]),
cirq.Rz(rads=-0.6778722373326689 * np.pi).on(q[6]),
cirq.Rz(rads=0.049341949396894985 * np.pi).on(q[9]),
cirq.Rz(rads=0.02393046182589869 * np.pi).on(q[10]),
cirq.Y(q[0])**0.5,
cirq.X(q[1])**0.5,
cirq.Y(q[2])**0.5,
[cirq.X(q[3])**0.5,
cirq.H(q[3])**0.5,
cirq.X(q[3])**-0.5],
cirq.Y(q[4])**0.5,
[cirq.X(q[5])**0.5,
cirq.H(q[5])**0.5,
cirq.X(q[5])**-0.5],
cirq.Y(q[6])**0.5,
cirq.Y(q[7])**0.5,
cirq.Y(q[8])**0.5,
[cirq.X(q[9])**0.5,
cirq.H(q[9])**0.5,
cirq.X(q[9])**-0.5],
[cirq.X(q[10])**0.5,
cirq.H(q[10])**0.5,
cirq.X(q[10])**-0.5],
cirq.Y(q[11])**0.5,
cirq.Rz(rads=2.5333591271878086 * np.pi).on(q[0]),
cirq.Rz(rads=-2.4748096263683066 * np.pi).on(q[1]),
cirq.Rz(rads=-4.480708067260001 * np.pi).on(q[2]),
cirq.Rz(rads=4.525888267898699 * np.pi).on(q[3]),
cirq.Rz(rads=2.135954522972214 * np.pi).on(q[4]),
cirq.Rz(rads=-2.1822665205802965 * np.pi).on(q[5]),
cirq.Rz(rads=-3.7780476633662574 * np.pi).on(q[6]),
cirq.Rz(rads=3.817335880513747 * np.pi).on(q[7]),
cirq.Rz(rads=0.7811374803446167 * np.pi).on(q[8]),
cirq.Rz(rads=-0.6780279413275597 * np.pi).on(q[9]),
cirq.Rz(rads=1.863573798571082 * np.pi).on(q[10]),
cirq.Rz(rads=-2.150412392135508 * np.pi).on(q[11]),
[
cirq.ISWAP(q[0], q[1])**-0.8242343706275942,
cirq.CZ(q[0], q[1])**-0.15468164635790926,
],
[
cirq.ISWAP(q[2], q[3])**-0.981653050634976,
cirq.CZ(q[2], q[3])**-0.1933349989832593,
],
[
cirq.ISWAP(q[4], q[5])**-0.9637565510028211,
cirq.CZ(q[4], q[5])**-0.15186761578643612,
],
[
cirq.ISWAP(q[6], q[7])**-1.0089894642925605,
cirq.CZ(q[6], q[7])**-0.17298943435986638,
],
[
cirq.ISWAP(q[8], q[9])**-0.980271915828302,
cirq.CZ(q[8], q[9])**-0.16470994863165317,
],
[
cirq.ISWAP(q[10], q[11])**-0.9290392306402181,
cirq.CZ(q[10], q[11])**-0.1664963204791881,
],
cirq.Rz(rads=-2.346072351850546 * np.pi).on(q[0]),
cirq.Rz(rads=2.404621852670048 * np.pi).on(q[1]),
cirq.Rz(rads=5.048199817882042 * np.pi).on(q[2]),
cirq.Rz(rads=-5.0030196172433445 * np.pi).on(q[3]),
cirq.Rz(rads=-2.6543362735839113 * np.pi).on(q[4]),
cirq.Rz(rads=2.6080242759758283 * np.pi).on(q[5]),
cirq.Rz(rads=3.9045088495271663 * np.pi).on(q[6]),
cirq.Rz(rads=-3.8652206323796765 * np.pi).on(q[7]),
cirq.Rz(rads=-1.5516585295358842 * np.pi).on(q[8]),
cirq.Rz(rads=1.6547680685529413 * np.pi).on(q[9]),
cirq.Rz(rads=-1.8933072151541963 * np.pi).on(q[10]),
cirq.Rz(rads=1.6064686215897703 * np.pi).on(q[11]),
cirq.X(q[0])**0.5,
cirq.Y(q[1])**0.5,
cirq.X(q[2])**0.5,
cirq.Y(q[3])**0.5,
cirq.X(q[4])**0.5,
cirq.X(q[5])**0.5,
cirq.X(q[6])**0.5,
[cirq.X(q[7])**0.5,
cirq.H(q[7])**0.5,
cirq.X(q[7])**-0.5],
cirq.X(q[8])**0.5,
cirq.X(q[9])**0.5,
cirq.X(q[10])**0.5,
cirq.X(q[11])**0.5,
cirq.Rz(rads=-3.2786928385561493 * np.pi).on(q[4]),
cirq.Rz(rads=3.339006443218924 * np.pi).on(q[8]),
cirq.Rz(rads=-5.390755870544794 * np.pi).on(q[5]),
cirq.Rz(rads=5.4172568990486605 * np.pi).on(q[9]),
cirq.Rz(rads=-5.620144773112766 * np.pi).on(q[6]),
cirq.Rz(rads=5.630469153514815 * np.pi).on(q[10]),
cirq.Rz(rads=4.367652291347506 * np.pi).on(q[7]),
cirq.Rz(rads=-3.9105776028384707 * np.pi).on(q[11]),
[
cirq.ISWAP(q[4], q[8])**-1.0121115249769066,
cirq.CZ(q[4], q[8])**-0.16059979031178617,
],
[
cirq.ISWAP(q[5], q[9])**-0.985003985982119,
cirq.CZ(q[5], q[9])**-0.16606010863938203,
],
[
cirq.ISWAP(q[6], q[10])**-0.9628319095031052,
cirq.CZ(q[6], q[10])**-0.16339300450568622,
],
[
cirq.ISWAP(q[7], q[11])**-0.9999941453695372,
cirq.CZ(q[7], q[11])**-0.16477879415124544,
],
cirq.Rz(rads=2.9425087256630427 * np.pi).on(q[4]),
cirq.Rz(rads=-2.882195121000268 * np.pi).on(q[8]),
cirq.Rz(rads=4.466531408750767 * np.pi).on(q[5]),
cirq.Rz(rads=-4.440030380246901 * np.pi).on(q[9]),
cirq.Rz(rads=4.486471496440378 * np.pi).on(q[6]),
cirq.Rz(rads=-4.476147116038329 * np.pi).on(q[10]),
cirq.Rz(rads=-4.89701654221443 * np.pi).on(q[7]),
cirq.Rz(rads=5.354091230723465 * np.pi).on(q[11]),
[cirq.X(q[0])**0.5,
cirq.H(q[0])**0.5,
cirq.X(q[0])**-0.5],
[cirq.X(q[1])**0.5,
cirq.H(q[1])**0.5,
cirq.X(q[1])**-0.5],
[cirq.X(q[2])**0.5,
cirq.H(q[2])**0.5,
cirq.X(q[2])**-0.5],
[cirq.X(q[3])**0.5,
cirq.H(q[3])**0.5,
cirq.X(q[3])**-0.5],
[cirq.X(q[4])**0.5,
cirq.H(q[4])**0.5,
cirq.X(q[4])**-0.5],
[cirq.X(q[5])**0.5,
cirq.H(q[5])**0.5,
cirq.X(q[5])**-0.5],
cirq.Y(q[6])**0.5,
cirq.Y(q[7])**0.5,
[cirq.X(q[8])**0.5,
cirq.H(q[8])**0.5,
cirq.X(q[8])**-0.5],
[cirq.X(q[9])**0.5,
cirq.H(q[9])**0.5,
cirq.X(q[9])**-0.5],
cirq.Y(q[10])**0.5,
[cirq.X(q[11])**0.5,
cirq.H(q[11])**0.5,
cirq.X(q[11])**-0.5],
cirq.Rz(rads=12.703597923836748 * np.pi).on(q[0]),
cirq.Rz(rads=-12.7869629079138 * np.pi).on(q[4]),
cirq.Rz(rads=12.184253063938954 * np.pi).on(q[1]),
cirq.Rz(rads=-12.108584830758572 * np.pi).on(q[5]),
cirq.Rz(rads=3.782562501914174 * np.pi).on(q[2]),
cirq.Rz(rads=-3.873596611893716 * np.pi).on(q[6]),
cirq.Rz(rads=4.772639843256901 * np.pi).on(q[3]),
cirq.Rz(rads=-4.771314675186062 * np.pi).on(q[7]),
[
cirq.ISWAP(q[0], q[4])**-0.933831313649303,
cirq.CZ(q[0], q[4])**-0.1583933739924931,
],
[
cirq.ISWAP(q[1], q[5])**-0.9390847780661252,
cirq.CZ(q[1], q[5])**-0.17144555428591543,
],
[
cirq.ISWAP(q[2], q[6])**-1.0209160715892363,
cirq.CZ(q[2], q[6])**-0.14849009270439747,
],
[
cirq.ISWAP(q[3], q[7])**-1.0287988330229174,
cirq.CZ(q[3], q[7])**-0.1385888562342036,
],
cirq.Rz(rads=-12.477250219528523 * np.pi).on(q[0]),
cirq.Rz(rads=12.39388523545147 * np.pi).on(q[4]),
cirq.Rz(rads=-11.31088974563283 * np.pi).on(q[1]),
cirq.Rz(rads=11.386557978813212 * np.pi).on(q[5]),
cirq.Rz(rads=-5.4898636407973544 * np.pi).on(q[2]),
cirq.Rz(rads=5.398829530817813 * np.pi).on(q[6]),
cirq.Rz(rads=-5.863871460773714 * np.pi).on(q[3]),
cirq.Rz(rads=5.8651966288445525 * np.pi).on(q[7]),
cirq.X(q[0])**0.5,
cirq.X(q[1])**0.5,
cirq.Y(q[2])**0.5,
cirq.X(q[3])**0.5,
cirq.X(q[4])**0.5,
cirq.X(q[5])**0.5,
[cirq.X(q[6])**0.5,
cirq.H(q[6])**0.5,
cirq.X(q[6])**-0.5],
[cirq.X(q[7])**0.5,
cirq.H(q[7])**0.5,
cirq.X(q[7])**-0.5],
cirq.Y(q[8])**0.5,
cirq.X(q[9])**0.5,
cirq.X(q[10])**0.5,
cirq.Y(q[11])**0.5,
cirq.Rz(rads=5.16073733770325 * np.pi).on(q[1]),
cirq.Rz(rads=-5.068929415695599 * np.pi).on(q[2]),
cirq.Rz(rads=-4.701251133883051 * np.pi).on(q[5]),
cirq.Rz(rads=4.82245467467519 * np.pi).on(q[6]),
cirq.Rz(rads=-3.587134633961795 * np.pi).on(q[9]),
cirq.Rz(rads=3.6604070451845887 * np.pi).on(q[10]),
[
cirq.ISWAP(q[1], q[2])**-1.009868884178167,
cirq.CZ(q[1], q[2])**-0.16552586798219657,
],
[
cirq.ISWAP(q[5], q[6])**-0.9733750299685556,
cirq.CZ(q[5], q[6])**-0.16091330726740966,
],
[
cirq.ISWAP(q[9], q[10])**-0.9769678680475263,
cirq.CZ(q[9], q[10])**-0.16332605888196952,
],
cirq.Rz(rads=-5.556214577494324 * np.pi).on(q[1]),
cirq.Rz(rads=5.648022499501975 * np.pi).on(q[2]),
cirq.Rz(rads=4.499075778124728 * np.pi).on(q[5]),
cirq.Rz(rads=-4.37787223733259 * np.pi).on(q[6]),
cirq.Rz(rads=3.305341949396799 * np.pi).on(q[9]),
cirq.Rz(rads=-3.232069538174005 * np.pi).on(q[10]),
[cirq.X(q[0])**0.5,
cirq.H(q[0])**0.5,
cirq.X(q[0])**-0.5],
[cirq.X(q[1])**0.5,
cirq.H(q[1])**0.5,
cirq.X(q[1])**-0.5],
cirq.X(q[2])**0.5,
cirq.Y(q[3])**0.5,
cirq.Y(q[4])**0.5,
cirq.Y(q[5])**0.5,
cirq.Y(q[6])**0.5,
cirq.X(q[7])**0.5,
[cirq.X(q[8])**0.5,
cirq.H(q[8])**0.5,
cirq.X(q[8])**-0.5],
cirq.Y(q[9])**0.5,
cirq.Y(q[10])**0.5,
[cirq.X(q[11])**0.5,
cirq.H(q[11])**0.5,
cirq.X(q[11])**-0.5],
cirq.Rz(rads=7.565359127187911 * np.pi).on(q[0]),
cirq.Rz(rads=-7.506809626368408 * np.pi).on(q[1]),
cirq.Rz(rads=-15.28470806725993 * np.pi).on(q[2]),
cirq.Rz(rads=15.329888267898626 * np.pi).on(q[3]),
cirq.Rz(rads=7.019954522972137 * np.pi).on(q[4]),
cirq.Rz(rads=-7.066266520580219 * np.pi).on(q[5]),
cirq.Rz(rads=-13.842047663366333 * np.pi).on(q[6]),
cirq.Rz(rads=13.881335880513822 * np.pi).on(q[7]),
cirq.Rz(rads=3.001137480344569 * np.pi).on(q[8]),
cirq.Rz(rads=-2.8980279413275123 * np.pi).on(q[9]),
cirq.Rz(rads=5.563573798571002 * np.pi).on(q[10]),
cirq.Rz(rads=-5.8504123921354285 * np.pi).on(q[11]),
[
cirq.ISWAP(q[0], q[1])**-0.8242343706275942,
cirq.CZ(q[0], q[1])**-0.15468164635790926,
],
[
cirq.ISWAP(q[2], q[3])**-0.981653050634976,
cirq.CZ(q[2], q[3])**-0.1933349989832593,
],
[
cirq.ISWAP(q[4], q[5])**-0.9637565510028211,
cirq.CZ(q[4], q[5])**-0.15186761578643612,
],
[
cirq.ISWAP(q[6], q[7])**-1.0089894642925605,
cirq.CZ(q[6], q[7])**-0.17298943435986638,
],
[
cirq.ISWAP(q[8], q[9])**-0.980271915828302,
cirq.CZ(q[8], q[9])**-0.16470994863165317,
],
[
cirq.ISWAP(q[10], q[11])**-0.9290392306402181,
cirq.CZ(q[10], q[11])**-0.1664963204791881,
],
cirq.Rz(rads=-7.378072351850649 * np.pi).on(q[0]),
cirq.Rz(rads=7.436621852670151 * np.pi).on(q[1]),
cirq.Rz(rads=15.852199817881967 * np.pi).on(q[2]),
cirq.Rz(rads=-15.80701961724327 * np.pi).on(q[3]),
cirq.Rz(rads=-7.538336273583833 * np.pi).on(q[4]),
cirq.Rz(rads=7.492024275975751 * np.pi).on(q[5]),
cirq.Rz(rads=13.968508849527241 * np.pi).on(q[6]),
cirq.Rz(rads=-13.929220632379753 * np.pi).on(q[7]),
cirq.Rz(rads=-3.771658529535837 * np.pi).on(q[8]),
cirq.Rz(rads=3.874768068552894 * np.pi).on(q[9]),
cirq.Rz(rads=-5.593307215154117 * np.pi).on(q[10]),
cirq.Rz(rads=5.30646862158969 * np.pi).on(q[11]),
cirq.X(q[0])**0.5,
cirq.X(q[1])**0.5,
[cirq.X(q[2])**0.5,
cirq.H(q[2])**0.5,
cirq.X(q[2])**-0.5],
cirq.X(q[3])**0.5,
cirq.X(q[4])**0.5,
[cirq.X(q[5])**0.5,
cirq.H(q[5])**0.5,
cirq.X(q[5])**-0.5],
cirq.X(q[6])**0.5,
cirq.Y(q[7])**0.5,
cirq.X(q[8])**0.5,
cirq.X(q[9])**0.5,
[cirq.X(q[10])**0.5,
cirq.H(q[10])**0.5,
cirq.X(q[10])**-0.5],
cirq.X(q[11])**0.5,
cirq.Rz(rads=-8.162692838556204 * np.pi).on(q[4]),
cirq.Rz(rads=8.223006443218978 * np.pi).on(q[8]),
cirq.Rz(rads=-12.938755870544817 * np.pi).on(q[5]),
cirq.Rz(rads=12.965256899048683 * np.pi).on(q[9]),
cirq.Rz(rads=-12.724144773112773 * np.pi).on(q[6]),
cirq.Rz(rads=12.73446915351482 * np.pi).on(q[10]),
cirq.Rz(rads=11.027652291347495 * np.pi).on(q[7]),
cirq.Rz(rads=-10.570577602838458 * np.pi).on(q[11]),
[
cirq.ISWAP(q[4], q[8])**-1.0121115249769066,
cirq.CZ(q[4], q[8])**-0.16059979031178617,
],
[
cirq.ISWAP(q[5], q[9])**-0.985003985982119,
cirq.CZ(q[5], q[9])**-0.16606010863938203,
],
[
cirq.ISWAP(q[6], q[10])**-0.9628319095031052,
cirq.CZ(q[6], q[10])**-0.16339300450568622,
],
[
cirq.ISWAP(q[7], q[11])**-0.9999941453695372,
cirq.CZ(q[7], q[11])**-0.16477879415124544,
],
cirq.Rz(rads=7.826508725663096 * np.pi).on(q[4]),
cirq.Rz(rads=-7.7661951210003215 * np.pi).on(q[8]),
cirq.Rz(rads=12.014531408750791 * np.pi).on(q[5]),
cirq.Rz(rads=-11.988030380246926 * np.pi).on(q[9]),
cirq.Rz(rads=11.590471496440383 * np.pi).on(q[6]),
cirq.Rz(rads=-11.580147116038336 * np.pi).on(q[10]),
cirq.Rz(rads=-11.55701654221442 * np.pi).on(q[7]),
cirq.Rz(rads=12.014091230723457 * np.pi).on(q[11]),
[cirq.X(q[0])**0.5,
cirq.H(q[0])**0.5,
cirq.X(q[0])**-0.5],
[cirq.X(q[1])**0.5,
cirq.H(q[1])**0.5,
cirq.X(q[1])**-0.5],
cirq.Y(q[2])**0.5,
[cirq.X(q[3])**0.5,
cirq.H(q[3])**0.5,
cirq.X(q[3])**-0.5],
[cirq.X(q[4])**0.5,
cirq.H(q[4])**0.5,
cirq.X(q[4])**-0.5],
cirq.X(q[5])**0.5,
cirq.Y(q[6])**0.5,
cirq.X(q[7])**0.5,
cirq.Y(q[8])**0.5,
[cirq.X(q[9])**0.5,
cirq.H(q[9])**0.5,
cirq.X(q[9])**-0.5],
cirq.X(q[10])**0.5,
[cirq.X(q[11])**0.5,
cirq.H(q[11])**0.5,
cirq.X(q[11])**-0.5],
cirq.Rz(rads=26.023597923836856 * np.pi).on(q[0]),
cirq.Rz(rads=-26.106962907913907 * np.pi).on(q[4]),
cirq.Rz(rads=25.356253063938887 * np.pi).on(q[1]),
cirq.Rz(rads=-25.2805848307585 * np.pi).on(q[5]),
cirq.Rz(rads=8.370562501914259 * np.pi).on(q[2]),
cirq.Rz(rads=-8.461596611893802 * np.pi).on(q[6]),
cirq.Rz(rads=10.100639843256841 * np.pi).on(q[3]),
cirq.Rz(rads=-10.099314675186001 * np.pi).on(q[7]),
[
cirq.ISWAP(q[0], q[4])**-0.933831313649303,
cirq.CZ(q[0], q[4])**-0.1583933739924931,
],
[
cirq.ISWAP(q[1], q[5])**-0.9390847780661252,
cirq.CZ(q[1], q[5])**-0.17144555428591543,
],
[
cirq.ISWAP(q[2], q[6])**-1.0209160715892363,
cirq.CZ(q[2], q[6])**-0.14849009270439747,
],
[
cirq.ISWAP(q[3], q[7])**-1.0287988330229174,
cirq.CZ(q[3], q[7])**-0.1385888562342036,
],
cirq.Rz(rads=-25.79725021952863 * np.pi).on(q[0]),
cirq.Rz(rads=25.713885235451578 * np.pi).on(q[4]),
cirq.Rz(rads=-24.48288974563276 * np.pi).on(q[1]),
cirq.Rz(rads=24.55855797881315 * np.pi).on(q[5]),
cirq.Rz(rads=-10.07786364079744 * np.pi).on(q[2]),
cirq.Rz(rads=9.986829530817898 * np.pi).on(q[6]),
cirq.Rz(rads=-11.191871460773655 * np.pi).on(q[3]),
cirq.Rz(rads=11.193196628844492 * np.pi).on(q[7]),
cirq.X(q[0])**0.5,
cirq.X(q[1])**0.5,
cirq.X(q[2])**0.5,
cirq.Y(q[3])**0.5,
cirq.Y(q[4])**0.5,
[cirq.X(q[5])**0.5,
cirq.H(q[5])**0.5,
cirq.X(q[5])**-0.5],
[cirq.X(q[6])**0.5,
cirq.H(q[6])**0.5,
cirq.X(q[6])**-0.5],
[cirq.X(q[7])**0.5,
cirq.H(q[7])**0.5,
cirq.X(q[7])**-0.5],
[cirq.X(q[8])**0.5,
cirq.H(q[8])**0.5,
cirq.X(q[8])**-0.5],
cirq.X(q[9])**0.5,
[cirq.X(q[10])**0.5,
cirq.H(q[10])**0.5,
cirq.X(q[10])**-0.5],
cirq.Y(q[11])**0.5,
cirq.Rz(rads=10.044737337703173 * np.pi).on(q[1]),
cirq.Rz(rads=-9.952929415695523 * np.pi).on(q[2]),
cirq.Rz(rads=-8.401251133882973 * np.pi).on(q[5]),
cirq.Rz(rads=8.52245467467511 * np.pi).on(q[6]),
cirq.Rz(rads=-6.843134633961698 * np.pi).on(q[9]),
cirq.Rz(rads=6.916407045184491 * np.pi).on(q[10]),
[
cirq.ISWAP(q[1], q[2])**-1.009868884178167,
cirq.CZ(q[1], q[2])**-0.16552586798219657,
],
[
cirq.ISWAP(q[5], q[6])**-0.9733750299685556,
cirq.CZ(q[5], q[6])**-0.16091330726740966,
],
[
cirq.ISWAP(q[9], q[10])**-0.9769678680475263,
cirq.CZ(q[9], q[10])**-0.16332605888196952,
],
cirq.Rz(rads=-10.440214577494247 * np.pi).on(q[1]),
cirq.Rz(rads=10.5320224995019 * np.pi).on(q[2]),
cirq.Rz(rads=8.199075778124648 * np.pi).on(q[5]),
cirq.Rz(rads=-8.07787223733251 * np.pi).on(q[6]),
cirq.Rz(rads=6.561341949396702 * np.pi).on(q[9]),
cirq.Rz(rads=-6.48806953817391 * np.pi).on(q[10]),
cirq.Y(q[0])**0.5,
cirq.Y(q[1])**0.5,
cirq.Y(q[2])**0.5,
cirq.X(q[3])**0.5,
cirq.X(q[4])**0.5,
cirq.Y(q[5])**0.5,
cirq.Y(q[6])**0.5,
cirq.X(q[7])**0.5,
cirq.X(q[8])**0.5,
[cirq.X(q[9])**0.5,
cirq.H(q[9])**0.5,
cirq.X(q[9])**-0.5],
cirq.Y(q[10])**0.5,
[cirq.X(q[11])**0.5,
cirq.H(q[11])**0.5,
cirq.X(q[11])**-0.5],
cirq.Rz(rads=12.597359127188014 * np.pi).on(q[0]),
cirq.Rz(rads=-12.538809626368511 * np.pi).on(q[1]),
cirq.Rz(rads=-26.08870806725985 * np.pi).on(q[2]),
cirq.Rz(rads=26.13388826789855 * np.pi).on(q[3]),
cirq.Rz(rads=11.90395452297206 * np.pi).on(q[4]),
cirq.Rz(rads=-11.950266520580142 * np.pi).on(q[5]),
cirq.Rz(rads=-23.906047663366408 * np.pi).on(q[6]),
cirq.Rz(rads=23.945335880513902 * np.pi).on(q[7]),
cirq.Rz(rads=5.221137480344522 * np.pi).on(q[8]),
cirq.Rz(rads=-5.118027941327464 * np.pi).on(q[9]),
cirq.Rz(rads=9.263573798570924 * np.pi).on(q[10]),
cirq.Rz(rads=-9.55041239213535 * np.pi).on(q[11]),
[
cirq.ISWAP(q[0], q[1])**-0.8242343706275942,
cirq.CZ(q[0], q[1])**-0.15468164635790926,
],
[
cirq.ISWAP(q[2], q[3])**-0.981653050634976,
cirq.CZ(q[2], q[3])**-0.1933349989832593,
],
[
cirq.ISWAP(q[4], q[5])**-0.9637565510028211,
cirq.CZ(q[4], q[5])**-0.15186761578643612,
],
[
cirq.ISWAP(q[6], q[7])**-1.0089894642925605,
cirq.CZ(q[6], q[7])**-0.17298943435986638,
],
[
cirq.ISWAP(q[8], q[9])**-0.980271915828302,
cirq.CZ(q[8], q[9])**-0.16470994863165317,
],
[
cirq.ISWAP(q[10], q[11])**-0.9290392306402181,
cirq.CZ(q[10], q[11])**-0.1664963204791881,
],
cirq.Rz(rads=-12.410072351850753 * np.pi).on(q[0]),
cirq.Rz(rads=12.468621852670255 * np.pi).on(q[1]),
cirq.Rz(rads=26.656199817881895 * np.pi).on(q[2]),
cirq.Rz(rads=-26.611019617243198 * np.pi).on(q[3]),
cirq.Rz(rads=-12.422336273583753 * np.pi).on(q[4]),
cirq.Rz(rads=12.376024275975672 * np.pi).on(q[5]),
cirq.Rz(rads=24.032508849527318 * np.pi).on(q[6]),
cirq.Rz(rads=-23.993220632379824 * np.pi).on(q[7]),
cirq.Rz(rads=-5.991658529535789 * np.pi).on(q[8]),
cirq.Rz(rads=6.094768068552847 * np.pi).on(q[9]),
cirq.Rz(rads=-9.293307215154037 * np.pi).on(q[10]),
cirq.Rz(rads=9.006468621589612 * np.pi).on(q[11]),
[cirq.X(q[0])**0.5,
cirq.H(q[0])**0.5,
cirq.X(q[0])**-0.5],
cirq.X(q[1])**0.5,
cirq.X(q[2])**0.5,
[cirq.X(q[3])**0.5,
cirq.H(q[3])**0.5,
cirq.X(q[3])**-0.5],
[cirq.X(q[4])**0.5,
cirq.H(q[4])**0.5,
cirq.X(q[4])**-0.5],
cirq.X(q[5])**0.5,
cirq.X(q[6])**0.5,
[cirq.X(q[7])**0.5,
cirq.H(q[7])**0.5,
cirq.X(q[7])**-0.5],
cirq.Y(q[8])**0.5,
cirq.Y(q[9])**0.5,
cirq.X(q[10])**0.5,
cirq.X(q[11])**0.5,
cirq.Rz(rads=-13.046692838556257 * np.pi).on(q[4]),
cirq.Rz(rads=13.107006443219033 * np.pi).on(q[8]),
cirq.Rz(rads=-20.486755870544844 * np.pi).on(q[5]),
cirq.Rz(rads=20.51325689904871 * np.pi).on(q[9]),
cirq.Rz(rads=-19.82814477311278 * np.pi).on(q[6]),
cirq.Rz(rads=19.838469153514826 * np.pi).on(q[10]),
cirq.Rz(rads=17.687652291347487 * np.pi).on(q[7]),
cirq.Rz(rads=-17.230577602838448 * np.pi).on(q[11]),
[
cirq.ISWAP(q[4], q[8])**-1.0121115249769066,
cirq.CZ(q[4], q[8])**-0.16059979031178617,
],
[
cirq.ISWAP(q[5], q[9])**-0.985003985982119,
cirq.CZ(q[5], q[9])**-0.16606010863938203,
],
[
cirq.ISWAP(q[6], q[10])**-0.9628319095031052,
cirq.CZ(q[6], q[10])**-0.16339300450568622,
],
[
cirq.ISWAP(q[7], q[11])**-0.9999941453695372,
cirq.CZ(q[7], q[11])**-0.16477879415124544,
],
cirq.Rz(rads=12.71050872566315 * np.pi).on(q[4]),
cirq.Rz(rads=-12.650195121000372 * np.pi).on(q[8]),
cirq.Rz(rads=19.562531408750814 * np.pi).on(q[5]),
cirq.Rz(rads=-19.53603038024695 * np.pi).on(q[9]),
cirq.Rz(rads=18.69447149644039 * np.pi).on(q[6]),
cirq.Rz(rads=-18.684147116038343 * np.pi).on(q[10]),
cirq.Rz(rads=-18.21701654221441 * np.pi).on(q[7]),
cirq.Rz(rads=18.674091230723448 * np.pi).on(q[11]),
cirq.Y(q[0])**0.5,
cirq.Y(q[1])**0.5,
cirq.Y(q[2])**0.5,
cirq.Y(q[3])**0.5,
cirq.X(q[4])**0.5,
cirq.Y(q[5])**0.5,
[cirq.X(q[6])**0.5,
cirq.H(q[6])**0.5,
cirq.X(q[6])**-0.5],
cirq.Y(q[7])**0.5,
cirq.X(q[8])**0.5,
[cirq.X(q[9])**0.5,
cirq.H(q[9])**0.5,
cirq.X(q[9])**-0.5],
cirq.Y(q[10])**0.5,
cirq.Y(q[11])**0.5,
cirq.Rz(rads=39.34359792383697 * np.pi).on(q[0]),
cirq.Rz(rads=-39.42696290791402 * np.pi).on(q[4]),
cirq.Rz(rads=38.52825306393881 * np.pi).on(q[1]),
cirq.Rz(rads=-38.452584830758425 * np.pi).on(q[5]),
cirq.Rz(rads=12.958562501914345 * np.pi).on(q[2]),
cirq.Rz(rads=-13.049596611893888 * np.pi).on(q[6]),
cirq.Rz(rads=15.428639843256777 * np.pi).on(q[3]),
cirq.Rz(rads=-15.42731467518594 * np.pi).on(q[7]),
[
cirq.ISWAP(q[0], q[4])**-0.933831313649303,
cirq.CZ(q[0], q[4])**-0.1583933739924931,
],
[
cirq.ISWAP(q[1], q[5])**-0.9390847780661252,
cirq.CZ(q[1], q[5])**-0.17144555428591543,
],
[
cirq.ISWAP(q[2], q[6])**-1.0209160715892363,
cirq.CZ(q[2], q[6])**-0.14849009270439747,
],
[
cirq.ISWAP(q[3], q[7])**-1.0287988330229174,
cirq.CZ(q[3], q[7])**-0.1385888562342036,
],
cirq.Rz(rads=-39.11725021952874 * np.pi).on(q[0]),
cirq.Rz(rads=39.03388523545169 * np.pi).on(q[4]),
cirq.Rz(rads=-37.65488974563269 * np.pi).on(q[1]),
cirq.Rz(rads=37.730557978813074 * np.pi).on(q[5]),
cirq.Rz(rads=-14.665863640797525 * np.pi).on(q[2]),
cirq.Rz(rads=14.574829530817984 * np.pi).on(q[6]),
cirq.Rz(rads=-16.519871460773594 * np.pi).on(q[3]),
cirq.Rz(rads=16.52119662884443 * np.pi).on(q[7]),
cirq.X(q[0])**0.5,
cirq.X(q[1])**0.5,
[cirq.X(q[2])**0.5,
cirq.H(q[2])**0.5,
cirq.X(q[2])**-0.5],
cirq.X(q[3])**0.5,
[cirq.X(q[4])**0.5,
cirq.H(q[4])**0.5,
cirq.X(q[4])**-0.5],
cirq.X(q[5])**0.5,
cirq.X(q[6])**0.5,
cirq.X(q[7])**0.5,
cirq.Y(q[8])**0.5,
cirq.Y(q[9])**0.5,
[cirq.X(q[10])**0.5,
cirq.H(q[10])**0.5,
cirq.X(q[10])**-0.5],
cirq.X(q[11])**0.5,
cirq.Rz(rads=14.928737337703097 * np.pi).on(q[1]),
cirq.Rz(rads=-14.836929415695444 * np.pi).on(q[2]),
cirq.Rz(rads=-12.10125113388289 * np.pi).on(q[5]),
cirq.Rz(rads=12.22245467467503 * np.pi).on(q[6]),
cirq.Rz(rads=-10.099134633961603 * np.pi).on(q[9]),
cirq.Rz(rads=10.172407045184396 * np.pi).on(q[10]),
[
cirq.ISWAP(q[1], q[2])**-1.009868884178167,
cirq.CZ(q[1], q[2])**-0.16552586798219657,
],
[
cirq.ISWAP(q[5], q[6])**-0.9733750299685556,
cirq.CZ(q[5], q[6])**-0.16091330726740966,
],
[
cirq.ISWAP(q[9], q[10])**-0.9769678680475263,
cirq.CZ(q[9], q[10])**-0.16332605888196952,
],
cirq.Rz(rads=-15.32421457749417 * np.pi).on(q[1]),
cirq.Rz(rads=15.416022499501823 * np.pi).on(q[2]),
cirq.Rz(rads=11.899075778124569 * np.pi).on(q[5]),
cirq.Rz(rads=-11.777872237332431 * np.pi).on(q[6]),
cirq.Rz(rads=9.817341949396608 * np.pi).on(q[9]),
cirq.Rz(rads=-9.744069538173814 * np.pi).on(q[10]),
cirq.Y(q[0])**0.5,
cirq.Y(q[1])**0.5,
cirq.Y(q[2])**0.5,
[cirq.X(q[3])**0.5,
cirq.H(q[3])**0.5,
cirq.X(q[3])**-0.5],
cirq.Y(q[4])**0.5,
cirq.Y(q[5])**0.5,
[cirq.X(q[6])**0.5,
cirq.H(q[6])**0.5,
cirq.X(q[6])**-0.5],
[cirq.X(q[7])**0.5,
cirq.H(q[7])**0.5,
cirq.X(q[7])**-0.5],
cirq.X(q[8])**0.5,
[cirq.X(q[9])**0.5,
cirq.H(q[9])**0.5,
cirq.X(q[9])**-0.5],
cirq.Y(q[10])**0.5,
cirq.Y(q[11])**0.5,
cirq.Rz(rads=17.629359127188117 * np.pi).on(q[0]),
cirq.Rz(rads=-17.570809626368614 * np.pi).on(q[1]),
cirq.Rz(rads=-36.89270806725978 * np.pi).on(q[2]),
cirq.Rz(rads=36.93788826789848 * np.pi).on(q[3]),
cirq.Rz(rads=16.787954522971983 * np.pi).on(q[4]),
cirq.Rz(rads=-16.834266520580062 * np.pi).on(q[5]),
cirq.Rz(rads=-33.970047663366486 * np.pi).on(q[6]),
cirq.Rz(rads=34.00933588051398 * np.pi).on(q[7]),
cirq.Rz(rads=7.441137480344476 * np.pi).on(q[8]),
cirq.Rz(rads=-7.338027941327417 * np.pi).on(q[9]),
cirq.Rz(rads=12.963573798570843 * np.pi).on(q[10]),
cirq.Rz(rads=-13.250412392135269 * np.pi).on(q[11]),
[
cirq.ISWAP(q[0], q[1])**-0.8242343706275942,
cirq.CZ(q[0], q[1])**-0.15468164635790926,
],
[
cirq.ISWAP(q[2], q[3])**-0.981653050634976,
cirq.CZ(q[2], q[3])**-0.1933349989832593,
],
[
cirq.ISWAP(q[4], q[5])**-0.9637565510028211,
cirq.CZ(q[4], q[5])**-0.15186761578643612,
],
[
cirq.ISWAP(q[6], q[7])**-1.0089894642925605,
cirq.CZ(q[6], q[7])**-0.17298943435986638,
],
[
cirq.ISWAP(q[8], q[9])**-0.980271915828302,
cirq.CZ(q[8], q[9])**-0.16470994863165317,
],
[
cirq.ISWAP(q[10], q[11])**-0.9290392306402181,
cirq.CZ(q[10], q[11])**-0.1664963204791881,
],
cirq.Rz(rads=-17.442072351850854 * np.pi).on(q[0]),
cirq.Rz(rads=17.500621852670356 * np.pi).on(q[1]),
cirq.Rz(rads=37.46019981788182 * np.pi).on(q[2]),
cirq.Rz(rads=-37.415019617243125 * np.pi).on(q[3]),
cirq.Rz(rads=-17.306336273583675 * np.pi).on(q[4]),
cirq.Rz(rads=17.260024275975592 * np.pi).on(q[5]),
cirq.Rz(rads=34.09650884952739 * np.pi).on(q[6]),
cirq.Rz(rads=-34.057220632379895 * np.pi).on(q[7]),
cirq.Rz(rads=-8.211658529535743 * np.pi).on(q[8]),
cirq.Rz(rads=8.3147680685528 * np.pi).on(q[9]),
cirq.Rz(rads=-12.993307215153958 * np.pi).on(q[10]),
cirq.Rz(rads=12.706468621589535 * np.pi).on(q[11]),
[cirq.X(q[0])**0.5,
cirq.H(q[0])**0.5,
cirq.X(q[0])**-0.5],
cirq.X(q[1])**0.5,
cirq.X(q[2])**0.5,
cirq.X(q[3])**0.5,
cirq.X(q[4])**0.5,
[cirq.X(q[5])**0.5,
cirq.H(q[5])**0.5,
cirq.X(q[5])**-0.5],
cirq.X(q[6])**0.5,
cirq.Y(q[7])**0.5,
cirq.Y(q[8])**0.5,
cirq.Y(q[9])**0.5,
[cirq.X(q[10])**0.5,
cirq.H(q[10])**0.5,
cirq.X(q[10])**-0.5],
cirq.X(q[11])**0.5,
],
strategy=cirq.InsertStrategy.EARLIEST)
return circuit
def test_cirq_qsim_global_shift(self):
q0 = cirq.GridQubit(1, 1)
q1 = cirq.GridQubit(1, 0)
q2 = cirq.GridQubit(0, 1)
q3 = cirq.GridQubit(0, 0)
circuit = cirq.Circuit(
cirq.Moment([
cirq.H(q0),
cirq.H(q1),
cirq.H(q2),
cirq.H(q3),
]),
cirq.Moment([
cirq.CXPowGate(exponent=1, global_shift=0.7)(q0, q1),
cirq.CZPowGate(exponent=1, global_shift=0.9)(q2, q3),
]),
cirq.Moment([
cirq.XPowGate(exponent=1, global_shift=1.1)(q0),
cirq.YPowGate(exponent=1, global_shift=1)(q1),
cirq.ZPowGate(exponent=1, global_shift=0.9)(q2),
cirq.HPowGate(exponent=1, global_shift=0.8)(q3),
]),
cirq.Moment([
cirq.XXPowGate(exponent=1, global_shift=0.2)(q0, q1),
cirq.YYPowGate(exponent=1, global_shift=0.3)(q2, q3),
]),
cirq.Moment([
cirq.ZPowGate(exponent=0.25, global_shift=0.4)(q0),
cirq.ZPowGate(exponent=0.5, global_shift=0.5)(q1),
cirq.YPowGate(exponent=1, global_shift=0.2)(q2),
cirq.ZPowGate(exponent=1, global_shift=0.3)(q3),
]),
cirq.Moment([
cirq.ZZPowGate(exponent=1, global_shift=0.2)(q0, q1),
cirq.SwapPowGate(exponent=1, global_shift=0.3)(q2, q3),
]),
cirq.Moment([
cirq.XPowGate(exponent=1, global_shift=0)(q0),
cirq.YPowGate(exponent=1, global_shift=0)(q1),
cirq.ZPowGate(exponent=1, global_shift=0)(q2),
cirq.HPowGate(exponent=1, global_shift=0)(q3),
]),
cirq.Moment([
cirq.ISwapPowGate(exponent=1, global_shift=0.3)(q0, q1),
cirq.ZZPowGate(exponent=1, global_shift=0.5)(q2, q3),
]),
cirq.Moment([
cirq.ZPowGate(exponent=0.5, global_shift=0)(q0),
cirq.ZPowGate(exponent=0.25, global_shift=0)(q1),
cirq.XPowGate(exponent=0.9, global_shift=0)(q2),
cirq.YPowGate(exponent=0.8, global_shift=0)(q3),
]),
cirq.Moment([
cirq.CZPowGate(exponent=0.3, global_shift=0)(q0, q1),
cirq.CXPowGate(exponent=0.4, global_shift=0)(q2, q3),
]),
cirq.Moment([
cirq.ZPowGate(exponent=1.3, global_shift=0)(q0),
cirq.HPowGate(exponent=0.8, global_shift=0)(q1),
cirq.XPowGate(exponent=0.9, global_shift=0)(q2),
cirq.YPowGate(exponent=0.4, global_shift=0)(q3),
]),
cirq.Moment([
cirq.XXPowGate(exponent=0.8, global_shift=0)(q0, q1),
cirq.YYPowGate(exponent=0.6, global_shift=0)(q2, q3),
]),
cirq.Moment([
cirq.HPowGate(exponent=0.7, global_shift=0)(q0),
cirq.ZPowGate(exponent=0.2, global_shift=0)(q1),
cirq.YPowGate(exponent=0.3, global_shift=0)(q2),
cirq.XPowGate(exponent=0.7, global_shift=0)(q3),
]),
cirq.Moment([
cirq.ZZPowGate(exponent=0.1, global_shift=0)(q0, q1),
cirq.SwapPowGate(exponent=0.6, global_shift=0)(q2, q3),
]),
cirq.Moment([
cirq.XPowGate(exponent=0.4, global_shift=0)(q0),
cirq.YPowGate(exponent=0.3, global_shift=0)(q1),
cirq.ZPowGate(exponent=0.2, global_shift=0)(q2),
cirq.HPowGate(exponent=0.1, global_shift=0)(q3),
]),
cirq.Moment([
cirq.ISwapPowGate(exponent=1.3, global_shift=0)(q0, q1),
cirq.CXPowGate(exponent=0.5, global_shift=0)(q2, q3),
]),
cirq.Moment([
cirq.H(q0),
cirq.H(q1),
cirq.H(q2),
cirq.H(q3),
]),
)
simulator = cirq.Simulator()
cirq_result = simulator.simulate(circuit)
qsim_simulator = qsimcirq.QSimSimulator()
qsim_result = qsim_simulator.simulate(circuit)
assert cirq.linalg.allclose_up_to_global_phase(
qsim_result.state_vector(), cirq_result.state_vector())
def test_decay_noise_after_moment():
program = cirq.Circuit()
qubits = cirq.LineQubit.range(3)
program.append([
cirq.H(qubits[0]),
cirq.CNOT(qubits[0], qubits[1]),
cirq.CNOT(qubits[1], qubits[2])
])
program.append(
[
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1'),
cirq.measure(qubits[2], key='q2'),
],
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
# Use noise model to generate circuit
depol_noise = ccn.DepolarizingNoiseModel(depol_prob=0.01)
readout_noise = ccn.ReadoutNoiseModel(bitflip_prob=0.05)
damping_noise = ccn.DampedReadoutNoiseModel(decay_prob=0.02)
noisy_circuit = cirq.Circuit(depol_noise.noisy_moments(program, qubits))
noisy_circuit = cirq.Circuit(
damping_noise.noisy_moments(noisy_circuit, qubits))
noisy_circuit = cirq.Circuit(
readout_noise.noisy_moments(noisy_circuit, qubits))
# Insert channels explicitly
true_noisy_program = cirq.Circuit()
true_noisy_program.append([cirq.H(qubits[0])])
true_noisy_program.append(
[
cirq.DepolarizingChannel(0.01).on(q).with_tags(ops.VirtualTag())
for q in qubits
],
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
true_noisy_program.append([cirq.CNOT(qubits[0], qubits[1])])
true_noisy_program.append(
[
cirq.DepolarizingChannel(0.01).on(q).with_tags(ops.VirtualTag())
for q in qubits
],
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
true_noisy_program.append([cirq.CNOT(qubits[1], qubits[2])])
true_noisy_program.append(
[
cirq.DepolarizingChannel(0.01).on(q).with_tags(ops.VirtualTag())
for q in qubits
],
strategy=cirq.InsertStrategy.NEW_THEN_INLINE,
)
true_noisy_program.append([
cirq.AmplitudeDampingChannel(0.02).on(q).with_tags(ops.VirtualTag())
for q in qubits
])
true_noisy_program.append([
cirq.BitFlipChannel(0.05).on(q).with_tags(ops.VirtualTag())
for q in qubits
])
true_noisy_program.append([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1'),
cirq.measure(qubits[2], key='q2'),
])
assert_equivalent_op_tree(true_noisy_program, noisy_circuit)
import cirq
circuit = cirq.Circuit()
# define two qubits
(q0, q1) = cirq.LineQubit.range(2)
# perform quantum gates on the qubits
qlist = circuit.append([cirq.H(q0), cirq.CNOT(q0, q1)])
# measure the the circuit bits
clist = circuit.append([cirq.measure(q0), cirq.measure(q1)])
# perform simulation of the circuit
sim = cirq.Simulator()
results = sim.run(circuit, repetitions=10)
# print("quantum circuit: {}".format(qlist))
# print("classical circuit: {}".format(clist))
# draw circuit
print(circuit)
print(results)
def test_static_cases(self):
"""Run inputs through in complex cases."""
bit = cirq.GridQubit(0, 0)
symbol = sympy.Symbol('alpha')
test_pstring = cirq.Z(bit)
test_psum = cirq.PauliSum.from_pauli_strings([test_pstring])
symb_circuit = cirq.Circuit(cirq.H(bit)**symbol)
reg_circuit = cirq.Circuit(cirq.H(bit))
# Passing a 2d operators input requires a 1d circuit input.
sampled_expectation.SampledExpectation()(
[reg_circuit, reg_circuit],
operators=[[test_psum, test_psum], [test_psum, test_psum]],
repetitions=1)
# Passing 2d operators along with other inputs.
sampled_expectation.SampledExpectation()(
[symb_circuit, symb_circuit],
symbol_names=[symbol],
operators=[[test_psum, test_psum], [test_psum, test_psum]],
repetitions=1)
sampled_expectation.SampledExpectation()(
[symb_circuit, symb_circuit],
symbol_names=[symbol],
symbol_values=[[0.5], [0.8]],
operators=[[test_psum, test_psum], [test_psum, test_psum]],
repetitions=1)
# Ensure tiling up of circuits works as expected.
sampled_expectation.SampledExpectation()(reg_circuit,
operators=test_psum,
repetitions=1)
sampled_expectation.SampledExpectation()(
reg_circuit, operators=[test_psum, test_psum], repetitions=1)
# Ensure tiling up of symbol_values works as expected.
sampled_expectation.SampledExpectation()(symb_circuit,
symbol_names=[symbol],
symbol_values=[[0.5], [0.8]],
operators=test_psum,
repetitions=1)
sampled_expectation.SampledExpectation()(symb_circuit,
symbol_names=[symbol],
symbol_values=[[0.5]],
operators=test_psum,
repetitions=1)
# Test multiple operators with integer valued repetition.
sampled_expectation.SampledExpectation()(
symb_circuit,
symbol_names=[symbol],
symbol_values=[[0.5]],
operators=[-1.0 * cirq.Z(bit),
cirq.X(bit) + 2.0 * cirq.Z(bit)],
repetitions=1)
sampled_expectation.SampledExpectation()(
symb_circuit,
symbol_names=[symbol],
symbol_values=[[0.5]],
operators=[-1.0 * cirq.Z(bit),
cirq.X(bit) + 2.0 * cirq.Z(bit)],
repetitions=[5, 1])
def test_sampled_expectation_op_error(self):
"""Test that expectation errors within underlying ops correctly."""
# Note the expected_regex is left blank here since there is a
# discrepancy between the error strings provided between backends.
bit = cirq.GridQubit(0, 0)
symbol = sympy.Symbol('alpha')
test_pstring = cirq.Z(bit)
test_psum = cirq.PauliSum.from_pauli_strings([test_pstring])
symb_circuit = cirq.Circuit(cirq.H(bit)**symbol)
reg_circuit = cirq.Circuit(cirq.H(bit))
with self.assertRaisesRegex(Exception, expected_regex="pauli_sums"):
# Operators has wrong rank. Parse error.
sampled_expectation.SampledExpectation()(
[reg_circuit],
operators=util.convert_to_tensor([test_psum]),
repetitions=1)
with self.assertRaisesRegex(Exception, expected_regex="symbol_values"):
# symbol_values has wrong rank.
sampled_expectation.SampledExpectation()([symb_circuit],
symbol_names=[symbol],
symbol_values=[0.5],
operators=test_psum,
repetitions=1)
with self.assertRaisesRegex(
Exception,
expected_regex="Number of circuits and PauliSums do not match"
):
# Wrong batch size for pauli operators.
sampled_expectation.SampledExpectation()(symb_circuit,
symbol_names=[symbol],
operators=[[test_psum],
[test_psum]],
repetitions=1)
with self.assertRaisesRegex(
Exception,
expected_regex="Number of circuits and PauliSums do not match"
):
# Wrong batch size for pauli operators.
sampled_expectation.SampledExpectation()(reg_circuit,
operators=[[test_psum],
[test_psum]],
repetitions=1)
with self.assertRaisesRegex(Exception,
expected_regex="greater than 0"):
# Wrong repetitions.
sampled_expectation.SampledExpectation()(reg_circuit,
operators=test_psum,
repetitions=-1)
with self.assertRaisesRegex(
Exception,
expected_regex="num_samples and pauli_sums do not match"):
# Wrong second dimension size for repetitions & pauli operators.
sampled_expectation.SampledExpectation()(reg_circuit,
operators=test_psum,
repetitions=[5, 4, 3])
def test_surface_code_cycle_stratifies_without_growing():
g = cirq.GridQubit
circuit = cirq.Circuit(
cirq.H(g(9, 11)),
cirq.H(g(11, 12)),
cirq.H(g(12, 9)),
cirq.H(g(9, 8)),
cirq.H(g(8, 11)),
cirq.H(g(11, 9)),
cirq.H(g(10, 9)),
cirq.H(g(10, 8)),
cirq.H(g(11, 10)),
cirq.H(g(12, 10)),
cirq.H(g(9, 9)),
cirq.H(g(9, 10)),
cirq.H(g(10, 11)),
cirq.CZ(g(10, 9), g(9, 9)),
cirq.CZ(g(10, 11), g(9, 11)),
cirq.CZ(g(9, 10), g(8, 10)),
cirq.CZ(g(11, 10), g(10, 10)),
cirq.CZ(g(12, 9), g(11, 9)),
cirq.CZ(g(11, 12), g(10, 12)),
cirq.H(g(9, 11)),
cirq.H(g(9, 9)),
cirq.H(g(10, 10)),
cirq.H(g(11, 9)),
cirq.H(g(10, 12)),
cirq.H(g(8, 10)),
cirq.CZ(g(11, 10), g(11, 11)),
cirq.CZ(g(10, 9), g(10, 8)),
cirq.CZ(g(12, 9), g(12, 10)),
cirq.CZ(g(10, 11), g(10, 10)),
cirq.CZ(g(9, 8), g(9, 9)),
cirq.CZ(g(9, 10), g(9, 11)),
cirq.CZ(g(8, 11), g(8, 10)),
cirq.CZ(g(11, 10), g(11, 9)),
cirq.CZ(g(11, 12), g(11, 11)),
cirq.H(g(10, 8)),
cirq.H(g(12, 10)),
cirq.H(g(12, 9)),
cirq.CZ(g(9, 10), g(9, 9)),
cirq.CZ(g(10, 9), g(10, 10)),
cirq.CZ(g(10, 11), g(10, 12)),
cirq.H(g(11, 11)),
cirq.H(g(9, 11)),
cirq.H(g(11, 9)),
cirq.CZ(g(9, 8), g(10, 8)),
cirq.CZ(g(11, 10), g(12, 10)),
cirq.H(g(11, 12)),
cirq.H(g(8, 10)),
cirq.H(g(10, 10)),
cirq.CZ(g(8, 11), g(9, 11)),
cirq.CZ(g(10, 9), g(11, 9)),
cirq.CZ(g(10, 11), g(11, 11)),
cirq.H(g(9, 8)),
cirq.H(g(10, 12)),
cirq.H(g(11, 10)),
cirq.CZ(g(9, 10), g(10, 10)),
cirq.H(g(11, 11)),
cirq.H(g(9, 11)),
cirq.H(g(8, 11)),
cirq.H(g(11, 9)),
cirq.H(g(10, 9)),
cirq.H(g(10, 11)),
cirq.H(g(9, 10)),
)
assert len(circuit) == 8
stratified = cirq.stratified_circuit(circuit, categories=[cirq.H, cirq.CZ])
# Ideally, this would not grow at all, but for now the algorithm has it
# grow to a 9. Note that this optimizer uses a fairly simple algorithm
# that is known not to be optimal - optimal stratification is a CSP
# problem with high dimensionality that quickly becomes intractable. See
# https://github.com/quantumlib/Cirq/pull/2772/ for some discussion on
# this, as well as a more optimal but much more complex and slow solution.
assert len(stratified) == 9
def _h_layer(self) -> List[cirq.Gate]:
gate_seq = []
for qubit in self._qubits:
gate_seq.append(cirq.H(qubit))
return gate_seq
def add_swap_test(
state1: typing.Union[cirq.Qid, typing.Iterable[cirq.Qid]],
state2: typing.Union[cirq.Qid, typing.Iterable[cirq.Qid]],
circuit: cirq.Circuit,
auxiliary_qubit: typing.Optional[cirq.Qid] = None,
auxiliary_qubit_type: typing.Optional[
typing.Union[typing.Type[cirq.GridQubit], typing.Type[cirq.LineQubit]]
] = cirq.GridQubit,
cswap_in_elementary_gates: bool = False
) -> typing.Tuple[str, cirq.Qid]:
"""
Add a SWAP test between two quantum states `state1` and `state2`, and then add
the test into `circuit`.
999: ───H───@───H───M('SWAP test measure')───
│
1: ─────────SWAP─────────────────────────────
│
2: ─────────SWAP─────────────────────────────
:param state1:
Quantum state to be tested.
:param state2:
Quantum state to be tested.
:param circuit:
The quantum circuit to which the SWAP test is to be appended.
:param auxiliary_qubit:
The auxiliary qubit.
If being None, it will be created by `generate_auxiliary_qubit`.
If being a `cirq.Qid` object, then it will be used as the auxiliary
qubit of our SWAP test, and the argument `auxiliary_qubit_type` will be
ignored.
Note: `auxiliary_qubit` and `auxiliary_qubit_type` can not both be
`None` at the same time.
:param auxiliary_qubit_type:
The type of the auxiliary qubit of SWAP test. Only LineQubit and
GridQubit are supported.
If `auxiliary_qubit` is None, this argument will be used to create the
auxiliary qubit.
If `auxiliary_qubit` is a `cirq.Qid` object, then this argument will be
ignored.
Note: `auxiliary_qubit` and `auxiliary_qubit_type` can not both be
`None` at the same time.
:param cswap_in_elementary_gates:
Tells whether the CSWAP gate will be represented in elementary gates.
:return:
The string key of the measurement.
"""
if isinstance(state1, cirq.Qid):
state1 = [state1]
if isinstance(state2, cirq.Qid):
state2 = [state2]
if len(state1) != len(state2):
raise ValueError(
"Qubit lengths of the two target states must equal, "
"but {} != {}.".format(len(state1), len(state2))
)
if auxiliary_qubit is None:
auxiliary_qubit = generate_auxiliary_qubit(circuit, auxiliary_qubit_type)
measurement_name = "SWAP test measure "
existed_swap_measurement_ids = {int(key[len(measurement_name):])
for key in get_all_measurement_keys(circuit)
if key.startswith(measurement_name)}
swap_measurement_id = (max(existed_swap_measurement_ids) + 1
if len(existed_swap_measurement_ids) != 0
else 0)
measurement_name += str(swap_measurement_id)
circuit.append(cirq.H(auxiliary_qubit))
for qubit1, qubit2 in zip(state1, state2):
cswap_op = cirq.CSWAP.on(auxiliary_qubit, qubit1, qubit2)
if cswap_in_elementary_gates:
circuit.append(
cirq.decompose(cswap_op)
)
else:
circuit.append(cswap_op)
circuit.append([
cirq.H(auxiliary_qubit),
cirq.measure(auxiliary_qubit, key=measurement_name)
])
return measurement_name, auxiliary_qubit
def encode_function(qubit):
if origin_bit == 1:
yield cirq.X(qubit)
if encode_gate == 1:
yield cirq.H(qubit)
# initialize registers
b = cirq.LineQubit(0)
x = []
for i in range(n):
x.append(
[cirq.LineQubit(i) for i in range(1 + bits * i,
bits * (i + 1) + 1)])
r = [cirq.LineQubit(i) for i in range(1 + bits * n, 1 + bits * n + m)]
# initialize circuit
circuit = cirq.Circuit()
# prepare superpositions over b and x
# have \sum_{b, x} |b>|x>|0>
circuit.append(cirq.H(b))
for i in range(n):
for j in range(bits):
circuit.append(cirq.H(x[i][j]))
# initialize phase qubis
for i in range(m):
circuit.append(cirq.H(r[i]))
# prepare phase qubits that recover MSB with high probability when measured
# after each iteration of the loop, the i-th phase qubit should be in the state:
# |+_theta>, where theta = pi/4 * (<a, x> + b . y_i) and a is the i-th row of A
for i in range(m):
for j in range(n):
for k in range(bits):
def test_throws_when_indexed_by_unused_qubit():
a, b = cirq.LineQubit.range(2)
moment = cirq.Moment([cirq.H(a)])
with pytest.raises(KeyError, match="Moment doesn't act on given qubit"):
_ = moment[b]
def test_cnots_separated_by_single_gates_correct():
a, b = cirq.LineQubit.range(2)
assert_optimization_not_broken(cirq.Circuit(cirq.CNOT(a, b), cirq.H(b), cirq.CNOT(a, b)))
def _decompose_(self, qubits):
"""The goal is to effect a rotation around an axis in the XY plane in
each of three orthogonal 2-dimensional subspaces.
First, the following basis change is performed:
0000 ↦ 0001 0001 ↦ 1111
1111 ↦ 0010 1110 ↦ 1100
0010 ↦ 0000
0110 ↦ 0101 1101 ↦ 0011
1001 ↦ 0110 0100 ↦ 0100
1010 ↦ 1001 1011 ↦ 0111
0101 ↦ 1010 1000 ↦ 1000
1100 ↦ 1101 0111 ↦ 1011
0011 ↦ 1110
Note that for each 2-dimensional subspace of interest, the first two
qubits are the same and the right two qubits are different. The desired
rotations thus can be effected by a complex-version of a partial SWAP
gate on the latter two qubits, controlled on the first two qubits. This
partial SWAP-like gate can be decomposed such that it is parameterized
solely by a rotation in the ZY plane on the third qubit. These are the
`individual_rotations`; call them U0, U1, U2.
To decompose the double controlled rotations, we use four other
rotations V0, V1, V2, V3 (the `combined_rotations`) such that
U0 = V3 · V1 · V0
U1 = V3 · V2 · V1
U2 = V2 · V0
"""
if self._is_parameterized_():
return NotImplemented
individual_rotations = [
la.expm(0.5j * self.exponent *
np.array([[np.real(w), 1j * s * np.imag(w)],
[-1j * s * np.imag(w), -np.real(w)]]))
for s, w in zip([1, -1, -1], self.weights)
]
combined_rotations = {}
combined_rotations[0] = la.sqrtm(
np.linalg.multi_dot([
la.inv(individual_rotations[1]), individual_rotations[0],
individual_rotations[2]
]))
combined_rotations[1] = la.inv(combined_rotations[0])
combined_rotations[2] = np.linalg.multi_dot([
la.inv(individual_rotations[0]), individual_rotations[1],
combined_rotations[0]
])
combined_rotations[3] = individual_rotations[0]
controlled_rotations = {
i: cirq.ControlledGate(
cirq.MatrixGate(combined_rotations[i], qid_shape=(2, )))
for i in range(4)
}
a, b, c, d = qubits
basis_change = list(
cirq.flatten_op_tree([
cirq.CNOT(b, a),
cirq.CNOT(c, b),
cirq.CNOT(d, c),
cirq.CNOT(c, b),
cirq.CNOT(b, a),
cirq.CNOT(a, b),
cirq.CNOT(b, c),
cirq.CNOT(a, b),
[cirq.X(c), cirq.X(d)],
[cirq.CNOT(c, d), cirq.CNOT(d, c)],
[cirq.X(c), cirq.X(d)],
]))
controlled_rotations = list(
cirq.flatten_op_tree([
controlled_rotations[0](b, c),
cirq.CNOT(a, b), controlled_rotations[1](b, c),
cirq.CNOT(b, a),
cirq.CNOT(a, b), controlled_rotations[2](b, c),
cirq.CNOT(a, b), controlled_rotations[3](b, c)
]))
controlled_swaps = [
[cirq.CNOT(c, d), cirq.H(c)],
cirq.CNOT(d, c),
controlled_rotations,
cirq.CNOT(d, c),
[cirq.inverse(op) for op in reversed(controlled_rotations)],
[cirq.H(c), cirq.CNOT(c, d)],
]
return [basis_change, controlled_swaps, basis_change[::-1]]
"""Program for generating random bits in Cirq."""
# Imports
import cirq
# Helper function for visualizing output
def bitstring(bits):
return ''.join('1' if e else '0' for e in bits)
# Get a qubit and quantum circuit
qbit = cirq.LineQubit(0)
circ = cirq.Circuit()
# Add the Hadamard and measure operations to the circuit
circ.append([cirq.H(qbit), cirq.measure(qbit, key="z")])
# Simulate the circuit
sim = cirq.Simulator()
res = sim.run(circ, repetitions=10)
# Print the outcome
print("Bitstring =", bitstring(res.measurements["z"]))
def test_repeat(add_measurements, use_default_ids_for_initial_rep):
a, b = cirq.LineQubit.range(2)
circuit = cirq.Circuit(cirq.H(a), cirq.CX(a, b))
if add_measurements:
circuit.append([cirq.measure(b, key='mb'), cirq.measure(a, key='ma')])
op_base = cirq.CircuitOperation(circuit.freeze())
assert op_base.repeat(1) is op_base
assert op_base.repeat(1, ['0']) != op_base
assert op_base.repeat(1, ['0']) == op_base.repeat(repetition_ids=['0'])
assert op_base.repeat(1, ['0']) == op_base.with_repetition_ids(['0'])
initial_repetitions = -3
if add_measurements:
with pytest.raises(ValueError, match='circuit is not invertible'):
_ = op_base.repeat(initial_repetitions)
initial_repetitions = abs(initial_repetitions)
op_with_reps: Optional[cirq.CircuitOperation] = None
rep_ids = []
if use_default_ids_for_initial_rep:
op_with_reps = op_base.repeat(initial_repetitions)
rep_ids = ['0', '1', '2']
assert op_base**initial_repetitions == op_with_reps
else:
rep_ids = ['a', 'b', 'c']
op_with_reps = op_base.repeat(initial_repetitions, rep_ids)
assert op_base**initial_repetitions != op_with_reps
assert (op_base**initial_repetitions).replace(
repetition_ids=rep_ids) == op_with_reps
assert op_with_reps.repetitions == initial_repetitions
assert op_with_reps.repetition_ids == rep_ids
assert op_with_reps.repeat(1) is op_with_reps
final_repetitions = 2 * initial_repetitions
op_with_consecutive_reps = op_with_reps.repeat(2)
assert op_with_consecutive_reps.repetitions == final_repetitions
assert op_with_consecutive_reps.repetition_ids == _full_join_string_lists(
['0', '1'], rep_ids)
assert op_base**final_repetitions != op_with_consecutive_reps
op_with_consecutive_reps = op_with_reps.repeat(2, ['a', 'b'])
assert op_with_reps.repeat(
repetition_ids=['a', 'b']) == op_with_consecutive_reps
assert op_with_consecutive_reps.repetitions == final_repetitions
assert op_with_consecutive_reps.repetition_ids == _full_join_string_lists(
['a', 'b'], rep_ids)
with pytest.raises(ValueError, match='length to be 2'):
_ = op_with_reps.repeat(2, ['a', 'b', 'c'])
with pytest.raises(
ValueError,
match='At least one of repetitions and repetition_ids must be set'
):
_ = op_base.repeat()
with pytest.raises(TypeError,
match='Only integer or sympy repetitions are allowed'):
_ = op_base.repeat(1.3)
assert op_base.repeat(3.00000000001).repetitions == 3
assert op_base.repeat(2.99999999999).repetitions == 3
def test_cirq_qsim_all_supported_gates(self):
q0 = cirq.GridQubit(1, 1)
q1 = cirq.GridQubit(1, 0)
q2 = cirq.GridQubit(0, 1)
q3 = cirq.GridQubit(0, 0)
circuit = cirq.Circuit(
cirq.Moment([
cirq.H(q0),
cirq.H(q1),
cirq.H(q2),
cirq.H(q3),
]),
cirq.Moment([
cirq.T(q0),
cirq.T(q1),
cirq.T(q2),
cirq.T(q3),
]),
cirq.Moment([
cirq.CZPowGate(exponent=0.7, global_shift=0.2)(q0, q1),
cirq.CXPowGate(exponent=1.2, global_shift=0.4)(q2, q3),
]),
cirq.Moment([
cirq.XPowGate(exponent=0.3, global_shift=1.1)(q0),
cirq.YPowGate(exponent=0.4, global_shift=1)(q1),
cirq.ZPowGate(exponent=0.5, global_shift=0.9)(q2),
cirq.HPowGate(exponent=0.6, global_shift=0.8)(q3),
]),
cirq.Moment([
cirq.CX(q0, q2),
cirq.CZ(q1, q3),
]),
cirq.Moment([
cirq.X(q0),
cirq.Y(q1),
cirq.Z(q2),
cirq.S(q3),
]),
cirq.Moment([
cirq.XXPowGate(exponent=0.4, global_shift=0.7)(q0, q1),
cirq.YYPowGate(exponent=0.8, global_shift=0.5)(q2, q3),
]),
cirq.Moment([cirq.I(q0),
cirq.I(q1),
cirq.IdentityGate(2)(q2, q3)]),
cirq.Moment([
cirq.rx(0.7)(q0),
cirq.ry(0.2)(q1),
cirq.rz(0.4)(q2),
cirq.PhasedXPowGate(phase_exponent=0.8,
exponent=0.6,
global_shift=0.3)(q3),
]),
cirq.Moment([
cirq.ZZPowGate(exponent=0.3, global_shift=1.3)(q0, q2),
cirq.ISwapPowGate(exponent=0.6, global_shift=1.2)(q1, q3),
]),
cirq.Moment([
cirq.XPowGate(exponent=0.1, global_shift=0.9)(q0),
cirq.YPowGate(exponent=0.2, global_shift=1)(q1),
cirq.ZPowGate(exponent=0.3, global_shift=1.1)(q2),
cirq.HPowGate(exponent=0.4, global_shift=1.2)(q3),
]),
cirq.Moment([
cirq.SwapPowGate(exponent=0.2, global_shift=0.9)(q0, q1),
cirq.PhasedISwapPowGate(phase_exponent=0.8, exponent=0.6)(q2,
q3),
]),
cirq.Moment([
cirq.PhasedXZGate(x_exponent=0.2,
z_exponent=0.3,
axis_phase_exponent=1.4)(q0),
cirq.T(q1),
cirq.H(q2),
cirq.S(q3),
]),
cirq.Moment([
cirq.SWAP(q0, q2),
cirq.XX(q1, q3),
]),
cirq.Moment([
cirq.rx(0.8)(q0),
cirq.ry(0.9)(q1),
cirq.rz(1.2)(q2),
cirq.T(q3),
]),
cirq.Moment([
cirq.YY(q0, q1),
cirq.ISWAP(q2, q3),
]),
cirq.Moment([
cirq.T(q0),
cirq.Z(q1),
cirq.Y(q2),
cirq.X(q3),
]),
cirq.Moment([
cirq.FSimGate(0.3, 1.7)(q0, q2),
cirq.ZZ(q1, q3),
]),
cirq.Moment([
cirq.ry(1.3)(q0),
cirq.rz(0.4)(q1),
cirq.rx(0.7)(q2),
cirq.S(q3),
]),
cirq.Moment([
cirq.MatrixGate(
np.array([[0, -0.5 - 0.5j, -0.5 - 0.5j, 0],
[0.5 - 0.5j, 0, 0, -0.5 + 0.5j],
[0.5 - 0.5j, 0, 0, 0.5 - 0.5j],
[0, -0.5 - 0.5j, 0.5 + 0.5j, 0]]))(q0, q1),
cirq.MatrixGate(
np.array([[0.5 - 0.5j, 0, 0, -0.5 + 0.5j],
[0, 0.5 - 0.5j, -0.5 + 0.5j, 0],
[0, -0.5 + 0.5j, -0.5 + 0.5j, 0],
[0.5 - 0.5j, 0, 0, 0.5 - 0.5j]]))(q2, q3),
]),
cirq.Moment([
cirq.MatrixGate(np.array([[1, 0], [0, 1j]]))(q0),
cirq.MatrixGate(np.array([[0, -1j], [1j, 0]]))(q1),
cirq.MatrixGate(np.array([[0, 1], [1, 0]]))(q2),
cirq.MatrixGate(np.array([[1, 0], [0, -1]]))(q3),
]),
cirq.Moment([
cirq.riswap(0.7)(q0, q1),
cirq.givens(1.2)(q2, q3),
]),
cirq.Moment([
cirq.H(q0),
cirq.H(q1),
cirq.H(q2),
cirq.H(q3),
]),
)
simulator = cirq.Simulator()
cirq_result = simulator.simulate(circuit)
qsim_simulator = qsimcirq.QSimSimulator()
qsim_result = qsim_simulator.simulate(circuit)
assert cirq.linalg.allclose_up_to_global_phase(
qsim_result.state_vector(), cirq_result.state_vector())
prefix = gates[:i + 1]
expected_a = cirq.LinearCombinationOfGates(collections.Counter(prefix))
expected_b = -expected_a
assert_linear_combinations_are_equal(a, expected_a)
assert_linear_combinations_are_equal(b, expected_b)
@pytest.mark.parametrize('op', (
cirq.X(q0),
cirq.Y(q1),
cirq.XX(q0, q1),
cirq.CZ(q0, q1),
cirq.FREDKIN(q0, q1, q2),
cirq.ControlledOperation((q0, q1), cirq.H(q2)),
cirq.ParallelGateOperation(cirq.X, (q0, q1, q2)),
cirq.PauliString({
q0: cirq.X,
q1: cirq.Y,
q2: cirq.Z
}),
))
def test_empty_linear_combination_of_operations_accepts_all_operations(op):
combination = cirq.LinearCombinationOfOperations({})
combination[op] = -0.5j
assert len(combination) == 1
@pytest.mark.parametrize('terms', (
{
def test_tagged_operation_forwards_protocols():
"""The results of all protocols applied to an operation with a tag should
be equivalent to the result without tags.
"""
q1 = cirq.GridQubit(1, 1)
q2 = cirq.GridQubit(1, 2)
h = cirq.H(q1)
tag = 'tag1'
tagged_h = cirq.H(q1).with_tags(tag)
np.testing.assert_equal(cirq.unitary(tagged_h), cirq.unitary(h))
assert cirq.has_unitary(tagged_h)
assert cirq.decompose(tagged_h) == cirq.decompose(h)
assert cirq.pauli_expansion(tagged_h) == cirq.pauli_expansion(h)
assert cirq.equal_up_to_global_phase(h, tagged_h)
assert np.isclose(cirq.channel(h), cirq.channel(tagged_h)).all()
assert cirq.measurement_key(cirq.measure(q1, key='blah').with_tags(tag)) == 'blah'
parameterized_op = cirq.XPowGate(exponent=sympy.Symbol('t'))(q1).with_tags(tag)
assert cirq.is_parameterized(parameterized_op)
resolver = cirq.study.ParamResolver({'t': 0.25})
assert cirq.resolve_parameters(parameterized_op, resolver) == cirq.XPowGate(exponent=0.25)(
q1
).with_tags(tag)
assert cirq.resolve_parameters_once(parameterized_op, resolver) == cirq.XPowGate(exponent=0.25)(
q1
).with_tags(tag)
y = cirq.Y(q1)
tagged_y = cirq.Y(q1).with_tags(tag)
assert tagged_y ** 0.5 == cirq.YPowGate(exponent=0.5)(q1)
assert tagged_y * 2 == (y * 2)
assert 3 * tagged_y == (3 * y)
assert cirq.phase_by(y, 0.125, 0) == cirq.phase_by(tagged_y, 0.125, 0)
controlled_y = tagged_y.controlled_by(q2)
assert controlled_y.qubits == (
q2,
q1,
)
assert isinstance(controlled_y, cirq.Operation)
assert not isinstance(controlled_y, cirq.TaggedOperation)
clifford_x = cirq.SingleQubitCliffordGate.X(q1)
tagged_x = cirq.SingleQubitCliffordGate.X(q1).with_tags(tag)
assert cirq.commutes(clifford_x, clifford_x)
assert cirq.commutes(tagged_x, clifford_x)
assert cirq.commutes(clifford_x, tagged_x)
assert cirq.commutes(tagged_x, tagged_x)
assert cirq.trace_distance_bound(y ** 0.001) == cirq.trace_distance_bound(
(y ** 0.001).with_tags(tag)
)
flip = cirq.bit_flip(0.5)(q1)
tagged_flip = cirq.bit_flip(0.5)(q1).with_tags(tag)
assert cirq.has_mixture(tagged_flip)
assert cirq.has_channel(tagged_flip)
flip_mixture = cirq.mixture(flip)
tagged_mixture = cirq.mixture(tagged_flip)
assert len(tagged_mixture) == 2
assert len(tagged_mixture[0]) == 2
assert len(tagged_mixture[1]) == 2
assert tagged_mixture[0][0] == flip_mixture[0][0]
assert np.isclose(tagged_mixture[0][1], flip_mixture[0][1]).all()
assert tagged_mixture[1][0] == flip_mixture[1][0]
assert np.isclose(tagged_mixture[1][1], flip_mixture[1][1]).all()
qubit_map = {q1: 'q1'}
qasm_args = cirq.QasmArgs(qubit_id_map=qubit_map)
assert cirq.qasm(h, args=qasm_args) == cirq.qasm(tagged_h, args=qasm_args)
cirq.testing.assert_has_consistent_apply_unitary(tagged_h)
def _get_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.1 * sympy.Symbol('alpha'))(q0)),
_build_gate_proto("HP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.1, 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.1 * sympy.Symbol('alpha'))(q0)),
_build_gate_proto("XP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.1, 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.1 * sympy.Symbol('alpha'))(q0)),
_build_gate_proto("YP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.1, 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.1 * sympy.Symbol('alpha'))(q0)),
_build_gate_proto("ZP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.1, 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.1 * sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("XXP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.1, 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.1 * sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("YYP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.1, 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.1 * sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("ZZP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.1, 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.1 * sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("CZP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.1, 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.1 * sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("CNP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.1, 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.1 * sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("SP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.1, 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.1 * sympy.Symbol('alpha'))(q0, q1)),
_build_gate_proto("ISP",
['exponent', 'exponent_scalar', 'global_shift'],
['alpha', 3.1, 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.1 * sympy.Symbol('alpha'),
exponent=0.3)(q0)),
_build_gate_proto("PXP", [
'phase_exponent', 'phase_exponent_scalar', 'exponent',
'exponent_scalar', 'global_shift'
], ['alpha', 3.1, 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.1 * sympy.Symbol('beta'))(q0)),
_build_gate_proto("PXP", [
'phase_exponent', 'phase_exponent_scalar', 'exponent',
'exponent_scalar', 'global_shift'
], [0.9, 1.0, 'beta', 5.1, 0.0], ['0_0'])),
(cirq.Circuit(
cirq.PhasedXPowGate(phase_exponent=3.1 * sympy.Symbol('alpha'),
exponent=5.1 * sympy.Symbol('beta'))(q0)),
_build_gate_proto("PXP", [
'phase_exponent', 'phase_exponent_scalar', 'exponent',
'exponent_scalar', 'global_shift'
], ['alpha', 3.1, 'beta', 5.1, 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'])),
# Identity
(cirq.Circuit(cirq.I(q0)),
_build_gate_proto("I", ['unused'], [True], ['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.1 * sympy.Symbol("alpha"),
phi=1.3 * sympy.Symbol("beta"))(q0, q1)),
_build_gate_proto("FSIM",
['theta', 'theta_scalar', 'phi', 'phi_scalar'],
['alpha', 2.1, 'beta', 1.3], ['0_0', '0_1'])),
]
return pairs
def encode(self, additional_qubits: List[cirq.Qid],
unencoded_qubits: List[cirq.Qid]) -> cirq.Circuit:
"""Creates a circuit that encodes the qubits using the code words.
Args:
additional_qubits: The list of self.n - self.k qubits needed to encode the qubit.
unencoded_qubits: The list of self.k qubits that contain the original message.
Returns:
A circuit where the self.n qubits are the encoded qubits.
"""
assert len(additional_qubits) == self.n - self.k
assert len(unencoded_qubits) == self.k
qubits = additional_qubits + unencoded_qubits
circuit = cirq.Circuit()
# Equation 4.8:
# This follows the improvements of:
# https://cs269q.stanford.edu/projects2019/stabilizer_code_report_Y.pdf
for r, x in enumerate(self.logical_Xs):
for j in range(self.r, self.n - self.k):
# By constructions, the first r rows can never contain a Z, as
# r is defined by the Gaussian elimination as the rank.
if x[j] == 'X' or x[j] == 'Y':
circuit.append(
cirq.ControlledOperation([unencoded_qubits[r]],
cirq.X(additional_qubits[j])))
gate_dict = {'X': cirq.X, 'Y': cirq.Y, 'Z': cirq.Z}
for r in range(self.r):
circuit.append(cirq.H(qubits[r]))
# Let's consider the first stabilizer:
# The reason for adding S gate is Y gate we used is the complex format (i.e. to
# make it Hermitian). It has following four cases: (ignore the phase factor)
# (I+X@P_2...P_k)|0...0> = |0...0> + |1>|\psi>
# (I+Y@P_2...P_k)|0...0> = |0...0> + i|1>|\psi>
# The other forms are not possible in the standard form, by construction.
# The first case means we need [1,1] vector and controlled gates and in the
# second case we need [1, i] vector and controlled gates. Corresponding, it is
# the first column of H and the first column of SH respectively.
# For the other stabilizers, the process can be repeated, as by definition they
# commute.
if self.M[r][r] == 'Y' or self.M[r][r] == 'Z':
circuit.append(cirq.S(qubits[r]))
for n in range(self.n):
if n == r:
continue
if self.M[r][n] == 'I':
continue
op = gate_dict[self.M[r][n]]
circuit.append(
cirq.ControlledOperation([qubits[r]], op(qubits[n])))
# At this stage, the state vector should be equal to equations 3.17 and 3.18.
return circuit
def test_readout_error():
p00 = 0.05
p11 = 0.1
p = p11 / (p00 + p11)
gamma = p11 / p
# Create qubits and circuit
qubits = [cirq.LineQubit(0), cirq.LineQubit(1)]
circuit = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.H(qubits[1])]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
)
# Create noise model from NoiseProperties object with specified noise
prop = NoiseProperties(p00=p00, p11=p11)
noise_model = NoiseModelFromNoiseProperties(prop)
noisy_circuit = cirq.Circuit(noise_model.noisy_moments(circuit, qubits))
# Insert expected channels to circuit
expected_circuit = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.H(qubits[1])]),
cirq.Moment([
cirq.GeneralizedAmplitudeDampingChannel(
p=p, gamma=gamma).on_each(qubits)
]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
)
assert_equivalent_op_tree(expected_circuit, noisy_circuit)
# Create Noise Model with just p00
prop_p00 = NoiseProperties(p00=p00)
noise_model_p00 = NoiseModelFromNoiseProperties(prop_p00)
noisy_circuit_p00 = cirq.Circuit(
noise_model_p00.noisy_moments(circuit, qubits))
# Insert expected channels to circuit
expected_circuit_p00 = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.H(qubits[1])]),
cirq.Moment([
cirq.GeneralizedAmplitudeDampingChannel(p=0.0,
gamma=p00).on_each(qubits)
]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
)
assert_equivalent_op_tree(expected_circuit_p00, noisy_circuit_p00)
# Create Noise Model with just p11
prop_p11 = NoiseProperties(p11=p11)
noise_model_p11 = NoiseModelFromNoiseProperties(prop_p11)
noisy_circuit_p11 = cirq.Circuit(
noise_model_p11.noisy_moments(circuit, qubits))
# Insert expected channels to circuit
expected_circuit_p11 = cirq.Circuit(
cirq.Moment([cirq.X(qubits[0])]),
cirq.Moment([cirq.CNOT(qubits[0], qubits[1])]),
cirq.Moment([cirq.H(qubits[1])]),
cirq.Moment([
cirq.GeneralizedAmplitudeDampingChannel(p=1.0,
gamma=p11).on_each(qubits)
]),
cirq.Moment([
cirq.measure(qubits[0], key='q0'),
cirq.measure(qubits[1], key='q1')
]),
)
assert_equivalent_op_tree(expected_circuit_p11, noisy_circuit_p11)
class UndiagrammableGate(cirq.SingleQubitGate):
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)
cgate = cirq.ControlledOperation([cb], gate, control_values=[0])
def test_string_format():
x, y, z = cirq.LineQubit.range(3)
fc0 = cirq.FrozenCircuit()
op0 = cirq.CircuitOperation(fc0)
assert (
str(op0)
== f"""\
{op0.circuit.diagram_name()}:
[ ]"""
)
fc0_global_phase_inner = cirq.FrozenCircuit(
cirq.GlobalPhaseOperation(1j), cirq.GlobalPhaseOperation(1j)
)
op0_global_phase_inner = cirq.CircuitOperation(fc0_global_phase_inner)
fc0_global_phase_outer = cirq.FrozenCircuit(
op0_global_phase_inner, cirq.GlobalPhaseOperation(1j)
)
op0_global_phase_outer = cirq.CircuitOperation(fc0_global_phase_outer)
assert (
str(op0_global_phase_outer)
== f"""\
{op0_global_phase_outer.circuit.diagram_name()}:
[ ]
[ ]
[ global phase: -0.5π ]"""
)
fc1 = cirq.FrozenCircuit(cirq.X(x), cirq.H(y), cirq.CX(y, z), cirq.measure(x, y, z, key='m'))
op1 = cirq.CircuitOperation(fc1)
assert (
str(op1)
== f"""\
{op1.circuit.diagram_name()}:
[ 0: ───X───────M('m')─── ]
[ │ ]
[ 1: ───H───@───M──────── ]
[ │ │ ]
[ 2: ───────X───M──────── ]"""
)
assert (
repr(op1)
== f"""\
cirq.CircuitOperation(
circuit=cirq.FrozenCircuit([
cirq.Moment(
cirq.X(cirq.LineQubit(0)),
cirq.H(cirq.LineQubit(1)),
),
cirq.Moment(
cirq.CNOT(cirq.LineQubit(1), cirq.LineQubit(2)),
),
cirq.Moment(
cirq.measure(cirq.LineQubit(0), cirq.LineQubit(1), cirq.LineQubit(2), key='m'),
),
]),
)"""
)
fc2 = cirq.FrozenCircuit(cirq.X(x), cirq.H(y), cirq.CX(y, x))
op2 = cirq.CircuitOperation(
circuit=fc2,
qubit_map=({y: z}),
repetitions=3,
parent_path=('outer', 'inner'),
repetition_ids=['a', 'b', 'c'],
)
assert (
str(op2)
== f"""\
{op2.circuit.diagram_name()}:
[ 0: ───X───X─── ]
[ │ ]
[ 1: ───H───@─── ](qubit_map={{1: 2}}, parent_path=('outer', 'inner'),\
repetition_ids=['a', 'b', 'c'])"""
)
assert (
repr(op2)
== """\
cirq.CircuitOperation(
circuit=cirq.FrozenCircuit([
cirq.Moment(
cirq.X(cirq.LineQubit(0)),
cirq.H(cirq.LineQubit(1)),
),
cirq.Moment(
cirq.CNOT(cirq.LineQubit(1), cirq.LineQubit(0)),
),
]),
repetitions=3,
qubit_map={cirq.LineQubit(1): cirq.LineQubit(2)},
parent_path=('outer', 'inner'),
repetition_ids=['a', 'b', 'c'],
)"""
)
fc3 = cirq.FrozenCircuit(
cirq.X(x) ** sympy.Symbol('b'),
cirq.measure(x, key='m'),
)
op3 = cirq.CircuitOperation(
circuit=fc3,
qubit_map={x: y},
measurement_key_map={'m': 'p'},
param_resolver={sympy.Symbol('b'): 2},
)
indented_fc3_repr = repr(fc3).replace('\n', '\n ')
assert (
str(op3)
== f"""\
{op3.circuit.diagram_name()}:
[ 0: ───X^b───M('m')─── ](qubit_map={{0: 1}}, \
key_map={{m: p}}, params={{b: 2}})"""
)
assert (
repr(op3)
== f"""\
cirq.CircuitOperation(
circuit={indented_fc3_repr},
qubit_map={{cirq.LineQubit(0): cirq.LineQubit(1)}},
measurement_key_map={{'m': 'p'}},
param_resolver=cirq.ParamResolver({{sympy.Symbol('b'): 2}}),
)"""
)
fc4 = cirq.FrozenCircuit(cirq.X(y))
op4 = cirq.CircuitOperation(fc4)
fc5 = cirq.FrozenCircuit(cirq.X(x), op4)
op5 = cirq.CircuitOperation(fc5)
assert (
repr(op5)
== f"""\
cirq.CircuitOperation(
circuit=cirq.FrozenCircuit([
cirq.Moment(
cirq.X(cirq.LineQubit(0)),
cirq.CircuitOperation(
circuit=cirq.FrozenCircuit([
cirq.Moment(
cirq.X(cirq.LineQubit(1)),
),
]),
),
),
]),
)"""
)
def test_run_no_repetitions():
q0 = cirq.LineQubit(0)
simulator = cirq.CliffordSimulator()
circuit = cirq.Circuit(cirq.H(q0), cirq.measure(q0))
result = simulator.run(circuit, repetitions=0)
assert sum(result.measurements['q(0)']) == 0
import cirq
#define the length of the grid, ie the 'GridQubit'
length = 3
qubits = [cirq.GridQubit(i,j) for i in range (length) for j in range (length)]
print(qubits)
#prints
#making a 'Moment', a circuit on the 'GridQubit'
circuit = cirq.Circuit()
circuit.append(cirq.H(q) for q in qubits if (q.row + q.col) % 2 == 0)
#H(Hadmard 'Gate' object) can be changed to foment this row+column even 'Operation'
circuit.append(cirq.X(q) for q in qubits if (q.row + q.col) % 2 == 1)
#X "Gate' object can be changed to foment this row+column odd 'Operation'
print(circuit)
#changing a 'Moment' to two 'Moments'
circuit = cirq.Circuit()
circuit.append([cirq.H(q) for q in qubits if (q.row + q.col) % 2 == 0],
#H(Hadmard 'Gate' object) can be changed to foment this row+column even 'Operation'
strategy=cirq.InsertStrategy.EARLIEST) #places H gate at earliest moment
circuit.append([cirq.X(q) for q in qubits if (q.row + q.col) % 2 == 1],
#X "Gate' object can be changed to foment this row+column odd 'Operation'
strategy=cirq.InsertStrategy.NEW_THEN_INLINE) #places X gate at new individual moment
print(circuit)
#itterating over a 'Circuit's 'Moments'
for i, m in enumerate(circuit):
print ('Moment {}: {}'.format(i, m))
