Sharedquiskit.ipynbOpen in CoCalc

QuisKit Terra in Python 3 (Ubuntu Linux)

import sys
'3.6.7 (default, Oct 22 2018, 11:32:17) \n[GCC 8.2.0]'
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit, BasicAer, execute

q = QuantumRegister(2)
c = ClassicalRegister(2)
qc = QuantumCircuit(q, c)

qc.h(q[0])[0], q[1])
qc.measure(q, c)

backend = BasicAer.get_backend('qasm_simulator')
job_sim = execute(qc, backend)
sim_result = job_sim.result()

/usr/local/lib/python3.6/dist-packages/marshmallow/ ChangedInMarshmallow3Warning: strict=False is not recommended. In marshmallow 3.0, schemas will always be strict. See ChangedInMarshmallow3Warning
{'11': 496, '00': 528}
res = sim_result.get_counts(qc)
assert res['11'] >= 100 and res['00'] >= 400
/usr/local/lib/python3.6/dist-packages/qiskit/result/ DeprecationWarning: circuit_statuses() is deprecated and will be removed in version 0.7+. Instead use result.results[x]status directly. 'directly.', DeprecationWarning)
import numpy as np
from import plot_bloch_vector
from qiskit import BasicAer
from qiskit_aqua.algorithms import AmplitudeEstimation
from import QFactory
from qiskit_aqua.components.uncertainty_problems import UncertaintyProblem
from qiskit_aqua.utils.circuit_utils import cry
# the probability to be recovered
probability = 0.3
theta_p = 2*np.arcsin(np.sqrt(probability))

# the resulting quantum state after A is applied
plot_bloch_vector([np.sin(theta_p), 0.0, np.cos(theta_p)])
class BernoulliAFactory(UncertaintyProblem):
    Circuit Factory representing the operator A.
    A is used to initialize the state as well as to construct Q.

    def __init__(self, probability=0.5, i_state=None):
        self._probability = probability
        self._theta_p = 2 * np.arcsin(np.sqrt(probability))
        if i_state is None:
            i_state = 0
        self._params = {'i_state': i_state}

    def build(self, qc, q, q_ancillas=None, params=None):
        if params is None:
            params = self._params
        # A is a rotation of angle theta_p around the Y-axis
        qc.ry(self._theta_p, q[params['i_state']])

class BernoulliQFactory(QFactory):
    Circuit Factory representing the operator Q.
    This implementation exploits the fact that powers of Q can be implemented efficiently by just multiplying the angle.
    (amplitude estimation only requires controlled powers of Q, thus, only this method is overridden.)

    def __init__(self, bernoulli_expected_value):

    def build(self, qc, q, q_ancillas=None, params=None):
        i_state = self.a_factory._params['i_state']
        theta_p = self.a_factory._theta_p
        # Q is a rotation of angle 2*theta_p around the Y-axis
        qc.ry(q[i_state], 2 * theta_p)

    def build_controlled_power(self,
        i_state = self.a_factory._params['i_state']
        theta_p = self.a_factory._theta_p
        cry(2 * power * theta_p, q_control, q[i_state], qc)
# construct factories for A and Q
bernoulli_a_factory = BernoulliAFactory(probability)
bernoulli_q_factory = BernoulliQFactory(bernoulli_a_factory)
# set number of evaluation qubits
m = 3

# construct amplitude estimation
# here, we override the standard construction of Q since we know a more efficient way
# (exploiting the fact that A and Q are just Y-rotations)
ae = AmplitudeEstimation(m, bernoulli_a_factory, q_factory=bernoulli_q_factory)
# result ='qasm_simulator'))
result ='statevector_simulator'))
all(_ >= 0 for _ in result['values'])
# plot estimated values
import matplotlib.pyplot as plt['values'], result['probabilities'], width=0.5/len(result['probabilities']))
plt.plot([probability, probability], [0,1], 'r--', linewidth=2)
plt.yticks([0, 0.25, 0.5, 0.75, 1], size=15)
plt.title('Estimated Values', size=15)
plt.ylabel('Probability', size=15)