diff --git a/examples/qaoa_maxcut_example.ipynb b/examples/qaoa_maxcut_example.ipynb index c48f2901a..fb8261e21 100644 --- a/examples/qaoa_maxcut_example.ipynb +++ b/examples/qaoa_maxcut_example.ipynb @@ -32,16 +32,16 @@ "id": "529cadb6", "metadata": { "execution": { - "iopub.execute_input": "2026-06-06T15:41:18.627747Z", - "iopub.status.busy": "2026-06-06T15:41:18.626748Z", - "iopub.status.idle": "2026-06-06T15:41:19.566192Z", - "shell.execute_reply": "2026-06-06T15:41:19.565190Z" + "iopub.execute_input": "2026-06-19T16:04:43.701294Z", + "iopub.status.busy": "2026-06-19T16:04:43.701083Z", + "iopub.status.idle": "2026-06-19T16:04:44.186491Z", + "shell.execute_reply": "2026-06-19T16:04:44.186089Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -174,16 +174,16 @@ "id": "d3ac9b6c", "metadata": { "execution": { - "iopub.execute_input": "2026-06-06T15:41:19.569191Z", - "iopub.status.busy": "2026-06-06T15:41:19.568189Z", - "iopub.status.idle": "2026-06-06T15:41:19.612774Z", - "shell.execute_reply": "2026-06-06T15:41:19.611773Z" + "iopub.execute_input": "2026-06-19T16:04:44.187828Z", + "iopub.status.busy": "2026-06-19T16:04:44.187718Z", + "iopub.status.idle": "2026-06-19T16:04:44.198114Z", + "shell.execute_reply": "2026-06-19T16:04:44.197653Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -264,9 +264,9 @@ "id": "be5b779b", "metadata": {}, "source": [ - "We will define a Python function which will construct a Guppy program implementing QAOA for an $n$ node graph. First we create the the uniform superposition state $|+\\rangle^{\\otimes n}$ and then alternate cost and mixer layers as described above.\n", + "We will define a Python function which will construct a Guppy program implementing QAOA for an $n$ node graph. First we create the uniform superposition state $|+\\rangle^{\\otimes n}$ and then alternate cost and mixer layers as described above.\n", "\n", - "We can load Python lists containing the cost and mixer angles into the Guppy program using comptime expressions. Note that the Guppy program `qaoa_instance` takes two [frozenarray](https://docs.quantinuum.com/guppy/api/generated/guppylang.std.builtins.frozenarray.html) arguments where the size of each array is $p$. These mutable Python lists are converted to frozen arrays by Guppy. For more on Guppy comptime, see the corresponding [section of the language guide](https://docs.quantinuum.com/guppy/language_guide/comptime.html)." + "The graph topology and the number of layers $p$ are fixed at compile time (loaded with [comptime](https://docs.quantinuum.com/guppy/language_guide/comptime.html) expressions), but the cost and mixer angles are passed as **runtime arguments**: `qaoa_instance` takes two [array](https://docs.quantinuum.com/guppy/api/generated/guppylang.std.builtins.array.html)`[float, p]` arguments. Because the angles are runtime arguments, the program can be compiled once and then re-run with different angle values — exactly what the variational optimization loop below needs." ] }, { @@ -275,10 +275,10 @@ "id": "e774a69f", "metadata": { "execution": { - "iopub.execute_input": "2026-06-06T15:41:19.614779Z", - "iopub.status.busy": "2026-06-06T15:41:19.613778Z", - "iopub.status.idle": "2026-06-06T15:41:21.108991Z", - "shell.execute_reply": "2026-06-06T15:41:21.107992Z" + "iopub.execute_input": "2026-06-19T16:04:44.199391Z", + "iopub.status.busy": "2026-06-19T16:04:44.199317Z", + "iopub.status.idle": "2026-06-19T16:04:45.022816Z", + "shell.execute_reply": "2026-06-19T16:04:45.022436Z" } }, "outputs": [], @@ -286,7 +286,7 @@ "from guppylang import guppy\n", "from guppylang.std.quantum import qubit, h, rx\n", "from guppylang.std.qsystem.helios import zz_phase\n", - "from guppylang.std.builtins import array, comptime, frozenarray\n", + "from guppylang.std.builtins import array, comptime\n", "from guppylang.std.angles import pi\n", "from guppylang.defs import GuppyFunctionDefinition\n", "\n", @@ -297,8 +297,8 @@ "\n", " @guppy\n", " def qaoa_instance(\n", - " cost_angles: frozenarray[float, comptime(n_layers)],\n", - " mixer_angles: frozenarray[float, comptime(n_layers)],\n", + " cost_angles: array[float, comptime(n_layers)],\n", + " mixer_angles: array[float, comptime(n_layers)],\n", " ) -> array[qubit, comptime(n_qubits)]:\n", " qs = array(qubit() for _ in range(comptime(n_qubits)))\n", " n = len(qs)\n", @@ -343,10 +343,10 @@ "id": "4683c89c", "metadata": { "execution": { - "iopub.execute_input": "2026-06-06T15:41:21.111499Z", - "iopub.status.busy": "2026-06-06T15:41:21.110992Z", - "iopub.status.idle": "2026-06-06T15:41:21.125171Z", - "shell.execute_reply": "2026-06-06T15:41:21.124171Z" + "iopub.execute_input": "2026-06-19T16:04:45.024253Z", + "iopub.status.busy": "2026-06-19T16:04:45.024180Z", + "iopub.status.idle": "2026-06-19T16:04:45.026254Z", + "shell.execute_reply": "2026-06-19T16:04:45.025896Z" } }, "outputs": [], @@ -370,11 +370,11 @@ "id": "852d6d0e", "metadata": {}, "source": [ - "Now let's define two helpers for executing and scoring QAOA parameter values. The `run_qaoa_circuit` function executes the Guppy program for a specific set of cost and mixer coefficients and returns the final `QsysResult`. The `eval_qaoa_energy` function turns that result into the scalar energy needed by the classical optimizer.\n", + "Now let's define helpers for executing and scoring QAOA parameter values.\n", "\n", - "The `run_qaoa_circuit` function defines a Guppy `main` function which serves as the entrypoint for program execution. The program is then executed for a given number of shots. The `p_value` argument defines the number of cost/mixer layers in the QAOA program.\n", + "Because the cost and mixer angles are runtime arguments, we compile the program **once** and re-run it for every parameter set. `build_qaoa_program` defines a `main` entrypoint that takes the angles as arguments and returns a built `EmulatorInstance`. `run_qaoa_circuit` executes that instance for specific angle values by passing them to `.run(...)`, and `eval_qaoa_energy` turns the result into the scalar energy needed by the classical optimizer.\n", "\n", - "NOTE: Currently it is not possible to pass arguments to an execution entrypoint in Guppy. Therefore we create a fresh `main` function for every set of parameters.\n" + "The `p_value` argument defines the number of cost/mixer layers in the QAOA program." ] }, { @@ -383,65 +383,68 @@ "id": "f2eb559e", "metadata": { "execution": { - "iopub.execute_input": "2026-06-06T15:41:21.127175Z", - "iopub.status.busy": "2026-06-06T15:41:21.127175Z", - "iopub.status.idle": "2026-06-06T15:41:21.139506Z", - "shell.execute_reply": "2026-06-06T15:41:21.139506Z" + "iopub.execute_input": "2026-06-19T16:04:45.027252Z", + "iopub.status.busy": "2026-06-19T16:04:45.027182Z", + "iopub.status.idle": "2026-06-19T16:04:45.030709Z", + "shell.execute_reply": "2026-06-19T16:04:45.030107Z" } }, "outputs": [], "source": [ "import numpy as np\n", - "from guppylang.std.quantum import measure_array\n", + "from guppylang.std.quantum import measure_array, collect_measurements\n", "from guppylang.std.builtins import output\n", + "from guppylang.emulator import EmulatorInstance\n", "from numpy.typing import NDArray\n", "\n", "\n", - "def run_qaoa_circuit(\n", - " cost_angles: NDArray[np.float64],\n", - " mixer_angles: NDArray[np.float64],\n", + "def build_qaoa_program(\n", " graph: nx.Graph,\n", " p_value: int,\n", " seed: int,\n", " shots: int,\n", - ") -> QsysResult:\n", + ") -> EmulatorInstance:\n", " qaoa_instance: GuppyFunctionDefinition = build_qaoa_instance(\n", " graph=graph,\n", " n_layers=p_value,\n", " )\n", "\n", " @guppy\n", - " def main() -> None:\n", - " qaoa_qubits = qaoa_instance(\n", - " comptime(list(cost_angles)), comptime(list(mixer_angles))\n", - " )\n", - " output(\"c\", measure_array(qaoa_qubits))\n", - "\n", + " def main(\n", + " cost_angles: array[float, comptime(p_value)],\n", + " mixer_angles: array[float, comptime(p_value)],\n", + " ) -> None:\n", + " qaoa_qubits = qaoa_instance(cost_angles, mixer_angles)\n", + " output(\"c\", collect_measurements(measure_array(qaoa_qubits)))\n", + "\n", + " # Compiled and built once; reused for every parameter set via `.run(...)`.\n", " return (\n", " main.emulator(n_qubits=graph.number_of_nodes())\n", " .with_shots(shots)\n", " .with_seed(seed)\n", - " .run()\n", + " )\n", + "\n", + "\n", + "def run_qaoa_circuit(\n", + " program: EmulatorInstance,\n", + " cost_angles: NDArray[np.float64],\n", + " mixer_angles: NDArray[np.float64],\n", + ") -> QsysResult:\n", + " return program.run(\n", + " cost_angles=[float(x) for x in cost_angles],\n", + " mixer_angles=[float(x) for x in mixer_angles],\n", " )\n", "\n", "\n", "def eval_qaoa_energy(\n", + " program: EmulatorInstance,\n", " cost_angles: NDArray[np.float64],\n", " mixer_angles: NDArray[np.float64],\n", " graph: nx.Graph,\n", - " p_value: int,\n", - " seed: int,\n", " shots: int,\n", ") -> float:\n", - " qaoa_result = run_qaoa_circuit(\n", - " cost_angles=cost_angles,\n", - " mixer_angles=mixer_angles,\n", - " graph=graph,\n", - " p_value=p_value,\n", - " seed=seed,\n", - " shots=shots,\n", - " )\n", - " return energy_from_result(graph, qaoa_result, shots)\n" + " qaoa_result = run_qaoa_circuit(program, cost_angles, mixer_angles)\n", + " return energy_from_result(graph, qaoa_result, shots)" ] }, { @@ -480,10 +483,10 @@ "id": "def010e3", "metadata": { "execution": { - "iopub.execute_input": "2026-06-06T15:41:21.142016Z", - "iopub.status.busy": "2026-06-06T15:41:21.142016Z", - "iopub.status.idle": "2026-06-06T15:41:21.544085Z", - "shell.execute_reply": "2026-06-06T15:41:21.543085Z" + "iopub.execute_input": "2026-06-19T16:04:45.031897Z", + "iopub.status.busy": "2026-06-19T16:04:45.031822Z", + "iopub.status.idle": "2026-06-19T16:04:45.435051Z", + "shell.execute_reply": "2026-06-19T16:04:45.434637Z" } }, "outputs": [], @@ -516,15 +519,20 @@ " mixer_angles=rng.uniform(0, 2 * np.pi, size=p_value),\n", " )\n", "\n", + " # Compile and build the program once, then reuse it for every objective\n", + " # evaluation by supplying the angles as runtime arguments.\n", + " program = build_qaoa_program(\n", + " graph=graph, p_value=p_value, seed=seed, shots=n_shots\n", + " )\n", + "\n", " def objective(params: NDArray[np.float64]) -> float:\n", " cost_angles, mixer_angles = split_qaoa_params(params, p_value)\n", " qaoa_energy = eval_qaoa_energy(\n", + " program=program,\n", " cost_angles=cost_angles,\n", " mixer_angles=mixer_angles,\n", - " seed=seed,\n", - " shots=n_shots,\n", " graph=graph,\n", - " p_value=p_value,\n", + " shots=n_shots,\n", " )\n", " return -qaoa_energy\n", "\n", @@ -538,16 +546,9 @@ " best_cost_angles, best_mixer_angles = split_qaoa_params(\n", " optimizer_result.x, p_value\n", " )\n", - " best_result = run_qaoa_circuit(\n", - " cost_angles=best_cost_angles,\n", - " mixer_angles=best_mixer_angles,\n", - " seed=seed,\n", - " shots=n_shots,\n", - " graph=graph,\n", - " p_value=p_value,\n", - " )\n", + " best_result = run_qaoa_circuit(program, best_cost_angles, best_mixer_angles)\n", "\n", - " return best_result, best_cost_angles, best_mixer_angles, optimizer_result\n" + " return best_result, best_cost_angles, best_mixer_angles, optimizer_result" ] }, { @@ -568,16 +569,16 @@ "id": "90bf1a83", "metadata": { "execution": { - "iopub.execute_input": "2026-06-06T15:41:21.546085Z", - "iopub.status.busy": "2026-06-06T15:41:21.546085Z", - "iopub.status.idle": "2026-06-06T15:41:21.604831Z", - "shell.execute_reply": "2026-06-06T15:41:21.603966Z" + "iopub.execute_input": "2026-06-19T16:04:45.436396Z", + "iopub.status.busy": "2026-06-19T16:04:45.436270Z", + "iopub.status.idle": "2026-06-19T16:04:45.458562Z", + "shell.execute_reply": "2026-06-19T16:04:45.458120Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -628,10 +629,10 @@ "id": "ff3572ee", "metadata": { "execution": { - "iopub.execute_input": "2026-06-06T15:41:21.606828Z", - "iopub.status.busy": "2026-06-06T15:41:21.606828Z", - "iopub.status.idle": "2026-06-06T15:41:21.619397Z", - "shell.execute_reply": "2026-06-06T15:41:21.619397Z" + "iopub.execute_input": "2026-06-19T16:04:45.459713Z", + "iopub.status.busy": "2026-06-19T16:04:45.459640Z", + "iopub.status.idle": "2026-06-19T16:04:45.461500Z", + "shell.execute_reply": "2026-06-19T16:04:45.461064Z" } }, "outputs": [], @@ -702,21 +703,26 @@ "id": "9b4dac68", "metadata": { "execution": { - "iopub.execute_input": "2026-06-06T15:41:21.621908Z", - "iopub.status.busy": "2026-06-06T15:41:21.621908Z", - "iopub.status.idle": "2026-06-06T15:44:51.340055Z", - "shell.execute_reply": "2026-06-06T15:44:51.339510Z" + "iopub.execute_input": "2026-06-19T16:04:45.462987Z", + "iopub.status.busy": "2026-06-19T16:04:45.462907Z", + "iopub.status.idle": "2026-06-19T16:05:00.919687Z", + "shell.execute_reply": "2026-06-19T16:05:00.919146Z" } }, "outputs": [ { - "output_type": "stream", "name": "stdout", - "text": "Optimizer status: Return from COBYLA because the trust region radius reaches its lower bound.\nObjective evaluations: 66\nOptimized energy: 5.1195\nCost angles: [1.743 2.62 4.764]\nMixer angles: [4.84 2.363 2.19 ]\nCPU times: total: 1min 28s\nWall time: 3min 23s\n" + "output_type": "stream", + "text": [ + "Optimizer status: Return from COBYLA because the trust region radius reaches its lower bound.\n", + "Objective evaluations: 76\n", + "Optimized energy: 5.0995\n", + "Cost angles: [1.736 2.63 4.751]\n", + "Mixer angles: [4.831 2.361 2.2 ]\n" + ] } ], "source": [ - "%%time\n", "n_shots = 2000\n", "p_value = 3\n", "random_seed = 12345\n", @@ -743,11 +749,9 @@ "id": "7666389a", "metadata": {}, "source": [ - "**Note, there are some performance limitations of the QAOA implementation shown here. The main bottleneck is that the `main` function in `eval_qaoa_energy` has to be recompiled for each parameter evaluation in the classical optimization loop. In the future, it may be possible to have a `main` function entrypoint which takes arguments. This would mean that the function can be compiled once and then re-computed for different parameter values**.\n", - "\n", "**Optimizer status note.** COBYLA is a derivative-free trust-region optimizer. If it reports that the trust-region radius reached its lower bound, that is a normal termination condition: the local search radius has shrunk to the configured tolerance. If it reports that the maximum number of function evaluations was exceeded, the configured `maxiter` budget was exhausted.\n", "\n", - "The optimizer objective above maximizes the expected max-cut energy. This is related to, but not identical to, maximizing the probability of sampling one of the two exact optimal colorings.\n" + "The optimizer objective above maximizes the expected max-cut energy. This is related to, but not identical to, maximizing the probability of sampling one of the two exact optimal colorings." ] }, { @@ -764,10 +768,10 @@ "id": "b9d8299e", "metadata": { "execution": { - "iopub.execute_input": "2026-06-06T15:44:51.342607Z", - "iopub.status.busy": "2026-06-06T15:44:51.342607Z", - "iopub.status.idle": "2026-06-06T15:44:51.355923Z", - "shell.execute_reply": "2026-06-06T15:44:51.355923Z" + "iopub.execute_input": "2026-06-19T16:05:00.921684Z", + "iopub.status.busy": "2026-06-19T16:05:00.921577Z", + "iopub.status.idle": "2026-06-19T16:05:00.924178Z", + "shell.execute_reply": "2026-06-19T16:05:00.923879Z" } }, "outputs": [], @@ -795,20 +799,22 @@ "id": "0bc07733", "metadata": { "execution": { - "iopub.execute_input": "2026-06-06T15:44:51.359060Z", - "iopub.status.busy": "2026-06-06T15:44:51.357512Z", - "iopub.status.idle": "2026-06-06T15:44:51.385766Z", - "shell.execute_reply": "2026-06-06T15:44:51.385766Z" + "iopub.execute_input": "2026-06-19T16:05:00.925297Z", + "iopub.status.busy": "2026-06-19T16:05:00.925229Z", + "iopub.status.idle": "2026-06-19T16:05:00.931454Z", + "shell.execute_reply": "2026-06-19T16:05:00.931069Z" } }, "outputs": [ { - "output_type": "execute_result", - "metadata": {}, "data": { - "text/plain": "'Success ratio: 0.3950'" + "text/plain": [ + "'Success ratio: 0.4015'" + ] }, - "execution_count": 11 + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -832,17 +838,27 @@ "id": "de10918b", "metadata": { "execution": { - "iopub.execute_input": "2026-06-06T15:44:51.388884Z", - "iopub.status.busy": "2026-06-06T15:44:51.388884Z", - "iopub.status.idle": "2026-06-06T15:44:51.415712Z", - "shell.execute_reply": "2026-06-06T15:44:51.415712Z" + "iopub.execute_input": "2026-06-19T16:05:00.932600Z", + "iopub.status.busy": "2026-06-19T16:05:00.932516Z", + "iopub.status.idle": "2026-06-19T16:05:00.939604Z", + "shell.execute_reply": "2026-06-19T16:05:00.939227Z" } }, "outputs": [ { - "output_type": "stream", "name": "stdout", - "text": "Expected energy from sampled distribution: 5.1195\nProbability of optimal colorings: 0.3950\nProbability by cut value:\n cut=0: 0.0005\n cut=1: 0.0005\n cut=2: 0.0155\n cut=3: 0.0385\n cut=4: 0.1475\n cut=5: 0.4025\n cut=6: 0.3950\n" + "output_type": "stream", + "text": [ + "Expected energy from sampled distribution: 5.0995\n", + "Probability of optimal colorings: 0.4015\n", + "Probability by cut value:\n", + " cut=1: 0.0005\n", + " cut=2: 0.0175\n", + " cut=3: 0.0425\n", + " cut=4: 0.1625\n", + " cut=5: 0.3755\n", + " cut=6: 0.4015\n" + ] } ], "source": [ @@ -894,20 +910,22 @@ "id": "3db27afd", "metadata": { "execution": { - "iopub.execute_input": "2026-06-06T15:44:51.418847Z", - "iopub.status.busy": "2026-06-06T15:44:51.417300Z", - "iopub.status.idle": "2026-06-06T15:44:51.543479Z", - "shell.execute_reply": "2026-06-06T15:44:51.542473Z" + "iopub.execute_input": "2026-06-19T16:05:00.940678Z", + "iopub.status.busy": "2026-06-19T16:05:00.940609Z", + "iopub.status.idle": "2026-06-19T16:05:00.988205Z", + "shell.execute_reply": "2026-06-19T16:05:00.987894Z" } }, "outputs": [ { - "output_type": "display_data", - "metadata": {}, "data": { - "text/plain": "
", - "image/png": "iVBORw0KGgoAAAANSUhEUgAABAsAAAI1CAYAAACwmnNQAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjksIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvJkbTWQAAAAlwSFlzAAAPYQAAD2EBqD+naQAAP0RJREFUeJzt3QmYFNWhP+wz7JuAIIJcEYkb4i5GRXFHEdFowESNUTREcw1xAePCjYJgDEqMejWoiVEx/2hMiEv+4oq4XRXFjSuiolGjJIq4AYLK2t9zzvd1f3NgEEZnnO19n6fo7qrq6lPdRU/Xr85SVigUCgEAAADg/9OoeAcAAABAWAAAAACsRs0CAAAAICMsAAAAADLCAgAAACAjLAAAAAAywgIAAAAgIywAAAAAMsICAAAAICMsAAD4CiZOnBjKysrCP//5T+8fAPWOsAAAavhkM06PP/74assLhULo1q1bWn7ooYeGuu6ee+4JF1xwwTqvv++++5benzi1bNkybL/99uGKK64IK1euDLXR1VdfnT5XAKjrhAUAUMNatGgRbrnlltXmP/roo+Ff//pXaN68eagPYlgwZsyYSj1n4403Dv/n//yfNI0bNy69V8OHDw/nn39+qI2EBQDUF8ICAKhhhxxySJg0aVJYvnx5Nj8GCL179w5dunQJDVW7du3CD3/4wzSdccYZ4bHHHgvdu3cPV111VVixYkVNFw8A6i1hAQDUsGOOOSZ89NFHYcqUKaV5S5cuDX/729/CD37wgwqfc+mll4Y99tgjdOzYMVXPj6FCXL+8G2+8MVXfv+GGG7L5v/rVr9L8eKV/bb744ovUdGDLLbdMV/U32mijMGjQoPDGG2+k5Y888kjaVrwtL7bjj/OLVfJPOOGEMGHChHS/fNOCyopl+Pa3vx0+/fTTMG/evGzZn/70p/Q+xPejQ4cO4eijjw5z5szJ1nn99dfD4MGDUwATtxVrLsT1FixYUGG5y4vzv6wZxaabbhpmzZqVaoQU9y82pYiWLVuWalVsscUW6XXj59a3b9/sMweA2qRJTRcAABq6eJLZp0+f8Oc//zkMGDAgzbv33nvTCWw8kb3yyitXe85///d/h+985zvh2GOPTcHCrbfeGr73ve+FyZMnh4EDB6Z1TjzxxHD77beHESNGhAMPPDD1fzBz5sx00jp06NBUo+HLxCv3sa+EqVOnpnKcfvrp6SQ9nuC+9NJLYbPNNlvnffzJT34S3n333fTc2KTg6yie0Ldv374076KLLkpNE77//e+HH//4x+GDDz5ItQ/23nvv8MILL6R14/vUv3//sGTJknDqqaemwODf//53es/mz5+fajF8HbEvhbjdNm3ahF/84hdpXufOndNtDBliM4pYtl133TUsXLgwPPvss+H5559Pnw0A1DbCAgCoBWINgpEjR4bPP/88XRm/+eabwz777BO6du1a4fqvvfZaWq/oZz/7Wdh5553DZZddVgoLouuuuy5ss802KRyIJ8VDhgxJJ8lxvbX54x//mIKCuG7sJ6Do3HPPTZ0vVkYMQ2LthBgWxCYF6yoGFh9++GG6H2tfXH/99ekkO+5jcf/ffvvtMHr06PDLX/4y/Nd//VfpubEGxE477ZT6EYjzX3755fDWW2+lJh9HHnlkab1Ro0aFqnDEEUeE8847L2ywwQar7ePdd9+dwpnf//73VfJaAFDdNEMAgFogXhGPQUE8oY9X7+PtmpogROWDgk8++STVQthrr73SleryYjAQq//Hk/S4fMaMGalZQtu2bddapttuuy2d+Mar5av6Kk0IvopXX301dOrUKU09e/YMv/71r1ONivLNBGLtiTg6QnwPY7BQnOK+x2r/Dz/8cFqvWHPg/vvvD5999ln4JsWaDbGJQmwGAQB1gZoFAFALxJPhfv36pU4N44lsvKJe/ur3qmKYEK+kx5P/WK3+y07iYxOC2J4/Xt0++eSTwwEHHJAtj1X2y3cWGKvRxyn2S7DVVluFJk2a1GgTjVg7IoYBsTyxuUEsb2z3XxRPwGNNhxgMVKRp06bptkePHqlJRqwpEWtuxPAkBg+xFsDXbYKwNmPHjg2HH354ql2x7bbbhoMPPjgcd9xxaShIAKiNhAUAUEvEmgQnnXRSmDt3buq7oHyb/PL+53/+J53kxvb4sYp97HQwnhDHDg0rGoIxVt+PVfejWBU/nng3avT/Vy6MHQbGqvxFsUr/l3Xkty41DKpqpILWrVunEKVozz33TM0tYrOCYl8OcX9iOWI/D40bN15tGzH4KPrNb36TOlv8+9//Hh544IFw2mmnpb4EnnrqqdTZYXXtT/ysYthRfN0//OEP4fLLLw/XXntt6scAAGobYQEA1BLf/e53U0eA8cT1L3/5y5c2D4hX1mN1+ubNm5fmx7CgIsOGDUtNG+JJcewXIXbEF6+wF8Wr7LEJRNG3vvWtdBs7MHz66adTT/7Fq/OrWn/99dNt7CCwvPLhQ1U2XYhX4mNNgN/97nfh5z//edhkk01SOWPNglhzIF65X5vtttsuTbF/gSeffDIFEPGkPdbUqMz+VOTL9jGO0BA7nYzTokWLUoAQQxlhAQC1kT4LAKCWiFfAr7nmmnQCedhhh61xvXj1PJ6Ulr/aHUcIuPPOO1dbNw6nGIOHiy++OHVMGJskxJPk2EFiUTxZjlfvi1MxLIhDDMa2/7/97W9X226xg8Pu3bun8jz22GPZ8ljjoaJaAhWdiFfW2WefnQKMYieNsSPDWIY4ysOqHS/Gx7FmRRRHIFi+fHm2PIYGsZZFsSlH7Msh9tOwLvtTkbiPFe1fsQzlP+vNN988a0ICALWJmgUAUIvE0QrWJo4EEE+UY7v32HRh3rx5qRPDePL54osvltaL80855ZSw3377pdESonjiHzv8i1XxH3/88aw5wqqOP/74NCJCrIUwffr01MZ/8eLF4cEHHww//elPUxv82NY/DtkYhymMAUa8yh/7U4ivvarevXun21j1Pw5hGE/wY3hRWb169UojC8Sq/HG4xPiasVZArDURQ5M4KsF6662XRj644447Uj8NsRbCQw89lN6HWN5YAyEGB3EYx1iOGIwUxSv9MVyJt7vssksKDsqHK18m7mMMfGJ54uex4YYbhv333z+Ved99903LYw2D2CwkBjnFzwUAap0CAFAjbrzxxngZvPDMM8986Xrdu3cvDBw4MJt3/fXXF7bYYotC8+bNCz179kzbGj16dNpe0aBBgwrrrbde4Z///Gf23L///e9pvUsuuWStZfzss88Kv/jFLwo9evQoNG3atNClS5fCkUceWXjjjTdK63zwwQeFwYMHF1q1alVYf/31Cz/5yU8KL730UnqNWK6i5cuXF0499dRCp06dCmVlZVlZK7LPPvsUttlmmwqXPfLII+n5cZ+LbrvttkLfvn0LrVu3TlN8X4YNG1aYPXt2Wv7mm28WfvSjHxU222yzQosWLQodOnQo7LfffoUHH3xwtX0eOnRooV27dun9+/73v1+YN2/eaq9X/Pzeeuut0ry5c+emzyo+Ly6L+xD98pe/LOy6666F9u3bF1q2bJnKdtFFFxWWLl261s8AAGpCWfynpgMLAAAAoPbQZwEAAACQERYAAAAAGWEBAAAAUHvCgjg0VOw5ufzUs2fP0vIvvvgijQ3dsWPHNMRQ7Kn4/fffz7bxzjvvpF6hW7VqlXocPuuss1YbFgkAAACoQ0MnbrPNNmkIpqImTf7/Ig0fPjzcfffdYdKkSWlopji8UBxL+YknnkjL4/jSMSjo0qVLePLJJ8N7772Xhnlq2rRp+NWvflUj+wMAAAB1XY2OhhBrFtx5551hxowZqy1bsGBB6NSpU7jlllvCkUcemea9+uqrYeuttw7Tpk0Lu+++e7j33nvDoYceGt59993QuXPntM61114bzjnnnPDBBx+EZs2afeP7BAAAAHVdjdcseP3110PXrl1DixYtQp8+fcK4cePCJptsEp577rmwbNmy0K9fv9K6sYlCXFYMC+LtdtttVwoKov79+4dTTjklzJo1K+y0004VvuaSJUvSVLRy5crw8ccfp+YOsSkEAAAA1EexvsCnn36azsMbNWpUO8OC3XbbLUycODFstdVWqQnBmDFjwl577RVeeumlMHfu3FQzoH379tlzYjAQl0XxtnxQUFxeXLYmMZCIrwUAAAAN0Zw5c8LGG29cO8OCAQMGlO5vv/32KTzo3r17+Otf/xpatmxZba87cuTIMGLEiKzJQ6yxEN+stm3bVtvrAgAAQE1auHBh6NatW1hvvfVqdzOE8mItgi233DL84x//CAceeGBYunRpmD9/fla7II6GEDs0jOLt9OnTs20UR0sorlOR5s2bp2lVMSgQFgAAAFDfra0Jfo0OnbiqRYsWhTfeeCNstNFGoXfv3mlUg6lTp5aWz549Ow2VGPs2iOLtzJkzw7x580rrTJkyJZ3w9+rVq0b2AQAAAOq6Gq1Z8POf/zwcdthhqelBHNFg9OjRoXHjxuGYY45JQyUOHTo0NRfo0KFDCgBOPfXUFBDEzg2jgw46KIUCxx13XBg/fnzqp+C8884Lw4YNq7DmAAAAAFDLw4J//etfKRj46KOP0jCJffv2DU899VS6H11++eWpd8bBgwen0QviSAdXX3116fkxWJg8eXIa/SCGCK1btw5DhgwJY8eOrcG9AgAAgLqtrBDHTWjgYgcPsSZD7OhQnwUAAAA09PPfWtVnAQAAAFDzhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAICwAAAAAFgzNQsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADINAm1xMUXXxxGjhwZTj/99HDFFVekeV988UU488wzw6233hqWLFkS+vfvH66++urQuXPn0vPeeeedcMopp4SHH344tGnTJgwZMiSMGzcuNGlSa3atypWNKavpIlDNCqML3mMAAKBh1yx45plnwu9+97uw/fbbZ/OHDx8e7rrrrjBp0qTw6KOPhnfffTcMGjSotHzFihVh4MCBYenSpeHJJ58MN910U5g4cWIYNWpUDewFAAAA1A81HhYsWrQoHHvsseG6664L66+/fmn+ggULwvXXXx8uu+yysP/++4fevXuHG2+8MYUCTz31VFrngQceCC+//HL405/+FHbccccwYMCAcOGFF4YJEyakAAEAAACog2HBsGHDUu2Afv36ZfOfe+65sGzZsmx+z549wyabbBKmTZuWHsfb7bbbLmuWEJsqLFy4MMyaNWuNrxmbNMR1yk8AAADA/6tGG/bHvgief/751AxhVXPnzg3NmjUL7du3z+bHYCAuK65TPigoLi8uW5PYp8GYMWOqaC8AAACgfqmxmgVz5sxJnRnefPPNoUWLFt/oa8eOFGMzh+IUywIAAADUcFgQmxnMmzcv7LzzzmnkgjjFTgyvvPLKdD/WEIj9DsyfPz973vvvvx+6dOmS7sfb+HjV5cVla9K8efPQtm3bbAIAAABqOCw44IADwsyZM8OMGTNK0y677JI6Oyzeb9q0aZg6dWrpObNnz05DJfbp0yc9jrdxGzF0KJoyZUo6+e/Vq1eN7BcAAADUdTXWZ8F6660Xtt1222xe69atQ8eOHUvzhw4dGkaMGBE6dOiQAoBTTz01BQS77757Wn7QQQelUOC4444L48ePT/0UnHfeeanTxFh7AAAAAKhjHRyuzeWXXx4aNWoUBg8enEYwiCMdXH311aXljRs3DpMnTw6nnHJKChFi2DBkyJAwduzYGi03AAAA1GVlhUKhEBq4OHRiu3btUmeHdaH/grIxZTVdBKpZYXSD/28JAADU4PlvjfVZAAAAANROwgIAAAAgIywAAAAAMsICAAAAICMsAAAAADLCAgAAACDTJH8INGSG5azfDMkJAMC6UrMAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAABhAQAAALBmahYAAAAAGWEBAAAAkBEWAAAAABlhAQAAAJARFgAAAAAZYQEAAACQERYAAAAAGWEBAAAAkBEWAAAAABlhAQAAAJARFgAAAAAZYQEAAACQERYAAAAAGWEBAAAAkBEWAAAAABlhAQAAAJARFgAAAAAZYQEAAACQERYAAAAAGWEBAAAAkBEWAAAAABlhAQAAAJARFgAAAAAZYQEAAACQERYAAAAAGWEBAAAAkBEWAAAAABlhAQAAAJARFgAAAAAZYQEAAACQERYAAAAAGWEBAAAAkBEWAAAAAF8vLLjpppvC3XffXXp89tlnh/bt24c99tgjvP3225XdHAAAAFDXw4Jf/epXoWXLlun+tGnTwoQJE8L48ePDBhtsEIYPH14dZQQAAAC+QU0q+4Q5c+aEzTffPN2/8847w+DBg8PJJ58c9txzz7DvvvtWRxkBAACA2lyzoE2bNuGjjz5K9x944IFw4IEHpvstWrQIn3/+edWXEAAAAKjdYUEMB3784x+n6bXXXguHHHJImj9r1qyw6aabVmpb11xzTdh+++1D27Zt09SnT59w7733lpZ/8cUXYdiwYaFjx44ppIi1GN5///1sG++8804YOHBgaNWqVdhwww3DWWedFZYvX17Z3QIAAAC+algQ+yiIJ/UffPBBuO2229KJfPTcc8+FY445plLb2njjjcPFF1+cnvvss8+G/fffPxx++OEpeIhiHwh33XVXmDRpUnj00UfDu+++GwYNGlR6/ooVK1JQsHTp0vDkk0+mzhcnTpwYRo0aVdndAgAAAP4/ZYVCoRAqIV7Jjyf5jRrlOUPcTOzPYJNNNglfR4cOHcKvf/3rcOSRR4ZOnTqFW265Jd2PXn311bD11lunjhV33333VAvh0EMPTSFC586d0zrXXnttOOecc1KY0axZs3V6zYULF4Z27dqFBQsWpBoOtV3ZmLKaLgLVrDC6Uv8tq4xjq36rqeMKAIDaY13Pfytds6BHjx7hww8/XG3+xx9/nJZ9VbGWwK233hoWL16cai7E2gbLli0L/fr1K63Ts2fPFEbEsCCKt9ttt10pKIj69++fdr5YO6EiS5YsSeuUnwAAAICvGBasqSLCokWLUieHlTVz5szUH0Hz5s3Df/7nf4Y77rgj9OrVK8ydOzfVDGjfvn22fgwG4rIo3pYPCorLi8vWZNy4cSlJKU7dunWrdLkBAAAgNPShE0eMGJFuy8rKUp8AsUPB8rUCnn766bDjjjtWugBbbbVVmDFjRqoC8be//S0MGTIk9U9QnUaOHFnanyjWLBAYAAAAQCXDghdeeKFUsyDWBijfH0C8v8MOO4Sf//zn67q57Lmbb755ut+7d+/wzDPPhP/+7/8ORx11VOq4cP78+VntgjgaQpcuXdL9eDt9+vRse8XREorrVCTWYogTAAAA8DXCgocffjjdnnjiielkvro6Aly5cmXqUyAGB02bNg1Tp05NQyZGs2fPTh0sxj4Nonh70UUXhXnz5qVhE6MpU6akssWmDAAAAEA1hgVFN954Y+n+v/71r3QbR0f4qs0BBgwYkDot/PTTT9PIB4888ki4//77U18CQ4cOTc0F4ggJMQA49dRTU0AQR0KIDjrooBQKHHfccWH8+PGpn4LzzjsvDBs2TM0BAAAA+KY6OIxX/seOHZtO5rt3756m2EzgwgsvTMsqI9YIOP7441O/BQcccEBqghCDggMPPDAtv/zyy9PQiLFmwd57752aFtx+++2l5zdu3DhMnjw53cYQ4Yc//GHaXiwfAAAA8NWUFdY0vMGX1Aa4/vrrw5gxY8Kee+6Z5j3++OPhggsuCCeddFJqFlBfx5msLcrGlNV0EahmhdGV+m9ZZRxb9VtNHVcAANS9899KN0O46aabwh/+8Ifwne98pzRv++23D//xH/8RfvrTn9bJsAAAAAD4Gs0QPv7449CzZ8/V5sd5cRkAAADQwMKCOETib3/729Xmx3lxGQAAAFC3VboZQhx1YODAgeHBBx8sDWE4bdq0MGfOnHDPPfdURxkBAACA2lyzYJ999gmvvfZa+O53vxvmz5+fpkGDBoXZs2eHvfbaq3pKCQAAANTemgVR165ddWQIAAAA9dRXCgtibYLp06eHefPmhZUrV2bLjj/++KoqGwAAAFAXwoK77rorHHvssWHRokVpTMaysrLSsnhfWAAAAAANrM+CM888M/zoRz9KYUGsYfDJJ5+UJkMnAgAAQAMMC/7973+H0047LbRq1ap6SgQAAADUrbCgf//+4dlnn62e0gAAAAB1o8+C//t//2/p/sCBA8NZZ50VXn755bDddtuFpk2bZut+5zvfqfpSAgAAALUrLDjiiCNWmzd27NjV5sUODlesWFE1JQMAAABqb1iw6vCIAAAAQP1V6T4LAAAAgPptncOCadOmhcmTJ2fz/vjHP4YePXqEDTfcMJx88slhyZIl1VFGAAAAoDaGBbGPglmzZpUez5w5MwwdOjT069cvnHvuueGuu+4K48aNq65yAgAAALUtLJgxY0Y44IADSo9vvfXWsNtuu4XrrrsujBgxIlx55ZXhr3/9a3WVEwAAAKhtYcEnn3wSOnfuXHr86KOPhgEDBpQef/vb3w5z5syp+hICAAAAtTMsiEHBW2+9le4vXbo0PP/882H33XcvLf/0009D06ZNq6eUAAAAQO0LCw455JDUN8H//M//hJEjR4ZWrVqFvfbaq7T8xRdfDJtttll1lRMAAAD4hjRZ1xUvvPDCMGjQoLDPPvuENm3ahJtuuik0a9astPyGG24IBx10UHWVEwAAAKhtYcEGG2wQHnvssbBgwYIUFjRu3DhbPmnSpDQfAAAAaCBhQVG7du0qnN+hQ4eqKA8AAABQV/osAAAAABoGYQEAAACQERYAAAAAlQ8Ldt555/DJJ5+k+2PHjg2fffbZujwNAAAAqK9hwSuvvBIWL16c7o8ZMyYsWrSoussFAAAA1ObREHbcccdw4oknhr59+4ZCoRAuvfTSNQ6TOGrUqKouIwAAAFDbwoKJEyeG0aNHh8mTJ4eysrJw7733hiZNVn9qXCYsAAAAgAYQFmy11Vbh1ltvTfcbNWoUpk6dGjbccMPqLhsAAABQW8OC8lauXFk9JQEAAADqZlgQvfHGG+GKK65IHR9GvXr1CqeffnrYbLPNqrp8AAAAQG0cDaG8+++/P4UD06dPD9tvv32ann766bDNNtuEKVOmVE8pAQAAgNpbs+Dcc88Nw4cPDxdffPFq888555xw4IEHVmX5AAAAgNpesyA2PRg6dOhq83/0ox+Fl19+uarKBQAAANSVsKBTp05hxowZq82P84yQAAAAAHVfpZshnHTSSeHkk08Ob775Zthjjz3SvCeeeCJccsklYcSIEdVRRgAAAKA2hwXnn39+WG+99cJvfvObMHLkyDSva9eu4YILLginnXZadZQRAAAAqM1hQVlZWergME6ffvppmhfDAwAAAKCBhgXlCQkAAACg/ql0B4cAAABA/SYsAAAAADLCAgAAAOCrhwXLli0LBxxwQHj99dcr8zQAAACgvoYFTZs2DS+++GL1lQYAAACoe80QfvjDH4brr7++ekoDAAAA1L2hE5cvXx5uuOGG8OCDD4bevXuH1q1bZ8svu+yyqiwfAAAAUNvDgpdeeinsvPPO6f5rr72WLSsrK6u6kgEAAAB1Iyx4+OGHq6ckAAAAQN0eOvEf//hHuP/++8Pnn3+eHhcKhaosFwAAAFBXwoKPPvooDZ+45ZZbhkMOOSS89957af7QoUPDmWeeWR1lBAAAAGpzWDB8+PA0hOI777wTWrVqVZp/1FFHhfvuu6+qywcAAADU9j4LHnjggdT8YOONN87mb7HFFuHtt9+uyrIBAAAAdaFmweLFi7MaBUUff/xxaN68eVWVCwAAAKgrYcFee+0V/vjHP2bDJa5cuTKMHz8+7LffflVdPgAAAKC2N0OIoUDs4PDZZ58NS5cuDWeffXaYNWtWqlnwxBNPVE8pAQAAgNpbs2DbbbcNr732Wujbt284/PDDU7OEQYMGhRdeeCFsttlm1VNKAAAAoPbWLIjatWsXfvGLX1R9aQAAAIC6GRZ88skn4frrrw+vvPJKetyrV69w4oknhg4dOlR1+QAAAIDa3gzhscceC5tuumm48sorU2gQp3i/R48eaRkAAADQwGoWDBs2LBx11FHhmmuuCY0bN07zVqxYEX7605+mZTNnzqyOcgIAAAC1tWbBP/7xj3DmmWeWgoIo3h8xYkRaBgAAADSwsGDnnXcu9VVQXpy3ww47VFW5AAAAgNrcDOHFF18s3T/ttNPC6aefnmoR7L777mneU089FSZMmBAuvvji6ispAAAA8I0oKxQKhbWt1KhRo1BWVhbWtmpcJ/ZfUNcsXLgwDQe5YMGC0LZt21DblY0pq+kiUM0Ko9f637JaOLbqt5o6rgAAqHvnv+tUs+Ctt96qyrIBAAAAtdg6hQXdu3ev/pIAAAAAdXPoxOjdd98Njz/+eJg3b15YuXJltiz2aQAAAAA0oLBg4sSJ4Sc/+Ulo1qxZ6NixY+qnoCjeFxYAAABAAwsLzj///DBq1KgwcuTI1PEhAAAAUL9U+mz/s88+C0cffbSgAAAAAOqpSocFQ4cODZMmTaqe0gAAAAB1rxnCuHHjwqGHHhruu+++sN1224WmTZtmyy+77LKqLB8AAABQF8KC+++/P2y11Vbp8aodHAIAAAANLCz4zW9+E2644YZwwgknVE+JAAAAgLrVZ0Hz5s3DnnvuWT2lAQAAAOpeWHD66aeHq666qnpKAwAAANS9ZgjTp08PDz30UJg8eXLYZpttVuvg8Pbbb6/K8gEAAAC1PSxo3759GDRoUPWUBgAAAKh7YcGNN95YPSUBAAAA6mafBQAAAED9VumaBT169AhlZWVrXP7mm29+3TIBAAAAdSksOOOMM7LHy5YtCy+88EK47777wllnnVWVZQMAAADqQlgQh06syIQJE8Kzzz5bqW2NGzcujZ7w6quvhpYtW4Y99tgjXHLJJWGrrbYqrfPFF1+EM888M9x6661hyZIloX///uHqq68OnTt3Lq3zzjvvhFNOOSU8/PDDoU2bNmHIkCFp202aVHr3AAAAoMGrsj4LBgwYEG677bZKPefRRx8Nw4YNC0899VSYMmVKqqVw0EEHhcWLF5fWGT58eLjrrrvCpEmT0vrvvvtuNhrDihUrwsCBA8PSpUvDk08+GW666aYwceLEMGrUqAb/4QIAAMBXUWWX3v/2t7+FDh06VOo5selCefEkf8MNNwzPPfdc2HvvvcOCBQvC9ddfH2655Zaw//77l0Zj2HrrrVPAsPvuu4cHHnggvPzyy+HBBx9MtQ123HHHcOGFF4ZzzjknXHDBBaFZs2ZVtYsAAADQIFQ6LNhpp52yDg4LhUKYO3du+OCDD1LzgK8jhgNRMXSIoUGsbdCvX7/SOj179gybbLJJmDZtWgoL4u12222XNUuITRVis4RZs2al8q4qNmeIU9HChQu/VrkBAACgQYcFRxxxRPa4UaNGoVOnTmHfffdNJ/Jf1cqVK1PniXvuuWfYdttt07wYQsSaAe3bt8/WjcFAXFZcp3xQUFxeXFaR2J/BmDFjvnJZAQAAoD6rdFgwevToailI7LvgpZdeCo8//niobiNHjgwjRozIahZ069at2l8XAAAA6oJaMVzAz372szB58uTw2GOPhY033rg0v0uXLqnjwvnz52e1C95///20rLjO9OnTs+3F5cVlFWnevHmaAAAAgK8xGkJsbtC4ceMvnSo7VGHs7yAGBXfccUd46KGHQo8ePbLlvXv3Dk2bNg1Tp04tzZs9e3YaKrFPnz7pcbydOXNmmDdvXmmdOLJC27ZtQ69evSpVHgAAAKASNQviCf2axE4Gr7zyytTvQGWbHsSRDv7+97+H9dZbr9THQLt27ULLli3T7dChQ1OTgdjpYQwATj311BQQxM4NozjUYgwFjjvuuDB+/Pi0jfPOOy9tW+0BAAAAqMaw4PDDD19tXrzKf+6554a77rorHHvssWHs2LGVevFrrrkm3cbOEcuLwyOecMIJ6f7ll1+eajUMHjw4jWAQRzooP+pCrNEQmzDE0Q9iiNC6deswZMiQSpcFAAAA+Bp9Frz77rupo8ObbropnbzPmDGjNIJBZZshrE2LFi3ChAkT0rQm3bt3D/fcc0+lXx8AAAD4Gn0WRAsWLAjnnHNO2HzzzcOsWbNSXwKxVsFXCQoAAACAOl6zIPYHcMkll6QRBv785z9X2CwBAAAAaEBhQeybIHY6GGsVxOYHcarI7bffXpXlAwAAAGprWHD88ceHsrKy6i0NAAAAUHfCgokTJ1ZvSQAAAIC618EhAAAAUP8JCwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACATJP8IQBUsVvKvKX13Q8KNV0CAKCKqVkAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGB4cAQN2k88z6TceZADVKzQIAAAAgIywAAAAAMsICAAAAICMsAAAAADLCAgAAACAjLAAAAAAyhk4EAIAiQ3LWf4blhHWiZgEAAACQERYAAAAAGWEBAAAAICwAAAAA1kzNAgAAACAjLAAAAAAywgIAAAAgIywAAAAAMsICAAAAICMsAAAAADLCAgAAACAjLAAAAAAywgIAAAAgIywAAAAAMsICAAAAICMsAAAAADLCAgAAACDTJH8IAABAlbulzJtan/2gEOobNQsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgNoTFjz22GPhsMMOC127dg1lZWXhzjvvzJYXCoUwatSosNFGG4WWLVuGfv36hddffz1b5+OPPw7HHntsaNu2bWjfvn0YOnRoWLRo0Te8JwAAAFB/1GhYsHjx4rDDDjuECRMmVLh8/Pjx4corrwzXXnttePrpp0Pr1q1D//79wxdffFFaJwYFs2bNClOmTAmTJ09OAcTJJ5/8De4FAAAA1C9NavLFBwwYkKaKxFoFV1xxRTjvvPPC4Ycfnub98Y9/DJ07d041EI4++ujwyiuvhPvuuy8888wzYZdddknrXHXVVeGQQw4Jl156aaqxAAAAANSTPgveeuutMHfu3NT0oKhdu3Zht912C9OmTUuP421selAMCqK4fqNGjVJNhDVZsmRJWLhwYTYBAAAAtTwsiEFBFGsSlBcfF5fF2w033DBb3qRJk9ChQ4fSOhUZN25cCh6KU7du3aplHwAAAKAuqrVhQXUaOXJkWLBgQWmaM2dOTRcJAAAAao1aGxZ06dIl3b7//vvZ/Pi4uCzezps3L1u+fPnyNEJCcZ2KNG/ePI2eUH4CAAAAanlY0KNHj3TCP3Xq1NK82LdA7IugT58+6XG8nT9/fnjuuedK6zz00ENh5cqVqW8DAAAAoI6NhrBo0aLwj3/8I+vUcMaMGanPgU022SScccYZ4Ze//GXYYostUnhw/vnnpxEOjjjiiLT+1ltvHQ4++OBw0kknpeEVly1bFn72s5+lkRKMhAAAAAB1MCx49tlnw3777Vd6PGLEiHQ7ZMiQMHHixHD22WeHxYsXh5NPPjnVIOjbt28aKrFFixal59x8880pIDjggAPSKAiDBw8OV155ZY3sDwAAANQHNRoW7LvvvqFQKKxxeVlZWRg7dmya1iTWQrjllluqqYQAAADQ8NTaPgsAAACAmiEsAAAAADLCAgAAACAjLAAAAAAywgIAAAAgIywAAAAAMsICAAAAICMsAAAAADLCAgAAACAjLAAAAAAywgIAAAAgIywAAAAAMsICAAAAICMsAAAAADLCAgAAACAjLAAAAAAywgIAAAAgIywAAAAAMsICAAAAICMsAAAAADLCAgAAACAjLAAAAAAywgIAAAAgIywAAAAAMsICAAAAICMsAAAAADLCAgAAACAjLAAAAACEBQAAAMCaqVkAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQP0MCyZMmBA23XTT0KJFi7DbbruF6dOn13SRAAAAoE6qF2HBX/7ylzBixIgwevTo8Pzzz4cddtgh9O/fP8ybN6+miwYAAAB1Tr0ICy677LJw0kknhRNPPDH06tUrXHvttaFVq1bhhhtuqOmiAQAAQJ3TJNRxS5cuDc8991wYOXJkaV6jRo1Cv379wrRp0yp8zpIlS9JUtGDBgnS7cOHCUCd8UdMFoLrV2LHo2KrXauy4+qxmXpZvkGMLxxV1ie8s6tNx9TV+ExYKhfodFnz44YdhxYoVoXPnztn8+PjVV1+t8Dnjxo0LY8aMWW1+t27dqq2cUBntLm7nDaPKOa6oNif5zsJxRR3iOwvHVfLpp5+Gdu3a1d+w4KuItRBiHwdFK1euDB9//HHo2LFjKCsrq9GysXrqFUOcOXPmhLZt23p7qDKOLaqD44rq4tjCcUVd4jurdos1CmJQ0LVr1y9dr86HBRtssEFo3LhxeP/997P58XGXLl0qfE7z5s3TVF779u2rtZx8PTEoEBZQHRxbOK6oS3xn4biiLvGdVXt9WY2CetPBYbNmzULv3r3D1KlTs5oC8XGfPn1qtGwAAABQF9X5mgVRbFIwZMiQsMsuu4Rdd901XHHFFWHx4sVpdAQAAACgAYYFRx11VPjggw/CqFGjwty5c8OOO+4Y7rvvvtU6PaTuic1FRo8evVqzEXBsURv5zsKxRV3iOwvHFl+mrLC28RIAAACABqXO91kAAAAAVC1hAQAAAJARFgAAAAAZYQEAAACQERbwlUyYMCFsuummoUWLFmG33XYL06dPLy37/e9/H/bdd9/Qtm3bUFZWFubPn7/a8z/++ONw7LHHpnXat28fhg4dGhYtWpSt8+KLL4a99torvUa3bt3C+PHjs+WzZs0KgwcPTuWIrxOHzKxsWaMvvvgiDBs2LHTs2DG0adMmbfP99993ZHzDHnvssXDYYYeFrl27ps/zzjvvzJbHvljjiCcbbbRRaNmyZejXr194/fXXs3UuuuiisMcee4RWrVql46oip512Wujdu3fqATqOnFKRqjj21rY/1K/j6p133gkDBw5M62y44YbhrLPOCsuXLy8tf++998IPfvCDsOWWW4ZGjRqFM844o8LtTJo0KfTs2TMde9ttt1245557Kl1eGtZ3VvwbdsIJJ6TjpUmTJuGII46ocDuPPPJI2HnnndN2Nt988zBx4sRK/72k4fzGWpfvo9tvvz0cdNBB6fdTLMuMGTNW28a6lJf6c2xV1ffRuvyGWpfjj69PWECl/eUvfwkjRoxIQxo+//zzYYcddgj9+/cP8+bNS8s/++yzcPDBB4f/+q//WuM24hdNPOGaMmVKmDx5cvpSOPnkk0vLFy5cmL4AunfvHp577rnw61//OlxwwQXpi6wovs63vvWtcPHFF4cuXbp8pbJGw4cPD3fddVf6o/joo4+Gd999NwwaNMiR8Q1bvHhx+nziH7KKxB8yV155Zbj22mvD008/HVq3bp0+y/iHqWjp0qXhe9/7XjjllFO+9LV+9KMfpSFXK1JVx97a9of6c1ytWLEiBQVxvSeffDLcdNNN6YdPPFEsWrJkSejUqVM477zzUnkqEp97zDHHpB9fL7zwQvqRFaeXXnqpUuWlYX1nxeMvhhExVIiBREXeeuutdIzut99+6Qd1DKt+/OMfh/vvv79Sfy9pOL+x1uX7KP4f6Nu3b7jkkkvWWJZ1KS/159iqqu+jdfkNtS7HH1UgDp0IlbHrrrsWhg0bVnq8YsWKQteuXQvjxo3L1nv44YfjsJyFTz75JJv/8ssvp/nPPPNMad69995bKCsrK/z73/9Oj6+++urC+uuvX1iyZElpnXPOOaew1VZbVVim7t27Fy6//PJKl3X+/PmFpk2bFiZNmlRa55VXXknlmzZtWqXeF6pOfP/vuOOO0uOVK1cWunTpUvj1r39dmhc/u+bNmxf+/Oc/r/b8G2+8sdCuXbsvfY3Ro0cXdthhh9XmV9Wx92X7Q/06ru65555Co0aNCnPnzi3Nu+aaawpt27bNjqOiffbZp3D66aevNv/73/9+YeDAgdm83XbbrfCTn/zkK5WXhvGdVd6QIUMKhx9++Grzzz777MI222yTzTvqqKMK/fv3r/TfdhrGb6y1fR+V99Zbb6XXfOGFF9a4X2sqL/Xr2Kqq76PK/IZal+OPr07NAiolXgWJKXT5tDBWqY2Pp02btk7biOvFqku77LJLaV58ftxOvPpSXGfvvfcOzZo1K60T08/Zs2eHTz75pMrKGpcvW7YsWydWudtkk03WeX+ofjGFnjt3bvY5tWvXLlWhq+rPqSqOPRrWcRXXjVUuO3funB0z8epdvAJTme2seiUmbqdYlm/y/wFfT237rNZ2bFXF33bq12+stR0z1C3f1LG1rttxbNUdwgIq5cMPP0xVjMr/KI7i4/jDaF3E9WKb3vJiu6YOHTqUthFvK3qN4rKqKmu8jX8sV20rWpn9ofoVP4uvc9xV5rW+7rFHwzququqYWdN2yn9fVUV5qX617bNa07EVA63PP/+8Sv62U79+Y63t+4i65Zs6tqri+4jaRVgAAAAAZIQFVMoGG2wQGjduvNpoAfHxmjp6W1Vcb9UOk2Kv4bGH1eI24m1Fr1FcVlVljbexataqPb5WZn+ofsXP4uscd5V5ra977NGwjquqOmbWtJ3y31dVUV6qX237rNZ0bMUezWNnZFXxt5369Rtrbd9H1C3f1LFVFd9H1C7CAiolVtmPQzhNnTq1NG/lypXpcZ8+fdZpG3G9eHIe204VPfTQQ2k7sT1ncZ3Yw2rsT6Ao9ry61VZbhfXXX7/KyhqXN23aNFsnttmLw6Ct6/5Q/Xr06JH+uJT/nGJ1tdhGrqo/p6o49mhYx1Vcd+bMmdmPqHjMxB8+vXr1qtR2ypeluJ1iWb7J/wd8PbXts1rbsVUVf9upX7+x1nbMULd8U8fWum7HsVWHfI3OEWmgbr311tSj88SJE1PPqCeffHKhffv2pZ7A33vvvdQj6XXXXZd6J33sscfS448++qi0jYMPPriw0047FZ5++unC448/Xthiiy0KxxxzTNZrdOfOnQvHHXdc4aWXXkqv2apVq8Lvfve70jqxF9+43ThttNFGhZ///Ofp/uuvv77OZY3+8z//s7DJJpsUHnroocKzzz5b6NOnT5r4Zn366aelzzMeN5dddlm6//bbb6flF198cfrs/v73vxdefPHF1MNujx49Cp9//nlpG3Hd+JwxY8YU2rRpU9pe3HZRPD7ivNij85Zbbllap9grdFUde2vbH+rPcbV8+fLCtttuWzjooIMKM2bMKNx3332FTp06FUaOHJmVpfi83r17F37wgx+k+7NmzSotf+KJJwpNmjQpXHrppWlUltj7fRytZebMmaV11qW8NKzvrCgeR3HeYYcdVth3331L6xS9+eab6XvsrLPOSsfWhAkTCo0bN07HamX+XtJwfmOty/dRfM342nfffXcqS9xOfBzLWLQu5aX+HFtV9X20Lr+h1uX44+sTFvCVXHXVVekEu1mzZmkolqeeeqq0LP5Bif9pV53i0FDl/4PHL5f44ygOL3biiSdmP46i//3f/y307ds3fbH9x3/8R/rhVdFQKatOcViydS1rFH+4/fSnP03DCMUvr+9+97u+aGpAcaieVac49E5xKLLzzz8//cCJx8QBBxxQmD17draNuG5F24jbLorHR0XrxOOpKo+9te0P9eu4+uc//1kYMGBAoWXLloUNNtigcOaZZxaWLVuWbaeibcShN8v761//mk4I4/dVHFoq/ggqb13KS8P7zorHUUXrrFreHXfcMR1b3/rWt7K/yev695KG8xtrXb6P4mtWVJZYxsqUl/p1bFXF99G6/IZal+OPr68s/lPTtRsAAACA2kOfBQAAAEBGWAAAAABkhAUAAABARlgAAAAAZIQFAAAAQEZYAAAAAGSEBQAAAEBGWAAAAABkhAUAQJWYOHFiaN++vXcTAOoBYQEANAAnnHBCKCsrK00dO3YMBx98cHjxxRer7DWOOuqo8Nprr33l5//v//5v+M53vhM23HDD0KJFi7Dpppumbc6bNy8tf+SRR1LZ58+fX6nt/vOf/0zPmzFjxlcuGwA0NMICAGggYjjw3nvvpWnq1KmhSZMm4dBDD62y7bds2TKd6H8VH3zwQTjggANChw4dwv333x9eeeWVcOONN4auXbuGxYsXV1kZAYB1IywAgAaiefPmoUuXLmnacccdw7nnnhvmzJmTTtSLzjnnnLDllluGVq1ahW9961vh/PPPD8uWLcuu/u+3335hvfXWC23btg29e/cOzz77bIXNEL5s3VU98cQTYcGCBeEPf/hD2GmnnUKPHj3Scy+//PJ0P9YOiI+j9ddfP9UUiLUlovvuuy/07ds3vXasMREDkDfeeKO07fj8KG43Pm/fffctLYuvt/XWW6eaDD179gxXX311Fb7jAFB3NanpAgAA37xFixaFP/3pT2HzzTdPJ9hF8cQ+nvTHK/ozZ84MJ510Upp39tlnp+XHHntsOum+5pprQuPGjVPV/qZNm1b4GpVZNwYYy5cvD3fccUc48sgj00l9ed26dQu33XZbGDx4cJg9e3YKH2JNhijWPBgxYkTYfvvt036NGjUqfPe7302v16hRozB9+vSw6667hgcffDBss802oVmzZul5N998c1r3t7/9bSrnCy+8kPa3devWYciQIVX2XgNAXVRWKBQKNV0IAKB6xavwMRyIV9CLJ9gbbbRRmDx5cth5553X+LxLL7003HrrraUaAfEk/aqrrqrwZDqGDGeccUapT4EvW7civ/jFL8L48ePT8+LJ/f777x+OP/740Llz51KfBbF2wSeffPKlHSl++OGHoVOnTins2HbbbVOthFi7IIYBsUZFUQxKLrzwwnDMMceU5v3yl78M99xzT3jyySfXqcwAUF9phgAADUQ80Y5X2+MUr7b3798/DBgwILz99tuldf7yl7+EPffcM13pb9OmTTjvvPPCO++8U1oer+D/+Mc/Dv369QsXX3xxVt1/VZVZN7rooovC3Llzw7XXXptqAMTb2DQgnvR/mddffz2d8MdmEzFoiB0jRuXLvaoYlsTyDB06NO1ncYphwdrKCQANgbAAABqIWL0+Xk2P07e//e3UXj+eNF933XVp+bRp01LTgUMOOSTVOIhX4uPV/qVLl5a2ccEFF4RZs2aFgQMHhoceeij06tUrNR2oSGXWLYpNIr73ve+lGg2xk8PYHCLe/zKHHXZY+Pjjj9N+PP3002mKypd7VbG5QhSfUwxQ4vTSSy+Fp5566ktfDwAaAn0WAEADFfsFiG36P//88/Q4Vr3v3r17CgiKytc6KIodIMZp+PDh6Yp+HLUg9hFQkcqsu6rYt8Bmm21WGg2h2NfAihUrSut89NFHqQ+DeNK/1157pXmPP/74attZ9XmxaUMMIt58880UkAAAOWEBADQQS5YsSdX8o9juP3bsF6+wxyvz0RZbbJGq7sc+CmLNg7vvvjurCRBDhbPOOit1QBj7APjXv/4VnnnmmdTp4Koqs24UazLE1z366KNTuBC7VLrrrrtS/wExYIhikBEDjrhurP0QOziMIyPE2gi///3vUx8MsfxxlIfy4nCOcd04asLGG2+c+m1o165dGDNmTDjttNPS/TisZHx/Yt8M8b2JTSgAoEGLHRwCAPXbkCFDYofGpWm99dYrfPvb3y787W9/y9Y766yzCh07diy0adOmcNRRRxUuv/zyQrt27dKyJUuWFI4++uhCt27dCs2aNSt07dq18LOf/azw+eefp+U33njjOq+7qjfeeKNw0kknFbbccstCy5YtC+3bt0/li9ssb+zYsYUuXboUysrK0j5FU6ZMKWy99daF5s2bF7bffvvCI488kvbxjjvuKD3vuuuuS2Vp1KhRYZ999inNv/nmmws77rhjKuP6669f2HvvvQu33357lb3vAFBXGQ0BAAAAyOjgEAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAAyAgLAAAAgIywAAAAAMgICwAAAICMsAAAAADICAsAAACAjLAAAAAACOX9P3sUHZ32gXmDAAAAAElFTkSuQmCC" - } + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -958,16 +976,16 @@ "id": "bd2b90be", "metadata": { "execution": { - "iopub.execute_input": "2026-06-06T15:44:51.544986Z", - "iopub.status.busy": "2026-06-06T15:44:51.544986Z", - "iopub.status.idle": "2026-06-06T15:44:51.699856Z", - "shell.execute_reply": "2026-06-06T15:44:51.699856Z" + "iopub.execute_input": "2026-06-19T16:05:00.989398Z", + "iopub.status.busy": "2026-06-19T16:05:00.989327Z", + "iopub.status.idle": "2026-06-19T16:05:01.020603Z", + "shell.execute_reply": "2026-06-19T16:05:01.020270Z" } }, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1041,7 +1059,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.20" + "version": "3.12.11" } }, "nbformat": 4, diff --git a/guppylang/src/guppylang/defs.py b/guppylang/src/guppylang/defs.py index 7840c8707..115e5f5b3 100644 --- a/guppylang/src/guppylang/defs.py +++ b/guppylang/src/guppylang/defs.py @@ -30,6 +30,11 @@ import guppylang from guppylang.emulator import EmulatorBuilder, EmulatorInstance +from guppylang.emulator._args import ( + EntrypointArgSpec, + unsupported_arg_reason, + wrap_entrypoint_with_args, +) from guppylang.emulator.builder import Platform from guppylang.emulator.exceptions import EmulatorBuildError @@ -80,6 +85,13 @@ def input_names(self) -> str: return ", ".join(f"`{x}`" for x in self.args) +@dataclass(frozen=True) +class UnsupportedEntrypointArgError(Error): + title: ClassVar[str] = "Unsupported entrypoint argument type" + span_label: ClassVar[str] = "{reason}" + reason: str + + @dataclass(frozen=True) class GuppyDefinition(TracingDefMixin): """A general Guppy definition.""" @@ -138,11 +150,17 @@ def emulator( ) -> EmulatorInstance: """Compile this function for emulation with the selene-sim emulator. - Calls `compile()` to get the HUGR package and then builds it using the - provided `EmulatorBuilder` configuration or a default one. + Compiles the function to a HUGR package and builds it using the provided + `EmulatorBuilder` configuration or a default one. See :py:mod:`guppylang.emulator` for more details on the emulator. + If the entrypoint takes parameters, they become *runtime arguments*: the + entrypoint is wrapped so that each argument is read at run time, and values + are supplied to :py:meth:`EmulatorInstance.run` (or + :py:meth:`EmulatorInstance.run_per_shot`). Only `bool`, signed `int`, + `float`, and arrays of those are supported as argument types. + Args: n_qubits: The number of qubits to allocate for the function. If it is not @@ -160,13 +178,22 @@ def emulator( Returns: An `EmulatorInstance` that can be used to run the function in an emulator. """ - mod = self.compile() + mod = self.compile_function() if libs is not None: mod = mod.link(*libs) + arg_specs = self._entrypoint_arg_specs() + if builder is None: builder = EmulatorBuilder().with_platform(platform) + + if arg_specs: + from selene_argreader_plugin import ArgReaderPlugin + + wrap_entrypoint_with_args(mod, [spec.name for spec in arg_specs]) + builder = builder.link_utility(ArgReaderPlugin()) + qubits = n_qubits if ( isinstance(self.wrapped, RawFunctionDef) @@ -193,7 +220,35 @@ def emulator( ) ) - return builder.build(mod, n_qubits=qubits) + return builder.build(mod, n_qubits=qubits, arg_specs=arg_specs) + + @pretty_errors + def _entrypoint_arg_specs(self) -> tuple[EntrypointArgSpec, ...]: + """Validate and collect the runtime argument schema of the entrypoint. + + Returns an empty tuple if the entrypoint takes no arguments. Raises a + `GuppyError` if any argument has an unsupported type. + """ + compiled_def = ENGINE.compiled.get((self.id, ())) + if not ( + isinstance(compiled_def, CompiledCallableDef) + and len(compiled_def.ty.inputs) > 0 + ): + return () + + defined_at = cast("ast.FunctionDef", compiled_def.defined_at) + names = compiled_def.ty.input_names or [] + specs: list[EntrypointArgSpec] = [] + for i, inp in enumerate(compiled_def.ty.inputs): + reason = unsupported_arg_reason(inp.ty) + if reason is not None: + raise GuppyError( + UnsupportedEntrypointArgError( + span=to_span(defined_at.args.args[i]), reason=reason + ) + ) + specs.append(EntrypointArgSpec(name=names[i], ty=inp.ty)) + return tuple(specs) def compile(self) -> Package: """ diff --git a/guppylang/src/guppylang/emulator/_args.py b/guppylang/src/guppylang/emulator/_args.py new file mode 100644 index 000000000..c7fd154b1 --- /dev/null +++ b/guppylang/src/guppylang/emulator/_args.py @@ -0,0 +1,261 @@ +"""Support for runtime arguments to emulator entrypoint functions. + +A Guppy execution entrypoint is normally required to take no inputs. To support +*runtime arguments* (e.g. for variational workflows where the same program is run +many times with different parameters), the emulator compiles an entrypoint with +parameters by *wrapping* it: + +* the wrapper takes no inputs, +* for each parameter it reads the value at runtime via the ``tket.argreader`` + ``read_arg`` op (tagged with the parameter name), and +* it calls the original entrypoint with those values. + +Argument *values* are supplied at run time through selene's ``ArgProvider`` (see +:meth:`EmulatorInstance.run ` and +:meth:`run_per_shot `), keyed by +the parameter name. + +This is currently an emulator-only (selene) feature: the ``read_arg`` op is only +lowered by the selene compiler, and argument values are provided through selene's +``ArgProvider``. + +Only a restricted set of argument types is supported: ``bool``, signed ``int``, +``float``, and (one-dimensional) arrays of those. Unsigned ``nat`` is deliberately +not supported so that a single generic ``read_arg`` op suffices without signedness +ambiguity; take an ``int`` and convert in-script instead. +""" + +from __future__ import annotations + +from dataclasses import dataclass +from typing import TYPE_CHECKING + +from guppylang_internals.tys.builtin import ( + get_array_length, + get_element_type, + is_array_type, + is_bool_type, +) +from guppylang_internals.tys.const import ConstValue +from guppylang_internals.tys.ty import NumericType + +if TYPE_CHECKING: + from collections.abc import Mapping, Sequence + + from guppylang_internals.tys.ty import Type + from hugr.package import Package + +#: Human-readable description of the supported entrypoint argument types. +SUPPORTED_ARG_TYPES_MSG = "`bool`, `int`, `float`, and arrays of those" + +#: Python value types accepted by selene's argument provider. +ArgValue = int | float | bool | list[int] | list[float] | list[bool] + + +@dataclass(frozen=True) +class EntrypointArgSpec: + """A single runtime argument expected by a wrapped entrypoint.""" + + name: str + ty: Type + + +class EntrypointArgValueError(ValueError): + """Raised when runtime argument values don't match the entrypoint signature.""" + + +def _is_supported_scalar(ty: Type) -> bool: + """Whether ``ty`` is a supported scalar entrypoint argument type.""" + if is_bool_type(ty): + return True + if isinstance(ty, NumericType): + return ty.kind in (NumericType.Kind.Int, NumericType.Kind.Float) + return False + + +def is_supported_arg_type(ty: Type) -> bool: + """Whether ``ty`` may be used as an entrypoint runtime argument.""" + if _is_supported_scalar(ty): + return True + if is_array_type(ty): + return _is_supported_scalar(get_element_type(ty)) + return False + + +def unsupported_arg_reason(ty: Type) -> str | None: + """Return ``None`` if ``ty`` is a supported argument type, otherwise a + human-readable explanation of why it is not.""" + if is_supported_arg_type(ty): + return None + if isinstance(ty, NumericType) and ty.kind is NumericType.Kind.Nat: + return ( + "Unsigned `nat` arguments are not supported. " + "Use a signed `int` argument and convert in your program if needed." + ) + if is_array_type(ty): + elem = get_element_type(ty) + if is_array_type(elem): + return "Nested arrays are not supported as entrypoint arguments." + return ( + f"Arrays of `{elem}` are not supported as entrypoint arguments. " + f"Supported element types are {SUPPORTED_ARG_TYPES_MSG}." + ) + return ( + f"Type `{ty}` is not supported as an entrypoint argument. " + f"Supported types are {SUPPORTED_ARG_TYPES_MSG}." + ) + + +def _array_length(ty: Type) -> int | None: + """Return the (concrete) length of an array type, or ``None`` if unknown.""" + length = get_array_length(ty) + if isinstance(length, ConstValue) and isinstance(length.value, int): + return length.value + return None + + +def _value_error(ty: Type, value: object) -> str | None: + """Return ``None`` if ``value`` is a valid argument of guppy type ``ty``, + otherwise a human-readable reason why it is not.""" + if is_bool_type(ty): + return None if isinstance(value, bool) else "expected a `bool`" + if isinstance(ty, NumericType): + if ty.kind is NumericType.Kind.Int: + if isinstance(value, bool): + return "expected an `int`, got a `bool`" + return None if isinstance(value, int) else "expected an `int`" + if ty.kind is NumericType.Kind.Float: + if isinstance(value, bool): + return "expected a `float`, got a `bool`" + return None if isinstance(value, (int, float)) else "expected a `float`" + if is_array_type(ty): + elem = get_element_type(ty) + n = _array_length(ty) + if not isinstance(value, (list, tuple)): + return f"expected an array of length {n}" + if len(value) == 0: + return "arrays must be non-empty" + if n is not None and len(value) != n: + return f"expected an array of length {n}, got {len(value)}" + for item in value: + reason = _value_error(elem, item) + if reason is not None: + return f"array element {reason}" + return None + return f"unsupported argument type `{ty}`" + + +def _validate_record( + specs: Sequence[EntrypointArgSpec], + record: Mapping[str, object], + *, + shot: int | None = None, +) -> None: + where = f" for shot {shot}" if shot is not None else "" + expected = {spec.name for spec in specs} + given = set(record) + if missing := sorted(expected - given): + raise EntrypointArgValueError( + f"Missing value(s){where} for entrypoint argument(s): " + + ", ".join(f"`{name}`" for name in missing) + ) + if extra := sorted(given - expected): + raise EntrypointArgValueError( + f"Unexpected entrypoint argument(s){where}: " + + ", ".join(f"`{name}`" for name in extra) + ) + for spec in specs: + reason = _value_error(spec.ty, record[spec.name]) + if reason is not None: + raise EntrypointArgValueError( + f"Invalid value{where} for entrypoint argument `{spec.name}`: {reason}" + ) + + +def validate_constant_args( + specs: Sequence[EntrypointArgSpec], values: Mapping[str, object] +) -> None: + """Validate constant argument values against the entrypoint signature.""" + _validate_record(specs, values) + + +def validate_per_shot_args( + specs: Sequence[EntrypointArgSpec], + per_shot: Sequence[Mapping[str, object]], +) -> None: + """Validate a list of per-shot argument records against the signature.""" + if not per_shot: + raise EntrypointArgValueError( + "`run_per_shot` requires at least one shot's arguments." + ) + for shot, record in enumerate(per_shot): + _validate_record(specs, record, shot=shot) + + +def wrap_entrypoint_with_args(package: Package, arg_names: Sequence[str]) -> None: + """Rewrite the entrypoint of ``package`` so that it takes no inputs. + + The original entrypoint ``f(a, b, ...)`` is replaced as the package entrypoint + by a no-input wrapper that reads each argument at runtime (via ``read_arg``, + tagged with the corresponding name from ``arg_names``) and calls ``f``. + + Mutates ``package`` in place. + """ + import tket_exts + from guppylang_internals.std._internal.compiler.array import ( + standard_array_type, + std_array_to_array, + ) + from hugr import Wire, ops + from hugr import tys as ht + from hugr.build.function import Function + from hugr.std.collections.borrow_array import EXTENSION as BORROW_ARRAY_EXT + + borrow_array_def = BORROW_ARRAY_EXT.types["borrow_array"] + + def read_arg_wire(wrapper: Function, name: str, ty: ht.Type) -> Wire: + """Read a single runtime argument, bridging array representations. + + Entrypoint array parameters are lowered to ``borrow_array``, but the + ``read_arg`` extern fills a standard ``array``. For arrays we therefore read + a standard ``array`` and convert it to the ``borrow_array`` the entrypoint + expects (the mirror of how the result compiler converts the other way). + """ + if isinstance(ty, ht.ExtType) and ty.type_def is borrow_array_def: + length_arg, elem_arg = ty.args + assert isinstance(elem_arg, ht.TypeTypeArg) + elem_ty = elem_arg.ty + std_ty = standard_array_type(elem_ty, length_arg) + std_wire = wrapper.add_op(tket_exts.argreader.read_arg(name, std_ty))[0] + return wrapper.add_op(std_array_to_array(elem_ty, length_arg), std_wire)[0] + return wrapper.add_op(tket_exts.argreader.read_arg(name, ty))[0] + + for module in package.modules: + entrypoint = module.entrypoint + op = module[entrypoint].op + if not isinstance(op, ops.FuncDefn) or len(op.inputs) == 0: + continue + + input_types = list(op.inputs) + output_types = list(op.signature.body.output) + if len(arg_names) != len(input_types): + raise ValueError( + "Mismatch between entrypoint parameter names " + f"({len(arg_names)}) and HUGR inputs ({len(input_types)})." + ) + + wrapper = Function.new_nested( + ops.FuncDefn("__wrapped_entrypoint", [], visibility="Public"), + module, + module.module_root, + ) + arg_wires = [ + read_arg_wire(wrapper, name, ty) + for name, ty in zip(arg_names, input_types, strict=True) + ] + call_node = wrapper.call(entrypoint, *arg_wires) + wrapper.set_outputs(*(call_node[i] for i in range(len(output_types)))) + module.entrypoint = wrapper.parent_node + return + + raise ValueError("No entrypoint with input parameters found in package.") diff --git a/guppylang/src/guppylang/emulator/builder.py b/guppylang/src/guppylang/emulator/builder.py index 6450947b0..16c8c19d4 100644 --- a/guppylang/src/guppylang/emulator/builder.py +++ b/guppylang/src/guppylang/emulator/builder.py @@ -19,6 +19,8 @@ from hugr.package import Package from selene_core import BuildPlanner, QuantumInterface, Utility + from ._args import EntrypointArgSpec + #: The quantum platform to target when building an emulator instance. #: ``"helios"`` is the default and targets the Helios QIS. @@ -97,6 +99,14 @@ def with_platform(self, value: Platform) -> Self: """ return replace(self, _platform=value) + def link_utility(self, utility: Utility) -> Self: + """Link a selene ``Utility`` into the emulator build. + + May be called multiple times to link additional utilities. + """ + utilities = [*(self._utilities or []), utility] + return replace(self, _utilities=utilities) + def with_build_arg(self, key: str, value: Any) -> Self: """Selene builds may support additional customisable arguments, e.g. to override the choice of compilation route. This is passed @@ -122,12 +132,19 @@ def with_build_arg(self, key: str, value: Any) -> Self: else: return replace(self, _custom_args=self._custom_args | {key: value}) - def build(self, package: Package, n_qubits: int) -> EmulatorInstance: + def build( + self, + package: Package, + n_qubits: int, + arg_specs: Sequence[EntrypointArgSpec] = (), + ) -> EmulatorInstance: """Build an EmulatorInstance from a compiled package. Args: package: The compiled HUGR package to build the emulator from. n_qubits: The number of qubits to allocate for the emulator instance. + arg_specs: The runtime argument schema of the (wrapped) entrypoint, if + it takes arguments. Used to validate values passed to ``run``. Returns: An EmulatorInstance that can be used to run the compiled program. @@ -149,4 +166,6 @@ def build(self, package: Package, n_qubits: int) -> EmulatorInstance: **custom_args, ) - return EmulatorInstance(_instance=instance, _n_qubits=n_qubits) + return EmulatorInstance( + _instance=instance, _n_qubits=n_qubits, _arg_specs=tuple(arg_specs) + ) diff --git a/guppylang/src/guppylang/emulator/instance.py b/guppylang/src/guppylang/emulator/instance.py index 6dde09224..3d37c1ab3 100644 --- a/guppylang/src/guppylang/emulator/instance.py +++ b/guppylang/src/guppylang/emulator/instance.py @@ -9,6 +9,7 @@ from typing import TYPE_CHECKING, Any, cast from hugr.qsystem.result import QsysShot +from selene_argreader_plugin import ArgProvider from selene_sim.backends.bundled_error_models import IdealErrorModel from selene_sim.backends.bundled_runtimes import SimpleRuntime from selene_sim.backends.bundled_simulators import Coinflip, Quest, Stim @@ -16,12 +17,17 @@ from tqdm import tqdm from typing_extensions import Self +from ._args import ( + EntrypointArgValueError, + validate_constant_args, + validate_per_shot_args, +) from .exceptions import EmulatorError from .result import EmulatorResult if TYPE_CHECKING: import datetime - from collections.abc import Iterator + from collections.abc import Iterator, Mapping, Sequence from pathlib import Path from hugr.qsystem.result import TaggedResult @@ -30,6 +36,8 @@ from selene_core.simulator import Simulator from selene_sim.instance import SeleneInstance + from ._args import ArgValue, EntrypointArgSpec + @dataclass(frozen=True) class _Options: @@ -62,6 +70,7 @@ class EmulatorInstance: _instance: SeleneInstance _n_qubits: int _options: _Options = field(default_factory=_Options) + _arg_specs: tuple[EntrypointArgSpec, ...] = () def _with_option(self, **kwargs: Any) -> Self: """Helper method to simplify setting options.""" @@ -211,11 +220,67 @@ def stabilizer_sim(self) -> Self: This only works for clifford circuits but is very fast.""" return self.with_simulator(Stim()) - def run(self) -> EmulatorResult: + def run(self, **args: ArgValue) -> EmulatorResult: """Run the emulator instance and return the results. - By default runs one shot, this can be configured with `with_shots()`.""" - result_stream = self._run_instance() + By default runs one shot, this can be configured with `with_shots()`. + + If the entrypoint takes runtime arguments, their values must be passed as + keyword arguments. The same values are used for every shot. For example:: + + main.emulator(n_qubits=2).run(theta=1.5, n=3) + + To vary arguments per shot, use :meth:`run_per_shot` instead. + """ + if not self._arg_specs: + if args: + raise EntrypointArgValueError( + "This entrypoint takes no runtime arguments, but got: " + + ", ".join(f"`{name}`" for name in args) + ) + return self._collect_results(self._run_instance()) + + validate_constant_args(self._arg_specs, args) + provider = ArgProvider() + provider.set_constant_args(**args) + with provider: + return self._collect_results(self._run_instance()) + + def run_per_shot(self, args: Sequence[Mapping[str, ArgValue]]) -> EmulatorResult: + """Run the emulator with a different set of runtime arguments per shot. + + ``args`` is a sequence with one mapping of argument values per shot; the + number of shots run is ``len(args)`` (the ``with_shots`` setting is + ignored). For example:: + + main.emulator(n_qubits=2).run_per_shot( + [{"theta": 1.0, "n": 10}, {"theta": 2.5, "n": 20}] + ) + + For constant arguments shared across all shots, use :meth:`run` instead. + """ + if not self._arg_specs: + raise EntrypointArgValueError( + "This entrypoint takes no runtime arguments; `run_per_shot` is not " + "applicable." + ) + validate_per_shot_args(self._arg_specs, args) + if self.shot_offset != 0: + raise EntrypointArgValueError( + "`run_per_shot` is not compatible with a non-zero shot offset " + f"(got {self.shot_offset}); per-shot arguments are indexed from 0." + ) + + instance = self.with_shots(len(args)) + provider = ArgProvider() + provider.set_variable_args([dict(record) for record in args]) + with provider: + return instance._collect_results(instance._run_instance()) + + def _collect_results( + self, result_stream: Iterator[Iterator[TaggedResult]] + ) -> EmulatorResult: + """Drain a shot result stream into an :class:`EmulatorResult`.""" all_results: list[QsysShot] = [] for shot in self._iterate_shots(result_stream): shot_results = QsysShot() diff --git a/pyproject.toml b/pyproject.toml index 5df469894..35b41a84b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -44,6 +44,10 @@ allow_redefinition = true [[tool.mypy.overrides]] module = ["miette_py"] +[[tool.mypy.overrides]] +module = ["selene_argreader_plugin"] +ignore_missing_imports = true + [tool.coverage.report] exclude_also = [ # Don't complain about missing coverage on typing imports diff --git a/tests/emulator/test_args.py b/tests/emulator/test_args.py new file mode 100644 index 000000000..7fcc5d3f7 --- /dev/null +++ b/tests/emulator/test_args.py @@ -0,0 +1,202 @@ +"""Unit tests for guppylang.emulator._args argument validation helpers.""" + +from __future__ import annotations + +import pytest +from guppylang.emulator._args import ( + EntrypointArgSpec, + EntrypointArgValueError, + is_supported_arg_type, + unsupported_arg_reason, + validate_constant_args, + validate_per_shot_args, +) +from guppylang_internals.tys.builtin import ( + array_type, + bool_type, + int_type, + nat_type, +) +from guppylang_internals.tys.ty import NumericType + +float_type = NumericType(NumericType.Kind.Float) + + +@pytest.mark.parametrize( + "ty", + [ + bool_type(), + int_type(), + float_type, + array_type(int_type(), 3), + array_type(float_type, 2), + array_type(bool_type(), 5), + ], +) +def test_supported_arg_types(ty): + assert is_supported_arg_type(ty) + assert unsupported_arg_reason(ty) is None + + +def test_nat_is_unsupported(): + reason = unsupported_arg_reason(nat_type()) + assert reason is not None + assert "nat" in reason + assert not is_supported_arg_type(nat_type()) + + +def test_nested_array_is_unsupported(): + ty = array_type(array_type(int_type(), 2), 3) + reason = unsupported_arg_reason(ty) + assert reason is not None + assert "Nested arrays" in reason + + +def test_array_of_nat_is_unsupported(): + ty = array_type(nat_type(), 3) + assert not is_supported_arg_type(ty) + assert unsupported_arg_reason(ty) is not None + + +def _specs() -> tuple[EntrypointArgSpec, ...]: + return ( + EntrypointArgSpec("theta", float_type), + EntrypointArgSpec("k", int_type()), + EntrypointArgSpec("flag", bool_type()), + ) + + +def test_validate_constant_args_ok(): + validate_constant_args(_specs(), {"theta": 1.5, "k": 3, "flag": True}) + # ints are accepted for floats + validate_constant_args(_specs(), {"theta": 2, "k": 3, "flag": False}) + + +def test_validate_constant_args_missing(): + with pytest.raises(EntrypointArgValueError, match=r"Missing.*`flag`"): + validate_constant_args(_specs(), {"theta": 1.5, "k": 3}) + + +def test_validate_constant_args_extra(): + with pytest.raises(EntrypointArgValueError, match=r"Unexpected.*`extra`"): + validate_constant_args( + _specs(), {"theta": 1.5, "k": 3, "flag": True, "extra": 1} + ) + + +def test_validate_constant_args_wrong_type(): + with pytest.raises(EntrypointArgValueError, match=r"`k`.*expected an `int`"): + validate_constant_args(_specs(), {"theta": 1.5, "k": "x", "flag": True}) + + +def test_validate_constant_args_bool_not_int(): + with pytest.raises(EntrypointArgValueError, match="got a `bool`"): + validate_constant_args(_specs(), {"theta": 1.5, "k": True, "flag": True}) + + +def test_validate_array_args(): + specs = (EntrypointArgSpec("xs", array_type(int_type(), 3)),) + validate_constant_args(specs, {"xs": [1, 2, 3]}) + + with pytest.raises(EntrypointArgValueError, match="length 3, got 2"): + validate_constant_args(specs, {"xs": [1, 2]}) + + with pytest.raises(EntrypointArgValueError, match="non-empty"): + validate_constant_args(specs, {"xs": []}) + + with pytest.raises(EntrypointArgValueError, match="array element"): + validate_constant_args(specs, {"xs": [1, "x", 3]}) + + +def test_validate_per_shot_args_ok(): + validate_per_shot_args( + _specs(), + [ + {"theta": 1.0, "k": 1, "flag": True}, + {"theta": 2.0, "k": 2, "flag": False}, + ], + ) + + +def test_validate_per_shot_args_empty(): + with pytest.raises(EntrypointArgValueError, match="at least one"): + validate_per_shot_args(_specs(), []) + + +def test_validate_per_shot_args_reports_shot(): + with pytest.raises(EntrypointArgValueError, match="for shot 1"): + validate_per_shot_args( + _specs(), + [ + {"theta": 1.0, "k": 1, "flag": True}, + {"theta": 2.0, "k": 2}, + ], + ) + + +def _read_arg_output_types(package): + """Collect the output type of every `read_arg` op in a wrapped package.""" + outs = [] + for module in package.modules: + for _node, data in module.nodes(): + op = data.op + if "read_arg" in str(op): + outs.extend(op.outer_signature().output) + return outs + + +def _has_from_array_op(package): + """True if any module contains a std->borrow `from_array` conversion op.""" + return any( + "from_array" in str(data.op).lower() + for module in package.modules + for _node, data in module.nodes() + ) + + +def test_wrap_bridges_array_to_standard_array(): + """Array params read a standard `array` and convert to `borrow_array`. + + The entrypoint expects a `borrow_array`, but the argreader extern fills a + standard `array`. The wrapper must therefore read a standard `array` and + insert a `from_array` conversion, mirroring the result compiler's bridge. + """ + from guppylang import guppy + from guppylang.emulator._args import wrap_entrypoint_with_args + from guppylang.std.builtins import array, result + + @guppy + def main(xs: array[float, 3]) -> None: + result("a", xs[0]) + + package = main.compile_function() + wrap_entrypoint_with_args(package, ["xs"]) + + out_types = _read_arg_output_types(package) + assert len(out_types) == 1 + out = out_types[0] + assert out.type_def.name == "array", ( + f"read_arg should output a standard `array`, got {out.type_def.name}" + ) + assert _has_from_array_op(package), ( + "expected a std->borrow `from_array` conversion for the array argument" + ) + + +def test_wrap_scalar_arg_has_no_conversion(): + """Scalar params read their type directly with no array conversion op.""" + from guppylang import guppy + from guppylang.emulator._args import wrap_entrypoint_with_args + from guppylang.std.builtins import result + + @guppy + def main(theta: float) -> None: + result("a", theta) + + package = main.compile_function() + wrap_entrypoint_with_args(package, ["theta"]) + + out_types = _read_arg_output_types(package) + assert len(out_types) == 1 + assert out_types[0].type_def.name == "float64" + assert not _has_from_array_op(package) diff --git a/tests/emulator/test_builder.py b/tests/emulator/test_builder.py index 027b46a9f..cfd2727cc 100644 --- a/tests/emulator/test_builder.py +++ b/tests/emulator/test_builder.py @@ -63,7 +63,7 @@ def test_emulator_builder_build(mock_emulator_instance, mock_selene_sim): # Check that EmulatorInstance was created correctly mock_emulator_instance.assert_called_once_with( - _instance=mock_selene_instance, _n_qubits=n_qubits + _instance=mock_selene_instance, _n_qubits=n_qubits, _arg_specs=() ) assert result == mock_emulator_result @@ -114,7 +114,7 @@ def test_emulator_builder_build_with_custom_parameters( # Check that EmulatorInstance was created correctly mock_emulator_instance.assert_called_once_with( - _instance=mock_selene_instance, _n_qubits=n_qubits + _instance=mock_selene_instance, _n_qubits=n_qubits, _arg_specs=() ) assert result == mock_emulator_result @@ -219,3 +219,39 @@ def test_emulator_builder_reuse(): assert calls[1].kwargs["name"] == "reusable" assert calls[0].kwargs["verbose"] is True assert calls[1].kwargs["verbose"] is True + + +def test_link_utility_appends(): + """link_utility appends utilities, preserving immutability.""" + util1 = Mock() + util2 = Mock() + + builder = EmulatorBuilder() + assert builder._utilities is None + + b1 = builder.link_utility(util1) + assert b1._utilities == [util1] + # original is unchanged + assert builder._utilities is None + + b2 = b1.link_utility(util2) + assert b2._utilities == [util1, util2] + assert b1._utilities == [util1] + + +@patch("guppylang.emulator.builder.selene_sim") +@patch("guppylang.emulator.builder.EmulatorInstance") +def test_build_passes_arg_specs(mock_emulator_instance, mock_selene_sim): + """build forwards arg_specs to the EmulatorInstance.""" + from guppylang.emulator._args import EntrypointArgSpec + from guppylang_internals.tys.builtin import int_type + + mock_selene_instance = Mock() + mock_selene_sim.build.return_value = mock_selene_instance + + specs = (EntrypointArgSpec("k", int_type()),) + EmulatorBuilder().build(Mock(), 2, arg_specs=specs) + + mock_emulator_instance.assert_called_once_with( + _instance=mock_selene_instance, _n_qubits=2, _arg_specs=specs + ) diff --git a/tests/emulator/test_instance.py b/tests/emulator/test_instance.py index a94b4c198..6ffbcf6fe 100644 --- a/tests/emulator/test_instance.py +++ b/tests/emulator/test_instance.py @@ -5,6 +5,7 @@ import datetime from unittest.mock import Mock, patch +import pytest from guppylang.emulator.instance import EmulatorInstance from guppylang.emulator.result import EmulatorResult from selene_depolarizing_error_model_plugin import DepolarizingPlugin @@ -435,3 +436,79 @@ def test_emulator_instance_full_configuration_workflow(): assert isinstance(call_kwargs["simulator"], Quest) mock_result.assert_called_once_with(mock_result_stream) + + +def _arg_instance(run_shots_side_effect=None): + """An EmulatorInstance with a float arg `theta` and a mocked selene instance.""" + from guppylang.emulator._args import EntrypointArgSpec + from guppylang_internals.tys.ty import NumericType + + mock_selene_instance = Mock() + if run_shots_side_effect is not None: + mock_selene_instance.run_shots.side_effect = run_shots_side_effect + else: + mock_selene_instance.run_shots.return_value = iter([]) + specs = (EntrypointArgSpec("theta", NumericType(NumericType.Kind.Float)),) + instance = EmulatorInstance( + _instance=mock_selene_instance, _n_qubits=1, _arg_specs=specs + ) + return instance, mock_selene_instance + + +def test_run_rejects_kwargs_when_no_args(): + from guppylang.emulator._args import EntrypointArgValueError + + instance = EmulatorInstance(_instance=Mock(), _n_qubits=1) + with pytest.raises(EntrypointArgValueError, match="no runtime arguments"): + instance.run(theta=1.0) + + +def test_run_requires_args_when_expected(): + from guppylang.emulator._args import EntrypointArgValueError + + instance, _ = _arg_instance() + with pytest.raises(EntrypointArgValueError, match=r"Missing.*`theta`"): + instance.run() + + +def test_run_sets_argprovider_env(): + """run() activates the ArgProvider (env var set) while running shots.""" + import os + + seen = {} + + def capture(**kwargs): + seen["env"] = os.environ.get("SELENE_ARGREADER_INPUT_FILE") + return iter([]) + + instance, mock_selene = _arg_instance(run_shots_side_effect=capture) + instance.run(theta=1.5) + + assert seen["env"] is not None + # provider cleans up afterwards + assert "SELENE_ARGREADER_INPUT_FILE" not in os.environ + mock_selene.run_shots.assert_called_once() + + +def test_run_per_shot_runs_len_shots(): + instance, mock_selene = _arg_instance() + instance.run_per_shot([{"theta": 1.0}, {"theta": 2.0}, {"theta": 3.0}]) + # n_shots should be overridden to the number of per-shot records + assert mock_selene.run_shots.call_args.kwargs["n_shots"] == 3 + + +def test_run_per_shot_rejects_shot_offset(): + from guppylang.emulator._args import EntrypointArgValueError + + instance, _ = _arg_instance() + instance = instance.with_shot_offset(5) + with pytest.raises(EntrypointArgValueError, match="shot offset"): + instance.run_per_shot([{"theta": 1.0}]) + + +def test_run_per_shot_rejects_when_no_args(): + from guppylang.emulator._args import EntrypointArgValueError + + instance = EmulatorInstance(_instance=Mock(), _n_qubits=1) + with pytest.raises(EntrypointArgValueError, match="no runtime arguments"): + instance.run_per_shot([{"theta": 1.0}]) diff --git a/tests/error/misc_errors/entrypoint_unsupported_arg.err b/tests/error/misc_errors/entrypoint_unsupported_arg.err new file mode 100644 index 000000000..253d9c5dc --- /dev/null +++ b/tests/error/misc_errors/entrypoint_unsupported_arg.err @@ -0,0 +1,9 @@ +Error: Unsupported entrypoint argument type (at $FILE:6:8) + | +4 | +5 | @guppy +6 | def foo(x: nat) -> None: + | ^^^^^^ Unsigned `nat` arguments are not supported. Use a signed + | `int` argument and convert in your program if needed. + +Guppy compilation failed due to 1 previous error diff --git a/tests/error/misc_errors/entrypoint_unsupported_arg.py b/tests/error/misc_errors/entrypoint_unsupported_arg.py new file mode 100644 index 000000000..c4fde38ee --- /dev/null +++ b/tests/error/misc_errors/entrypoint_unsupported_arg.py @@ -0,0 +1,10 @@ +from guppylang.decorator import guppy +from guppylang.std.num import nat + + +@guppy +def foo(x: nat) -> None: + pass + + +foo.emulator(1) diff --git a/tests/integration/test_emulator_args.py b/tests/integration/test_emulator_args.py new file mode 100644 index 000000000..0725940ac --- /dev/null +++ b/tests/integration/test_emulator_args.py @@ -0,0 +1,101 @@ +"""End-to-end emulator tests for entrypoint runtime arguments. + +These require a build of ``tket_exts`` and the selene compiler that support the +``tket.argreader`` extension. When those are unavailable (e.g. running against a +published release that predates argreader support) the whole module is skipped. +""" + +from __future__ import annotations + +import functools + +import pytest + +from guppylang import guppy +from guppylang.emulator import EmulatorResult +from guppylang.std.builtins import array, result + + +@functools.cache +def _args_supported() -> bool: + """Probe whether the toolchain can build & run an entrypoint with arguments.""" + try: + import tket_exts + + if not hasattr(tket_exts, "argreader"): + return False + + @guppy + def probe(x: int) -> None: + result("x", x) + + probe.emulator(n_qubits=1).run(x=1) + except Exception: # noqa: BLE001 + return False + return True + + +pytestmark = pytest.mark.skipif( + not _args_supported(), + reason="toolchain does not support the tket.argreader extension", +) + + +def test_constant_args() -> None: + @guppy + def main(theta: float, k: int) -> None: + result("doubled", theta * 2.0) + result("k1", k + 1) + + res = main.emulator(n_qubits=1).run(theta=1.5, k=3) + assert res == EmulatorResult([[("doubled", 3.0), ("k1", 4)]]) + + +def test_constant_args_broadcast_over_shots() -> None: + @guppy + def main(theta: float) -> None: + result("theta", theta) + + res = main.emulator(n_qubits=1).with_shots(3).run(theta=2.0) + assert res == EmulatorResult([[("theta", 2.0)]] * 3) + + +def test_per_shot_args() -> None: + @guppy + def main(theta: float, k: int) -> None: + result("doubled", theta * 2.0) + result("k1", k + 1) + + res = main.emulator(n_qubits=1).run_per_shot( + [ + {"theta": 1.0, "k": 10}, + {"theta": 2.5, "k": 20}, + {"theta": 4.0, "k": 30}, + ] + ) + assert res == EmulatorResult( + [ + [("doubled", 2.0), ("k1", 11)], + [("doubled", 5.0), ("k1", 21)], + [("doubled", 8.0), ("k1", 31)], + ] + ) + + +def test_array_arg() -> None: + @guppy + def main(xs: array[float, 3]) -> None: + result("first", xs[0]) + result("third", xs[2]) + + res = main.emulator(n_qubits=1).run(xs=[1.0, 2.0, 3.0]) + assert res == EmulatorResult([[("first", 1.0), ("third", 3.0)]]) + + +def test_bool_arg() -> None: + @guppy + def main(flag: bool) -> None: + result("flag", flag) + + res = main.emulator(n_qubits=1).run(flag=True) + assert res == EmulatorResult([[("flag", True)]]) diff --git a/tests/integration/test_notebooks.py b/tests/integration/test_notebooks.py index 4e4809d4d..0f3407961 100644 --- a/tests/integration/test_notebooks.py +++ b/tests/integration/test_notebooks.py @@ -7,12 +7,6 @@ (Path(__file__).parent.parent.parent / "examples").glob("*.ipynb") ) -# Remove long running QAOA notebook from C.I. tests -# Hopefully we can add it back in when we can speed it up. -# https://github.com/Quantinuum/guppylang/issues/1546 -example_notebooks.remove( - Path(__file__).parent.parent.parent / "examples" / "qaoa_maxcut_example.ipynb" -) # Turn paths into strings, otherwise pytest doesn't display the names example_notebooks = [str(f) for f in example_notebooks]