┌───────┐┌────┐\n", "q_0: ┤0 ├┤0 ├\n", " │ ││ │\n", "q_1: ┤1 P(X) ├┤1 ├\n", " │ ││ │\n", "q_2: ┤2 ├┤2 ├\n", " └───────┘│ │\n", "q_3: ─────────┤3 F ├\n", " │ │\n", "q_4: ─────────┤4 ├\n", " │ │\n", "q_5: ─────────┤5 ├\n", " │ │\n", "q_6: ─────────┤6 ├\n", " └────┘" ], "text/plain": [ " ┌───────┐┌────┐\n", "q_0: ┤0 ├┤0 ├\n", " │ ││ │\n", "q_1: ┤1 P(X) ├┤1 ├\n", " │ ││ │\n", "q_2: ┤2 ├┤2 ├\n", " └───────┘│ │\n", "q_3: ─────────┤3 F ├\n", " │ │\n", "q_4: ─────────┤4 ├\n", " │ │\n", "q_5: ─────────┤5 ├\n", " │ │\n", "q_6: ─────────┤6 ├\n", " └────┘" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# set the strike price (should be within the low and the high value of the uncertainty)\n", "strike_price = 1.896\n", "\n", "# set the approximation scaling for the payoff function\n", "c_approx = 0.25\n", "\n", "# setup piecewise linear objective fcuntion\n", "breakpoints = [low, strike_price]\n", "slopes = [0, 1]\n", "offsets = [0, 0]\n", "f_min = 0\n", "f_max = high - strike_price\n", "european_call_objective = LinearAmplitudeFunction(\n", " num_uncertainty_qubits,\n", " slopes,\n", " offsets,\n", " domain=(low, high),\n", " image=(f_min, f_max),\n", " breakpoints=breakpoints,\n", " rescaling_factor=c_approx,\n", ")\n", "\n", "# construct A operator for QAE for the payoff function by\n", "# composing the uncertainty model and the objective\n", "num_qubits = european_call_objective.num_qubits\n", "european_call = QuantumCircuit(num_qubits)\n", "european_call.append(uncertainty_model, range(num_uncertainty_qubits))\n", "european_call.append(european_call_objective, range(num_qubits))\n", "\n", "# draw the circuit\n", "european_call.draw()" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:35:11.080005Z", "start_time": "2020-07-13T23:35:10.832762Z" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
┌───────┐┌────┐\n", "q_0: ┤0 ├┤0 ├\n", " │ ││ │\n", "q_1: ┤1 P(X) ├┤1 ├\n", " │ ││ │\n", "q_2: ┤2 ├┤2 ├\n", " └───────┘│ │\n", "q_3: ─────────┤3 F ├\n", " │ │\n", "q_4: ─────────┤4 ├\n", " │ │\n", "q_5: ─────────┤5 ├\n", " │ │\n", "q_6: ─────────┤6 ├\n", " └────┘" ], "text/plain": [ " ┌───────┐┌────┐\n", "q_0: ┤0 ├┤0 ├\n", " │ ││ │\n", "q_1: ┤1 P(X) ├┤1 ├\n", " │ ││ │\n", "q_2: ┤2 ├┤2 ├\n", " └───────┘│ │\n", "q_3: ─────────┤3 F ├\n", " │ │\n", "q_4: ─────────┤4 ├\n", " │ │\n", "q_5: ─────────┤5 ├\n", " │ │\n", "q_6: ─────────┤6 ├\n", " └────┘" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "european_call.draw()" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:35:11.253873Z", "start_time": "2020-07-13T23:35:11.247765Z" } }, "outputs": [], "source": [ "# set target precision and confidence level\n", "epsilon = 0.01\n", "alpha = 0.05\n", "\n", "problem = EstimationProblem(\n", " state_preparation=european_call,\n", " objective_qubits=[3],\n", " post_processing=european_call_objective.post_processing,\n", ")\n", "# construct amplitude estimation\n", "ae = IterativeAmplitudeEstimation(\n", " epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={\"shots\": 100, \"seed\": 75})\n", ")" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:35:35.384882Z", "start_time": "2020-07-13T23:35:11.373858Z" } }, "outputs": [], "source": [ "result = ae.estimate(problem)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:35:35.392375Z", "start_time": "2020-07-13T23:35:35.387058Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Exact value: \t0.1623\n", "Estimated value: \t0.1687\n", "Confidence interval:\t[0.1637, 0.1737]\n" ] } ], "source": [ "conf_int = np.array(result.confidence_interval_processed)\n", "print(\"Exact value: \\t%.4f\" % exact_value)\n", "print(\"Estimated value: \\t%.4f\" % (result.estimation_processed))\n", "print(\"Confidence interval:\\t[%.4f, %.4f]\" % tuple(conf_int))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Instead of constructing these circuits manually, the Qiskit Finance module offers the `EuropeanCallPricing` circuit, which already implements this functionality as a building block." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "from qiskit_finance.applications.estimation import EuropeanCallPricing\n", "\n", "european_call_pricing = EuropeanCallPricing(\n", " num_state_qubits=num_uncertainty_qubits,\n", " strike_price=strike_price,\n", " rescaling_factor=c_approx,\n", " bounds=(low, high),\n", " uncertainty_model=uncertainty_model,\n", ")" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Exact value: \t0.1623\n", "Estimated value: \t0.1687\n", "Confidence interval:\t[0.1637, 0.1737]\n" ] } ], "source": [ "# set target precision and confidence level\n", "epsilon = 0.01\n", "alpha = 0.05\n", "\n", "problem = european_call_pricing.to_estimation_problem()\n", "# construct amplitude estimation\n", "ae = IterativeAmplitudeEstimation(\n", " epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={\"shots\": 100, \"seed\": 75})\n", ")\n", "result = ae.estimate(problem)\n", "\n", "conf_int = np.array(result.confidence_interval_processed)\n", "print(\"Exact value: \\t%.4f\" % exact_value)\n", "print(\"Estimated value: \\t%.4f\" % (european_call_pricing.interpret(result)))\n", "print(\"Confidence interval:\\t[%.4f, %.4f]\" % tuple(conf_int))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Evaluate Delta\n", "\n", "The Delta is a bit simpler to evaluate than the expected payoff.\n", "Similarly to the expected payoff, we use a comparator circuit and an ancilla qubit to identify the cases where $S_T > K$.\n", "However, since we are only interested in the probability of this condition being true, we can directly use this ancilla qubit as the objective qubit in amplitude estimation without any further approximation." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:35:35.826269Z", "start_time": "2020-07-13T23:35:35.819320Z" } }, "outputs": [], "source": [ "from qiskit_finance.applications.estimation import EuropeanCallDelta\n", "\n", "european_call_delta = EuropeanCallDelta(\n", " num_state_qubits=num_uncertainty_qubits,\n", " strike_price=strike_price,\n", " bounds=(low, high),\n", " uncertainty_model=uncertainty_model,\n", ")" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
┌──────┐\n", "state_0: ┤0 ├\n", " │ │\n", "state_1: ┤1 ├\n", " │ │\n", "state_2: ┤2 ├\n", " │ cmp │\n", "state_3: ┤3 ├\n", " │ │\n", " work_0: ┤4 ├\n", " │ │\n", " work_1: ┤5 ├\n", " └──────┘" ], "text/plain": [ " ┌──────┐\n", "state_0: ┤0 ├\n", " │ │\n", "state_1: ┤1 ├\n", " │ │\n", "state_2: ┤2 ├\n", " │ cmp │\n", "state_3: ┤3 ├\n", " │ │\n", " work_0: ┤4 ├\n", " │ │\n", " work_1: ┤5 ├\n", " └──────┘" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "european_call_delta._objective.decompose().draw()" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
┌───────┐┌──────┐\n", "q_0: ┤0 ├┤0 ├\n", " │ ││ │\n", "q_1: ┤1 P(X) ├┤1 ├\n", " │ ││ │\n", "q_2: ┤2 ├┤2 ├\n", " └───────┘│ ECD │\n", "q_3: ─────────┤3 ├\n", " │ │\n", "q_4: ─────────┤4 ├\n", " │ │\n", "q_5: ─────────┤5 ├\n", " └──────┘" ], "text/plain": [ " ┌───────┐┌──────┐\n", "q_0: ┤0 ├┤0 ├\n", " │ ││ │\n", "q_1: ┤1 P(X) ├┤1 ├\n", " │ ││ │\n", "q_2: ┤2 ├┤2 ├\n", " └───────┘│ ECD │\n", "q_3: ─────────┤3 ├\n", " │ │\n", "q_4: ─────────┤4 ├\n", " │ │\n", "q_5: ─────────┤5 ├\n", " └──────┘" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "european_call_delta_circ = QuantumCircuit(european_call_delta._objective.num_qubits)\n", "european_call_delta_circ.append(uncertainty_model, range(num_uncertainty_qubits))\n", "european_call_delta_circ.append(\n", " european_call_delta._objective, range(european_call_delta._objective.num_qubits)\n", ")\n", "\n", "european_call_delta_circ.draw()" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:35:35.843101Z", "start_time": "2020-07-13T23:35:35.828358Z" } }, "outputs": [], "source": [ "# set target precision and confidence level\n", "epsilon = 0.01\n", "alpha = 0.05\n", "\n", "problem = european_call_delta.to_estimation_problem()\n", "\n", "# construct amplitude estimation\n", "ae_delta = IterativeAmplitudeEstimation(\n", " epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={\"shots\": 100, \"seed\": 75})\n", ")" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:35:58.524643Z", "start_time": "2020-07-13T23:35:35.848588Z" } }, "outputs": [], "source": [ "result_delta = ae_delta.estimate(problem)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:35:58.531941Z", "start_time": "2020-07-13T23:35:58.526967Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Exact delta: \t0.8098\n", "Estimated value: \t0.8091\n", "Confidence interval: \t[0.8034, 0.8148]\n" ] } ], "source": [ "conf_int = np.array(result_delta.confidence_interval_processed)\n", "print(\"Exact delta: \\t%.4f\" % exact_delta)\n", "print(\"Estimated value: \\t%.4f\" % european_call_delta.interpret(result_delta))\n", "print(\"Confidence interval: \\t[%.4f, %.4f]\" % tuple(conf_int))" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "ExecuteTime": { "end_time": "2020-07-13T23:35:58.967675Z", "start_time": "2020-07-13T23:35:58.792732Z" } }, "outputs": [ { "data": { "text/html": [ "
Software | Version |
---|---|
qiskit | None |
qiskit-terra | 0.45.0.dev0+c626be7 |
qiskit_finance | 0.4.0 |
qiskit_aer | 0.12.0 |
qiskit_algorithms | 0.2.0 |
qiskit_ibm_provider | 0.6.1 |
qiskit_optimization | 0.6.0 |
System information | |
Python version | 3.9.7 |
Python compiler | GCC 7.5.0 |
Python build | default, Sep 16 2021 13:09:58 |
OS | Linux |
CPUs | 2 |
Memory (Gb) | 5.778430938720703 |
Fri Aug 18 16:00:58 2023 EDT |
© Copyright IBM 2017, 2023.
This code is licensed under the Apache License, Version 2.0. You may
obtain a copy of this license in the LICENSE.txt file in the root directory
of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
Any modifications or derivative works of this code must retain this
copyright notice, and modified files need to carry a notice indicating
that they have been altered from the originals.