modifications after revision

Author: alexandre-ricardo

tutorials/documentation_materials/classiq_101/classiq_concepts/design/classical_variables_and_operations/classical_variables_and_operations.ipynb

@@ -13,9 +13,9 @@
    "source": [
     "Classical variables and operations lie at the heart of the Qmod language, but they are complemented by classical control flow and operations, making it easier to design quantum algorithms with hybrid quantum-classical logic. With the latest updates, Qmod now fully supports Python's classical operations, such as `for` loops, `if-else` statements, and more, smoothly integrating with quantum workflows.\n",
     "\n",
-    "In Qmod, equivalent types for common Python `int`, `float`, `list`, and `bool` types are denoted by `int`, `real`, `array`, and `bool` in the native syntax and by `CInt`, `CReal`, `CArray`, and `CBool` in the Python SDK. The Qmod types can be used in quantum workflows, though Python types can also be passed as classical parameters. For example, when writing quantum workflows, it is possible to use both the lenght of a quantum array, which is a Qmod quantity, or a Python `int` quantity to control the action of a loop. This ensures the type consistency required for quantum control flow operations like `repeat` (the Qmod equivalent of a Python `for` loop) and `if-else` statements, which enable sophisticated hybrid control logic, see a [detailed description](https://docs.classiq.io/latest/qmod-reference/language-reference/statements/classical-control-flow/). Additionally, Qmod supports arrays of classical values and more configurable data structures called `Struct`s (equivalent to Python dataclasses without methods). See the full list of [classical variables and types supported in Qmod](https://docs.classiq.io/latest/qmod-reference/language-reference/classical-types/#structs). \n",
+    "In Qmod, equivalent types for common Python `int`, `float`, `list`, and `bool` types are denoted by `int`, `real`, `array`, and `bool` in the native syntax and by `CInt`, `CReal`, `CArray`, and `CBool` in the Python SDK. The Qmod types can be used in quantum workflows, though Python types can also be passed as classical parameters. For example, when writing quantum workflows, it is possible to use both the length of a quantum array, which is a Qmod quantity, or a Python `int` quantity to control the action of a loop. This ensures the type consistency required for quantum control flow operations like `repeat` (the Qmod equivalent of a Python `for` loop) and `if-else` statements, which enable sophisticated hybrid control logic, see a [detailed description](https://docs.classiq.io/latest/qmod-reference/language-reference/statements/classical-control-flow/). Additionally, Qmod supports arrays of classical values and more configurable data structures called `Struct`s (equivalent to Python dataclasses without methods). See the full list of [classical variables and types supported in Qmod](https://docs.classiq.io/latest/qmod-reference/language-reference/classical-types/#structs). \n",
     "\n",
-    "While Qmod enables the integration of Python types within its quantum workflows, the converse is not true. Python control flow constructs, such as `range`, `for` loops and `if-else` statements, are central to managing logic and iteration in classical programming. These constructs enable dynamic behavior, such as iterating over lists or conditionally executing code based on runtime values. However, it is not possible to use Qmod-specific quantities, such as the `len` of a quantum array, within Python’s native control flow. Qmod quantities remain tightly integrated within the Qmod execution environment and cannot directly influence Python logic, ensuring a clear separation between classical Python constructs and Qmod quantum operations."
+    "While Qmod enables the integration of Python types within its quantum workflows, the converse is not true with the capabilities covered so far. Python control flow constructs, such as `range`, `for` loops and `if-else` statements, cannot yet incorporate Qmod-specific quantities such as the `len` of a quantum array, within Python’s native control flow. Qmod quantities remain tightly integrated within the Qmod execution environment and cannot directly influence Python logic, ensuring a clear separation between classical Python constructs and Qmod quantum operations."
    ]
   },
   {
@@ -33,7 +33,7 @@
     "\n",
     "- **`range`**: Generate sequences of classical values to iterate quantum operations dynamically over classical types within Qmod types. \n",
     "- **`if` statements**: Define conditional logic for generating and applying quantum operations using Qmod types as classical control parameters.\n",
-    "- **Threat quantum constants as classical**: Converts parameters intricate to the quantum systems to Python types. This allows one to use, for example, integration of functions from external packages such as `math.sqrt` over classical quantities of a quantum object, such as the `len` of a quantum array.\n",
+    "- **Treating quantum constants as classical**: Converts parameters intricate to the quantum systems to Python types. This allows one to use, for example, integration of functions from external packages such as `math.sqrt` over classical quantities of a quantum object, such as the `len` of a quantum array.\n",
     "\n",
     "\n",
     "Generative functions provide an elegant way to manage hybrid classical-quantum workflows, enhancing the expressiveness of your quantum algorithms. For more details and examples, refer to the [Generative Functions documentation](https://docs.classiq.io/latest/qmod-reference/language-reference/generative-functions/?h=ge).\n",
@@ -60,7 +60,7 @@
     "\n",
     "The argument of the `main` function is a qubit array named `x`. Initalize it to the state $|0000000000\\rangle$ with $10$ qubits using the `allocate` function.\n",
     "\n",
-    "After that, by allowing generative functions by setting `@qfunc(generative=True)`, it is possible to use the lenght of the qubit array `x` as a classical variable, and apply quantum operations over qubits dynamically, using Python's `if` and `for` statements over the qmod `x.len` quantity, according to the pre-defined rule of flipping the state of the even qubits. \n",
+    "After that, by allowing generative functions by setting `@qfunc(generative=True)`, it is possible to use the length of the qubit array `x` as a classical variable, and apply quantum operations over qubits dynamically, using Python's `if` and `for` statements over the qmod `x.len` quantity, according to the pre-defined rule of flipping the state of the even qubits. \n",
     "\n",
     "The condition of whether `i` is even evaluated is using the `%` modulo operation, which calculates the reminder of the integer `i` divided by $2$."
    ]
@@ -174,7 +174,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "In this example, the task is to prepare the $N$-qubit state $|0001111000\\dots\\rangle$, where the state $|1\\rangle$ is prepared between the qubits over the integer interval $(N/3, N/2)$. For this, it is possible to create a program that applies the $X$ operation to the correct qubits. In this example, consider a total of $N=24$ qubits."
+    "In this example, the task is to prepare the $N$-qubit state $|00011111000\\dots\\rangle$, where the state $|1\\rangle$ is prepared in the qubits over the integer interval $(N/3, N/2)$. For this, it is possible to create a program that apply alternately the $X$ operation to the correct qubits. In this example, consider a total of $N=24$ qubits."
    ]
   },
   {
@@ -187,6 +187,7 @@
     "@qfunc(generative=True)\n",
     "def main(x: Output[QArray]):\n",
     "    allocate(24, x)\n",
+    "    k=0\n",
     "    for i in range(x.len//3,x.len//2):\n",
     "        X(x[i])"
    ]