Sync docs for SDK version 1.2.0

Author: classiq-library-bot-app[bot]

.internal/docs/qmod-reference/api-reference/functions/core_library/gray_code.md

@@ -10,5 +10,6 @@ search:
         show_if_no_docstrings: false
         members:
             - select_rotation
+            - select_z_rotation
 <!-- prettier-ignore-end -->
 <!-- spell-checker: enable -->

.internal/docs/qmod-reference/language-reference/expressions.md

@@ -166,7 +166,7 @@ on the Assignment documentation page.
 
 Classical expressions are expressions that involve classical variables and
 constant literals, but no quantum variables.
-Classical variables may have known values at [compile time, link time, or runtime]](https://docs.classiq.io/latest/qmod-reference/language-reference/classical-variables/#semantics).
+Classical variables may have known values at [compile time, link time, or runtime](https://docs.classiq.io/latest/qmod-reference/language-reference/classical-variables/#semantics).
 Classical expressions with only compile-time variables are evaluated and
 simplified during compilation.
 This applies sub-expressions of quantum expressions too.

.internal/docs/qmod-reference/language-reference/generative-descriptions.md

@@ -141,7 +141,7 @@ The example below demonstrates the declaration and use of a function parameter w
 a Python type. The function `my_operator` takes a function parameter `my_operand`,
 which expects a Python `float` as parameter. In function `main`, `my_operator` is called
 and passed a lambda expression in which the corresponding `ratio` parameter is used
-in Python context expression, namely as the argument of `math.asin`. If `ration*2` were
+in Python context expression, namely as the argument of `math.asin`. If `ratio*2` were
 a symbolic expression, it would be illegal to use it in this context.
 
 ```python

.internal/docs/qmod-reference/language-reference/quantum-types.md

@@ -223,6 +223,7 @@ the values are rounded down:
 
 Output measurements:
 
+```
     state=[{'x': 1.0, 'y': 1.25}: 268,
             {'x': 1.5, 'y': 2.0}: 262,
             {'x': 2.5, 'y': 3.25}: 261,
@@ -231,6 +232,7 @@ Output measurements:
             {'x': 3.5, 'y': 0.75}: 253,
             {'x': 0.5, 'y': 0.5}: 251,
             {'x': 3.0, 'y': 0.0}: 238]
+```
 
 Notice, for instance, when `x = 1.0`, the exact product 1.4 is rounded down to 1.25 to fit into `y`'s available qubits.
 
@@ -491,9 +493,11 @@ diffuser is defined in a generic way and uses the qubit array view of the state.
 Executing this model will sample a state representing a solution to the problem in
 very high probability. This is an example of an output. Here is an output example:
 
+```
     state={'p': {'a': 0.0, 'b': 0.625}} shots=350
     state={'p': {'a': 0.25, 'b': 0.375}} shots=344
     state={'p': {'a': 0.5, 'b': 0.125}} shots=306
+```
 
 In Qmod's Python embedding, the size of `MyProblem` is given by
 `MyProblem.num_qubits`:

.internal/docs/qmod-reference/language-reference/statements/power.md

@@ -43,6 +43,7 @@ of the _power_ operation.
 
     ```python
     from classiq import *
+    from classiq.qmod.symbolic import pi
 
 
     @qfunc
@@ -52,8 +53,7 @@ of the _power_ operation.
 
 
     @qfunc
-    def main() -> None:
-        q = QBit()
+    def main(q: Output[QBit]) -> None:
         allocate(q)
         power(2, lambda: foo(5, q))
     ```

.internal/docs/sdk-reference/cudaq.md

@@ -0,0 +1,13 @@
+---
+search:
+    boost: 1.0
+---
+
+<!-- cspell:ignore cudaq -->
+
+Classiq to [CUDA-Q](https://developer.nvidia.com/cuda-q) translation.
+These functions require the `cudaq` extra (install `classiq[cudaq]`).
+Note that the `cudaq` extra is only available in Classiq Studio and on any Linux
+Machine.
+
+::: classiq.qprog_to_cudaq

.internal/docs/user-guide/execution/budget-management.md

@@ -5,13 +5,13 @@ search:
 
 # Managing Execution Budget
 
-Enrolled users can run quantum programs on multiple backends without needing to provide their own credentials, by using `run_through_classiq`.
+Enrolled users can run quantum programs on multiple backends without needing to provide their own credentials, by using `run_via_classiq`.
 
-When a job is submitted using `run_through_classiq`, it will only proceed if the estimated cost is within the remaining budget allocated for the chosen provider.
+When a job is submitted using `run_via_classiq`, it will only proceed if the estimated cost is within the remaining budget allocated for the chosen provider.
 
 Additionally, we offer methods to monitor usage and set limits, helping you control and optimize your spending.
 
-For example, to set up execution using `run_through_classiq` on the Amazon Braket SV1 simulator:
+For example, to set up execution using `run_via_classiq` on the Amazon Braket SV1 simulator:
 
 [comment]: DO_NOT_TEST
 
@@ -29,7 +29,7 @@ qprog = synthesize(main)
 exec_pref = ExecutionPreferences(
     backend_preferences=AwsBackendPreferences(
         backend_name="SV1",
-        run_through_classiq=True,
+        run_via_classiq=True,
     )
 )
 

.internal/docs/user-guide/execution/cloud-providers/azure-backends.md

@@ -16,7 +16,7 @@ The Classiq executor supports execution on Azure Quantum cloud simulators and ha
 
 Possible modes of operation:
 
--   Running through Classiq-Azure integration. In this mode you do not need to provide credentials or location.
+-   Running via Classiq-Azure integration. In this mode you do not need to provide credentials or location.
 -   Executing on your private Azure Quantum Workspace by providing credentials.
     For more details, see [Executing on Your Quantum Workspace](#executing-on-your-quantum-workspace).
 
@@ -30,12 +30,12 @@ Possible modes of operation:
         AzureBackendPreferences,
     )
 
-    # Running through Classiq-Azure integration:
+    # Running via Classiq-Azure integration:
     preferences = AzureBackendPreferences(
         backend_name="Name of requsted simulator or hardware",
     )
 
-    # Running through a private Azure account:
+    # Running via a private Azure account:
     cred = AzureCredential(
         tenant_id="Azure Tenant ID (from Azure Active Directory)",
         client_id="Azure Application (client) ID",
@@ -54,7 +54,7 @@ Possible modes of operation:
 
      ![Opening info tab](../../../resources/execution_azure_login.png)
 
-For academic users, backends run through Classiq-Azure integration by default. To override this configuration, switch on "Run with my own credentials" in the backends summary section on the Execution page:
+For academic users, backends run via Classiq-Azure integration by default. To override this configuration, switch on "Run with my own credentials" in the backends summary section on the Execution page:
 
 ![Config run with own credentials](../../../resources/config-run-with-own-credentials.png)
 

.internal/docs/user-guide/execution/cudaq_integration.md

@@ -0,0 +1,58 @@
+# CUDA-Q Integration
+
+## Overview
+
+The Classiq–CUDA-Q integration enables users to design quantum algorithms at a high level using Classiq, while leveraging CUDA-Q for execution, simulation, and hybrid quantum–classical workflows.
+This integration is particularly well suited for variational algorithms, such as QAOA, where circuit synthesis, parameterized execution, and classical optimization must work together efficiently.
+
+## Prerequisites
+
+Before using the integration, ensure the following are installed in your python environment:
+
+-   Python 3.9 or later
+-   Classiq SDK
+-   CUDA-Q
+
+Note: The integration is only supported on Linux. The simplest way to handle installations is to use [Classiq Studio](https://platform.classiq.io/studio/) and `pip install classiq[cudaq]`.
+
+## Integration Core Functions
+
+The Integration is built around two Classiq SDK helper functions:
+
+-   `qprog_to_cudaq_kernel()`  
+    Converts a synthesized Classiq quantum program (`qprog`) into a CUDA-Q kernel that can be executed using CUDA-Q SDK.
+
+-   `pauli_operator_to_cudaq_spin_op()`  
+    Transforms Qmod's `SparsePauliOp` data structure to CUDA-Q's `SpinOperator`.
+
+## Usage Example
+
+Here is a minimal example:
+
+-   Defining and synthesizing a parametric model using Classiq.
+-   Converting to CUDA-Q kernel, assigning value to the parameter and sampling.
+
+[comment]: DO_NOT_TEST
+
+```python
+# ! pip install classiq[cudaq]
+from classiq import *
+import cudaq
+import math
+
+
+@qfunc
+def main(theta: CReal, q: Output[QBit]):
+    allocate(q)
+    RX(theta, q)
+
+
+qprog = synthesize(main)
+my_kernel = qprog_to_cudaq_kernel(qprog)
+
+counts = cudaq.sample(my_kernel, math.pi / 3)
+print(counts)
+
+# example outputs -
+# { 0:753 1:247 }
+```

.internal/docs/user-guide/execution/index.md

@@ -16,7 +16,7 @@ When designing your model, do not forget to include [execution primitives](primi
 
     When viewing a quantum program in the "Quantum Program" page, after synthesizing your model or uploading your quantum program file, click "Execute":
 
-    ![Execute a quantum program](../resources/execute_circuit_button.png)
+    ![Execute a quantum program](../resources/newvis_execute_circuit_button.png)
 
     In the next screen you can choose your execution preferences and run your quantum program.
 
@@ -25,26 +25,26 @@ When designing your model, do not forget to include [execution primitives](primi
     [comment]: DO_NOT_TEST
 
 ```python
-from classiq import qfunc, Output, QBit, synthesize, execute, allocate
+from classiq import *
 
 
 # Design your quantum model
 @qfunc
 def main(res: Output[QBit]) -> None:
-    allocate(1, res)
+    allocate(res)
 
 
 # Synthesize a quantum program from the quantum model
 quantum_program = synthesize(main)
 
 # Execute the quantum program and access the result
-job = execute(quantum_program)
-results = job.result()
+ex = execute(quantum_program)
+results = ex.result()
 ```
 
 ### Execution Preferences
 
-You can configure the execution process by modifying the execution preferences.
+You can configure the execution process by modifying the execution preferences with the function [`ExecutionPreferences`](../../sdk-reference/execution/#classiq.execution.ExecutionPreferences).
 The main execution preferences:
 
 -   Backend preferences, such as provider, backend name, and credentials. See [Cloud Providers](cloud-providers/index.md).
@@ -58,13 +58,13 @@ The main execution preferences:
 
     Choose your backend preferences in the "Execute Quantum Circuit" window:
 
-    ![Choose backend preferences](../resources/backend_preferences.png)
+    ![Choose backend preferences](../resources/newvis_backend_preferences.png)
 
     You can select more than one backend on which to run, but note that a maximum of five backends can be selected at a time.
 
     Optionally configure more execution preferences in the "Execution Configuration" window:
 
-    ![Choose execution preferences](../resources/execution_preferences.png)
+    ![Choose execution preferences](../resources/newvis_execution_preferences.png)
 
     Finally, execute your program by clicking "Run".
 
@@ -75,17 +75,17 @@ The main execution preferences:
     [comment]: DO_NOT_TEST
 
     ```python
-    from classiq import set_execution_preferences, ExecutionPreferences
+    from classiq import *
 
     # Define execution preferences
     execution_preferences = ExecutionPreferences(
         num_shots=1000
     )  # set your real preferences instead!
 
     # Set the execution preferences
-    model = set_execution_preferences(model, execution_preferences)
+    with ExecutionSession(qprog, execution_preferences=execution_preferences) as es:
+        results_more_shots = es.sample()
     ```
-    See [ExecutionPreferences](../../sdk-reference/execution/#classiq.execution.ExecutionPreferences) in the SDK reference for more details.
 
     <!-- prettier-ignore-start -->
     !!! tip
@@ -131,6 +131,8 @@ regardless of whether they were originally sent via the IDE or the SDK.
     job = ExecutionJob.from_id("00000000-0000-0000-0000-000000000000")
     ```
 
+    See also [`get_execution_jobs` reference](../../sdk-reference/execution/#classiq.execution.jobs.get_execution_jobs)
+
 ### Results
 
 === "IDE"
@@ -143,8 +145,7 @@ regardless of whether they were originally sent via the IDE or the SDK.
 
     It is possible to filter the results by specifying them:
 
-    ![Filter results](../resources/filter_results_button.png)
-    ![Filtered results](../resources/filtered_results.png)
+    ![Filter results](../resources/newvis_filter_results_button.png)
 
 === "SDK"