From 0d4d4c4ce46beeb2e67c451e11250f42945e16fa Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Wed, 21 Aug 2024 15:01:46 -0400
Subject: [PATCH 01/20] change: Use multiprocessing Pool rather than
 ProcessPoolExecutor

---
 src/braket/simulator_v2/base_simulator_v2.py | 40 +++++++-------------
 1 file changed, 13 insertions(+), 27 deletions(-)

diff --git a/src/braket/simulator_v2/base_simulator_v2.py b/src/braket/simulator_v2/base_simulator_v2.py
index 3eb7801..58aa413 100644
--- a/src/braket/simulator_v2/base_simulator_v2.py
+++ b/src/braket/simulator_v2/base_simulator_v2.py
@@ -1,6 +1,6 @@
 import sys
 from collections.abc import Sequence
-from concurrent.futures import ProcessPoolExecutor, wait
+from multiprocessing.pool import Pool
 from typing import List, Optional, Union
 
 import numpy as np
@@ -105,19 +105,12 @@ def translate_and_run_multiple(
 class BaseLocalSimulatorV2(BaseLocalSimulator):
     def __init__(self, device: str):
         self._device = device
-        executor = ProcessPoolExecutor(max_workers=1, initializer=setup_julia)
-
-        def no_op():
-            pass
-
-        # trigger worker creation here, because workers are created
-        # on an as-needed basis, *not* when the executor is created
-        f = executor.submit(no_op)
-        wait([f])
-        self._executor = executor
+        pool = Pool(1, initializer=setup_julia)
+        self._executor = pool
 
     def __del__(self):
-        self._executor.shutdown(wait=False)
+        self._executor.terminate()
+        del self._executor
 
     def initialize_simulation(self, **kwargs):
         return
@@ -143,14 +136,11 @@ def run_openqasm(
                 as a result type when shots=0. Or, if StateVector and Amplitude result types
                 are requested when shots>0.
         """
-        f = self._executor.submit(
-            translate_and_run,
-            self._device,
-            openqasm_ir,
-            shots,
-        )
         try:
-            jl_result = f.result()
+            jl_result = self._executor.apply(
+                translate_and_run,
+                [self._device, openqasm_ir, shots],
+            )
         except Exception as e:
             _handle_julia_error(e)
 
@@ -183,15 +173,11 @@ def run_multiple(
             list[GateModelTaskResult]: A list of result objects, with the ith object being
             the result of the ith program.
         """
-        f = self._executor.submit(
-            translate_and_run_multiple,
-            self._device,
-            programs,
-            shots,
-            inputs,
-        )
         try:
-            jl_results = f.result()
+            jl_results = self._executor.apply(
+                translate_and_run_multiple,
+                [self._device, programs, shots, inputs],
+            )
         except Exception as e:
             _handle_julia_error(e)
 

From 80c67f79490f43e677ed062c08d6435df6c80d1d Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Thu, 22 Aug 2024 13:58:12 -0400
Subject: [PATCH 02/20] fix: No sigterm screaming

---
 src/braket/juliapkg.json                     |  2 +-
 src/braket/simulator_v2/__init__.py          |  1 -
 src/braket/simulator_v2/base_simulator_v2.py | 98 ++++++++++++--------
 src/braket/simulator_v2/julia_import.py      | 72 --------------
 tox.ini                                      |  4 +-
 5 files changed, 64 insertions(+), 113 deletions(-)

diff --git a/src/braket/juliapkg.json b/src/braket/juliapkg.json
index 6e35a4a..33c0432 100644
--- a/src/braket/juliapkg.json
+++ b/src/braket/juliapkg.json
@@ -3,7 +3,7 @@
     "packages": {
         "BraketSimulator": {
             "uuid": "76d27892-9a0b-406c-98e4-7c178e9b3dff",
-            "version": "0.0.3"
+            "dev": "True"
         },
         "JSON3": {
             "uuid": "0f8b85d8-7281-11e9-16c2-39a750bddbf1",
diff --git a/src/braket/simulator_v2/__init__.py b/src/braket/simulator_v2/__init__.py
index ef2ca74..92dc40a 100644
--- a/src/braket/simulator_v2/__init__.py
+++ b/src/braket/simulator_v2/__init__.py
@@ -1,7 +1,6 @@
 from braket.simulator_v2.density_matrix_simulator_v2 import (  # noqa: F401
     DensityMatrixSimulatorV2,
 )
-from braket.simulator_v2.julia_import import setup_julia  # noqa: F401
 from braket.simulator_v2.state_vector_simulator_v2 import (  # noqa: F401
     StateVectorSimulatorV2,
 )
diff --git a/src/braket/simulator_v2/base_simulator_v2.py b/src/braket/simulator_v2/base_simulator_v2.py
index 58aa413..aaa3348 100644
--- a/src/braket/simulator_v2/base_simulator_v2.py
+++ b/src/braket/simulator_v2/base_simulator_v2.py
@@ -2,14 +2,52 @@
 from collections.abc import Sequence
 from multiprocessing.pool import Pool
 from typing import List, Optional, Union
-
+import atexit
+import json
 import numpy as np
 from braket.default_simulator.simulator import BaseLocalSimulator
 from braket.ir.jaqcd import DensityMatrix, Probability, StateVector
 from braket.ir.openqasm import Program as OpenQASMProgram
 from braket.task_result import GateModelTaskResult
 
-from braket.simulator_v2.julia_import import setup_julia
+def setup_julia():
+    import os
+    import sys
+    import json
+    import warnings
+
+    # don't reimport if we don't have to
+    if "juliacall" in sys.modules:
+        os.environ["PYTHON_JULIACALL_HANDLE_SIGNALS"] = "yes"
+        return sys.modules["juliacall"].Main
+    else:
+        for k, default in (
+            ("PYTHON_JULIACALL_HANDLE_SIGNALS", "yes"),
+            ("PYTHON_JULIACALL_THREADS", "auto"),
+            ("PYTHON_JULIACALL_OPTLEVEL", "3"),
+            # let the user's Conda/Pip handle installing things
+            ("JULIA_CONDAPKG_BACKEND", "Null"),
+        ):
+            os.environ[k] = os.environ.get(k, default)
+        # install Julia and any packages as needed
+        import juliacall
+
+        jl = juliacall.Main
+        jl.seval("using JSON3, BraketSimulator")
+        jl_yield = getattr(jl, "yield")
+        jl_yield()
+        # don't waste time looking for packages
+        # which should already be present after this
+        os.environ["PYTHON_JULIAPKG_OFFLINE"] = "no"
+
+        return jl
+
+def exit_julia():
+    import sys
+    jl = sys.modules["juliacall"].Main
+    jl_yield = getattr(jl, "yield")
+    jl_yield()
+    return
 
 
 def _handle_julia_error(error):
@@ -32,33 +70,23 @@ def _handle_julia_error(error):
 def translate_and_run(
     device_id: str, openqasm_ir: OpenQASMProgram, shots: int = 0
 ) -> str:
-    jl = setup_julia()
-    jl_shots = shots
-    jl_inputs = (
-        jl.Dict[jl.String, jl.Any](
-            jl.Pair(jl.convert(jl.String, k), jl.convert(jl.Any, v))
-            for (k, v) in openqasm_ir.inputs.items()
-        )
-        if openqasm_ir.inputs
-        else jl.Dict[jl.String, jl.Any]()
-    )
-    if device_id == "braket_sv_v2":
-        device = jl.BraketSimulator.StateVectorSimulator(0, 0)
-    elif device_id == "braket_dm_v2":
-        device = jl.BraketSimulator.DensityMatrixSimulator(0, 0)
-
+    jl        = setup_julia()
+    jl_shots  = shots
+    jl_inputs = json.dumps(openqasm_ir.inputs) if openqasm_ir.inputs else json.dumps({})
+    py_result = ""
     try:
-        result = jl.BraketSimulator.simulate._jl_call_nogil(
-            device,
+        result = jl.BraketSimulator.simulate(
+            device_id,
             openqasm_ir.source,
             jl_inputs,
             jl_shots,
         )
         py_result = str(result)
-        return py_result
     except Exception as e:
         _handle_julia_error(e)
 
+    return py_result
+
 
 def translate_and_run_multiple(
     device_id: str,
@@ -67,7 +95,7 @@ def translate_and_run_multiple(
     inputs: Optional[Union[dict, Sequence[dict]]] = {},
 ) -> List[str]:
     jl = setup_julia()
-    irs = jl.Vector[jl.String]()
+    irs = [program.source for program in programs]
     is_single_input = isinstance(inputs, dict) or len(inputs) == 1
     py_inputs = {}
     if (is_single_input and isinstance(inputs, dict)) or not is_single_input:
@@ -76,22 +104,18 @@ def translate_and_run_multiple(
         py_inputs = [inputs[0].copy() for _ in range(len(programs))]
     else:
         py_inputs = inputs
-    jl_inputs = jl.Vector[jl.Dict[jl.String, jl.Any]]()
+    full_inputs = []
     for p_ix, program in enumerate(programs):
-        irs.append(program.source)
         if program.inputs:
-            jl_inputs.append(program.inputs | py_inputs[p_ix])
+            full_inputs.append(program.inputs | py_inputs[p_ix])
         else:
-            jl_inputs.append(py_inputs[p_ix])
+            full_inputs.append(py_inputs[p_ix])
 
-    if device_id == "braket_sv_v2":
-        device = jl.BraketSimulator.StateVectorSimulator(0, 0)
-    elif device_id == "braket_dm_v2":
-        device = jl.BraketSimulator.DensityMatrixSimulator(0, 0)
+    jl_inputs = json.dumps(full_inputs)
 
     try:
-        results = jl.BraketSimulator.simulate._jl_call_nogil(
-            device,
+        results = jl.BraketSimulator.simulate(
+            device_id,
             irs,
             jl_inputs,
             shots,
@@ -105,13 +129,11 @@ def translate_and_run_multiple(
 class BaseLocalSimulatorV2(BaseLocalSimulator):
     def __init__(self, device: str):
         self._device = device
-        pool = Pool(1, initializer=setup_julia)
+        pool = Pool(processes=1)
+        pool.apply(setup_julia)
         self._executor = pool
-
-    def __del__(self):
-        self._executor.terminate()
-        del self._executor
-
+        atexit.register(self._executor.close)
+    
     def initialize_simulation(self, **kwargs):
         return
 
@@ -145,6 +167,7 @@ def run_openqasm(
             _handle_julia_error(e)
 
         result = GateModelTaskResult.parse_raw_schema(jl_result)
+        jl_result = None
         result.additionalMetadata.action = openqasm_ir
 
         # attach the result types
@@ -184,6 +207,7 @@ def run_multiple(
         results = [
             GateModelTaskResult.parse_raw_schema(jl_result) for jl_result in jl_results
         ]
+        jl_results = None
         for p_ix, program in enumerate(programs):
             results[p_ix].additionalMetadata.action = program
 
diff --git a/src/braket/simulator_v2/julia_import.py b/src/braket/simulator_v2/julia_import.py
index 74ea565..e69de29 100644
--- a/src/braket/simulator_v2/julia_import.py
+++ b/src/braket/simulator_v2/julia_import.py
@@ -1,72 +0,0 @@
-def setup_julia():
-    import os
-    import sys
-    import warnings
-
-    # Check if JuliaCall is already loaded, and if so, warn the user
-    # about the relevant environment variables. If not loaded,
-    # set up sensible defaults.
-    # Required to avoid segfaults (https://juliapy.github.io/PythonCall.jl/dev/faq/)
-    if os.environ.get("PYTHON_JULIACALL_HANDLE_SIGNALS", "yes") != "yes":
-        warnings.warn(
-            "`PYTHON_JULIACALL_HANDLE_SIGNALS` environment variable "
-            + "is set to something other than 'yes' or ''. "
-            + "You will experience segfaults if running with Julia multithreading."
-        )
-
-    if os.environ.get("PYTHON_JULIACALL_THREADS", "auto") != "auto":
-        warnings.warn(
-            "`PYTHON_JULIACALL_THREADS` environment variable is set to "
-            + "something other than `auto`, so `amazon-braket-simulator-v2` "
-            + "was not able to set it."
-        )
-
-    for k, default in (
-        ("PYTHON_JULIACALL_HANDLE_SIGNALS", "yes"),
-        ("PYTHON_JULIACALL_THREADS", "auto"),
-        ("PYTHON_JULIACALL_OPTLEVEL", "3"),
-        # let the user's Conda/Pip handle installing things
-        ("JULIA_CONDAPKG_BACKEND", "Null"),
-    ):
-        os.environ[k] = os.environ.get(k, default)
-
-    # don't reimport if we don't have to
-    if "juliacall" in sys.modules:
-        return sys.modules["juliacall"].Main
-    else:
-        # install Julia and any packages as needed
-        os.environ["PYTHON_JULIAPKG_OFFLINE"] = "no"
-        import juliacall
-
-        jl = juliacall.Main
-        jl.seval("using JSON3, BraketSimulator")
-        # trigger top-level precompilation at first import
-        sv = jl.BraketSimulator.StateVectorSimulator(0, 0)
-        dm = jl.BraketSimulator.StateVectorSimulator(0, 0)
-        stock_oq3 = """
-        qubit[2] q;
-        h q[0];
-        cnot q[0], q[1];
-        #pragma braket result state_vector
-        """
-        input_dict = jl.Vector[jl.Dict[jl.String, jl.Any]]()
-        input_dict.append(jl.Dict[jl.String, jl.Any]())
-        irs = jl.Vector[jl.String]()
-        irs.append(stock_oq3)
-        irs.append(stock_oq3)
-        jl.BraketSimulator.simulate._jl_call_nogil(
-            sv, stock_oq3, jl.Dict[jl.String, jl.Any](), 0
-        )
-        jl.BraketSimulator.simulate._jl_call_nogil(sv, irs, input_dict, 0)
-        jl.BraketSimulator.simulate._jl_call_nogil(
-            dm, stock_oq3, jl.Dict[jl.String, jl.Any](), 0
-        )
-        jl.BraketSimulator.simulate._jl_call_nogil(dm, irs, input_dict, 0)
-        # don't waste time looking for packages
-        # which should already be present after this
-        del sv
-        del dm
-        del stock_oq3
-        del input_dict
-        del irs
-        return jl
diff --git a/tox.ini b/tox.ini
index 46576b8..551951f 100644
--- a/tox.ini
+++ b/tox.ini
@@ -10,9 +10,9 @@ allowlist_externals =
     pytest
 setenv =
     PYTHON_JULIACALL_HANDLE_SIGNALS=yes
-    PYTHON_JULIACALL_OPTIMIZE=0
+    PYTHON_JULIAPKG_OFFLINE=yes
 commands =
-    python -c 'import juliacall' # force install of all deps
+    python -c 'import juliacall' # force install of all deps, trigger precompilation
     pytest {posargs} --cov-report term-missing --cov-report html --cov-report xml --cov=braket
 extras = test
 

From 05870ba88ba870bb8e26f113d8288149696024d5 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Thu, 22 Aug 2024 16:12:42 -0400
Subject: [PATCH 03/20] fix: Force close and join at exit

---
 src/braket/simulator_v2/base_simulator_v2.py | 139 +++++--------------
 src/braket/simulator_v2/julia_import.py      |   0
 src/braket/simulator_v2/julia_workers.py     |  78 +++++++++++
 3 files changed, 113 insertions(+), 104 deletions(-)
 delete mode 100644 src/braket/simulator_v2/julia_import.py
 create mode 100644 src/braket/simulator_v2/julia_workers.py

diff --git a/src/braket/simulator_v2/base_simulator_v2.py b/src/braket/simulator_v2/base_simulator_v2.py
index aaa3348..5fe958d 100644
--- a/src/braket/simulator_v2/base_simulator_v2.py
+++ b/src/braket/simulator_v2/base_simulator_v2.py
@@ -1,8 +1,6 @@
-import sys
+import time
 from collections.abc import Sequence
-from multiprocessing.pool import Pool
 from typing import List, Optional, Union
-import atexit
 import json
 import numpy as np
 from braket.default_simulator.simulator import BaseLocalSimulator
@@ -10,12 +8,16 @@
 from braket.ir.openqasm import Program as OpenQASMProgram
 from braket.task_result import GateModelTaskResult
 
+from braket.simulator_v2.julia_workers import translate_and_run, translate_and_run_multiple, _handle_julia_error
+
+from multiprocessing.pool import Pool
+import atexit
+
+__JULIA_POOL__ = None
+
 def setup_julia():
-    import os
     import sys
-    import json
-    import warnings
-
+    import os
     # don't reimport if we don't have to
     if "juliacall" in sys.modules:
         os.environ["PYTHON_JULIACALL_HANDLE_SIGNALS"] = "yes"
@@ -30,110 +32,37 @@ def setup_julia():
         ):
             os.environ[k] = os.environ.get(k, default)
         # install Julia and any packages as needed
+        os.environ["PYTHON_JULIAPKG_OFFLINE"] = "yes"
         import juliacall
 
         jl = juliacall.Main
         jl.seval("using JSON3, BraketSimulator")
-        jl_yield = getattr(jl, "yield")
-        jl_yield()
-        # don't waste time looking for packages
-        # which should already be present after this
-        os.environ["PYTHON_JULIAPKG_OFFLINE"] = "no"
-
+        stock_oq3 = """
+        OPENQASM 3.0;
+        qubit[2] q;
+        h q[0];
+        cnot q;
+        #pragma braket result probability 
+        """
+        jl.BraketSimulator.simulate("braket_sv_v2", stock_oq3, '{}', 0)
+        jl.BraketSimulator.simulate("braket_dm_v2", stock_oq3, '{}', 0)
         return jl
 
-def exit_julia():
-    import sys
-    jl = sys.modules["juliacall"].Main
-    jl_yield = getattr(jl, "yield")
-    jl_yield()
+def setup_pool():
+    global __JULIA_POOL__
+    __JULIA_POOL__ = Pool(processes=1)
+    __JULIA_POOL__.apply(setup_julia)
+    atexit.register(__JULIA_POOL__.join)
+    atexit.register(__JULIA_POOL__.close)
     return
 
-
-def _handle_julia_error(error):
-    # we don't import `JuliaError` explicitly here to avoid
-    # having to import juliacall on the main thread. we need
-    # to call *this* function on that thread in case getting
-    # the result from the submitted Future raises an exception
-    if type(error).__name__ == "JuliaError":
-        python_exception = getattr(error.exception, "alternate_type", None)
-        if python_exception is None:
-            py_error = error
-        else:
-            class_val = getattr(sys.modules["builtins"], str(python_exception))
-            py_error = class_val(str(error.exception.message))
-        raise py_error
-    else:
-        raise error
-
-
-def translate_and_run(
-    device_id: str, openqasm_ir: OpenQASMProgram, shots: int = 0
-) -> str:
-    jl        = setup_julia()
-    jl_shots  = shots
-    jl_inputs = json.dumps(openqasm_ir.inputs) if openqasm_ir.inputs else json.dumps({})
-    py_result = ""
-    try:
-        result = jl.BraketSimulator.simulate(
-            device_id,
-            openqasm_ir.source,
-            jl_inputs,
-            jl_shots,
-        )
-        py_result = str(result)
-    except Exception as e:
-        _handle_julia_error(e)
-
-    return py_result
-
-
-def translate_and_run_multiple(
-    device_id: str,
-    programs: Sequence[OpenQASMProgram],
-    shots: Optional[int] = 0,
-    inputs: Optional[Union[dict, Sequence[dict]]] = {},
-) -> List[str]:
-    jl = setup_julia()
-    irs = [program.source for program in programs]
-    is_single_input = isinstance(inputs, dict) or len(inputs) == 1
-    py_inputs = {}
-    if (is_single_input and isinstance(inputs, dict)) or not is_single_input:
-        py_inputs = [inputs.copy() for _ in range(len(programs))]
-    elif is_single_input and not isinstance(inputs, dict):
-        py_inputs = [inputs[0].copy() for _ in range(len(programs))]
-    else:
-        py_inputs = inputs
-    full_inputs = []
-    for p_ix, program in enumerate(programs):
-        if program.inputs:
-            full_inputs.append(program.inputs | py_inputs[p_ix])
-        else:
-            full_inputs.append(py_inputs[p_ix])
-
-    jl_inputs = json.dumps(full_inputs)
-
-    try:
-        results = jl.BraketSimulator.simulate(
-            device_id,
-            irs,
-            jl_inputs,
-            shots,
-        )
-        py_results = [str(result) for result in results]
-    except Exception as e:
-        _handle_julia_error(e)
-    return py_results
-
-
 class BaseLocalSimulatorV2(BaseLocalSimulator):
     def __init__(self, device: str):
+        global __JULIA_POOL__
+        if __JULIA_POOL__ is None:
+            setup_pool()
         self._device = device
-        pool = Pool(processes=1)
-        pool.apply(setup_julia)
-        self._executor = pool
-        atexit.register(self._executor.close)
-    
+
     def initialize_simulation(self, **kwargs):
         return
 
@@ -158,15 +87,16 @@ def run_openqasm(
                 as a result type when shots=0. Or, if StateVector and Amplitude result types
                 are requested when shots>0.
         """
+        global __JULIA_POOL__
         try:
-            jl_result = self._executor.apply(
+            jl_result = __JULIA_POOL__.apply(
                 translate_and_run,
                 [self._device, openqasm_ir, shots],
             )
         except Exception as e:
             _handle_julia_error(e)
 
-        result = GateModelTaskResult.parse_raw_schema(jl_result)
+        result = GateModelTaskResult(**json.loads(jl_result))
         jl_result = None
         result.additionalMetadata.action = openqasm_ir
 
@@ -196,8 +126,9 @@ def run_multiple(
             list[GateModelTaskResult]: A list of result objects, with the ith object being
             the result of the ith program.
         """
+        global __JULIA_POOL__
         try:
-            jl_results = self._executor.apply(
+            jl_results = __JULIA_POOL__.apply(
                 translate_and_run_multiple,
                 [self._device, programs, shots, inputs],
             )
@@ -205,7 +136,7 @@ def run_multiple(
             _handle_julia_error(e)
 
         results = [
-            GateModelTaskResult.parse_raw_schema(jl_result) for jl_result in jl_results
+            GateModelTaskResult(**json.loads(jl_result)) for jl_result in jl_results
         ]
         jl_results = None
         for p_ix, program in enumerate(programs):
diff --git a/src/braket/simulator_v2/julia_import.py b/src/braket/simulator_v2/julia_import.py
deleted file mode 100644
index e69de29..0000000
diff --git a/src/braket/simulator_v2/julia_workers.py b/src/braket/simulator_v2/julia_workers.py
new file mode 100644
index 0000000..e795667
--- /dev/null
+++ b/src/braket/simulator_v2/julia_workers.py
@@ -0,0 +1,78 @@
+from braket.ir.openqasm import Program as OpenQASMProgram
+from collections.abc import Sequence
+import json
+import sys
+from typing import List, Optional, Union
+
+def _handle_julia_error(error):
+    import sys
+    if isinstance(error, sys.modules["juliacall"].JuliaError):
+        python_exception = getattr(error.exception, "alternate_type", None)
+        if python_exception is None:
+            py_error = error
+        else:
+            class_val = getattr(sys.modules["builtins"], str(python_exception))
+            py_error = class_val(str(error.exception.message))
+        raise py_error
+    else:
+        raise error
+    return
+
+
+def translate_and_run(
+    device_id: str, openqasm_ir: OpenQASMProgram, shots: int = 0
+) -> str:
+    jl        = sys.modules["juliacall"].Main
+    jl_shots  = shots
+    jl_inputs = json.dumps(openqasm_ir.inputs) if openqasm_ir.inputs else '{}'
+    py_result = ""
+    try:
+        result = jl.BraketSimulator.simulate(
+            device_id,
+            openqasm_ir.source,
+            jl_inputs,
+            jl_shots,
+        )
+        py_result = str(result)
+    except Exception as e:
+        _handle_julia_error(e)
+
+    return py_result
+
+
+def translate_and_run_multiple(
+    device_id: str,
+    programs: Sequence[OpenQASMProgram],
+    shots: Optional[int] = 0,
+    inputs: Optional[Union[dict, Sequence[dict]]] = {},
+) -> List[str]:
+    jl  = sys.modules["juliacall"].Main
+    irs = [program.source for program in programs]
+    is_single_input = isinstance(inputs, dict) or len(inputs) == 1
+    py_inputs = {}
+    if (is_single_input and isinstance(inputs, dict)) or not is_single_input:
+        py_inputs = [inputs.copy() for _ in range(len(programs))]
+    elif is_single_input and not isinstance(inputs, dict):
+        py_inputs = [inputs[0].copy() for _ in range(len(programs))]
+    else:
+        py_inputs = inputs
+    full_inputs = []
+    for p_ix, program in enumerate(programs):
+        if program.inputs:
+            full_inputs.append(program.inputs | py_inputs[p_ix])
+        else:
+            full_inputs.append(py_inputs[p_ix])
+
+    jl_inputs = json.dumps(full_inputs)
+
+    try:
+        results = jl.BraketSimulator.simulate(
+            device_id,
+            irs,
+            jl_inputs,
+            shots,
+        )
+        py_results = [str(result) for result in results]
+    except Exception as e:
+        _handle_julia_error(e)
+    return py_results

From 58ccd818988f6020e4761e4bc603153b81e9e24f Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Fri, 23 Aug 2024 18:16:41 -0400
Subject: [PATCH 04/20] fix: Faster

---
 src/braket/simulator_v2/base_simulator_v2.py | 25 +++++++++++++++++---
 src/braket/simulator_v2/julia_workers.py     |  6 ++---
 2 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/src/braket/simulator_v2/base_simulator_v2.py b/src/braket/simulator_v2/base_simulator_v2.py
index 5fe958d..3a31379 100644
--- a/src/braket/simulator_v2/base_simulator_v2.py
+++ b/src/braket/simulator_v2/base_simulator_v2.py
@@ -37,15 +37,34 @@ def setup_julia():
 
         jl = juliacall.Main
         jl.seval("using JSON3, BraketSimulator")
-        stock_oq3 = """
+        sv_stock_oq3 = """
         OPENQASM 3.0;
+        input float theta; 
         qubit[2] q;
         h q[0];
         cnot q;
+        x q[0];
+        xx(theta) q;
+        yy(theta) q;
+        zz(theta) q;
+        #pragma braket result expectation z(q[0]) 
+        """
+        dm_stock_oq3 = """
+        OPENQASM 3.0;
+        input float theta; 
+        qubit[2] q;
+        h q[0];
+        x q[0];
+        cnot q;
+        xx(theta) q;
+        yy(theta) q;
+        zz(theta) q;
         #pragma braket result probability 
         """
-        jl.BraketSimulator.simulate("braket_sv_v2", stock_oq3, '{}', 0)
-        jl.BraketSimulator.simulate("braket_dm_v2", stock_oq3, '{}', 0)
+        r = jl.BraketSimulator.simulate("braket_sv_v2", sv_stock_oq3, '{\"theta\": 0.1}', 0)
+        jl.JSON3.write(r)
+        r = jl.BraketSimulator.simulate("braket_dm_v2", dm_stock_oq3, '{\"theta\": 0.1}', 0)
+        jl.JSON3.write(r)
         return jl
 
 def setup_pool():
diff --git a/src/braket/simulator_v2/julia_workers.py b/src/braket/simulator_v2/julia_workers.py
index e795667..caa4e82 100644
--- a/src/braket/simulator_v2/julia_workers.py
+++ b/src/braket/simulator_v2/julia_workers.py
@@ -1,4 +1,5 @@
 from braket.ir.openqasm import Program as OpenQASMProgram
+from braket.task_result import ResultTypeValue
 from collections.abc import Sequence
 import json
 import sys
@@ -25,7 +26,6 @@ def translate_and_run(
     jl        = sys.modules["juliacall"].Main
     jl_shots  = shots
     jl_inputs = json.dumps(openqasm_ir.inputs) if openqasm_ir.inputs else '{}'
-    py_result = ""
     try:
         result = jl.BraketSimulator.simulate(
             device_id,
@@ -33,11 +33,11 @@ def translate_and_run(
             jl_inputs,
             jl_shots,
         )
-        py_result = str(result)
+
     except Exception as e:
         _handle_julia_error(e)
 
-    return py_result
+    return result
 
 
 def translate_and_run_multiple(

From 8fd33407ad6ba6e34e281aebcb035363e8fce6a5 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Mon, 26 Aug 2024 15:50:03 -0400
Subject: [PATCH 05/20] fix: handle julia error in serializable way

---
 src/braket/simulator_v2/julia_workers.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/braket/simulator_v2/julia_workers.py b/src/braket/simulator_v2/julia_workers.py
index caa4e82..9298212 100644
--- a/src/braket/simulator_v2/julia_workers.py
+++ b/src/braket/simulator_v2/julia_workers.py
@@ -10,7 +10,8 @@ def _handle_julia_error(error):
     if isinstance(error, sys.modules["juliacall"].JuliaError):
         python_exception = getattr(error.exception, "alternate_type", None)
         if python_exception is None:
-            py_error = error
+            # convert to RuntimeError as JuliaError can't be serialized
+            py_error = RuntimeError(f"Unable to unwrap internal Julia exception. Exception message: {str(error.exception.message)}")
         else:
             class_val = getattr(sys.modules["builtins"], str(python_exception))
             py_error = class_val(str(error.exception.message))

From 5f0a2d1d9b6a0f2eaa84618f8c2ca616600bfbb0 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Mon, 26 Aug 2024 15:50:18 -0400
Subject: [PATCH 06/20] change: Add benchmark workflow to CI

---
 .github/workflows/benchmark.yml | 46 +++++++++++++++++++++++++++++++++
 1 file changed, 46 insertions(+)
 create mode 100644 .github/workflows/benchmark.yml

diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
new file mode 100644
index 0000000..f61d60f
--- /dev/null
+++ b/.github/workflows/benchmark.yml
@@ -0,0 +1,46 @@
+name: Benchmark
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+
+jobs:
+  benchmark:
+    runs-on: ubuntu-latest
+    timeout-minutes: 30
+    steps:
+    - uses: actions/checkout@v4
+    - name: Install juliaup
+      uses: julia-actions/install-juliaup@v2.1.2
+      with:
+        channel: '1'
+    - name: Update Julia registry 
+      shell: julia --project=. --color=yes {0}
+      run: |
+        using Pkg
+        Pkg.Registry.update()
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: 3.9
+    - name: Install dependencies
+      run: |
+        pip install pytest pytest-benchmark pytest-xdist juliacall
+        pip install -e . # to put juliapkg.json in sys.path
+        python -c 'import juliacall' # force install of all deps
+    - name: Benchmark
+      run: |
+        pytest -n 0 benchmark/benchmark.py --benchmark-json benchmark/output.json
+    - name: Store benchmark result
+      uses: benchmark-action/github-action-benchmark@v1
+      with:
+        name: Python Benchmark with pytest-benchmark
+        tool: 'pytest'
+        output-file-path: benchmark/output.json
+        github-token: ${{ secrets.GITHUB_TOKEN }}
+        auto-push: true
+        # Show alert with commit comment on detecting possible performance regression
+        alert-threshold: '200%'
+        comment-on-alert: true
+        fail-on-alert: true

From 88a55d4d422e10cb587589458e4c5fd2007de61e Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Mon, 26 Aug 2024 15:50:28 -0400
Subject: [PATCH 07/20] change: Point to latest unblocking branch

---
 src/braket/juliapkg.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/braket/juliapkg.json b/src/braket/juliapkg.json
index 33c0432..fdaca17 100644
--- a/src/braket/juliapkg.json
+++ b/src/braket/juliapkg.json
@@ -3,7 +3,7 @@
     "packages": {
         "BraketSimulator": {
             "uuid": "76d27892-9a0b-406c-98e4-7c178e9b3dff",
-            "dev": "True"
+            "rev": "ksh/python"
         },
         "JSON3": {
             "uuid": "0f8b85d8-7281-11e9-16c2-39a750bddbf1",

From 7140d2d1ffc15b506bff1fab8fdd26889a241e37 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Mon, 26 Aug 2024 16:02:36 -0400
Subject: [PATCH 08/20] fix: linting

---
 src/braket/simulator_v2/base_simulator_v2.py | 39 +++++++++++++-------
 src/braket/simulator_v2/julia_workers.py     | 21 +++++++----
 2 files changed, 38 insertions(+), 22 deletions(-)

diff --git a/src/braket/simulator_v2/base_simulator_v2.py b/src/braket/simulator_v2/base_simulator_v2.py
index 3a31379..0d0ff85 100644
--- a/src/braket/simulator_v2/base_simulator_v2.py
+++ b/src/braket/simulator_v2/base_simulator_v2.py
@@ -1,23 +1,28 @@
-import time
-from collections.abc import Sequence
-from typing import List, Optional, Union
+import atexit
 import json
+from collections.abc import Sequence
+from multiprocessing.pool import Pool
+from typing import Optional, Union
+
 import numpy as np
 from braket.default_simulator.simulator import BaseLocalSimulator
 from braket.ir.jaqcd import DensityMatrix, Probability, StateVector
 from braket.ir.openqasm import Program as OpenQASMProgram
 from braket.task_result import GateModelTaskResult
 
-from braket.simulator_v2.julia_workers import translate_and_run, translate_and_run_multiple, _handle_julia_error
-
-from multiprocessing.pool import Pool
-import atexit
+from braket.simulator_v2.julia_workers import (
+    _handle_julia_error,
+    translate_and_run,
+    translate_and_run_multiple,
+)
 
 __JULIA_POOL__ = None
 
+
 def setup_julia():
-    import sys
     import os
+    import sys
+
     # don't reimport if we don't have to
     if "juliacall" in sys.modules:
         os.environ["PYTHON_JULIACALL_HANDLE_SIGNALS"] = "yes"
@@ -39,7 +44,7 @@ def setup_julia():
         jl.seval("using JSON3, BraketSimulator")
         sv_stock_oq3 = """
         OPENQASM 3.0;
-        input float theta; 
+        input float theta;
         qubit[2] q;
         h q[0];
         cnot q;
@@ -47,11 +52,11 @@ def setup_julia():
         xx(theta) q;
         yy(theta) q;
         zz(theta) q;
-        #pragma braket result expectation z(q[0]) 
+        #pragma braket result expectation z(q[0])
         """
         dm_stock_oq3 = """
         OPENQASM 3.0;
-        input float theta; 
+        input float theta;
         qubit[2] q;
         h q[0];
         x q[0];
@@ -59,14 +64,19 @@ def setup_julia():
         xx(theta) q;
         yy(theta) q;
         zz(theta) q;
-        #pragma braket result probability 
+        #pragma braket result probability
         """
-        r = jl.BraketSimulator.simulate("braket_sv_v2", sv_stock_oq3, '{\"theta\": 0.1}', 0)
+        r = jl.BraketSimulator.simulate(
+            "braket_sv_v2", sv_stock_oq3, '{"theta": 0.1}', 0
+        )
         jl.JSON3.write(r)
-        r = jl.BraketSimulator.simulate("braket_dm_v2", dm_stock_oq3, '{\"theta\": 0.1}', 0)
+        r = jl.BraketSimulator.simulate(
+            "braket_dm_v2", dm_stock_oq3, '{"theta": 0.1}', 0
+        )
         jl.JSON3.write(r)
         return jl
 
+
 def setup_pool():
     global __JULIA_POOL__
     __JULIA_POOL__ = Pool(processes=1)
@@ -75,6 +85,7 @@ def setup_pool():
     atexit.register(__JULIA_POOL__.close)
     return
 
+
 class BaseLocalSimulatorV2(BaseLocalSimulator):
     def __init__(self, device: str):
         global __JULIA_POOL__
diff --git a/src/braket/simulator_v2/julia_workers.py b/src/braket/simulator_v2/julia_workers.py
index 9298212..d901a2a 100644
--- a/src/braket/simulator_v2/julia_workers.py
+++ b/src/braket/simulator_v2/julia_workers.py
@@ -1,17 +1,22 @@
-from braket.ir.openqasm import Program as OpenQASMProgram
-from braket.task_result import ResultTypeValue
-from collections.abc import Sequence
 import json
 import sys
+from collections.abc import Sequence
 from typing import List, Optional, Union
 
+from braket.ir.openqasm import Program as OpenQASMProgram
+
+
 def _handle_julia_error(error):
     import sys
+
     if isinstance(error, sys.modules["juliacall"].JuliaError):
         python_exception = getattr(error.exception, "alternate_type", None)
         if python_exception is None:
             # convert to RuntimeError as JuliaError can't be serialized
-            py_error = RuntimeError(f"Unable to unwrap internal Julia exception. Exception message: {str(error.exception.message)}")
+            py_error = RuntimeError(
+                "Unable to unwrap internal Julia exception."
+                f"Exception message: {str(error.exception.message)}"
+            )
         else:
             class_val = getattr(sys.modules["builtins"], str(python_exception))
             py_error = class_val(str(error.exception.message))
@@ -24,9 +29,9 @@ def _handle_julia_error(error):
 def translate_and_run(
     device_id: str, openqasm_ir: OpenQASMProgram, shots: int = 0
 ) -> str:
-    jl        = sys.modules["juliacall"].Main
-    jl_shots  = shots
-    jl_inputs = json.dumps(openqasm_ir.inputs) if openqasm_ir.inputs else '{}'
+    jl = sys.modules["juliacall"].Main
+    jl_shots = shots
+    jl_inputs = json.dumps(openqasm_ir.inputs) if openqasm_ir.inputs else "{}"
     try:
         result = jl.BraketSimulator.simulate(
             device_id,
@@ -47,7 +52,7 @@ def translate_and_run_multiple(
     shots: Optional[int] = 0,
     inputs: Optional[Union[dict, Sequence[dict]]] = {},
 ) -> List[str]:
-    jl  = sys.modules["juliacall"].Main
+    jl = sys.modules["juliacall"].Main
     irs = [program.source for program in programs]
     is_single_input = isinstance(inputs, dict) or len(inputs) == 1
     py_inputs = {}

From 509479e798a692b65945364ec1db5911851a1606 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Mon, 26 Aug 2024 16:14:58 -0400
Subject: [PATCH 09/20] fix: Don't turn off juliapkg in tox

---
 tox.ini | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tox.ini b/tox.ini
index 551951f..8b95a6f 100644
--- a/tox.ini
+++ b/tox.ini
@@ -10,7 +10,6 @@ allowlist_externals =
     pytest
 setenv =
     PYTHON_JULIACALL_HANDLE_SIGNALS=yes
-    PYTHON_JULIAPKG_OFFLINE=yes
 commands =
     python -c 'import juliacall' # force install of all deps, trigger precompilation
     pytest {posargs} --cov-report term-missing --cov-report html --cov-report xml --cov=braket

From f550cabd5532d39a9e3dfa134ebff4080f86c670 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <67932820+kshyatt-aws@users.noreply.github.com>
Date: Tue, 27 Aug 2024 13:28:55 -0400
Subject: [PATCH 10/20] Update src/braket/simulator_v2/julia_workers.py

Co-authored-by: Ryan Shaffer <3620100+rmshaffer@users.noreply.github.com>
---
 src/braket/simulator_v2/julia_workers.py | 7 ++-----
 1 file changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/braket/simulator_v2/julia_workers.py b/src/braket/simulator_v2/julia_workers.py
index d901a2a..9f705cc 100644
--- a/src/braket/simulator_v2/julia_workers.py
+++ b/src/braket/simulator_v2/julia_workers.py
@@ -54,14 +54,11 @@ def translate_and_run_multiple(
 ) -> List[str]:
     jl = sys.modules["juliacall"].Main
     irs = [program.source for program in programs]
-    is_single_input = isinstance(inputs, dict) or len(inputs) == 1
     py_inputs = {}
-    if (is_single_input and isinstance(inputs, dict)) or not is_single_input:
+    if len(inputs) > 1 or isinstance(inputs, dict)):
         py_inputs = [inputs.copy() for _ in range(len(programs))]
-    elif is_single_input and not isinstance(inputs, dict):
+    elif len(inputs) == 1:
         py_inputs = [inputs[0].copy() for _ in range(len(programs))]
-    else:
-        py_inputs = inputs
     full_inputs = []
     for p_ix, program in enumerate(programs):
         if program.inputs:

From 3e244c11629fbb0f3f5f4d3c0c617ace73d6ee42 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <67932820+kshyatt-aws@users.noreply.github.com>
Date: Tue, 27 Aug 2024 13:29:12 -0400
Subject: [PATCH 11/20] Update src/braket/simulator_v2/julia_workers.py

Co-authored-by: Ryan Shaffer <3620100+rmshaffer@users.noreply.github.com>
---
 src/braket/simulator_v2/julia_workers.py | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/braket/simulator_v2/julia_workers.py b/src/braket/simulator_v2/julia_workers.py
index 9f705cc..482a7b8 100644
--- a/src/braket/simulator_v2/julia_workers.py
+++ b/src/braket/simulator_v2/julia_workers.py
@@ -49,9 +49,10 @@ def translate_and_run(
 def translate_and_run_multiple(
     device_id: str,
     programs: Sequence[OpenQASMProgram],
-    shots: Optional[int] = 0,
-    inputs: Optional[Union[dict, Sequence[dict]]] = {},
+    shots: int = 0,
+    inputs: Optional[Union[dict, Sequence[dict]]] = None,
 ) -> List[str]:
+    inputs = inputs or {}
     jl = sys.modules["juliacall"].Main
     irs = [program.source for program in programs]
     py_inputs = {}

From 3c6735b2ca164616666f0ae36aae319ec05a706a Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Tue, 27 Aug 2024 13:34:34 -0400
Subject: [PATCH 12/20] fix: one-line pip in benchmark

---
 .github/workflows/benchmark.yml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
index f61d60f..9773895 100644
--- a/.github/workflows/benchmark.yml
+++ b/.github/workflows/benchmark.yml
@@ -26,8 +26,7 @@ jobs:
         python-version: 3.9
     - name: Install dependencies
       run: |
-        pip install pytest pytest-benchmark pytest-xdist juliacall
-        pip install -e . # to put juliapkg.json in sys.path
+        pip install -e .[test] # to put juliapkg.json in sys.path
         python -c 'import juliacall' # force install of all deps
     - name: Benchmark
       run: |

From 716bd9c1e9af277aa4bab76e841b7b9b82255fdf Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Tue, 27 Aug 2024 14:14:03 -0400
Subject: [PATCH 13/20] fix: typo

---
 src/braket/simulator_v2/julia_workers.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/braket/simulator_v2/julia_workers.py b/src/braket/simulator_v2/julia_workers.py
index 482a7b8..989d522 100644
--- a/src/braket/simulator_v2/julia_workers.py
+++ b/src/braket/simulator_v2/julia_workers.py
@@ -56,7 +56,7 @@ def translate_and_run_multiple(
     jl = sys.modules["juliacall"].Main
     irs = [program.source for program in programs]
     py_inputs = {}
-    if len(inputs) > 1 or isinstance(inputs, dict)):
+    if len(inputs) > 1 or isinstance(inputs, dict):
         py_inputs = [inputs.copy() for _ in range(len(programs))]
     elif len(inputs) == 1:
         py_inputs = [inputs[0].copy() for _ in range(len(programs))]

From b62a8f97158805b56e883c821052a9f71830e335 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Tue, 27 Aug 2024 14:15:11 -0400
Subject: [PATCH 14/20] fix: Use benchmark-json option correctly

---
 .github/workflows/benchmark.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
index 9773895..36c09e4 100644
--- a/.github/workflows/benchmark.yml
+++ b/.github/workflows/benchmark.yml
@@ -30,7 +30,7 @@ jobs:
         python -c 'import juliacall' # force install of all deps
     - name: Benchmark
       run: |
-        pytest -n 0 benchmark/benchmark.py --benchmark-json benchmark/output.json
+        pytest -n 0 benchmark/benchmark.py --benchmark-json=benchmark/output.json
     - name: Store benchmark result
       uses: benchmark-action/github-action-benchmark@v1
       with:

From 967dea4bdd96eb01c8adba818d075ee53d382803 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Tue, 27 Aug 2024 14:32:25 -0400
Subject: [PATCH 15/20] change: Add initial output.json

---
 benchmark/output.json | 6379 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 6379 insertions(+)
 create mode 100644 benchmark/output.json

diff --git a/benchmark/output.json b/benchmark/output.json
new file mode 100644
index 0000000..717f68c
--- /dev/null
+++ b/benchmark/output.json
@@ -0,0 +1,6379 @@
+{
+    "machine_info": {
+        "node": "c889f3b9ffb2",
+        "processor": "arm",
+        "machine": "arm64",
+        "python_compiler": "Clang 15.0.0 (clang-1500.1.0.2.5)",
+        "python_implementation": "CPython",
+        "python_implementation_version": "3.10.14",
+        "python_version": "3.10.14",
+        "python_build": [
+            "main",
+            "Mar 19 2024 21:46:16"
+        ],
+        "release": "22.6.0",
+        "system": "Darwin",
+        "cpu": {
+            "python_version": "3.10.14.final.0 (64 bit)",
+            "cpuinfo_version": [
+                9,
+                0,
+                0
+            ],
+            "cpuinfo_version_string": "9.0.0",
+            "arch": "ARM_8",
+            "bits": 64,
+            "count": 10,
+            "arch_string_raw": "arm64",
+            "brand_raw": "Apple M1 Pro"
+        }
+    },
+    "commit_info": {
+        "id": "b62a8f97158805b56e883c821052a9f71830e335",
+        "time": "2024-08-27T14:15:11-04:00",
+        "author_time": "2024-08-27T14:15:11-04:00",
+        "dirty": false,
+        "project": "amazon-braket-julia-simulator",
+        "branch": "ksh/speed"
+    },
+    "benchmarks": [
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-3]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-3]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 3
+            },
+            "param": "shots_and_results0-3",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.11085466598160565,
+                "max": 0.11085466598160565,
+                "mean": 0.11085466598160565,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.11085466598160565,
+                "iqr": 0.0,
+                "q1": 0.11085466598160565,
+                "q3": 0.11085466598160565,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.11085466598160565,
+                "hd15iqr": 0.11085466598160565,
+                "ops": 9.020820108428563,
+                "total": 0.11085466598160565,
+                "data": [
+                    0.11085466598160565
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-4]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-4]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 4
+            },
+            "param": "shots_and_results0-4",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0015520419692620635,
+                "max": 0.0015520419692620635,
+                "mean": 0.0015520419692620635,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0015520419692620635,
+                "iqr": 0.0,
+                "q1": 0.0015520419692620635,
+                "q3": 0.0015520419692620635,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0015520419692620635,
+                "hd15iqr": 0.0015520419692620635,
+                "ops": 644.3124733769034,
+                "total": 0.0015520419692620635,
+                "data": [
+                    0.0015520419692620635
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-5]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-5]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 5
+            },
+            "param": "shots_and_results0-5",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0011728749959729612,
+                "max": 0.0011728749959729612,
+                "mean": 0.0011728749959729612,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0011728749959729612,
+                "iqr": 0.0,
+                "q1": 0.0011728749959729612,
+                "q3": 0.0011728749959729612,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0011728749959729612,
+                "hd15iqr": 0.0011728749959729612,
+                "ops": 852.6057793315371,
+                "total": 0.0011728749959729612,
+                "data": [
+                    0.0011728749959729612
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-6]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-6]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 6
+            },
+            "param": "shots_and_results0-6",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0019042500061914325,
+                "max": 0.0019042500061914325,
+                "mean": 0.0019042500061914325,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0019042500061914325,
+                "iqr": 0.0,
+                "q1": 0.0019042500061914325,
+                "q3": 0.0019042500061914325,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0019042500061914325,
+                "hd15iqr": 0.0019042500061914325,
+                "ops": 525.1411299717075,
+                "total": 0.0019042500061914325,
+                "data": [
+                    0.0019042500061914325
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-7]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-7]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 7
+            },
+            "param": "shots_and_results0-7",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0013667920138686895,
+                "max": 0.0013667920138686895,
+                "mean": 0.0013667920138686895,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0013667920138686895,
+                "iqr": 0.0,
+                "q1": 0.0013667920138686895,
+                "q3": 0.0013667920138686895,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0013667920138686895,
+                "hd15iqr": 0.0013667920138686895,
+                "ops": 731.6402128876296,
+                "total": 0.0013667920138686895,
+                "data": [
+                    0.0013667920138686895
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-8]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-8]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 8
+            },
+            "param": "shots_and_results0-8",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0016128330025821924,
+                "max": 0.0016128330025821924,
+                "mean": 0.0016128330025821924,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0016128330025821924,
+                "iqr": 0.0,
+                "q1": 0.0016128330025821924,
+                "q3": 0.0016128330025821924,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0016128330025821924,
+                "hd15iqr": 0.0016128330025821924,
+                "ops": 620.0269949827235,
+                "total": 0.0016128330025821924,
+                "data": [
+                    0.0016128330025821924
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-9]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-9]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 9
+            },
+            "param": "shots_and_results0-9",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.001757332996930927,
+                "max": 0.001757332996930927,
+                "mean": 0.001757332996930927,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.001757332996930927,
+                "iqr": 0.0,
+                "q1": 0.001757332996930927,
+                "q3": 0.001757332996930927,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.001757332996930927,
+                "hd15iqr": 0.001757332996930927,
+                "ops": 569.0441150006503,
+                "total": 0.001757332996930927,
+                "data": [
+                    0.001757332996930927
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-10]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-10]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 10
+            },
+            "param": "shots_and_results0-10",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0021038329578004777,
+                "max": 0.0021038329578004777,
+                "mean": 0.0021038329578004777,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0021038329578004777,
+                "iqr": 0.0,
+                "q1": 0.0021038329578004777,
+                "q3": 0.0021038329578004777,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0021038329578004777,
+                "hd15iqr": 0.0021038329578004777,
+                "ops": 475.3229082623952,
+                "total": 0.0021038329578004777,
+                "data": [
+                    0.0021038329578004777
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-11]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-11]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 11
+            },
+            "param": "shots_and_results0-11",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0031469999812543392,
+                "max": 0.0031469999812543392,
+                "mean": 0.0031469999812543392,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0031469999812543392,
+                "iqr": 0.0,
+                "q1": 0.0031469999812543392,
+                "q3": 0.0031469999812543392,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0031469999812543392,
+                "hd15iqr": 0.0031469999812543392,
+                "ops": 317.7629507329763,
+                "total": 0.0031469999812543392,
+                "data": [
+                    0.0031469999812543392
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-12]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-12]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 12
+            },
+            "param": "shots_and_results0-12",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.004438042000401765,
+                "max": 0.004438042000401765,
+                "mean": 0.004438042000401765,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.004438042000401765,
+                "iqr": 0.0,
+                "q1": 0.004438042000401765,
+                "q3": 0.004438042000401765,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.004438042000401765,
+                "hd15iqr": 0.004438042000401765,
+                "ops": 225.32459131965683,
+                "total": 0.004438042000401765,
+                "data": [
+                    0.004438042000401765
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-13]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-13]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 13
+            },
+            "param": "shots_and_results0-13",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.00672875001328066,
+                "max": 0.00672875001328066,
+                "mean": 0.00672875001328066,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.00672875001328066,
+                "iqr": 0.0,
+                "q1": 0.00672875001328066,
+                "q3": 0.00672875001328066,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.00672875001328066,
+                "hd15iqr": 0.00672875001328066,
+                "ops": 148.616013082115,
+                "total": 0.00672875001328066,
+                "data": [
+                    0.00672875001328066
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-14]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-14]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 14
+            },
+            "param": "shots_and_results0-14",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.012640959001146257,
+                "max": 0.012640959001146257,
+                "mean": 0.012640959001146257,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.012640959001146257,
+                "iqr": 0.0,
+                "q1": 0.012640959001146257,
+                "q3": 0.012640959001146257,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.012640959001146257,
+                "hd15iqr": 0.012640959001146257,
+                "ops": 79.10792210538156,
+                "total": 0.012640959001146257,
+                "data": [
+                    0.012640959001146257
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-15]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-15]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 15
+            },
+            "param": "shots_and_results0-15",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.021296833001542836,
+                "max": 0.021296833001542836,
+                "mean": 0.021296833001542836,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.021296833001542836,
+                "iqr": 0.0,
+                "q1": 0.021296833001542836,
+                "q3": 0.021296833001542836,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.021296833001542836,
+                "hd15iqr": 0.021296833001542836,
+                "ops": 46.95533837954007,
+                "total": 0.021296833001542836,
+                "data": [
+                    0.021296833001542836
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-16]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-16]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 16
+            },
+            "param": "shots_and_results0-16",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.08103887503966689,
+                "max": 0.08103887503966689,
+                "mean": 0.08103887503966689,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.08103887503966689,
+                "iqr": 0.0,
+                "q1": 0.08103887503966689,
+                "q3": 0.08103887503966689,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.08103887503966689,
+                "hd15iqr": 0.08103887503966689,
+                "ops": 12.339756684807387,
+                "total": 0.08103887503966689,
+                "data": [
+                    0.08103887503966689
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-17]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-17]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 17
+            },
+            "param": "shots_and_results0-17",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.11963962495792657,
+                "max": 0.11963962495792657,
+                "mean": 0.11963962495792657,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.11963962495792657,
+                "iqr": 0.0,
+                "q1": 0.11963962495792657,
+                "q3": 0.11963962495792657,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.11963962495792657,
+                "hd15iqr": 0.11963962495792657,
+                "ops": 8.358434760654491,
+                "total": 0.11963962495792657,
+                "data": [
+                    0.11963962495792657
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-18]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-18]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 18
+            },
+            "param": "shots_and_results0-18",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.26072500000009313,
+                "max": 0.26072500000009313,
+                "mean": 0.26072500000009313,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.26072500000009313,
+                "iqr": 0.0,
+                "q1": 0.26072500000009313,
+                "q3": 0.26072500000009313,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.26072500000009313,
+                "hd15iqr": 0.26072500000009313,
+                "ops": 3.835458816759585,
+                "total": 0.26072500000009313,
+                "data": [
+                    0.26072500000009313
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-19]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-19]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 19
+            },
+            "param": "shots_and_results0-19",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.4268693749909289,
+                "max": 0.4268693749909289,
+                "mean": 0.4268693749909289,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.4268693749909289,
+                "iqr": 0.0,
+                "q1": 0.4268693749909289,
+                "q3": 0.4268693749909289,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.4268693749909289,
+                "hd15iqr": 0.4268693749909289,
+                "ops": 2.34263701869278,
+                "total": 0.4268693749909289,
+                "data": [
+                    0.4268693749909289
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results0-20]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-20]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "state_vector"
+                ],
+                "nq": 20
+            },
+            "param": "shots_and_results0-20",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.794439000019338,
+                "max": 0.794439000019338,
+                "mean": 0.794439000019338,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.794439000019338,
+                "iqr": 0.0,
+                "q1": 0.794439000019338,
+                "q3": 0.794439000019338,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.794439000019338,
+                "hd15iqr": 0.794439000019338,
+                "ops": 1.2587498851084329,
+                "total": 0.794439000019338,
+                "data": [
+                    0.794439000019338
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-3]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-3]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 3
+            },
+            "param": "shots_and_results1-3",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.020558208983857185,
+                "max": 0.020558208983857185,
+                "mean": 0.020558208983857185,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.020558208983857185,
+                "iqr": 0.0,
+                "q1": 0.020558208983857185,
+                "q3": 0.020558208983857185,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.020558208983857185,
+                "hd15iqr": 0.020558208983857185,
+                "ops": 48.64236961426089,
+                "total": 0.020558208983857185,
+                "data": [
+                    0.020558208983857185
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-4]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-4]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 4
+            },
+            "param": "shots_and_results1-4",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0013599999947473407,
+                "max": 0.0013599999947473407,
+                "mean": 0.0013599999947473407,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0013599999947473407,
+                "iqr": 0.0,
+                "q1": 0.0013599999947473407,
+                "q3": 0.0013599999947473407,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0013599999947473407,
+                "hd15iqr": 0.0013599999947473407,
+                "ops": 735.2941204869481,
+                "total": 0.0013599999947473407,
+                "data": [
+                    0.0013599999947473407
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-5]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-5]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 5
+            },
+            "param": "shots_and_results1-5",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0011040419922210276,
+                "max": 0.0011040419922210276,
+                "mean": 0.0011040419922210276,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0011040419922210276,
+                "iqr": 0.0,
+                "q1": 0.0011040419922210276,
+                "q3": 0.0011040419922210276,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0011040419922210276,
+                "hd15iqr": 0.0011040419922210276,
+                "ops": 905.7626494697689,
+                "total": 0.0011040419922210276,
+                "data": [
+                    0.0011040419922210276
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-6]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-6]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 6
+            },
+            "param": "shots_and_results1-6",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0013118329807184637,
+                "max": 0.0013118329807184637,
+                "mean": 0.0013118329807184637,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0013118329807184637,
+                "iqr": 0.0,
+                "q1": 0.0013118329807184637,
+                "q3": 0.0013118329807184637,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0013118329807184637,
+                "hd15iqr": 0.0013118329807184637,
+                "ops": 762.2921627205322,
+                "total": 0.0013118329807184637,
+                "data": [
+                    0.0013118329807184637
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-7]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-7]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 7
+            },
+            "param": "shots_and_results1-7",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.001469499955419451,
+                "max": 0.001469499955419451,
+                "mean": 0.001469499955419451,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.001469499955419451,
+                "iqr": 0.0,
+                "q1": 0.001469499955419451,
+                "q3": 0.001469499955419451,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.001469499955419451,
+                "hd15iqr": 0.001469499955419451,
+                "ops": 680.5035932883455,
+                "total": 0.001469499955419451,
+                "data": [
+                    0.001469499955419451
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-8]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-8]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 8
+            },
+            "param": "shots_and_results1-8",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0013899999903514981,
+                "max": 0.0013899999903514981,
+                "mean": 0.0013899999903514981,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0013899999903514981,
+                "iqr": 0.0,
+                "q1": 0.0013899999903514981,
+                "q3": 0.0013899999903514981,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0013899999903514981,
+                "hd15iqr": 0.0013899999903514981,
+                "ops": 719.4244654254449,
+                "total": 0.0013899999903514981,
+                "data": [
+                    0.0013899999903514981
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-9]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-9]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 9
+            },
+            "param": "shots_and_results1-9",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.001814916031435132,
+                "max": 0.001814916031435132,
+                "mean": 0.001814916031435132,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.001814916031435132,
+                "iqr": 0.0,
+                "q1": 0.001814916031435132,
+                "q3": 0.001814916031435132,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.001814916031435132,
+                "hd15iqr": 0.001814916031435132,
+                "ops": 550.9896781336253,
+                "total": 0.001814916031435132,
+                "data": [
+                    0.001814916031435132
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-10]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-10]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 10
+            },
+            "param": "shots_and_results1-10",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.002677417011000216,
+                "max": 0.002677417011000216,
+                "mean": 0.002677417011000216,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.002677417011000216,
+                "iqr": 0.0,
+                "q1": 0.002677417011000216,
+                "q3": 0.002677417011000216,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.002677417011000216,
+                "hd15iqr": 0.002677417011000216,
+                "ops": 373.494302864097,
+                "total": 0.002677417011000216,
+                "data": [
+                    0.002677417011000216
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-11]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-11]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 11
+            },
+            "param": "shots_and_results1-11",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.003303209028672427,
+                "max": 0.003303209028672427,
+                "mean": 0.003303209028672427,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.003303209028672427,
+                "iqr": 0.0,
+                "q1": 0.003303209028672427,
+                "q3": 0.003303209028672427,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.003303209028672427,
+                "hd15iqr": 0.003303209028672427,
+                "ops": 302.735912659425,
+                "total": 0.003303209028672427,
+                "data": [
+                    0.003303209028672427
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-12]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-12]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 12
+            },
+            "param": "shots_and_results1-12",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.003958083980251104,
+                "max": 0.003958083980251104,
+                "mean": 0.003958083980251104,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.003958083980251104,
+                "iqr": 0.0,
+                "q1": 0.003958083980251104,
+                "q3": 0.003958083980251104,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.003958083980251104,
+                "hd15iqr": 0.003958083980251104,
+                "ops": 252.64749434057214,
+                "total": 0.003958083980251104,
+                "data": [
+                    0.003958083980251104
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-13]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-13]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 13
+            },
+            "param": "shots_and_results1-13",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.004732333007268608,
+                "max": 0.004732333007268608,
+                "mean": 0.004732333007268608,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.004732333007268608,
+                "iqr": 0.0,
+                "q1": 0.004732333007268608,
+                "q3": 0.004732333007268608,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.004732333007268608,
+                "hd15iqr": 0.004732333007268608,
+                "ops": 211.31226362642994,
+                "total": 0.004732333007268608,
+                "data": [
+                    0.004732333007268608
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-14]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-14]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 14
+            },
+            "param": "shots_and_results1-14",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.00856354198185727,
+                "max": 0.00856354198185727,
+                "mean": 0.00856354198185727,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.00856354198185727,
+                "iqr": 0.0,
+                "q1": 0.00856354198185727,
+                "q3": 0.00856354198185727,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.00856354198185727,
+                "hd15iqr": 0.00856354198185727,
+                "ops": 116.77411077315918,
+                "total": 0.00856354198185727,
+                "data": [
+                    0.00856354198185727
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-15]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-15]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 15
+            },
+            "param": "shots_and_results1-15",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.014807707979343832,
+                "max": 0.014807707979343832,
+                "mean": 0.014807707979343832,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.014807707979343832,
+                "iqr": 0.0,
+                "q1": 0.014807707979343832,
+                "q3": 0.014807707979343832,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.014807707979343832,
+                "hd15iqr": 0.014807707979343832,
+                "ops": 67.53239605987372,
+                "total": 0.014807707979343832,
+                "data": [
+                    0.014807707979343832
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-16]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-16]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 16
+            },
+            "param": "shots_and_results1-16",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.030338832992129028,
+                "max": 0.030338832992129028,
+                "mean": 0.030338832992129028,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.030338832992129028,
+                "iqr": 0.0,
+                "q1": 0.030338832992129028,
+                "q3": 0.030338832992129028,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.030338832992129028,
+                "hd15iqr": 0.030338832992129028,
+                "ops": 32.96105688242641,
+                "total": 0.030338832992129028,
+                "data": [
+                    0.030338832992129028
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-17]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-17]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 17
+            },
+            "param": "shots_and_results1-17",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.058687000011559576,
+                "max": 0.058687000011559576,
+                "mean": 0.058687000011559576,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.058687000011559576,
+                "iqr": 0.0,
+                "q1": 0.058687000011559576,
+                "q3": 0.058687000011559576,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.058687000011559576,
+                "hd15iqr": 0.058687000011559576,
+                "ops": 17.039548789391688,
+                "total": 0.058687000011559576,
+                "data": [
+                    0.058687000011559576
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-18]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-18]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 18
+            },
+            "param": "shots_and_results1-18",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.10794875002466142,
+                "max": 0.10794875002466142,
+                "mean": 0.10794875002466142,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.10794875002466142,
+                "iqr": 0.0,
+                "q1": 0.10794875002466142,
+                "q3": 0.10794875002466142,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.10794875002466142,
+                "hd15iqr": 0.10794875002466142,
+                "ops": 9.263655204636876,
+                "total": 0.10794875002466142,
+                "data": [
+                    0.10794875002466142
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-19]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-19]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 19
+            },
+            "param": "shots_and_results1-19",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.2157110829721205,
+                "max": 0.2157110829721205,
+                "mean": 0.2157110829721205,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.2157110829721205,
+                "iqr": 0.0,
+                "q1": 0.2157110829721205,
+                "q3": 0.2157110829721205,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.2157110829721205,
+                "hd15iqr": 0.2157110829721205,
+                "ops": 4.635830418269443,
+                "total": 0.2157110829721205,
+                "data": [
+                    0.2157110829721205
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results1-20]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-20]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "probability"
+                ],
+                "nq": 20
+            },
+            "param": "shots_and_results1-20",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.4330306670162827,
+                "max": 0.4330306670162827,
+                "mean": 0.4330306670162827,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.4330306670162827,
+                "iqr": 0.0,
+                "q1": 0.4330306670162827,
+                "q3": 0.4330306670162827,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.4330306670162827,
+                "hd15iqr": 0.4330306670162827,
+                "ops": 2.3093052667385296,
+                "total": 0.4330306670162827,
+                "data": [
+                    0.4330306670162827
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-3]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-3]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 3
+            },
+            "param": "shots_and_results2-3",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0015866249450482428,
+                "max": 0.0015866249450482428,
+                "mean": 0.0015866249450482428,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0015866249450482428,
+                "iqr": 0.0,
+                "q1": 0.0015866249450482428,
+                "q3": 0.0015866249450482428,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0015866249450482428,
+                "hd15iqr": 0.0015866249450482428,
+                "ops": 630.2686738418789,
+                "total": 0.0015866249450482428,
+                "data": [
+                    0.0015866249450482428
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-4]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-4]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 4
+            },
+            "param": "shots_and_results2-4",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0013286250177770853,
+                "max": 0.0013286250177770853,
+                "mean": 0.0013286250177770853,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0013286250177770853,
+                "iqr": 0.0,
+                "q1": 0.0013286250177770853,
+                "q3": 0.0013286250177770853,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0013286250177770853,
+                "hd15iqr": 0.0013286250177770853,
+                "ops": 752.6578128666387,
+                "total": 0.0013286250177770853,
+                "data": [
+                    0.0013286250177770853
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-5]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-5]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 5
+            },
+            "param": "shots_and_results2-5",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0012189170229248703,
+                "max": 0.0012189170229248703,
+                "mean": 0.0012189170229248703,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0012189170229248703,
+                "iqr": 0.0,
+                "q1": 0.0012189170229248703,
+                "q3": 0.0012189170229248703,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0012189170229248703,
+                "hd15iqr": 0.0012189170229248703,
+                "ops": 820.4003891917395,
+                "total": 0.0012189170229248703,
+                "data": [
+                    0.0012189170229248703
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-6]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-6]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 6
+            },
+            "param": "shots_and_results2-6",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0013885420048609376,
+                "max": 0.0013885420048609376,
+                "mean": 0.0013885420048609376,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0013885420048609376,
+                "iqr": 0.0,
+                "q1": 0.0013885420048609376,
+                "q3": 0.0013885420048609376,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0013885420048609376,
+                "hd15iqr": 0.0013885420048609376,
+                "ops": 720.1798696036926,
+                "total": 0.0013885420048609376,
+                "data": [
+                    0.0013885420048609376
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-7]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-7]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 7
+            },
+            "param": "shots_and_results2-7",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0015077919815666974,
+                "max": 0.0015077919815666974,
+                "mean": 0.0015077919815666974,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0015077919815666974,
+                "iqr": 0.0,
+                "q1": 0.0015077919815666974,
+                "q3": 0.0015077919815666974,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0015077919815666974,
+                "hd15iqr": 0.0015077919815666974,
+                "ops": 663.2214604039297,
+                "total": 0.0015077919815666974,
+                "data": [
+                    0.0015077919815666974
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-8]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-8]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 8
+            },
+            "param": "shots_and_results2-8",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0012403340078890324,
+                "max": 0.0012403340078890324,
+                "mean": 0.0012403340078890324,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0012403340078890324,
+                "iqr": 0.0,
+                "q1": 0.0012403340078890324,
+                "q3": 0.0012403340078890324,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0012403340078890324,
+                "hd15iqr": 0.0012403340078890324,
+                "ops": 806.234444625069,
+                "total": 0.0012403340078890324,
+                "data": [
+                    0.0012403340078890324
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-9]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-9]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 9
+            },
+            "param": "shots_and_results2-9",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0020737089798785746,
+                "max": 0.0020737089798785746,
+                "mean": 0.0020737089798785746,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0020737089798785746,
+                "iqr": 0.0,
+                "q1": 0.0020737089798785746,
+                "q3": 0.0020737089798785746,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0020737089798785746,
+                "hd15iqr": 0.0020737089798785746,
+                "ops": 482.22774251503444,
+                "total": 0.0020737089798785746,
+                "data": [
+                    0.0020737089798785746
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-10]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-10]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 10
+            },
+            "param": "shots_and_results2-10",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0015921249869279563,
+                "max": 0.0015921249869279563,
+                "mean": 0.0015921249869279563,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0015921249869279563,
+                "iqr": 0.0,
+                "q1": 0.0015921249869279563,
+                "q3": 0.0015921249869279563,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0015921249869279563,
+                "hd15iqr": 0.0015921249869279563,
+                "ops": 628.0913924537572,
+                "total": 0.0015921249869279563,
+                "data": [
+                    0.0015921249869279563
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-11]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-11]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 11
+            },
+            "param": "shots_and_results2-11",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0017122090212069452,
+                "max": 0.0017122090212069452,
+                "mean": 0.0017122090212069452,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0017122090212069452,
+                "iqr": 0.0,
+                "q1": 0.0017122090212069452,
+                "q3": 0.0017122090212069452,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0017122090212069452,
+                "hd15iqr": 0.0017122090212069452,
+                "ops": 584.0408429194555,
+                "total": 0.0017122090212069452,
+                "data": [
+                    0.0017122090212069452
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-12]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-12]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 12
+            },
+            "param": "shots_and_results2-12",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.00153795798541978,
+                "max": 0.00153795798541978,
+                "mean": 0.00153795798541978,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.00153795798541978,
+                "iqr": 0.0,
+                "q1": 0.00153795798541978,
+                "q3": 0.00153795798541978,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.00153795798541978,
+                "hd15iqr": 0.00153795798541978,
+                "ops": 650.2128208184138,
+                "total": 0.00153795798541978,
+                "data": [
+                    0.00153795798541978
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-13]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-13]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 13
+            },
+            "param": "shots_and_results2-13",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0017805829993449152,
+                "max": 0.0017805829993449152,
+                "mean": 0.0017805829993449152,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0017805829993449152,
+                "iqr": 0.0,
+                "q1": 0.0017805829993449152,
+                "q3": 0.0017805829993449152,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0017805829993449152,
+                "hd15iqr": 0.0017805829993449152,
+                "ops": 561.613808717653,
+                "total": 0.0017805829993449152,
+                "data": [
+                    0.0017805829993449152
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-14]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-14]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 14
+            },
+            "param": "shots_and_results2-14",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.002065250009763986,
+                "max": 0.002065250009763986,
+                "mean": 0.002065250009763986,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.002065250009763986,
+                "iqr": 0.0,
+                "q1": 0.002065250009763986,
+                "q3": 0.002065250009763986,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.002065250009763986,
+                "hd15iqr": 0.002065250009763986,
+                "ops": 484.20287871795176,
+                "total": 0.002065250009763986,
+                "data": [
+                    0.002065250009763986
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-15]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-15]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 15
+            },
+            "param": "shots_and_results2-15",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0034898340236395597,
+                "max": 0.0034898340236395597,
+                "mean": 0.0034898340236395597,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0034898340236395597,
+                "iqr": 0.0,
+                "q1": 0.0034898340236395597,
+                "q3": 0.0034898340236395597,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0034898340236395597,
+                "hd15iqr": 0.0034898340236395597,
+                "ops": 286.54657878459693,
+                "total": 0.0034898340236395597,
+                "data": [
+                    0.0034898340236395597
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-16]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-16]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 16
+            },
+            "param": "shots_and_results2-16",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.00339816597988829,
+                "max": 0.00339816597988829,
+                "mean": 0.00339816597988829,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.00339816597988829,
+                "iqr": 0.0,
+                "q1": 0.00339816597988829,
+                "q3": 0.00339816597988829,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.00339816597988829,
+                "hd15iqr": 0.00339816597988829,
+                "ops": 294.2763849436435,
+                "total": 0.00339816597988829,
+                "data": [
+                    0.00339816597988829
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-17]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-17]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 17
+            },
+            "param": "shots_and_results2-17",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.002276083978358656,
+                "max": 0.002276083978358656,
+                "mean": 0.002276083978358656,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.002276083978358656,
+                "iqr": 0.0,
+                "q1": 0.002276083978358656,
+                "q3": 0.002276083978358656,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.002276083978358656,
+                "hd15iqr": 0.002276083978358656,
+                "ops": 439.3511001826594,
+                "total": 0.002276083978358656,
+                "data": [
+                    0.002276083978358656
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-18]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-18]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 18
+            },
+            "param": "shots_and_results2-18",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0029573749634437263,
+                "max": 0.0029573749634437263,
+                "mean": 0.0029573749634437263,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0029573749634437263,
+                "iqr": 0.0,
+                "q1": 0.0029573749634437263,
+                "q3": 0.0029573749634437263,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0029573749634437263,
+                "hd15iqr": 0.0029573749634437263,
+                "ops": 338.1377107607438,
+                "total": 0.0029573749634437263,
+                "data": [
+                    0.0029573749634437263
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-19]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-19]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 19
+            },
+            "param": "shots_and_results2-19",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.004229249956551939,
+                "max": 0.004229249956551939,
+                "mean": 0.004229249956551939,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.004229249956551939,
+                "iqr": 0.0,
+                "q1": 0.004229249956551939,
+                "q3": 0.004229249956551939,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.004229249956551939,
+                "hd15iqr": 0.004229249956551939,
+                "ops": 236.4485453149449,
+                "total": 0.004229249956551939,
+                "data": [
+                    0.004229249956551939
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results2-20]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-20]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "expectation z(q[0])"
+                ],
+                "nq": 20
+            },
+            "param": "shots_and_results2-20",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.006636540987528861,
+                "max": 0.006636540987528861,
+                "mean": 0.006636540987528861,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.006636540987528861,
+                "iqr": 0.0,
+                "q1": 0.006636540987528861,
+                "q3": 0.006636540987528861,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.006636540987528861,
+                "hd15iqr": 0.006636540987528861,
+                "ops": 150.68090468802387,
+                "total": 0.006636540987528861,
+                "data": [
+                    0.006636540987528861
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-3]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-3]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 3
+            },
+            "param": "shots_and_results3-3",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.1469930830062367,
+                "max": 0.1469930830062367,
+                "mean": 0.1469930830062367,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.1469930830062367,
+                "iqr": 0.0,
+                "q1": 0.1469930830062367,
+                "q3": 0.1469930830062367,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.1469930830062367,
+                "hd15iqr": 0.1469930830062367,
+                "ops": 6.803041201316741,
+                "total": 0.1469930830062367,
+                "data": [
+                    0.1469930830062367
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-4]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-4]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 4
+            },
+            "param": "shots_and_results3-4",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.001580375013872981,
+                "max": 0.001580375013872981,
+                "mean": 0.001580375013872981,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.001580375013872981,
+                "iqr": 0.0,
+                "q1": 0.001580375013872981,
+                "q3": 0.001580375013872981,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.001580375013872981,
+                "hd15iqr": 0.001580375013872981,
+                "ops": 632.7612061831627,
+                "total": 0.001580375013872981,
+                "data": [
+                    0.001580375013872981
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-5]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-5]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 5
+            },
+            "param": "shots_and_results3-5",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0013881250051781535,
+                "max": 0.0013881250051781535,
+                "mean": 0.0013881250051781535,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0013881250051781535,
+                "iqr": 0.0,
+                "q1": 0.0013881250051781535,
+                "q3": 0.0013881250051781535,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0013881250051781535,
+                "hd15iqr": 0.0013881250051781535,
+                "ops": 720.396215232546,
+                "total": 0.0013881250051781535,
+                "data": [
+                    0.0013881250051781535
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-6]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-6]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 6
+            },
+            "param": "shots_and_results3-6",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0018390000332146883,
+                "max": 0.0018390000332146883,
+                "mean": 0.0018390000332146883,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0018390000332146883,
+                "iqr": 0.0,
+                "q1": 0.0018390000332146883,
+                "q3": 0.0018390000332146883,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0018390000332146883,
+                "hd15iqr": 0.0018390000332146883,
+                "ops": 543.7737802820682,
+                "total": 0.0018390000332146883,
+                "data": [
+                    0.0018390000332146883
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-7]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-7]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 7
+            },
+            "param": "shots_and_results3-7",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.001570541993714869,
+                "max": 0.001570541993714869,
+                "mean": 0.001570541993714869,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.001570541993714869,
+                "iqr": 0.0,
+                "q1": 0.001570541993714869,
+                "q3": 0.001570541993714869,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.001570541993714869,
+                "hd15iqr": 0.001570541993714869,
+                "ops": 636.7228663747208,
+                "total": 0.001570541993714869,
+                "data": [
+                    0.001570541993714869
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-8]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-8]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 8
+            },
+            "param": "shots_and_results3-8",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0015441669966094196,
+                "max": 0.0015441669966094196,
+                "mean": 0.0015441669966094196,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0015441669966094196,
+                "iqr": 0.0,
+                "q1": 0.0015441669966094196,
+                "q3": 0.0015441669966094196,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0015441669966094196,
+                "hd15iqr": 0.0015441669966094196,
+                "ops": 647.5983505642423,
+                "total": 0.0015441669966094196,
+                "data": [
+                    0.0015441669966094196
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-9]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-9]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 9
+            },
+            "param": "shots_and_results3-9",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0018146249931305647,
+                "max": 0.0018146249931305647,
+                "mean": 0.0018146249931305647,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0018146249931305647,
+                "iqr": 0.0,
+                "q1": 0.0018146249931305647,
+                "q3": 0.0018146249931305647,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0018146249931305647,
+                "hd15iqr": 0.0018146249931305647,
+                "ops": 551.0780485144837,
+                "total": 0.0018146249931305647,
+                "data": [
+                    0.0018146249931305647
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-10]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-10]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 10
+            },
+            "param": "shots_and_results3-10",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0019207079894840717,
+                "max": 0.0019207079894840717,
+                "mean": 0.0019207079894840717,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0019207079894840717,
+                "iqr": 0.0,
+                "q1": 0.0019207079894840717,
+                "q3": 0.0019207079894840717,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0019207079894840717,
+                "hd15iqr": 0.0019207079894840717,
+                "ops": 520.6413496872128,
+                "total": 0.0019207079894840717,
+                "data": [
+                    0.0019207079894840717
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-11]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-11]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 11
+            },
+            "param": "shots_and_results3-11",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0018692080047912896,
+                "max": 0.0018692080047912896,
+                "mean": 0.0018692080047912896,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0018692080047912896,
+                "iqr": 0.0,
+                "q1": 0.0018692080047912896,
+                "q3": 0.0018692080047912896,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0018692080047912896,
+                "hd15iqr": 0.0018692080047912896,
+                "ops": 534.9859391981671,
+                "total": 0.0018692080047912896,
+                "data": [
+                    0.0018692080047912896
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-12]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-12]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 12
+            },
+            "param": "shots_and_results3-12",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0022399579756893218,
+                "max": 0.0022399579756893218,
+                "mean": 0.0022399579756893218,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0022399579756893218,
+                "iqr": 0.0,
+                "q1": 0.0022399579756893218,
+                "q3": 0.0022399579756893218,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0022399579756893218,
+                "hd15iqr": 0.0022399579756893218,
+                "ops": 446.4369469664989,
+                "total": 0.0022399579756893218,
+                "data": [
+                    0.0022399579756893218
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-13]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-13]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 13
+            },
+            "param": "shots_and_results3-13",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0017346660024486482,
+                "max": 0.0017346660024486482,
+                "mean": 0.0017346660024486482,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0017346660024486482,
+                "iqr": 0.0,
+                "q1": 0.0017346660024486482,
+                "q3": 0.0017346660024486482,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0017346660024486482,
+                "hd15iqr": 0.0017346660024486482,
+                "ops": 576.4798517918745,
+                "total": 0.0017346660024486482,
+                "data": [
+                    0.0017346660024486482
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-14]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-14]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 14
+            },
+            "param": "shots_and_results3-14",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.002296249964274466,
+                "max": 0.002296249964274466,
+                "mean": 0.002296249964274466,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.002296249964274466,
+                "iqr": 0.0,
+                "q1": 0.002296249964274466,
+                "q3": 0.002296249964274466,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.002296249964274466,
+                "hd15iqr": 0.002296249964274466,
+                "ops": 435.4926578369985,
+                "total": 0.002296249964274466,
+                "data": [
+                    0.002296249964274466
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-15]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-15]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 15
+            },
+            "param": "shots_and_results3-15",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0019337080302648246,
+                "max": 0.0019337080302648246,
+                "mean": 0.0019337080302648246,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0019337080302648246,
+                "iqr": 0.0,
+                "q1": 0.0019337080302648246,
+                "q3": 0.0019337080302648246,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0019337080302648246,
+                "hd15iqr": 0.0019337080302648246,
+                "ops": 517.1411528259766,
+                "total": 0.0019337080302648246,
+                "data": [
+                    0.0019337080302648246
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-16]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-16]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 16
+            },
+            "param": "shots_and_results3-16",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0030358750373125076,
+                "max": 0.0030358750373125076,
+                "mean": 0.0030358750373125076,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0030358750373125076,
+                "iqr": 0.0,
+                "q1": 0.0030358750373125076,
+                "q3": 0.0030358750373125076,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0030358750373125076,
+                "hd15iqr": 0.0030358750373125076,
+                "ops": 329.39432213430126,
+                "total": 0.0030358750373125076,
+                "data": [
+                    0.0030358750373125076
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-17]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-17]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 17
+            },
+            "param": "shots_and_results3-17",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.003976540989242494,
+                "max": 0.003976540989242494,
+                "mean": 0.003976540989242494,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.003976540989242494,
+                "iqr": 0.0,
+                "q1": 0.003976540989242494,
+                "q3": 0.003976540989242494,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.003976540989242494,
+                "hd15iqr": 0.003976540989242494,
+                "ops": 251.47483773089277,
+                "total": 0.003976540989242494,
+                "data": [
+                    0.003976540989242494
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-18]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-18]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 18
+            },
+            "param": "shots_and_results3-18",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.004659582977183163,
+                "max": 0.004659582977183163,
+                "mean": 0.004659582977183163,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.004659582977183163,
+                "iqr": 0.0,
+                "q1": 0.004659582977183163,
+                "q3": 0.004659582977183163,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.004659582977183163,
+                "hd15iqr": 0.004659582977183163,
+                "ops": 214.61148023262064,
+                "total": 0.004659582977183163,
+                "data": [
+                    0.004659582977183163
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-19]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-19]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 19
+            },
+            "param": "shots_and_results3-19",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.005890000029467046,
+                "max": 0.005890000029467046,
+                "mean": 0.005890000029467046,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.005890000029467046,
+                "iqr": 0.0,
+                "q1": 0.005890000029467046,
+                "q3": 0.005890000029467046,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.005890000029467046,
+                "hd15iqr": 0.005890000029467046,
+                "ops": 169.7792860776071,
+                "total": 0.005890000029467046,
+                "data": [
+                    0.005890000029467046
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results3-20]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-20]",
+            "params": {
+                "shots_and_results": [
+                    0,
+                    "variance y(q[0])"
+                ],
+                "nq": 20
+            },
+            "param": "shots_and_results3-20",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.012661834014579654,
+                "max": 0.012661834014579654,
+                "mean": 0.012661834014579654,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.012661834014579654,
+                "iqr": 0.0,
+                "q1": 0.012661834014579654,
+                "q3": 0.012661834014579654,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.012661834014579654,
+                "hd15iqr": 0.012661834014579654,
+                "ops": 78.97750032487674,
+                "total": 0.012661834014579654,
+                "data": [
+                    0.012661834014579654
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-3]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-3]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 3
+            },
+            "param": "shots_and_results4-3",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.20281929202610627,
+                "max": 0.20281929202610627,
+                "mean": 0.20281929202610627,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.20281929202610627,
+                "iqr": 0.0,
+                "q1": 0.20281929202610627,
+                "q3": 0.20281929202610627,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.20281929202610627,
+                "hd15iqr": 0.20281929202610627,
+                "ops": 4.930497439421508,
+                "total": 0.20281929202610627,
+                "data": [
+                    0.20281929202610627
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-4]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-4]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 4
+            },
+            "param": "shots_and_results4-4",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0024854589719325304,
+                "max": 0.0024854589719325304,
+                "mean": 0.0024854589719325304,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0024854589719325304,
+                "iqr": 0.0,
+                "q1": 0.0024854589719325304,
+                "q3": 0.0024854589719325304,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0024854589719325304,
+                "hd15iqr": 0.0024854589719325304,
+                "ops": 402.34017591626764,
+                "total": 0.0024854589719325304,
+                "data": [
+                    0.0024854589719325304
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-5]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-5]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 5
+            },
+            "param": "shots_and_results4-5",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0025891249533742666,
+                "max": 0.0025891249533742666,
+                "mean": 0.0025891249533742666,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0025891249533742666,
+                "iqr": 0.0,
+                "q1": 0.0025891249533742666,
+                "q3": 0.0025891249533742666,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0025891249533742666,
+                "hd15iqr": 0.0025891249533742666,
+                "ops": 386.2308764576055,
+                "total": 0.0025891249533742666,
+                "data": [
+                    0.0025891249533742666
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-6]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-6]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 6
+            },
+            "param": "shots_and_results4-6",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0030179169843904674,
+                "max": 0.0030179169843904674,
+                "mean": 0.0030179169843904674,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0030179169843904674,
+                "iqr": 0.0,
+                "q1": 0.0030179169843904674,
+                "q3": 0.0030179169843904674,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0030179169843904674,
+                "hd15iqr": 0.0030179169843904674,
+                "ops": 331.35437627088055,
+                "total": 0.0030179169843904674,
+                "data": [
+                    0.0030179169843904674
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-7]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-7]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 7
+            },
+            "param": "shots_and_results4-7",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0030238330364227295,
+                "max": 0.0030238330364227295,
+                "mean": 0.0030238330364227295,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0030238330364227295,
+                "iqr": 0.0,
+                "q1": 0.0030238330364227295,
+                "q3": 0.0030238330364227295,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0030238330364227295,
+                "hd15iqr": 0.0030238330364227295,
+                "ops": 330.7060899046943,
+                "total": 0.0030238330364227295,
+                "data": [
+                    0.0030238330364227295
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-8]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-8]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 8
+            },
+            "param": "shots_and_results4-8",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.003418374981265515,
+                "max": 0.003418374981265515,
+                "mean": 0.003418374981265515,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.003418374981265515,
+                "iqr": 0.0,
+                "q1": 0.003418374981265515,
+                "q3": 0.003418374981265515,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.003418374981265515,
+                "hd15iqr": 0.003418374981265515,
+                "ops": 292.53666010327237,
+                "total": 0.003418374981265515,
+                "data": [
+                    0.003418374981265515
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-9]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-9]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 9
+            },
+            "param": "shots_and_results4-9",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0030650420230813324,
+                "max": 0.0030650420230813324,
+                "mean": 0.0030650420230813324,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0030650420230813324,
+                "iqr": 0.0,
+                "q1": 0.0030650420230813324,
+                "q3": 0.0030650420230813324,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0030650420230813324,
+                "hd15iqr": 0.0030650420230813324,
+                "ops": 326.2598008345364,
+                "total": 0.0030650420230813324,
+                "data": [
+                    0.0030650420230813324
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-10]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-10]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 10
+            },
+            "param": "shots_and_results4-10",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.00404508295468986,
+                "max": 0.00404508295468986,
+                "mean": 0.00404508295468986,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.00404508295468986,
+                "iqr": 0.0,
+                "q1": 0.00404508295468986,
+                "q3": 0.00404508295468986,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.00404508295468986,
+                "hd15iqr": 0.00404508295468986,
+                "ops": 247.21371877938924,
+                "total": 0.00404508295468986,
+                "data": [
+                    0.00404508295468986
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-11]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-11]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 11
+            },
+            "param": "shots_and_results4-11",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.003804875013884157,
+                "max": 0.003804875013884157,
+                "mean": 0.003804875013884157,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.003804875013884157,
+                "iqr": 0.0,
+                "q1": 0.003804875013884157,
+                "q3": 0.003804875013884157,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.003804875013884157,
+                "hd15iqr": 0.003804875013884157,
+                "ops": 262.82072245499677,
+                "total": 0.003804875013884157,
+                "data": [
+                    0.003804875013884157
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-12]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-12]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 12
+            },
+            "param": "shots_and_results4-12",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.004821832990273833,
+                "max": 0.004821832990273833,
+                "mean": 0.004821832990273833,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.004821832990273833,
+                "iqr": 0.0,
+                "q1": 0.004821832990273833,
+                "q3": 0.004821832990273833,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.004821832990273833,
+                "hd15iqr": 0.004821832990273833,
+                "ops": 207.39001164434973,
+                "total": 0.004821832990273833,
+                "data": [
+                    0.004821832990273833
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-13]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-13]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 13
+            },
+            "param": "shots_and_results4-13",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0045837920042686164,
+                "max": 0.0045837920042686164,
+                "mean": 0.0045837920042686164,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0045837920042686164,
+                "iqr": 0.0,
+                "q1": 0.0045837920042686164,
+                "q3": 0.0045837920042686164,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0045837920042686164,
+                "hd15iqr": 0.0045837920042686164,
+                "ops": 218.15998611384606,
+                "total": 0.0045837920042686164,
+                "data": [
+                    0.0045837920042686164
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-14]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-14]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 14
+            },
+            "param": "shots_and_results4-14",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.004916917008813471,
+                "max": 0.004916917008813471,
+                "mean": 0.004916917008813471,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.004916917008813471,
+                "iqr": 0.0,
+                "q1": 0.004916917008813471,
+                "q3": 0.004916917008813471,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.004916917008813471,
+                "hd15iqr": 0.004916917008813471,
+                "ops": 203.37947502622495,
+                "total": 0.004916917008813471,
+                "data": [
+                    0.004916917008813471
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-15]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-15]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 15
+            },
+            "param": "shots_and_results4-15",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.004840250010602176,
+                "max": 0.004840250010602176,
+                "mean": 0.004840250010602176,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.004840250010602176,
+                "iqr": 0.0,
+                "q1": 0.004840250010602176,
+                "q3": 0.004840250010602176,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.004840250010602176,
+                "hd15iqr": 0.004840250010602176,
+                "ops": 206.60089826136684,
+                "total": 0.004840250010602176,
+                "data": [
+                    0.004840250010602176
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-16]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-16]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 16
+            },
+            "param": "shots_and_results4-16",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0054152499651536345,
+                "max": 0.0054152499651536345,
+                "mean": 0.0054152499651536345,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0054152499651536345,
+                "iqr": 0.0,
+                "q1": 0.0054152499651536345,
+                "q3": 0.0054152499651536345,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0054152499651536345,
+                "hd15iqr": 0.0054152499651536345,
+                "ops": 184.66368245877072,
+                "total": 0.0054152499651536345,
+                "data": [
+                    0.0054152499651536345
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-17]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-17]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 17
+            },
+            "param": "shots_and_results4-17",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.006259209010750055,
+                "max": 0.006259209010750055,
+                "mean": 0.006259209010750055,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.006259209010750055,
+                "iqr": 0.0,
+                "q1": 0.006259209010750055,
+                "q3": 0.006259209010750055,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.006259209010750055,
+                "hd15iqr": 0.006259209010750055,
+                "ops": 159.76459617861008,
+                "total": 0.006259209010750055,
+                "data": [
+                    0.006259209010750055
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-18]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-18]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 18
+            },
+            "param": "shots_and_results4-18",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.013382332981564105,
+                "max": 0.013382332981564105,
+                "mean": 0.013382332981564105,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.013382332981564105,
+                "iqr": 0.0,
+                "q1": 0.013382332981564105,
+                "q3": 0.013382332981564105,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.013382332981564105,
+                "hd15iqr": 0.013382332981564105,
+                "ops": 74.72538617725544,
+                "total": 0.013382332981564105,
+                "data": [
+                    0.013382332981564105
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-19]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-19]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 19
+            },
+            "param": "shots_and_results4-19",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.013001125014852732,
+                "max": 0.013001125014852732,
+                "mean": 0.013001125014852732,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.013001125014852732,
+                "iqr": 0.0,
+                "q1": 0.013001125014852732,
+                "q3": 0.013001125014852732,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.013001125014852732,
+                "hd15iqr": 0.013001125014852732,
+                "ops": 76.91642060649221,
+                "total": 0.013001125014852732,
+                "data": [
+                    0.013001125014852732
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results4-20]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-20]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "probability"
+                ],
+                "nq": 20
+            },
+            "param": "shots_and_results4-20",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.021054624987300485,
+                "max": 0.021054624987300485,
+                "mean": 0.021054624987300485,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.021054624987300485,
+                "iqr": 0.0,
+                "q1": 0.021054624987300485,
+                "q3": 0.021054624987300485,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.021054624987300485,
+                "hd15iqr": 0.021054624987300485,
+                "ops": 47.49550279822936,
+                "total": 0.021054624987300485,
+                "data": [
+                    0.021054624987300485
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-3]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-3]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 3
+            },
+            "param": "shots_and_results5-3",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.07412141695385799,
+                "max": 0.07412141695385799,
+                "mean": 0.07412141695385799,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.07412141695385799,
+                "iqr": 0.0,
+                "q1": 0.07412141695385799,
+                "q3": 0.07412141695385799,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.07412141695385799,
+                "hd15iqr": 0.07412141695385799,
+                "ops": 13.491377271194361,
+                "total": 0.07412141695385799,
+                "data": [
+                    0.07412141695385799
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-4]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-4]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 4
+            },
+            "param": "shots_and_results5-4",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0023655840195715427,
+                "max": 0.0023655840195715427,
+                "mean": 0.0023655840195715427,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0023655840195715427,
+                "iqr": 0.0,
+                "q1": 0.0023655840195715427,
+                "q3": 0.0023655840195715427,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0023655840195715427,
+                "hd15iqr": 0.0023655840195715427,
+                "ops": 422.7285912174538,
+                "total": 0.0023655840195715427,
+                "data": [
+                    0.0023655840195715427
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-5]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-5]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 5
+            },
+            "param": "shots_and_results5-5",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.002518499968573451,
+                "max": 0.002518499968573451,
+                "mean": 0.002518499968573451,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.002518499968573451,
+                "iqr": 0.0,
+                "q1": 0.002518499968573451,
+                "q3": 0.002518499968573451,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.002518499968573451,
+                "hd15iqr": 0.002518499968573451,
+                "ops": 397.0617480557,
+                "total": 0.002518499968573451,
+                "data": [
+                    0.002518499968573451
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-6]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-6]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 6
+            },
+            "param": "shots_and_results5-6",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.00324737501796335,
+                "max": 0.00324737501796335,
+                "mean": 0.00324737501796335,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.00324737501796335,
+                "iqr": 0.0,
+                "q1": 0.00324737501796335,
+                "q3": 0.00324737501796335,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.00324737501796335,
+                "hd15iqr": 0.00324737501796335,
+                "ops": 307.9410275894677,
+                "total": 0.00324737501796335,
+                "data": [
+                    0.00324737501796335
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-7]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-7]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 7
+            },
+            "param": "shots_and_results5-7",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0029858749476261437,
+                "max": 0.0029858749476261437,
+                "mean": 0.0029858749476261437,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0029858749476261437,
+                "iqr": 0.0,
+                "q1": 0.0029858749476261437,
+                "q3": 0.0029858749476261437,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0029858749476261437,
+                "hd15iqr": 0.0029858749476261437,
+                "ops": 334.9102080765401,
+                "total": 0.0029858749476261437,
+                "data": [
+                    0.0029858749476261437
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-8]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-8]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 8
+            },
+            "param": "shots_and_results5-8",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.003279375028796494,
+                "max": 0.003279375028796494,
+                "mean": 0.003279375028796494,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.003279375028796494,
+                "iqr": 0.0,
+                "q1": 0.003279375028796494,
+                "q3": 0.003279375028796494,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.003279375028796494,
+                "hd15iqr": 0.003279375028796494,
+                "ops": 304.93615131508534,
+                "total": 0.003279375028796494,
+                "data": [
+                    0.003279375028796494
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-9]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-9]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 9
+            },
+            "param": "shots_and_results5-9",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0033004169818013906,
+                "max": 0.0033004169818013906,
+                "mean": 0.0033004169818013906,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0033004169818013906,
+                "iqr": 0.0,
+                "q1": 0.0033004169818013906,
+                "q3": 0.0033004169818013906,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0033004169818013906,
+                "hd15iqr": 0.0033004169818013906,
+                "ops": 302.99201752809824,
+                "total": 0.0033004169818013906,
+                "data": [
+                    0.0033004169818013906
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-10]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-10]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 10
+            },
+            "param": "shots_and_results5-10",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.003565249964594841,
+                "max": 0.003565249964594841,
+                "mean": 0.003565249964594841,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.003565249964594841,
+                "iqr": 0.0,
+                "q1": 0.003565249964594841,
+                "q3": 0.003565249964594841,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.003565249964594841,
+                "hd15iqr": 0.003565249964594841,
+                "ops": 280.4852422496668,
+                "total": 0.003565249964594841,
+                "data": [
+                    0.003565249964594841
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-11]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-11]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 11
+            },
+            "param": "shots_and_results5-11",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0036357499775476754,
+                "max": 0.0036357499775476754,
+                "mean": 0.0036357499775476754,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0036357499775476754,
+                "iqr": 0.0,
+                "q1": 0.0036357499775476754,
+                "q3": 0.0036357499775476754,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0036357499775476754,
+                "hd15iqr": 0.0036357499775476754,
+                "ops": 275.04641578090667,
+                "total": 0.0036357499775476754,
+                "data": [
+                    0.0036357499775476754
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-12]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-12]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 12
+            },
+            "param": "shots_and_results5-12",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0045823329710401595,
+                "max": 0.0045823329710401595,
+                "mean": 0.0045823329710401595,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0045823329710401595,
+                "iqr": 0.0,
+                "q1": 0.0045823329710401595,
+                "q3": 0.0045823329710401595,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0045823329710401595,
+                "hd15iqr": 0.0045823329710401595,
+                "ops": 218.22944912992793,
+                "total": 0.0045823329710401595,
+                "data": [
+                    0.0045823329710401595
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-13]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-13]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 13
+            },
+            "param": "shots_and_results5-13",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.004717584000900388,
+                "max": 0.004717584000900388,
+                "mean": 0.004717584000900388,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.004717584000900388,
+                "iqr": 0.0,
+                "q1": 0.004717584000900388,
+                "q3": 0.004717584000900388,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.004717584000900388,
+                "hd15iqr": 0.004717584000900388,
+                "ops": 211.97290812609637,
+                "total": 0.004717584000900388,
+                "data": [
+                    0.004717584000900388
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-14]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-14]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 14
+            },
+            "param": "shots_and_results5-14",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.004726000013761222,
+                "max": 0.004726000013761222,
+                "mean": 0.004726000013761222,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.004726000013761222,
+                "iqr": 0.0,
+                "q1": 0.004726000013761222,
+                "q3": 0.004726000013761222,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.004726000013761222,
+                "hd15iqr": 0.004726000013761222,
+                "ops": 211.59542892259591,
+                "total": 0.004726000013761222,
+                "data": [
+                    0.004726000013761222
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-15]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-15]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 15
+            },
+            "param": "shots_and_results5-15",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0051437089568935335,
+                "max": 0.0051437089568935335,
+                "mean": 0.0051437089568935335,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0051437089568935335,
+                "iqr": 0.0,
+                "q1": 0.0051437089568935335,
+                "q3": 0.0051437089568935335,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0051437089568935335,
+                "hd15iqr": 0.0051437089568935335,
+                "ops": 194.41224384591447,
+                "total": 0.0051437089568935335,
+                "data": [
+                    0.0051437089568935335
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-16]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-16]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 16
+            },
+            "param": "shots_and_results5-16",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.005437167012132704,
+                "max": 0.005437167012132704,
+                "mean": 0.005437167012132704,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.005437167012132704,
+                "iqr": 0.0,
+                "q1": 0.005437167012132704,
+                "q3": 0.005437167012132704,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.005437167012132704,
+                "hd15iqr": 0.005437167012132704,
+                "ops": 183.91930903879933,
+                "total": 0.005437167012132704,
+                "data": [
+                    0.005437167012132704
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-17]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-17]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 17
+            },
+            "param": "shots_and_results5-17",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.006272958999034017,
+                "max": 0.006272958999034017,
+                "mean": 0.006272958999034017,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.006272958999034017,
+                "iqr": 0.0,
+                "q1": 0.006272958999034017,
+                "q3": 0.006272958999034017,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.006272958999034017,
+                "hd15iqr": 0.006272958999034017,
+                "ops": 159.41440078820722,
+                "total": 0.006272958999034017,
+                "data": [
+                    0.006272958999034017
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-18]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-18]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 18
+            },
+            "param": "shots_and_results5-18",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.007851500005926937,
+                "max": 0.007851500005926937,
+                "mean": 0.007851500005926937,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.007851500005926937,
+                "iqr": 0.0,
+                "q1": 0.007851500005926937,
+                "q3": 0.007851500005926937,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.007851500005926937,
+                "hd15iqr": 0.007851500005926937,
+                "ops": 127.36419782781894,
+                "total": 0.007851500005926937,
+                "data": [
+                    0.007851500005926937
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-19]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-19]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 19
+            },
+            "param": "shots_and_results5-19",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.01259108301019296,
+                "max": 0.01259108301019296,
+                "mean": 0.01259108301019296,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.01259108301019296,
+                "iqr": 0.0,
+                "q1": 0.01259108301019296,
+                "q3": 0.01259108301019296,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.01259108301019296,
+                "hd15iqr": 0.01259108301019296,
+                "ops": 79.42128561859707,
+                "total": 0.01259108301019296,
+                "data": [
+                    0.01259108301019296
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results5-20]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-20]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "expectation z(q[0])"
+                ],
+                "nq": 20
+            },
+            "param": "shots_and_results5-20",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.02228291699429974,
+                "max": 0.02228291699429974,
+                "mean": 0.02228291699429974,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.02228291699429974,
+                "iqr": 0.0,
+                "q1": 0.02228291699429974,
+                "q3": 0.02228291699429974,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.02228291699429974,
+                "hd15iqr": 0.02228291699429974,
+                "ops": 44.87742786349799,
+                "total": 0.02228291699429974,
+                "data": [
+                    0.02228291699429974
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-3]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-3]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 3
+            },
+            "param": "shots_and_results6-3",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.10656795802060515,
+                "max": 0.10656795802060515,
+                "mean": 0.10656795802060515,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.10656795802060515,
+                "iqr": 0.0,
+                "q1": 0.10656795802060515,
+                "q3": 0.10656795802060515,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.10656795802060515,
+                "hd15iqr": 0.10656795802060515,
+                "ops": 9.383683600343058,
+                "total": 0.10656795802060515,
+                "data": [
+                    0.10656795802060515
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-4]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-4]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 4
+            },
+            "param": "shots_and_results6-4",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0024904169840738177,
+                "max": 0.0024904169840738177,
+                "mean": 0.0024904169840738177,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0024904169840738177,
+                "iqr": 0.0,
+                "q1": 0.0024904169840738177,
+                "q3": 0.0024904169840738177,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0024904169840738177,
+                "hd15iqr": 0.0024904169840738177,
+                "ops": 401.53918255255496,
+                "total": 0.0024904169840738177,
+                "data": [
+                    0.0024904169840738177
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-5]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-5]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 5
+            },
+            "param": "shots_and_results6-5",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.002569083997514099,
+                "max": 0.002569083997514099,
+                "mean": 0.002569083997514099,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.002569083997514099,
+                "iqr": 0.0,
+                "q1": 0.002569083997514099,
+                "q3": 0.002569083997514099,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.002569083997514099,
+                "hd15iqr": 0.002569083997514099,
+                "ops": 389.243793105878,
+                "total": 0.002569083997514099,
+                "data": [
+                    0.002569083997514099
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-6]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-6]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 6
+            },
+            "param": "shots_and_results6-6",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0027647920069284737,
+                "max": 0.0027647920069284737,
+                "mean": 0.0027647920069284737,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0027647920069284737,
+                "iqr": 0.0,
+                "q1": 0.0027647920069284737,
+                "q3": 0.0027647920069284737,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0027647920069284737,
+                "hd15iqr": 0.0027647920069284737,
+                "ops": 361.69086046763533,
+                "total": 0.0027647920069284737,
+                "data": [
+                    0.0027647920069284737
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-7]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-7]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 7
+            },
+            "param": "shots_and_results6-7",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0029679579893127084,
+                "max": 0.0029679579893127084,
+                "mean": 0.0029679579893127084,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0029679579893127084,
+                "iqr": 0.0,
+                "q1": 0.0029679579893127084,
+                "q3": 0.0029679579893127084,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0029679579893127084,
+                "hd15iqr": 0.0029679579893127084,
+                "ops": 336.9319928384736,
+                "total": 0.0029679579893127084,
+                "data": [
+                    0.0029679579893127084
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-8]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-8]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 8
+            },
+            "param": "shots_and_results6-8",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.008034416998270899,
+                "max": 0.008034416998270899,
+                "mean": 0.008034416998270899,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.008034416998270899,
+                "iqr": 0.0,
+                "q1": 0.008034416998270899,
+                "q3": 0.008034416998270899,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.008034416998270899,
+                "hd15iqr": 0.008034416998270899,
+                "ops": 124.46453802624531,
+                "total": 0.008034416998270899,
+                "data": [
+                    0.008034416998270899
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-9]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-9]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 9
+            },
+            "param": "shots_and_results6-9",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0036411249893717468,
+                "max": 0.0036411249893717468,
+                "mean": 0.0036411249893717468,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0036411249893717468,
+                "iqr": 0.0,
+                "q1": 0.0036411249893717468,
+                "q3": 0.0036411249893717468,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0036411249893717468,
+                "hd15iqr": 0.0036411249893717468,
+                "ops": 274.64039353742254,
+                "total": 0.0036411249893717468,
+                "data": [
+                    0.0036411249893717468
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-10]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-10]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 10
+            },
+            "param": "shots_and_results6-10",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0037293750210665166,
+                "max": 0.0037293750210665166,
+                "mean": 0.0037293750210665166,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0037293750210665166,
+                "iqr": 0.0,
+                "q1": 0.0037293750210665166,
+                "q3": 0.0037293750210665166,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0037293750210665166,
+                "hd15iqr": 0.0037293750210665166,
+                "ops": 268.1414430973538,
+                "total": 0.0037293750210665166,
+                "data": [
+                    0.0037293750210665166
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-11]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-11]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 11
+            },
+            "param": "shots_and_results6-11",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.004744167032185942,
+                "max": 0.004744167032185942,
+                "mean": 0.004744167032185942,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.004744167032185942,
+                "iqr": 0.0,
+                "q1": 0.004744167032185942,
+                "q3": 0.004744167032185942,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.004744167032185942,
+                "hd15iqr": 0.004744167032185942,
+                "ops": 210.78515853587808,
+                "total": 0.004744167032185942,
+                "data": [
+                    0.004744167032185942
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-12]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-12]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 12
+            },
+            "param": "shots_and_results6-12",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.005379125010222197,
+                "max": 0.005379125010222197,
+                "mean": 0.005379125010222197,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.005379125010222197,
+                "iqr": 0.0,
+                "q1": 0.005379125010222197,
+                "q3": 0.005379125010222197,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.005379125010222197,
+                "hd15iqr": 0.005379125010222197,
+                "ops": 185.90384088483805,
+                "total": 0.005379125010222197,
+                "data": [
+                    0.005379125010222197
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-13]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-13]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 13
+            },
+            "param": "shots_and_results6-13",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.004691459005698562,
+                "max": 0.004691459005698562,
+                "mean": 0.004691459005698562,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.004691459005698562,
+                "iqr": 0.0,
+                "q1": 0.004691459005698562,
+                "q3": 0.004691459005698562,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.004691459005698562,
+                "hd15iqr": 0.004691459005698562,
+                "ops": 213.15330663346577,
+                "total": 0.004691459005698562,
+                "data": [
+                    0.004691459005698562
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-14]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-14]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 14
+            },
+            "param": "shots_and_results6-14",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.004525166004896164,
+                "max": 0.004525166004896164,
+                "mean": 0.004525166004896164,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.004525166004896164,
+                "iqr": 0.0,
+                "q1": 0.004525166004896164,
+                "q3": 0.004525166004896164,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.004525166004896164,
+                "hd15iqr": 0.004525166004896164,
+                "ops": 220.98636799578503,
+                "total": 0.004525166004896164,
+                "data": [
+                    0.004525166004896164
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-15]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-15]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 15
+            },
+            "param": "shots_and_results6-15",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.005676250031683594,
+                "max": 0.005676250031683594,
+                "mean": 0.005676250031683594,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.005676250031683594,
+                "iqr": 0.0,
+                "q1": 0.005676250031683594,
+                "q3": 0.005676250031683594,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.005676250031683594,
+                "hd15iqr": 0.005676250031683594,
+                "ops": 176.17264821285485,
+                "total": 0.005676250031683594,
+                "data": [
+                    0.005676250031683594
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-16]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-16]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 16
+            },
+            "param": "shots_and_results6-16",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.005442874971777201,
+                "max": 0.005442874971777201,
+                "mean": 0.005442874971777201,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.005442874971777201,
+                "iqr": 0.0,
+                "q1": 0.005442874971777201,
+                "q3": 0.005442874971777201,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.005442874971777201,
+                "hd15iqr": 0.005442874971777201,
+                "ops": 183.72643229640113,
+                "total": 0.005442874971777201,
+                "data": [
+                    0.005442874971777201
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-17]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-17]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 17
+            },
+            "param": "shots_and_results6-17",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.006393791001755744,
+                "max": 0.006393791001755744,
+                "mean": 0.006393791001755744,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.006393791001755744,
+                "iqr": 0.0,
+                "q1": 0.006393791001755744,
+                "q3": 0.006393791001755744,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.006393791001755744,
+                "hd15iqr": 0.006393791001755744,
+                "ops": 156.4017340769191,
+                "total": 0.006393791001755744,
+                "data": [
+                    0.006393791001755744
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-18]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-18]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 18
+            },
+            "param": "shots_and_results6-18",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.008627417031675577,
+                "max": 0.008627417031675577,
+                "mean": 0.008627417031675577,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.008627417031675577,
+                "iqr": 0.0,
+                "q1": 0.008627417031675577,
+                "q3": 0.008627417031675577,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.008627417031675577,
+                "hd15iqr": 0.008627417031675577,
+                "ops": 115.90954700908722,
+                "total": 0.008627417031675577,
+                "data": [
+                    0.008627417031675577
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-19]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-19]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 19
+            },
+            "param": "shots_and_results6-19",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.013398082985077053,
+                "max": 0.013398082985077053,
+                "mean": 0.013398082985077053,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.013398082985077053,
+                "iqr": 0.0,
+                "q1": 0.013398082985077053,
+                "q3": 0.013398082985077053,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.013398082985077053,
+                "hd15iqr": 0.013398082985077053,
+                "ops": 74.6375433794381,
+                "total": 0.013398082985077053,
+                "data": [
+                    0.013398082985077053
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results6-20]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-20]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "variance y(q[0])"
+                ],
+                "nq": 20
+            },
+            "param": "shots_and_results6-20",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.023601875000167638,
+                "max": 0.023601875000167638,
+                "mean": 0.023601875000167638,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.023601875000167638,
+                "iqr": 0.0,
+                "q1": 0.023601875000167638,
+                "q3": 0.023601875000167638,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.023601875000167638,
+                "hd15iqr": 0.023601875000167638,
+                "ops": 42.36951513356025,
+                "total": 0.023601875000167638,
+                "data": [
+                    0.023601875000167638
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-3]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-3]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 3
+            },
+            "param": "shots_and_results7-3",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.04172033298527822,
+                "max": 0.04172033298527822,
+                "mean": 0.04172033298527822,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.04172033298527822,
+                "iqr": 0.0,
+                "q1": 0.04172033298527822,
+                "q3": 0.04172033298527822,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.04172033298527822,
+                "hd15iqr": 0.04172033298527822,
+                "ops": 23.969127963404997,
+                "total": 0.04172033298527822,
+                "data": [
+                    0.04172033298527822
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-4]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-4]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 4
+            },
+            "param": "shots_and_results7-4",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.002549666038248688,
+                "max": 0.002549666038248688,
+                "mean": 0.002549666038248688,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.002549666038248688,
+                "iqr": 0.0,
+                "q1": 0.002549666038248688,
+                "q3": 0.002549666038248688,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.002549666038248688,
+                "hd15iqr": 0.002549666038248688,
+                "ops": 392.2082284497459,
+                "total": 0.002549666038248688,
+                "data": [
+                    0.002549666038248688
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-5]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-5]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 5
+            },
+            "param": "shots_and_results7-5",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.002409542037639767,
+                "max": 0.002409542037639767,
+                "mean": 0.002409542037639767,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.002409542037639767,
+                "iqr": 0.0,
+                "q1": 0.002409542037639767,
+                "q3": 0.002409542037639767,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.002409542037639767,
+                "hd15iqr": 0.002409542037639767,
+                "ops": 415.0166232333244,
+                "total": 0.002409542037639767,
+                "data": [
+                    0.002409542037639767
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-6]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-6]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 6
+            },
+            "param": "shots_and_results7-6",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0024610409745946527,
+                "max": 0.0024610409745946527,
+                "mean": 0.0024610409745946527,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0024610409745946527,
+                "iqr": 0.0,
+                "q1": 0.0024610409745946527,
+                "q3": 0.0024610409745946527,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0024610409745946527,
+                "hd15iqr": 0.0024610409745946527,
+                "ops": 406.33212137587657,
+                "total": 0.0024610409745946527,
+                "data": [
+                    0.0024610409745946527
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-7]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-7]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 7
+            },
+            "param": "shots_and_results7-7",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.002603249973617494,
+                "max": 0.002603249973617494,
+                "mean": 0.002603249973617494,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.002603249973617494,
+                "iqr": 0.0,
+                "q1": 0.002603249973617494,
+                "q3": 0.002603249973617494,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.002603249973617494,
+                "hd15iqr": 0.002603249973617494,
+                "ops": 384.13521948888877,
+                "total": 0.002603249973617494,
+                "data": [
+                    0.002603249973617494
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-8]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-8]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 8
+            },
+            "param": "shots_and_results7-8",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.0034407079801894724,
+                "max": 0.0034407079801894724,
+                "mean": 0.0034407079801894724,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.0034407079801894724,
+                "iqr": 0.0,
+                "q1": 0.0034407079801894724,
+                "q3": 0.0034407079801894724,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.0034407079801894724,
+                "hd15iqr": 0.0034407079801894724,
+                "ops": 290.6378587656056,
+                "total": 0.0034407079801894724,
+                "data": [
+                    0.0034407079801894724
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-9]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-9]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 9
+            },
+            "param": "shots_and_results7-9",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.003490457951556891,
+                "max": 0.003490457951556891,
+                "mean": 0.003490457951556891,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.003490457951556891,
+                "iqr": 0.0,
+                "q1": 0.003490457951556891,
+                "q3": 0.003490457951556891,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.003490457951556891,
+                "hd15iqr": 0.003490457951556891,
+                "ops": 286.49535788103617,
+                "total": 0.003490457951556891,
+                "data": [
+                    0.003490457951556891
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-10]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-10]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 10
+            },
+            "param": "shots_and_results7-10",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.004947667010128498,
+                "max": 0.004947667010128498,
+                "mean": 0.004947667010128498,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.004947667010128498,
+                "iqr": 0.0,
+                "q1": 0.004947667010128498,
+                "q3": 0.004947667010128498,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.004947667010128498,
+                "hd15iqr": 0.004947667010128498,
+                "ops": 202.11546127758274,
+                "total": 0.004947667010128498,
+                "data": [
+                    0.004947667010128498
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-11]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-11]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 11
+            },
+            "param": "shots_and_results7-11",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.003849416971206665,
+                "max": 0.003849416971206665,
+                "mean": 0.003849416971206665,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.003849416971206665,
+                "iqr": 0.0,
+                "q1": 0.003849416971206665,
+                "q3": 0.003849416971206665,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.003849416971206665,
+                "hd15iqr": 0.003849416971206665,
+                "ops": 259.7795997367708,
+                "total": 0.003849416971206665,
+                "data": [
+                    0.003849416971206665
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-12]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-12]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 12
+            },
+            "param": "shots_and_results7-12",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.005518499994650483,
+                "max": 0.005518499994650483,
+                "mean": 0.005518499994650483,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.005518499994650483,
+                "iqr": 0.0,
+                "q1": 0.005518499994650483,
+                "q3": 0.005518499994650483,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.005518499994650483,
+                "hd15iqr": 0.005518499994650483,
+                "ops": 181.20866194969264,
+                "total": 0.005518499994650483,
+                "data": [
+                    0.005518499994650483
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-13]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-13]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 13
+            },
+            "param": "shots_and_results7-13",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.005429374985396862,
+                "max": 0.005429374985396862,
+                "mean": 0.005429374985396862,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.005429374985396862,
+                "iqr": 0.0,
+                "q1": 0.005429374985396862,
+                "q3": 0.005429374985396862,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.005429374985396862,
+                "hd15iqr": 0.005429374985396862,
+                "ops": 184.18326284142347,
+                "total": 0.005429374985396862,
+                "data": [
+                    0.005429374985396862
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-14]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-14]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 14
+            },
+            "param": "shots_and_results7-14",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.004841040994506329,
+                "max": 0.004841040994506329,
+                "mean": 0.004841040994506329,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.004841040994506329,
+                "iqr": 0.0,
+                "q1": 0.004841040994506329,
+                "q3": 0.004841040994506329,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.004841040994506329,
+                "hd15iqr": 0.004841040994506329,
+                "ops": 206.56714147531736,
+                "total": 0.004841040994506329,
+                "data": [
+                    0.004841040994506329
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-15]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-15]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 15
+            },
+            "param": "shots_and_results7-15",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.005831082991790026,
+                "max": 0.005831082991790026,
+                "mean": 0.005831082991790026,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.005831082991790026,
+                "iqr": 0.0,
+                "q1": 0.005831082991790026,
+                "q3": 0.005831082991790026,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.005831082991790026,
+                "hd15iqr": 0.005831082991790026,
+                "ops": 171.4947294367045,
+                "total": 0.005831082991790026,
+                "data": [
+                    0.005831082991790026
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-16]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-16]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 16
+            },
+            "param": "shots_and_results7-16",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.005832041031681001,
+                "max": 0.005832041031681001,
+                "mean": 0.005832041031681001,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.005832041031681001,
+                "iqr": 0.0,
+                "q1": 0.005832041031681001,
+                "q3": 0.005832041031681001,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.005832041031681001,
+                "hd15iqr": 0.005832041031681001,
+                "ops": 171.46655768842638,
+                "total": 0.005832041031681001,
+                "data": [
+                    0.005832041031681001
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-17]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-17]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 17
+            },
+            "param": "shots_and_results7-17",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.007709417026489973,
+                "max": 0.007709417026489973,
+                "mean": 0.007709417026489973,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.007709417026489973,
+                "iqr": 0.0,
+                "q1": 0.007709417026489973,
+                "q3": 0.007709417026489973,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.007709417026489973,
+                "hd15iqr": 0.007709417026489973,
+                "ops": 129.71149395135146,
+                "total": 0.007709417026489973,
+                "data": [
+                    0.007709417026489973
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-18]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-18]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 18
+            },
+            "param": "shots_and_results7-18",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.014526000013574958,
+                "max": 0.014526000013574958,
+                "mean": 0.014526000013574958,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.014526000013574958,
+                "iqr": 0.0,
+                "q1": 0.014526000013574958,
+                "q3": 0.014526000013574958,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.014526000013574958,
+                "hd15iqr": 0.014526000013574958,
+                "ops": 68.84207621268565,
+                "total": 0.014526000013574958,
+                "data": [
+                    0.014526000013574958
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-19]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-19]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 19
+            },
+            "param": "shots_and_results7-19",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.011261124978773296,
+                "max": 0.011261124978773296,
+                "mean": 0.011261124978773296,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.011261124978773296,
+                "iqr": 0.0,
+                "q1": 0.011261124978773296,
+                "q3": 0.011261124978773296,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.011261124978773296,
+                "hd15iqr": 0.011261124978773296,
+                "ops": 88.80107466038731,
+                "total": 0.011261124978773296,
+                "data": [
+                    0.011261124978773296
+                ],
+                "iterations": 1
+            }
+        },
+        {
+            "group": null,
+            "name": "test_benchmark[shots_and_results7-20]",
+            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-20]",
+            "params": {
+                "shots_and_results": [
+                    100,
+                    "sample z(q[0])"
+                ],
+                "nq": 20
+            },
+            "param": "shots_and_results7-20",
+            "extra_info": {},
+            "options": {
+                "disable_gc": false,
+                "timer": "perf_counter",
+                "min_rounds": 5,
+                "max_time": 1.0,
+                "min_time": 5e-06,
+                "warmup": false
+            },
+            "stats": {
+                "min": 0.02057291701203212,
+                "max": 0.02057291701203212,
+                "mean": 0.02057291701203212,
+                "stddev": 0,
+                "rounds": 1,
+                "median": 0.02057291701203212,
+                "iqr": 0.0,
+                "q1": 0.02057291701203212,
+                "q3": 0.02057291701203212,
+                "iqr_outliers": 0,
+                "stddev_outliers": 0,
+                "outliers": "0;0",
+                "ld15iqr": 0.02057291701203212,
+                "hd15iqr": 0.02057291701203212,
+                "ops": 48.60759412071451,
+                "total": 0.02057291701203212,
+                "data": [
+                    0.02057291701203212
+                ],
+                "iterations": 1
+            }
+        }
+    ],
+    "datetime": "2024-08-27T18:31:42.399972",
+    "version": "4.0.0"
+}
\ No newline at end of file

From 228932f72297df3172b54ad32362d0f9cb257970 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Tue, 27 Aug 2024 14:36:14 -0400
Subject: [PATCH 16/20] fix: Actually include benchmark script

---
 benchmark/benchmark.py | 41 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 41 insertions(+)
 create mode 100644 benchmark/benchmark.py

diff --git a/benchmark/benchmark.py b/benchmark/benchmark.py
new file mode 100644
index 0000000..aaae1cd
--- /dev/null
+++ b/benchmark/benchmark.py
@@ -0,0 +1,41 @@
+import numpy as np
+import pytest
+from braket.devices import LocalSimulator
+from braket.ir.openqasm import Program
+
+# always the same for repeatability
+np.random.seed(0x1C2C6D66)
+
+n_qubits = range(3, 21)
+shots_and_results = (
+    (0, "state_vector"),
+    (0, "probability"),
+    (0, "expectation z(q[0])"),
+    (0, "variance y(q[0])"),
+    (100, "probability"),
+    (100, "expectation z(q[0])"),
+    (100, "variance y(q[0])"),
+    (100, "sample z(q[0])"),
+)
+
+
+def generate_ghz(nq: int, result_type: str):
+    source = f"OPENQASM 3.0;\nqubit[{nq}] q;\nh q[0];\n"
+    for q in range(1, nq - 1):
+        source += f"cnot q[0], q[{q}];\n"
+
+    source += f"#pragma braket result {result_type}\n"
+    return source
+
+
+def run_sim(oq3_prog, sim, shots):
+    sim.run(oq3_prog, shots=shots)
+    return
+
+
+@pytest.mark.parametrize("nq", n_qubits)
+@pytest.mark.parametrize("shots_and_results", shots_and_results)
+def test_benchmark(benchmark, nq, shots_and_results):
+    shots, result_type = shots_and_results
+    oq3_prog = Program(source=generate_ghz(nq, result_type))
+    benchmark.pedantic(run_sim, args=(oq3_prog, LocalSimulator("braket_sv_v2"), shots))

From 2280398c3c799ed7e425be74d2876c0b7a4d542f Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Tue, 27 Aug 2024 14:48:12 -0400
Subject: [PATCH 17/20] fix: Don't deploy benchmark results to gh-pages

---
 .github/workflows/benchmark.yml | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
index 36c09e4..3916697 100644
--- a/.github/workflows/benchmark.yml
+++ b/.github/workflows/benchmark.yml
@@ -37,8 +37,9 @@ jobs:
         name: Python Benchmark with pytest-benchmark
         tool: 'pytest'
         output-file-path: benchmark/output.json
-        github-token: ${{ secrets.GITHUB_TOKEN }}
-        auto-push: true
+        # don't auto-deploy to gh-pages for now
+        #github-token: ${{ secrets.GITHUB_TOKEN }}
+        #auto-push: true
         # Show alert with commit comment on detecting possible performance regression
         alert-threshold: '200%'
         comment-on-alert: true

From e18ad32da63c12f58d96cf4d8f2b6b8e8bc4897f Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Tue, 27 Aug 2024 14:54:43 -0400
Subject: [PATCH 18/20] fix: restore GH token

---
 .github/workflows/benchmark.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
index 3916697..5c8537b 100644
--- a/.github/workflows/benchmark.yml
+++ b/.github/workflows/benchmark.yml
@@ -37,8 +37,8 @@ jobs:
         name: Python Benchmark with pytest-benchmark
         tool: 'pytest'
         output-file-path: benchmark/output.json
+        github-token: ${{ secrets.GITHUB_TOKEN }}
         # don't auto-deploy to gh-pages for now
-        #github-token: ${{ secrets.GITHUB_TOKEN }}
         #auto-push: true
         # Show alert with commit comment on detecting possible performance regression
         alert-threshold: '200%'

From b10144a330bd992c147fee253812b8bdf155cbba Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Tue, 27 Aug 2024 15:29:13 -0400
Subject: [PATCH 19/20] fix: Remove benchmarks for now

---
 .github/workflows/benchmark.yml |   46 -
 benchmark/benchmark.py          |   41 -
 benchmark/output.json           | 6379 -------------------------------
 3 files changed, 6466 deletions(-)
 delete mode 100644 .github/workflows/benchmark.yml
 delete mode 100644 benchmark/benchmark.py
 delete mode 100644 benchmark/output.json

diff --git a/.github/workflows/benchmark.yml b/.github/workflows/benchmark.yml
deleted file mode 100644
index 5c8537b..0000000
--- a/.github/workflows/benchmark.yml
+++ /dev/null
@@ -1,46 +0,0 @@
-name: Benchmark
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-
-jobs:
-  benchmark:
-    runs-on: ubuntu-latest
-    timeout-minutes: 30
-    steps:
-    - uses: actions/checkout@v4
-    - name: Install juliaup
-      uses: julia-actions/install-juliaup@v2.1.2
-      with:
-        channel: '1'
-    - name: Update Julia registry 
-      shell: julia --project=. --color=yes {0}
-      run: |
-        using Pkg
-        Pkg.Registry.update()
-    - name: Set up Python
-      uses: actions/setup-python@v5
-      with:
-        python-version: 3.9
-    - name: Install dependencies
-      run: |
-        pip install -e .[test] # to put juliapkg.json in sys.path
-        python -c 'import juliacall' # force install of all deps
-    - name: Benchmark
-      run: |
-        pytest -n 0 benchmark/benchmark.py --benchmark-json=benchmark/output.json
-    - name: Store benchmark result
-      uses: benchmark-action/github-action-benchmark@v1
-      with:
-        name: Python Benchmark with pytest-benchmark
-        tool: 'pytest'
-        output-file-path: benchmark/output.json
-        github-token: ${{ secrets.GITHUB_TOKEN }}
-        # don't auto-deploy to gh-pages for now
-        #auto-push: true
-        # Show alert with commit comment on detecting possible performance regression
-        alert-threshold: '200%'
-        comment-on-alert: true
-        fail-on-alert: true
diff --git a/benchmark/benchmark.py b/benchmark/benchmark.py
deleted file mode 100644
index aaae1cd..0000000
--- a/benchmark/benchmark.py
+++ /dev/null
@@ -1,41 +0,0 @@
-import numpy as np
-import pytest
-from braket.devices import LocalSimulator
-from braket.ir.openqasm import Program
-
-# always the same for repeatability
-np.random.seed(0x1C2C6D66)
-
-n_qubits = range(3, 21)
-shots_and_results = (
-    (0, "state_vector"),
-    (0, "probability"),
-    (0, "expectation z(q[0])"),
-    (0, "variance y(q[0])"),
-    (100, "probability"),
-    (100, "expectation z(q[0])"),
-    (100, "variance y(q[0])"),
-    (100, "sample z(q[0])"),
-)
-
-
-def generate_ghz(nq: int, result_type: str):
-    source = f"OPENQASM 3.0;\nqubit[{nq}] q;\nh q[0];\n"
-    for q in range(1, nq - 1):
-        source += f"cnot q[0], q[{q}];\n"
-
-    source += f"#pragma braket result {result_type}\n"
-    return source
-
-
-def run_sim(oq3_prog, sim, shots):
-    sim.run(oq3_prog, shots=shots)
-    return
-
-
-@pytest.mark.parametrize("nq", n_qubits)
-@pytest.mark.parametrize("shots_and_results", shots_and_results)
-def test_benchmark(benchmark, nq, shots_and_results):
-    shots, result_type = shots_and_results
-    oq3_prog = Program(source=generate_ghz(nq, result_type))
-    benchmark.pedantic(run_sim, args=(oq3_prog, LocalSimulator("braket_sv_v2"), shots))
diff --git a/benchmark/output.json b/benchmark/output.json
deleted file mode 100644
index 717f68c..0000000
--- a/benchmark/output.json
+++ /dev/null
@@ -1,6379 +0,0 @@
-{
-    "machine_info": {
-        "node": "c889f3b9ffb2",
-        "processor": "arm",
-        "machine": "arm64",
-        "python_compiler": "Clang 15.0.0 (clang-1500.1.0.2.5)",
-        "python_implementation": "CPython",
-        "python_implementation_version": "3.10.14",
-        "python_version": "3.10.14",
-        "python_build": [
-            "main",
-            "Mar 19 2024 21:46:16"
-        ],
-        "release": "22.6.0",
-        "system": "Darwin",
-        "cpu": {
-            "python_version": "3.10.14.final.0 (64 bit)",
-            "cpuinfo_version": [
-                9,
-                0,
-                0
-            ],
-            "cpuinfo_version_string": "9.0.0",
-            "arch": "ARM_8",
-            "bits": 64,
-            "count": 10,
-            "arch_string_raw": "arm64",
-            "brand_raw": "Apple M1 Pro"
-        }
-    },
-    "commit_info": {
-        "id": "b62a8f97158805b56e883c821052a9f71830e335",
-        "time": "2024-08-27T14:15:11-04:00",
-        "author_time": "2024-08-27T14:15:11-04:00",
-        "dirty": false,
-        "project": "amazon-braket-julia-simulator",
-        "branch": "ksh/speed"
-    },
-    "benchmarks": [
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-3]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-3]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 3
-            },
-            "param": "shots_and_results0-3",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.11085466598160565,
-                "max": 0.11085466598160565,
-                "mean": 0.11085466598160565,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.11085466598160565,
-                "iqr": 0.0,
-                "q1": 0.11085466598160565,
-                "q3": 0.11085466598160565,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.11085466598160565,
-                "hd15iqr": 0.11085466598160565,
-                "ops": 9.020820108428563,
-                "total": 0.11085466598160565,
-                "data": [
-                    0.11085466598160565
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-4]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-4]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 4
-            },
-            "param": "shots_and_results0-4",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0015520419692620635,
-                "max": 0.0015520419692620635,
-                "mean": 0.0015520419692620635,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0015520419692620635,
-                "iqr": 0.0,
-                "q1": 0.0015520419692620635,
-                "q3": 0.0015520419692620635,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0015520419692620635,
-                "hd15iqr": 0.0015520419692620635,
-                "ops": 644.3124733769034,
-                "total": 0.0015520419692620635,
-                "data": [
-                    0.0015520419692620635
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-5]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-5]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 5
-            },
-            "param": "shots_and_results0-5",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0011728749959729612,
-                "max": 0.0011728749959729612,
-                "mean": 0.0011728749959729612,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0011728749959729612,
-                "iqr": 0.0,
-                "q1": 0.0011728749959729612,
-                "q3": 0.0011728749959729612,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0011728749959729612,
-                "hd15iqr": 0.0011728749959729612,
-                "ops": 852.6057793315371,
-                "total": 0.0011728749959729612,
-                "data": [
-                    0.0011728749959729612
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-6]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-6]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 6
-            },
-            "param": "shots_and_results0-6",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0019042500061914325,
-                "max": 0.0019042500061914325,
-                "mean": 0.0019042500061914325,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0019042500061914325,
-                "iqr": 0.0,
-                "q1": 0.0019042500061914325,
-                "q3": 0.0019042500061914325,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0019042500061914325,
-                "hd15iqr": 0.0019042500061914325,
-                "ops": 525.1411299717075,
-                "total": 0.0019042500061914325,
-                "data": [
-                    0.0019042500061914325
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-7]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-7]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 7
-            },
-            "param": "shots_and_results0-7",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0013667920138686895,
-                "max": 0.0013667920138686895,
-                "mean": 0.0013667920138686895,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0013667920138686895,
-                "iqr": 0.0,
-                "q1": 0.0013667920138686895,
-                "q3": 0.0013667920138686895,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0013667920138686895,
-                "hd15iqr": 0.0013667920138686895,
-                "ops": 731.6402128876296,
-                "total": 0.0013667920138686895,
-                "data": [
-                    0.0013667920138686895
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-8]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-8]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 8
-            },
-            "param": "shots_and_results0-8",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0016128330025821924,
-                "max": 0.0016128330025821924,
-                "mean": 0.0016128330025821924,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0016128330025821924,
-                "iqr": 0.0,
-                "q1": 0.0016128330025821924,
-                "q3": 0.0016128330025821924,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0016128330025821924,
-                "hd15iqr": 0.0016128330025821924,
-                "ops": 620.0269949827235,
-                "total": 0.0016128330025821924,
-                "data": [
-                    0.0016128330025821924
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-9]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-9]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 9
-            },
-            "param": "shots_and_results0-9",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.001757332996930927,
-                "max": 0.001757332996930927,
-                "mean": 0.001757332996930927,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.001757332996930927,
-                "iqr": 0.0,
-                "q1": 0.001757332996930927,
-                "q3": 0.001757332996930927,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.001757332996930927,
-                "hd15iqr": 0.001757332996930927,
-                "ops": 569.0441150006503,
-                "total": 0.001757332996930927,
-                "data": [
-                    0.001757332996930927
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-10]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-10]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 10
-            },
-            "param": "shots_and_results0-10",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0021038329578004777,
-                "max": 0.0021038329578004777,
-                "mean": 0.0021038329578004777,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0021038329578004777,
-                "iqr": 0.0,
-                "q1": 0.0021038329578004777,
-                "q3": 0.0021038329578004777,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0021038329578004777,
-                "hd15iqr": 0.0021038329578004777,
-                "ops": 475.3229082623952,
-                "total": 0.0021038329578004777,
-                "data": [
-                    0.0021038329578004777
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-11]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-11]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 11
-            },
-            "param": "shots_and_results0-11",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0031469999812543392,
-                "max": 0.0031469999812543392,
-                "mean": 0.0031469999812543392,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0031469999812543392,
-                "iqr": 0.0,
-                "q1": 0.0031469999812543392,
-                "q3": 0.0031469999812543392,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0031469999812543392,
-                "hd15iqr": 0.0031469999812543392,
-                "ops": 317.7629507329763,
-                "total": 0.0031469999812543392,
-                "data": [
-                    0.0031469999812543392
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-12]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-12]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 12
-            },
-            "param": "shots_and_results0-12",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.004438042000401765,
-                "max": 0.004438042000401765,
-                "mean": 0.004438042000401765,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.004438042000401765,
-                "iqr": 0.0,
-                "q1": 0.004438042000401765,
-                "q3": 0.004438042000401765,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.004438042000401765,
-                "hd15iqr": 0.004438042000401765,
-                "ops": 225.32459131965683,
-                "total": 0.004438042000401765,
-                "data": [
-                    0.004438042000401765
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-13]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-13]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 13
-            },
-            "param": "shots_and_results0-13",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.00672875001328066,
-                "max": 0.00672875001328066,
-                "mean": 0.00672875001328066,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.00672875001328066,
-                "iqr": 0.0,
-                "q1": 0.00672875001328066,
-                "q3": 0.00672875001328066,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.00672875001328066,
-                "hd15iqr": 0.00672875001328066,
-                "ops": 148.616013082115,
-                "total": 0.00672875001328066,
-                "data": [
-                    0.00672875001328066
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-14]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-14]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 14
-            },
-            "param": "shots_and_results0-14",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.012640959001146257,
-                "max": 0.012640959001146257,
-                "mean": 0.012640959001146257,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.012640959001146257,
-                "iqr": 0.0,
-                "q1": 0.012640959001146257,
-                "q3": 0.012640959001146257,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.012640959001146257,
-                "hd15iqr": 0.012640959001146257,
-                "ops": 79.10792210538156,
-                "total": 0.012640959001146257,
-                "data": [
-                    0.012640959001146257
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-15]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-15]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 15
-            },
-            "param": "shots_and_results0-15",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.021296833001542836,
-                "max": 0.021296833001542836,
-                "mean": 0.021296833001542836,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.021296833001542836,
-                "iqr": 0.0,
-                "q1": 0.021296833001542836,
-                "q3": 0.021296833001542836,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.021296833001542836,
-                "hd15iqr": 0.021296833001542836,
-                "ops": 46.95533837954007,
-                "total": 0.021296833001542836,
-                "data": [
-                    0.021296833001542836
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-16]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-16]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 16
-            },
-            "param": "shots_and_results0-16",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.08103887503966689,
-                "max": 0.08103887503966689,
-                "mean": 0.08103887503966689,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.08103887503966689,
-                "iqr": 0.0,
-                "q1": 0.08103887503966689,
-                "q3": 0.08103887503966689,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.08103887503966689,
-                "hd15iqr": 0.08103887503966689,
-                "ops": 12.339756684807387,
-                "total": 0.08103887503966689,
-                "data": [
-                    0.08103887503966689
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-17]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-17]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 17
-            },
-            "param": "shots_and_results0-17",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.11963962495792657,
-                "max": 0.11963962495792657,
-                "mean": 0.11963962495792657,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.11963962495792657,
-                "iqr": 0.0,
-                "q1": 0.11963962495792657,
-                "q3": 0.11963962495792657,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.11963962495792657,
-                "hd15iqr": 0.11963962495792657,
-                "ops": 8.358434760654491,
-                "total": 0.11963962495792657,
-                "data": [
-                    0.11963962495792657
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-18]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-18]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 18
-            },
-            "param": "shots_and_results0-18",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.26072500000009313,
-                "max": 0.26072500000009313,
-                "mean": 0.26072500000009313,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.26072500000009313,
-                "iqr": 0.0,
-                "q1": 0.26072500000009313,
-                "q3": 0.26072500000009313,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.26072500000009313,
-                "hd15iqr": 0.26072500000009313,
-                "ops": 3.835458816759585,
-                "total": 0.26072500000009313,
-                "data": [
-                    0.26072500000009313
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-19]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-19]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 19
-            },
-            "param": "shots_and_results0-19",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.4268693749909289,
-                "max": 0.4268693749909289,
-                "mean": 0.4268693749909289,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.4268693749909289,
-                "iqr": 0.0,
-                "q1": 0.4268693749909289,
-                "q3": 0.4268693749909289,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.4268693749909289,
-                "hd15iqr": 0.4268693749909289,
-                "ops": 2.34263701869278,
-                "total": 0.4268693749909289,
-                "data": [
-                    0.4268693749909289
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results0-20]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results0-20]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "state_vector"
-                ],
-                "nq": 20
-            },
-            "param": "shots_and_results0-20",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.794439000019338,
-                "max": 0.794439000019338,
-                "mean": 0.794439000019338,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.794439000019338,
-                "iqr": 0.0,
-                "q1": 0.794439000019338,
-                "q3": 0.794439000019338,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.794439000019338,
-                "hd15iqr": 0.794439000019338,
-                "ops": 1.2587498851084329,
-                "total": 0.794439000019338,
-                "data": [
-                    0.794439000019338
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-3]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-3]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 3
-            },
-            "param": "shots_and_results1-3",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.020558208983857185,
-                "max": 0.020558208983857185,
-                "mean": 0.020558208983857185,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.020558208983857185,
-                "iqr": 0.0,
-                "q1": 0.020558208983857185,
-                "q3": 0.020558208983857185,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.020558208983857185,
-                "hd15iqr": 0.020558208983857185,
-                "ops": 48.64236961426089,
-                "total": 0.020558208983857185,
-                "data": [
-                    0.020558208983857185
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-4]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-4]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 4
-            },
-            "param": "shots_and_results1-4",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0013599999947473407,
-                "max": 0.0013599999947473407,
-                "mean": 0.0013599999947473407,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0013599999947473407,
-                "iqr": 0.0,
-                "q1": 0.0013599999947473407,
-                "q3": 0.0013599999947473407,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0013599999947473407,
-                "hd15iqr": 0.0013599999947473407,
-                "ops": 735.2941204869481,
-                "total": 0.0013599999947473407,
-                "data": [
-                    0.0013599999947473407
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-5]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-5]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 5
-            },
-            "param": "shots_and_results1-5",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0011040419922210276,
-                "max": 0.0011040419922210276,
-                "mean": 0.0011040419922210276,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0011040419922210276,
-                "iqr": 0.0,
-                "q1": 0.0011040419922210276,
-                "q3": 0.0011040419922210276,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0011040419922210276,
-                "hd15iqr": 0.0011040419922210276,
-                "ops": 905.7626494697689,
-                "total": 0.0011040419922210276,
-                "data": [
-                    0.0011040419922210276
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-6]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-6]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 6
-            },
-            "param": "shots_and_results1-6",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0013118329807184637,
-                "max": 0.0013118329807184637,
-                "mean": 0.0013118329807184637,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0013118329807184637,
-                "iqr": 0.0,
-                "q1": 0.0013118329807184637,
-                "q3": 0.0013118329807184637,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0013118329807184637,
-                "hd15iqr": 0.0013118329807184637,
-                "ops": 762.2921627205322,
-                "total": 0.0013118329807184637,
-                "data": [
-                    0.0013118329807184637
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-7]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-7]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 7
-            },
-            "param": "shots_and_results1-7",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.001469499955419451,
-                "max": 0.001469499955419451,
-                "mean": 0.001469499955419451,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.001469499955419451,
-                "iqr": 0.0,
-                "q1": 0.001469499955419451,
-                "q3": 0.001469499955419451,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.001469499955419451,
-                "hd15iqr": 0.001469499955419451,
-                "ops": 680.5035932883455,
-                "total": 0.001469499955419451,
-                "data": [
-                    0.001469499955419451
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-8]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-8]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 8
-            },
-            "param": "shots_and_results1-8",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0013899999903514981,
-                "max": 0.0013899999903514981,
-                "mean": 0.0013899999903514981,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0013899999903514981,
-                "iqr": 0.0,
-                "q1": 0.0013899999903514981,
-                "q3": 0.0013899999903514981,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0013899999903514981,
-                "hd15iqr": 0.0013899999903514981,
-                "ops": 719.4244654254449,
-                "total": 0.0013899999903514981,
-                "data": [
-                    0.0013899999903514981
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-9]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-9]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 9
-            },
-            "param": "shots_and_results1-9",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.001814916031435132,
-                "max": 0.001814916031435132,
-                "mean": 0.001814916031435132,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.001814916031435132,
-                "iqr": 0.0,
-                "q1": 0.001814916031435132,
-                "q3": 0.001814916031435132,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.001814916031435132,
-                "hd15iqr": 0.001814916031435132,
-                "ops": 550.9896781336253,
-                "total": 0.001814916031435132,
-                "data": [
-                    0.001814916031435132
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-10]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-10]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 10
-            },
-            "param": "shots_and_results1-10",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.002677417011000216,
-                "max": 0.002677417011000216,
-                "mean": 0.002677417011000216,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.002677417011000216,
-                "iqr": 0.0,
-                "q1": 0.002677417011000216,
-                "q3": 0.002677417011000216,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.002677417011000216,
-                "hd15iqr": 0.002677417011000216,
-                "ops": 373.494302864097,
-                "total": 0.002677417011000216,
-                "data": [
-                    0.002677417011000216
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-11]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-11]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 11
-            },
-            "param": "shots_and_results1-11",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.003303209028672427,
-                "max": 0.003303209028672427,
-                "mean": 0.003303209028672427,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.003303209028672427,
-                "iqr": 0.0,
-                "q1": 0.003303209028672427,
-                "q3": 0.003303209028672427,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.003303209028672427,
-                "hd15iqr": 0.003303209028672427,
-                "ops": 302.735912659425,
-                "total": 0.003303209028672427,
-                "data": [
-                    0.003303209028672427
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-12]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-12]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 12
-            },
-            "param": "shots_and_results1-12",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.003958083980251104,
-                "max": 0.003958083980251104,
-                "mean": 0.003958083980251104,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.003958083980251104,
-                "iqr": 0.0,
-                "q1": 0.003958083980251104,
-                "q3": 0.003958083980251104,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.003958083980251104,
-                "hd15iqr": 0.003958083980251104,
-                "ops": 252.64749434057214,
-                "total": 0.003958083980251104,
-                "data": [
-                    0.003958083980251104
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-13]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-13]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 13
-            },
-            "param": "shots_and_results1-13",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.004732333007268608,
-                "max": 0.004732333007268608,
-                "mean": 0.004732333007268608,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.004732333007268608,
-                "iqr": 0.0,
-                "q1": 0.004732333007268608,
-                "q3": 0.004732333007268608,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.004732333007268608,
-                "hd15iqr": 0.004732333007268608,
-                "ops": 211.31226362642994,
-                "total": 0.004732333007268608,
-                "data": [
-                    0.004732333007268608
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-14]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-14]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 14
-            },
-            "param": "shots_and_results1-14",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.00856354198185727,
-                "max": 0.00856354198185727,
-                "mean": 0.00856354198185727,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.00856354198185727,
-                "iqr": 0.0,
-                "q1": 0.00856354198185727,
-                "q3": 0.00856354198185727,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.00856354198185727,
-                "hd15iqr": 0.00856354198185727,
-                "ops": 116.77411077315918,
-                "total": 0.00856354198185727,
-                "data": [
-                    0.00856354198185727
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-15]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-15]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 15
-            },
-            "param": "shots_and_results1-15",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.014807707979343832,
-                "max": 0.014807707979343832,
-                "mean": 0.014807707979343832,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.014807707979343832,
-                "iqr": 0.0,
-                "q1": 0.014807707979343832,
-                "q3": 0.014807707979343832,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.014807707979343832,
-                "hd15iqr": 0.014807707979343832,
-                "ops": 67.53239605987372,
-                "total": 0.014807707979343832,
-                "data": [
-                    0.014807707979343832
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-16]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-16]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 16
-            },
-            "param": "shots_and_results1-16",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.030338832992129028,
-                "max": 0.030338832992129028,
-                "mean": 0.030338832992129028,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.030338832992129028,
-                "iqr": 0.0,
-                "q1": 0.030338832992129028,
-                "q3": 0.030338832992129028,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.030338832992129028,
-                "hd15iqr": 0.030338832992129028,
-                "ops": 32.96105688242641,
-                "total": 0.030338832992129028,
-                "data": [
-                    0.030338832992129028
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-17]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-17]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 17
-            },
-            "param": "shots_and_results1-17",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.058687000011559576,
-                "max": 0.058687000011559576,
-                "mean": 0.058687000011559576,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.058687000011559576,
-                "iqr": 0.0,
-                "q1": 0.058687000011559576,
-                "q3": 0.058687000011559576,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.058687000011559576,
-                "hd15iqr": 0.058687000011559576,
-                "ops": 17.039548789391688,
-                "total": 0.058687000011559576,
-                "data": [
-                    0.058687000011559576
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-18]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-18]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 18
-            },
-            "param": "shots_and_results1-18",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.10794875002466142,
-                "max": 0.10794875002466142,
-                "mean": 0.10794875002466142,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.10794875002466142,
-                "iqr": 0.0,
-                "q1": 0.10794875002466142,
-                "q3": 0.10794875002466142,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.10794875002466142,
-                "hd15iqr": 0.10794875002466142,
-                "ops": 9.263655204636876,
-                "total": 0.10794875002466142,
-                "data": [
-                    0.10794875002466142
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-19]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-19]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 19
-            },
-            "param": "shots_and_results1-19",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.2157110829721205,
-                "max": 0.2157110829721205,
-                "mean": 0.2157110829721205,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.2157110829721205,
-                "iqr": 0.0,
-                "q1": 0.2157110829721205,
-                "q3": 0.2157110829721205,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.2157110829721205,
-                "hd15iqr": 0.2157110829721205,
-                "ops": 4.635830418269443,
-                "total": 0.2157110829721205,
-                "data": [
-                    0.2157110829721205
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results1-20]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results1-20]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "probability"
-                ],
-                "nq": 20
-            },
-            "param": "shots_and_results1-20",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.4330306670162827,
-                "max": 0.4330306670162827,
-                "mean": 0.4330306670162827,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.4330306670162827,
-                "iqr": 0.0,
-                "q1": 0.4330306670162827,
-                "q3": 0.4330306670162827,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.4330306670162827,
-                "hd15iqr": 0.4330306670162827,
-                "ops": 2.3093052667385296,
-                "total": 0.4330306670162827,
-                "data": [
-                    0.4330306670162827
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-3]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-3]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 3
-            },
-            "param": "shots_and_results2-3",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0015866249450482428,
-                "max": 0.0015866249450482428,
-                "mean": 0.0015866249450482428,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0015866249450482428,
-                "iqr": 0.0,
-                "q1": 0.0015866249450482428,
-                "q3": 0.0015866249450482428,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0015866249450482428,
-                "hd15iqr": 0.0015866249450482428,
-                "ops": 630.2686738418789,
-                "total": 0.0015866249450482428,
-                "data": [
-                    0.0015866249450482428
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-4]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-4]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 4
-            },
-            "param": "shots_and_results2-4",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0013286250177770853,
-                "max": 0.0013286250177770853,
-                "mean": 0.0013286250177770853,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0013286250177770853,
-                "iqr": 0.0,
-                "q1": 0.0013286250177770853,
-                "q3": 0.0013286250177770853,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0013286250177770853,
-                "hd15iqr": 0.0013286250177770853,
-                "ops": 752.6578128666387,
-                "total": 0.0013286250177770853,
-                "data": [
-                    0.0013286250177770853
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-5]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-5]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 5
-            },
-            "param": "shots_and_results2-5",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0012189170229248703,
-                "max": 0.0012189170229248703,
-                "mean": 0.0012189170229248703,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0012189170229248703,
-                "iqr": 0.0,
-                "q1": 0.0012189170229248703,
-                "q3": 0.0012189170229248703,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0012189170229248703,
-                "hd15iqr": 0.0012189170229248703,
-                "ops": 820.4003891917395,
-                "total": 0.0012189170229248703,
-                "data": [
-                    0.0012189170229248703
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-6]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-6]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 6
-            },
-            "param": "shots_and_results2-6",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0013885420048609376,
-                "max": 0.0013885420048609376,
-                "mean": 0.0013885420048609376,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0013885420048609376,
-                "iqr": 0.0,
-                "q1": 0.0013885420048609376,
-                "q3": 0.0013885420048609376,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0013885420048609376,
-                "hd15iqr": 0.0013885420048609376,
-                "ops": 720.1798696036926,
-                "total": 0.0013885420048609376,
-                "data": [
-                    0.0013885420048609376
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-7]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-7]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 7
-            },
-            "param": "shots_and_results2-7",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0015077919815666974,
-                "max": 0.0015077919815666974,
-                "mean": 0.0015077919815666974,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0015077919815666974,
-                "iqr": 0.0,
-                "q1": 0.0015077919815666974,
-                "q3": 0.0015077919815666974,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0015077919815666974,
-                "hd15iqr": 0.0015077919815666974,
-                "ops": 663.2214604039297,
-                "total": 0.0015077919815666974,
-                "data": [
-                    0.0015077919815666974
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-8]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-8]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 8
-            },
-            "param": "shots_and_results2-8",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0012403340078890324,
-                "max": 0.0012403340078890324,
-                "mean": 0.0012403340078890324,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0012403340078890324,
-                "iqr": 0.0,
-                "q1": 0.0012403340078890324,
-                "q3": 0.0012403340078890324,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0012403340078890324,
-                "hd15iqr": 0.0012403340078890324,
-                "ops": 806.234444625069,
-                "total": 0.0012403340078890324,
-                "data": [
-                    0.0012403340078890324
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-9]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-9]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 9
-            },
-            "param": "shots_and_results2-9",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0020737089798785746,
-                "max": 0.0020737089798785746,
-                "mean": 0.0020737089798785746,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0020737089798785746,
-                "iqr": 0.0,
-                "q1": 0.0020737089798785746,
-                "q3": 0.0020737089798785746,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0020737089798785746,
-                "hd15iqr": 0.0020737089798785746,
-                "ops": 482.22774251503444,
-                "total": 0.0020737089798785746,
-                "data": [
-                    0.0020737089798785746
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-10]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-10]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 10
-            },
-            "param": "shots_and_results2-10",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0015921249869279563,
-                "max": 0.0015921249869279563,
-                "mean": 0.0015921249869279563,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0015921249869279563,
-                "iqr": 0.0,
-                "q1": 0.0015921249869279563,
-                "q3": 0.0015921249869279563,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0015921249869279563,
-                "hd15iqr": 0.0015921249869279563,
-                "ops": 628.0913924537572,
-                "total": 0.0015921249869279563,
-                "data": [
-                    0.0015921249869279563
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-11]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-11]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 11
-            },
-            "param": "shots_and_results2-11",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0017122090212069452,
-                "max": 0.0017122090212069452,
-                "mean": 0.0017122090212069452,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0017122090212069452,
-                "iqr": 0.0,
-                "q1": 0.0017122090212069452,
-                "q3": 0.0017122090212069452,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0017122090212069452,
-                "hd15iqr": 0.0017122090212069452,
-                "ops": 584.0408429194555,
-                "total": 0.0017122090212069452,
-                "data": [
-                    0.0017122090212069452
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-12]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-12]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 12
-            },
-            "param": "shots_and_results2-12",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.00153795798541978,
-                "max": 0.00153795798541978,
-                "mean": 0.00153795798541978,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.00153795798541978,
-                "iqr": 0.0,
-                "q1": 0.00153795798541978,
-                "q3": 0.00153795798541978,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.00153795798541978,
-                "hd15iqr": 0.00153795798541978,
-                "ops": 650.2128208184138,
-                "total": 0.00153795798541978,
-                "data": [
-                    0.00153795798541978
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-13]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-13]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 13
-            },
-            "param": "shots_and_results2-13",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0017805829993449152,
-                "max": 0.0017805829993449152,
-                "mean": 0.0017805829993449152,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0017805829993449152,
-                "iqr": 0.0,
-                "q1": 0.0017805829993449152,
-                "q3": 0.0017805829993449152,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0017805829993449152,
-                "hd15iqr": 0.0017805829993449152,
-                "ops": 561.613808717653,
-                "total": 0.0017805829993449152,
-                "data": [
-                    0.0017805829993449152
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-14]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-14]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 14
-            },
-            "param": "shots_and_results2-14",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.002065250009763986,
-                "max": 0.002065250009763986,
-                "mean": 0.002065250009763986,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.002065250009763986,
-                "iqr": 0.0,
-                "q1": 0.002065250009763986,
-                "q3": 0.002065250009763986,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.002065250009763986,
-                "hd15iqr": 0.002065250009763986,
-                "ops": 484.20287871795176,
-                "total": 0.002065250009763986,
-                "data": [
-                    0.002065250009763986
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-15]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-15]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 15
-            },
-            "param": "shots_and_results2-15",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0034898340236395597,
-                "max": 0.0034898340236395597,
-                "mean": 0.0034898340236395597,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0034898340236395597,
-                "iqr": 0.0,
-                "q1": 0.0034898340236395597,
-                "q3": 0.0034898340236395597,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0034898340236395597,
-                "hd15iqr": 0.0034898340236395597,
-                "ops": 286.54657878459693,
-                "total": 0.0034898340236395597,
-                "data": [
-                    0.0034898340236395597
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-16]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-16]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 16
-            },
-            "param": "shots_and_results2-16",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.00339816597988829,
-                "max": 0.00339816597988829,
-                "mean": 0.00339816597988829,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.00339816597988829,
-                "iqr": 0.0,
-                "q1": 0.00339816597988829,
-                "q3": 0.00339816597988829,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.00339816597988829,
-                "hd15iqr": 0.00339816597988829,
-                "ops": 294.2763849436435,
-                "total": 0.00339816597988829,
-                "data": [
-                    0.00339816597988829
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-17]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-17]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 17
-            },
-            "param": "shots_and_results2-17",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.002276083978358656,
-                "max": 0.002276083978358656,
-                "mean": 0.002276083978358656,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.002276083978358656,
-                "iqr": 0.0,
-                "q1": 0.002276083978358656,
-                "q3": 0.002276083978358656,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.002276083978358656,
-                "hd15iqr": 0.002276083978358656,
-                "ops": 439.3511001826594,
-                "total": 0.002276083978358656,
-                "data": [
-                    0.002276083978358656
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-18]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-18]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 18
-            },
-            "param": "shots_and_results2-18",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0029573749634437263,
-                "max": 0.0029573749634437263,
-                "mean": 0.0029573749634437263,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0029573749634437263,
-                "iqr": 0.0,
-                "q1": 0.0029573749634437263,
-                "q3": 0.0029573749634437263,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0029573749634437263,
-                "hd15iqr": 0.0029573749634437263,
-                "ops": 338.1377107607438,
-                "total": 0.0029573749634437263,
-                "data": [
-                    0.0029573749634437263
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-19]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-19]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 19
-            },
-            "param": "shots_and_results2-19",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.004229249956551939,
-                "max": 0.004229249956551939,
-                "mean": 0.004229249956551939,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.004229249956551939,
-                "iqr": 0.0,
-                "q1": 0.004229249956551939,
-                "q3": 0.004229249956551939,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.004229249956551939,
-                "hd15iqr": 0.004229249956551939,
-                "ops": 236.4485453149449,
-                "total": 0.004229249956551939,
-                "data": [
-                    0.004229249956551939
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results2-20]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results2-20]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "expectation z(q[0])"
-                ],
-                "nq": 20
-            },
-            "param": "shots_and_results2-20",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.006636540987528861,
-                "max": 0.006636540987528861,
-                "mean": 0.006636540987528861,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.006636540987528861,
-                "iqr": 0.0,
-                "q1": 0.006636540987528861,
-                "q3": 0.006636540987528861,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.006636540987528861,
-                "hd15iqr": 0.006636540987528861,
-                "ops": 150.68090468802387,
-                "total": 0.006636540987528861,
-                "data": [
-                    0.006636540987528861
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-3]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-3]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 3
-            },
-            "param": "shots_and_results3-3",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.1469930830062367,
-                "max": 0.1469930830062367,
-                "mean": 0.1469930830062367,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.1469930830062367,
-                "iqr": 0.0,
-                "q1": 0.1469930830062367,
-                "q3": 0.1469930830062367,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.1469930830062367,
-                "hd15iqr": 0.1469930830062367,
-                "ops": 6.803041201316741,
-                "total": 0.1469930830062367,
-                "data": [
-                    0.1469930830062367
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-4]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-4]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 4
-            },
-            "param": "shots_and_results3-4",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.001580375013872981,
-                "max": 0.001580375013872981,
-                "mean": 0.001580375013872981,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.001580375013872981,
-                "iqr": 0.0,
-                "q1": 0.001580375013872981,
-                "q3": 0.001580375013872981,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.001580375013872981,
-                "hd15iqr": 0.001580375013872981,
-                "ops": 632.7612061831627,
-                "total": 0.001580375013872981,
-                "data": [
-                    0.001580375013872981
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-5]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-5]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 5
-            },
-            "param": "shots_and_results3-5",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0013881250051781535,
-                "max": 0.0013881250051781535,
-                "mean": 0.0013881250051781535,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0013881250051781535,
-                "iqr": 0.0,
-                "q1": 0.0013881250051781535,
-                "q3": 0.0013881250051781535,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0013881250051781535,
-                "hd15iqr": 0.0013881250051781535,
-                "ops": 720.396215232546,
-                "total": 0.0013881250051781535,
-                "data": [
-                    0.0013881250051781535
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-6]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-6]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 6
-            },
-            "param": "shots_and_results3-6",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0018390000332146883,
-                "max": 0.0018390000332146883,
-                "mean": 0.0018390000332146883,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0018390000332146883,
-                "iqr": 0.0,
-                "q1": 0.0018390000332146883,
-                "q3": 0.0018390000332146883,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0018390000332146883,
-                "hd15iqr": 0.0018390000332146883,
-                "ops": 543.7737802820682,
-                "total": 0.0018390000332146883,
-                "data": [
-                    0.0018390000332146883
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-7]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-7]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 7
-            },
-            "param": "shots_and_results3-7",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.001570541993714869,
-                "max": 0.001570541993714869,
-                "mean": 0.001570541993714869,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.001570541993714869,
-                "iqr": 0.0,
-                "q1": 0.001570541993714869,
-                "q3": 0.001570541993714869,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.001570541993714869,
-                "hd15iqr": 0.001570541993714869,
-                "ops": 636.7228663747208,
-                "total": 0.001570541993714869,
-                "data": [
-                    0.001570541993714869
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-8]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-8]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 8
-            },
-            "param": "shots_and_results3-8",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0015441669966094196,
-                "max": 0.0015441669966094196,
-                "mean": 0.0015441669966094196,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0015441669966094196,
-                "iqr": 0.0,
-                "q1": 0.0015441669966094196,
-                "q3": 0.0015441669966094196,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0015441669966094196,
-                "hd15iqr": 0.0015441669966094196,
-                "ops": 647.5983505642423,
-                "total": 0.0015441669966094196,
-                "data": [
-                    0.0015441669966094196
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-9]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-9]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 9
-            },
-            "param": "shots_and_results3-9",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0018146249931305647,
-                "max": 0.0018146249931305647,
-                "mean": 0.0018146249931305647,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0018146249931305647,
-                "iqr": 0.0,
-                "q1": 0.0018146249931305647,
-                "q3": 0.0018146249931305647,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0018146249931305647,
-                "hd15iqr": 0.0018146249931305647,
-                "ops": 551.0780485144837,
-                "total": 0.0018146249931305647,
-                "data": [
-                    0.0018146249931305647
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-10]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-10]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 10
-            },
-            "param": "shots_and_results3-10",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0019207079894840717,
-                "max": 0.0019207079894840717,
-                "mean": 0.0019207079894840717,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0019207079894840717,
-                "iqr": 0.0,
-                "q1": 0.0019207079894840717,
-                "q3": 0.0019207079894840717,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0019207079894840717,
-                "hd15iqr": 0.0019207079894840717,
-                "ops": 520.6413496872128,
-                "total": 0.0019207079894840717,
-                "data": [
-                    0.0019207079894840717
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-11]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-11]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 11
-            },
-            "param": "shots_and_results3-11",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0018692080047912896,
-                "max": 0.0018692080047912896,
-                "mean": 0.0018692080047912896,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0018692080047912896,
-                "iqr": 0.0,
-                "q1": 0.0018692080047912896,
-                "q3": 0.0018692080047912896,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0018692080047912896,
-                "hd15iqr": 0.0018692080047912896,
-                "ops": 534.9859391981671,
-                "total": 0.0018692080047912896,
-                "data": [
-                    0.0018692080047912896
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-12]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-12]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 12
-            },
-            "param": "shots_and_results3-12",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0022399579756893218,
-                "max": 0.0022399579756893218,
-                "mean": 0.0022399579756893218,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0022399579756893218,
-                "iqr": 0.0,
-                "q1": 0.0022399579756893218,
-                "q3": 0.0022399579756893218,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0022399579756893218,
-                "hd15iqr": 0.0022399579756893218,
-                "ops": 446.4369469664989,
-                "total": 0.0022399579756893218,
-                "data": [
-                    0.0022399579756893218
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-13]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-13]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 13
-            },
-            "param": "shots_and_results3-13",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0017346660024486482,
-                "max": 0.0017346660024486482,
-                "mean": 0.0017346660024486482,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0017346660024486482,
-                "iqr": 0.0,
-                "q1": 0.0017346660024486482,
-                "q3": 0.0017346660024486482,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0017346660024486482,
-                "hd15iqr": 0.0017346660024486482,
-                "ops": 576.4798517918745,
-                "total": 0.0017346660024486482,
-                "data": [
-                    0.0017346660024486482
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-14]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-14]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 14
-            },
-            "param": "shots_and_results3-14",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.002296249964274466,
-                "max": 0.002296249964274466,
-                "mean": 0.002296249964274466,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.002296249964274466,
-                "iqr": 0.0,
-                "q1": 0.002296249964274466,
-                "q3": 0.002296249964274466,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.002296249964274466,
-                "hd15iqr": 0.002296249964274466,
-                "ops": 435.4926578369985,
-                "total": 0.002296249964274466,
-                "data": [
-                    0.002296249964274466
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-15]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-15]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 15
-            },
-            "param": "shots_and_results3-15",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0019337080302648246,
-                "max": 0.0019337080302648246,
-                "mean": 0.0019337080302648246,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0019337080302648246,
-                "iqr": 0.0,
-                "q1": 0.0019337080302648246,
-                "q3": 0.0019337080302648246,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0019337080302648246,
-                "hd15iqr": 0.0019337080302648246,
-                "ops": 517.1411528259766,
-                "total": 0.0019337080302648246,
-                "data": [
-                    0.0019337080302648246
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-16]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-16]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 16
-            },
-            "param": "shots_and_results3-16",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0030358750373125076,
-                "max": 0.0030358750373125076,
-                "mean": 0.0030358750373125076,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0030358750373125076,
-                "iqr": 0.0,
-                "q1": 0.0030358750373125076,
-                "q3": 0.0030358750373125076,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0030358750373125076,
-                "hd15iqr": 0.0030358750373125076,
-                "ops": 329.39432213430126,
-                "total": 0.0030358750373125076,
-                "data": [
-                    0.0030358750373125076
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-17]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-17]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 17
-            },
-            "param": "shots_and_results3-17",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.003976540989242494,
-                "max": 0.003976540989242494,
-                "mean": 0.003976540989242494,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.003976540989242494,
-                "iqr": 0.0,
-                "q1": 0.003976540989242494,
-                "q3": 0.003976540989242494,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.003976540989242494,
-                "hd15iqr": 0.003976540989242494,
-                "ops": 251.47483773089277,
-                "total": 0.003976540989242494,
-                "data": [
-                    0.003976540989242494
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-18]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-18]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 18
-            },
-            "param": "shots_and_results3-18",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.004659582977183163,
-                "max": 0.004659582977183163,
-                "mean": 0.004659582977183163,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.004659582977183163,
-                "iqr": 0.0,
-                "q1": 0.004659582977183163,
-                "q3": 0.004659582977183163,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.004659582977183163,
-                "hd15iqr": 0.004659582977183163,
-                "ops": 214.61148023262064,
-                "total": 0.004659582977183163,
-                "data": [
-                    0.004659582977183163
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-19]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-19]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 19
-            },
-            "param": "shots_and_results3-19",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.005890000029467046,
-                "max": 0.005890000029467046,
-                "mean": 0.005890000029467046,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.005890000029467046,
-                "iqr": 0.0,
-                "q1": 0.005890000029467046,
-                "q3": 0.005890000029467046,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.005890000029467046,
-                "hd15iqr": 0.005890000029467046,
-                "ops": 169.7792860776071,
-                "total": 0.005890000029467046,
-                "data": [
-                    0.005890000029467046
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results3-20]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results3-20]",
-            "params": {
-                "shots_and_results": [
-                    0,
-                    "variance y(q[0])"
-                ],
-                "nq": 20
-            },
-            "param": "shots_and_results3-20",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.012661834014579654,
-                "max": 0.012661834014579654,
-                "mean": 0.012661834014579654,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.012661834014579654,
-                "iqr": 0.0,
-                "q1": 0.012661834014579654,
-                "q3": 0.012661834014579654,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.012661834014579654,
-                "hd15iqr": 0.012661834014579654,
-                "ops": 78.97750032487674,
-                "total": 0.012661834014579654,
-                "data": [
-                    0.012661834014579654
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-3]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-3]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 3
-            },
-            "param": "shots_and_results4-3",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.20281929202610627,
-                "max": 0.20281929202610627,
-                "mean": 0.20281929202610627,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.20281929202610627,
-                "iqr": 0.0,
-                "q1": 0.20281929202610627,
-                "q3": 0.20281929202610627,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.20281929202610627,
-                "hd15iqr": 0.20281929202610627,
-                "ops": 4.930497439421508,
-                "total": 0.20281929202610627,
-                "data": [
-                    0.20281929202610627
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-4]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-4]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 4
-            },
-            "param": "shots_and_results4-4",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0024854589719325304,
-                "max": 0.0024854589719325304,
-                "mean": 0.0024854589719325304,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0024854589719325304,
-                "iqr": 0.0,
-                "q1": 0.0024854589719325304,
-                "q3": 0.0024854589719325304,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0024854589719325304,
-                "hd15iqr": 0.0024854589719325304,
-                "ops": 402.34017591626764,
-                "total": 0.0024854589719325304,
-                "data": [
-                    0.0024854589719325304
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-5]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-5]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 5
-            },
-            "param": "shots_and_results4-5",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0025891249533742666,
-                "max": 0.0025891249533742666,
-                "mean": 0.0025891249533742666,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0025891249533742666,
-                "iqr": 0.0,
-                "q1": 0.0025891249533742666,
-                "q3": 0.0025891249533742666,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0025891249533742666,
-                "hd15iqr": 0.0025891249533742666,
-                "ops": 386.2308764576055,
-                "total": 0.0025891249533742666,
-                "data": [
-                    0.0025891249533742666
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-6]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-6]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 6
-            },
-            "param": "shots_and_results4-6",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0030179169843904674,
-                "max": 0.0030179169843904674,
-                "mean": 0.0030179169843904674,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0030179169843904674,
-                "iqr": 0.0,
-                "q1": 0.0030179169843904674,
-                "q3": 0.0030179169843904674,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0030179169843904674,
-                "hd15iqr": 0.0030179169843904674,
-                "ops": 331.35437627088055,
-                "total": 0.0030179169843904674,
-                "data": [
-                    0.0030179169843904674
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-7]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-7]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 7
-            },
-            "param": "shots_and_results4-7",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0030238330364227295,
-                "max": 0.0030238330364227295,
-                "mean": 0.0030238330364227295,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0030238330364227295,
-                "iqr": 0.0,
-                "q1": 0.0030238330364227295,
-                "q3": 0.0030238330364227295,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0030238330364227295,
-                "hd15iqr": 0.0030238330364227295,
-                "ops": 330.7060899046943,
-                "total": 0.0030238330364227295,
-                "data": [
-                    0.0030238330364227295
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-8]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-8]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 8
-            },
-            "param": "shots_and_results4-8",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.003418374981265515,
-                "max": 0.003418374981265515,
-                "mean": 0.003418374981265515,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.003418374981265515,
-                "iqr": 0.0,
-                "q1": 0.003418374981265515,
-                "q3": 0.003418374981265515,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.003418374981265515,
-                "hd15iqr": 0.003418374981265515,
-                "ops": 292.53666010327237,
-                "total": 0.003418374981265515,
-                "data": [
-                    0.003418374981265515
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-9]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-9]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 9
-            },
-            "param": "shots_and_results4-9",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0030650420230813324,
-                "max": 0.0030650420230813324,
-                "mean": 0.0030650420230813324,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0030650420230813324,
-                "iqr": 0.0,
-                "q1": 0.0030650420230813324,
-                "q3": 0.0030650420230813324,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0030650420230813324,
-                "hd15iqr": 0.0030650420230813324,
-                "ops": 326.2598008345364,
-                "total": 0.0030650420230813324,
-                "data": [
-                    0.0030650420230813324
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-10]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-10]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 10
-            },
-            "param": "shots_and_results4-10",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.00404508295468986,
-                "max": 0.00404508295468986,
-                "mean": 0.00404508295468986,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.00404508295468986,
-                "iqr": 0.0,
-                "q1": 0.00404508295468986,
-                "q3": 0.00404508295468986,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.00404508295468986,
-                "hd15iqr": 0.00404508295468986,
-                "ops": 247.21371877938924,
-                "total": 0.00404508295468986,
-                "data": [
-                    0.00404508295468986
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-11]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-11]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 11
-            },
-            "param": "shots_and_results4-11",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.003804875013884157,
-                "max": 0.003804875013884157,
-                "mean": 0.003804875013884157,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.003804875013884157,
-                "iqr": 0.0,
-                "q1": 0.003804875013884157,
-                "q3": 0.003804875013884157,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.003804875013884157,
-                "hd15iqr": 0.003804875013884157,
-                "ops": 262.82072245499677,
-                "total": 0.003804875013884157,
-                "data": [
-                    0.003804875013884157
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-12]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-12]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 12
-            },
-            "param": "shots_and_results4-12",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.004821832990273833,
-                "max": 0.004821832990273833,
-                "mean": 0.004821832990273833,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.004821832990273833,
-                "iqr": 0.0,
-                "q1": 0.004821832990273833,
-                "q3": 0.004821832990273833,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.004821832990273833,
-                "hd15iqr": 0.004821832990273833,
-                "ops": 207.39001164434973,
-                "total": 0.004821832990273833,
-                "data": [
-                    0.004821832990273833
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-13]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-13]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 13
-            },
-            "param": "shots_and_results4-13",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0045837920042686164,
-                "max": 0.0045837920042686164,
-                "mean": 0.0045837920042686164,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0045837920042686164,
-                "iqr": 0.0,
-                "q1": 0.0045837920042686164,
-                "q3": 0.0045837920042686164,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0045837920042686164,
-                "hd15iqr": 0.0045837920042686164,
-                "ops": 218.15998611384606,
-                "total": 0.0045837920042686164,
-                "data": [
-                    0.0045837920042686164
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-14]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-14]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 14
-            },
-            "param": "shots_and_results4-14",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.004916917008813471,
-                "max": 0.004916917008813471,
-                "mean": 0.004916917008813471,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.004916917008813471,
-                "iqr": 0.0,
-                "q1": 0.004916917008813471,
-                "q3": 0.004916917008813471,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.004916917008813471,
-                "hd15iqr": 0.004916917008813471,
-                "ops": 203.37947502622495,
-                "total": 0.004916917008813471,
-                "data": [
-                    0.004916917008813471
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-15]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-15]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 15
-            },
-            "param": "shots_and_results4-15",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.004840250010602176,
-                "max": 0.004840250010602176,
-                "mean": 0.004840250010602176,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.004840250010602176,
-                "iqr": 0.0,
-                "q1": 0.004840250010602176,
-                "q3": 0.004840250010602176,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.004840250010602176,
-                "hd15iqr": 0.004840250010602176,
-                "ops": 206.60089826136684,
-                "total": 0.004840250010602176,
-                "data": [
-                    0.004840250010602176
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-16]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-16]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 16
-            },
-            "param": "shots_and_results4-16",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0054152499651536345,
-                "max": 0.0054152499651536345,
-                "mean": 0.0054152499651536345,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0054152499651536345,
-                "iqr": 0.0,
-                "q1": 0.0054152499651536345,
-                "q3": 0.0054152499651536345,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0054152499651536345,
-                "hd15iqr": 0.0054152499651536345,
-                "ops": 184.66368245877072,
-                "total": 0.0054152499651536345,
-                "data": [
-                    0.0054152499651536345
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-17]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-17]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 17
-            },
-            "param": "shots_and_results4-17",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.006259209010750055,
-                "max": 0.006259209010750055,
-                "mean": 0.006259209010750055,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.006259209010750055,
-                "iqr": 0.0,
-                "q1": 0.006259209010750055,
-                "q3": 0.006259209010750055,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.006259209010750055,
-                "hd15iqr": 0.006259209010750055,
-                "ops": 159.76459617861008,
-                "total": 0.006259209010750055,
-                "data": [
-                    0.006259209010750055
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-18]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-18]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 18
-            },
-            "param": "shots_and_results4-18",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.013382332981564105,
-                "max": 0.013382332981564105,
-                "mean": 0.013382332981564105,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.013382332981564105,
-                "iqr": 0.0,
-                "q1": 0.013382332981564105,
-                "q3": 0.013382332981564105,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.013382332981564105,
-                "hd15iqr": 0.013382332981564105,
-                "ops": 74.72538617725544,
-                "total": 0.013382332981564105,
-                "data": [
-                    0.013382332981564105
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-19]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-19]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 19
-            },
-            "param": "shots_and_results4-19",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.013001125014852732,
-                "max": 0.013001125014852732,
-                "mean": 0.013001125014852732,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.013001125014852732,
-                "iqr": 0.0,
-                "q1": 0.013001125014852732,
-                "q3": 0.013001125014852732,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.013001125014852732,
-                "hd15iqr": 0.013001125014852732,
-                "ops": 76.91642060649221,
-                "total": 0.013001125014852732,
-                "data": [
-                    0.013001125014852732
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results4-20]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results4-20]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "probability"
-                ],
-                "nq": 20
-            },
-            "param": "shots_and_results4-20",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.021054624987300485,
-                "max": 0.021054624987300485,
-                "mean": 0.021054624987300485,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.021054624987300485,
-                "iqr": 0.0,
-                "q1": 0.021054624987300485,
-                "q3": 0.021054624987300485,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.021054624987300485,
-                "hd15iqr": 0.021054624987300485,
-                "ops": 47.49550279822936,
-                "total": 0.021054624987300485,
-                "data": [
-                    0.021054624987300485
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-3]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-3]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 3
-            },
-            "param": "shots_and_results5-3",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.07412141695385799,
-                "max": 0.07412141695385799,
-                "mean": 0.07412141695385799,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.07412141695385799,
-                "iqr": 0.0,
-                "q1": 0.07412141695385799,
-                "q3": 0.07412141695385799,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.07412141695385799,
-                "hd15iqr": 0.07412141695385799,
-                "ops": 13.491377271194361,
-                "total": 0.07412141695385799,
-                "data": [
-                    0.07412141695385799
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-4]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-4]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 4
-            },
-            "param": "shots_and_results5-4",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0023655840195715427,
-                "max": 0.0023655840195715427,
-                "mean": 0.0023655840195715427,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0023655840195715427,
-                "iqr": 0.0,
-                "q1": 0.0023655840195715427,
-                "q3": 0.0023655840195715427,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0023655840195715427,
-                "hd15iqr": 0.0023655840195715427,
-                "ops": 422.7285912174538,
-                "total": 0.0023655840195715427,
-                "data": [
-                    0.0023655840195715427
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-5]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-5]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 5
-            },
-            "param": "shots_and_results5-5",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.002518499968573451,
-                "max": 0.002518499968573451,
-                "mean": 0.002518499968573451,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.002518499968573451,
-                "iqr": 0.0,
-                "q1": 0.002518499968573451,
-                "q3": 0.002518499968573451,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.002518499968573451,
-                "hd15iqr": 0.002518499968573451,
-                "ops": 397.0617480557,
-                "total": 0.002518499968573451,
-                "data": [
-                    0.002518499968573451
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-6]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-6]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 6
-            },
-            "param": "shots_and_results5-6",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.00324737501796335,
-                "max": 0.00324737501796335,
-                "mean": 0.00324737501796335,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.00324737501796335,
-                "iqr": 0.0,
-                "q1": 0.00324737501796335,
-                "q3": 0.00324737501796335,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.00324737501796335,
-                "hd15iqr": 0.00324737501796335,
-                "ops": 307.9410275894677,
-                "total": 0.00324737501796335,
-                "data": [
-                    0.00324737501796335
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-7]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-7]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 7
-            },
-            "param": "shots_and_results5-7",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0029858749476261437,
-                "max": 0.0029858749476261437,
-                "mean": 0.0029858749476261437,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0029858749476261437,
-                "iqr": 0.0,
-                "q1": 0.0029858749476261437,
-                "q3": 0.0029858749476261437,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0029858749476261437,
-                "hd15iqr": 0.0029858749476261437,
-                "ops": 334.9102080765401,
-                "total": 0.0029858749476261437,
-                "data": [
-                    0.0029858749476261437
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-8]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-8]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 8
-            },
-            "param": "shots_and_results5-8",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.003279375028796494,
-                "max": 0.003279375028796494,
-                "mean": 0.003279375028796494,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.003279375028796494,
-                "iqr": 0.0,
-                "q1": 0.003279375028796494,
-                "q3": 0.003279375028796494,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.003279375028796494,
-                "hd15iqr": 0.003279375028796494,
-                "ops": 304.93615131508534,
-                "total": 0.003279375028796494,
-                "data": [
-                    0.003279375028796494
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-9]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-9]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 9
-            },
-            "param": "shots_and_results5-9",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0033004169818013906,
-                "max": 0.0033004169818013906,
-                "mean": 0.0033004169818013906,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0033004169818013906,
-                "iqr": 0.0,
-                "q1": 0.0033004169818013906,
-                "q3": 0.0033004169818013906,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0033004169818013906,
-                "hd15iqr": 0.0033004169818013906,
-                "ops": 302.99201752809824,
-                "total": 0.0033004169818013906,
-                "data": [
-                    0.0033004169818013906
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-10]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-10]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 10
-            },
-            "param": "shots_and_results5-10",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.003565249964594841,
-                "max": 0.003565249964594841,
-                "mean": 0.003565249964594841,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.003565249964594841,
-                "iqr": 0.0,
-                "q1": 0.003565249964594841,
-                "q3": 0.003565249964594841,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.003565249964594841,
-                "hd15iqr": 0.003565249964594841,
-                "ops": 280.4852422496668,
-                "total": 0.003565249964594841,
-                "data": [
-                    0.003565249964594841
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-11]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-11]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 11
-            },
-            "param": "shots_and_results5-11",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0036357499775476754,
-                "max": 0.0036357499775476754,
-                "mean": 0.0036357499775476754,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0036357499775476754,
-                "iqr": 0.0,
-                "q1": 0.0036357499775476754,
-                "q3": 0.0036357499775476754,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0036357499775476754,
-                "hd15iqr": 0.0036357499775476754,
-                "ops": 275.04641578090667,
-                "total": 0.0036357499775476754,
-                "data": [
-                    0.0036357499775476754
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-12]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-12]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 12
-            },
-            "param": "shots_and_results5-12",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0045823329710401595,
-                "max": 0.0045823329710401595,
-                "mean": 0.0045823329710401595,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0045823329710401595,
-                "iqr": 0.0,
-                "q1": 0.0045823329710401595,
-                "q3": 0.0045823329710401595,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0045823329710401595,
-                "hd15iqr": 0.0045823329710401595,
-                "ops": 218.22944912992793,
-                "total": 0.0045823329710401595,
-                "data": [
-                    0.0045823329710401595
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-13]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-13]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 13
-            },
-            "param": "shots_and_results5-13",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.004717584000900388,
-                "max": 0.004717584000900388,
-                "mean": 0.004717584000900388,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.004717584000900388,
-                "iqr": 0.0,
-                "q1": 0.004717584000900388,
-                "q3": 0.004717584000900388,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.004717584000900388,
-                "hd15iqr": 0.004717584000900388,
-                "ops": 211.97290812609637,
-                "total": 0.004717584000900388,
-                "data": [
-                    0.004717584000900388
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-14]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-14]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 14
-            },
-            "param": "shots_and_results5-14",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.004726000013761222,
-                "max": 0.004726000013761222,
-                "mean": 0.004726000013761222,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.004726000013761222,
-                "iqr": 0.0,
-                "q1": 0.004726000013761222,
-                "q3": 0.004726000013761222,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.004726000013761222,
-                "hd15iqr": 0.004726000013761222,
-                "ops": 211.59542892259591,
-                "total": 0.004726000013761222,
-                "data": [
-                    0.004726000013761222
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-15]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-15]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 15
-            },
-            "param": "shots_and_results5-15",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0051437089568935335,
-                "max": 0.0051437089568935335,
-                "mean": 0.0051437089568935335,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0051437089568935335,
-                "iqr": 0.0,
-                "q1": 0.0051437089568935335,
-                "q3": 0.0051437089568935335,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0051437089568935335,
-                "hd15iqr": 0.0051437089568935335,
-                "ops": 194.41224384591447,
-                "total": 0.0051437089568935335,
-                "data": [
-                    0.0051437089568935335
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-16]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-16]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 16
-            },
-            "param": "shots_and_results5-16",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.005437167012132704,
-                "max": 0.005437167012132704,
-                "mean": 0.005437167012132704,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.005437167012132704,
-                "iqr": 0.0,
-                "q1": 0.005437167012132704,
-                "q3": 0.005437167012132704,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.005437167012132704,
-                "hd15iqr": 0.005437167012132704,
-                "ops": 183.91930903879933,
-                "total": 0.005437167012132704,
-                "data": [
-                    0.005437167012132704
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-17]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-17]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 17
-            },
-            "param": "shots_and_results5-17",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.006272958999034017,
-                "max": 0.006272958999034017,
-                "mean": 0.006272958999034017,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.006272958999034017,
-                "iqr": 0.0,
-                "q1": 0.006272958999034017,
-                "q3": 0.006272958999034017,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.006272958999034017,
-                "hd15iqr": 0.006272958999034017,
-                "ops": 159.41440078820722,
-                "total": 0.006272958999034017,
-                "data": [
-                    0.006272958999034017
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-18]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-18]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 18
-            },
-            "param": "shots_and_results5-18",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.007851500005926937,
-                "max": 0.007851500005926937,
-                "mean": 0.007851500005926937,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.007851500005926937,
-                "iqr": 0.0,
-                "q1": 0.007851500005926937,
-                "q3": 0.007851500005926937,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.007851500005926937,
-                "hd15iqr": 0.007851500005926937,
-                "ops": 127.36419782781894,
-                "total": 0.007851500005926937,
-                "data": [
-                    0.007851500005926937
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-19]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-19]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 19
-            },
-            "param": "shots_and_results5-19",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.01259108301019296,
-                "max": 0.01259108301019296,
-                "mean": 0.01259108301019296,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.01259108301019296,
-                "iqr": 0.0,
-                "q1": 0.01259108301019296,
-                "q3": 0.01259108301019296,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.01259108301019296,
-                "hd15iqr": 0.01259108301019296,
-                "ops": 79.42128561859707,
-                "total": 0.01259108301019296,
-                "data": [
-                    0.01259108301019296
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results5-20]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results5-20]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "expectation z(q[0])"
-                ],
-                "nq": 20
-            },
-            "param": "shots_and_results5-20",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.02228291699429974,
-                "max": 0.02228291699429974,
-                "mean": 0.02228291699429974,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.02228291699429974,
-                "iqr": 0.0,
-                "q1": 0.02228291699429974,
-                "q3": 0.02228291699429974,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.02228291699429974,
-                "hd15iqr": 0.02228291699429974,
-                "ops": 44.87742786349799,
-                "total": 0.02228291699429974,
-                "data": [
-                    0.02228291699429974
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-3]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-3]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 3
-            },
-            "param": "shots_and_results6-3",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.10656795802060515,
-                "max": 0.10656795802060515,
-                "mean": 0.10656795802060515,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.10656795802060515,
-                "iqr": 0.0,
-                "q1": 0.10656795802060515,
-                "q3": 0.10656795802060515,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.10656795802060515,
-                "hd15iqr": 0.10656795802060515,
-                "ops": 9.383683600343058,
-                "total": 0.10656795802060515,
-                "data": [
-                    0.10656795802060515
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-4]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-4]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 4
-            },
-            "param": "shots_and_results6-4",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0024904169840738177,
-                "max": 0.0024904169840738177,
-                "mean": 0.0024904169840738177,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0024904169840738177,
-                "iqr": 0.0,
-                "q1": 0.0024904169840738177,
-                "q3": 0.0024904169840738177,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0024904169840738177,
-                "hd15iqr": 0.0024904169840738177,
-                "ops": 401.53918255255496,
-                "total": 0.0024904169840738177,
-                "data": [
-                    0.0024904169840738177
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-5]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-5]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 5
-            },
-            "param": "shots_and_results6-5",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.002569083997514099,
-                "max": 0.002569083997514099,
-                "mean": 0.002569083997514099,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.002569083997514099,
-                "iqr": 0.0,
-                "q1": 0.002569083997514099,
-                "q3": 0.002569083997514099,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.002569083997514099,
-                "hd15iqr": 0.002569083997514099,
-                "ops": 389.243793105878,
-                "total": 0.002569083997514099,
-                "data": [
-                    0.002569083997514099
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-6]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-6]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 6
-            },
-            "param": "shots_and_results6-6",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0027647920069284737,
-                "max": 0.0027647920069284737,
-                "mean": 0.0027647920069284737,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0027647920069284737,
-                "iqr": 0.0,
-                "q1": 0.0027647920069284737,
-                "q3": 0.0027647920069284737,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0027647920069284737,
-                "hd15iqr": 0.0027647920069284737,
-                "ops": 361.69086046763533,
-                "total": 0.0027647920069284737,
-                "data": [
-                    0.0027647920069284737
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-7]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-7]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 7
-            },
-            "param": "shots_and_results6-7",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0029679579893127084,
-                "max": 0.0029679579893127084,
-                "mean": 0.0029679579893127084,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0029679579893127084,
-                "iqr": 0.0,
-                "q1": 0.0029679579893127084,
-                "q3": 0.0029679579893127084,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0029679579893127084,
-                "hd15iqr": 0.0029679579893127084,
-                "ops": 336.9319928384736,
-                "total": 0.0029679579893127084,
-                "data": [
-                    0.0029679579893127084
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-8]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-8]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 8
-            },
-            "param": "shots_and_results6-8",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.008034416998270899,
-                "max": 0.008034416998270899,
-                "mean": 0.008034416998270899,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.008034416998270899,
-                "iqr": 0.0,
-                "q1": 0.008034416998270899,
-                "q3": 0.008034416998270899,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.008034416998270899,
-                "hd15iqr": 0.008034416998270899,
-                "ops": 124.46453802624531,
-                "total": 0.008034416998270899,
-                "data": [
-                    0.008034416998270899
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-9]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-9]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 9
-            },
-            "param": "shots_and_results6-9",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0036411249893717468,
-                "max": 0.0036411249893717468,
-                "mean": 0.0036411249893717468,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0036411249893717468,
-                "iqr": 0.0,
-                "q1": 0.0036411249893717468,
-                "q3": 0.0036411249893717468,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0036411249893717468,
-                "hd15iqr": 0.0036411249893717468,
-                "ops": 274.64039353742254,
-                "total": 0.0036411249893717468,
-                "data": [
-                    0.0036411249893717468
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-10]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-10]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 10
-            },
-            "param": "shots_and_results6-10",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0037293750210665166,
-                "max": 0.0037293750210665166,
-                "mean": 0.0037293750210665166,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0037293750210665166,
-                "iqr": 0.0,
-                "q1": 0.0037293750210665166,
-                "q3": 0.0037293750210665166,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0037293750210665166,
-                "hd15iqr": 0.0037293750210665166,
-                "ops": 268.1414430973538,
-                "total": 0.0037293750210665166,
-                "data": [
-                    0.0037293750210665166
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-11]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-11]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 11
-            },
-            "param": "shots_and_results6-11",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.004744167032185942,
-                "max": 0.004744167032185942,
-                "mean": 0.004744167032185942,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.004744167032185942,
-                "iqr": 0.0,
-                "q1": 0.004744167032185942,
-                "q3": 0.004744167032185942,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.004744167032185942,
-                "hd15iqr": 0.004744167032185942,
-                "ops": 210.78515853587808,
-                "total": 0.004744167032185942,
-                "data": [
-                    0.004744167032185942
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-12]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-12]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 12
-            },
-            "param": "shots_and_results6-12",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.005379125010222197,
-                "max": 0.005379125010222197,
-                "mean": 0.005379125010222197,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.005379125010222197,
-                "iqr": 0.0,
-                "q1": 0.005379125010222197,
-                "q3": 0.005379125010222197,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.005379125010222197,
-                "hd15iqr": 0.005379125010222197,
-                "ops": 185.90384088483805,
-                "total": 0.005379125010222197,
-                "data": [
-                    0.005379125010222197
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-13]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-13]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 13
-            },
-            "param": "shots_and_results6-13",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.004691459005698562,
-                "max": 0.004691459005698562,
-                "mean": 0.004691459005698562,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.004691459005698562,
-                "iqr": 0.0,
-                "q1": 0.004691459005698562,
-                "q3": 0.004691459005698562,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.004691459005698562,
-                "hd15iqr": 0.004691459005698562,
-                "ops": 213.15330663346577,
-                "total": 0.004691459005698562,
-                "data": [
-                    0.004691459005698562
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-14]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-14]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 14
-            },
-            "param": "shots_and_results6-14",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.004525166004896164,
-                "max": 0.004525166004896164,
-                "mean": 0.004525166004896164,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.004525166004896164,
-                "iqr": 0.0,
-                "q1": 0.004525166004896164,
-                "q3": 0.004525166004896164,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.004525166004896164,
-                "hd15iqr": 0.004525166004896164,
-                "ops": 220.98636799578503,
-                "total": 0.004525166004896164,
-                "data": [
-                    0.004525166004896164
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-15]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-15]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 15
-            },
-            "param": "shots_and_results6-15",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.005676250031683594,
-                "max": 0.005676250031683594,
-                "mean": 0.005676250031683594,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.005676250031683594,
-                "iqr": 0.0,
-                "q1": 0.005676250031683594,
-                "q3": 0.005676250031683594,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.005676250031683594,
-                "hd15iqr": 0.005676250031683594,
-                "ops": 176.17264821285485,
-                "total": 0.005676250031683594,
-                "data": [
-                    0.005676250031683594
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-16]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-16]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 16
-            },
-            "param": "shots_and_results6-16",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.005442874971777201,
-                "max": 0.005442874971777201,
-                "mean": 0.005442874971777201,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.005442874971777201,
-                "iqr": 0.0,
-                "q1": 0.005442874971777201,
-                "q3": 0.005442874971777201,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.005442874971777201,
-                "hd15iqr": 0.005442874971777201,
-                "ops": 183.72643229640113,
-                "total": 0.005442874971777201,
-                "data": [
-                    0.005442874971777201
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-17]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-17]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 17
-            },
-            "param": "shots_and_results6-17",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.006393791001755744,
-                "max": 0.006393791001755744,
-                "mean": 0.006393791001755744,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.006393791001755744,
-                "iqr": 0.0,
-                "q1": 0.006393791001755744,
-                "q3": 0.006393791001755744,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.006393791001755744,
-                "hd15iqr": 0.006393791001755744,
-                "ops": 156.4017340769191,
-                "total": 0.006393791001755744,
-                "data": [
-                    0.006393791001755744
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-18]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-18]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 18
-            },
-            "param": "shots_and_results6-18",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.008627417031675577,
-                "max": 0.008627417031675577,
-                "mean": 0.008627417031675577,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.008627417031675577,
-                "iqr": 0.0,
-                "q1": 0.008627417031675577,
-                "q3": 0.008627417031675577,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.008627417031675577,
-                "hd15iqr": 0.008627417031675577,
-                "ops": 115.90954700908722,
-                "total": 0.008627417031675577,
-                "data": [
-                    0.008627417031675577
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-19]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-19]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 19
-            },
-            "param": "shots_and_results6-19",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.013398082985077053,
-                "max": 0.013398082985077053,
-                "mean": 0.013398082985077053,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.013398082985077053,
-                "iqr": 0.0,
-                "q1": 0.013398082985077053,
-                "q3": 0.013398082985077053,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.013398082985077053,
-                "hd15iqr": 0.013398082985077053,
-                "ops": 74.6375433794381,
-                "total": 0.013398082985077053,
-                "data": [
-                    0.013398082985077053
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results6-20]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results6-20]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "variance y(q[0])"
-                ],
-                "nq": 20
-            },
-            "param": "shots_and_results6-20",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.023601875000167638,
-                "max": 0.023601875000167638,
-                "mean": 0.023601875000167638,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.023601875000167638,
-                "iqr": 0.0,
-                "q1": 0.023601875000167638,
-                "q3": 0.023601875000167638,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.023601875000167638,
-                "hd15iqr": 0.023601875000167638,
-                "ops": 42.36951513356025,
-                "total": 0.023601875000167638,
-                "data": [
-                    0.023601875000167638
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-3]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-3]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 3
-            },
-            "param": "shots_and_results7-3",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.04172033298527822,
-                "max": 0.04172033298527822,
-                "mean": 0.04172033298527822,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.04172033298527822,
-                "iqr": 0.0,
-                "q1": 0.04172033298527822,
-                "q3": 0.04172033298527822,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.04172033298527822,
-                "hd15iqr": 0.04172033298527822,
-                "ops": 23.969127963404997,
-                "total": 0.04172033298527822,
-                "data": [
-                    0.04172033298527822
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-4]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-4]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 4
-            },
-            "param": "shots_and_results7-4",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.002549666038248688,
-                "max": 0.002549666038248688,
-                "mean": 0.002549666038248688,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.002549666038248688,
-                "iqr": 0.0,
-                "q1": 0.002549666038248688,
-                "q3": 0.002549666038248688,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.002549666038248688,
-                "hd15iqr": 0.002549666038248688,
-                "ops": 392.2082284497459,
-                "total": 0.002549666038248688,
-                "data": [
-                    0.002549666038248688
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-5]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-5]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 5
-            },
-            "param": "shots_and_results7-5",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.002409542037639767,
-                "max": 0.002409542037639767,
-                "mean": 0.002409542037639767,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.002409542037639767,
-                "iqr": 0.0,
-                "q1": 0.002409542037639767,
-                "q3": 0.002409542037639767,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.002409542037639767,
-                "hd15iqr": 0.002409542037639767,
-                "ops": 415.0166232333244,
-                "total": 0.002409542037639767,
-                "data": [
-                    0.002409542037639767
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-6]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-6]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 6
-            },
-            "param": "shots_and_results7-6",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0024610409745946527,
-                "max": 0.0024610409745946527,
-                "mean": 0.0024610409745946527,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0024610409745946527,
-                "iqr": 0.0,
-                "q1": 0.0024610409745946527,
-                "q3": 0.0024610409745946527,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0024610409745946527,
-                "hd15iqr": 0.0024610409745946527,
-                "ops": 406.33212137587657,
-                "total": 0.0024610409745946527,
-                "data": [
-                    0.0024610409745946527
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-7]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-7]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 7
-            },
-            "param": "shots_and_results7-7",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.002603249973617494,
-                "max": 0.002603249973617494,
-                "mean": 0.002603249973617494,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.002603249973617494,
-                "iqr": 0.0,
-                "q1": 0.002603249973617494,
-                "q3": 0.002603249973617494,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.002603249973617494,
-                "hd15iqr": 0.002603249973617494,
-                "ops": 384.13521948888877,
-                "total": 0.002603249973617494,
-                "data": [
-                    0.002603249973617494
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-8]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-8]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 8
-            },
-            "param": "shots_and_results7-8",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.0034407079801894724,
-                "max": 0.0034407079801894724,
-                "mean": 0.0034407079801894724,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.0034407079801894724,
-                "iqr": 0.0,
-                "q1": 0.0034407079801894724,
-                "q3": 0.0034407079801894724,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.0034407079801894724,
-                "hd15iqr": 0.0034407079801894724,
-                "ops": 290.6378587656056,
-                "total": 0.0034407079801894724,
-                "data": [
-                    0.0034407079801894724
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-9]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-9]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 9
-            },
-            "param": "shots_and_results7-9",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.003490457951556891,
-                "max": 0.003490457951556891,
-                "mean": 0.003490457951556891,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.003490457951556891,
-                "iqr": 0.0,
-                "q1": 0.003490457951556891,
-                "q3": 0.003490457951556891,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.003490457951556891,
-                "hd15iqr": 0.003490457951556891,
-                "ops": 286.49535788103617,
-                "total": 0.003490457951556891,
-                "data": [
-                    0.003490457951556891
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-10]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-10]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 10
-            },
-            "param": "shots_and_results7-10",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.004947667010128498,
-                "max": 0.004947667010128498,
-                "mean": 0.004947667010128498,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.004947667010128498,
-                "iqr": 0.0,
-                "q1": 0.004947667010128498,
-                "q3": 0.004947667010128498,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.004947667010128498,
-                "hd15iqr": 0.004947667010128498,
-                "ops": 202.11546127758274,
-                "total": 0.004947667010128498,
-                "data": [
-                    0.004947667010128498
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-11]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-11]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 11
-            },
-            "param": "shots_and_results7-11",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.003849416971206665,
-                "max": 0.003849416971206665,
-                "mean": 0.003849416971206665,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.003849416971206665,
-                "iqr": 0.0,
-                "q1": 0.003849416971206665,
-                "q3": 0.003849416971206665,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.003849416971206665,
-                "hd15iqr": 0.003849416971206665,
-                "ops": 259.7795997367708,
-                "total": 0.003849416971206665,
-                "data": [
-                    0.003849416971206665
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-12]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-12]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 12
-            },
-            "param": "shots_and_results7-12",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.005518499994650483,
-                "max": 0.005518499994650483,
-                "mean": 0.005518499994650483,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.005518499994650483,
-                "iqr": 0.0,
-                "q1": 0.005518499994650483,
-                "q3": 0.005518499994650483,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.005518499994650483,
-                "hd15iqr": 0.005518499994650483,
-                "ops": 181.20866194969264,
-                "total": 0.005518499994650483,
-                "data": [
-                    0.005518499994650483
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-13]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-13]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 13
-            },
-            "param": "shots_and_results7-13",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.005429374985396862,
-                "max": 0.005429374985396862,
-                "mean": 0.005429374985396862,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.005429374985396862,
-                "iqr": 0.0,
-                "q1": 0.005429374985396862,
-                "q3": 0.005429374985396862,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.005429374985396862,
-                "hd15iqr": 0.005429374985396862,
-                "ops": 184.18326284142347,
-                "total": 0.005429374985396862,
-                "data": [
-                    0.005429374985396862
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-14]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-14]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 14
-            },
-            "param": "shots_and_results7-14",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.004841040994506329,
-                "max": 0.004841040994506329,
-                "mean": 0.004841040994506329,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.004841040994506329,
-                "iqr": 0.0,
-                "q1": 0.004841040994506329,
-                "q3": 0.004841040994506329,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.004841040994506329,
-                "hd15iqr": 0.004841040994506329,
-                "ops": 206.56714147531736,
-                "total": 0.004841040994506329,
-                "data": [
-                    0.004841040994506329
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-15]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-15]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 15
-            },
-            "param": "shots_and_results7-15",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.005831082991790026,
-                "max": 0.005831082991790026,
-                "mean": 0.005831082991790026,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.005831082991790026,
-                "iqr": 0.0,
-                "q1": 0.005831082991790026,
-                "q3": 0.005831082991790026,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.005831082991790026,
-                "hd15iqr": 0.005831082991790026,
-                "ops": 171.4947294367045,
-                "total": 0.005831082991790026,
-                "data": [
-                    0.005831082991790026
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-16]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-16]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 16
-            },
-            "param": "shots_and_results7-16",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.005832041031681001,
-                "max": 0.005832041031681001,
-                "mean": 0.005832041031681001,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.005832041031681001,
-                "iqr": 0.0,
-                "q1": 0.005832041031681001,
-                "q3": 0.005832041031681001,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.005832041031681001,
-                "hd15iqr": 0.005832041031681001,
-                "ops": 171.46655768842638,
-                "total": 0.005832041031681001,
-                "data": [
-                    0.005832041031681001
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-17]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-17]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 17
-            },
-            "param": "shots_and_results7-17",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.007709417026489973,
-                "max": 0.007709417026489973,
-                "mean": 0.007709417026489973,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.007709417026489973,
-                "iqr": 0.0,
-                "q1": 0.007709417026489973,
-                "q3": 0.007709417026489973,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.007709417026489973,
-                "hd15iqr": 0.007709417026489973,
-                "ops": 129.71149395135146,
-                "total": 0.007709417026489973,
-                "data": [
-                    0.007709417026489973
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-18]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-18]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 18
-            },
-            "param": "shots_and_results7-18",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.014526000013574958,
-                "max": 0.014526000013574958,
-                "mean": 0.014526000013574958,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.014526000013574958,
-                "iqr": 0.0,
-                "q1": 0.014526000013574958,
-                "q3": 0.014526000013574958,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.014526000013574958,
-                "hd15iqr": 0.014526000013574958,
-                "ops": 68.84207621268565,
-                "total": 0.014526000013574958,
-                "data": [
-                    0.014526000013574958
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-19]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-19]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 19
-            },
-            "param": "shots_and_results7-19",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.011261124978773296,
-                "max": 0.011261124978773296,
-                "mean": 0.011261124978773296,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.011261124978773296,
-                "iqr": 0.0,
-                "q1": 0.011261124978773296,
-                "q3": 0.011261124978773296,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.011261124978773296,
-                "hd15iqr": 0.011261124978773296,
-                "ops": 88.80107466038731,
-                "total": 0.011261124978773296,
-                "data": [
-                    0.011261124978773296
-                ],
-                "iterations": 1
-            }
-        },
-        {
-            "group": null,
-            "name": "test_benchmark[shots_and_results7-20]",
-            "fullname": "benchmark/benchmark.py::test_benchmark[shots_and_results7-20]",
-            "params": {
-                "shots_and_results": [
-                    100,
-                    "sample z(q[0])"
-                ],
-                "nq": 20
-            },
-            "param": "shots_and_results7-20",
-            "extra_info": {},
-            "options": {
-                "disable_gc": false,
-                "timer": "perf_counter",
-                "min_rounds": 5,
-                "max_time": 1.0,
-                "min_time": 5e-06,
-                "warmup": false
-            },
-            "stats": {
-                "min": 0.02057291701203212,
-                "max": 0.02057291701203212,
-                "mean": 0.02057291701203212,
-                "stddev": 0,
-                "rounds": 1,
-                "median": 0.02057291701203212,
-                "iqr": 0.0,
-                "q1": 0.02057291701203212,
-                "q3": 0.02057291701203212,
-                "iqr_outliers": 0,
-                "stddev_outliers": 0,
-                "outliers": "0;0",
-                "ld15iqr": 0.02057291701203212,
-                "hd15iqr": 0.02057291701203212,
-                "ops": 48.60759412071451,
-                "total": 0.02057291701203212,
-                "data": [
-                    0.02057291701203212
-                ],
-                "iterations": 1
-            }
-        }
-    ],
-    "datetime": "2024-08-27T18:31:42.399972",
-    "version": "4.0.0"
-}
\ No newline at end of file

From 0041a2b6ad41813697352ccb53a285647190b419 Mon Sep 17 00:00:00 2001
From: Katharine Hyatt <hyatkath@amazon.com>
Date: Tue, 27 Aug 2024 15:46:35 -0400
Subject: [PATCH 20/20] change: Point to new BraketSimulator 0.0.4

---
 src/braket/juliapkg.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/braket/juliapkg.json b/src/braket/juliapkg.json
index fdaca17..9ad41c3 100644
--- a/src/braket/juliapkg.json
+++ b/src/braket/juliapkg.json
@@ -3,7 +3,7 @@
     "packages": {
         "BraketSimulator": {
             "uuid": "76d27892-9a0b-406c-98e4-7c178e9b3dff",
-            "rev": "ksh/python"
+            "version": "0.0.4"
         },
         "JSON3": {
             "uuid": "0f8b85d8-7281-11e9-16c2-39a750bddbf1",