def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=9
c.append(cirq.H.on(input_qubit[1])) # number=2
c.append(cirq.H.on(input_qubit[2])) # number=3
c.append(cirq.H.on(input_qubit[3])) # number=4
c.append(cirq.H.on(input_qubit[0])) # number=5
c.append(cirq.CNOT.on(input_qubit[0],input_qubit[3])) # number=28
c.append(cirq.X.on(input_qubit[3])) # number=29
c.append(cirq.CNOT.on(input_qubit[0],input_qubit[3])) # number=30
c.append(cirq.H.on(input_qubit[1])) # number=6
c.append(cirq.X.on(input_qubit[1])) # number=25
c.append(cirq.H.on(input_qubit[2])) # number=7
c.append(cirq.H.on(input_qubit[3])) # number=8
c.append(cirq.Z.on(input_qubit[1])) # number=21
c.append(cirq.CNOT.on(input_qubit[0],input_qubit[3])) # number=14
c.append(cirq.X.on(input_qubit[3])) # number=15
c.append(cirq.rx(1.8001325905069514).on(input_qubit[3])) # number=18
c.append(cirq.Z.on(input_qubit[1])) # number=27
c.append(cirq.CNOT.on(input_qubit[0],input_qubit[3])) # number=16
c.append(cirq.H.on(input_qubit[1])) # number=22
c.append(cirq.CNOT.on(input_qubit[2],input_qubit[0])) # number=10
c.append(cirq.X.on(input_qubit[1])) # number=17
c.append(cirq.CNOT.on(input_qubit[2],input_qubit[0])) # number=11
c.append(cirq.Y.on(input_qubit[0])) # number=12
c.append(cirq.Y.on(input_qubit[0])) # number=13
c.append(cirq.Z.on(input_qubit[2])) # number=26
c.append(cirq.CNOT.on(input_qubit[2],input_qubit[1])) # number=23
c.append(cirq.X.on(input_qubit[0])) # number=19
c.append(cirq.X.on(input_qubit[0])) # number=20
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.H.on(input_qubit[1])) # number=2
c.append(cirq.H.on(input_qubit[2])) # number=3
c.append(cirq.H.on(input_qubit[3])) # number=4
c.append(cirq.SWAP.on(input_qubit[2], input_qubit[0])) # number=5
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=16
c.append(cirq.X.on(input_qubit[1])) # number=17
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=18
c.append(cirq.SWAP.on(input_qubit[2], input_qubit[0])) # number=6
c.append(cirq.rx(-1.0053096491487337).on(input_qubit[2])) # number=10
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[3])) # number=13
c.append(cirq.X.on(input_qubit[3])) # number=14
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[3])) # number=15
c.append(cirq.X.on(input_qubit[3])) # number=9
c.append(cirq.X.on(input_qubit[2])) # number=11
c.append(cirq.X.on(input_qubit[2])) # number=12
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
def test_text_diagrams():
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
circuit = cirq.Circuit(
cirq.X(a),
cirq.Y(a),
cirq.Z(a),
cirq.Z(a)**sympy.Symbol('x'),
cirq.rx(sympy.Symbol('x')).on(a),
cirq.CZ(a, b),
cirq.CNOT(a, b),
cirq.CNOT(b, a),
cirq.H(a)**0.5,
cirq.I(a),
cirq.IdentityGate(2)(a, b),
cirq.cphase(sympy.pi * sympy.Symbol('t')).on(a, b),
)
cirq.testing.assert_has_diagram(
circuit,
"""
a: ───X───Y───Z───Z^x───Rx(x)───@───@───X───H^0.5───I───I───@─────
│ │ │ │ │
b: ─────────────────────────────@───X───@───────────────I───@^t───
""",
)
cirq.testing.assert_has_diagram(
circuit,
"""
a: ---X---Y---Z---Z^x---Rx(x)---@---@---X---H^0.5---I---I---@-----
| | | | |
b: -----------------------------@---X---@---------------I---@^t---
""",
use_unicode_characters=False,
)
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.H.on(input_qubit[1])) # number=2
c.append(cirq.H.on(input_qubit[1])) # number=7
c.append(cirq.X.on(input_qubit[1])) # number=10
c.append(cirq.H.on(input_qubit[2])) # number=3
c.append(cirq.H.on(input_qubit[3])) # number=4
c.append(cirq.CNOT.on(input_qubit[3], input_qubit[0])) # number=5
c.append(cirq.H.on(input_qubit[3])) # number=15
c.append(cirq.CZ.on(input_qubit[2], input_qubit[3])) # number=16
c.append(cirq.H.on(input_qubit[3])) # number=17
c.append(cirq.H.on(input_qubit[0])) # number=18
c.append(cirq.CZ.on(input_qubit[3], input_qubit[0])) # number=19
c.append(cirq.H.on(input_qubit[0])) # number=20
c.append(cirq.rx(2.3027874150813186).on(input_qubit[1])) # number=13
c.append(cirq.SWAP.on(input_qubit[1], input_qubit[0])) # number=8
c.append(cirq.SWAP.on(input_qubit[1], input_qubit[0])) # number=9
c.append(cirq.SWAP.on(input_qubit[2], input_qubit[0])) # number=11
c.append(cirq.SWAP.on(input_qubit[2], input_qubit[0])) # number=12
# circuit end
return c
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.Y.on(input_qubit[1])) # number=2
c.append(cirq.Y.on(input_qubit[1])) # number=4
c.append(cirq.Y.on(input_qubit[1])) # number=3
c.append(cirq.rx(2.0860175219836226).on(input_qubit[1])) # number=7
c.append(cirq.X.on(input_qubit[0])) # number=5
c.append(cirq.X.on(input_qubit[0])) # number=6
c.append(cirq.H.on(input_qubit[0])) # number=10
c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=11
c.append(cirq.H.on(input_qubit[0])) # number=12
c.append(cirq.H.on(input_qubit[0])) # number=13
c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=14
c.append(cirq.H.on(input_qubit[0])) # number=15
c.append(cirq.SWAP.on(input_qubit[1], input_qubit[0])) # number=16
c.append(cirq.SWAP.on(input_qubit[1], input_qubit[0])) # number=17
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=9
c.append(cirq.H.on(input_qubit[1])) # number=2
c.append(cirq.Y.on(input_qubit[3])) # number=18
c.append(cirq.H.on(input_qubit[2])) # number=3
c.append(cirq.H.on(input_qubit[3])) # number=4
c.append(cirq.Y.on(input_qubit[3])) # number=12
c.append(cirq.H.on(input_qubit[0])) # number=5
c.append(cirq.H.on(input_qubit[1])) # number=6
c.append(cirq.H.on(input_qubit[2])) # number=7
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=28
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=31
c.append(cirq.X.on(input_qubit[1])) # number=32
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=33
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=30
c.append(cirq.H.on(input_qubit[3])) # number=8
c.append(cirq.H.on(input_qubit[3])) # number=19
c.append(cirq.CZ.on(input_qubit[0], input_qubit[3])) # number=20
c.append(cirq.H.on(input_qubit[3])) # number=21
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[3])) # number=23
c.append(cirq.X.on(input_qubit[3])) # number=24
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[3])) # number=25
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[3])) # number=17
c.append(cirq.rx(-0.48380526865282825).on(input_qubit[3])) # number=26
c.append(cirq.Y.on(input_qubit[2])) # number=10
c.append(cirq.X.on(input_qubit[2])) # number=22
c.append(cirq.Y.on(input_qubit[2])) # number=11
c.append(cirq.X.on(input_qubit[0])) # number=13
c.append(cirq.X.on(input_qubit[0])) # number=14
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[2])) # number=11
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[2])) # number=31
c.append(cirq.X.on(input_qubit[2])) # number=32
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[2])) # number=33
c.append(cirq.H.on(input_qubit[2])) # number=25
c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=26
c.append(cirq.H.on(input_qubit[2])) # number=27
c.append(cirq.H.on(input_qubit[1])) # number=7
c.append(cirq.CZ.on(input_qubit[2], input_qubit[1])) # number=8
c.append(cirq.rx(-0.3989822670059037).on(input_qubit[1])) # number=30
c.append(cirq.H.on(input_qubit[1])) # number=9
c.append(cirq.H.on(input_qubit[1])) # number=18
c.append(cirq.CZ.on(input_qubit[2], input_qubit[1])) # number=19
c.append(cirq.H.on(input_qubit[1])) # number=20
c.append(cirq.Y.on(input_qubit[1])) # number=14
c.append(cirq.H.on(input_qubit[1])) # number=22
c.append(cirq.CZ.on(input_qubit[2], input_qubit[1])) # number=23
c.append(cirq.H.on(input_qubit[1])) # number=24
c.append(cirq.Z.on(input_qubit[2])) # number=3
c.append(cirq.X.on(input_qubit[1])) # number=17
c.append(cirq.Y.on(input_qubit[2])) # number=5
c.append(cirq.X.on(input_qubit[2])) # number=21
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=15
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=16
c.append(cirq.X.on(input_qubit[2])) # number=28
c.append(cirq.X.on(input_qubit[2])) # number=29
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=9
c.append(cirq.H.on(input_qubit[1])) # number=2
c.append(cirq.H.on(input_qubit[2])) # number=3
c.append(cirq.H.on(input_qubit[2])) # number=17
c.append(cirq.H.on(input_qubit[3])) # number=4
c.append(cirq.H.on(input_qubit[0])) # number=5
c.append(cirq.H.on(input_qubit[1])) # number=6
c.append(cirq.H.on(input_qubit[2])) # number=7
c.append(cirq.H.on(input_qubit[3])) # number=8
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[3])) # number=10
c.append(cirq.H.on(input_qubit[3])) # number=30
c.append(cirq.X.on(input_qubit[3])) # number=11
c.append(cirq.H.on(input_qubit[3])) # number=13
c.append(cirq.CZ.on(input_qubit[0], input_qubit[3])) # number=14
c.append(cirq.H.on(input_qubit[1])) # number=18
c.append(cirq.CZ.on(input_qubit[3], input_qubit[1])) # number=19
c.append(cirq.Z.on(input_qubit[3])) # number=25
c.append(cirq.H.on(input_qubit[1])) # number=20
c.append(cirq.rx(-3.141592653589793).on(input_qubit[3])) # number=26
c.append(cirq.H.on(input_qubit[3])) # number=15
c.append(cirq.H.on(input_qubit[0])) # number=27
c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=28
c.append(cirq.H.on(input_qubit[0])) # number=29
c.append(cirq.H.on(input_qubit[0])) # number=31
c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=32
c.append(cirq.H.on(input_qubit[0])) # number=33
c.append(cirq.X.on(input_qubit[1])) # number=23
c.append(cirq.X.on(input_qubit[1])) # number=24
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.rx(-0.09738937226128368).on(input_qubit[2])) # number=2
c.append(cirq.H.on(input_qubit[1])) # number=3
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=4
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=10
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=15
c.append(cirq.X.on(input_qubit[1])) # number=16
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=17
c.append(cirq.Z.on(input_qubit[1])) # number=11
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=12
c.append(cirq.Y.on(input_qubit[1])) # number=14
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=5
c.append(cirq.X.on(input_qubit[1])) # number=6
c.append(cirq.Z.on(input_qubit[1])) # number=8
c.append(cirq.X.on(input_qubit[1])) # number=7
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
def test_rx_unitary():
s = np.sqrt(0.5)
np.testing.assert_allclose(cirq.unitary(cirq.rx(np.pi / 2)),
np.array([[s, -s * 1j], [-s * 1j, s]]))
np.testing.assert_allclose(cirq.unitary(cirq.rx(-np.pi / 2)),
np.array([[s, s * 1j], [s * 1j, s]]))
np.testing.assert_allclose(cirq.unitary(cirq.rx(0)),
np.array([[1, 0], [0, 1]]))
np.testing.assert_allclose(cirq.unitary(cirq.rx(2 * np.pi)),
np.array([[-1, 0], [0, -1]]))
np.testing.assert_allclose(cirq.unitary(cirq.rx(np.pi)),
np.array([[0, -1j], [-1j, 0]]))
np.testing.assert_allclose(cirq.unitary(cirq.rx(-np.pi)),
np.array([[0, 1j], [1j, 0]]))
def qaoa_max_cut_unitary(qubits, betas, gammas,
graph): # Nodes should be integers
for beta, gamma in zip(betas, gammas):
yield (rzz(-0.5 * gamma).on(qubits[i], qubits[j])
for i, j in graph.edges)
yield cirq.rx(2 * beta).on_each(*qubits)
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
class SerializerTest(tf.test.TestCase, parameterized.TestCase):
"""Tests basic serializer functionality"""
@parameterized.parameters(
[{
'circ_proto_pair': v
} for v in _get_controlled_circuit_proto_pairs() +
_get_circuit_proto_pairs() + _get_noise_proto_pairs()])
def test_serialize_circuit_valid(self, circ_proto_pair):
"""Test conversion of cirq Circuits to tfq_gate_set proto."""
self.assertProtoEquals(
serializer.serialize_circuit(circ_proto_pair[0]),
circ_proto_pair[1])
@parameterized.parameters(
[{
'circ_proto_pair': v
} for v in _get_controlled_circuit_proto_pairs() +
_get_circuit_proto_pairs() + _get_noise_proto_pairs()])
def test_deserialize_circuit_valid(self, circ_proto_pair):
"""Test deserialization of protos in tfq_gate_set."""
# String casting is done here to round floating point values.
# cirq.testing.assert_same_circuits will call break and think
# cirq.Z^0.30000001 is different from cirq.Z^0.3
self.assertEqual(circ_proto_pair[0],
serializer.deserialize_circuit(circ_proto_pair[1]))
@parameterized.parameters(
[{
'circ_proto_pair': v
} for v in _get_controlled_circuit_proto_pairs() +
_get_circuit_proto_pairs() + _get_noise_proto_pairs()])
def test_serialize_deserialize_circuit_consistency(self, circ_proto_pair):
"""Ensure that serializing followed by deserializing works."""
# String casting is done here to round floating point values.
# cirq.testing.assert_same_circuits will call break and think
# cirq.Z^0.30000001 is different from cirq.Z^0.3
self.assertProtoEquals(
serializer.serialize_circuit(
serializer.deserialize_circuit(circ_proto_pair[1])),
circ_proto_pair[1])
self.assertEqual(
serializer.deserialize_circuit(
serializer.serialize_circuit(circ_proto_pair[0])),
circ_proto_pair[0])
def test_serialize_circuit_unsupported_gate(self):
"""Ensure we error on unsupported gates."""
q0 = cirq.GridQubit(0, 0)
q1 = cirq.GridQubit(0, 1)
unsupported_circuit = cirq.Circuit(cirq.QFT(q0, q1))
with self.assertRaises(ValueError):
serializer.serialize_circuit(unsupported_circuit)
def test_serialize_circuit_with_large_identity(self):
"""Ensure that multi qubit identity errors correctly."""
q0 = cirq.GridQubit(0, 0)
q1 = cirq.GridQubit(0, 1)
unsupported_circuit = cirq.Circuit(
cirq.IdentityGate(num_qubits=2)(q0, q1))
with self.assertRaisesRegex(ValueError, expected_regex="cirq.I"):
serializer.serialize_circuit(unsupported_circuit)
@parameterized.parameters([
{
"gate_with_param": g(p)
}
# Use a gate from each category of serializer
for g in [
# eigen
lambda p: cirq.Circuit(
cirq.HPowGate(exponent=p, global_shift=p)
(cirq.GridQubit(0, 0))),
# phased eigen
lambda p: cirq.Circuit(
cirq.PhasedXPowGate(
phase_exponent=p, exponent=p, global_shift=p)
(cirq.GridQubit(0, 0))),
# fsim
lambda p: cirq.Circuit(
cirq.FSimGate(theta=p, phi=p)
(cirq.GridQubit(0, 0), cirq.GridQubit(0, 1))),
]
# Attempt parameterization with a variety of numeric types
for p in
[0.35, float(0.35), 35e-2,
np.float32(0.35),
np.float64(0.35), 7]
])
def test_serialize_circuit_valid_number_types(self, gate_with_param):
"""Tests number datatype support by our serializer."""
self.assertAllClose(
gate_with_param.unitary(),
serializer.deserialize_circuit(
serializer.serialize_circuit(gate_with_param)).unitary())
def test_serialize_circuit_unsupported_value(self):
"""Ensure we error on unsupported arithmetic expressions and qubits."""
q0 = cirq.GridQubit(0, 0)
unsupported_circuit = cirq.Circuit(
cirq.HPowGate()(q0)**(sympy.Symbol('alpha') + 1))
q1 = cirq.NamedQubit('wont work')
unsupported_circuit2 = cirq.Circuit(cirq.H(q1))
with self.assertRaises(ValueError):
serializer.serialize_circuit(unsupported_circuit)
with self.assertRaises(ValueError):
serializer.serialize_circuit(unsupported_circuit2)
def test_serialize_controlled_circuit_unsupported_value(self):
"""Ensure serializing invalid controlled gates fails gracefully."""
qubits = cirq.GridQubit.rect(1, 2)
bad_qubit = cirq.LineQubit(5)
invalid_control = cirq.Circuit(
cirq.H(qubits[0]).controlled_by(qubits[1], bad_qubit))
invalid_symbol = cirq.Circuit((cirq.HPowGate()(
qubits[0])**(sympy.Symbol('alpha') + 1)).controlled_by(qubits[1]))
with self.assertRaises(ValueError):
serializer.serialize_circuit(invalid_control)
with self.assertRaises(ValueError):
serializer.serialize_circuit(invalid_symbol)
def test_serialize_noise_channel_unsupported_value(self):
"""Ensure serializing invalid channels fails gracefully."""
qubit = cirq.LineQubit(5)
simple_circuit = cirq.Circuit(cirq.depolarize(0.3)(qubit))
with self.assertRaises(ValueError):
serializer.serialize_circuit(simple_circuit)
@parameterized.parameters([{'inp': v} for v in ['wrong', 1.0, None, []]])
def test_serialize_circuit_wrong_type(self, inp):
"""Attempt to serialize invalid objects types."""
with self.assertRaises(TypeError):
serializer.serialize_circuit(input)
@parameterized.parameters([{'inp': v} for v in ['wrong', 1.0, None, []]])
def test_deserialize_circuit_wrong_type(self, inp):
"""Attempt to deserialize invalid objects types."""
with self.assertRaises(TypeError):
serializer.deserialize_circuit(input)
@parameterized.parameters([{'inp': v} for v in ['wrong', 1.0, None, []]])
def test_serialize_paulisum_wrong_type(self, inp):
"""Attempt to serialize invalid object types."""
with self.assertRaises(TypeError):
serializer.serialize_paulisum(inp)
@parameterized.parameters([{'inp': v} for v in ['wrong', 1.0, None, []]])
def test_deserialize_paulisum_wrong_type(self, inp):
"""Attempt to deserialize invalid object types."""
with self.assertRaises(TypeError):
serializer.deserialize_paulisum(inp)
def test_serialize_paulisum_invalid(self):
"""Ensure we don't support anything but GridQubits."""
q0 = cirq.NamedQubit('wont work')
a = 3.0 * cirq.Z(q0) - 2.0 * cirq.X(q0)
with self.assertRaises(ValueError):
serializer.serialize_paulisum(a)
@parameterized.parameters([{
'sum_proto_pair': v
} for v in _get_valid_pauli_proto_pairs()])
def test_serialize_paulisum_simple(self, sum_proto_pair):
"""Ensure serialization is correct."""
self.assertProtoEquals(
sum_proto_pair[1],
serializer.serialize_paulisum(sum_proto_pair[0]))
@parameterized.parameters([{
'sum_proto_pair': v
} for v in _get_valid_pauli_proto_pairs()])
def test_deserialize_paulisum_simple(self, sum_proto_pair):
"""Ensure deserialization is correct."""
self.assertEqual(serializer.deserialize_paulisum(sum_proto_pair[1]),
sum_proto_pair[0])
@parameterized.parameters([{
'sum_proto_pair': v
} for v in _get_valid_pauli_proto_pairs()])
def test_serialize_deserialize_paulisum_consistency(self, sum_proto_pair):
"""Serialize and deserialize and ensure nothing changed."""
self.assertEqual(
serializer.serialize_paulisum(
serializer.deserialize_paulisum(sum_proto_pair[1])),
sum_proto_pair[1])
self.assertEqual(
serializer.deserialize_paulisum(
serializer.serialize_paulisum(sum_proto_pair[0])),
sum_proto_pair[0])
@parameterized.parameters([
{
'gate': cirq.rx(3.0 * sympy.Symbol('alpha'))
},
{
'gate': cirq.ry(-1.0 * sympy.Symbol('alpha'))
},
{
'gate': cirq.rz(sympy.Symbol('alpha'))
},
])
def test_serialize_deserialize_special_case_one_qubit(self, gate):
"""Check output state equality."""
q0 = cirq.GridQubit(0, 0)
c = cirq.Circuit(gate(q0))
c = c._resolve_parameters_(cirq.ParamResolver({"alpha": 0.1234567}))
before = c.unitary()
c2 = serializer.deserialize_circuit(serializer.serialize_circuit(c))
after = c2.unitary()
self.assertAllClose(before, after)
def test_terminal_measurement_support(self):
"""Test that non-terminal measurements error during serialization."""
q0 = cirq.GridQubit(0, 0)
q1 = cirq.GridQubit(0, 1)
simple_circuit = cirq.Circuit(cirq.H(q0), cirq.measure(q0), cirq.H(q1),
cirq.Z(q1), cirq.measure(q1))
simple_circuit_before_call = copy.deepcopy(simple_circuit)
expected_circuit = cirq.Circuit(cirq.Moment([cirq.H(q0),
cirq.H(q1)]),
cirq.Moment([cirq.Z(q1)]),
cirq.Moment([]))
self.assertEqual(serializer.serialize_circuit(simple_circuit),
serializer.serialize_circuit(expected_circuit))
# Check that serialization didn't modify existing circuit.
self.assertEqual(simple_circuit, simple_circuit_before_call)
invalid_circuit = cirq.Circuit(cirq.H(q0), cirq.measure(q0),
cirq.measure(q0))
with self.assertRaisesRegex(ValueError, expected_regex="non-terminal"):
serializer.serialize_circuit(invalid_circuit)
def test_serialize_deserialize_identity(self):
"""Confirm that identity gates can be serialized and deserialized."""
q0 = cirq.GridQubit(0, 0)
q1 = cirq.GridQubit(0, 1)
paulisum_with_identity = cirq.PauliSum.from_pauli_strings([
cirq.PauliString(cirq.I(q0)),
cirq.PauliString(cirq.Z(q0), cirq.Z(q1)),
])
self.assertEqual(
paulisum_with_identity,
serializer.deserialize_paulisum(
serializer.serialize_paulisum(paulisum_with_identity)))
def test_rxyz_circuit_diagram():
q = cirq.NamedQubit('q')
cirq.testing.assert_has_diagram(
cirq.Circuit(
cirq.rx(np.pi).on(q),
cirq.rx(-np.pi).on(q),
cirq.rx(-np.pi + 0.00001).on(q),
cirq.rx(-np.pi - 0.00001).on(q),
cirq.rx(3 * np.pi).on(q),
cirq.rx(7 * np.pi / 2).on(q),
cirq.rx(9 * np.pi / 2 + 0.00001).on(q),
),
"""
q: ───Rx(π)───Rx(-π)───Rx(-π)───Rx(-π)───Rx(-π)───Rx(-0.5π)───Rx(0.5π)───
""",
)
cirq.testing.assert_has_diagram(
cirq.Circuit(
cirq.rx(np.pi).on(q),
cirq.rx(np.pi / 2).on(q),
cirq.rx(-np.pi + 0.00001).on(q),
cirq.rx(-np.pi - 0.00001).on(q),
),
"""
q: ---Rx(pi)---Rx(0.5pi)---Rx(-pi)---Rx(-pi)---
""",
use_unicode_characters=False,
)
cirq.testing.assert_has_diagram(
cirq.Circuit(
cirq.ry(np.pi).on(q),
cirq.ry(-np.pi).on(q),
cirq.ry(3 * np.pi).on(q),
cirq.ry(9 * np.pi / 2).on(q),
),
"""
q: ───Ry(π)───Ry(-π)───Ry(-π)───Ry(0.5π)───
""",
)
cirq.testing.assert_has_diagram(
cirq.Circuit(
cirq.rz(np.pi).on(q),
cirq.rz(-np.pi).on(q),
cirq.rz(3 * np.pi).on(q),
cirq.rz(9 * np.pi / 2).on(q),
cirq.rz(9 * np.pi / 2 + 0.00001).on(q),
),
"""
q: ───Rz(π)───Rz(-π)───Rz(-π)───Rz(0.5π)───Rz(0.5π)───
""",
)
expected_matrix = get_matrix(expected)
assert np.allclose(actual_matrix, expected_matrix)
actual_expansion = cirq.pauli_expansion(actual)
expected_expansion = cirq.pauli_expansion(expected)
assert set(actual_expansion.keys()) == set(expected_expansion.keys())
for name in actual_expansion.keys():
assert abs(actual_expansion[name] - expected_expansion[name]) < 1e-12
@pytest.mark.parametrize('expression, expected_result', (
((cirq.X + cirq.Z) / np.sqrt(2), cirq.H),
(cirq.X - cirq.Y, -cirq.Y + cirq.X),
(cirq.X + cirq.S - cirq.X, cirq.S),
(cirq.Y - 2 * cirq.Y, -cirq.Y),
(cirq.rx(0.2), np.cos(0.1) * cirq.I - 1j * np.sin(0.1) * cirq.X),
(1j * cirq.H * 1j, -cirq.H),
(-1j * cirq.Y, cirq.ry(np.pi)),
(np.sqrt(-1j) * cirq.S, cirq.rz(np.pi / 2)),
(0.5 * (cirq.IdentityGate(2) + cirq.XX + cirq.YY + cirq.ZZ), cirq.SWAP),
((cirq.IdentityGate(2) + 1j *
(cirq.XX + cirq.YY) + cirq.ZZ) / 2, cirq.ISWAP),
(cirq.CNOT + 0 * cirq.SWAP, cirq.CNOT),
(0.5 * cirq.FREDKIN, cirq.FREDKIN / 2),
(cirq.FREDKIN * 0.5, cirq.FREDKIN / 2),
(((cirq.X + cirq.Y) / np.sqrt(2))**2, cirq.I),
((cirq.X + cirq.Z)**3, 2 * (cirq.X + cirq.Z)),
((cirq.X + 1j * cirq.Y)**2, cirq.LinearCombinationOfGates({})),
((cirq.X - 1j * cirq.Y)**2, cirq.LinearCombinationOfGates({})),
(((3 * cirq.X - 4 * cirq.Y + 12 * cirq.Z) / 13)**24, cirq.I),
(((3 * cirq.X - 4 * cirq.Y + 12 * cirq.Z) / 13)**25,
def uc(target): return [cirq.rx(1).on(target)]
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=3
c.append(cirq.H.on(input_qubit[1])) # number=4
c.append(cirq.H.on(input_qubit[2])) # number=5
c.append(cirq.H.on(input_qubit[1])) # number=29
c.append(cirq.CZ.on(input_qubit[3],input_qubit[1])) # number=30
c.append(cirq.H.on(input_qubit[1])) # number=31
c.append(cirq.H.on(input_qubit[3])) # number=6
c.append(cirq.H.on(input_qubit[4])) # number=21
for i in range(2):
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.H.on(input_qubit[1])) # number=2
c.append(cirq.H.on(input_qubit[2])) # number=7
c.append(cirq.H.on(input_qubit[3])) # number=8
c.append(cirq.H.on(input_qubit[0])) # number=17
c.append(cirq.H.on(input_qubit[1])) # number=18
c.append(cirq.H.on(input_qubit[2])) # number=19
c.append(cirq.H.on(input_qubit[3])) # number=20
c.append(cirq.H.on(input_qubit[0])) # number=38
c.append(cirq.CZ.on(input_qubit[1],input_qubit[0])) # number=39
c.append(cirq.H.on(input_qubit[0])) # number=40
c.append(cirq.H.on(input_qubit[0])) # number=51
c.append(cirq.CZ.on(input_qubit[1],input_qubit[0])) # number=52
c.append(cirq.H.on(input_qubit[0])) # number=53
c.append(cirq.H.on(input_qubit[0])) # number=64
c.append(cirq.CZ.on(input_qubit[1],input_qubit[0])) # number=65
c.append(cirq.H.on(input_qubit[0])) # number=66
c.append(cirq.X.on(input_qubit[0])) # number=49
c.append(cirq.H.on(input_qubit[0])) # number=57
c.append(cirq.CZ.on(input_qubit[1],input_qubit[0])) # number=58
c.append(cirq.H.on(input_qubit[0])) # number=59
c.append(cirq.H.on(input_qubit[0])) # number=54
c.append(cirq.CZ.on(input_qubit[1],input_qubit[0])) # number=55
c.append(cirq.H.on(input_qubit[0])) # number=56
c.append(cirq.H.on(input_qubit[4])) # number=41
c.append(cirq.H.on(input_qubit[0])) # number=61
c.append(cirq.CZ.on(input_qubit[1],input_qubit[0])) # number=62
c.append(cirq.H.on(input_qubit[0])) # number=63
c.append(cirq.CNOT.on(input_qubit[0],input_qubit[1])) # number=67
c.append(cirq.X.on(input_qubit[1])) # number=68
c.append(cirq.CNOT.on(input_qubit[0],input_qubit[1])) # number=69
c.append(cirq.H.on(input_qubit[2])) # number=25
c.append(cirq.CZ.on(input_qubit[0],input_qubit[2])) # number=26
c.append(cirq.H.on(input_qubit[2])) # number=27
c.append(cirq.X.on(input_qubit[2])) # number=23
c.append(cirq.CNOT.on(input_qubit[0],input_qubit[2])) # number=24
c.append(cirq.CNOT.on(input_qubit[0],input_qubit[3])) # number=32
c.append(cirq.X.on(input_qubit[3])) # number=33
c.append(cirq.H.on(input_qubit[3])) # number=42
c.append(cirq.CZ.on(input_qubit[0],input_qubit[3])) # number=43
c.append(cirq.H.on(input_qubit[3])) # number=44
c.append(cirq.X.on(input_qubit[0])) # number=13
c.append(cirq.rx(0.6157521601035993).on(input_qubit[1])) # number=60
c.append(cirq.X.on(input_qubit[1])) # number=14
c.append(cirq.X.on(input_qubit[2])) # number=15
c.append(cirq.X.on(input_qubit[3])) # number=16
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=3
c.append(cirq.H.on(input_qubit[1])) # number=4
c.append(cirq.H.on(input_qubit[2])) # number=5
c.append(cirq.H.on(input_qubit[3])) # number=6
c.append(cirq.H.on(input_qubit[0])) # number=38
c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=39
c.append(cirq.H.on(input_qubit[0])) # number=40
c.append(cirq.H.on(input_qubit[0])) # number=49
c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=50
c.append(cirq.H.on(input_qubit[0])) # number=51
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=52
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=56
c.append(cirq.Z.on(input_qubit[1])) # number=57
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=58
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=54
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=47
c.append(cirq.H.on(input_qubit[0])) # number=32
c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=33
c.append(cirq.H.on(input_qubit[0])) # number=34
c.append(cirq.X.on(input_qubit[4])) # number=48
c.append(cirq.H.on(input_qubit[4])) # number=21
for i in range(2):
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.H.on(input_qubit[1])) # number=2
c.append(cirq.H.on(input_qubit[2])) # number=7
c.append(cirq.H.on(input_qubit[3])) # number=8
c.append(cirq.CNOT.on(input_qubit[3], input_qubit[0])) # number=41
c.append(cirq.Z.on(input_qubit[3])) # number=42
c.append(cirq.CNOT.on(input_qubit[3], input_qubit[0])) # number=43
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[3])) # number=44
c.append(cirq.H.on(input_qubit[0])) # number=17
c.append(cirq.H.on(input_qubit[1])) # number=18
c.append(cirq.H.on(input_qubit[2])) # number=19
c.append(cirq.H.on(input_qubit[3])) # number=20
c.append(cirq.X.on(input_qubit[0])) # number=9
c.append(cirq.X.on(input_qubit[1])) # number=10
c.append(cirq.X.on(input_qubit[2])) # number=11
c.append(cirq.rx(-2.9845130209103035).on(input_qubit[4])) # number=55
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[3])) # number=35
c.append(cirq.X.on(input_qubit[3])) # number=36
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[3])) # number=37
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=24
c.append(cirq.X.on(input_qubit[0])) # number=25
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=26
c.append(cirq.X.on(input_qubit[1])) # number=14
c.append(cirq.X.on(input_qubit[2])) # number=15
c.append(cirq.X.on(input_qubit[3])) # number=16
c.append(cirq.X.on(input_qubit[1])) # number=22
c.append(cirq.X.on(input_qubit[1])) # number=23
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.H.on(input_qubit[2])) # number=38
c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=39
c.append(cirq.H.on(input_qubit[2])) # number=40
c.append(cirq.H.on(input_qubit[2])) # number=59
c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=60
c.append(cirq.H.on(input_qubit[2])) # number=61
c.append(cirq.H.on(input_qubit[2])) # number=42
c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=43
c.append(cirq.H.on(input_qubit[2])) # number=44
c.append(cirq.H.on(input_qubit[2])) # number=48
c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=49
c.append(cirq.H.on(input_qubit[2])) # number=50
c.append(cirq.H.on(input_qubit[2])) # number=71
c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=72
c.append(cirq.H.on(input_qubit[2])) # number=73
c.append(cirq.X.on(input_qubit[2])) # number=55
c.append(cirq.H.on(input_qubit[2])) # number=67
c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=68
c.append(cirq.H.on(input_qubit[2])) # number=69
c.append(cirq.H.on(input_qubit[2])) # number=64
c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=65
c.append(cirq.H.on(input_qubit[2])) # number=66
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[2])) # number=37
c.append(cirq.H.on(input_qubit[2])) # number=51
c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=52
c.append(cirq.H.on(input_qubit[2])) # number=53
c.append(cirq.H.on(input_qubit[2])) # number=25
c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=26
c.append(cirq.H.on(input_qubit[2])) # number=27
c.append(cirq.H.on(input_qubit[1])) # number=7
c.append(cirq.CZ.on(input_qubit[2], input_qubit[1])) # number=8
c.append(cirq.rx(0.17592918860102857).on(input_qubit[2])) # number=34
c.append(cirq.rx(-0.3989822670059037).on(input_qubit[1])) # number=30
c.append(cirq.H.on(input_qubit[1])) # number=9
c.append(cirq.H.on(input_qubit[1])) # number=18
c.append(cirq.rx(2.3310617489636263).on(input_qubit[2])) # number=58
c.append(cirq.CZ.on(input_qubit[2], input_qubit[1])) # number=19
c.append(cirq.H.on(input_qubit[1])) # number=20
c.append(cirq.X.on(input_qubit[1])) # number=62
c.append(cirq.Y.on(input_qubit[1])) # number=14
c.append(cirq.H.on(input_qubit[1])) # number=22
c.append(cirq.CZ.on(input_qubit[2], input_qubit[1])) # number=23
c.append(cirq.rx(-0.9173450548482197).on(input_qubit[1])) # number=57
c.append(cirq.CNOT.on(input_qubit[2], input_qubit[1])) # number=63
c.append(cirq.H.on(input_qubit[1])) # number=24
c.append(cirq.CNOT.on(input_qubit[2], input_qubit[0])) # number=74
c.append(cirq.Z.on(input_qubit[2])) # number=75
c.append(cirq.CNOT.on(input_qubit[2], input_qubit[0])) # number=76
c.append(cirq.CNOT.on(input_qubit[2], input_qubit[1])) # number=70
c.append(cirq.Z.on(input_qubit[1])) # number=41
c.append(cirq.X.on(input_qubit[1])) # number=17
c.append(cirq.Y.on(input_qubit[2])) # number=5
c.append(cirq.X.on(input_qubit[2])) # number=21
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=15
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=16
c.append(cirq.X.on(input_qubit[2])) # number=28
c.append(cirq.X.on(input_qubit[2])) # number=29
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
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())
import cirq
from cirq.contrib.svg.svg import tdd_to_svg
import sympy
if __name__ == "__main__":
qubits = cirq.LineQubit.range(10)
x = sympy.symbols("x0:10")
thetas = sympy.symbols("t0:10")
circuit = cirq.Circuit()
for i in range(10):
circuit.append(cirq.rx(x[i])(qubits[i]))
circuit.append(cirq.ry(thetas[i])(qubits[i]))
circuit.append(cirq.measure_each(*qubits))
with open("simple_VQC.svg", "w") as file:
file.write(
tdd_to_svg(
circuit.to_text_diagram_drawer(), ref_boxheight=40, ref_boxwidth=160,
)
)
def qaoa_max_cut_unitary(qubits, p, graph): # Nodes should be integers
for index in range(p):
yield (
rzz(-0.5 * sympy.Symbol('gamma'+str(index))).on(qubits[i], qubits[j]) for i, j in graph.edges)
yield cirq.rx(2 * sympy.Symbol('beta'+str(index))).on_each(*qubits)
def _build_qsp_sequence(self, q):
self.append(cirq.Circuit(cirq.rz(self.phis[0])(q)))
for phi in self.phis[1:]:
c = cirq.Circuit(cirq.rx(self.theta)(q), cirq.rz(phi)(q))
self.append(c)
def bitfliplayer_mc(ci: Circuit, g: Graph, px: float, py: float,
pz: float) -> None:
n = len(g.nodes)
for i in range(n):
ci.depolarizing(i, px=px, py=py, pz=pz)
bitfliplayer.__repr__ = """bitfliplayer_mc""" # type: ignore
bitfliplayer.__trainable__ = True # type: ignore
## below is similar layer but in cirq API instead of tensrocircuit native API
## special notes to the API, the arguments order are different due to historical reason
basis_rotation = {
"x": (cirq.H, cirq.H),
"y": (cirq.rx(-np.pi / 2), cirq.rx(np.pi / 2)),
"z": None,
}
def generate_qubits(g: Graph) -> List[Any]:
return sorted([v for _, v in g.nodes.data("qubit")])
def generate_cirq_double_gate(gates: str) -> None:
d1, d2 = gates[0], gates[1]
r1, r2 = basis_rotation[d1], basis_rotation[d2]
def f(
circuit: cirq.Circuit,
qubit1: cirq.GridQubit,
def test_non_diagrammable_subop():
qbits = cirq.LineQubit.range(2)
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)
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=3
c.append(cirq.H.on(input_qubit[1])) # number=4
c.append(cirq.H.on(input_qubit[2])) # number=5
c.append(cirq.H.on(input_qubit[3])) # number=6
c.append(cirq.H.on(input_qubit[3])) # number=59
c.append(cirq.H.on(input_qubit[4])) # number=21
c.append(cirq.H.on(input_qubit[0])) # number=43
c.append(cirq.CZ.on(input_qubit[4], input_qubit[0])) # number=44
c.append(cirq.H.on(input_qubit[0])) # number=45
c.append(cirq.H.on(input_qubit[0])) # number=56
c.append(cirq.CZ.on(input_qubit[4], input_qubit[0])) # number=57
c.append(cirq.H.on(input_qubit[0])) # number=58
c.append(cirq.Z.on(input_qubit[4])) # number=47
c.append(cirq.CNOT.on(input_qubit[4], input_qubit[0])) # number=48
c.append(cirq.H.on(input_qubit[0])) # number=37
c.append(cirq.CZ.on(input_qubit[4], input_qubit[0])) # number=38
c.append(cirq.H.on(input_qubit[0])) # number=39
for i in range(2):
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.rx(-1.0430087609918113).on(input_qubit[4])) # number=36
c.append(cirq.H.on(input_qubit[1])) # number=2
c.append(cirq.H.on(input_qubit[2])) # number=7
c.append(cirq.H.on(input_qubit[3])) # number=8
c.append(cirq.H.on(input_qubit[0])) # number=17
c.append(cirq.rx(2.4912829742967055).on(input_qubit[2])) # number=26
c.append(cirq.H.on(input_qubit[1])) # number=18
c.append(cirq.H.on(input_qubit[2])) # number=19
c.append(cirq.H.on(input_qubit[2])) # number=55
c.append(cirq.H.on(input_qubit[2])) # number=25
c.append(cirq.H.on(input_qubit[3])) # number=20
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=40
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=52
c.append(cirq.X.on(input_qubit[0])) # number=53
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=54
c.append(cirq.H.on(input_qubit[0])) # number=49
c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=50
c.append(cirq.H.on(input_qubit[0])) # number=51
c.append(cirq.X.on(input_qubit[1])) # number=10
c.append(cirq.rx(-0.06597344572538572).on(input_qubit[3])) # number=27
c.append(cirq.H.on(input_qubit[2])) # number=60
c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=61
c.append(cirq.H.on(input_qubit[2])) # number=62
c.append(cirq.X.on(input_qubit[2])) # number=23
c.append(cirq.H.on(input_qubit[2])) # number=28
c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=29
c.append(cirq.H.on(input_qubit[2])) # number=30
c.append(cirq.X.on(input_qubit[3])) # number=12
c.append(cirq.X.on(input_qubit[0])) # number=13
c.append(cirq.X.on(input_qubit[1])) # number=14
c.append(cirq.X.on(input_qubit[2])) # number=15
c.append(cirq.X.on(input_qubit[3])) # number=16
c.append(cirq.H.on(input_qubit[4])) # number=35
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
cirq.testing.assert_allclose_up_to_global_phase(cirq.unitary(
HALF_PI_GATE_SET.deserialize_op(proto)),
cirq.unitary(op),
atol=1e-6)
@pytest.mark.parametrize(
('gate', 'axis_half_turns', 'half_turns'),
[
(cirq.X**0.25, 0.0, 0.25),
(cirq.Y**0.25, 0.5, 0.25),
(cirq.XPowGate(exponent=0.125), 0.0, 0.125),
(cirq.YPowGate(exponent=0.125), 0.5, 0.125),
(cirq.PhasedXPowGate(exponent=0.125,
phase_exponent=0.25), 0.25, 0.125),
(cirq.rx(0.125 * np.pi), 0.0, 0.125),
(cirq.ry(0.25 * np.pi), 0.5, 0.25),
],
)
def test_serialize_deserialize_arbitrary_xy(gate, axis_half_turns, half_turns):
op = gate.on(cirq.GridQubit(1, 2))
expected = op_proto({
'gate': {
'id': 'xy'
},
'args': {
'axis_half_turns': {
'arg_value': {
'float_value': axis_half_turns
}
},
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=3
c.append(cirq.rx(-1.3603096190043806).on(input_qubit[2])) # number=28
c.append(cirq.H.on(input_qubit[1])) # number=4
c.append(cirq.H.on(input_qubit[2])) # number=5
c.append(cirq.H.on(input_qubit[3])) # number=6
c.append(cirq.H.on(input_qubit[4])) # number=21
for i in range(2):
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.H.on(input_qubit[1])) # number=2
c.append(cirq.H.on(input_qubit[2])) # number=7
c.append(cirq.H.on(input_qubit[3])) # number=8
c.append(cirq.H.on(input_qubit[3])) # number=34
c.append(cirq.CZ.on(input_qubit[4], input_qubit[3])) # number=35
c.append(cirq.H.on(input_qubit[3])) # number=36
c.append(cirq.H.on(input_qubit[0])) # number=17
c.append(cirq.H.on(input_qubit[1])) # number=18
c.append(cirq.H.on(input_qubit[2])) # number=53
c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=54
c.append(cirq.H.on(input_qubit[2])) # number=55
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[2])) # number=56
c.append(cirq.X.on(input_qubit[2])) # number=57
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[2])) # number=58
c.append(cirq.H.on(input_qubit[2])) # number=47
c.append(cirq.CZ.on(input_qubit[0], input_qubit[2])) # number=48
c.append(cirq.H.on(input_qubit[2])) # number=49
c.append(cirq.rx(-1.9697785938008003).on(input_qubit[1])) # number=37
c.append(cirq.H.on(input_qubit[2])) # number=19
c.append(cirq.H.on(input_qubit[3])) # number=20
c.append(cirq.H.on(input_qubit[0])) # number=38
c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=39
c.append(cirq.H.on(input_qubit[0])) # number=40
c.append(cirq.X.on(input_qubit[0])) # number=32
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=33
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=24
c.append(cirq.X.on(input_qubit[1])) # number=25
c.append(cirq.X.on(input_qubit[1])) # number=41
c.append(cirq.H.on(input_qubit[1])) # number=50
c.append(cirq.CZ.on(input_qubit[0], input_qubit[1])) # number=51
c.append(cirq.H.on(input_qubit[1])) # number=52
c.append(cirq.X.on(input_qubit[2])) # number=11
c.append(cirq.CNOT.on(input_qubit[2], input_qubit[3])) # number=30
c.append(cirq.X.on(input_qubit[3])) # number=12
c.append(cirq.H.on(input_qubit[2])) # number=42
c.append(cirq.X.on(input_qubit[0])) # number=13
c.append(cirq.X.on(input_qubit[1])) # number=14
c.append(cirq.X.on(input_qubit[2])) # number=15
c.append(cirq.X.on(input_qubit[4])) # number=46
c.append(cirq.X.on(input_qubit[3])) # number=16
c.append(cirq.X.on(input_qubit[1])) # number=22
c.append(cirq.X.on(input_qubit[1])) # number=23
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.H.on(input_qubit[1])) # number=70
c.append(cirq.rx(-0.09738937226128368).on(input_qubit[2])) # number=2
c.append(cirq.H.on(input_qubit[1])) # number=33
c.append(cirq.Y.on(input_qubit[2])) # number=56
c.append(cirq.CZ.on(input_qubit[2], input_qubit[1])) # number=34
c.append(cirq.H.on(input_qubit[1])) # number=35
c.append(cirq.H.on(input_qubit[1])) # number=3
c.append(cirq.H.on(input_qubit[0])) # number=45
c.append(cirq.CNOT.on(input_qubit[2], input_qubit[1])) # number=60
c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=46
c.append(cirq.H.on(input_qubit[0])) # number=47
c.append(cirq.Y.on(input_qubit[1])) # number=15
c.append(cirq.H.on(input_qubit[0])) # number=66
c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=67
c.append(cirq.H.on(input_qubit[0])) # number=68
c.append(cirq.H.on(input_qubit[1])) # number=19
c.append(cirq.CZ.on(input_qubit[0], input_qubit[1])) # number=20
c.append(cirq.rx(-0.6000441968356504).on(input_qubit[1])) # number=28
c.append(cirq.H.on(input_qubit[1])) # number=21
c.append(cirq.H.on(input_qubit[1])) # number=30
c.append(cirq.CZ.on(input_qubit[0], input_qubit[1])) # number=31
c.append(cirq.H.on(input_qubit[1])) # number=32
c.append(cirq.H.on(input_qubit[1])) # number=57
c.append(cirq.CZ.on(input_qubit[0], input_qubit[1])) # number=58
c.append(cirq.H.on(input_qubit[1])) # number=59
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=51
c.append(cirq.X.on(input_qubit[1])) # number=52
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=53
c.append(cirq.CNOT.on(input_qubit[0], input_qubit[1])) # number=50
c.append(cirq.Y.on(input_qubit[2])) # number=69
c.append(cirq.H.on(input_qubit[2])) # number=29
c.append(cirq.H.on(input_qubit[1])) # number=36
c.append(cirq.X.on(input_qubit[1])) # number=64
c.append(cirq.CZ.on(input_qubit[0], input_qubit[1])) # number=37
c.append(cirq.Y.on(input_qubit[2])) # number=44
c.append(cirq.H.on(input_qubit[1])) # number=38
c.append(cirq.Z.on(input_qubit[1])) # number=55
c.append(cirq.H.on(input_qubit[1])) # number=61
c.append(cirq.CZ.on(input_qubit[0], input_qubit[1])) # number=62
c.append(cirq.CNOT.on(input_qubit[2], input_qubit[0])) # number=71
c.append(cirq.Z.on(input_qubit[2])) # number=72
c.append(cirq.CNOT.on(input_qubit[2], input_qubit[0])) # number=73
c.append(cirq.H.on(input_qubit[1])) # number=63
c.append(cirq.Z.on(input_qubit[1])) # number=11
c.append(cirq.rx(-1.1780972450961724).on(input_qubit[2])) # number=54
c.append(cirq.H.on(input_qubit[1])) # number=42
c.append(cirq.H.on(input_qubit[0])) # number=39
c.append(cirq.CZ.on(input_qubit[1], input_qubit[0])) # number=40
c.append(cirq.H.on(input_qubit[0])) # number=41
c.append(cirq.CNOT.on(input_qubit[2], input_qubit[1])) # number=26
c.append(cirq.Y.on(input_qubit[1])) # number=14
c.append(cirq.CNOT.on(input_qubit[1], input_qubit[0])) # number=5
c.append(cirq.X.on(input_qubit[1])) # number=6
c.append(cirq.Z.on(input_qubit[1])) # number=8
c.append(cirq.X.on(input_qubit[1])) # number=7
c.append(cirq.H.on(input_qubit[2])) # number=43
c.append(cirq.rx(-2.42845112122491).on(input_qubit[1])) # number=25
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
def make_circuit(n: int, input_qubit):
c = cirq.Circuit() # circuit begin
c.append(cirq.H.on(input_qubit[0])) # number=3
c.append(cirq.H.on(input_qubit[1])) # number=4
c.append(cirq.CNOT.on(input_qubit[4],input_qubit[0])) # number=54
c.append(cirq.Z.on(input_qubit[4])) # number=55
c.append(cirq.CNOT.on(input_qubit[4],input_qubit[0])) # number=56
c.append(cirq.H.on(input_qubit[2])) # number=50
c.append(cirq.CZ.on(input_qubit[4],input_qubit[2])) # number=51
c.append(cirq.H.on(input_qubit[2])) # number=52
c.append(cirq.H.on(input_qubit[2])) # number=5
c.append(cirq.H.on(input_qubit[3])) # number=6
c.append(cirq.H.on(input_qubit[4])) # number=21
for i in range(2):
c.append(cirq.H.on(input_qubit[0])) # number=1
c.append(cirq.H.on(input_qubit[1])) # number=2
c.append(cirq.H.on(input_qubit[2])) # number=7
c.append(cirq.H.on(input_qubit[3])) # number=8
c.append(cirq.H.on(input_qubit[0])) # number=17
c.append(cirq.H.on(input_qubit[1])) # number=18
c.append(cirq.H.on(input_qubit[2])) # number=19
c.append(cirq.H.on(input_qubit[3])) # number=20
c.append(cirq.H.on(input_qubit[0])) # number=28
c.append(cirq.CNOT.on(input_qubit[3],input_qubit[0])) # number=57
c.append(cirq.Z.on(input_qubit[3])) # number=58
c.append(cirq.CNOT.on(input_qubit[3],input_qubit[0])) # number=59
c.append(cirq.CZ.on(input_qubit[1],input_qubit[0])) # number=29
c.append(cirq.H.on(input_qubit[0])) # number=30
c.append(cirq.H.on(input_qubit[0])) # number=43
c.append(cirq.CZ.on(input_qubit[1],input_qubit[0])) # number=44
c.append(cirq.H.on(input_qubit[0])) # number=45
c.append(cirq.CNOT.on(input_qubit[1],input_qubit[0])) # number=35
c.append(cirq.CNOT.on(input_qubit[1],input_qubit[0])) # number=38
c.append(cirq.X.on(input_qubit[0])) # number=39
c.append(cirq.CNOT.on(input_qubit[1],input_qubit[0])) # number=40
c.append(cirq.CNOT.on(input_qubit[1],input_qubit[0])) # number=37
c.append(cirq.H.on(input_qubit[0])) # number=46
c.append(cirq.CZ.on(input_qubit[1],input_qubit[0])) # number=47
c.append(cirq.H.on(input_qubit[0])) # number=48
c.append(cirq.CNOT.on(input_qubit[1],input_qubit[0])) # number=27
c.append(cirq.X.on(input_qubit[1])) # number=10
c.append(cirq.X.on(input_qubit[2])) # number=11
c.append(cirq.X.on(input_qubit[3])) # number=12
c.append(cirq.X.on(input_qubit[0])) # number=13
c.append(cirq.CNOT.on(input_qubit[0],input_qubit[1])) # number=22
c.append(cirq.Y.on(input_qubit[2])) # number=41
c.append(cirq.X.on(input_qubit[1])) # number=23
c.append(cirq.CNOT.on(input_qubit[0],input_qubit[1])) # number=24
c.append(cirq.rx(1.0398671683382215).on(input_qubit[2])) # number=31
c.append(cirq.X.on(input_qubit[2])) # number=15
c.append(cirq.X.on(input_qubit[3])) # number=16
# circuit end
c.append(cirq.measure(*input_qubit, key='result'))
return c
