def test_find_optimal_representation_no_superoperator_error():
q = LineQubit(0)
# Define noisy operation without superoperator matrix
noisy_op = NoisyOperation(Circuit(X(q)))
noisy_basis = NoisyBasis(noisy_op)
with raises(ValueError, match="numerical superoperator matrix"):
find_optimal_representation(Circuit(X(q)), noisy_basis)
def test_represent_operations_in_circuit_with_measurements(
circuit_type: str, rep_function,
):
"""Tests measurements in circuit are ignored (not represented)."""
q0, q1 = LineQubit.range(2)
circ_mitiq = Circuit(
X(q1),
MeasurementGate(num_qubits=1)(q0),
X(q1),
MeasurementGate(num_qubits=1)(q0),
)
circ = convert_from_mitiq(circ_mitiq, circuit_type)
reps = rep_function(ideal_circuit=circ, noise_level=0.1)
for op in convert_to_mitiq(circ)[0].all_operations():
found = False
for rep in reps:
if _equal(rep.ideal, Circuit(op), require_qubit_equality=True):
found = True
if isinstance(op.gate, MeasurementGate):
assert not found
else:
assert found
# Number of unique gates excluding measurement gates
assert len(reps) == 1
def minus1(circuit, l, countReg, workReg, control, ancilla, level):
"""
Recursively carries an subtraction of 1 to the LSB of a register to all bits if control == 1
Equivalent to plus1 but with an X applied to all count qubits before and after gate
"""
circuit.append([X(qubit) for qubit in countReg], strategy=new)
plus1(circuit, l, countReg, workReg, control, ancilla, level)
circuit.append([X(qubit) for qubit in countReg], strategy=new)
def test_aqt_sampler_sim_xtalk():
num_points = 10
max_angle = np.pi
repetitions = 100
num_qubits = 4
device, qubits = get_aqt_device(num_qubits)
sampler = AQTSamplerLocalSimulator()
sampler.simulate_ideal = False
circuit = Circuit(X(qubits[0]), X(qubits[3]), X(qubits[2]), device=device)
sweep = study.Linspace(key='theta',
start=0.1,
stop=max_angle / np.pi,
length=num_points)
_results = sampler.run_sweep(circuit, params=sweep, repetitions=repetitions)
def plus1(circuit, l, countReg, workReg, control, ancilla, level):
"""
Recursively add 1 to the LSB of a register and carries to all bits, if control == 1
l: number of qubits in count register
countReg, workReg: count register and associated work register
control: control qubit to determine if plus1 should be executed
ancilla: extra work qubit
level: current qubit we are operating on, recursively travels from qubit 0 to l-1
"""
# apply X to LSB
if level == 0:
circuit.append(CNOT(control, countReg[0]), strategy=new)
if level < l - 1:
# first level uses CNOT instead of TOFFOLI gate
if level == 0:
# move all X gates to first step to avoid unnecesarry gates
circuit.append([X(qubit) for qubit in countReg], strategy=new)
circuit.append(TOFFOLI(countReg[0], control, workReg[0]),
strategy=new)
else:
circuit.append(TOFFOLI(countReg[level], workReg[level - 1],
ancilla),
strategy=new)
circuit.append(TOFFOLI(ancilla, control, workReg[level]),
strategy=new)
circuit.append(TOFFOLI(countReg[level], workReg[level - 1],
ancilla),
strategy=new)
circuit.append(TOFFOLI(workReg[level], control, countReg[level + 1]),
strategy=new)
# recursively call next layer
print("countReg ", countReg)
plus1(circuit, l, countReg, workReg, control, ancilla, level + 1)
# undo work qubits (exact opposite of first 7 lines - undoes calculation)
if level == 0:
circuit.append(TOFFOLI(countReg[0], control, workReg[0]),
strategy=new)
circuit.append([X(qubit) for qubit in countReg], strategy=new)
else:
circuit.append(TOFFOLI(countReg[level], workReg[level - 1],
ancilla),
strategy=new)
circuit.append(TOFFOLI(ancilla, control, workReg[level]),
strategy=new)
circuit.append(TOFFOLI(countReg[level], workReg[level - 1],
ancilla),
strategy=new)
def test_joined_generator(self):
generator1 = TwoRotsGenerator()
generator2 = OneRotGenerator()
grad = op_tree_generator_grad(
OpTreeGenerator.join(generator1, generator2),
rad
)
grad_lco = LinearCombinationOfOperations({
_generator((q0, q1)): _coeff for _generator, _coeff in grad.items()
})
for _generator, _coeff in grad.items():
print(_generator.diagram(), _coeff)
exact_grad_lco = LinearCombinationOfOperations({
(X(q0), rx(rad).on(q0), rz(rad).on(q1), ry(c * rad).on(q0)): -0.5j,
(rx(rad).on(q0), Z(q1), rz(rad).on(q1), ry(c * rad).on(q0)): -0.5j,
(rx(rad).on(q0), rz(rad).on(q1), Y(q0), ry(c * rad).on(q0)): -0.5j * c,
})
param_resolver = {
rad: np.random.rand() * 4 * np.pi,
c: np.random.rand()
}
grad_lco = cirq.resolve_parameters(grad_lco, param_resolver)
exact_grad_lco = cirq.resolve_parameters(exact_grad_lco, param_resolver)
test_lco_identical_with_simulator(
grad_lco,
exact_grad_lco,
self
)
def makeOracle(q0, q1, secretFunction):
""" Gates implementing the secret function f(x)."""
if secretFunction[0]:
yield [CNOT(q0, q1), X(q1)]
if secretFunction[1]:
yield CNOT(q0, q1)
def test_simple_pauli_deco_dict_CNOT():
"""Tests that the _simple_pauli_deco_dict function returns a decomposition
dicitonary which is consistent with a local depolarizing noise model.
The channel acting on the state each qubit is assumed to be:
D(rho) = = (1 - epsilon) rho + epsilon I/2
= (1 - p) rho + p/3 (X rho X + Y rho Y^dag + Z rho Z)
"""
# Deduce epsilon from BASE_NOISE
epsilon = BASE_NOISE * 4.0 / 3.0
c_neg = -(1 / 4) * epsilon / (1 - epsilon)
c_pos = 1 - 3 * c_neg
qreg = LineQubit.range(2)
# Get the decomposition of a CNOT gate
deco = DECO_DICT[CNOT.on(*qreg)]
# The first term of 'deco' corresponds to no error occurring
first_coefficient, first_imp_seq = deco[0]
assert np.isclose(c_pos * c_pos, first_coefficient)
assert first_imp_seq == [CNOT.on(*qreg)]
# The second term corresponds to a Pauli X error on one qubit
second_coefficient, second_imp_seq = deco[1]
assert np.isclose(c_pos * c_neg, second_coefficient)
assert second_imp_seq == [CNOT.on(*qreg), X.on(qreg[0])]
# The last term corresponds to two Pauli Z errors on both qubits
last_coefficient, last_imp_seq = deco[-1]
assert np.isclose(c_neg * c_neg, last_coefficient)
assert last_imp_seq == [CNOT.on(*qreg), Z.on(qreg[0]), Z.on(qreg[1])]
def test_qubitop_to_paulisum_more_terms(self):
# Given
qubit_operator = (
QubitOperator("Z0 Z1 Z2", -1.5)
+ QubitOperator("X0", 2.5)
+ QubitOperator("Y1", 3.5)
)
expected_qubits = (LineQubit(0), LineQubit(5), LineQubit(8))
expected_paulisum = (
PauliSum()
+ (
PauliString(Z.on(expected_qubits[0]))
* PauliString(Z.on(expected_qubits[1]))
* PauliString(Z.on(expected_qubits[2]))
* -1.5
)
+ (PauliString(X.on(expected_qubits[0]) * 2.5))
+ (PauliString(Y.on(expected_qubits[1]) * 3.5))
)
# When
paulisum = qubitop_to_paulisum(qubit_operator, qubits=expected_qubits)
# Then
self.assertEqual(paulisum.qubits, expected_qubits)
self.assertEqual(paulisum, expected_paulisum)
def numberControlT(circuit, l, number, countReg, workReg):
"""CLEANS AFTER numberControl operation"""
if type(number) == int:
numberBinary = intToBinary(l, number)
else:
numberBinary = number
# subfunction to recursively handle toffoli gates
def binaryToffolisT(level):
# circuit.append(TOFFOLI(countReg[level], workReg[level-2], workReg[level-1]), strategy=new)
if level < l:
binaryToffolisT(level + 1)
# undo
circuit.append(TOFFOLI(countReg[level], workReg[level - 2],
workReg[level - 1]),
strategy=new)
if l > 2:
binaryToffolisT(2)
# undo
if l > 1:
circuit.append(TOFFOLI(countReg[0], countReg[1], workReg[0]),
strategy=new)
# undo
circuit.append([
X(countReg[i])
for i in range(len(numberBinary)) if numberBinary[i] == 0
],
strategy=new)
def test_aqt_sampler():
put_call_args0 = {
'access_token': 'testkey',
'id': '2131da',
}
e_return = EngineReturn()
with mock.patch('cirq.aqt.aqt_sampler.put',
return_value=e_return,
side_effect=e_return.update) as mock_method:
theta = sympy.Symbol('theta')
num_points = 1
max_angle = np.pi
repetitions = 10
sampler = AQTSampler(remote_host="http://localhost:5000",
access_token='testkey')
device, qubits = get_aqt_device(1)
circuit = Circuit(X(qubits[0])**theta, device=device)
sweep = study.Linspace(key='theta',
start=0.1,
stop=max_angle / np.pi,
length=num_points)
results = sampler.run_sweep(circuit,
params=sweep,
repetitions=repetitions)
excited_state_probs = np.zeros(num_points)
for i in range(num_points):
excited_state_probs[i] = np.mean(results[i].measurements['m'])
callargs = mock_method.call_args[1]['data']
for keys in put_call_args0:
assert callargs[keys] == put_call_args0[keys]
assert mock_method.call_count == 3
def test_aqt_sampler_error_handling():
for e_return in [
EngineError(),
EngineErrorSecond(),
EngineNoStatus(),
EngineNoStatus2(),
EngineNoid()
]:
with mock.patch('cirq.aqt.aqt_sampler.put',
return_value=e_return,
side_effect=e_return.update) as _mock_method:
theta = sympy.Symbol('theta')
num_points = 1
max_angle = np.pi
repetitions = 10
sampler = AQTSampler(remote_host="http://localhost:5000",
access_token='testkey')
device, qubits = get_aqt_device(1)
circuit = Circuit(X(qubits[0])**theta, device=device)
sweep = study.Linspace(key='theta',
start=0.1,
stop=max_angle / np.pi,
length=num_points)
with pytest.raises(RuntimeError):
_results = sampler.run_sweep(circuit,
params=sweep,
repetitions=repetitions)
def U_h(circuit, l, n_i, m, n_phiReg, w_phiReg, n_aReg, w_aReg, n_bReg, w_bReg,
wReg, eReg, pReg, hReg, w_hReg, P_phi, P_a, P_b):
"""Implement U_h from paper"""
# for k in range(n_i + m):
for k in range(1):
countsList = generateParticleCounts(
n_i, m, k) # reduce the available number of particles
for counts in [countsList[0]]:
n_phi, n_a, n_b = counts[0], counts[1], counts[2]
# controlled R-y from |0> to |k> on all qubits with all possible angles depending on n_phi, n_a, n_b, and flavor
for flavor in ['phi']:
# for flavor in ['phi', 'a', 'b']:
angle = U_hAngle(flavor, n_phi, n_a, n_b, P_phi, P_a, P_b)
# add in x gates for checking
phiControl = numberControl(circuit, l, n_phi, n_phiReg,
w_phiReg)
print("cirq phiControl: ", phiControl)
aControl = numberControl(circuit, l, n_a, n_aReg, w_aReg)
print("cirq aControl: ", aControl)
# bControl = numberControl(circuit, l, n_b, n_bReg, w_bReg)
print("cirq wReg[0]: ", wReg[0])
# circuit.append(TOFFOLI(phiControl, aControl, wReg[0]), strategy=new)
# circuit.append(TOFFOLI(bControl, wReg[0], wReg[1]), strategy=new)
flavorControl(
circuit, flavor, pReg[k], wReg[2],
wReg[4]) # wReg[4] is work qubit but is reset to 0
# circuit.append(TOFFOLI(wReg[1], wReg[2], wReg[3]), strategy=new)
# circuit.append(TOFFOLI(eReg[0], wReg[3], wReg[4]), strategy=new)
#
# # print("m ", m)
# # print("hReg[m]: ",hReg[m])
#
# twoLevelControlledRy(circuit, l, angle, k+1, wReg[4], hReg[m], w_hReg)
#
# circuit.append(TOFFOLI(eReg[0], wReg[3], wReg[4]), strategy=new) # next steps undo work qubits
# circuit.append(TOFFOLI(wReg[1], wReg[2], wReg[3]), strategy=new)
# flavorControl(circuit, flavor, pReg[k], wReg[2], wReg[4])
# circuit.append(TOFFOLI(bControl, wReg[0], wReg[1]), strategy=new)
# circuit.append(TOFFOLI(phiControl, aControl, wReg[0]), strategy=new)
# numberControlT(circuit, l, n_b, n_bReg, w_bReg)
# numberControlT(circuit, l, n_a, n_aReg, w_aReg)
# numberControlT(circuit, l, n_phi, n_phiReg, w_phiReg)
# subtract from the counts register depending on which flavor particle emitted
for flavor, countReg, workReg in zip(['phi', 'a', 'b'],
[n_phiReg, n_aReg, n_bReg],
[w_phiReg, w_aReg, w_bReg]):
flavorControl(circuit, flavor, pReg[k], wReg[0], wReg[1])
minus1(circuit, l, countReg, workReg, wReg[0], wReg[1], 0)
flavorControl(circuit, flavor, pReg[k], wReg[0], wReg[1])
# apply x on eReg if hReg[m] = 0, apply another x so we essentially control on not 0 instead of 0
isZeroControl = numberControl(circuit, l, 0, hReg[m], w_hReg)
circuit.append(CNOT(isZeroControl, eReg[0]))
circuit.append(X(eReg[0]), strategy=new)
numberControlT(circuit, l, 0, hReg[m], w_hReg)
def intializeParticles(circuit, pReg, initialParticles):
""" Apply appropriate X gates to ensure that the p register contains all of the initial particles.
The p registers contains particles in the form of a list [LSB, middle bit, MSB]"""
for currentParticleIndex in range(len(initialParticles)):
for particleBit in range(3):
if initialParticles[currentParticleIndex][particleBit] == 1:
circuit.append(X(pReg[currentParticleIndex][particleBit]),
strategy=early)
def exponentiation_circuit(param):
circuit = Circuit()
if is_constant(pauli_string):
PHASE = ZPowGate(exponent=(-param * coeff)/np.pi)
circuit.append([X(GridQubit(0, 0))],
strategy=InsertStrategy.EARLIEST)
circuit.append([PHASE(GridQubit(0, 0))],
strategy=InsertStrategy.EARLIEST)
circuit.append([X(GridQubit(0, 0))],
strategy=InsertStrategy.EARLIEST)
circuit.append([PHASE(GridQubit(0, 0))],
strategy=InsertStrategy.EARLIEST)
elif is_zero(pauli_string):
pass
else:
circuit += exponentiate_general_case(pauli_string, param)
return circuit
def makeDeutschCircuit(q0, q1, oracle):
c = cirq.Circuit()
c.append([X(q1), H(q1), H(q0)])
c.append(oracle)
c.append([H(q0), measure(q0, key='result')])
return c
def make_oracle(q0, q1, secret_function):
""" Gates implementing the secret function f(x)."""
# coverage: ignore
if secret_function[0]:
yield [CNOT(q0, q1), X(q1)]
if secret_function[1]:
yield CNOT(q0, q1)
def test_get_imp_sequences_no_simplify(gate: Gate):
q = LineQubit(0)
expected_imp_sequences = [
[gate.on(q)],
[gate.on(q), X.on(q)],
[gate.on(q), Y.on(q)],
[gate.on(q), Z.on(q)],
]
assert get_imp_sequences(gate.on(q), DECO_DICT) == expected_imp_sequences
def test_short_circuit_warning(factory):
"""Tests a warning is raised if the input circuit has very few gates."""
scale_factors = np.linspace(1.0, 10.0, num=20)
def executor(circuits) -> List[float]:
return [1.0] * len(circuits)
if factory is PolyFactory or factory is PolyExpFactory:
fac = factory(scale_factors=scale_factors, order=2)
elif factory is AdaExpFactory:
fac = factory(steps=4)
else:
fac = factory(scale_factors=scale_factors)
qubit = LineQubit(0)
circuit = cirq.Circuit(X(qubit), H(qubit), X(qubit))
with warns(
UserWarning, match=r"The input circuit is very short.",
):
fac.run(circuit, executor, scale_noise=lambda circ, _: circ)
def make_deutsch_circuit(q0, q1, oracle):
c = cirq.Circuit()
# Initialize qubits.
c.append([X(q1), H(q1), H(q0)], strategy=InsertStrategy.NEW)
# Query oracle.
c.append(oracle, strategy=InsertStrategy.NEW)
# Measure in X basis.
c.append([H(q0), measure(q0, key='result')], strategy=InsertStrategy.NEW)
return c
def test_sample_circuit_with_seed():
decomp = _simple_pauli_deco_dict(0.7, simplify_paulis=True)
circ = Circuit([X.on(LineQubit(0)) for _ in range(10)])
expected = sample_circuit(circ, decomp, random_state=4)[0]
# Check we're not sampling the same operation every call to sample_sequence
assert len(set(expected.all_operations())) > 1
for _ in range(10):
sampled = sample_circuit(circ, decomp, random_state=4)[0]
assert _equal(sampled, expected)
def make_deutsch_circuit(q0, q1, oracle):
c = cirq.Circuit()
# Initialize qubits.
c.append([X(q1), H(q1), H(q0)])
# Query oracle.
c.append(oracle)
# Measure in X basis.
c.append(H(q0))
return c
def test_x_crosstalk_n_noise():
num_qubits = 4
noise_mod = AQTNoiseModel()
device, qubits = get_aqt_device(num_qubits)
circuit = Circuit(device=device)
circuit.append(Y(qubits[1])**0.5)
circuit.append(Z(qubits[1])**0.5)
circuit.append(X(qubits[1])**0.5)
for moment in circuit.moments:
noisy_moment = noise_mod.noisy_moment(moment, qubits)
assert noisy_moment == [(cirq.X**0.5).on(cirq.LineQubit(1)),
cirq.depolarize(p=0.001).on(cirq.LineQubit(1)),
(cirq.X**0.015).on(cirq.LineQubit(0)),
(cirq.X**0.015).on(cirq.LineQubit(2))]
def to_circuit(self, history=None, ix=0, n=None, depth=None):
if n is None:
n = self.n
if history is None:
history = []
if depth is None:
depth = self.depth
c_on, c_off = split_control(history, n)
qix = len(history)
if self.type == AOG.TERMINAL:
circuit = Circuit()
if self._data:
if not history:
circuit.append(X(LineQubit(ix)))
else:
for cont in bin_string_iter(depth - len(history)):
aug_history = history + cont
aug_c_on, aug_c_off = split_control(aug_history, n)
circuit.append(
controlled_circuit(X, [LineQubit(ix)], aug_c_on,
aug_c_off))
return circuit, history, 1
elif self.type == AOG.OR:
or_gate = Rx(self._theta)
circuit = controlled_circuit(or_gate, [LineQubit(qix + n)], c_on,
c_off)
left_circuit, _, left_len = self._left.to_circuit(
history + [0], ix, n, depth)
right_circuit, _, right_len = self._right.to_circuit(
history + [1], ix, n, depth)
assert left_len == right_len # debugging
circuit.append(left_circuit)
circuit.append(right_circuit)
return circuit, history + [-1], left_len
elif self.type == AOG.AND:
left_circuit, history_after_left, left_len = self._left.to_circuit(
history, ix, n, depth)
right_circuit, history_after_right, right_len = \
self._right.to_circuit(history_after_left, ix + left_len, n, depth)
left_circuit.append(right_circuit)
return left_circuit, history_after_right, left_len + right_len
def updateParticles(circuit, l, n_i, m, k, pReg, wReg, controlQub, g_a, g_b):
"""Updates particle if controlQub is on"""
oldParticleReg = pReg[k]
newParticleReg = pReg[n_i + m]
#first gate in paper U_p
circuit.append(TOFFOLI(controlQub, oldParticleReg[2], newParticleReg[0]),
strategy=new)
#second gate in paper (undoes work register immediately)
circuit.append([X(oldParticleReg[1]), X(oldParticleReg[2])], strategy=new)
circuit.append(TOFFOLI(controlQub, oldParticleReg[2], wReg[0]),
strategy=new)
circuit.append(TOFFOLI(wReg[0], oldParticleReg[1], wReg[1]), strategy=new)
circuit.append(TOFFOLI(wReg[1], oldParticleReg[0], newParticleReg[2]),
strategy=new)
circuit.append(TOFFOLI(wReg[0], oldParticleReg[1], wReg[1]), strategy=new)
circuit.append(TOFFOLI(controlQub, oldParticleReg[2], wReg[0]),
strategy=new)
circuit.append([X(oldParticleReg[1]), X(oldParticleReg[2])], strategy=new)
#third gate in paper
circuit.append(TOFFOLI(controlQub, newParticleReg[2], oldParticleReg[2]),
strategy=new)
#fourth and fifth gate in paper (then undoes work register)
circuit.append(TOFFOLI(controlQub, newParticleReg[2], wReg[0]),
strategy=new)
circuit.append(cirq.H.controlled().on(wReg[0], newParticleReg[1]))
angle = (2 * np.arccos(g_a / np.sqrt(g_a**2 + g_b**2)))
circuit.append(cirq.ry(angle).controlled().on(wReg[0], newParticleReg[0]))
circuit.append(TOFFOLI(controlQub, newParticleReg[2], wReg[0]),
strategy=new)
#sixth and seventh gate in paper (then undoes work register)
circuit.append([X(newParticleReg[0]), X(newParticleReg[1])], strategy=new)
circuit.append(TOFFOLI(newParticleReg[1], newParticleReg[2], wReg[0]),
strategy=new)
circuit.append(TOFFOLI(controlQub, wReg[0], oldParticleReg[1]),
strategy=new)
circuit.append(TOFFOLI(newParticleReg[1], newParticleReg[2], wReg[0]),
strategy=new)
circuit.append(TOFFOLI(newParticleReg[0], newParticleReg[2], wReg[0]),
strategy=new)
circuit.append(TOFFOLI(controlQub, wReg[0], oldParticleReg[0]),
strategy=new)
circuit.append(TOFFOLI(newParticleReg[0], newParticleReg[2], wReg[0]),
strategy=new)
circuit.append([X(newParticleReg[0]), X(newParticleReg[1])], strategy=new)
def numberControl(circuit, l, number, countReg, workReg):
"""
Applies an X to the l-2 (0 indexed) qubit of the work register if count register encodes the inputted number in binary
returns this l-2 qubit, unless l=1, in which case return the only count register qubit
DOES NOT CLEAN AFTER ITSELF - USE numberControlT to clean after this operation
"""
if type(number) == int:
numberBinary = intToBinary(l, number)
else:
numberBinary = number
circuit.append([
X(countReg[i])
for i in range(len(numberBinary)) if numberBinary[i] == 0
],
strategy=new)
print("countReg: ", countReg)
for i in range(len(numberBinary)):
if numberBinary[i] == 0:
print("countReg[i]: ", countReg[i])
# print("x gate: ", [countReg[i]for i in range(len(numberBinary)) if numberBinary[i] == 0])
# first level does not use work qubits as control
if l > 1:
print("Toffoli: ", countReg[0], countReg[1], workReg[0])
circuit.append(TOFFOLI(countReg[0], countReg[1], workReg[0]),
strategy=new)
# subfunction to recursively handle toffoli gates
def binaryToffolis(level):
print("Toffoli: ", countReg[level], countReg[level - 2],
workReg[level - 1])
circuit.append(TOFFOLI(countReg[level], workReg[level - 2],
workReg[level - 1]),
strategy=new)
if level < l - 1:
binaryToffolis(level + 1)
if l > 2:
print("l>2")
binaryToffolis(2)
# return qubit containing outcome of the operation
if l == 1:
return countReg[0]
else:
return workReg[l - 2]
def qubit_op_to_gate(operation: 'QubitOperator',
qubit) -> 'SingleQubitPauliStringGateOperation':
"""Convert a qubit operation into a gate operations that can be digested
by a Cirq simulator.
Args:
operation (QubitOperator)
qubit (Qid) - a qubit on which the Pauli matrices will act.
Returns:
(gate) - a gate that can be executed on the qubit passed
"""
if operation == 'X':
return X.on(qubit)
if operation == 'Y':
return Y.on(qubit)
if operation == 'Z':
return Z.on(qubit)
raise ValueError('No gate identified in qubit_op_to_gate')
def test_simple_pauli_deco_dict_single_qubit(gate: Gate):
"""Tests that the _simple_pauli_deco_dict function returns a decomposition
dicitonary which is consistent with a local depolarizing noise model.
This is similar to test_simple_pauli_deco_dict_CNOT but applied to
single-qubit gates.
"""
epsilon = BASE_NOISE * 4.0 / 3.0
c_neg = -(1 / 4) * epsilon / (1 - epsilon)
c_pos = 1 - 3 * c_neg
qreg = LineQubit.range(2)
for q in qreg:
deco = DECO_DICT[gate.on(q)]
first_coefficient, first_imp_seq = deco[0]
assert np.isclose(c_pos, first_coefficient)
assert first_imp_seq == [gate.on(q)]
second_coefficient, second_imp_seq = deco[1]
assert np.isclose(c_neg, second_coefficient)
assert second_imp_seq == [gate.on(q), X.on(q)]
def test_aqt_sampler_sim():
theta = sympy.Symbol('theta')
num_points = 10
max_angle = np.pi
repetitions = 1000
num_qubits = 4
device, qubits = get_aqt_device(num_qubits)
sampler = AQTSamplerLocalSimulator()
sampler.simulate_ideal = True
circuit = Circuit(X(qubits[3])**theta, device=device)
sweep = study.Linspace(key='theta',
start=0.1,
stop=max_angle / np.pi,
length=num_points)
results = sampler.run_sweep(circuit, params=sweep, repetitions=repetitions)
excited_state_probs = np.zeros(num_points)
for i in range(num_points):
excited_state_probs[i] = np.mean(results[i].measurements['m'])
assert excited_state_probs[-1] == 0.25
def flavorControl(circuit, flavor, control, target, ancilla):
"""Controlled x onto targetQubit if "control" particle is of the correct flavor"""
if flavor == "phi":
circuit.append([X(control[1]), X(control[2])], strategy=new)
circuit.append(TOFFOLI(control[0], control[1], ancilla), strategy=new)
circuit.append(TOFFOLI(control[2], ancilla, target), strategy=new)
# undo work
circuit.append(TOFFOLI(control[0], control[1], ancilla), strategy=new)
circuit.append([X(control[1]), X(control[2])], strategy=new)
if flavor == "a":
circuit.append(X(control[0]), strategy=new)
circuit.append(TOFFOLI(control[0], control[2], target), strategy=new)
# undo work
circuit.append(X(control[0]), strategy=new)
if flavor == "b":
circuit.append(TOFFOLI(control[0], control[2], target), strategy=new)
