class TestFixedIncomeAssets(QiskitFinanceTestCase): """ Test Fixed Income Assets """ def setUp(self): super().setUp() self._statevector = QuantumInstance( backend=BasicAer.get_backend('statevector_simulator'), seed_simulator=2, seed_transpiler=2) self._qasm = QuantumInstance( backend=BasicAer.get_backend('qasm_simulator'), shots=100, seed_simulator=2, seed_transpiler=2) @parameterized.expand([[ 'statevector', AmplitudeEstimation(5), { 'estimation': 2.4600, 'mle': 2.3402315559106843 } ], [ 'qasm', AmplitudeEstimation(5), { 'estimation': 2.4600, 'mle': 2.3632087675061726 } ], [ 'statevector', MaximumLikelihoodAmplitudeEstimation(5), { 'estimation': 2.340361798381051 } ], [ 'qasm', MaximumLikelihoodAmplitudeEstimation(5), { 'estimation': 2.317921060790118 } ]]) def test_expected_value(self, simulator, a_e, expect): """ expected value test """ # can be used in case a principal component analysis # has been done to derive the uncertainty model, ignored in this example. a_n = np.eye(2) b = np.zeros(2) # specify the number of qubits that are used to represent # the different dimensions of the uncertainty model num_qubits = [2, 2] # specify the lower and upper bounds for the different dimension low = [0, 0] high = [0.12, 0.24] m_u = [0.12, 0.24] sigma = 0.01 * np.eye(2) # construct corresponding distribution mund = MultivariateNormalDistribution(num_qubits, low, high, m_u, sigma) # specify cash flow c_f = [1.0, 2.0] # specify approximation factor c_approx = 0.125 # get fixed income circuit appfactory fixed_income = FixedIncomeExpectedValue(mund, a_n, b, c_f, c_approx) a_e.a_factory = fixed_income # run simulation result = a_e.run(self._qasm if simulator == 'qasm' else self._statevector) # compare to precomputed solution for key, value in expect.items(): self.assertAlmostEqual(result[key], value, places=4, msg="estimate `{}` failed".format(key))
class TestSineIntegral(QiskitAquaTestCase): """Tests based on the A operator to integrate sin^2(x). This class tests * the estimation result * the confidence intervals """ def setUp(self): super().setUp() self._statevector = QuantumInstance( backend=BasicAer.get_backend('statevector_simulator'), seed_simulator=123, seed_transpiler=41) def qasm(shots=100): return QuantumInstance( backend=BasicAer.get_backend('qasm_simulator'), shots=shots, seed_simulator=7192, seed_transpiler=90000) self._qasm = qasm @idata([ [2, AmplitudeEstimation(2), { 'estimation': 0.5, 'mle': 0.270290 }], [4, MaximumLikelihoodAmplitudeEstimation(4), { 'estimation': 0.272675 }], [3, IterativeAmplitudeEstimation(0.1, 0.1), { 'estimation': 0.272082 }], ]) @unpack def test_statevector(self, n, qae, expect): """ Statevector end-to-end test """ # construct factories for A and Q with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=DeprecationWarning) qae.a_factory = SineIntegralAFactory(n) result = qae.run(self._statevector) for key, value in expect.items(): self.assertAlmostEqual(value, result[key], places=3, msg="estimate `{}` failed".format(key)) @idata([ [4, 10, AmplitudeEstimation(2), { 'estimation': 0.5, 'mle': 0.333333 }], [ 3, 10, MaximumLikelihoodAmplitudeEstimation(2), { 'estimation': 0.256878 } ], [ 3, 1000, IterativeAmplitudeEstimation(0.01, 0.01), { 'estimation': 0.271790 } ], ]) @unpack def test_qasm(self, n, shots, qae, expect): """QASM simulator end-to-end test.""" # construct factories for A and Q with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=DeprecationWarning) qae.a_factory = SineIntegralAFactory(n) result = qae.run(self._qasm(shots)) for key, value in expect.items(): self.assertAlmostEqual(value, result[key], places=3, msg="estimate `{}` failed".format(key)) @idata([ [ AmplitudeEstimation(3), 'mle', { 'likelihood_ratio': [0.24947346406470136, 0.3003771197734433], 'fisher': [0.24861769995820207, 0.2999286066724035], 'observed_fisher': [0.24845622030041542, 0.30009008633019013] } ], [ MaximumLikelihoodAmplitudeEstimation(3), 'estimation', { 'likelihood_ratio': [0.25987941798909114, 0.27985361366769945], 'fisher': [0.2584889015125656, 0.2797018754936686], 'observed_fisher': [0.2659279996107888, 0.2722627773954454] } ], ]) @unpack def test_confidence_intervals(self, qae, key, expect): """End-to-end test for all confidence intervals.""" n = 3 with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=DeprecationWarning) qae.a_factory = SineIntegralAFactory(n) # statevector simulator result = qae.run(self._statevector) methods = ['lr', 'fi', 'oi'] # short for likelihood_ratio, fisher, observed_fisher alphas = [0.1, 0.00001, 0.9] # alpha shouldn't matter in statevector for alpha, method in zip(alphas, methods): confint = qae.confidence_interval(alpha, method) # confidence interval based on statevector should be empty, as we are sure of the result self.assertAlmostEqual(confint[1] - confint[0], 0.0) self.assertAlmostEqual(confint[0], result[key]) # qasm simulator shots = 100 alpha = 0.01 result = qae.run(self._qasm(shots)) for method, expected_confint in expect.items(): confint = qae.confidence_interval(alpha, method) np.testing.assert_almost_equal(confint, expected_confint, decimal=10) self.assertTrue(confint[0] <= result[key] <= confint[1]) def test_iqae_confidence_intervals(self): """End-to-end test for the IQAE confidence interval.""" n = 3 with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=DeprecationWarning) qae = IterativeAmplitudeEstimation( 0.1, 0.01, a_factory=SineIntegralAFactory(n)) expected_confint = [0.19840508760087738, 0.35110155403424115] # statevector simulator result = qae.run(self._statevector) confint = result['confidence_interval'] # confidence interval based on statevector should be empty, as we are sure of the result self.assertAlmostEqual(confint[1] - confint[0], 0.0) self.assertAlmostEqual(confint[0], result['estimation']) # qasm simulator shots = 100 result = qae.run(self._qasm(shots)) confint = result['confidence_interval'] np.testing.assert_almost_equal(confint, expected_confint, decimal=7) self.assertTrue(confint[0] <= result['estimation'] <= confint[1])
class TestBernoulli(QiskitAquaTestCase): """ Test Bernoulli """ def setUp(self): super().setUp() self._statevector = QuantumInstance( backend=BasicAer.get_backend('statevector_simulator'), seed_simulator=2, seed_transpiler=2) def qasm(shots=100): return QuantumInstance( backend=BasicAer.get_backend('qasm_simulator'), shots=shots, seed_simulator=2, seed_transpiler=2) self._qasm = qasm @parameterized.expand( [[0.2, AmplitudeEstimation(2), { 'estimation': 0.5, 'mle': 0.2 }], [0.4, AmplitudeEstimation(4), { 'estimation': 0.30866, 'mle': 0.4 }], [0.82, AmplitudeEstimation(5), { 'estimation': 0.85355, 'mle': 0.82 }], [0.49, AmplitudeEstimation(3), { 'estimation': 0.5, 'mle': 0.49 }], [0.2, MaximumLikelihoodAmplitudeEstimation(2), { 'estimation': 0.2 }], [0.4, MaximumLikelihoodAmplitudeEstimation(4), { 'estimation': 0.4 }], [0.82, MaximumLikelihoodAmplitudeEstimation(5), { 'estimation': 0.82 }], [0.49, MaximumLikelihoodAmplitudeEstimation(3), { 'estimation': 0.49 }]]) def test_statevector(self, prob, a_e, expect): """ statevector test """ # construct factories for A and Q a_e.a_factory = BernoulliAFactory(prob) a_e.q_factory = BernoulliQFactory(a_e.a_factory) result = a_e.run(self._statevector) for key, value in expect.items(): self.assertAlmostEqual(value, result[key], places=3, msg="estimate `{}` failed".format(key)) @parameterized.expand([[ 0.2, 100, AmplitudeEstimation(4), { 'estimation': 0.14644, 'mle': 0.193888 } ], [0.0, 1000, AmplitudeEstimation(2), { 'estimation': 0.0, 'mle': 0.0 }], [ 0.8, 10, AmplitudeEstimation(7), { 'estimation': 0.79784, 'mle': 0.801612 } ], [ 0.2, 100, MaximumLikelihoodAmplitudeEstimation(4), { 'estimation': 0.199606 } ], [ 0.4, 1000, MaximumLikelihoodAmplitudeEstimation(6), { 'estimation': 0.399488 } ], [ 0.8, 10, MaximumLikelihoodAmplitudeEstimation(7), { 'estimation': 0.800926 } ]]) def test_qasm(self, prob, shots, a_e, expect): """ qasm test """ # construct factories for A and Q a_e.a_factory = BernoulliAFactory(prob) a_e.q_factory = BernoulliQFactory(a_e.a_factory) result = a_e.run(self._qasm(shots)) for key, value in expect.items(): self.assertAlmostEqual(value, result[key], places=3, msg="estimate `{}` failed".format(key))
class TestBernoulli(QiskitAquaTestCase): """Tests based on the Bernoulli A operator. This class tests * the estimation result * the constructed circuits """ def setUp(self): super().setUp() warnings.filterwarnings(action="ignore", category=DeprecationWarning) self._statevector = QuantumInstance( backend=BasicAer.get_backend('statevector_simulator'), seed_simulator=2, seed_transpiler=2) self._unitary = QuantumInstance( backend=BasicAer.get_backend('unitary_simulator'), shots=1, seed_simulator=42, seed_transpiler=91) def qasm(shots=100): return QuantumInstance( backend=BasicAer.get_backend('qasm_simulator'), shots=shots, seed_simulator=2, seed_transpiler=2) self._qasm = qasm def tearDown(self): super().tearDown() warnings.filterwarnings(action="always", category=DeprecationWarning) @idata( [[0.2, AmplitudeEstimation(2), { 'estimation': 0.5, 'mle': 0.2 }], [0.4, AmplitudeEstimation(4), { 'estimation': 0.30866, 'mle': 0.4 }], [0.82, AmplitudeEstimation(5), { 'estimation': 0.85355, 'mle': 0.82 }], [0.49, AmplitudeEstimation(3), { 'estimation': 0.5, 'mle': 0.49 }], [0.2, MaximumLikelihoodAmplitudeEstimation(2), { 'estimation': 0.2 }], [0.4, MaximumLikelihoodAmplitudeEstimation(4), { 'estimation': 0.4 }], [0.82, MaximumLikelihoodAmplitudeEstimation(5), { 'estimation': 0.82 }], [0.49, MaximumLikelihoodAmplitudeEstimation(3), { 'estimation': 0.49 }], [0.2, IterativeAmplitudeEstimation(0.1, 0.1), { 'estimation': 0.2 }], [ 0.4, IterativeAmplitudeEstimation(0.00001, 0.01), { 'estimation': 0.4 } ], [ 0.82, IterativeAmplitudeEstimation(0.00001, 0.05), { 'estimation': 0.82 } ], [ 0.49, IterativeAmplitudeEstimation(0.001, 0.01), { 'estimation': 0.49 } ]]) @unpack def test_statevector(self, prob, qae, expect): """Test running QAE using the statevector simulator.""" # construct factories for A and Q qae.a_factory = BernoulliAFactory(prob) qae.q_factory = BernoulliQFactory(qae.a_factory) result = qae.run(self._statevector) for key, value in expect.items(): self.assertAlmostEqual(value, result[key], places=3, msg="estimate `{}` failed".format(key)) @idata([ [ 0.2, 100, AmplitudeEstimation(4), { 'estimation': 0.14644, 'mle': 0.193888 } ], [0.0, 1000, AmplitudeEstimation(2), { 'estimation': 0.0, 'mle': 0.0 }], [ 0.8, 10, AmplitudeEstimation(7), { 'estimation': 0.79784, 'mle': 0.801612 } ], [ 0.2, 100, MaximumLikelihoodAmplitudeEstimation(4), { 'estimation': 0.199606 } ], [ 0.4, 1000, MaximumLikelihoodAmplitudeEstimation(6), { 'estimation': 0.399488 } ], # [0.8, 10, MaximumLikelihoodAmplitudeEstimation(7), {'estimation': 0.800926}], [ 0.2, 100, IterativeAmplitudeEstimation(0.0001, 0.01), { 'estimation': 0.199987 } ], [ 0.4, 1000, IterativeAmplitudeEstimation(0.001, 0.05), { 'estimation': 0.400071 } ], [ 0.8, 10, IterativeAmplitudeEstimation(0.1, 0.05), { 'estimation': 0.811711 } ] ]) @unpack def test_qasm(self, prob, shots, qae, expect): """ qasm test """ # construct factories for A and Q qae.a_factory = BernoulliAFactory(prob) qae.q_factory = BernoulliQFactory(qae.a_factory) result = qae.run(self._qasm(shots)) for key, value in expect.items(): self.assertAlmostEqual(value, result[key], places=3, msg="estimate `{}` failed".format(key)) @data(True, False) def test_qae_circuit(self, efficient_circuit): """Test circuits resulting from canonical amplitude estimation. Build the circuit manually and from the algorithm and compare the resulting unitaries. """ prob = 0.5 for m in range(2, 7): warnings.filterwarnings('ignore', category=DeprecationWarning) qae = AmplitudeEstimation(m, a_factory=BernoulliAFactory(prob)) angle = 2 * np.arcsin(np.sqrt(prob)) # manually set up the inefficient AE circuit q_ancilla = QuantumRegister(m, 'a') q_objective = QuantumRegister(1, 'q') circuit = QuantumCircuit(q_ancilla, q_objective) # initial Hadamard gates for i in range(m): circuit.h(q_ancilla[i]) # A operator circuit.ry(angle, q_objective) if efficient_circuit: qae.q_factory = BernoulliQFactory(qae.a_factory) for power in range(m): circuit.cry(2 * 2**power * angle, q_ancilla[power], q_objective[0]) else: q_factory = QFactory(qae.a_factory, i_objective=0) for power in range(m): for _ in range(2**power): q_factory.build_controlled(circuit, q_objective, q_ancilla[power]) warnings.filterwarnings('always', category=DeprecationWarning) # fourier transform iqft = QFT(m, do_swaps=False).inverse().reverse_bits() circuit.append(iqft.to_instruction(), q_ancilla) expected_unitary = self._unitary.execute(circuit).get_unitary() actual_circuit = qae.construct_circuit(measurement=False) actual_unitary = self._unitary.execute( actual_circuit).get_unitary() diff = np.sum(np.abs(actual_unitary - expected_unitary)) self.assertAlmostEqual(diff, 0) @data(True, False) def test_iqae_circuits(self, efficient_circuit): """Test circuits resulting from iterative amplitude estimation. Build the circuit manually and from the algorithm and compare the resulting unitaries. """ prob = 0.5 for k in range(2, 7): warnings.filterwarnings('ignore', category=DeprecationWarning) qae = IterativeAmplitudeEstimation( 0.01, 0.05, a_factory=BernoulliAFactory(prob)) angle = 2 * np.arcsin(np.sqrt(prob)) # manually set up the inefficient AE circuit q_objective = QuantumRegister(1, 'q') circuit = QuantumCircuit(q_objective) # A operator circuit.ry(angle, q_objective) if efficient_circuit: qae.q_factory = BernoulliQFactory(qae.a_factory) # for power in range(k): # circuit.ry(2 ** power * angle, q_objective[0]) circuit.ry(2 * k * angle, q_objective[0]) else: q_factory = QFactory(qae.a_factory, i_objective=0) for _ in range(k): q_factory.build(circuit, q_objective) warnings.filterwarnings('always', category=DeprecationWarning) expected_unitary = self._unitary.execute(circuit).get_unitary() actual_circuit = qae.construct_circuit(k, measurement=False) actual_unitary = self._unitary.execute( actual_circuit).get_unitary() diff = np.sum(np.abs(actual_unitary - expected_unitary)) self.assertAlmostEqual(diff, 0) @data(True, False) def test_mlae_circuits(self, efficient_circuit): """ Test the circuits constructed for MLAE """ prob = 0.5 for k in range(1, 7): warnings.filterwarnings('ignore', category=DeprecationWarning) qae = MaximumLikelihoodAmplitudeEstimation( k, a_factory=BernoulliAFactory(prob)) angle = 2 * np.arcsin(np.sqrt(prob)) # compute all the circuits used for MLAE circuits = [] # 0th power q_objective = QuantumRegister(1, 'q') circuit = QuantumCircuit(q_objective) circuit.ry(angle, q_objective) circuits += [circuit] # powers of 2 for power in range(k): q_objective = QuantumRegister(1, 'q') circuit = QuantumCircuit(q_objective) # A operator circuit.ry(angle, q_objective) # Q^(2^j) operator if efficient_circuit: qae.q_factory = BernoulliQFactory(qae.a_factory) circuit.ry(2 * 2**power * angle, q_objective[0]) else: q_factory = QFactory(qae.a_factory, i_objective=0) for _ in range(2**power): q_factory.build(circuit, q_objective) warnings.filterwarnings('always', category=DeprecationWarning) actual_circuits = qae.construct_circuits(measurement=False) for actual, expected in zip(actual_circuits, circuits): expected_unitary = self._unitary.execute( expected).get_unitary() actual_unitary = self._unitary.execute(actual).get_unitary() diff = np.sum(np.abs(actual_unitary - expected_unitary)) self.assertAlmostEqual(diff, 0)
class TestProblemSetting(QiskitAquaTestCase): """Test the setting and getting of the A and Q operator and the objective qubit index.""" def setUp(self): super().setUp() self.a_bernoulli = BernoulliAFactory(0) self.q_bernoulli = BernoulliQFactory(self.a_bernoulli) self.i_bernoulli = 0 num_qubits = 5 self.a_integral = SineIntegralAFactory(num_qubits) with warnings.catch_warnings(): warnings.filterwarnings('ignore', category=DeprecationWarning) self.q_integral = QFactory(self.a_integral, num_qubits) self.i_integral = num_qubits @idata([ [AmplitudeEstimation(2)], [IterativeAmplitudeEstimation(0.1, 0.001)], [MaximumLikelihoodAmplitudeEstimation(3)], ]) @unpack def test_operators(self, qae): """ Test if A/Q operator + i_objective set correctly """ warnings.filterwarnings('ignore', category=DeprecationWarning) self.assertIsNone(qae.a_factory) self.assertIsNone(qae.q_factory) self.assertIsNone(qae.i_objective) self.assertIsNone(qae._a_factory) self.assertIsNone(qae._q_factory) self.assertIsNone(qae._i_objective) qae.a_factory = self.a_bernoulli self.assertIsNotNone(qae.a_factory) self.assertIsNotNone(qae.q_factory) self.assertIsNotNone(qae.i_objective) self.assertIsNotNone(qae._a_factory) self.assertIsNone(qae._q_factory) self.assertIsNone(qae._i_objective) qae.q_factory = self.q_bernoulli self.assertIsNotNone(qae.a_factory) self.assertIsNotNone(qae.q_factory) self.assertIsNotNone(qae.i_objective) self.assertIsNotNone(qae._a_factory) self.assertIsNotNone(qae._q_factory) self.assertIsNone(qae._i_objective) qae.i_objective = self.i_bernoulli self.assertIsNotNone(qae.a_factory) self.assertIsNotNone(qae.q_factory) self.assertIsNotNone(qae.i_objective) self.assertIsNotNone(qae._a_factory) self.assertIsNotNone(qae._q_factory) self.assertIsNotNone(qae._i_objective) warnings.filterwarnings('always', category=DeprecationWarning) @data( AmplitudeEstimation(2), IterativeAmplitudeEstimation(0.1, 0.001), MaximumLikelihoodAmplitudeEstimation(3), ) def test_a_factory_update(self, qae): """Test if the Q factory is updated if the a_factory changes -- except set manually.""" # Case 1: Set to BernoulliAFactory with default Q operator warnings.filterwarnings(action="ignore", category=DeprecationWarning) qae.a_factory = self.a_bernoulli self.assertIsInstance(qae.q_factory.a_factory, BernoulliAFactory) self.assertEqual(qae.i_objective, self.i_bernoulli) # Case 2: Change to SineIntegralAFactory with default Q operator qae.a_factory = self.a_integral self.assertIsInstance(qae.q_factory.a_factory, SineIntegralAFactory) self.assertEqual(qae.i_objective, self.i_integral) # Case 3: Set to BernoulliAFactory with special Q operator qae.a_factory = self.a_bernoulli qae.q_factory = self.q_bernoulli self.assertIsInstance(qae.q_factory, BernoulliQFactory) self.assertEqual(qae.i_objective, self.i_bernoulli) # Case 4: Set to SineIntegralAFactory, and do not set Q. Then the old Q operator # should remain qae.a_factory = self.a_integral self.assertIsInstance(qae.q_factory, BernoulliQFactory) self.assertEqual(qae.i_objective, self.i_bernoulli) warnings.filterwarnings(action="always", category=DeprecationWarning)
class TestBernoulli(QiskitAquaTestCase): """Tests based on the Bernoulli A operator. This class tests * the estimation result * the constructed circuits """ def setUp(self): super().setUp() self._statevector = QuantumInstance( backend=BasicAer.get_backend('statevector_simulator'), seed_simulator=2, seed_transpiler=2) self._unitary = QuantumInstance( backend=BasicAer.get_backend('unitary_simulator'), shots=1, seed_simulator=42, seed_transpiler=91) def qasm(shots=100): return QuantumInstance( backend=BasicAer.get_backend('qasm_simulator'), shots=shots, seed_simulator=2, seed_transpiler=2) self._qasm = qasm @idata( [[0.2, AmplitudeEstimation(2), { 'estimation': 0.5, 'mle': 0.2 }], [0.49, AmplitudeEstimation(3), { 'estimation': 0.5, 'mle': 0.49 }], [0.2, MaximumLikelihoodAmplitudeEstimation(2), { 'estimation': 0.2 }], [0.49, MaximumLikelihoodAmplitudeEstimation(3), { 'estimation': 0.49 }], [0.2, IterativeAmplitudeEstimation(0.1, 0.1), { 'estimation': 0.2 }], [ 0.49, IterativeAmplitudeEstimation(0.001, 0.01), { 'estimation': 0.49 } ]]) @unpack def test_statevector(self, prob, qae, expect): """ statevector test """ # construct factories for A and Q qae.state_preparation = BernoulliStateIn(prob) qae.grover_operator = BernoulliGrover(prob) result = qae.run(self._statevector) self.assertGreater(self._statevector.time_taken, 0.) self._statevector.reset_execution_results() for key, value in expect.items(): self.assertAlmostEqual(value, getattr(result, key), places=3, msg="estimate `{}` failed".format(key)) @idata([[ 0.2, 100, AmplitudeEstimation(4), { 'estimation': 0.14644, 'mle': 0.193888 } ], [0.0, 1000, AmplitudeEstimation(2), { 'estimation': 0.0, 'mle': 0.0 }], [ 0.2, 100, MaximumLikelihoodAmplitudeEstimation(4), { 'estimation': 0.199606 } ], [ 0.8, 10, IterativeAmplitudeEstimation(0.1, 0.05), { 'estimation': 0.811711 } ]]) @unpack def test_qasm(self, prob, shots, qae, expect): """ qasm test """ # construct factories for A and Q qae.state_preparation = BernoulliStateIn(prob) qae.grover_operator = BernoulliGrover(prob) result = qae.run(self._qasm(shots)) for key, value in expect.items(): self.assertAlmostEqual(value, getattr(result, key), places=3, msg="estimate `{}` failed".format(key)) @data(True, False) def test_qae_circuit(self, efficient_circuit): """Test circuits resulting from canonical amplitude estimation. Build the circuit manually and from the algorithm and compare the resulting unitaries. """ prob = 0.5 for m in [2, 5]: qae = AmplitudeEstimation(m, BernoulliStateIn(prob)) angle = 2 * np.arcsin(np.sqrt(prob)) # manually set up the inefficient AE circuit qr_eval = QuantumRegister(m, 'a') qr_objective = QuantumRegister(1, 'q') circuit = QuantumCircuit(qr_eval, qr_objective) # initial Hadamard gates for i in range(m): circuit.h(qr_eval[i]) # A operator circuit.ry(angle, qr_objective) if efficient_circuit: qae.grover_operator = BernoulliGrover(prob) for power in range(m): circuit.cry(2 * 2**power * angle, qr_eval[power], qr_objective[0]) else: oracle = QuantumCircuit(1) oracle.x(0) oracle.z(0) oracle.x(0) state_preparation = QuantumCircuit(1) state_preparation.ry(angle, 0) grover_op = GroverOperator(oracle, state_preparation) for power in range(m): circuit.compose(grover_op.power(2**power).control(), qubits=[qr_eval[power], qr_objective[0]], inplace=True) # fourier transform iqft = QFT(m, do_swaps=False).inverse() circuit.append(iqft.to_instruction(), qr_eval) actual_circuit = qae.construct_circuit(measurement=False) self.assertEqual(Operator(circuit), Operator(actual_circuit)) @data(True, False) def test_iqae_circuits(self, efficient_circuit): """Test circuits resulting from iterative amplitude estimation. Build the circuit manually and from the algorithm and compare the resulting unitaries. """ prob = 0.5 for k in [2, 5]: qae = IterativeAmplitudeEstimation( 0.01, 0.05, state_preparation=BernoulliStateIn(prob)) angle = 2 * np.arcsin(np.sqrt(prob)) # manually set up the inefficient AE circuit q_objective = QuantumRegister(1, 'q') circuit = QuantumCircuit(q_objective) # A operator circuit.ry(angle, q_objective) if efficient_circuit: qae.grover_operator = BernoulliGrover(prob) circuit.ry(2 * k * angle, q_objective[0]) else: oracle = QuantumCircuit(1) oracle.x(0) oracle.z(0) oracle.x(0) state_preparation = QuantumCircuit(1) state_preparation.ry(angle, 0) grover_op = GroverOperator(oracle, state_preparation) for _ in range(k): circuit.compose(grover_op, inplace=True) actual_circuit = qae.construct_circuit(k, measurement=False) self.assertEqual(Operator(circuit), Operator(actual_circuit)) @data(True, False) def test_mlae_circuits(self, efficient_circuit): """ Test the circuits constructed for MLAE """ prob = 0.5 for k in [2, 5]: qae = MaximumLikelihoodAmplitudeEstimation( k, state_preparation=BernoulliStateIn(prob)) angle = 2 * np.arcsin(np.sqrt(prob)) # compute all the circuits used for MLAE circuits = [] # 0th power q_objective = QuantumRegister(1, 'q') circuit = QuantumCircuit(q_objective) circuit.ry(angle, q_objective) circuits += [circuit] # powers of 2 for power in range(k): q_objective = QuantumRegister(1, 'q') circuit = QuantumCircuit(q_objective) # A operator circuit.ry(angle, q_objective) # Q^(2^j) operator if efficient_circuit: qae.grover_operator = BernoulliGrover(prob) circuit.ry(2 * 2**power * angle, q_objective[0]) else: oracle = QuantumCircuit(1) oracle.x(0) oracle.z(0) oracle.x(0) state_preparation = QuantumCircuit(1) state_preparation.ry(angle, 0) grover_op = GroverOperator(oracle, state_preparation) for _ in range(2**power): circuit.compose(grover_op, inplace=True) actual_circuits = qae.construct_circuits(measurement=False) for actual, expected in zip(actual_circuits, circuits): self.assertEqual(Operator(actual), Operator(expected))
multivariate = MultivariateProblem(u, agg, objective) #trouver le nombre de qubit nécessaires pour le MultivariateProblem num_qubits = multivariate.num_target_qubits #trouver le nombre de qubits auxilliaires pour notre problème num_ancillas = multivariate.required_ancillas() #construction des registres et du circuit q = QuantumRegister(num_qubits, name='q') q_a = QuantumRegister(num_ancillas, name='q_a') qc = QuantumCircuit(q, q_a) multivariate.build(qc, q, q_a) # executer l'estimation num_eval_qubits = 5 ae = AmplitudeEstimation(num_eval_qubits, multivariate) #executer le QAE pour estimer la perte result = ae.run(quantum_instance=BasicAer.get_backend('statevector_simulator')) print('Exact Expected Loss E[L]: \t%.4f' % expected_loss) print('Estimated Expected Loss E[L]: \t%.4f' % result['estimation']) print('probability: \t%.4f' % result['max_probability']) # # tracer les valeurs estimées pour "a". # plt.bar(result['values'], result['probabilities'], width=0.5/len(result['probabilities'])) # plt.xticks([0, 0.25, 0.5, 0.75, 1], size=15) # plt.yticks([0, 0.25, 0.5, 0.75, 1], size=15) # plt.title('"a" Value', size=15) # plt.ylabel('Probability', size=15) # plt.ylim((0,1))
def test_ecev(self, use_circuits): """ European Call Expected Value test """ if not use_circuits: # ignore deprecation warnings from the deprecation of VariationalForm as input for # the univariate variational distribution warnings.filterwarnings("ignore", category=DeprecationWarning) bounds = np.array([0., 7.]) num_qubits = [3] entangler_map = [] for i in range(sum(num_qubits)): entangler_map.append([i, int(np.mod(i + 1, sum(num_qubits)))]) g_params = [ 0.29399714, 0.38853322, 0.9557694, 0.07245791, 6.02626428, 0.13537225 ] # Set an initial state for the generator circuit init_dist = NormalDistribution(int(sum(num_qubits)), mu=1., sigma=1., low=bounds[0], high=bounds[1]) init_distribution = np.sqrt(init_dist.probabilities) init_distribution = Custom(num_qubits=sum(num_qubits), state_vector=init_distribution) var_form = RY(int(np.sum(num_qubits)), depth=1, initial_state=init_distribution, entangler_map=entangler_map, entanglement_gate='cz') if use_circuits: theta = ParameterVector('θ', var_form.num_parameters) var_form = var_form.construct_circuit(theta) uncertainty_model = UnivariateVariationalDistribution(int( sum(num_qubits)), var_form, g_params, low=bounds[0], high=bounds[1]) if use_circuits: uncertainty_model._var_form_params = theta strike_price = 2 c_approx = 0.25 european_call = EuropeanCallExpectedValue(uncertainty_model, strike_price=strike_price, c_approx=c_approx) uncertainty_model.set_probabilities( QuantumInstance(BasicAer.get_backend('statevector_simulator'))) algo = AmplitudeEstimation(5, european_call) result = algo.run( quantum_instance=BasicAer.get_backend('statevector_simulator')) self.assertAlmostEqual(result['estimation'], 1.2580, places=4) self.assertAlmostEqual(result['max_probability'], 0.8785, places=4) if not use_circuits: warnings.filterwarnings(action="always", category=DeprecationWarning)
class TestEuropeanCallOption(QiskitAquaTestCase): """ Test European Call Option """ def setUp(self): super().setUp() # number of qubits to represent the uncertainty num_uncertainty_qubits = 3 # parameters for considered random distribution s_p = 2.0 # initial spot price vol = 0.4 # volatility of 40% r = 0.05 # annual interest rate of 4% t_m = 40 / 365 # 40 days to maturity # resulting parameters for log-normal distribution m_u = ((r - 0.5 * vol**2) * t_m + np.log(s_p)) sigma = vol * np.sqrt(t_m) mean = np.exp(m_u + sigma**2 / 2) variance = (np.exp(sigma**2) - 1) * np.exp(2 * m_u + sigma**2) stddev = np.sqrt(variance) # lowest and highest value considered for the spot price; # in between, an equidistant discretization is considered. low = np.maximum(0, mean - 3 * stddev) high = mean + 3 * stddev # construct circuit factory for uncertainty model uncertainty_model = LogNormalDistribution(num_uncertainty_qubits, mu=m_u, sigma=sigma, low=low, high=high) # set the strike price (should be within the low and the high value of the uncertainty) strike_price = 1.896 # set the approximation scaling for the payoff function c_approx = 0.1 # setup piecewise linear objective function breakpoints = [uncertainty_model.low, strike_price] slopes = [0, 1] offsets = [0, 0] f_min = 0 f_max = uncertainty_model.high - strike_price european_call_objective = PwlObjective( uncertainty_model.num_target_qubits, uncertainty_model.low, uncertainty_model.high, breakpoints, slopes, offsets, f_min, f_max, c_approx) # construct circuit factory for payoff function self.european_call = UnivariateProblem(uncertainty_model, european_call_objective) # construct circuit factory for payoff function self.european_call_delta = EuropeanCallDelta( uncertainty_model, strike_price=strike_price, ) self._statevector = QuantumInstance( backend=BasicAer.get_backend('statevector_simulator'), circuit_caching=False, seed_simulator=2, seed_transpiler=2) self._qasm = QuantumInstance( backend=BasicAer.get_backend('qasm_simulator'), shots=100, circuit_caching=False, seed_simulator=2, seed_transpiler=2) @parameterized.expand([ [ 'statevector', AmplitudeEstimation(3), { 'estimation': 0.45868536404797905, 'mle': 0.1633160 } ], [ 'qasm', AmplitudeEstimation(4), { 'estimation': 0.45868536404797905, 'mle': 0.23479973342434832 } ], [ 'statevector', MaximumLikelihoodAmplitudeEstimation(5), { 'estimation': 0.16330976193204114 } ], [ 'qasm', MaximumLikelihoodAmplitudeEstimation(3), { 'estimation': 0.1027255930905642 } ], ]) def test_expected_value(self, simulator, a_e, expect): """ expected value test """ # set A factory for amplitude estimation a_e.a_factory = self.european_call # run simulation result = a_e.run(self._qasm if simulator == 'qasm' else self._statevector) # compare to precomputed solution for key, value in expect.items(): self.assertAlmostEqual(result[key], value, places=4, msg="estimate `{}` failed".format(key)) @parameterized.expand([ [ 'statevector', AmplitudeEstimation(3), { 'estimation': 0.8535534, 'mle': 0.8097974047170567 } ], [ 'qasm', AmplitudeEstimation(4), { 'estimation': 0.8535534, 'mle': 0.8143597808556013 } ], [ 'statevector', MaximumLikelihoodAmplitudeEstimation(5), { 'estimation': 0.8097582003326866 } ], [ 'qasm', MaximumLikelihoodAmplitudeEstimation(6), { 'estimation': 0.8096123776923358 } ], ]) def test_delta(self, simulator, a_e, expect): """ delta test """ # set A factory for amplitude estimation a_e.a_factory = self.european_call_delta # run simulation result = a_e.run(self._qasm if simulator == 'qasm' else self._statevector) # compare to precomputed solution for key, value in expect.items(): self.assertAlmostEqual(result[key], value, places=4, msg="estimate `{}` failed".format(key))
class TestProblemSetting(QiskitAquaTestCase): """Test the setting and getting of the A and Q operator and the objective qubit index.""" def setUp(self): super().setUp() self.a_bernoulli = BernoulliAFactory(0) self.q_bernoulli = BernoulliQFactory(self.a_bernoulli) self.i_bernoulli = 0 num_qubits = 5 self.a_integral = SineIntegralAFactory(num_qubits) self.q_intergal = QFactory(self.a_integral, num_qubits) self.i_intergal = num_qubits @parameterized.expand([ [AmplitudeEstimation(2)], [IterativeAmplitudeEstimation(0.1, 0.001)], [MaximumLikelihoodAmplitudeEstimation(3)], ]) def test_operators(self, qae): """ Test if A/Q operator + i_objective set correctly """ self.assertIsNone(qae.a_factory) self.assertIsNone(qae.q_factory) self.assertIsNone(qae.i_objective) self.assertIsNone(qae._a_factory) self.assertIsNone(qae._q_factory) self.assertIsNone(qae._i_objective) qae.a_factory = self.a_bernoulli self.assertIsNotNone(qae.a_factory) self.assertIsNotNone(qae.q_factory) self.assertIsNotNone(qae.i_objective) self.assertIsNotNone(qae._a_factory) self.assertIsNone(qae._q_factory) self.assertIsNone(qae._i_objective) qae.q_factory = self.q_bernoulli self.assertIsNotNone(qae.a_factory) self.assertIsNotNone(qae.q_factory) self.assertIsNotNone(qae.i_objective) self.assertIsNotNone(qae._a_factory) self.assertIsNotNone(qae._q_factory) self.assertIsNone(qae._i_objective) qae.i_objective = self.i_bernoulli self.assertIsNotNone(qae.a_factory) self.assertIsNotNone(qae.q_factory) self.assertIsNotNone(qae.i_objective) self.assertIsNotNone(qae._a_factory) self.assertIsNotNone(qae._q_factory) self.assertIsNotNone(qae._i_objective) @parameterized.expand([ [AmplitudeEstimation(2)], [IterativeAmplitudeEstimation(0.1, 0.001)], [MaximumLikelihoodAmplitudeEstimation(3)], ]) def test_a_factory_update(self, qae): """Test if the Q factory is updated if the a_factory changes -- except set manually.""" # Case 1: Set to BernoulliAFactory with default Q operator qae.a_factory = self.a_bernoulli self.assertIsInstance(qae.q_factory.a_factory, BernoulliAFactory) self.assertEqual(qae.i_objective, self.i_bernoulli) # Case 2: Change to SineIntegralAFactory with default Q operator qae.a_factory = self.a_integral self.assertIsInstance(qae.q_factory.a_factory, SineIntegralAFactory) self.assertEqual(qae.i_objective, self.i_intergal) # Case 3: Set to BernoulliAFactory with special Q operator qae.a_factory = self.a_bernoulli qae.q_factory = self.q_bernoulli self.assertIsInstance(qae.q_factory, BernoulliQFactory) self.assertEqual(qae.i_objective, self.i_bernoulli) # Case 4: Set to SineIntegralAFactory, and do not set Q. Then the old Q operator # should remain qae.a_factory = self.a_integral self.assertIsInstance(qae.q_factory, BernoulliQFactory) self.assertEqual(qae.i_objective, self.i_bernoulli)