{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Hampy Tutorial\n", "\n", "This tutorial goes through most of hampy features with examples of how to use it." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from pprint import pprint\n", "try:\n", " from quantum_launcher.hampy import Variable, Equation\n", " from quantum_launcher import hampy\n", "except:\n", " import sys, os\n", " parent_dir = os.path.abspath(os.path.join(os.getcwd(), os.pardir))\n", " sys.path.insert(0, parent_dir)\n", "\n", " from quantum_launcher.hampy import Variable, Equation\n", " from quantum_launcher import hampy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Main components:\n", "\n", "- Equation: Wrapper to SparsePauliOp that adds few functionalities for boolean operations\n", " - Operations:\n", " - And\n", " - Or\n", " - Xor\n", " - Negation\n", " - Other functions:\n", " - hamiltonian - stores the SparsePauliOp instance\n", " - get_variable(index) - returns the variable under given index\n", " - is_quadratic() - verifies if hamiltonian is of up to quadratic order\n", " - get_order() - returns the order of hamiltonian\n", "- Variable: Pointer for specific variable\n", "\n", "`Note:` Variable(0, eq) == eq.get_variable(0) == eq[0]" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hamiltonian order: 4\n", "And so Hamiltonian is not quadratic: False\n", "[Pauli('IIII'),\n", " Pauli('IZII'),\n", " Pauli('IIIZ'),\n", " Pauli('IZIZ'),\n", " Pauli('IIZI'),\n", " Pauli('ZIII'),\n", " Pauli('ZIZI'),\n", " Pauli('IZZI'),\n", " Pauli('ZZII'),\n", " Pauli('ZZZI'),\n", " Pauli('IIZZ'),\n", " Pauli('ZIIZ'),\n", " Pauli('ZIZZ'),\n", " Pauli('IZZZ'),\n", " Pauli('ZZIZ'),\n", " Pauli('ZZZZ')]\n" ] } ], "source": [ "eq = Equation(4)\n", "var0 = eq.get_variable(0)\n", "var2 = Variable(2, eq)\n", "part_0 = var0 & ~var2\n", "part_1 = eq[1] & eq[3]\n", "eq = part_0 | part_1\n", "print(f'Hamiltonian order: {eq.get_order()}')\n", "print(f'And so Hamiltonian is not quadratic: {eq.is_quadratic()}')\n", "pprint(list(eq.hamiltonian.paulis))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Hampy also support some of often used equations in the equations modules such as one_in_n returning True if there is exactly one variable that is true in given list." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "SparsePauliOp(['IIIIII', 'ZIIIII', 'IIIZII', 'ZIIZII', 'IIZIII', 'ZIZIII', 'IIZZII', 'IZIIII', 'ZZIIII', 'IZIZII', 'ZIZIZZ', 'IIZZZZ', 'ZIZZZZ', 'ZZIIZZ', 'IZIZZZ', 'ZZIZZZ', 'IZZIZZ', 'ZZZIZZ', 'IZZZZZ', 'ZZZZZZ', 'IIIIZI', 'ZIIIZI', 'IIIZZI', 'IIIIIZ', 'ZIIIIZ', 'IIIZIZ', 'ZZZIZI', 'IZZZZI', 'ZZZZZI', 'ZZZIIZ', 'IZZZIZ', 'ZZZZIZ', 'IZZIII', 'IIZIZI', 'IZIIZI', 'IIZIIZ', 'IZIIIZ', 'IIIIZZ', 'ZZZZII', 'ZIZZZI', 'ZZIZZI', 'ZIZZIZ', 'ZZIZIZ', 'ZIIZZZ'],\n", " coeffs=[ 0.09375+0.j, 0.0625 +0.j, 0.0625 +0.j, 0.03125+0.j, 0.0625 +0.j,\n", " 0.03125+0.j, 0.03125+0.j, 0.0625 +0.j, 0.03125+0.j, 0.03125+0.j,\n", " -0.03125+0.j, -0.03125+0.j, -0.0625 +0.j, -0.03125+0.j, -0.03125+0.j,\n", " -0.0625 +0.j, -0.03125+0.j, -0.0625 +0.j, -0.0625 +0.j, -0.09375+0.j,\n", " 0.0625 +0.j, 0.03125+0.j, 0.03125+0.j, 0.0625 +0.j, 0.03125+0.j,\n", " 0.03125+0.j, -0.03125+0.j, -0.03125+0.j, -0.0625 +0.j, -0.03125+0.j,\n", " -0.03125+0.j, -0.0625 +0.j, 0.03125+0.j, 0.03125+0.j, 0.03125+0.j,\n", " 0.03125+0.j, 0.03125+0.j, 0.03125+0.j, -0.03125+0.j, -0.03125+0.j,\n", " -0.03125+0.j, -0.03125+0.j, -0.03125+0.j, -0.03125+0.j])\n" ] } ], "source": [ "one_in_n = hampy.equations.one_in_n([0, 1, 2, 3, 4, 5], size=6)\n", "print(one_in_n.hamiltonian)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Hampy also offers tools for debugging and verifying correctness of your hamiltonians.\n", "\n", "Main component of debug module is TruthTable storing all information about values of hamiltonians truth table, because of that is strongly limited to around hamiltonians of size around 20, and we do not recommend trying to use it on larger hamiltonians, as complexity growths exponentially." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Hamiltonians energies are in binary values?: True\n", "Value of '000100' is 1\n", "Value of 0 is 0\n", "Hamiltonian has 6 valid solutions:\n", "['100000', '010000', '001000', '000100', '000010', '000001']\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "truth = hampy.debug.TruthTable(one_in_n)\n", "print(f'Hamiltonians energies are in binary values?: {truth.check_if_binary()}')\n", "print(f\"Value of '000100' is {truth['000100']}\")\n", "print(f'Value of 0 is {truth[0]}')\n", "print(f'Hamiltonian has {truth.count(True)} valid solutions:')\n", "pprint(truth.get_solutions(True))\n", "truth.plot_distribution()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Utility functions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`shift_affected_qubits()` \n", "Changes the qubits affected by a given equation." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Constraint has 2 valid solutions:\n", "['1000', '0010']\n" ] } ], "source": [ "constraint = hampy.one_in_n([0,2],4)\n", "constraint &= (~constraint[1] & ~constraint[3]) #Restrict other qubits to 0\n", "\n", "truth = hampy.debug.TruthTable(constraint)\n", "print(f'Constraint has {truth.count(True)} valid solutions:')\n", "pprint(truth.get_solutions(True))" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Constraint has 2 valid solutions:\n", "['0100', '0001']\n" ] } ], "source": [ "shifted = hampy.shift_affected_qubits(constraint, 1)\n", "\n", "truth = hampy.debug.TruthTable(shifted)\n", "print(f'Constraint has {truth.count(True)} valid solutions:')\n", "pprint(truth.get_solutions(True))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The one_in_n constraint was shifted from qubits [0,2] to qubits [1,3]" ] } ], "metadata": { "kernelspec": { "display_name": "quantum", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.11" } }, "nbformat": 4, "nbformat_minor": 2 }