Add test: rainbow_options_integration_method

Author: classiqdor

research/rainbow_options/rainbow_options_integration_method.ipynb

@@ -520,11 +520,12 @@
     "    rainbow_integration(qvars)\n",
     "\n",
     "\n",
-    "constraints = Constraints(max_width=23)\n",
-    "qmod = create_model(main, constraints=constraints)\n",
+    "MAX_WIDTH_1 = 23\n",
+    "qmod_1 = create_model(main)\n",
+    "qmod_1 = update_constraints(qmod_1, max_width=MAX_WIDTH_1)\n",
     "print(\"Starting synthesis\")\n",
-    "qprog = synthesize(qmod)\n",
-    "show(qprog)"
+    "qprog_1 = synthesize(qmod_1)\n",
+    "show(qprog_1)"
    ]
   },
   {
@@ -633,17 +634,18 @@
    },
    "outputs": [],
    "source": [
-    "qmod = create_model(\n",
+    "MAX_WIDTH_2 = 25\n",
+    "qmod_2 = create_model(\n",
     "    main,\n",
-    "    constraints=Constraints(max_width=25),\n",
+    "    constraints=Constraints(max_width=MAX_WIDTH_2),\n",
     "    classical_execution_function=cmain,\n",
     "    out_file=\"rainbow_options_integration_method\",\n",
     ")\n",
     "print(\"Starting synthesis\")\n",
-    "qprog = synthesize(qmod)\n",
-    "show(qprog)\n",
+    "qprog_2 = synthesize(qmod_2)\n",
+    "show(qprog_2)\n",
     "print(\"Starting execution\")\n",
-    "result = execute(qprog).result_value()\n",
+    "result = execute(qprog_2).result_value()\n",
     "print(\"raw iqae results:\", result.estimation, result.confidence_interval)"
    ]
   },

research/rainbow_options/rainbow_options_integration_method.qmod

@@ -9,6 +9,13 @@ qstruct EstimationVars {
   ind: qbit;
 }
 
+qfunc grover_algorithm(k: int, oracle_operand: qfunc (qbit[]), sp_operand: qfunc (qbit[]), x: qbit[]) {
+  sp_operand(x);
+  power (k) {
+    grover_operator(oracle_operand, sp_operand, x);
+  }
+}
+
 qfunc qmci_oracle(qvars: EstimationVars) {
   Z(qvars.ind);
 }
@@ -65,13 +72,6 @@ qfunc rainbow_integration(qvars: EstimationVars) {
   }
 }
 
-qfunc grover_algorithm(k: int, oracle_operand: qfunc (qbit[]), sp_operand: qfunc (qbit[]), x: qbit[]) {
-  sp_operand(x);
-  power (k) {
-    grover_operator(oracle_operand, sp_operand, x);
-  }
-}
-
 qfunc main(k: int, output ind: qbit) {
   qvars: EstimationVars;
   allocate(qvars.size, qvars);

research/rainbow_options/rainbow_options_integration_method.synthesis_options.json

@@ -1,5 +1,45 @@
 {
   "constraints": {
-    "max_width": 25
+    "max_width": 25,
+    "max_gate_count": {},
+    "optimization_parameter": "no_opt"
+  },
+  "preferences": {
+    "machine_precision": 8,
+    "custom_hardware_settings": {
+      "basis_gates": [
+        "sx",
+        "u1",
+        "id",
+        "x",
+        "p",
+        "z",
+        "y",
+        "h",
+        "rz",
+        "cz",
+        "u",
+        "rx",
+        "r",
+        "sxdg",
+        "ry",
+        "sdg",
+        "t",
+        "cy",
+        "u2",
+        "s",
+        "cx",
+        "tdg"
+      ],
+      "is_symmetric_connectivity": true
+    },
+    "debug_mode": true,
+    "synthesize_all_separately": false,
+    "optimization_level": 3,
+    "output_format": ["qasm"],
+    "pretty_qasm": true,
+    "transpilation_option": "auto optimize",
+    "timeout_seconds": 300,
+    "random_seed": 1749957507
   }
 }

tests/notebooks/test_rainbow_options_bruteforce_method.py

@@ -5,8 +5,6 @@
 )
 from testbook.client import TestbookNotebookClient
 
-import numpy as np
-
 
 @wrap_testbook(
     "rainbow_options_bruteforce_method",

tests/notebooks/test_rainbow_options_integration_method.py

@@ -0,0 +1,47 @@
+from tests.utils_for_testbook import (
+    validate_quantum_program_size,
+    validate_quantum_model,
+    wrap_testbook,
+)
+from testbook.client import TestbookNotebookClient
+
+import numpy as np
+
+
+@wrap_testbook(
+    "rainbow_options_integration_method",
+    timeout_seconds=1000,
+)
+def test_notebook(tb: TestbookNotebookClient) -> None:
+    """
+    A notebook for a hybrid classical quantum neural network.
+    The test verifies that the pre-trained model is indeed well trained.
+    """
+    # test models
+    validate_quantum_model(tb.ref("qmod_1"))
+    validate_quantum_model(tb.ref("qmod_2"))
+    # test quantum programs
+    validate_quantum_program_size(
+        tb.ref("qprog_1"),
+        expected_width=tb.ref("MAX_WIDTH_1"),
+        expected_depth=1700,  # actual depth: 1456
+    )
+    validate_quantum_program_size(
+        tb.ref("qprog_2"),
+        expected_width=tb.ref("MAX_WIDTH_2"),
+        expected_depth=5500,  # actual depth: 4930
+    )
+
+    # test notebook content
+    expected_payoff = 23.0238
+    alpha_assertion = 1e-5
+
+    measured_confidence = tb.ref("conf_interval[1] - conf_interval[0]")
+    # based on e^2=(1/2N)*log(2T/alpha) from "Iterative Quantum Amplitude Estimation" since our alpha is low, we want to check within a bigger confidence interval
+    confidence_scale_by_alpha = np.sqrt(np.log(tb.ref("ALPHA_VALUE") / alpha_assertion))
+
+    parsed_result = tb.ref("parsed_result")
+    assert (
+        np.abs(parsed_result - expected_payoff)
+        <= 0.5 * measured_confidence * confidence_scale_by_alpha
+    ), f"Payoff result is out of the {alpha_assertion*100}% confidence interval: |{parsed_result} - {expected_payoff}| > {0.5*measured_confidence * confidence_scale_by_alpha}"