def test_string_format():
x, y, z = cirq.LineQubit.range(3)
fc0 = cirq.FrozenCircuit()
op0 = cirq.CircuitOperation(fc0)
assert (
str(op0)
== f"""\
{op0.circuit.serialization_key()}:
[ ]"""
)
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.serialization_key()}:
[ 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)
assert (
str(op2)
== f"""\
{op2.circuit.serialization_key()}:
[ 0: ───X───X─── ]
[ │ ]
[ 1: ───H───@─── ](qubit_map={{1: 2}}, loops=3)"""
)
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)},
)"""
)
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.serialization_key()}:
[ 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_map_operations_deep_subcircuits():
q = cirq.LineQubit.range(5)
c_orig = cirq.Circuit(cirq.CX(q[0], q[1]), cirq.CX(q[3], q[2]), cirq.CX(q[3], q[4]))
c_orig_with_circuit_ops = cirq.Circuit(
cirq.CircuitOperation(
cirq.FrozenCircuit(
[
cirq.CircuitOperation(cirq.FrozenCircuit(op)).repeat(2).with_tags("internal")
for op in c_orig.all_operations()
]
)
)
.repeat(6)
.with_tags("external")
)
def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE:
yield [
cirq.Z.on_each(*op.qubits),
cirq.CX(*op.qubits),
cirq.Z.on_each(*op.qubits),
] if op.gate == cirq.CX else op
cirq.testing.assert_has_diagram(
c_orig_with_circuit_ops,
'''
[ [ 0: ───@─── ] ]
[ 0: ───[ │ ]────────────────────────────────────────────────────────────── ]
[ [ 1: ───X─── ](loops=2)['internal'] ]
[ │ ]
[ 1: ───#2────────────────────────────────────────────────────────────────────────── ]
[ ]
[ [ 2: ───X─── ] ]
0: ───[ 2: ───[ │ ]────────────────────────────────────────────────────────────── ]────────────────────────
[ [ 3: ───@─── ](loops=2)['internal'] ]
[ │ ]
[ │ [ 3: ───@─── ] ]
[ 3: ───#2────────────────────────────────────[ │ ]──────────────────────── ]
[ [ 4: ───X─── ](loops=2)['internal'] ]
[ │ ]
[ 4: ─────────────────────────────────────────#2──────────────────────────────────── ](loops=6)['external']
│
1: ───#2────────────────────────────────────────────────────────────────────────────────────────────────────────────
│
2: ───#3────────────────────────────────────────────────────────────────────────────────────────────────────────────
│
3: ───#4────────────────────────────────────────────────────────────────────────────────────────────────────────────
│
4: ───#5────────────────────────────────────────────────────────────────────────────────────────────────────────────
''',
)
c_mapped = cirq.map_operations(c_orig_with_circuit_ops, map_func, deep=True)
for unroller in [
cirq.unroll_circuit_op,
cirq.unroll_circuit_op_greedy_earliest,
cirq.unroll_circuit_op_greedy_frontier,
]:
cirq.testing.assert_has_diagram(
unroller(c_mapped, deep=True),
'''
[ [ 0: ───Z───@───Z─── ] ]
[ 0: ───[ │ ]────────────────────────────────────────────────────────────────────── ]
[ [ 1: ───Z───X───Z─── ](loops=2)['internal'] ]
[ │ ]
[ 1: ───#2────────────────────────────────────────────────────────────────────────────────────────── ]
[ ]
[ [ 2: ───Z───X───Z─── ] ]
0: ───[ 2: ───[ │ ]────────────────────────────────────────────────────────────────────── ]────────────────────────
[ [ 3: ───Z───@───Z─── ](loops=2)['internal'] ]
[ │ ]
[ │ [ 3: ───Z───@───Z─── ] ]
[ 3: ───#2────────────────────────────────────────────[ │ ]──────────────────────── ]
[ [ 4: ───Z───X───Z─── ](loops=2)['internal'] ]
[ │ ]
[ 4: ─────────────────────────────────────────────────#2──────────────────────────────────────────── ](loops=6)['external']
│
1: ───#2────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
│
2: ───#3────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
│
3: ───#4────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
│
4: ───#5────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
''',
)
def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE:
yield cirq.Z.on_each(*op.qubits)
yield cirq.CX(*op.qubits)
yield cirq.Z.on_each(*op.qubits)
def test_cirq_qsim_all_supported_gates():
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.IdentityGate(4).on(q0, q1, q2, q3),
]),
cirq.Moment([
cirq.CCZPowGate(exponent=0.7, global_shift=0.3)(q2, q0, q1),
]),
cirq.Moment([
cirq.CCXPowGate(exponent=0.4, global_shift=0.6)(
q3, q1, q0).controlled_by(q2, control_values=[0]),
]),
cirq.Moment([
cirq.rx(0.3)(q0),
cirq.ry(0.5)(q1),
cirq.rz(0.7)(q2),
cirq.rx(0.9)(q3),
]),
cirq.Moment([
cirq.TwoQubitDiagonalGate([0.1, 0.2, 0.3, 0.4])(q0, q1),
]),
cirq.Moment([
cirq.ThreeQubitDiagonalGate([0.5, 0.6, 0.7, 0.8, 0.9, 1, 1.2,
1.3])(q1, q2, q3),
]),
cirq.Moment([
cirq.CSwapGate()(q0, q3, q1),
]),
cirq.Moment([
cirq.rz(0.6)(q0),
cirq.rx(0.7)(q1),
cirq.ry(0.8)(q2),
cirq.rz(0.9)(q3),
]),
cirq.Moment([
cirq.TOFFOLI(q3, q2, q0),
]),
cirq.Moment([
cirq.FREDKIN(q1, q3, q2),
]),
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 q0, q1 = cirq.LineQubit.range(2) # q0 = cirq.GridQubit(0, 0) # q1 = cirq.GridQubit(0, 1) circuit = cirq.Circuit() circuit.append([cirq.H(q0), cirq.H(q1)]) # Oracle for |00⟩ : circuit.append([cirq.X(q0), cirq.X(q1)]) circuit.append(cirq.CX(q0, q1)) circuit.append([cirq.X(q0), cirq.X(q1)]) circuit.append([cirq.H(q0), cirq.H(q1)]) # reflection circuit : circuit.append([cirq.Z(q0), cirq.Z(q1)]) circuit.append(cirq.CX(q0, q1)) circuit.append([cirq.H(q0), cirq.H(q1)]) circuit.append([cirq.measure(q0), cirq.measure(q1)]) print(circuit) simulator = cirq.Simulator() result = simulator.simulate(circuit) # result = simulator.run(circuit, repetitions=40) # NISQ computers print(result)
def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE:
yield [
cirq.Z.on_each(*op.qubits),
cirq.CX(*op.qubits),
cirq.Z.on_each(*op.qubits),
] if op.gate == cirq.CX else op
def test_string_format():
x, y, z = cirq.LineQubit.range(3)
fc0 = cirq.FrozenCircuit()
op0 = cirq.CircuitOperation(fc0)
assert str(op0) == f"[ ]"
fc0_global_phase_inner = cirq.FrozenCircuit(
cirq.global_phase_operation(1j), cirq.global_phase_operation(1j))
op0_global_phase_inner = cirq.CircuitOperation(fc0_global_phase_inner)
fc0_global_phase_outer = cirq.FrozenCircuit(
op0_global_phase_inner, cirq.global_phase_operation(1j))
op0_global_phase_outer = cirq.CircuitOperation(fc0_global_phase_outer)
assert (str(op0_global_phase_outer) == f"""\
[ ]
[ ]
[ 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"""\
[ 0: ───X───────M('m')─── ]
[ │ ]
[ 1: ───H───@───M──────── ]
[ │ │ ]
[ 2: ───────X───M──────── ]""")
assert (repr(op1) == """\
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=cirq.MeasurementKey(name='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"""\
[ 0: ───X───X─── ]
[ │ ]
[ 1: ───H───@─── ](qubit_map={{q(1): q(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"""\
[ 0: ───X^b───M('m')─── ](qubit_map={{q(0): q(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) == """\
cirq.CircuitOperation(
circuit=cirq.FrozenCircuit([
cirq.Moment(
cirq.X(cirq.LineQubit(0)),
cirq.CircuitOperation(
circuit=cirq.FrozenCircuit([
cirq.Moment(
cirq.X(cirq.LineQubit(1)),
),
]),
),
),
]),
)""")
op6 = cirq.CircuitOperation(fc5, use_repetition_ids=False)
assert (repr(op6) == """\
cirq.CircuitOperation(
circuit=cirq.FrozenCircuit([
cirq.Moment(
cirq.X(cirq.LineQubit(0)),
cirq.CircuitOperation(
circuit=cirq.FrozenCircuit([
cirq.Moment(
cirq.X(cirq.LineQubit(1)),
),
]),
),
),
]),
use_repetition_ids=False,
)""")
op7 = cirq.CircuitOperation(
cirq.FrozenCircuit(cirq.measure(x, key='a')),
use_repetition_ids=False,
repeat_until=cirq.KeyCondition(cirq.MeasurementKey('a')),
)
assert (repr(op7) == """\
cirq.CircuitOperation(
circuit=cirq.FrozenCircuit([
cirq.Moment(
cirq.measure(cirq.LineQubit(0), key=cirq.MeasurementKey(name='a')),
),
]),
use_repetition_ids=False,
repeat_until=cirq.KeyCondition(cirq.MeasurementKey(name='a')),
)""")
import cirq qr = cirq.LineQubit.range(5) c = cirq.Circuit() c.append(cirq.H(qr[0])) c.append(cirq.H(qr[1])) c.append(cirq.H(qr[2])) c.append(cirq.Z(qr[0])) c.append(cirq.H(qr[2])) c.append(cirq.H(qr[0])) c.append(cirq.CX(qr[1], qr[2])) c.append(cirq.measure(qr[0], key='x0')) c.append(cirq.H(qr[1])) c.append(cirq.H(qr[2])) c.append(cirq.measure(qr[1], key='x1')) c.append(cirq.H(qr[2])) c.append(cirq.measure(qr[2], key='x2')) result = cirq.Simulator().run(c, repetitions=1000) print(c) cirq.plot_state_histogram(result)
def map_func(op: cirq.Operation, _: int) -> cirq.OP_TREE:
if op.gate == cirq.CX:
yield cirq.Z.on_each(*op.qubits)
yield cirq.CX(*op.qubits)
yield cirq.Z.on_each(*op.qubits)
return op
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_circuit_0():
qusetta_circuit = [
"H(0)", "H(1)", "CX(0, 1)", "CX(1, 0)", "CZ(2, 0)", "I(1)",
"SWAP(0, 3)", "RY(PI)(1)", "X(2)", "S(0)", "Z(2)", "Y(3)",
"RX(0.4*PI)(0)", "T(2)", "RZ(-0.3*PI)(2)", "CCX(0, 1, 2)"
]
cirq_circuit = cirq.Circuit()
q = [cirq.LineQubit(i) for i in range(4)]
cirq_circuit.append(cirq.H(q[0]))
cirq_circuit.append(cirq.H(q[1]))
cirq_circuit.append(cirq.CX(q[0], q[1]))
cirq_circuit.append(cirq.CX(q[1], q[0]))
cirq_circuit.append(cirq.CZ(q[2], q[0]))
cirq_circuit.append(cirq.I(q[1]))
cirq_circuit.append(cirq.SWAP(q[0], q[3]))
cirq_circuit.append(cirq.ry(pi)(q[1]))
cirq_circuit.append(cirq.X(q[2]))
cirq_circuit.append(cirq.S(q[0]))
cirq_circuit.append(cirq.Z(q[2]))
cirq_circuit.append(cirq.Y(q[3]))
cirq_circuit.append(cirq.rx(.4 * pi)(q[0]))
cirq_circuit.append(cirq.T(q[2]))
cirq_circuit.append(cirq.rz(-.3 * pi)(q[2]))
cirq_circuit.append(cirq.CCX(q[0], q[1], q[2]))
# ibm is weird so we flip all of the qubits here
qiskit_circuit = qiskit.QuantumCircuit(4)
qiskit_circuit.h(3 - 0)
qiskit_circuit.h(3 - 1)
qiskit_circuit.cx(3 - 0, 3 - 1)
qiskit_circuit.cx(3 - 1, 3 - 0)
qiskit_circuit.cz(3 - 2, 3 - 0)
qiskit_circuit.i(3 - 1)
qiskit_circuit.swap(3 - 0, 3 - 3)
qiskit_circuit.ry(pi, 3 - 1)
qiskit_circuit.x(3 - 2)
qiskit_circuit.s(3 - 0)
qiskit_circuit.z(3 - 2)
qiskit_circuit.y(3 - 3)
qiskit_circuit.rx(.4 * pi, 3 - 0)
qiskit_circuit.t(3 - 2)
qiskit_circuit.rz(-.3 * pi, 3 - 2)
qiskit_circuit.ccx(3 - 0, 3 - 1, 3 - 2)
quasar_circuit = quasar.Circuit()
quasar_circuit.H(0)
quasar_circuit.H(1)
quasar_circuit.CX(0, 1)
quasar_circuit.CX(1, 0)
quasar_circuit.CZ(2, 0)
quasar_circuit.I(1)
quasar_circuit.SWAP(0, 3)
quasar_circuit.Ry(1, pi)
quasar_circuit.X(2)
quasar_circuit.S(0)
quasar_circuit.Z(2)
quasar_circuit.Y(3)
quasar_circuit.Rx(0, .2 * pi)
quasar_circuit.T(2)
quasar_circuit.Rz(2, -.15 * pi)
quasar_circuit.CCX(0, 1, 2)
# tests
all_tests(qusetta_circuit, cirq_circuit, qiskit_circuit, quasar_circuit)
import cirq import matplotlib.pyplot as plt import numpy as np qubits = cirq.LineQubit.range(10) c = cirq.Circuit() q_qft = [qubits[0], qubits[1], qubits[2], qubits[3], qubits[4]] c.append(cirq.H(qubits[0])) c.append(cirq.H(qubits[1])) c.append(cirq.H(qubits[2])) c.append(cirq.H(qubits[3])) c.append(cirq.H(qubits[4])) c.append(cirq.X(qubits[5])) c.append(cirq.CX(qubits[0], qubits[7])) c.append(cirq.CCX(qubits[1], qubits[8], qubits[9])) c.append(cirq.CCX(qubits[8], qubits[1], qubits[6])) c.append(cirq.CSWAP(qubits[1], qubits[6], qubits[8])) c.append(cirq.CSWAP(qubits[1], qubits[7], qubits[9])) c.append(cirq.CSWAP(qubits[1], qubits[5], qubits[7])) c.append(cirq.CSWAP(qubits[2], qubits[5], qubits[7])) c.append(cirq.CSWAP(qubits[2], qubits[7], qubits[9])) c.append(cirq.CSWAP(qubits[2], qubits[6], qubits[8])) c.append(cirq.CCX(qubits[2], qubits[6], qubits[8])) c.append(cirq.CCX(qubits[2], qubits[8], qubits[9])) c.append(cirq.CCX(qubits[3], qubits[8], qubits[9])) c.append(cirq.CCX(qubits[6], qubits[3], qubits[8]))
def balanced_mod2(qubits: List[cirq.Qid]) -> cirq.OP_TREE: return cirq.CX(qubits[0], qubits[len(qubits) - 1])
def balanced_parity(qubits: List[cirq.Qid]) -> cirq.OP_TREE: n = len(qubits) - 1 return [cirq.CX(qubits[i], qubits[n]) for i in range(n)]
def oracle_op(qubits: List[cirq.Qid]) -> cirq.OP_TREE:
if len(qubits) != len(s) + 1:
raise ValueError(f'{len(qubits)} qubits passed to oracle expecting {len(s) + 1}')
n = len(qubits) - 1
return [cirq.CX(qubits[i], qubits[n]) for i in range(n) if s[i]]
