Merge pull request #52833 from jlehnersd/fix-equations-entanglement

Trying to fix aligned equation rendering, and no-locing eqns

Author: JamesJBarnett

learn-pr/quantum/explore-entanglement/includes/3-create-entanglement-qsharp.md

@@ -6,84 +6,81 @@ First, let's understand how these operations work and why they create entangled
 
 ## The Hadamard operation
 
-Recall that the Hadamard, or H, operation, puts a qubit that's in a pure $|0\rangle$ state or $|1\rangle$ state into an equal superposition state.
+Recall that the Hadamard, or H, operation, puts a qubit that's in a pure :::no-loc text="$\\ket{0}$"::: state or :::no-loc text="$\\ket{1}$"::: state into an equal superposition state.
 
-$$ H |0\rangle = \frac1{\sqrt2} |0\rangle + \frac1{\sqrt2} |1\rangle$$
-$$ H |1\rangle = \frac1{\sqrt2} |0\rangle - \frac1{\sqrt2} |1\rangle$$
+:::no-loc text="$$ H \\ket{0} = \\frac1{\\sqrt2} \\ket{0} + \\frac1{\\sqrt2} \\ket{1}$$":::
+:::no-loc text="$$ H \\ket{1} = \\frac1{\\sqrt2} \\ket{0} - \\frac1{\\sqrt2} \\ket{1}$$":::
 
 The first step to create your Bell state is to perform a Hadamard operation on one of the qubits.
 
 ## The Controlled-NOT (CNOT) operation
 
-When two qubits are entangled, the state of one qubit is dependent on the state of the other qubit. Therefore, to entangle two qubits you need an operation that acts on both qubits at the same time. This is called a multi-qubit operation. The Controlled-NOT, or CNOT, operation is a multi-qubit operation that helps create entanglement.
+When two qubits are entangled, the state of one qubit is dependent on the state of the other qubit. Therefore, to entangle two qubits you need to apply a multi-qubit operation, which is an operation that acts on both qubits at the same time. The Controlled-NOT, or CNOT, operation is a multi-qubit operation that helps create entanglement.
 
-The CNOT operation takes two qubits as input. One of the qubits is called the control qubit and the other qubit is called the target qubit. If the control qubit is in the $|1\rangle$ state, then the CNOT operation flips the state of the target qubit. Otherwise, CNOT does nothing.
+The CNOT operation takes two qubits as input. One of the qubits is the control qubit and the other qubit is the target qubit. If the control qubit is in the :::no-loc text="$\\ket{1}$"::: state, then the CNOT operation flips the state of the target qubit. Otherwise, CNOT does nothing.
 
 For example, in the following two-qubit states, the control qubit is the leftmost qubit and the target qubit is the rightmost qubit.
 
-| Input to `CNOT` | Output from `CNOT` |
-|-----------------|--------------------|
-| $\ket{00}$      | $\ket{00}$         |
-| $\ket{01}$      | $\ket{01}$         |
-| $\ket{10}$      | $\ket{11}$         |
-| $\ket{11}$      | $\ket{10}$         |
+| Input to `CNOT`                 | Output from `CNOT`              |
+|---------------------------------|---------------------------------|
+| :::no-loc text="$\\ket{00}$"::: | :::no-loc text="$\\ket{00}$"::: |
+| :::no-loc text="$\\ket{01}$"::: | :::no-loc text="$\\ket{01}$"::: |
+| :::no-loc text="$\\ket{10}$"::: | :::no-loc text="$\\ket{11}$"::: |
+| :::no-loc text="$\\ket{11}$"::: | :::no-loc text="$\\ket{10}$"::: |
 
 In Q#, the `CNOT` operation acts on an array of two qubits, and it flips the second qubit only if the first qubit is `One`.
 
 ## Entanglement with Hadamard and CNOT operations
 
-Suppose that you have a two-qubit system in the state $|00\rangle$. In this state, the qubits aren't entangled. To put these qubits into the entangled Bell state $\ket{\phi^+}=\frac1{\sqrt2}(|00\rangle+|11\rangle)$, apply the Hadamard and CNOT operations.
+Suppose that you have a two-qubit system in the state :::no-loc text="$\\ket{00}$":::. In this state, the qubits aren't entangled. To put these qubits into the entangled Bell state :::no-loc text="$\\ket{\\phi^+}=\\frac1{\\sqrt2}(\\ket{00}+\\ket{11})$":::, apply the Hadamard and CNOT operations.
 
 Here's how it works:
 
-1. Choose one qubit in the $|00\rangle$ state to be the control qubit and the other qubit to be the target qubit. Here, we choose the leftmost qubit to be the control and the rightmost qubit to be the target.
+1. Choose one qubit in the c state to be the control qubit and the other qubit to be the target qubit. Here, we choose the leftmost qubit to be the control and the rightmost qubit to be the target.
 1. Put only the control qubit into an equal superposition state. To do so, apply an H operation to only the control qubit:
 
-   $$H |0_c\rangle= \frac{1}{\sqrt{2}}(|0_c\rangle+|1_c\rangle)$$
+   :::no-loc text="$$H \\ket{0_c} = \\frac{1}{\\sqrt{2}}(\\ket{0_c} + \\ket{1_c})$$":::
 
    > [!NOTE]
-   > The subscripts ${}_c$ and ${}_t$ specify the control and target qubits, respectively.
+   > The subscripts :::no-loc text="${}_c$"::: and :::no-loc text="${}_t$"::: specify the control and target qubits, respectively.
 
-1. Apply a CNOT operation to the qubit pair. Recall that the control qubit is in a superposition state and the target qubit is in the $|0_t\rangle$ state.
+1. Apply a CNOT operation to the qubit pair. Recall that the control qubit is in a superposition state and the target qubit is in the :::no-loc text="$\\ket{0_t}$"::: state.
 
     $$
-    \begin{align*}
-    CNOT \frac{1}{\sqrt{2}}(\ket{0_c}+\ket{1_c})\ket{0}_t &= CNOT \frac{1}{\sqrt2}(\ket{0_c 0_t}+|\ket{1_c 0_t})\\
-    &= \frac{1}{\sqrt2}(CNOT \ket{0_c 0_t} + CNOT \ket{1_c 0_t})\\
-    &= \frac{1}{\sqrt2}(\ket{0_c 0_t}+\ket{1_c 1_t})
-    \end{align*}
+    \\begin{aligned}
+    CNOT \\frac{1}{\\sqrt{2}}(\\ket{0_c}+\\ket{1_c})\\ket{0_t} &= CNOT \\frac{1}{\\sqrt2}(\\ket{0_c 0_t}+\\ket{1_c 0_t})\\\\
+    &= \\frac{1}{\\sqrt2}(CNOT \\ket{0_c 0_t} + CNOT \\ket{1_c 0_t})\\\\
+    &= \\frac{1}{\\sqrt2}(\\ket{0_c 0_t}+\\ket{1_c 1_t})
+    \\end{aligned}
     $$
 
-The state $\frac{1}{\sqrt2}(\ket{0_c 0_t}+\ket{1_c 1_t})$ is entangled. This particular entangled state is one of the four Bell states, $\ket{\phi^{+}}$.
+The state :::no-loc text="$\\frac{1}{\\sqrt2}(\\ket{0_c 0_t}+\\ket{1_c 1_t})$"::: is entangled. This particular entangled state is one of the four Bell states, :::no-loc text="$\\ket{\\phi^{+}}$":::.
 
 > [!NOTE]
 > In quantum computing, operations are often called gates. For example, the H gate and the CNOT gate.
 
-## Create quantum entanglement in Q#
+## Create quantum entanglement in Q\#
 
 To create a Bell state with Q# code, follow these steps in Visual Studio Code (VS Code):
 
 1. Open VS Code.
 1. Open the **File** menu, and then choose **New Text File** to create a new file.
 1. Save the file as Main.qs.
 
-### Create the Bell state $\ket{\phi^+}$
+### Create a Bell state
 
-To create the Bell state $\ket{\phi^+}$ in Q#, follow these steps:
+To create the Bell state :::no-loc text="$\\ket{\\phi^+}$"::: in Q#, follow these steps:
 
-1. Import the `Microsoft.Quantum.Diagnostics` namespace from the Q# standard library so that you can use the `DumpMachine` function. This function shows information about the qubit states when you call the function in your code. To import the namespace, copy the following Q# code into your **Main.qs** file:
+1. Import the `Std.Diagnostics` namespace from the Q# standard library so that you can use the `DumpMachine` function. This function shows information about the qubit states when you call the function in your code. To import the namespace, copy the following Q# code into your **Main.qs** file:
 
     ```qsharp
-    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;
+    import Std.Diagnostics.*;
     ```
 
-    > [!TIP]
-    > You can use `Std` instead of `Microsoft.Quantum` to import from the standard library. For example, `import Std.Diagnostics.*` is equivalent to `import Microsoft.Quantum.Diagnostics.*`.
-
 1. Create the `Main` operation that returns two `Result` type values, which are the measurement results of the qubits.
 
     ```qsharp
-    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;
+    import Std.Diagnostics.*;
 
     operation Main() : (Result, Result) {
         // Your code goes here
@@ -93,7 +90,7 @@ To create the Bell state $\ket{\phi^+}$ in Q#, follow these steps:
 1. Inside the `Main` operation, allocate two qubits to be entangled, `q1` and `q2`.
 
     ```qsharp
-    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;
+    import Std.Diagnostics.*;
 
     operation Main() : (Result, Result) {
         use (q1, q2) = (Qubit(), Qubit());
@@ -103,7 +100,7 @@ To create the Bell state $\ket{\phi^+}$ in Q#, follow these steps:
 1. Apply the Hadamard gate, `H`, to the control qubit,`q1`. This puts only that qubit into a superposition state. Then apply the CNOT gate, `CNOT`, to both qubits to entangle the two qubits. The first argument to `CNOT` is the control qubit and the second argument is the target qubit.
 
     ```qsharp
-    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;
+    import Std.Diagnostics.*; 
 
     operation Main() : (Result, Result) {
         use (q1, q2) = (Qubit(), Qubit());
@@ -116,7 +113,7 @@ To create the Bell state $\ket{\phi^+}$ in Q#, follow these steps:
 1. Use the `DumpMachine` function to display the state of the qubits after you entangle them. Note that `DumpMachine` doesn't perform a measurement on the qubits, so `DumpMachine` doesn't affect the qubit states.
 
     ```qsharp
-    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;
+    import Std.Diagnostics.*;
 
     operation Main() : (Result, Result) {
         use (q1, q2) = (Qubit(), Qubit());
@@ -131,7 +128,7 @@ To create the Bell state $\ket{\phi^+}$ in Q#, follow these steps:
 1. Use the `M` operation to measure the qubits, and store the results in `m1` and `m2`. Then use the `Reset` operation to reset the qubits.
 
     ```qsharp
-    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;
+    import Std.Diagnostics.*;
 
     operation Main() : (Result, Result) {
 
@@ -151,7 +148,7 @@ To create the Bell state $\ket{\phi^+}$ in Q#, follow these steps:
 1. Return the measurement results of the qubits with the `return` statement. Here is final program in your **Main.qs** file:
 
     ```qsharp
-    import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;
+    import Std.Diagnostics.*;
 
     operation Main() : (Result, Result) {
         use (q1, q2) = (Qubit(), Qubit());
@@ -177,38 +174,38 @@ To create the Bell state $\ket{\phi^+}$ in Q#, follow these steps:
 
 ## Create other Bell states
 
-To create other Bell states, apply additional Pauli $X$ or $Z$ operations to the qubits.
+To create other Bell states, apply additional Pauli :::no-loc text="$X$"::: or :::no-loc text="$Z$"::: operations to the qubits.
 
-For example, to create the Bell state $\ket{\phi^-}=\frac1{\sqrt2}(|00\rangle-|11\rangle)$, apply the Pauli $Z$ operation to the control qubit after you apply the Hadamard gate, but before you apply CNOT. The $Z$ operation flips the state $\ket{+}$ to $\ket{-}$.
+For example, to create the Bell state :::no-loc text="$\\ket{\\phi^-}=\\frac1{\\sqrt2}(\\ket{00}-\\ket{11})$":::, apply the Pauli $Z$ operation to the control qubit after you apply the Hadamard gate, but before you apply CNOT. The :::no-loc text="$Z$"::: operation flips the state :::no-loc text="$\\ket{+}$"::: to :::no-loc text="$\\ket{-}$":::.
 
 > [!NOTE]
-> The states $\frac{1}{\sqrt{2}}(|0\rangle+|1\rangle)$ and $\frac{1}{\sqrt{2}}(|0\rangle -|1\rangle)$ are also known as $\ket{+}$ and $\ket{-}$, respectively.
+> The states :::no-loc text="$\\frac{1}{\\sqrt{2}}(\\ket{0}+\\ket{1})$"::: and :::no-loc text="$\\frac{1}{\\sqrt{2}}(\\ket{0} - \\ket{1})$"::: are also known as :::no-loc text="$\\ket{+}$"::: and :::no-loc text="$\\ket{-}$":::, respectively.
 
-Here's how to create the $\ket{\phi^-}$ state:
+Here's how to create the :::no-loc text="$\\ket{\\phi^-}$"::: state:
 
-1. Create two qubits in the state $|00\rangle$.
-1. Put the control qubit into a superposition state with the $H$ operation:
+1. Create two qubits in the state :::no-loc text="$\\ket{00}$":::.
+1. Put the control qubit into a superposition state with the :::no-loc text="$H$"::: operation:
 
-   $$H |0_c\rangle= \frac{1}{\sqrt{2}}(|0_c\rangle+|1_c\rangle) = \ket{+}_c$$
+   :::no-loc text="$$H \\ket{0_c} = \\frac{1}{\\sqrt{2}}(\\ket{0_c} + \\ket{1_c}) = \\ket{+_c}$$":::
 
-1. Apply the $Z$ operation to the control qubit.
+1. Apply the :::no-loc text="$Z$"::: operation to the control qubit.
 
-    $$Z \frac{1}{\sqrt{2}}(|0_c\rangle+|1_c\rangle)= \frac{1}{\sqrt{2}}(|0_c\rangle-|1_c\rangle)= \ket{-}_c$$
+    :::no-loc text="$$Z \\frac{1}{\\sqrt{2}}(\\ket{0_c} + \\ket{1_c}) = \\frac{1}{\\sqrt{2}}(\\ket{0_c} - \\ket{1_c}) = \\ket{-_c}$$":::
 
-1. Apply the $CNOT$ operation to the control qubit and the target qubit, which is in the $|0_t\rangle$ state.
+1. Apply the CNOT operation to the control qubit and the target qubit, which is in the :::no-loc text="$\\ket{0_t}$"::: state.
 
     $$
-    \begin{align*}
-    CNOT \frac{1}{\sqrt{2}}(\ket{0_c}-\ket{1_c})\ket{0}_t = CNOT \frac{1}{\sqrt2}(\ket{0_c 0_t}-|\ket{1_c 0_t})\\
-    &= \frac{1}{\sqrt2}(CNOT \ket{0_c 0_t} - CNOT \ket{1_c 0_t})\\
-    &= \frac{1}{\sqrt2}(\ket{0_c 0_t}-\ket{1_c 1_t})
-    \end{align*}
+    \\begin{aligned}
+    CNOT \\frac{1}{\\sqrt{2}}(\\ket{0_c}-\\ket{1_c})\\ket{0_t} &= CNOT \\frac{1}{\\sqrt2}(\\ket{0_c 0_t}-\\ket{1_c 0_t})\\\\
+    &= \\frac{1}{\\sqrt2}(CNOT \\ket{0_c 0_t} - CNOT \\ket{1_c 0_t})\\\\
+    &= \\frac{1}{\\sqrt2}(\\ket{0_c 0_t}-\\ket{1_c 1_t})
+    \\end{aligned}
     $$
 
-To create the $\ket{\phi^-}$ Bell state in Q#, replace the code in the your **Main.qs** with the following code:
+To create the :::no-loc text="$\\ket{\\phi^-}$"::: Bell state in Q#, replace the code in the your **Main.qs** with the following code:
 
 ```qsharp
-import Microsoft.Quantum.Diagnostics.*; // Aka Std.Diagnostics.*;
+import Std.Diagnostics.*;
     
 operation Main() : (Result, Result) {
     use (q1, q2) = (Qubit(), Qubit());
@@ -227,9 +224,9 @@ operation Main() : (Result, Result) {
 }
 ```
 
-Similarly, you can create the Bell states $\ket{\psi^+}$ and $\ket{\psi^-}$ by applying the Pauli $X$ and $Z$ operations to the qubits.
+Similarly, you can create the Bell states :::no-loc text="$\\ket{\\psi^+}$ and $\\ket{\\psi^-}$"::: by applying the Pauli $X$ and $Z$ operations to the qubits.
 
-- To create the Bell state $\ket{\psi^+}=\frac1{\sqrt2}(|01\rangle+|10\rangle)$, apply the Pauli $X$ gate to the target qubit after you apply the Hadamard gate to the control qubit. Then apply the CNOT gate.
-- To create the Bell state $\ket{\psi^-}=\frac1{\sqrt2}(|01\rangle-|10\rangle)$, apply the Pauli $Z$ to the control qubit and the Pauli $X$ to the target qubit after you apply the Hadamard gate to the control qubit. Then apply the CNOT gate.
+- To create the Bell state :::no-loc text="$\\ket{\\psi^+}=\\frac1{\\sqrt2}(\\ket{01}+\\ket{10})$":::, apply the Pauli $X$ gate to the target qubit after you apply the Hadamard gate to the control qubit. Then apply the CNOT gate.
+- To create the Bell state :::no-loc text="$\\ket{\\psi^-}=\\frac1{\\sqrt2}(\\ket{01}-\\ket{10})$":::, apply the Pauli $Z$ to the control qubit and the Pauli $X$ to the target qubit after you apply the Hadamard gate to the control qubit. Then apply the CNOT gate.
 
 In the next unit, you learn how to use entanglement to send quantum information, a process known as quantum teleportation.