Docs preview for PR #3514.

Author: cuda-quantum-bot

pr-3514/_sources/using/backends/hardware/superconducting.rst.txt

@@ -287,20 +287,19 @@ Quantum Circuits, Inc.
 
 .. _qci-backend:
 
-As part of its first phase of integration with CUDA-Q,
-`Quantum Circuits <https://quantumcircuits.com/>`__ offers users the ability to simulate CUDA-Q
-programs using its simulator, AquSim. AquSim is the first simulator that models error detection and
-real-time control of Quantum Circuits' Dual-Rail Cavity Qubit systems, and uses a Monte Carlo
-approach to do so on a shot-by-shot basis.
-
-In this first phase, the supported features include all of the single and two-qubit gates offered by
-CUDA-Q, together with real-time conditional logic enabled by feed-forward capability. AquSim is
-currently wired to support ideal simulations only and noise models will be added in future
-iterations.
-
-With C++ and Python programming supported, users are able to prototype, test and explore quantum
-applications in CUDA-Q in preparation for upcoming releases targeting Quantum Circuits QPUs.
-Examples are provided to get started.
+As part of the integration with CUDA-Q, `Quantum Circuits <https://quantumcircuits.com/>`__ 
+provides the ability to simulate CUDA-Q programs using its AquSim simulator or 
+execute them on the Seeker QPU. AquSim is the first simulator to model error 
+detection and real-time control of Quantum Circuits' Dual-Rail Cavity Qubit 
+systems, using a Monte Carlo approach for shot-by-shot simulation. Seeker, the 
+industry's first Dual-Rail Cavity Qubit quantum computing system, supports all 
+core operations of a universal quantum computer. 
+
+In the initial phase, the supported features include all of the single and 
+two-qubit gates offered by CUDA-Q, together with real-time conditional logic 
+enabled by feed-forward capability. With C++ and Python programming supported, 
+users are able to prototype, test and explore quantum applications in CUDA-Q 
+targeting Quantum Circuits QPUs. Examples are provided to get started.
 
 Users who wish to get started with running CUDA-Q on AquSim should visit our
 `Explore <https://quantumcircuits.com/explore/>`__ page to learn more about the Quantum Circuits
@@ -333,11 +332,43 @@ named :code:`QCI_AUTH_TOKEN` before running your CUDA-Q program.
             [... your Python here]
 
         To run on AquSim, simply execute the script using your Python interpreter.
+        
+        To specify which QCI machine to use, set the :code:`machine` parameter:
+
+        .. code:: python
+
+            # The default machine is AquSim
+            cudaq.set_target('qci', machine='AquSim') 
+            # or
+            cudaq.set_target('qci', machine='Seeker')
+
+        You can control the execution method using the :code:`method` parameter:
+
+        .. code:: python
+
+            # For simulation (default)
+            cudaq.set_target('Seeker', method='simulate')
+            # For hardware execution
+            cudaq.set_target('Seeker', method='execute')
+
+        For noisy simulation, you can enable the :code:`noisy` parameter:
+
+        .. code:: python
+
+            cudaq.set_target('qci', noisy=True)
+
+        When collecting shots, you can ensure the requested number of shots are obtained
+        by enabling the :code:`repeat_until_shots_requested` parameter:
+
+        .. code:: python
+
+            cudaq.set_target('qci', repeat_until_shots_requested=True)
+
 
 .. tab:: C++
 
         When executing programs in C++, they must first be compiled using the
-        CUDA-Q nvq++ compiler, and then submitted to run on AquSim.
+        CUDA-Q nvq++ compiler, and then submitted to run on the device.
 
         Note that your token is fetched from your environment at run time, not at compile time.
 
@@ -351,5 +382,42 @@ named :code:`QCI_AUTH_TOKEN` before running your CUDA-Q program.
             nvq++ example.cpp --target qci -o example.x
             ./example.x
 
+        To specify which QCI machine to use, pass the ``--qci-machine`` flag:
+
+        .. code:: bash
+
+            # The default machine is AquSim
+            nvq++ --target qci --qci-machine AquSim src.cpp -o example.x
+            # or
+            nvq++ --target qci --qci-machine Seeker src.cpp -o example.x
+
+        You can control the execution method using the ``--qci-method`` flag:
+
+        .. code:: bash
+
+            # For simulation (default)
+            nvq++ --target qci --qci-machine Seeker --qci-method simulate src.cpp -o example.x
+            # For hardware execution
+            nvq++ --target qci --qci-machine Seeker --qci-method execute src.cpp -o example.x
+
+        For noisy simulation, you can set the ``--qci-noisy`` argument to `true`:
+
+        .. code:: bash
+
+            nvq++ --target qci --qci-noisy true src.cpp -o example.x
+
+        When collecting shots, you can ensure the requested number of shots are obtained
+        with the ``--qci-repeat_until_shots_requested`` argument:
+
+        .. code:: bash
+
+            nvq++ --target qci --qci-repeat_until_shots_requested true src.cpp -o example.x
+
+.. note::
+    By default, only successful shots are presented to the user and may be fewer than the 
+    requested number. Enabling :code:`repeat_until_shots_requested` ensures the full 
+    requested shot count is collected, at the cost of increased execution time.
+
+
 To see a complete example of using Quantum Circuits' backends, please take a look at the
 :ref:`Quantum Circuits examples <quantum-circuits-examples>`.

pr-3514/api/languages/python_api.html

@@ -2446,7 +2446,7 @@ <h3>Spin Operators<a class="headerlink" href="#spin-operators" title="Permalink
 <em class="property"><span class="pre">static</span><span class="w"> </span></em><span class="sig-name descname"><span class="pre">random</span></span><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="headerlink" href="#cudaq.operators.spin.SpinOperator.random" title="Permalink to this definition">¶</a></dt>
 <dd><dl class="py function">
 <dt class="sig sig-object py">
-<span class="sig-name descname"><span class="pre">random</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">qubit_count</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.14)"><span class="pre">int</span></a></span></em>, <em class="sig-param"><span class="n"><span class="pre">term_count</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.14)"><span class="pre">int</span></a></span></em>, <em class="sig-param"><span class="n"><span class="pre">seed</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.14)"><span class="pre">int</span></a></span><span class="w"> </span><span class="o"><span class="pre">=</span></span><span class="w"> </span><span class="default_value"><span class="pre">1577681192</span></span></em><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><a class="reference internal" href="#cudaq.operators.spin.SpinOperator" title="cudaq.operators.spin.SpinOperator"><span class="pre">SpinOperator</span></a></span></span></dt>
+<span class="sig-name descname"><span class="pre">random</span></span><span class="sig-paren">(</span><em class="sig-param"><span class="n"><span class="pre">qubit_count</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.14)"><span class="pre">int</span></a></span></em>, <em class="sig-param"><span class="n"><span class="pre">term_count</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.14)"><span class="pre">int</span></a></span></em>, <em class="sig-param"><span class="n"><span class="pre">seed</span></span><span class="p"><span class="pre">:</span></span><span class="w"> </span><span class="n"><a class="reference external" href="https://docs.python.org/3/library/functions.html#int" title="(in Python v3.14)"><span class="pre">int</span></a></span><span class="w"> </span><span class="o"><span class="pre">=</span></span><span class="w"> </span><span class="default_value"><span class="pre">3063169483</span></span></em><span class="sig-paren">)</span> <span class="sig-return"><span class="sig-return-icon">&#x2192;</span> <span class="sig-return-typehint"><a class="reference internal" href="#cudaq.operators.spin.SpinOperator" title="cudaq.operators.spin.SpinOperator"><span class="pre">SpinOperator</span></a></span></span></dt>
 <dd></dd></dl>
 
 <p>Return a random spin operator with the given number of terms (<code class="code docutils literal notranslate"><span class="pre">term_count</span></code>) where each term acts on all targets in the open range [0, qubit_count). An optional seed value may also be provided.</p>

pr-3514/api/languages/python_api.md

@@ -3624,7 +3624,7 @@ aria-hidden="true"}](../default_ops.html "Quantum Operations"){.btn
 
     :   
 
-        [[random]{.pre}]{.sig-name .descname}[(]{.sig-paren}*[[qubit_count]{.pre}]{.n}[[:]{.pre}]{.p}[ ]{.w}[[[int]{.pre}](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)"){.reference .external}]{.n}*, *[[term_count]{.pre}]{.n}[[:]{.pre}]{.p}[ ]{.w}[[[int]{.pre}](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)"){.reference .external}]{.n}*, *[[seed]{.pre}]{.n}[[:]{.pre}]{.p}[ ]{.w}[[[int]{.pre}](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)"){.reference .external}]{.n}[ ]{.w}[[=]{.pre}]{.o}[ ]{.w}[[1577681192]{.pre}]{.default_value}*[)]{.sig-paren} [[→]{.sig-return-icon} [[[SpinOperator]{.pre}](#cudaq.operators.spin.SpinOperator "cudaq.operators.spin.SpinOperator"){.reference .internal}]{.sig-return-typehint}]{.sig-return}
+        [[random]{.pre}]{.sig-name .descname}[(]{.sig-paren}*[[qubit_count]{.pre}]{.n}[[:]{.pre}]{.p}[ ]{.w}[[[int]{.pre}](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)"){.reference .external}]{.n}*, *[[term_count]{.pre}]{.n}[[:]{.pre}]{.p}[ ]{.w}[[[int]{.pre}](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)"){.reference .external}]{.n}*, *[[seed]{.pre}]{.n}[[:]{.pre}]{.p}[ ]{.w}[[[int]{.pre}](https://docs.python.org/3/library/functions.html#int "(in Python v3.14)"){.reference .external}]{.n}[ ]{.w}[[=]{.pre}]{.o}[ ]{.w}[[3063169483]{.pre}]{.default_value}*[)]{.sig-paren} [[→]{.sig-return-icon} [[[SpinOperator]{.pre}](#cudaq.operators.spin.SpinOperator "cudaq.operators.spin.SpinOperator"){.reference .internal}]{.sig-return-typehint}]{.sig-return}
 
         :   
 

pr-3514/applications/python/adapt_qaoa.html

@@ -1012,7 +1012,7 @@ <h1>ADAPT-QAOA algorithm<a class="headerlink" href="#ADAPT-QAOA-algorithm" title
 parameter</p>
 <p>3- Optimize all parameters currently in the Ansatz <span class="math notranslate nohighlight">\(\beta_m, \gamma_m = 1, 2, ...k\)</span> such that <span class="math notranslate nohighlight">\(\braket{\psi (k)|H_C|\psi(k)}\)</span> is minimized, and return to the second step.</p>
 <p>Below is a schematic representation of the ADAPT-QAOA algorithm explained above.</p>
-<div><p><img alt="3d4277dc7b9d4bd8a392601bac163a66" class="no-scaled-link" src="../../_images/adapt-qaoa.png" style="width: 1000px;" /></p>
+<div><p><img alt="9a0350baa470402b8dd0768c187da5d0" class="no-scaled-link" src="../../_images/adapt-qaoa.png" style="width: 1000px;" /></p>
 </div><div class="nbinput nblast docutils container">
 <div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[15]:
 </pre></div>

pr-3514/applications/python/adapt_qaoa.md

@@ -1777,7 +1777,7 @@ explained above.
 
 <div>
 
-![3d4277dc7b9d4bd8a392601bac163a66](../../_images/adapt-qaoa.png){.no-scaled-link
+![9a0350baa470402b8dd0768c187da5d0](../../_images/adapt-qaoa.png){.no-scaled-link
 style="width: 1000px;"}
 
 </div>

pr-3514/applications/python/adapt_vqe.html

@@ -1009,7 +1009,7 @@ <h1>ADAPT-VQE algorithm<a class="headerlink" href="#ADAPT-VQE-algorithm" title="
 <p>7- Perform a VQE experiment to re-optimize all parameters in the ansatz.</p>
 <p>8- go to step 4</p>
 <p>Below is a Schematic depiction of the ADAPT-VQE algorithm</p>
-<div><p><img alt="5d267f50980c4c9eaa5fda6378ba4e2e" class="no-scaled-link" src="../../_images/adapt-vqe.png" style="width: 800px;" /></p>
+<div><p><img alt="5a4ca4796c2b4f22a9b71af749905e9d" class="no-scaled-link" src="../../_images/adapt-vqe.png" style="width: 800px;" /></p>
 </div><div class="nbinput docutils container">
 <div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[1]:
 </pre></div>

pr-3514/applications/python/adapt_vqe.md

@@ -1745,7 +1745,7 @@ Below is a Schematic depiction of the ADAPT-VQE algorithm
 
 <div>
 
-![5d267f50980c4c9eaa5fda6378ba4e2e](../../_images/adapt-vqe.png){.no-scaled-link
+![5a4ca4796c2b4f22a9b71af749905e9d](../../_images/adapt-vqe.png){.no-scaled-link
 style="width: 800px;"}
 
 </div>

pr-3514/applications/python/deutsch_algorithm.html

@@ -1069,7 +1069,7 @@ <h2>XOR <span class="math notranslate nohighlight">\(\oplus\)</span><a class="he
 </section>
 <section id="Quantum-oracles">
 <h2>Quantum oracles<a class="headerlink" href="#Quantum-oracles" title="Permalink to this heading">¶</a></h2>
-<p><img alt="250d9e0756974bf9801949b6fc27f253" class="no-scaled-link" src="../../_images/oracle.png" style="width: 300px; height: 150px;" /></p>
+<p><img alt="8eb20595f26f4258b09e5ed83bbcde84" class="no-scaled-link" src="../../_images/oracle.png" style="width: 300px; height: 150px;" /></p>
 <p>Suppose we have <span class="math notranslate nohighlight">\(f(x): \{0,1\} \longrightarrow \{0,1\}\)</span>. We can compute this function on a quantum computer using oracles which we treat as black box functions that yield the output with an appropriate sequence of logical gates.</p>
 <p>Above you see an oracle represented as <span class="math notranslate nohighlight">\(U_f\)</span> which allows us to transform the state <span class="math notranslate nohighlight">\(\ket{x}\ket{y}\)</span> into:</p>
 <div class="math notranslate nohighlight">
@@ -1117,7 +1117,7 @@ <h2>Quantum parallelism<a class="headerlink" href="#Quantum-parallelism" title="
 <h2>Deutsch’s Algorithm:<a class="headerlink" href="#Deutsch's-Algorithm:" title="Permalink to this heading">¶</a></h2>
 <p>Our aim is to find out if <span class="math notranslate nohighlight">\(f: \{0,1\} \longrightarrow \{0,1\}\)</span> is a constant or a balanced function? If constant, <span class="math notranslate nohighlight">\(f(0) = f(1)\)</span>, and if balanced, <span class="math notranslate nohighlight">\(f(0) \neq f(1)\)</span>.</p>
 <p>We step through the circuit diagram below and follow the math after the application of each gate.</p>
-<p><img alt="34bdb9cc895a4b928b77db6a7a76cf79" class="no-scaled-link" src="../../_images/deutsch.png" style="width: 500px; height: 210px;" /></p>
+<p><img alt="be1bd3ff1c504e84b34215d666e91496" class="no-scaled-link" src="../../_images/deutsch.png" style="width: 500px; height: 210px;" /></p>
 <div class="math notranslate nohighlight">
 \[\ket{\psi_0}  =  \ket{01}
 \tag{1}\]</div>

pr-3514/applications/python/deutsch_algorithm.md

@@ -1826,7 +1826,7 @@ number, the result is 0 otherwise 1.
 ::: {#Quantum-oracles .section}
 ## Quantum oracles[¶](#Quantum-oracles "Permalink to this heading"){.headerlink}
 
-![250d9e0756974bf9801949b6fc27f253](../../_images/oracle.png){.no-scaled-link
+![8eb20595f26f4258b09e5ed83bbcde84](../../_images/oracle.png){.no-scaled-link
 style="width: 300px; height: 150px;"}
 
 Suppose we have [\\(f(x): \\{0,1\\} \\longrightarrow \\{0,1\\}\\)]{.math
@@ -1932,7 +1932,7 @@ balanced function? If constant, [\\(f(0) = f(1)\\)]{.math .notranslate
 We step through the circuit diagram below and follow the math after the
 application of each gate.
 
-![34bdb9cc895a4b928b77db6a7a76cf79](../../_images/deutsch.png){.no-scaled-link
+![be1bd3ff1c504e84b34215d666e91496](../../_images/deutsch.png){.no-scaled-link
 style="width: 500px; height: 210px;"}
 
 ::: {.math .notranslate .nohighlight}

pr-3514/applications/python/edge_detection.html

@@ -1049,7 +1049,7 @@ <h2>Image<a class="headerlink" href="#Image" title="Permalink to this heading">
 <section id="Quantum-Probability-Image-Encoding-(QPIE):">
 <h2>Quantum Probability Image Encoding (QPIE):<a class="headerlink" href="#Quantum-Probability-Image-Encoding-(QPIE):" title="Permalink to this heading">¶</a></h2>
 <p>Lets take as an example a classical 2x2 image (4 pixels). We can label each pixel with its position</p>
-<div><p><img alt="2861d996290242f7858d9ac544a2c602" class="no-scaled-link" src="../../_images/pixels-img.png" style="width: 200px;" /></p>
+<div><p><img alt="631d4529fc2e4b6994b72df53f30394a" class="no-scaled-link" src="../../_images/pixels-img.png" style="width: 200px;" /></p>
 </div><p>Each pixel will have its own color intensity represented along with its position label as an 8-bit black and white color. To convert the pixel intensity to probability amplitudes of a quantum state</p>
 <div class="math notranslate nohighlight">
 \[c_i = \frac{I_{yx}}{\sqrt(\sum I^2_{yx})}\]</div>