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)