├── .gitignore ├── LICENSE ├── README.md ├── chapter01_Quantum_Circuits_and_Operations ├── chapter01-1_Constructing_Quantum_Circuits.ipynb ├── chapter01-2_Instructions_and_Gates.ipynb └── chapter01-3_Parameterized_Quantum_Circuits.ipynb ├── chapter02_Running_Quantum_Circuits ├── chapter02-1_Using_the_BasicAer_Simulators.ipynb └── chapter02-2_Using_the_Aer_Simulators.ipynb ├── chapter03_Visualizing_Quantum_Measurements_and_States ├── chapter03-1_Visualizing_Measurement_Counts.ipynb └── chapter03-2_Visualizing_Quantum_States.ipynb ├── chapter05_Quantum_Information ├── chapter05-1_Using_Quantum_Information_States.ipynb ├── chapter05-2_Using_Quantum_Information_Operators.ipynb ├── chapter05-3_Using_Quantum_Information_Channels.ipynb └── chapter05-4_Using_Quantum_Information_Measures.ipynb ├── chapter06_Operator_Flow ├── chapter06-1_Creating_Operator_Flow_Expressions.ipynb ├── chapter06-2_Using_the_Operator_Flow_State_Function_classes.ipynb └── chapter06-3_Using_the_Operator_Flow_Primitive_Operators_classes.ipynb ├── logo.png └── requirements.txt /.gitignore: -------------------------------------------------------------------------------- 1 | # editor files 2 | .vscode/ 3 | .idea/ 4 | 5 | #standard python ignores follow 6 | 7 | # Byte-compiled / optimized / DLL files 8 | __pycache__/ 9 | .pytest_cache/ 10 | *.py[cod] 11 | *$py.class 12 | .ipynb_checkpoints/ 13 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | Apache License 2 | Version 2.0, January 2004 3 | http://www.apache.org/licenses/ 4 | 5 | TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 6 | 7 | 1. Definitions. 8 | 9 | "License" shall mean the terms and conditions for use, reproduction, 10 | and distribution as defined by Sections 1 through 9 of this document. 11 | 12 | "Licensor" shall mean the copyright owner or entity authorized by 13 | the copyright owner that is granting the License. 14 | 15 | "Legal Entity" shall mean the union of the acting entity and all 16 | other entities that control, are controlled by, or are under common 17 | control with that entity. For the purposes of this definition, 18 | "control" means (i) the power, direct or indirect, to cause the 19 | direction or management of such entity, whether by contract or 20 | otherwise, or (ii) ownership of fifty percent (50%) or more of the 21 | outstanding shares, or (iii) beneficial ownership of such entity. 22 | 23 | "You" (or "Your") shall mean an individual or Legal Entity 24 | exercising permissions granted by this License. 25 | 26 | "Source" form shall mean the preferred form for making modifications, 27 | including but not limited to software source code, documentation 28 | source, and configuration files. 29 | 30 | "Object" form shall mean any form resulting from mechanical 31 | transformation or translation of a Source form, including but 32 | not limited to compiled object code, generated documentation, 33 | and conversions to other media types. 34 | 35 | "Work" shall mean the work of authorship, whether in Source or 36 | Object form, made available under the License, as indicated by a 37 | copyright notice that is included in or attached to the work 38 | (an example is provided in the Appendix below). 39 | 40 | "Derivative Works" shall mean any work, whether in Source or Object 41 | form, that is based on (or derived from) the Work and for which the 42 | editorial revisions, annotations, elaborations, or other modifications 43 | represent, as a whole, an original work of authorship. For the purposes 44 | of this License, Derivative Works shall not include works that remain 45 | separable from, or merely link (or bind by name) to the interfaces of, 46 | the Work and Derivative Works thereof. 47 | 48 | "Contribution" shall mean any work of authorship, including 49 | the original version of the Work and any modifications or additions 50 | to that Work or Derivative Works thereof, that is intentionally 51 | submitted to Licensor for inclusion in the Work by the copyright owner 52 | or by an individual or Legal Entity authorized to submit on behalf of 53 | the copyright owner. For the purposes of this definition, "submitted" 54 | means any form of electronic, verbal, or written communication sent 55 | to the Licensor or its representatives, including but not limited to 56 | communication on electronic mailing lists, source code control systems, 57 | and issue tracking systems that are managed by, or on behalf of, the 58 | Licensor for the purpose of discussing and improving the Work, but 59 | excluding communication that is conspicuously marked or otherwise 60 | designated in writing by the copyright owner as "Not a Contribution." 61 | 62 | "Contributor" shall mean Licensor and any individual or Legal Entity 63 | on behalf of whom a Contribution has been received by Licensor and 64 | subsequently incorporated within the Work. 65 | 66 | 2. Grant of Copyright License. Subject to the terms and conditions of 67 | this License, each Contributor hereby grants to You a perpetual, 68 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 69 | copyright license to reproduce, prepare Derivative Works of, 70 | publicly display, publicly perform, sublicense, and distribute the 71 | Work and such Derivative Works in Source or Object form. 72 | 73 | 3. Grant of Patent License. Subject to the terms and conditions of 74 | this License, each Contributor hereby grants to You a perpetual, 75 | worldwide, non-exclusive, no-charge, royalty-free, irrevocable 76 | (except as stated in this section) patent license to make, have made, 77 | use, offer to sell, sell, import, and otherwise transfer the Work, 78 | where such license applies only to those patent claims licensable 79 | by such Contributor that are necessarily infringed by their 80 | Contribution(s) alone or by combination of their Contribution(s) 81 | with the Work to which such Contribution(s) was submitted. If You 82 | institute patent litigation against any entity (including a 83 | cross-claim or counterclaim in a lawsuit) alleging that the Work 84 | or a Contribution incorporated within the Work constitutes direct 85 | or contributory patent infringement, then any patent licenses 86 | granted to You under this License for that Work shall terminate 87 | as of the date such litigation is filed. 88 | 89 | 4. Redistribution. You may reproduce and distribute copies of the 90 | Work or Derivative Works thereof in any medium, with or without 91 | modifications, and in Source or Object form, provided that You 92 | meet the following conditions: 93 | 94 | (a) You must give any other recipients of the Work or 95 | Derivative Works a copy of this License; and 96 | 97 | (b) You must cause any modified files to carry prominent notices 98 | stating that You changed the files; and 99 | 100 | (c) You must retain, in the Source form of any Derivative Works 101 | that You distribute, all copyright, patent, trademark, and 102 | attribution notices from the Source form of the Work, 103 | excluding those notices that do not pertain to any part of 104 | the Derivative Works; and 105 | 106 | (d) If the Work includes a "NOTICE" text file as part of its 107 | distribution, then any Derivative Works that You distribute must 108 | include a readable copy of the attribution notices contained 109 | within such NOTICE file, excluding those notices that do not 110 | pertain to any part of the Derivative Works, in at least one 111 | of the following places: within a NOTICE text file distributed 112 | as part of the Derivative Works; within the Source form or 113 | documentation, if provided along with the Derivative Works; or, 114 | within a display generated by the Derivative Works, if and 115 | wherever such third-party notices normally appear. The contents 116 | of the NOTICE file are for informational purposes only and 117 | do not modify the License. You may add Your own attribution 118 | notices within Derivative Works that You distribute, alongside 119 | or as an addendum to the NOTICE text from the Work, provided 120 | that such additional attribution notices cannot be construed 121 | as modifying the License. 122 | 123 | You may add Your own copyright statement to Your modifications and 124 | may provide additional or different license terms and conditions 125 | for use, reproduction, or distribution of Your modifications, or 126 | for any such Derivative Works as a whole, provided Your use, 127 | reproduction, and distribution of the Work otherwise complies with 128 | the conditions stated in this License. 129 | 130 | 5. Submission of Contributions. Unless You explicitly state otherwise, 131 | any Contribution intentionally submitted for inclusion in the Work 132 | by You to the Licensor shall be under the terms and conditions of 133 | this License, without any additional terms or conditions. 134 | Notwithstanding the above, nothing herein shall supersede or modify 135 | the terms of any separate license agreement you may have executed 136 | with Licensor regarding such Contributions. 137 | 138 | 6. Trademarks. This License does not grant permission to use the trade 139 | names, trademarks, service marks, or product names of the Licensor, 140 | except as required for reasonable and customary use in describing the 141 | origin of the Work and reproducing the content of the NOTICE file. 142 | 143 | 7. Disclaimer of Warranty. Unless required by applicable law or 144 | agreed to in writing, Licensor provides the Work (and each 145 | Contributor provides its Contributions) on an "AS IS" BASIS, 146 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or 147 | implied, including, without limitation, any warranties or conditions 148 | of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A 149 | PARTICULAR PURPOSE. You are solely responsible for determining the 150 | appropriateness of using or redistributing the Work and assume any 151 | risks associated with Your exercise of permissions under this License. 152 | 153 | 8. Limitation of Liability. In no event and under no legal theory, 154 | whether in tort (including negligence), contract, or otherwise, 155 | unless required by applicable law (such as deliberate and grossly 156 | negligent acts) or agreed to in writing, shall any Contributor be 157 | liable to You for damages, including any direct, indirect, special, 158 | incidental, or consequential damages of any character arising as a 159 | result of this License or out of the use or inability to use the 160 | Work (including but not limited to damages for loss of goodwill, 161 | work stoppage, computer failure or malfunction, or any and all 162 | other commercial damages or losses), even if such Contributor 163 | has been advised of the possibility of such damages. 164 | 165 | 9. Accepting Warranty or Additional Liability. While redistributing 166 | the Work or Derivative Works thereof, You may choose to offer, 167 | and charge a fee for, acceptance of support, warranty, indemnity, 168 | or other liability obligations and/or rights consistent with this 169 | License. However, in accepting such obligations, You may act only 170 | on Your own behalf and on Your sole responsibility, not on behalf 171 | of any other Contributor, and only if You agree to indemnify, 172 | defend, and hold each Contributor harmless for any liability 173 | incurred by, or claims asserted against, such Contributor by reason 174 | of your accepting any such warranty or additional liability. 175 | 176 | END OF TERMS AND CONDITIONS 177 | 178 | APPENDIX: How to apply the Apache License to your work. 179 | 180 | To apply the Apache License to your work, attach the following 181 | boilerplate notice, with the fields enclosed by brackets "[]" 182 | replaced with your own identifying information. (Don't include 183 | the brackets!) The text should be enclosed in the appropriate 184 | comment syntax for the file format. We also recommend that a 185 | file or class name and description of purpose be included on the 186 | same "printed page" as the copyright notice for easier 187 | identification within third-party archives. 188 | 189 | Copyright [yyyy] [name of copyright owner] 190 | 191 | Licensed under the Apache License, Version 2.0 (the "License"); 192 | you may not use this file except in compliance with the License. 193 | You may obtain a copy of the License at 194 | 195 | http://www.apache.org/licenses/LICENSE-2.0 196 | 197 | Unless required by applicable law or agreed to in writing, software 198 | distributed under the License is distributed on an "AS IS" BASIS, 199 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 200 | See the License for the specific language governing permissions and 201 | limitations under the License. 202 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Welcome to the Qiskit Pocket Guide book site! 2 | 3 | [![Qiskit Pocket Guide, by James L. Weaver and Frank J. Harkins](http://covers.oreilly.com/images/9781098112400/cat.gif)](https://www.safaribooksonline.com/library/view/title/9781098112462//) 4 | 5 | In general, you may use the code from Qiskit Pocket Guide in your programs and documentation. You do not need to contact the authors for permission unless you're reproducing a significant portion of the code. For example, writing a program that uses several chunks of code from this book does not require permission. Answering a question by citing this book and quoting example code does not require permission. On the other hand, selling or distributing a CD-ROM of examples from Qiskit Pocket Guide does require permission. Incorporating a significant amount of example code from this book into your product's documentation does require permission. 6 | 7 | We appreciate, but do not require, attribution. An attribution usually includes the title, author, publisher, and ISBN. 8 | 9 | If you think your use of code examples falls outside fair use or the permission given here, feel free to contact O'Reilly at . 10 | 11 | Please note that the examples are not production code and have not been carefully tested. They are provided "as-is" and come with no warranty of any kind. 12 | 13 | # Quick start for running the code examples 14 | 15 | ## Installing 16 | 17 | You need a way to run Python and Jupyter Notebooks: 18 | ```bash 19 | pip install jupyter 20 | ``` 21 | 22 | This is tested on Qiskit Terra 0.20. This and other dependencies can be installed via Pip: 23 | ```bash 24 | pip install -r requirements.txt 25 | 26 | ``` 27 | 28 | ## Download and run the chapters 29 | 30 | ```bash 31 | wget http://github.com/qiskit-community/qiskit-pocket-guide/archive/refs/heads/main.zip 32 | unzip main.zip 33 | 34 | ``` 35 | 36 | ## You may also run these examples in the cloud 37 | Paste or import an example into the [IBM Quantum Lab](https://quantum-computing.ibm.com/lab) 38 | 39 | # Index 40 | 41 | ## Chapter 1: Quantum Circuits and Operations 42 | * [Constructing Quantum Circuits](chapter01_Quantum_Circuits_and_Operations/chapter01-1_Constructing_Quantum_Circuits.ipynb) 43 | * [Instructions and Gates](chapter01_Quantum_Circuits_and_Operations/chapter01-2_Instructions_and_Gates.ipynb) 44 | * [Parameterized Quantum Circuits](chapter01_Quantum_Circuits_and_Operations/chapter01-3_Parameterized_Quantum_Circuits.ipynb) 45 | ## Chapter 2: Running Quantum Circuits 46 | * [Using the BasicAer Simulators](chapter02_Running_Quantum_Circuits/chapter02-1_Using_the_BasicAer_Simulators.ipynb) 47 | * [Using the Aer Simulators](chapter02_Running_Quantum_Circuits/chapter02-2_Using_the_Aer_Simulators.ipynb) 48 | * Monitoring Job Status and Obtaining Results (no code examples) 49 | ## Chapter 3: Visualizing Quantum Measurements and States 50 | * [Visualizing Measurement Counts](chapter03_Visualizing_Quantum_Measurements_and_States/chapter03-1_Visualizing_Measurement_Counts.ipynb) 51 | * [Visualizing Quantum States](chapter03_Visualizing_Quantum_Measurements_and_States/chapter03-2_Visualizing_Quantum_States.ipynb) 52 | ## Chapter 4: Using the Transpiler 53 | * Quickstart with Transpile 54 | * Transpiler Passes 55 | ## Chapter 5: Quantum Information 56 | * [Using Quantum Information States](chapter05_Quantum_Information/chapter05-1_Using_Quantum_Information_States.ipynb) 57 | * [Using Quantum Information Operators](chapter05_Quantum_Information/chapter05-2_Using_Quantum_Information_Operators.ipynb) 58 | * [Using Quantum Information Channels](chapter05_Quantum_Information/chapter05-3_Using_Quantum_Information_Channels.ipynb) 59 | * [Using Quantum Information Measures](chapter05_Quantum_Information/chapter05-4_Using_Quantum_Information_Measures.ipynb) 60 | ## Chapter 6: Operator Flow 61 | * [Creating Operator Flow Expressions](chapter06_Operator_Flow/chapter06-1_Creating_Operator_Flow_Expressions.ipynb) 62 | * [Using the Operator Flow State Function classes](chapter06_Operator_Flow/chapter06-2_Using_the_Operator_Flow_State_Function_classes.ipynb) 63 | * [Using the Operator Flow Primitive Operators classes](chapter06_Operator_Flow/chapter06-3_Using_the_Operator_Flow_Primitive_Operators_classes.ipynb) 64 | ## Chapter 7: Quantum Algorithms 65 | * Background on Quantum Algorithms 66 | * Using the Algorithms Module 67 | * Traditional Quantum Algorithms 68 | * Eigensolvers 69 | ## Chapter 8: Qiskit Circuit Library Standard Operations 70 | * Standard Instructions (no code examples) 71 | * Standard Single-Qubit Gates (no code examples) 72 | * Standard Multi-Qubit Gates (no code examples) 73 | ## Chapter 9: Working with Providers and Backends 74 | * Graphical Tools 75 | * Text-Based Tools 76 | * Getting System Info Programmatically 77 | * Interacting with Quantum Systems on the Cloud 78 | ## Chapter 10: OpenQASM 79 | * Building Quantum Circuits in QASM 80 | * Building Higher-Level Gates 81 | * Classical Types and Instructions 82 | * Building Quantum Programs 83 | -------------------------------------------------------------------------------- /chapter01_Quantum_Circuits_and_Operations/chapter01-2_Instructions_and_Gates.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "e9c34909", 6 | "metadata": {}, 7 | "source": [ 8 | "# Chapter 1: Quantum Circuits and Operations" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "b0482103", 14 | "metadata": { 15 | "ExecuteTime": { 16 | "end_time": "2022-05-05T13:46:50.178490Z", 17 | "start_time": "2022-05-05T13:46:50.167932Z" 18 | } 19 | }, 20 | "source": [ 21 | "## Instructions and Gates" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "id": "263543ab", 27 | "metadata": {}, 28 | "source": [ 29 | "Page 39a:" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 1, 35 | "id": "065f884d", 36 | "metadata": { 37 | "ExecuteTime": { 38 | "end_time": "2022-05-05T13:16:29.175235Z", 39 | "start_time": "2022-05-05T13:16:28.556041Z" 40 | } 41 | }, 42 | "outputs": [ 43 | { 44 | "name": "stdout", 45 | "output_type": "stream", 46 | "text": [ 47 | "2\n" 48 | ] 49 | } 50 | ], 51 | "source": [ 52 | "from qiskit.circuit.library import CCXGate\n", 53 | "\n", 54 | "toffoli = CCXGate()\n", 55 | "print(toffoli.num_ctrl_qubits)" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "id": "0424f0ac", 61 | "metadata": {}, 62 | "source": [ 63 | "Figure 1-20 - Page 39b:" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 2, 69 | "id": "433bdbaf", 70 | "metadata": { 71 | "ExecuteTime": { 72 | "end_time": "2022-05-05T13:16:29.208150Z", 73 | "start_time": "2022-05-05T13:16:29.196718Z" 74 | } 75 | }, 76 | "outputs": [ 77 | { 78 | "data": { 79 | "image/png": "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\n", 80 | "text/plain": [ 81 | "
" 82 | ] 83 | }, 84 | "execution_count": 2, 85 | "metadata": {}, 86 | "output_type": "execute_result" 87 | } 88 | ], 89 | "source": [ 90 | "toffoli = CCXGate()\n", 91 | "toffoli.ctrl_state = 2\n", 92 | "\n", 93 | "toffoli.definition.draw()" 94 | ] 95 | }, 96 | { 97 | "cell_type": "markdown", 98 | "id": "28f41daa", 99 | "metadata": { 100 | "ExecuteTime": { 101 | "end_time": "2022-05-05T12:50:30.128203Z", 102 | "start_time": "2022-05-05T12:50:30.121537Z" 103 | } 104 | }, 105 | "source": [ 106 | "Figure 1-21 - Page 40" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": 3, 112 | "id": "ab415ef8", 113 | "metadata": { 114 | "ExecuteTime": { 115 | "end_time": "2022-05-05T13:16:30.722708Z", 116 | "start_time": "2022-05-05T13:16:29.211773Z" 117 | } 118 | }, 119 | "outputs": [ 120 | { 121 | "data": { 122 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAHMAAABOCAYAAAATpymVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAEiklEQVR4nO3df2jUdRzH8efdee5ms+Q4dHOGee0H7PA2dtIfgt3mJkl/iFZWcywYwuQyIhSjyIV/6P6YE4TIIfTHDMpIOxjBIGx6988kWiPNMTxx5pyebsscXlhzd+sPaTCbcRvXPt+9937A/rk77l7w5Pu9X3CzTUxMTKBEsJseoDJHYwqiMQXRmIJoTEE0piAaUxCNKYjGFERjCqIxBdGYgmhMQTSmIBpTEI0piMYURGMKojEF0ZiCaExBNKYgGlMQjSmIxhREYwqiMQVZZHqAKZfPwv0hM4+9dDkUb8z8/S7YmPeH4N6g6RWZpadZQTSmIBpTEI0pyIJ9ATQbe1sr6Lt+HofDid3uIM/tpbZqPxv8r5qeBuiROWO11Y18eyhB+MBvVJbVcPCLNxgcjpmeBWjMWXM4FrFl/dukUkmuxX8xPQfQmLP2cHyM9q5PWeRw4l1ZanoOYMGYqVSKlpYWCgsLcblclJaWEo1GKS4upqGhwfQ8vuw8xNbGZew4uIrzve18/NY35HsKTM8CLPgCaOfOnYTDYRobGwkEAnR1dVFTU8Pw8DB79uwxPY8dVR9RW73f9IxpWSrmyZMnaWtrIxKJEAwGAaisrKSnp4dwOEx5ebnhhdZmqdNsU1MTmzdvngz5j4KCApxOJ36/39Cy+cEyMQcHB7l06RLbt2//13UDAwP4fD6ysrIMLJs/LBUTIDc3d8rlDx48IBqNpn2Ktdlsaf1Fo5EZbzwSimTk+TIajaS9cyYsE9Pj8QAQi019A97c3Ew8HicQCJiYNa9Y5gWQ1+vF7/fT1NSE2+0mPz+f06dP09HRAZB2zHR/17H7K3PfZwaDFUy0Zv73Jy1zZNrtdk6dOoXP5yMUClFfX4/H42H37t04HA598ZMGyxyZAEVFRZw7d27KZXV1dZSUlJCdnW1o1fxhmSPzSbq7u/X5Mk2WjplIJIjFYpb4sGBk9CbH2t9jZPQWoaPlvPyhi2RyfPL6M92fs+94FXtbKxgZvWlko6VOs4/LyckhmUyangHAT7EzBIo28fQSN80NnRw4sW3yupHRm1zsj3J4V6fBhRaPacqFqxEOnNiGN6+U23ev8fzKMpYucfPO1k9Y7HSx2Omacvvuy9+RTCXZd7yK1StKCG05isPumPPdlj7NmrJ2zYsUP/sCR0IR/N4g775yjD/H/iA7K2fa2/+euMN4cozDuzrJci6hq7d9jhc/ojGnEb/bT57bC8Dw6A3uJYb/8zvLp1zP4Pc++jy5rGAjA0N9c7LzcRpzGtdv97I610cylcRms9Nz5QyBwk1PvH3J6vX0xy8CcPXWz+S518zV1Ck05jR+vdPLcyt8PBz/i3uJIXqufE/RqnUAjCcf8v7xavrjF/jgs5foG/iBgvwyspzZ7G2tIHbjRzasfc3IbttC/b8mM/k4L3rha4Klr2fssZetgnVvZuzuJumRmYZMhvw/Ldi3JkuXy3vsBXualUhPs4JoTEE0piAaUxCNKYjGFERjCqIxBdGYgmhMQTSmIBpTEI0piMYURGMKojEF0ZiCaExB/ga2nS8TuoFjfwAAAABJRU5ErkJggg==\n", 123 | "text/plain": [ 124 | "
" 125 | ] 126 | }, 127 | "execution_count": 3, 128 | "metadata": {}, 129 | "output_type": "execute_result" 130 | } 131 | ], 132 | "source": [ 133 | "from qiskit import QuantumCircuit\n", 134 | "import math\n", 135 | "\n", 136 | "p16_qc = QuantumCircuit(1)\n", 137 | "p16_qc.p(math.pi/16, 0)\n", 138 | "\n", 139 | "p16_gate = p16_qc.to_gate()\n", 140 | "\n", 141 | "p16_gate.definition.draw()" 142 | ] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "id": "458d6fc7", 147 | "metadata": {}, 148 | "source": [ 149 | "Figure 1-22 - Page 40-41" 150 | ] 151 | }, 152 | { 153 | "cell_type": "code", 154 | "execution_count": 4, 155 | "id": "bc786dd4", 156 | "metadata": { 157 | "ExecuteTime": { 158 | "end_time": "2022-05-05T13:24:50.962582Z", 159 | "start_time": "2022-05-05T13:24:50.926733Z" 160 | } 161 | }, 162 | "outputs": [ 163 | { 164 | "data": { 165 | "image/png": "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\n", 166 | "text/plain": [ 167 | "
" 168 | ] 169 | }, 170 | "execution_count": 4, 171 | "metadata": {}, 172 | "output_type": "execute_result" 173 | } 174 | ], 175 | "source": [ 176 | "ctrl_p16 = p16_gate.control(2)\n", 177 | "\n", 178 | "ctrl_p16.definition.draw()" 179 | ] 180 | }, 181 | { 182 | "cell_type": "markdown", 183 | "id": "89d712db", 184 | "metadata": {}, 185 | "source": [ 186 | "Figure 1-23 - Page 41" 187 | ] 188 | }, 189 | { 190 | "cell_type": "code", 191 | "execution_count": 5, 192 | "id": "2dc0adcd", 193 | "metadata": { 194 | "ExecuteTime": { 195 | "end_time": "2022-05-05T13:30:46.826122Z", 196 | "start_time": "2022-05-05T13:30:46.374697Z" 197 | } 198 | }, 199 | "outputs": [ 200 | { 201 | "data": { 202 | "image/png": "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\n", 203 | "text/plain": [ 204 | "
" 205 | ] 206 | }, 207 | "execution_count": 5, 208 | "metadata": {}, 209 | "output_type": "execute_result" 210 | } 211 | ], 212 | "source": [ 213 | "qc = QuantumCircuit(4)\n", 214 | "qc.h([0,1,2,3])\n", 215 | "qc.append(ctrl_p16,[0,1,3])\n", 216 | "\n", 217 | "qc.decompose().draw()" 218 | ] 219 | } 220 | ], 221 | "metadata": { 222 | "kernelspec": { 223 | "display_name": "Qiskit v0.35.0 (ipykernel)", 224 | "language": "python", 225 | "name": "python3" 226 | }, 227 | "language_info": { 228 | "codemirror_mode": { 229 | "name": "ipython", 230 | "version": 3 231 | }, 232 | "file_extension": ".py", 233 | "mimetype": "text/x-python", 234 | "name": "python", 235 | "nbconvert_exporter": "python", 236 | "pygments_lexer": "ipython3", 237 | "version": "3.8.13" 238 | }, 239 | "widgets": { 240 | "application/vnd.jupyter.widget-state+json": { 241 | "state": {}, 242 | "version_major": 2, 243 | "version_minor": 0 244 | } 245 | } 246 | }, 247 | "nbformat": 4, 248 | "nbformat_minor": 5 249 | } 250 | -------------------------------------------------------------------------------- /chapter01_Quantum_Circuits_and_Operations/chapter01-3_Parameterized_Quantum_Circuits.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "e9c34909", 6 | "metadata": {}, 7 | "source": [ 8 | "# Chapter 1: Quantum Circuits and Operations" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "b0482103", 14 | "metadata": { 15 | "ExecuteTime": { 16 | "end_time": "2022-05-05T13:46:50.178490Z", 17 | "start_time": "2022-05-05T13:46:50.167932Z" 18 | } 19 | }, 20 | "source": [ 21 | "## Parameterized Quantum Circuits" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "id": "0424f0ac", 27 | "metadata": {}, 28 | "source": [ 29 | "Figure 1-24 - Page 42-43:" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 1, 35 | "id": "433bdbaf", 36 | "metadata": { 37 | "ExecuteTime": { 38 | "end_time": "2022-05-05T13:16:29.208150Z", 39 | "start_time": "2022-05-05T13:16:29.196718Z" 40 | } 41 | }, 42 | "outputs": [ 43 | { 44 | "data": { 45 | "image/png": "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\n", 46 | "text/plain": [ 47 | "
" 48 | ] 49 | }, 50 | "execution_count": 1, 51 | "metadata": {}, 52 | "output_type": "execute_result" 53 | } 54 | ], 55 | "source": [ 56 | "from qiskit.circuit import QuantumCircuit,\\\n", 57 | " ParameterVector\n", 58 | "\n", 59 | "theta = ParameterVector('θ', 3)\n", 60 | "\n", 61 | "qc = QuantumCircuit(3)\n", 62 | "qc.h([0,1,2])\n", 63 | "qc.p(theta[0],0)\n", 64 | "qc.p(theta[1],1)\n", 65 | "qc.p(theta[2],2)\n", 66 | "\n", 67 | "qc.draw()" 68 | ] 69 | }, 70 | { 71 | "cell_type": "markdown", 72 | "id": "28f41daa", 73 | "metadata": { 74 | "ExecuteTime": { 75 | "end_time": "2022-05-05T12:50:30.128203Z", 76 | "start_time": "2022-05-05T12:50:30.121537Z" 77 | } 78 | }, 79 | "source": [ 80 | "Figure 1-25 - Page 43:" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": 2, 86 | "id": "ab415ef8", 87 | "metadata": { 88 | "ExecuteTime": { 89 | "end_time": "2022-05-05T13:16:30.722708Z", 90 | "start_time": "2022-05-05T13:16:29.211773Z" 91 | } 92 | }, 93 | "outputs": [ 94 | { 95 | "data": { 96 | "image/png": "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\n", 97 | "text/plain": [ 98 | "
" 99 | ] 100 | }, 101 | "execution_count": 2, 102 | "metadata": {}, 103 | "output_type": "execute_result" 104 | } 105 | ], 106 | "source": [ 107 | "import math\n", 108 | "\n", 109 | "b_qc = qc.bind_parameters({theta: [math.pi/8,\n", 110 | " math.pi/4,\n", 111 | " math.pi/2]})\n", 112 | "\n", 113 | "b_qc.draw()" 114 | ] 115 | } 116 | ], 117 | "metadata": { 118 | "kernelspec": { 119 | "display_name": "Qiskit v0.35.0 (ipykernel)", 120 | "language": "python", 121 | "name": "python3" 122 | }, 123 | "language_info": { 124 | "codemirror_mode": { 125 | "name": "ipython", 126 | "version": 3 127 | }, 128 | "file_extension": ".py", 129 | "mimetype": "text/x-python", 130 | "name": "python", 131 | "nbconvert_exporter": "python", 132 | "pygments_lexer": "ipython3", 133 | "version": "3.8.13" 134 | }, 135 | "widgets": { 136 | "application/vnd.jupyter.widget-state+json": { 137 | "state": {}, 138 | "version_major": 2, 139 | "version_minor": 0 140 | } 141 | } 142 | }, 143 | "nbformat": 4, 144 | "nbformat_minor": 5 145 | } 146 | -------------------------------------------------------------------------------- /chapter02_Running_Quantum_Circuits/chapter02-1_Using_the_BasicAer_Simulators.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "e9c34909", 6 | "metadata": {}, 7 | "source": [ 8 | "# Chapter 2: Running Quantum Circuits" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "b0482103", 14 | "metadata": { 15 | "ExecuteTime": { 16 | "end_time": "2022-05-05T13:46:50.178490Z", 17 | "start_time": "2022-05-05T13:46:50.167932Z" 18 | } 19 | }, 20 | "source": [ 21 | "## Using the BasicAer Simulators" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "id": "263543ab", 27 | "metadata": {}, 28 | "source": [ 29 | "Page 46:" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 1, 35 | "id": "065f884d", 36 | "metadata": { 37 | "ExecuteTime": { 38 | "end_time": "2022-05-05T13:16:29.175235Z", 39 | "start_time": "2022-05-05T13:16:28.556041Z" 40 | } 41 | }, 42 | "outputs": [ 43 | { 44 | "name": "stdout", 45 | "output_type": "stream", 46 | "text": [ 47 | "[, , ]\n" 48 | ] 49 | } 50 | ], 51 | "source": [ 52 | "from qiskit import BasicAer\n", 53 | "print(BasicAer.backends())" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "id": "0424f0ac", 59 | "metadata": {}, 60 | "source": [ 61 | "Page 46-47" 62 | ] 63 | }, 64 | { 65 | "cell_type": "code", 66 | "execution_count": 2, 67 | "id": "433bdbaf", 68 | "metadata": {}, 69 | "outputs": [ 70 | { 71 | "name": "stderr", 72 | "output_type": "stream", 73 | "text": [ 74 | ":219: RuntimeWarning: scipy._lib.messagestream.MessageStream size changed, may indicate binary incompatibility. Expected 56 from C header, got 64 from PyObject\n" 75 | ] 76 | }, 77 | { 78 | "name": "stdout", 79 | "output_type": "stream", 80 | "text": [ 81 | "{'11': 502, '00': 498}\n" 82 | ] 83 | } 84 | ], 85 | "source": [ 86 | "from qiskit import QuantumCircuit,BasicAer,transpile\n", 87 | "\n", 88 | "qc = QuantumCircuit(2)\n", 89 | "qc.h(0)\n", 90 | "qc.cx(0, 1)\n", 91 | "qc.measure_all()\n", 92 | "\n", 93 | "backend = BasicAer.get_backend(\"qasm_simulator\")\n", 94 | "tqc = transpile(qc, backend)\n", 95 | "job = backend.run(tqc, shots=1000)\n", 96 | "result = job.result()\n", 97 | "counts = result.get_counts(tqc)\n", 98 | "print(counts)" 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "id": "28f41daa", 104 | "metadata": {}, 105 | "source": [ 106 | "Page 48" 107 | ] 108 | }, 109 | { 110 | "cell_type": "code", 111 | "execution_count": 3, 112 | "id": "ab415ef8", 113 | "metadata": {}, 114 | "outputs": [ 115 | { 116 | "name": "stdout", 117 | "output_type": "stream", 118 | "text": [ 119 | "[0.7071+0.j 0. +0.j 0. +0.j 0.7071+0.j]\n" 120 | ] 121 | } 122 | ], 123 | "source": [ 124 | "from qiskit import QuantumCircuit,BasicAer,transpile\n", 125 | "\n", 126 | "qc = QuantumCircuit(2)\n", 127 | "qc.h(0)\n", 128 | "qc.cx(0, 1)\n", 129 | "\n", 130 | "backend = BasicAer.get_backend(\"statevector_simulator\")\n", 131 | "tqc = transpile(qc, backend)\n", 132 | "job = backend.run(tqc)\n", 133 | "result = job.result()\n", 134 | "statevector = result.get_statevector(tqc, 4)\n", 135 | "print(statevector)" 136 | ] 137 | }, 138 | { 139 | "cell_type": "markdown", 140 | "id": "458d6fc7", 141 | "metadata": {}, 142 | "source": [ 143 | "Page 49-50" 144 | ] 145 | }, 146 | { 147 | "cell_type": "code", 148 | "execution_count": 4, 149 | "id": "bc786dd4", 150 | "metadata": {}, 151 | "outputs": [ 152 | { 153 | "name": "stdout", 154 | "output_type": "stream", 155 | "text": [ 156 | "[[ 0.7071+0.j 0.7071-0.j 0. +0.j 0. +0.j]\n", 157 | " [ 0. +0.j 0. +0.j 0.7071+0.j -0.7071+0.j]\n", 158 | " [ 0. +0.j 0. +0.j 0.7071+0.j 0.7071-0.j]\n", 159 | " [ 0.7071+0.j -0.7071+0.j 0. +0.j 0. +0.j]]\n" 160 | ] 161 | } 162 | ], 163 | "source": [ 164 | "from qiskit import QuantumCircuit,BasicAer,transpile\n", 165 | "\n", 166 | "qc = QuantumCircuit(2)\n", 167 | "qc.h(0)\n", 168 | "qc.cx(0, 1)\n", 169 | "\n", 170 | "backend = BasicAer.get_backend(\"unitary_simulator\")\n", 171 | "tqc = transpile(qc, backend)\n", 172 | "job = backend.run(tqc)\n", 173 | "result = job.result()\n", 174 | "unitary = result.get_unitary(tqc, 4)\n", 175 | "print(unitary)" 176 | ] 177 | } 178 | ], 179 | "metadata": { 180 | "kernelspec": { 181 | "display_name": "Qiskit v0.35.0 (ipykernel)", 182 | "language": "python", 183 | "name": "python3" 184 | }, 185 | "language_info": { 186 | "codemirror_mode": { 187 | "name": "ipython", 188 | "version": 3 189 | }, 190 | "file_extension": ".py", 191 | "mimetype": "text/x-python", 192 | "name": "python", 193 | "nbconvert_exporter": "python", 194 | "pygments_lexer": "ipython3", 195 | "version": "3.8.13" 196 | }, 197 | "widgets": { 198 | "application/vnd.jupyter.widget-state+json": { 199 | "state": {}, 200 | "version_major": 2, 201 | "version_minor": 0 202 | } 203 | } 204 | }, 205 | "nbformat": 4, 206 | "nbformat_minor": 5 207 | } 208 | -------------------------------------------------------------------------------- /chapter02_Running_Quantum_Circuits/chapter02-2_Using_the_Aer_Simulators.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "e9c34909", 6 | "metadata": {}, 7 | "source": [ 8 | "# Chapter 2: Running Quantum Circuits" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "b0482103", 14 | "metadata": { 15 | "ExecuteTime": { 16 | "end_time": "2022-05-05T13:46:50.178490Z", 17 | "start_time": "2022-05-05T13:46:50.167932Z" 18 | } 19 | }, 20 | "source": [ 21 | "## Using the Aer Simulators" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "id": "89d712db", 27 | "metadata": {}, 28 | "source": [ 29 | "Page 51" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 1, 35 | "id": "2dc0adcd", 36 | "metadata": { 37 | "ExecuteTime": { 38 | "end_time": "2022-05-05T13:30:46.826122Z", 39 | "start_time": "2022-05-05T13:30:46.374697Z" 40 | } 41 | }, 42 | "outputs": [ 43 | { 44 | "name": "stdout", 45 | "output_type": "stream", 46 | "text": [ 47 | "[AerSimulator('aer_simulator'), AerSimulator('aer_simulator_statevector'), AerSimulator('aer_simulator_density_matrix'), AerSimulator('aer_simulator_stabilizer'), AerSimulator('aer_simulator_matrix_product_state'), AerSimulator('aer_simulator_extended_stabilizer'), AerSimulator('aer_simulator_unitary'), AerSimulator('aer_simulator_superop'), QasmSimulator('qasm_simulator'), StatevectorSimulator('statevector_simulator'), UnitarySimulator('unitary_simulator'), PulseSimulator('pulse_simulator')]\n" 48 | ] 49 | }, 50 | { 51 | "name": "stderr", 52 | "output_type": "stream", 53 | "text": [ 54 | ":219: RuntimeWarning: scipy._lib.messagestream.MessageStream size changed, may indicate binary incompatibility. Expected 56 from C header, got 64 from PyObject\n" 55 | ] 56 | } 57 | ], 58 | "source": [ 59 | "from qiskit import Aer\n", 60 | "\n", 61 | "print(Aer.backends())" 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "id": "e55e951b", 67 | "metadata": { 68 | "ExecuteTime": { 69 | "end_time": "2022-05-05T13:32:18.999640Z", 70 | "start_time": "2022-05-05T13:32:18.993693Z" 71 | } 72 | }, 73 | "source": [ 74 | "Page 52-53" 75 | ] 76 | }, 77 | { 78 | "cell_type": "code", 79 | "execution_count": 2, 80 | "id": "7453793d", 81 | "metadata": { 82 | "ExecuteTime": { 83 | "end_time": "2022-05-05T13:32:42.368407Z", 84 | "start_time": "2022-05-05T13:32:42.142646Z" 85 | } 86 | }, 87 | "outputs": [ 88 | { 89 | "name": "stdout", 90 | "output_type": "stream", 91 | "text": [ 92 | "{'00': 533, '11': 467}\n" 93 | ] 94 | } 95 | ], 96 | "source": [ 97 | "from qiskit import QuantumCircuit,Aer,transpile\n", 98 | "\n", 99 | "qc = QuantumCircuit(2)\n", 100 | "qc.h(0)\n", 101 | "qc.cx(0, 1)\n", 102 | "qc.measure_all()\n", 103 | " \n", 104 | "backend = Aer.get_backend(\"aer_simulator\")\n", 105 | "tqc = transpile(qc, backend)\n", 106 | "job = backend.run(tqc, shots=1000)\n", 107 | "result = job.result()\n", 108 | "counts = result.get_counts(tqc)\n", 109 | "print(counts)" 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "id": "6d14063c", 115 | "metadata": { 116 | "ExecuteTime": { 117 | "end_time": "2022-05-05T13:33:17.932308Z", 118 | "start_time": "2022-05-05T13:33:17.924996Z" 119 | } 120 | }, 121 | "source": [ 122 | "Page 54" 123 | ] 124 | }, 125 | { 126 | "cell_type": "code", 127 | "execution_count": 3, 128 | "id": "5723e0b3", 129 | "metadata": { 130 | "ExecuteTime": { 131 | "end_time": "2022-05-05T13:33:49.940954Z", 132 | "start_time": "2022-05-05T13:33:49.791202Z" 133 | } 134 | }, 135 | "outputs": [ 136 | { 137 | "name": "stdout", 138 | "output_type": "stream", 139 | "text": [ 140 | "Statevector([0.7071+0.j, 0. +0.j, 0. +0.j, 0.7071+0.j],\n", 141 | " dims=(2, 2))\n" 142 | ] 143 | } 144 | ], 145 | "source": [ 146 | "from qiskit import QuantumCircuit,Aer,transpile\n", 147 | "\n", 148 | "qc = QuantumCircuit(2)\n", 149 | "qc.h(0)\n", 150 | "qc.cx(0, 1)\n", 151 | "\n", 152 | "backend = Aer.get_backend(\"aer_simulator\")\n", 153 | "qc.save_statevector()\n", 154 | "tqc = transpile(qc, backend)\n", 155 | "job = backend.run(tqc)\n", 156 | "result = job.result()\n", 157 | "statevector = result.get_statevector(tqc, 4)\n", 158 | "print(statevector)\n" 159 | ] 160 | }, 161 | { 162 | "cell_type": "markdown", 163 | "id": "0976c8b8-8410-4f67-902a-8f2c7030062d", 164 | "metadata": {}, 165 | "source": [ 166 | "Page 55-56" 167 | ] 168 | }, 169 | { 170 | "cell_type": "code", 171 | "execution_count": 4, 172 | "id": "0a118695-f4c6-49f0-b390-20a90b707d89", 173 | "metadata": {}, 174 | "outputs": [ 175 | { 176 | "name": "stdout", 177 | "output_type": "stream", 178 | "text": [ 179 | "Operator([[ 0.7071+0.j, 0.7071-0.j, 0. +0.j, 0. +0.j],\n", 180 | " [ 0. +0.j, 0. +0.j, 0.7071+0.j, -0.7071+0.j],\n", 181 | " [ 0. +0.j, 0. +0.j, 0.7071+0.j, 0.7071-0.j],\n", 182 | " [ 0.7071+0.j, -0.7071+0.j, 0. +0.j, 0. +0.j]],\n", 183 | " input_dims=(2, 2), output_dims=(2, 2))\n" 184 | ] 185 | } 186 | ], 187 | "source": [ 188 | "from qiskit import QuantumCircuit,Aer,transpile\n", 189 | "\n", 190 | "qc = QuantumCircuit(2)\n", 191 | "qc.h(0)\n", 192 | "qc.cx(0, 1)\n", 193 | "\n", 194 | "backend = Aer.get_backend(\"aer_simulator\")\n", 195 | "qc.save_unitary()\n", 196 | "tqc = transpile(qc, backend)\n", 197 | "job = backend.run(tqc)\n", 198 | "result = job.result()\n", 199 | "unitary = result.get_unitary(qc, 4)\n", 200 | "print(unitary)" 201 | ] 202 | }, 203 | { 204 | "cell_type": "markdown", 205 | "id": "bc9112bd", 206 | "metadata": {}, 207 | "source": [ 208 | "Page 59-60" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 5, 214 | "id": "98e3197c", 215 | "metadata": { 216 | "ExecuteTime": { 217 | "end_time": "2022-05-05T13:37:11.362970Z", 218 | "start_time": "2022-05-05T13:37:11.176004Z" 219 | } 220 | }, 221 | "outputs": [ 222 | { 223 | "name": "stdout", 224 | "output_type": "stream", 225 | "text": [ 226 | "{'10': 2, '00': 497, '11': 501}\n" 227 | ] 228 | } 229 | ], 230 | "source": [ 231 | "from qiskit import QuantumCircuit, Aer, transpile\n", 232 | "from qiskit.providers.aer.noise import \\\n", 233 | " NoiseModel, depolarizing_error\n", 234 | "\n", 235 | "err_1 = depolarizing_error(0.95, 1)\n", 236 | "err_2 = depolarizing_error(0.01, 2)\n", 237 | "noise_model = NoiseModel()\n", 238 | "noise_model.add_all_qubit_quantum_error(err_1,\n", 239 | " ['u1', 'u2', 'u3'])\n", 240 | "noise_model.add_all_qubit_quantum_error(err_2,\n", 241 | " ['cx'])\n", 242 | "\n", 243 | "qc = QuantumCircuit(2)\n", 244 | "qc.h(0)\n", 245 | "qc.cx(0, 1)\n", 246 | "qc.measure_all()\n", 247 | "\n", 248 | "backend = Aer.get_backend(\"aer_simulator\")\n", 249 | "backend.set_options(noise_model=noise_model)\n", 250 | "tqc = transpile(qc, backend)\n", 251 | "job = backend.run(tqc, shots=1000)\n", 252 | "result = job.result()\n", 253 | "counts = result.get_counts(tqc)\n", 254 | "print(counts)" 255 | ] 256 | }, 257 | { 258 | "cell_type": "markdown", 259 | "id": "bd12d7ef-fe58-4e80-ba19-67c8b763c0f4", 260 | "metadata": {}, 261 | "source": [ 262 | "Page 60-61" 263 | ] 264 | }, 265 | { 266 | "cell_type": "code", 267 | "execution_count": 6, 268 | "id": "3361028c", 269 | "metadata": { 270 | "ExecuteTime": { 271 | "end_time": "2022-05-05T13:42:19.901933Z", 272 | "start_time": "2022-05-05T13:42:19.898449Z" 273 | } 274 | }, 275 | "outputs": [ 276 | { 277 | "name": "stdout", 278 | "output_type": "stream", 279 | "text": [ 280 | "{'01': 64, '11': 443, '10': 29, '00': 464}\n" 281 | ] 282 | } 283 | ], 284 | "source": [ 285 | "from qiskit import QuantumCircuit, transpile\n", 286 | "from qiskit.providers.aer import AerSimulator\n", 287 | "from qiskit.test.mock import FakeVigo\n", 288 | "\n", 289 | "qc = QuantumCircuit(2)\n", 290 | "qc.h(0)\n", 291 | "qc.cx(0, 1)\n", 292 | "qc.measure_all()\n", 293 | "device_backend = FakeVigo()\n", 294 | "\n", 295 | "backend = AerSimulator.from_backend(device_backend)\n", 296 | "tqc = transpile(qc, backend)\n", 297 | "job = backend.run(tqc, shots=1000)\n", 298 | "result = job.result()\n", 299 | "counts = result.get_counts(tqc)\n", 300 | "print(counts)" 301 | ] 302 | } 303 | ], 304 | "metadata": { 305 | "kernelspec": { 306 | "display_name": "Qiskit v0.35.0 (ipykernel)", 307 | "language": "python", 308 | "name": "python3" 309 | }, 310 | "language_info": { 311 | "codemirror_mode": { 312 | "name": "ipython", 313 | "version": 3 314 | }, 315 | "file_extension": ".py", 316 | "mimetype": "text/x-python", 317 | "name": "python", 318 | "nbconvert_exporter": "python", 319 | "pygments_lexer": "ipython3", 320 | "version": "3.8.13" 321 | }, 322 | "widgets": { 323 | "application/vnd.jupyter.widget-state+json": { 324 | "state": {}, 325 | "version_major": 2, 326 | "version_minor": 0 327 | } 328 | } 329 | }, 330 | "nbformat": 4, 331 | "nbformat_minor": 5 332 | } 333 | -------------------------------------------------------------------------------- /chapter03_Visualizing_Quantum_Measurements_and_States/chapter03-1_Visualizing_Measurement_Counts.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "e9c34909", 6 | "metadata": {}, 7 | "source": [ 8 | "# Chapter 3: Visualizing Quantum Measurements and States" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "b0482103", 14 | "metadata": { 15 | "ExecuteTime": { 16 | "end_time": "2022-05-05T13:46:50.178490Z", 17 | "start_time": "2022-05-05T13:46:50.167932Z" 18 | } 19 | }, 20 | "source": [ 21 | "## Visualizing Measurement Counts" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "id": "263543ab", 27 | "metadata": {}, 28 | "source": [ 29 | "Figure 3-1 - Page 66:" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 3, 35 | "id": "065f884d", 36 | "metadata": { 37 | "ExecuteTime": { 38 | "end_time": "2022-05-05T13:16:29.175235Z", 39 | "start_time": "2022-05-05T13:16:28.556041Z" 40 | } 41 | }, 42 | "outputs": [ 43 | { 44 | "data": { 45 | "image/png": "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\n", 46 | "text/plain": [ 47 | "
" 48 | ] 49 | }, 50 | "execution_count": 3, 51 | "metadata": {}, 52 | "output_type": "execute_result" 53 | } 54 | ], 55 | "source": [ 56 | "from qiskit import QuantumCircuit,Aer,transpile\n", 57 | "from qiskit.visualization import plot_histogram\n", 58 | "\n", 59 | "qc = QuantumCircuit(2)\n", 60 | "qc.h(0)\n", 61 | "qc.cx(0, 1)\n", 62 | "qc.measure_all()\n", 63 | "\n", 64 | "backend = Aer.get_backend(\"aer_simulator\")\n", 65 | "tqc = transpile(qc, backend)\n", 66 | "job = backend.run(tqc, shots=1000)\n", 67 | "result = job.result()\n", 68 | "counts = result.get_counts(tqc)\n", 69 | "\n", 70 | "plot_histogram(counts)" 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": null, 76 | "id": "5a784c31-d094-4b82-b6ed-c94d45e656a6", 77 | "metadata": {}, 78 | "outputs": [], 79 | "source": [] 80 | } 81 | ], 82 | "metadata": { 83 | "kernelspec": { 84 | "display_name": "Qiskit v0.35.0 (ipykernel)", 85 | "language": "python", 86 | "name": "python3" 87 | }, 88 | "language_info": { 89 | "codemirror_mode": { 90 | "name": "ipython", 91 | "version": 3 92 | }, 93 | "file_extension": ".py", 94 | "mimetype": "text/x-python", 95 | "name": "python", 96 | "nbconvert_exporter": "python", 97 | "pygments_lexer": "ipython3", 98 | "version": "3.8.13" 99 | }, 100 | "widgets": { 101 | "application/vnd.jupyter.widget-state+json": { 102 | "state": {}, 103 | "version_major": 2, 104 | "version_minor": 0 105 | } 106 | } 107 | }, 108 | "nbformat": 4, 109 | "nbformat_minor": 5 110 | } 111 | -------------------------------------------------------------------------------- /chapter05_Quantum_Information/chapter05-2_Using_Quantum_Information_Operators.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "e9c34909", 6 | "metadata": {}, 7 | "source": [ 8 | "# Chapter 5: Quantum Information" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "b0482103", 14 | "metadata": { 15 | "ExecuteTime": { 16 | "end_time": "2022-05-05T13:46:50.178490Z", 17 | "start_time": "2022-05-05T13:46:50.167932Z" 18 | } 19 | }, 20 | "source": [ 21 | "## Using Quantum Information Operators" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "id": "263543ab", 27 | "metadata": {}, 28 | "source": [ 29 | "Page 107-108:" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 1, 35 | "id": "065f884d", 36 | "metadata": { 37 | "ExecuteTime": { 38 | "end_time": "2022-05-05T13:16:29.175235Z", 39 | "start_time": "2022-05-05T13:16:28.556041Z" 40 | } 41 | }, 42 | "outputs": [ 43 | { 44 | "name": "stdout", 45 | "output_type": "stream", 46 | "text": [ 47 | "[[0.+0.j 0.+0.j 1.+0.j 0.+0.j]\n", 48 | " [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n", 49 | " [1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n", 50 | " [0.+0.j 1.+0.j 0.+0.j 0.+0.j]]\n" 51 | ] 52 | } 53 | ], 54 | "source": [ 55 | "from qiskit import QuantumCircuit\n", 56 | "from qiskit.quantum_info import Operator\n", 57 | " \n", 58 | "qc = QuantumCircuit(2)\n", 59 | "qc.id(0)\n", 60 | "qc.x(1)\n", 61 | "op_XI = Operator(qc)\n", 62 | "print(op_XI.data)" 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "id": "eae8856b-2034-4dd4-80fc-f8022f92a284", 68 | "metadata": {}, 69 | "source": [ 70 | "Page 108:" 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": 2, 76 | "id": "5a784c31-d094-4b82-b6ed-c94d45e656a6", 77 | "metadata": {}, 78 | "outputs": [ 79 | { 80 | "name": "stdout", 81 | "output_type": "stream", 82 | "text": [ 83 | "[[0.+0.j 0.+0.j 1.+0.j 0.+0.j]\n", 84 | " [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n", 85 | " [1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n", 86 | " [0.+0.j 1.+0.j 0.+0.j 0.+0.j]]\n" 87 | ] 88 | } 89 | ], 90 | "source": [ 91 | "from qiskit.quantum_info import Operator\n", 92 | "\n", 93 | "op_XI = Operator([[0, 0, 1, 0],\n", 94 | " [0, 0, 0, 1],\n", 95 | " [1, 0, 0, 0],\n", 96 | " [0, 1, 0, 0]])\n", 97 | "print(op_XI.data)" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "id": "1d4c9e82-9f28-4ba8-9167-a2d46bc6ba3a", 103 | "metadata": {}, 104 | "source": [ 105 | "Page 108-109:" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 3, 111 | "id": "88d0c709-b232-480c-b059-dabc151e4cdf", 112 | "metadata": {}, 113 | "outputs": [ 114 | { 115 | "name": "stdout", 116 | "output_type": "stream", 117 | "text": [ 118 | "[[0.+0.j 0.+0.j 1.+0.j 0.+0.j]\n", 119 | " [0.+0.j 0.+0.j 0.+0.j 1.+0.j]\n", 120 | " [1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n", 121 | " [0.+0.j 1.+0.j 0.+0.j 0.+0.j]]\n" 122 | ] 123 | } 124 | ], 125 | "source": [ 126 | "from qiskit.quantum_info import Operator, Pauli\n", 127 | " \n", 128 | "op_XI = Operator(Pauli('XI'))\n", 129 | "print(op_XI.data)" 130 | ] 131 | }, 132 | { 133 | "cell_type": "markdown", 134 | "id": "3359c717-bef3-4861-8bf4-be7c5c9c31b2", 135 | "metadata": {}, 136 | "source": [ 137 | "Page 109:" 138 | ] 139 | }, 140 | { 141 | "cell_type": "code", 142 | "execution_count": 4, 143 | "id": "a1df99e4-31cb-494f-ba3b-40e6ebd99562", 144 | "metadata": {}, 145 | "outputs": [ 146 | { 147 | "name": "stdout", 148 | "output_type": "stream", 149 | "text": [ 150 | "[[1. +0.j 0. +0.j 0. +0.j\n", 151 | " 0. +0.j ]\n", 152 | " [0. +0.j 1. +0.j 0. +0.j\n", 153 | " 0. +0.j ]\n", 154 | " [0. +0.j 0. +0.j 1. +0.j\n", 155 | " 0. +0.j ]\n", 156 | " [0. +0.j 0. +0.j 0. +0.j\n", 157 | " 0.70710678+0.70710678j]]\n" 158 | ] 159 | } 160 | ], 161 | "source": [ 162 | "from qiskit.quantum_info import Operator\n", 163 | "from qiskit.circuit.library.standard_gates \\\n", 164 | " import CPhaseGate\n", 165 | "import numpy as np\n", 166 | "\n", 167 | "op_CP = Operator(CPhaseGate(np.pi / 4))\n", 168 | "print(op_CP.data)" 169 | ] 170 | }, 171 | { 172 | "cell_type": "markdown", 173 | "id": "488af704-c50c-4a52-8efe-704e629a2df0", 174 | "metadata": {}, 175 | "source": [ 176 | "Page 111a:" 177 | ] 178 | }, 179 | { 180 | "cell_type": "code", 181 | "execution_count": 5, 182 | "id": "b065e3b7-a57f-4c16-a87b-5d103480f9ae", 183 | "metadata": {}, 184 | "outputs": [ 185 | { 186 | "name": "stdout", 187 | "output_type": "stream", 188 | "text": [ 189 | "[[ 0.+0.j 0.+0.j -1.+0.j 0.+0.j]\n", 190 | " [ 0.+0.j 0.+0.j 0.+0.j 1.-0.j]\n", 191 | " [-1.+0.j 0.+0.j 0.+0.j 0.+0.j]\n", 192 | " [ 0.+0.j 1.-0.j 0.+0.j 0.+0.j]]\n" 193 | ] 194 | } 195 | ], 196 | "source": [ 197 | "from qiskit.quantum_info import Pauli\n", 198 | "\n", 199 | "pauli_piXZ = Pauli('-XZ')\n", 200 | "print(pauli_piXZ.to_matrix())" 201 | ] 202 | }, 203 | { 204 | "cell_type": "markdown", 205 | "id": "fc2aa10f-9f4c-4501-b427-450db0f8b515", 206 | "metadata": {}, 207 | "source": [ 208 | "Page 111b:" 209 | ] 210 | }, 211 | { 212 | "cell_type": "code", 213 | "execution_count": 6, 214 | "id": "8a4e7818-a69c-4c9d-8961-e9d172701aa1", 215 | "metadata": {}, 216 | "outputs": [ 217 | { 218 | "name": "stdout", 219 | "output_type": "stream", 220 | "text": [ 221 | "True\n" 222 | ] 223 | } 224 | ], 225 | "source": [ 226 | "from qiskit import QuantumCircuit\n", 227 | "from qiskit.quantum_info import Pauli\n", 228 | "\n", 229 | "qc = QuantumCircuit(2)\n", 230 | "qc.z(0)\n", 231 | "qc.x(1)\n", 232 | "\n", 233 | "pauli_XZ = Pauli(qc)\n", 234 | "print(pauli_XZ.equiv(Pauli('-XZ')))" 235 | ] 236 | } 237 | ], 238 | "metadata": { 239 | "kernelspec": { 240 | "display_name": "Qiskit v0.35.0 (ipykernel)", 241 | "language": "python", 242 | "name": "python3" 243 | }, 244 | "language_info": { 245 | "codemirror_mode": { 246 | "name": "ipython", 247 | "version": 3 248 | }, 249 | "file_extension": ".py", 250 | "mimetype": "text/x-python", 251 | "name": "python", 252 | "nbconvert_exporter": "python", 253 | "pygments_lexer": "ipython3", 254 | "version": "3.8.13" 255 | }, 256 | "widgets": { 257 | "application/vnd.jupyter.widget-state+json": { 258 | "state": {}, 259 | "version_major": 2, 260 | "version_minor": 0 261 | } 262 | } 263 | }, 264 | "nbformat": 4, 265 | "nbformat_minor": 5 266 | } 267 | -------------------------------------------------------------------------------- /chapter05_Quantum_Information/chapter05-3_Using_Quantum_Information_Channels.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "e9c34909", 6 | "metadata": {}, 7 | "source": [ 8 | "# Chapter 5: Quantum Information" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "b0482103", 14 | "metadata": { 15 | "ExecuteTime": { 16 | "end_time": "2022-05-05T13:46:50.178490Z", 17 | "start_time": "2022-05-05T13:46:50.167932Z" 18 | } 19 | }, 20 | "source": [ 21 | "## Using Quantum Information Channels" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "id": "263543ab", 27 | "metadata": {}, 28 | "source": [ 29 | "Figure 5-3 - Page 113-114:" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 1, 35 | "id": "065f884d", 36 | "metadata": { 37 | "ExecuteTime": { 38 | "end_time": "2022-05-05T13:16:29.175235Z", 39 | "start_time": "2022-05-05T13:16:28.556041Z" 40 | } 41 | }, 42 | "outputs": [ 43 | { 44 | "data": { 45 | "image/png": "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\n", 46 | "text/plain": [ 47 | "
" 48 | ] 49 | }, 50 | "execution_count": 1, 51 | "metadata": {}, 52 | "output_type": "execute_result" 53 | } 54 | ], 55 | "source": [ 56 | "from qiskit import QuantumCircuit\n", 57 | "from qiskit.quantum_info import Kraus\n", 58 | "import numpy as np\n", 59 | "\n", 60 | "noise_ops = [np.sqrt(0.9) * np.array([[1, 0],\n", 61 | " [0, 1]]),\n", 62 | " np.sqrt(0.1) * np.array([[0, 1],\n", 63 | " [1, 0]])]\n", 64 | "kraus = Kraus(noise_ops)\n", 65 | "\n", 66 | "qc = QuantumCircuit(2)\n", 67 | "qc.append(kraus, [0])\n", 68 | "qc.append(kraus, [1])\n", 69 | "qc.measure_all()\n", 70 | "qc.draw()" 71 | ] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "id": "eae8856b-2034-4dd4-80fc-f8022f92a284", 76 | "metadata": {}, 77 | "source": [ 78 | "Page 114:" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": 2, 84 | "id": "5a784c31-d094-4b82-b6ed-c94d45e656a6", 85 | "metadata": {}, 86 | "outputs": [ 87 | { 88 | "name": "stderr", 89 | "output_type": "stream", 90 | "text": [ 91 | ":219: RuntimeWarning: scipy._lib.messagestream.MessageStream size changed, may indicate binary incompatibility. Expected 56 from C header, got 64 from PyObject\n" 92 | ] 93 | }, 94 | { 95 | "name": "stdout", 96 | "output_type": "stream", 97 | "text": [ 98 | "{'11': 13, '10': 77, '00': 811, '01': 99}\n" 99 | ] 100 | } 101 | ], 102 | "source": [ 103 | "from qiskit import Aer, transpile\n", 104 | "\n", 105 | "backend = Aer.get_backend(\"aer_simulator\")\n", 106 | "tqc = transpile(qc, backend)\n", 107 | "job = backend.run(tqc, shots=1000)\n", 108 | "result = job.result()\n", 109 | "counts = result.get_counts(tqc)\n", 110 | "print(counts)" 111 | ] 112 | } 113 | ], 114 | "metadata": { 115 | "kernelspec": { 116 | "display_name": "Qiskit v0.35.0 (ipykernel)", 117 | "language": "python", 118 | "name": "python3" 119 | }, 120 | "language_info": { 121 | "codemirror_mode": { 122 | "name": "ipython", 123 | "version": 3 124 | }, 125 | "file_extension": ".py", 126 | "mimetype": "text/x-python", 127 | "name": "python", 128 | "nbconvert_exporter": "python", 129 | "pygments_lexer": "ipython3", 130 | "version": "3.8.13" 131 | }, 132 | "widgets": { 133 | "application/vnd.jupyter.widget-state+json": { 134 | "state": {}, 135 | "version_major": 2, 136 | "version_minor": 0 137 | } 138 | } 139 | }, 140 | "nbformat": 4, 141 | "nbformat_minor": 5 142 | } 143 | -------------------------------------------------------------------------------- /chapter05_Quantum_Information/chapter05-4_Using_Quantum_Information_Measures.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "e9c34909", 6 | "metadata": {}, 7 | "source": [ 8 | "# Chapter 5: Quantum Information" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "b0482103", 14 | "metadata": { 15 | "ExecuteTime": { 16 | "end_time": "2022-05-05T13:46:50.178490Z", 17 | "start_time": "2022-05-05T13:46:50.167932Z" 18 | } 19 | }, 20 | "source": [ 21 | "## Using Quantum Information Measures" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "id": "263543ab", 27 | "metadata": {}, 28 | "source": [ 29 | "Page 115-116:" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 3, 35 | "id": "065f884d", 36 | "metadata": { 37 | "ExecuteTime": { 38 | "end_time": "2022-05-05T13:16:29.175235Z", 39 | "start_time": "2022-05-05T13:16:28.556041Z" 40 | } 41 | }, 42 | "outputs": [ 43 | { 44 | "name": "stdout", 45 | "output_type": "stream", 46 | "text": [ 47 | "0.8535533905932733\n" 48 | ] 49 | } 50 | ], 51 | "source": [ 52 | "from qiskit.quantum_info import Statevector\n", 53 | "from qiskit.quantum_info import Statevector, \\\n", 54 | " Operator, state_fidelity\n", 55 | "\n", 56 | "sv_a = Statevector.from_label('+')\n", 57 | "sv_b = sv_a.evolve(Operator.from_label('T'))\n", 58 | "print(state_fidelity(sv_a, sv_b))" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": null, 64 | "id": "0abb2d09-de7c-4d84-9960-169fd877a7f9", 65 | "metadata": {}, 66 | "outputs": [], 67 | "source": [] 68 | } 69 | ], 70 | "metadata": { 71 | "kernelspec": { 72 | "display_name": "Qiskit v0.35.0 (ipykernel)", 73 | "language": "python", 74 | "name": "python3" 75 | }, 76 | "language_info": { 77 | "codemirror_mode": { 78 | "name": "ipython", 79 | "version": 3 80 | }, 81 | "file_extension": ".py", 82 | "mimetype": "text/x-python", 83 | "name": "python", 84 | "nbconvert_exporter": "python", 85 | "pygments_lexer": "ipython3", 86 | "version": "3.8.13" 87 | }, 88 | "widgets": { 89 | "application/vnd.jupyter.widget-state+json": { 90 | "state": {}, 91 | "version_major": 2, 92 | "version_minor": 0 93 | } 94 | } 95 | }, 96 | "nbformat": 4, 97 | "nbformat_minor": 5 98 | } 99 | -------------------------------------------------------------------------------- /chapter06_Operator_Flow/chapter06-1_Creating_Operator_Flow_Expressions.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "e9c34909", 6 | "metadata": {}, 7 | "source": [ 8 | "# Chapter 6: Operator Flow" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "b0482103", 14 | "metadata": { 15 | "ExecuteTime": { 16 | "end_time": "2022-05-05T13:46:50.178490Z", 17 | "start_time": "2022-05-05T13:46:50.167932Z" 18 | } 19 | }, 20 | "source": [ 21 | "## Creating Operator Flow Expressions" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "id": "263543ab", 27 | "metadata": {}, 28 | "source": [ 29 | "Page 119a:" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 1, 35 | "id": "065f884d", 36 | "metadata": { 37 | "ExecuteTime": { 38 | "end_time": "2022-05-05T13:16:29.175235Z", 39 | "start_time": "2022-05-05T13:16:28.556041Z" 40 | } 41 | }, 42 | "outputs": [ 43 | { 44 | "name": "stdout", 45 | "output_type": "stream", 46 | "text": [ 47 | "DictStateFn({'10100': 1})\n" 48 | ] 49 | } 50 | ], 51 | "source": [ 52 | "from qiskit.opflow import Zero, One\n", 53 | "\n", 54 | "state = One ^ Zero ^ One ^ Zero ^ Zero\n", 55 | "print(state)" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "id": "eae8856b-2034-4dd4-80fc-f8022f92a284", 61 | "metadata": {}, 62 | "source": [ 63 | "Page 119b:" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 2, 69 | "id": "5a784c31-d094-4b82-b6ed-c94d45e656a6", 70 | "metadata": {}, 71 | "outputs": [ 72 | { 73 | "name": "stdout", 74 | "output_type": "stream", 75 | "text": [ 76 | "-1.0 * XZ\n" 77 | ] 78 | } 79 | ], 80 | "source": [ 81 | "from qiskit.opflow import X, Z\n", 82 | "\n", 83 | "pauli_piXZ = -(X ^ Z)\n", 84 | "print(pauli_piXZ)" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "id": "1d4c9e82-9f28-4ba8-9167-a2d46bc6ba3a", 90 | "metadata": {}, 91 | "source": [ 92 | "Page 119c:" 93 | ] 94 | }, 95 | { 96 | "cell_type": "code", 97 | "execution_count": 3, 98 | "id": "88d0c709-b232-480c-b059-dabc151e4cdf", 99 | "metadata": {}, 100 | "outputs": [ 101 | { 102 | "name": "stdout", 103 | "output_type": "stream", 104 | "text": [ 105 | "[[-0.+0.j -0.+0.j -1.+0.j -0.+0.j]\n", 106 | " [-0.+0.j -0.+0.j -0.+0.j 1.-0.j]\n", 107 | " [-1.+0.j -0.+0.j -0.+0.j -0.+0.j]\n", 108 | " [-0.+0.j 1.-0.j -0.+0.j -0.+0.j]]\n" 109 | ] 110 | } 111 | ], 112 | "source": [ 113 | "print(pauli_piXZ.to_matrix())" 114 | ] 115 | }, 116 | { 117 | "cell_type": "markdown", 118 | "id": "3359c717-bef3-4861-8bf4-be7c5c9c31b2", 119 | "metadata": {}, 120 | "source": [ 121 | "Page 120a:" 122 | ] 123 | }, 124 | { 125 | "cell_type": "code", 126 | "execution_count": 4, 127 | "id": "a1df99e4-31cb-494f-ba3b-40e6ebd99562", 128 | "metadata": {}, 129 | "outputs": [ 130 | { 131 | "name": "stdout", 132 | "output_type": "stream", 133 | "text": [ 134 | " ┌───┐ \n", 135 | "q_0: ┤ H ├──■───────\n", 136 | " └───┘┌─┴─┐ \n", 137 | "q_1: ─────┤ X ├──■──\n", 138 | " └───┘┌─┴─┐\n", 139 | "q_2: ──────────┤ X ├\n", 140 | " └───┘\n" 141 | ] 142 | } 143 | ], 144 | "source": [ 145 | "from qiskit.opflow import I, X, H, CX\n", 146 | "\n", 147 | "op = (CX ^ I) @ (I ^ CX) @ (I ^ I ^ H)\n", 148 | "print(op)" 149 | ] 150 | }, 151 | { 152 | "cell_type": "markdown", 153 | "id": "488af704-c50c-4a52-8efe-704e629a2df0", 154 | "metadata": {}, 155 | "source": [ 156 | "Page 120b:" 157 | ] 158 | }, 159 | { 160 | "cell_type": "code", 161 | "execution_count": 5, 162 | "id": "b065e3b7-a57f-4c16-a87b-5d103480f9ae", 163 | "metadata": {}, 164 | "outputs": [ 165 | { 166 | "name": "stdout", 167 | "output_type": "stream", 168 | "text": [ 169 | "{'000': 503, '111': 497}\n" 170 | ] 171 | } 172 | ], 173 | "source": [ 174 | "from qiskit.quantum_info import Statevector\n", 175 | "\n", 176 | "qc = op.to_circuit()\n", 177 | "sv = Statevector(qc)\n", 178 | "print(sv.sample_counts(1000))" 179 | ] 180 | } 181 | ], 182 | "metadata": { 183 | "kernelspec": { 184 | "display_name": "Qiskit v0.35.0 (ipykernel)", 185 | "language": "python", 186 | "name": "python3" 187 | }, 188 | "language_info": { 189 | "codemirror_mode": { 190 | "name": "ipython", 191 | "version": 3 192 | }, 193 | "file_extension": ".py", 194 | "mimetype": "text/x-python", 195 | "name": "python", 196 | "nbconvert_exporter": "python", 197 | "pygments_lexer": "ipython3", 198 | "version": "3.8.13" 199 | }, 200 | "widgets": { 201 | "application/vnd.jupyter.widget-state+json": { 202 | "state": {}, 203 | "version_major": 2, 204 | "version_minor": 0 205 | } 206 | } 207 | }, 208 | "nbformat": 4, 209 | "nbformat_minor": 5 210 | } 211 | -------------------------------------------------------------------------------- /chapter06_Operator_Flow/chapter06-2_Using_the_Operator_Flow_State_Function_classes.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "e9c34909", 6 | "metadata": {}, 7 | "source": [ 8 | "# Chapter 6: Operator Flow" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "b0482103", 14 | "metadata": { 15 | "ExecuteTime": { 16 | "end_time": "2022-05-05T13:46:50.178490Z", 17 | "start_time": "2022-05-05T13:46:50.167932Z" 18 | } 19 | }, 20 | "source": [ 21 | "## Using the Operator Flow State Function classes" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "id": "263543ab", 27 | "metadata": {}, 28 | "source": [ 29 | "Page 121-122:" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 1, 35 | "id": "065f884d", 36 | "metadata": { 37 | "ExecuteTime": { 38 | "end_time": "2022-05-05T13:16:29.175235Z", 39 | "start_time": "2022-05-05T13:16:28.556041Z" 40 | } 41 | }, 42 | "outputs": [ 43 | { 44 | "name": "stdout", 45 | "output_type": "stream", 46 | "text": [ 47 | "DictStateFn({'10100': 1})\n" 48 | ] 49 | } 50 | ], 51 | "source": [ 52 | "from qiskit.opflow.state_fns import StateFn\n", 53 | "\n", 54 | "statefn = StateFn('10100')\n", 55 | "print(statefn)" 56 | ] 57 | }, 58 | { 59 | "cell_type": "markdown", 60 | "id": "eae8856b-2034-4dd4-80fc-f8022f92a284", 61 | "metadata": {}, 62 | "source": [ 63 | "Page 122:" 64 | ] 65 | }, 66 | { 67 | "cell_type": "code", 68 | "execution_count": 2, 69 | "id": "5a784c31-d094-4b82-b6ed-c94d45e656a6", 70 | "metadata": {}, 71 | "outputs": [ 72 | { 73 | "name": "stdout", 74 | "output_type": "stream", 75 | "text": [ 76 | "CircuitStateFn(\n", 77 | " ┌───┐ \n", 78 | "q_0: ┤ H ├──■───────\n", 79 | " └───┘┌─┴─┐ \n", 80 | "q_1: ─────┤ X ├──■──\n", 81 | " └───┘┌─┴─┐\n", 82 | "q_2: ──────────┤ X ├\n", 83 | " └───┘\n", 84 | ")\n" 85 | ] 86 | } 87 | ], 88 | "source": [ 89 | "from qiskit import QuantumCircuit\n", 90 | "\n", 91 | "qc = QuantumCircuit(3)\n", 92 | "qc.h(0)\n", 93 | "qc.cx(0, 1)\n", 94 | "qc.cx(1, 2)\n", 95 | "\n", 96 | "statefn = StateFn(qc)\n", 97 | "print(statefn)" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "id": "1d4c9e82-9f28-4ba8-9167-a2d46bc6ba3a", 103 | "metadata": {}, 104 | "source": [ 105 | "Page 123:" 106 | ] 107 | }, 108 | { 109 | "cell_type": "code", 110 | "execution_count": 3, 111 | "id": "88d0c709-b232-480c-b059-dabc151e4cdf", 112 | "metadata": {}, 113 | "outputs": [ 114 | { 115 | "name": "stdout", 116 | "output_type": "stream", 117 | "text": [ 118 | "VectorStateFn(Statevector([0.70710678+0.j, 0. +0.j, 0. +0.j,\n", 119 | " 0.70710678+0.j],\n", 120 | " dims=(2, 2)))\n" 121 | ] 122 | } 123 | ], 124 | "source": [ 125 | "import numpy as np\n", 126 | "\n", 127 | "statefn = StateFn([1, 0, 0, 1] / np.sqrt(2))\n", 128 | "print(statefn)" 129 | ] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "id": "3359c717-bef3-4861-8bf4-be7c5c9c31b2", 134 | "metadata": {}, 135 | "source": [ 136 | "Page 123-124:" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": 4, 142 | "id": "a1df99e4-31cb-494f-ba3b-40e6ebd99562", 143 | "metadata": {}, 144 | "outputs": [ 145 | { 146 | "name": "stdout", 147 | "output_type": "stream", 148 | "text": [ 149 | "statefn_a: DictMeasurement({'100': 1}) True\n", 150 | "statefn_b: DictMeasurement({'100': 1}) True\n" 151 | ] 152 | } 153 | ], 154 | "source": [ 155 | "from qiskit.opflow.state_fns import StateFn\n", 156 | "from qiskit.opflow import One, Zero\n", 157 | " \n", 158 | "statefn_a = StateFn('100', is_measurement=True)\n", 159 | "print('statefn_a:', statefn_a, statefn_a.is_measurement)\n", 160 | "\n", 161 | "statefn_b = ~(One ^ Zero ^ Zero)\n", 162 | "print('statefn_b:', statefn_b, statefn_b.is_measurement)" 163 | ] 164 | } 165 | ], 166 | "metadata": { 167 | "kernelspec": { 168 | "display_name": "Qiskit v0.35.0 (ipykernel)", 169 | "language": "python", 170 | "name": "python3" 171 | }, 172 | "language_info": { 173 | "codemirror_mode": { 174 | "name": "ipython", 175 | "version": 3 176 | }, 177 | "file_extension": ".py", 178 | "mimetype": "text/x-python", 179 | "name": "python", 180 | "nbconvert_exporter": "python", 181 | "pygments_lexer": "ipython3", 182 | "version": "3.8.13" 183 | }, 184 | "widgets": { 185 | "application/vnd.jupyter.widget-state+json": { 186 | "state": {}, 187 | "version_major": 2, 188 | "version_minor": 0 189 | } 190 | } 191 | }, 192 | "nbformat": 4, 193 | "nbformat_minor": 5 194 | } 195 | -------------------------------------------------------------------------------- /chapter06_Operator_Flow/chapter06-3_Using_the_Operator_Flow_Primitive_Operators_classes.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "id": "e9c34909", 6 | "metadata": {}, 7 | "source": [ 8 | "# Chapter 6: Operator Flow" 9 | ] 10 | }, 11 | { 12 | "cell_type": "markdown", 13 | "id": "b0482103", 14 | "metadata": { 15 | "ExecuteTime": { 16 | "end_time": "2022-05-05T13:46:50.178490Z", 17 | "start_time": "2022-05-05T13:46:50.167932Z" 18 | } 19 | }, 20 | "source": [ 21 | "## Using the Operator Flow Primitive Operators classes" 22 | ] 23 | }, 24 | { 25 | "cell_type": "markdown", 26 | "id": "263543ab", 27 | "metadata": {}, 28 | "source": [ 29 | "Page 126:" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 1, 35 | "id": "065f884d", 36 | "metadata": { 37 | "ExecuteTime": { 38 | "end_time": "2022-05-05T13:16:29.175235Z", 39 | "start_time": "2022-05-05T13:16:28.556041Z" 40 | } 41 | }, 42 | "outputs": [ 43 | { 44 | "name": "stdout", 45 | "output_type": "stream", 46 | "text": [ 47 | "-XZ\n", 48 | "\n" 49 | ] 50 | } 51 | ], 52 | "source": [ 53 | "from qiskit.opflow.primitive_ops import PrimitiveOp\n", 54 | "from qiskit.quantum_info import Pauli\n", 55 | "\n", 56 | "primop_piXZ = PrimitiveOp(Pauli('-XZ'))\n", 57 | "print(primop_piXZ)\n", 58 | "print(type(primop_piXZ))" 59 | ] 60 | }, 61 | { 62 | "cell_type": "markdown", 63 | "id": "eae8856b-2034-4dd4-80fc-f8022f92a284", 64 | "metadata": {}, 65 | "source": [ 66 | "Page 127a:" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 2, 72 | "id": "5a784c31-d094-4b82-b6ed-c94d45e656a6", 73 | "metadata": {}, 74 | "outputs": [ 75 | { 76 | "name": "stdout", 77 | "output_type": "stream", 78 | "text": [ 79 | "\n", 80 | "True\n" 81 | ] 82 | } 83 | ], 84 | "source": [ 85 | "from qiskit.opflow import X, Z\n", 86 | "\n", 87 | "pauli_piXZ = -(X ^ Z)\n", 88 | "print(type(pauli_piXZ))\n", 89 | "print(primop_piXZ.primitive\n", 90 | " .equiv(pauli_piXZ.primitive))\n" 91 | ] 92 | }, 93 | { 94 | "cell_type": "markdown", 95 | "id": "1d4c9e82-9f28-4ba8-9167-a2d46bc6ba3a", 96 | "metadata": {}, 97 | "source": [ 98 | "Page 127b:" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": 3, 104 | "id": "88d0c709-b232-480c-b059-dabc151e4cdf", 105 | "metadata": {}, 106 | "outputs": [ 107 | { 108 | "name": "stdout", 109 | "output_type": "stream", 110 | "text": [ 111 | " ┌───┐\n", 112 | "q_0: ┤ H ├\n", 113 | " ├───┤\n", 114 | "q_1: ┤ H ├\n", 115 | " ├───┤\n", 116 | "q_2: ┤ H ├\n", 117 | " └───┘\n", 118 | "\n" 119 | ] 120 | } 121 | ], 122 | "source": [ 123 | "from qiskit import QuantumCircuit\n", 124 | "\n", 125 | "qc = QuantumCircuit(3)\n", 126 | "qc.h([0,1,2])\n", 127 | "\n", 128 | "h_primop = PrimitiveOp(qc)\n", 129 | "print(h_primop)\n", 130 | "print(type(h_primop))" 131 | ] 132 | }, 133 | { 134 | "cell_type": "markdown", 135 | "id": "3359c717-bef3-4861-8bf4-be7c5c9c31b2", 136 | "metadata": {}, 137 | "source": [ 138 | "Page 128:" 139 | ] 140 | }, 141 | { 142 | "cell_type": "code", 143 | "execution_count": 4, 144 | "id": "a1df99e4-31cb-494f-ba3b-40e6ebd99562", 145 | "metadata": {}, 146 | "outputs": [ 147 | { 148 | "name": "stdout", 149 | "output_type": "stream", 150 | "text": [ 151 | " ┌───┐\n", 152 | "q_0: ┤ H ├\n", 153 | " ├───┤\n", 154 | "q_1: ┤ H ├\n", 155 | " ├───┤\n", 156 | "q_2: ┤ H ├\n", 157 | " └───┘\n", 158 | "\n" 159 | ] 160 | } 161 | ], 162 | "source": [ 163 | "from qiskit.opflow import H\n", 164 | "\n", 165 | "hgates = H^3\n", 166 | "print(hgates)\n", 167 | "print(type(hgates))" 168 | ] 169 | } 170 | ], 171 | "metadata": { 172 | "kernelspec": { 173 | "display_name": "Qiskit v0.35.0 (ipykernel)", 174 | "language": "python", 175 | "name": "python3" 176 | }, 177 | "language_info": { 178 | "codemirror_mode": { 179 | "name": "ipython", 180 | "version": 3 181 | }, 182 | "file_extension": ".py", 183 | "mimetype": "text/x-python", 184 | "name": "python", 185 | "nbconvert_exporter": "python", 186 | "pygments_lexer": "ipython3", 187 | "version": "3.8.13" 188 | }, 189 | "widgets": { 190 | "application/vnd.jupyter.widget-state+json": { 191 | "state": {}, 192 | "version_major": 2, 193 | "version_minor": 0 194 | } 195 | } 196 | }, 197 | "nbformat": 4, 198 | "nbformat_minor": 5 199 | } 200 | -------------------------------------------------------------------------------- /logo.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/qiskit-community/qiskit-pocket-guide/5326b2064cbb8ec226c97d5e1d80659579a67ab3/logo.png -------------------------------------------------------------------------------- /requirements.txt: -------------------------------------------------------------------------------- 1 | qiskit-terra~=0.20 2 | matplotlib~=3.5.2 3 | pylatexenc~=1.4 4 | --------------------------------------------------------------------------------