review-1

Author: v-thpra

learn-pr/quantum/qsharp-create-first-quantum-development-kit/5-knowledge-check.yml

@@ -1,55 +1,55 @@
-### YamlMime:ModuleUnit
-uid: learn.quantum.qsharp-create-first-quantum-development-kit.knowledge-check
-title: Module assessment
-metadata:
-  title: Module assessment
-  description: Check your understanding so far.
-  author: azure-quantum-content
-  ms.author: quantumdocwriters
-  
-  ms.date: 10/30/2024
-  ms.topic: unit
-  ai-usage: ai-assisted
-durationInMinutes: 7
-content: |
-  [!include[](includes/5-knowledge-check.md)]
-
-quiz:
-  title: Check your knowledge
-  questions:
-
-  - content: 'Which of these statements is true about the random number generator that you built in this module?'
-    choices:
-    - content: "The quantum random number generator takes the current time from the CPU's clock as a seed to generate random numbers."
-      isCorrect: false
-      explanation: "The quantum random number generator doesn't use the CPU's clock to generate random numbers. A classical pseudo-random number generator would do that."
-    - content: "The quantum random number generator creates one qubit, measures it, and the result of the measurement is a random decimal number."
-      isCorrect: false
-      explanation: "The result of the measurement of a qubit is a random bit, not a random decimal number. This isn't the logic behind the random number generator that you built in this module."
-    - content: "The quantum random number generator creates a bit string from the repetition of measurements of a qubit in superposition. Then, it takes the bit string and converts it to a decimal number."
-      isCorrect: true
-      explanation: "This is the logic behind the random number generator that you built in this module."
-
-  - content: 'Which of the following structures are required for a Q# program to run successfully?'
-    choices:
-    - content: 'To run successfully, a Q# program must have a function.'
-      isCorrect: false
-      explanation: "A function is not required in a Q# program."
-    - content: "To run successfully, a Q# program must have an entry point, which is the `Main` operation."
-      isCorrect: true
-      explanation: "Every Q# program must have an entry point, which is the `Main` operation, so the Q# compiler knows where to start the program."
-    - content: "To run successfully, a Q# program must have an entry point and at least one allocated qubit."
-      isCorrect: false
-      explanation: "You can write Q# programs that don't need to perform operations on a qubit. A Q# program without a qubit allocated can run successfully."
-
-  - content: "Consider a quantum operation `A` that acts on a single qubit. If you want to write a Q# program that applies `A` to a qubit `q`, which of the following statements is true?"
-    choices:
-    - content: "You allocate a qubit using `q = Qubit();` and then apply `A` to `q` using `A(q);`."
-      isCorrect: false
-      explanation: "To allocate a qubit, you must use the `use` keyword, `use q = Qubit();`."
-    - content: "You allocate a qubit using `use q = Qubit();` and then apply `A` to `q` using `A(q);`."
-      isCorrect: true
-      explanation: "You first allocate a qubit using `use` and then apply `A` to the qubit allocated using `A(q);`."
-    - content: "You allocate a qubit using `use q = Qubit();` and then apply `A` to `q` using `A[q];`."
-      isCorrect: false
-      explanation: "To apply an operation to a qubit, you must use parentheses, `A(q);`."
+### YamlMime:ModuleUnit
+uid: learn.quantum.qsharp-create-first-quantum-development-kit.knowledge-check
+title: Module assessment
+metadata:
+  title: Module assessment
+  description: Check your understanding so far.
+  author: azure-quantum-content
+  ms.author: quantumdocwriters
+  
+  ms.date: 10/30/2024
+  ms.topic: unit
+  ai-usage: ai-assisted
+durationInMinutes: 7
+content: |
+  [!include[](includes/5-knowledge-check.md)]
+
+quiz:
+  title: Check your knowledge
+  questions:
+
+  - content: 'Which of these statements is true about the random number generator that you built in this module?'
+    choices:
+    - content: "The quantum random number generator takes the current time from the CPU's clock as a seed to generate random numbers."
+      isCorrect: false
+      explanation: "The quantum random number generator doesn't use the CPU's clock to generate random numbers. A classical pseudo-random number generator would do that."
+    - content: "The quantum random number generator creates one qubit, measures it, and the result of the measurement is a random decimal number."
+      isCorrect: false
+      explanation: "The result of the measurement of a qubit is a random bit, not a random decimal number. This answer doesn't describe the logic behind the random number generator that you built in this module."
+    - content: "The quantum random number generator creates a bit string from the repetition of measurements of a qubit in superposition. Then, it takes the bit string and converts it to a decimal number."
+      isCorrect: true
+      explanation: "This statement describes the logic behind the random number generator that you built in this module."
+
+  - content: 'Which of the following structures are required for a Q# program to run successfully?'
+    choices:
+    - content: 'To run successfully, a Q# program must have a function.'
+      isCorrect: false
+      explanation: "A function isn't required in a Q# program."
+    - content: "To run successfully, a Q# program must have an entry point, which is the `Main` operation."
+      isCorrect: true
+      explanation: "Every Q# program must have an entry point, which is the `Main` operation, so the Q# compiler knows where to start the program."
+    - content: "To run successfully, a Q# program must have an entry point and at least one allocated qubit."
+      isCorrect: false
+      explanation: "You can write Q# programs that don't need to perform operations on a qubit. A Q# program without a qubit allocated can run successfully."
+
+  - content: "Consider a quantum operation `A` that acts on a single qubit. If you want to write a Q# program that applies `A` to a qubit `q`, which of the following statements is true?"
+    choices:
+    - content: "You allocate a qubit using `q = Qubit();` and then apply `A` to `q` using `A(q);`."
+      isCorrect: false
+      explanation: "To allocate a qubit, you must use the `use` keyword, `use q = Qubit();`."
+    - content: "You allocate a qubit using `use q = Qubit();` and then apply `A` to `q` using `A(q);`."
+      isCorrect: true
+      explanation: "You first allocate a qubit using `use` and then apply `A` to the qubit allocated using `A(q);`."
+    - content: "You allocate a qubit using `use q = Qubit();` and then apply `A` to `q` using `A[q];`."
+      isCorrect: false
+      explanation: "To apply an operation to a qubit, you must use parentheses, `A(q);`."

learn-pr/quantum/qsharp-create-first-quantum-development-kit/includes/1-introduction.md

@@ -18,6 +18,4 @@ After completing this module, you're able to:
 - Basic knowledge of classical programming concepts.
 - Install the latest version of [Visual Studio Code](https://code.visualstudio.com/download).
 - Install the latest version of the [Azure Quantum Development Kit](https://marketplace.visualstudio.com/items?itemName=quantum.qsharp-lang-vscode) extension.
-    - You can also open [Visual Studio Code for the web](https://vscode.dev/quantum), which already includes the Quantum Development Kit extension.
-
-
+  - You can also open [Visual Studio Code for the web](https://vscode.dev/quantum), which already includes the Quantum Development Kit extension.

learn-pr/quantum/qsharp-create-first-quantum-development-kit/includes/2-qsharp-structure.md

@@ -1,11 +1,11 @@
 
 Before you start writing quantum programs, it's important to understand the structure and components of a Q# program.
 
-In this unit, you'll review the main components of a Q# program.
+In this unit, you review the main components of a Q# program.
 
 ## The `Main` operation
 
-Every Q# program must contain at least one operation, which is usually the `Main` operation. The `Main` operation is the entry point of your program. By default, the Q# compiler starts executing a program from the `Main()` operation. Optionally, you can use the `@EntryPoint()` attribute to specify any operation in the program as the point of execution. 
+Every Q# program must contain at least one operation, which is usually the `Main` operation. The `Main` operation is the entry point of your program. By default, the Q# compiler starts executing a program from the `Main()` operation. Optionally, you can use the `@EntryPoint()` attribute to specify any operation in the program as the point of execution.
 
 For example, the following code defines an entry point operation, `MeasureOneQubit`:
 
@@ -39,7 +39,7 @@ operation MeasureOneQubit() : Result {
 
 ## Quantum libraries
 
-The Q# libraries contain functions and operations that you can use in quantum programs. When you call a function or operation from a library, you use the `import` directive and specify the library's namespace. For example, to use the `Message` function from the `Microsoft.Quantum.Intrinsic` namespace in the Standard quantum library, you do the following:
+The Q# libraries contain functions and operations that you can use in quantum programs. When you call a function or operation from a library, you use the `import` directive and specify the library's namespace. For example, to use the `Message` function from the `Microsoft.Quantum.Intrinsic` namespace in the Standard quantum library, you use the following code:
 
 ```qsharp
 // imports all functions and operations from Microsoft.Quantum.Intrinsic 
@@ -79,10 +79,9 @@ To implement a measurement in the computational basis $\lbrace\ket{0},\ket{1}\rb
 
 ## Resetting qubits
 
-In Q#, qubits must be in the $\ket{0}$ state by the time they are released. When you have finished using a qubit, you use the `Reset` operation to reset the qubit to the $\ket{0}$.
+In Q#, qubits must be in the $\ket{0}$ state by the time they're released. When you finish using a qubit, you use the `Reset` operation to reset the qubit to the $\ket{0}$ state.
 
 ```qsharp
     // Reset the qubit so it can be safely released.
     Reset(qubit);
 ```
-

learn-pr/quantum/qsharp-create-first-quantum-development-kit/includes/3-random-bit-generator.md

@@ -5,7 +5,7 @@ You build out your quantum random number generator in two phases. In this unit,
 ## Create the Q# program
 
 1. Open Visual Studio Code and select **File > New Text File** to create a new file.
-1. Save the file as `Main.qs`. This file will contain the Q# code for your program.
+1. Save the file as `Main.qs`. This file contains the Q# code for your program.
 
 ## Define the `Main` operation
 
@@ -34,7 +34,7 @@ operation Main(): Result{
 
 ## Put the qubit into superposition
 
-The qubit is in the $\ket{0}$ state, which isn't very useful for generating random numbers. You need to put the qubit into superposition. To do this, you apply the **Hadamard operation**, `H`, to the qubit. The Hadamard operation changes the state of the qubit and puts it into an equal superposition of $\ket{0}$ and $\ket{1}$. 
+The qubit is in the $\ket{0}$ state, which isn't useful for generating random numbers. You need to put the qubit into superposition. To do this, you apply the **Hadamard operation**, `H`, to the qubit. The Hadamard operation changes the state of the qubit and puts it into an equal superposition of $\ket{0}$ and $\ket{1}$.
 
 $$ H \ket{0} = \frac{1}{\sqrt{2}} (\ket{0} + \ket{1}) $$
 
@@ -50,7 +50,7 @@ operation Main(): Result{
 
 ## Measure the qubit
 
-At this point the qubit `q` has 50% chance of being measured in the |0〉 state and 50% chance of being measured in the |1〉 state. Thus, if you measure the qubit, you'll get a random bit, either 0 or 1, with equal 50% probability. The value of this bit is truly random, there's no way of knowing in advance the result of the measurement.
+At this point, the qubit `q` has 50% chance of being measured in the |0〉 state and 50% chance of being measured in the |1〉 state. Thus, if you measure the qubit, you get a random bit, either 0 or 1, with equal 50% probability. The value of this bit is truly random, there's no way of knowing in advance the result of the measurement.
 
 To measure the qubit value, use the `M` operation and store the measurement value in the `result` variable.
 
@@ -65,7 +65,7 @@ operation Main(): Result{
 
 ## Reset the qubit
 
-In Q#, every qubit must be in the $\ket{0}$ state by the time they are released. You use `Reset(q)` to reset the qubit to the zero state.
+In Q#, every qubit must be in the $\ket{0}$ state by the time they're released. You use `Reset(q)` to reset the qubit to the zero state.
 
 ```qsharp
 operation Main(): Result{
@@ -109,7 +109,6 @@ operation Main() : Result {
     H(q);
 
     // Measure the qubit and store the result.
-
     let result = M(q);
 
     // Reset qubit to the |0〉 state.
@@ -122,7 +121,7 @@ operation Main() : Result {
 
 ## Run the program
 
-To run your program on the built-in simulator, click **Run** above the `Main` operation or press **Ctrl+F5**. Your output appears in the debug console in the terminal.
+To run your program on the built-in simulator, select **Run** above the `Main` operation or press **Ctrl+F5**. Your output appears in the debug console in the terminal.
 
 The result is either `One` or `Zero`, which represents a truly random bit. You can run the program again to see a different result.
 

learn-pr/quantum/qsharp-create-first-quantum-development-kit/includes/4-random-number-generator.md

@@ -4,7 +4,7 @@ In this unit, you implement the second phase of your quantum random number gener
 
 In the previous unit, you created a random bit generator that generates a random bit by putting a qubit into superposition and measuring it.
 
-When you measure the qubit, you'll get a random bit, either 0 or 1, with equal 50% probability. The value of this bit is truly random, there's no way of knowing what you get after the measurement. But how can you use this behavior to generate larger random numbers?
+When you measure the qubit, you get a random bit, either 0 or 1, with equal 50% probability. The value of this bit is truly random, there's no way of knowing what you get after the measurement. But how can you use this behavior to generate larger random numbers?
 
 Let's say you repeat the process four times, generating this sequence of binary digits:
 
@@ -42,7 +42,7 @@ Here, you expand on the `Main.qs` file to build larger random numbers.
 
 ### Import the required libraries
 
-First, you need to import the required namespaces from the Q# Standard library to the program. The Q# compiler loads many common functions and operations automatically, however for the complete quantum random number generator, you need some additional functions and operations from two Q# namespaces: `Microsoft.Quantum.Math`and `Microsoft.Quantum.Convert`.
+First, you need to import the required namespaces from the Q# Standard library to the program. The Q# compiler loads many common functions and operations automatically, however for the complete quantum random number generator, you need some more functions and operations from two Q# namespaces: `Microsoft.Quantum.Math`and `Microsoft.Quantum.Convert`.
 
 Copy and paste the following `import` directives to the top of your `Main.qs` file:
 
@@ -65,8 +65,7 @@ The `GenerateRandomBit` operation should look like this:
         // Set the qubit into superposition of 0 and 1 using the Hadamard 
         H(q);
     
-        // Measure the qubit and store the result.
-    
+        // Measure the qubit and store the result.    
         let result = M(q);
     
         // Reset qubit to the |0〉 state.
@@ -111,7 +110,7 @@ Let's take a moment to review the new code.
 
 ### Add an entry point
 
-Finally, you add an entry point to the program. By default, the Q# compiler looks for a `Main` operation and starts processing there, no matter where it's located. The `Main` operation calls the `GenerateRandomNumberInRange` operation to generate a random number between 0 and a `max` number. In this example, you define the maximum value as 100.
+Finally, you add an entry point to the program. By default, the Q# compiler looks for a `Main` operation and starts processing there, no matter where the operation is located. The `Main` operation calls the `GenerateRandomNumberInRange` operation to generate a random number between 0 and a `max` number. In this example, you define the maximum value as 100.
 
 Copy and paste the following code to your `Main.qs` file:
 
@@ -180,12 +179,12 @@ import Microsoft.Quantum.Math.*;
 
 Let's try out our new random number generator!
 
-1. Before running the program, you need to set the target profile to **Unrestricted**. Select **View** > **Command Palette**, search for QIR, select **Q#: Set the Azure Quantum QIR target profile**, and then select **Q#: unrestricted**.
-1. To run your program, select **Run** from the list of commands above the `Main` operation or press **Ctrl+F5**. Your output will appear in the debug console.
+1. Before running the program, you need to set the target profile to **Unrestricted**. Select **View** > **Command Palette**, search for *QIR*, select **Q#: Set the Azure Quantum QIR target profile**, and then select **Q#: unrestricted**.
+1. To run your program, select **Run** from the list of commands above the `Main` operation or press **Ctrl+F5**. Your output displays in the debug console.
 1. Run the program again to see a different result.
 
 > [!NOTE]
-> If the target profile is not set to **Unrestricted**, you will get an error when you run the program.
+> If the target profile isn't set to **Unrestricted**, you get an error when you run the program.
 
 Congratulations! Now you know how to combine classical logic with Q# to create a quantum random number generator.
 

learn-pr/quantum/qsharp-create-first-quantum-development-kit/includes/6-summary.md

@@ -4,18 +4,17 @@ The Quantum Development Kit provides you with everything you need to start writi
 
 In this module, we covered a lot. Here are a few key concepts to keep in mind:
 
-* A Q# program must have an entry point, which is the `Main` operation.
-* In Q#, you allocate a qubit by using the `use` keyword and the `Qubit` type. The qubit is always in the $\ket{0}$ state.
-* Superposition is a quantum phenomenon where a qubit is in a combination of both zero and one states. If a qubit is in the $\ket{0}$ state, you can put it into superposition by using the `H` operation.
-* In Q#, you use the `M` operation to measure qubits in the Z-basis. When measured, a qubit goes from being in superposition to one of the classical states.
-* You can combine classical code with quantum code. This combination enables you to perform quantum computations and work with the results, all in the same program.
+- A Q# program must have an entry point, which is the `Main` operation.
+- In Q#, you allocate a qubit by using the `use` keyword and the `Qubit` type. The qubit is always in the $\ket{0}$ state.
+- Superposition is a quantum phenomenon where a qubit is in a combination of both zero and one states. If a qubit is in the $\ket{0}$ state, you can put it into superposition by using the `H` operation.
+- In Q#, you use the `M` operation to measure qubits in the Z-basis. When measured, a qubit goes from being in superposition to one of the classical states.
+- You can combine classical code with quantum code. This combination enables you to perform quantum computations and work with the results, all in the same program.
 
 ## Next steps
 
-The Quantum Development Kit includes a set of built-in Q# samples that you can use to learn more about Q# and quantum computing. To view the samples, open a blank Q# file in Visual Studio Code and type `sample`, then select the sample you want to view from the list of options. For example, you can find the Q# code in unit 2 under "Random Bit sample".
+The Quantum Development Kit includes a set of built-in Q# samples that you can use to learn more about Q# and quantum computing. To view the samples, open a blank Q# file in Visual Studio Code and type `sample`, then select the sample you want to view from the list of options. For example, you can find the Q# code we used in unit 2 by selecting *Random Bit sample*.
 
 ## Learn more
 
-* Explore the [Azure Quantum documentation](/quantum/?azure-portal=true).
-* Learn quantum computing with the [Quantum Katas](https://quantum.microsoft.com/tools/quantum-katas).
-
+- Explore the [Azure Quantum documentation](/quantum/?azure-portal=true).
+- Learn quantum computing with the [Quantum Katas](https://quantum.microsoft.com/tools/quantum-katas).