Typo corrections into 0.3 (microsoft#131)

* cherry-picking commit 0c01ba2

* Cherry-picking correct commit.

* Update Samples/src/OpenQasm/OpenQasmDriver.cs

Co-Authored-By: anpaz-msft <[email protected]>

Author: anpaz

Samples/src/AdiabaticIsing/AdiabaticIsing.qs

@@ -108,7 +108,7 @@ namespace Microsoft.Quantum.Samples.Ising {
     //////////////////////////////////////////////////////////////////////////
 
     /// # Summary
-    /// This uses the Ising model `GeneratorSystem` construced previously to
+    /// This uses the Ising model `GeneratorSystem` constructed previously to
     /// represent the desired interpolated Hamiltonian H(s). This is
     /// accomplished by choosing an appropriate function for its coefficients.
     ///
@@ -220,7 +220,7 @@ namespace Microsoft.Quantum.Samples.Ising {
 
     /// # Summary
     /// We now allocate qubits to the simulation, implement adiabatic state
-    /// prepartion, and then return the results of spin measurement on each
+    /// preparation, and then return the results of spin measurement on each
     /// site.
     ///
     /// # Input
@@ -335,7 +335,7 @@ namespace Microsoft.Quantum.Samples.Ising {
         let end = EndEvoGen(nSites, jCoupling);
 
         // We choose the time-dependent Trotter–Suzuki decomposition as
-        // our similation algorithm.
+        // our simulation algorithm.
         let timeDependentSimulationAlgorithm = TimeDependentTrotterSimulationAlgorithm(trotterStepSize, trotterOrder);
 
         // The function InterpolatedEvolution uniformly interpolates between the start and the end Hamiltonians.
@@ -345,7 +345,7 @@ namespace Microsoft.Quantum.Samples.Ising {
 
     /// # Summary
     /// We now choose uniform coupling coefficients, allocate qubits to the
-    /// simulation, implement adiabatic state prepartion, and then return
+    /// simulation, implement adiabatic state preparation, and then return
     /// the results of spin measurement on each site.
     ///
     /// # Input

Samples/src/BitFlipCode/BitFlipCode.qs

@@ -56,24 +56,24 @@ namespace Microsoft.Quantum.Samples.BitFlipCode {
     // Thus, we can write out our encoder in a very simple form:
 
     /// # Summary
-    /// Given a qubit representing a state to be protected and two auxillary
+    /// Given a qubit representing a state to be protected and two auxiliary
     /// qubits initially in the |0〉 state, encodes the state into the
     /// three-qubit bit-flip code.
     ///
     /// # Input
     /// ## data
     /// A qubit whose state is to be protected.
-    /// ## auxillaryQubits
+    /// ## auxiliaryQubits
     /// Two qubits, initially in the |00〉 state, to be used in protecting
     /// the state of `data`.
-    operation EncodeIntoBitFlipCode (data : Qubit, auxillaryQubits : Qubit[]) : Unit {
+    operation EncodeIntoBitFlipCode (data : Qubit, auxiliaryQubits : Qubit[]) : Unit {
 
         body (...) {
             // We use the ApplyToEach operation from the canon,
             // partially applied with the data qubit, to represent
             // a "CNOT-ladder." In this case, the line below
             // applies CNOT₀₁ · CNOT₀₂.
-            ApplyToEachCA(CNOT(data, _), auxillaryQubits);
+            ApplyToEachCA(CNOT(data, _), auxiliaryQubits);
         }
 
         // Since decoding is the adjoint of encoding, we must
@@ -105,15 +105,15 @@ namespace Microsoft.Quantum.Samples.BitFlipCode {
     operation CheckBitFlipCodeStateParity () : Unit {
 
         // We start by preparing R_x(π / 3) |0〉 as our
-        // test state, along with two auxillary qubits in the |00〉
+        // test state, along with two auxiliary qubits in the |00〉
         // state that we can use to encode.
         using (register = Qubit[3]) {
             let data = register[0];
-            let auxillaryQubits = register[1 .. 2];
+            let auxiliaryQubits = register[1 .. 2];
             Rx(PI() / 3.0, data);
 
             // Next, we encode our test state.
-            EncodeIntoBitFlipCode(data, auxillaryQubits);
+            EncodeIntoBitFlipCode(data, auxiliaryQubits);
 
             // At this point, register represents a code block
             // that protects the state R_x(π / 3) |0〉.
@@ -143,7 +143,7 @@ namespace Microsoft.Quantum.Samples.BitFlipCode {
 
             // To check that we have not disturbed the state, we decode,
             // rotate back, and assert once more.
-            Adjoint EncodeIntoBitFlipCode(data, auxillaryQubits);
+            Adjoint EncodeIntoBitFlipCode(data, auxiliaryQubits);
             Adjoint Rx(PI() / 3.0, data);
             Assert([PauliZ], [data], Zero, "Didn't return to |0〉!");
         }
@@ -185,9 +185,9 @@ namespace Microsoft.Quantum.Samples.BitFlipCode {
             // We start by proceeding the same way as above
             // in order to obtain the code block state |̅ψ〉.
             let data = register[0];
-            let auxillaryQubits = register[1 .. 2];
+            let auxiliaryQubits = register[1 .. 2];
             Rx(PI() / 3.0, data);
-            EncodeIntoBitFlipCode(data, auxillaryQubits);
+            EncodeIntoBitFlipCode(data, auxiliaryQubits);
 
             // Next, we apply the error that we've been given to the
             // entire register.
@@ -222,7 +222,7 @@ namespace Microsoft.Quantum.Samples.BitFlipCode {
 
             // To check that we have not disturbed the state, we decode,
             // rotate back, and assert once more.
-            Adjoint EncodeIntoBitFlipCode(data, auxillaryQubits);
+            Adjoint EncodeIntoBitFlipCode(data, auxiliaryQubits);
             Adjoint Rx(PI() / 3.0, data);
             Assert([PauliZ], [data], Zero, "Didn't return to |0〉!");
         }
@@ -311,14 +311,14 @@ namespace Microsoft.Quantum.Samples.BitFlipCode {
     operation CheckCodeCorrectsError (code : QECC, nScratch : Int, fn : RecoveryFn, error : (Qubit[] => Unit)) : Unit {
 
         // We once again begin by allocating some qubits to use as data
-        // and auxillary qubits, and by preparing a test state on the
+        // and auxiliary qubits, and by preparing a test state on the
         // data qubit.
         using (register = Qubit[1 + nScratch]) {
 
             // We start by proceeding the same way as above
             // in order to obtain the code block state |̅ψ〉.
             let data = register[0];
-            let auxillaryQubits = register[1 .. nScratch];
+            let auxiliaryQubits = register[1 .. nScratch];
             Rx(PI() / 3.0, data);
 
             // We differ this time, however, in how we perform the
@@ -336,7 +336,7 @@ namespace Microsoft.Quantum.Samples.BitFlipCode {
             // blocks.
             // Note that we also pass data as an array of qubits, to
             // allow for codes which protect multiple qubits in one block.
-            let codeBlock = encode!([data], auxillaryQubits);
+            let codeBlock = encode!([data], auxiliaryQubits);
 
             // Next, we cause an error as usual.
             error(codeBlock!);
@@ -347,8 +347,8 @@ namespace Microsoft.Quantum.Samples.BitFlipCode {
             Recover(code, fn, codeBlock);
 
             // Having recovered, we can decode to obtain new qubit arrays
-            // pointing to the decoded data and auxillary qubits.
-            let (decodedData, decodedAuxillary) = decode!(codeBlock);
+            // pointing to the decoded data and auxiliary qubits.
+            let (decodedData, decodedauxiliary) = decode!(codeBlock);
 
             // Finally, we test that our test state was protected.
             Adjoint Rx(PI() / 3.0, data);

Samples/src/DatabaseSearch/DatabaseSearch.qs

@@ -34,8 +34,8 @@ namespace Microsoft.Quantum.Samples.DatabaseSearch {
 
     // First, we work out an example of how to construct and apply D without
     // using the canon. We then implement all the steps of Grover search
-    // manually using this databse oracle. Second, we show the amplitude
-    // amplication libraries provided with the canon can make this task
+    // manually using this database oracle. Second, we show the amplitude
+    // amplification libraries provided with the canon can make this task
     // significantly easier.
 
     //////////////////////////////////////////////////////////////////////////
@@ -142,7 +142,7 @@ namespace Microsoft.Quantum.Samples.DatabaseSearch {
     ///
     /// # Input
     /// ## markedQubit
-    /// Qubit that indicats whether database element is marked.
+    /// Qubit that indicates whether database element is marked.
     /// ## databaseRegister
     /// A register of n qubits initially in the |00…0〉 state.
     operation StatePreparationOracle (markedQubit : Qubit, databaseRegister : Qubit[]) : Unit {
@@ -416,7 +416,7 @@ namespace Microsoft.Quantum.Samples.DatabaseSearch {
     // defined above with one major difference -- Its arguments have signature
     // the signature (Int, Qubit[]). Rather than directly passing the marked
     // qubit to the operation, we instead pass an integer than indexes The
-    // location of the marked qubit in the qubit arrary, which now encompasses
+    // location of the marked qubit in the qubit array, which now encompasses
     // all qubits.
 
     // Our goal is thus to construct this `StateOracle` oracle type and pass it

Samples/src/DatabaseSearch/Program.cs

@@ -72,7 +72,7 @@ static void Main(string[] args)
 
                 successCount += markedQubit == Result.One ? 1 : 0;
 
-                // Print the results of the search every 100 attemps
+                // Print the results of the search every 100 attempts
                 if ((idxAttempt + 1) % 100 == 0)
                 {
 
@@ -93,7 +93,7 @@ static void Main(string[] args)
 
             // Let us investigate the success probability of the quantum search.
 
-            // Wedefine the size `N` = 2^n of the database to searched in terms of 
+            // We define the size `N` = 2^n of the database to searched in terms of 
             // number of qubits `n`. 
             nDatabaseQubits = 6;
             databaseSize = Math.Pow(2.0, nDatabaseQubits);
@@ -135,7 +135,7 @@ static void Main(string[] args)
 
                 successCount += markedQubit == Result.One ? 1 : 0;
 
-                // Print the results of the search every 10 attemps
+                // Print the results of the search every 10 attempts
                 if ((idxAttempt + 1) % 10 == 0)
                 {
                     var empiricalSuccessProbability = Math.Round((double)successCount / ((double)idxAttempt + 1), 3);
@@ -213,7 +213,7 @@ static void Main(string[] args)
 
                 successCount += markedQubit == Result.One ? 1 : 0;
 
-                // Print the results of the search every 1 attemps
+                // Print the results of the search every 1 attempt
                 if ((idxAttempt + 1) % 1 == 0)
                 {
                     var empiricalSuccessProbability = Math.Round((double)successCount / ((double)idxAttempt + 1), 3);

Samples/src/H2SimulationCmdLine/Operation.qs

@@ -95,7 +95,7 @@ namespace Microsoft.Quantum.Samples.H2Simulation {
 
 
     /// # Summary
-    /// Given an index, returns a description of the correponding
+    /// Given an index, returns a description of the corresponding
     /// term in the Hamiltonian for H₂. Each term is described by
     /// a pair of integer arrays representing a sparse Pauli operator.
     ///
@@ -216,7 +216,7 @@ namespace Microsoft.Quantum.Samples.H2Simulation {
 
     /// # Summary
     /// We now provide Canon's Hamiltonian simulation
-    /// functions with the above representaiton to automatically
+    /// functions with the above representation to automatically
     /// decompose the H₂ Hamiltonian into an appropriate operation
     /// that we can apply to qubits as we please.
     operation H2TrotterStep (idxBondLength : Int, trotterOrder : Int, trotterStepSize : Double, qubits : Qubit[]) : Unit {

Samples/src/H2SimulationCmdLine/Program.cs

@@ -45,7 +45,7 @@ static void Main(string[] args)
                 // step size of 1.
                 //
                 // The result of calling H2EstimateEnergyRPE is a Double, so we can minimize over
-                // that to deal with the possibility that we accidently entered into the excited
+                // that to deal with the possibility that we accidentally entered into the excited
                 // state instead of the ground state of interest.
                 Func<int, Double> estAtBondLength = (idx) => Enumerable.Min(
                     from idxRep in Enumerable.Range(0, 3)

Samples/src/H2SimulationGUI/Program.cs

@@ -58,7 +58,7 @@ private static void SendPlotPoints(NetworkStream stream)
                 // step size of 1.
                 //
                 // The result of calling H2EstimateEnergyRPE is a Double, so we can minimize over
-                // that to deal with the possibility that we accidently entered into the excited
+                // that to deal with the possibility that we accidentally entered into the excited
                 // state instead of the ground state of interest.
                 Func<int, Double> estAtBondLength = (idx) => Enumerable.Min(
                     from idxRep in Enumerable.Range(0, 3)

Samples/src/HubbardSimulation/HubbardSimulation.qs

@@ -12,10 +12,10 @@ namespace Microsoft.Quantum.Samples.Hubbard {
     //////////////////////////////////////////////////////////////////////////
 
     // In this example, we will show how to simulate the time evolution of
-    // a 1D Hubbard model with `n` sitess. Let `i` be the site index,
-    // `s` = 1,0 be the spin index, where 0 is up and 1 is down. t be the
-    // hopping coefficient, U the repulsion coefficient, and aᵢₛ the fermionic
-    // annihilation operator on the fermion indexed by {i,s}. The Hamiltonian
+    // a 1D Hubbard model with `n` sites. Let `i` be the site index, 
+    // `s` = 1,0 be the spin index, where 0 is up and 1 is down. t be the 
+    // hopping coefficient, U the repulsion coefficient, and aᵢₛ the fermionic 
+    // annihilation operator on the fermion indexed by {i,s}. The Hamiltonian 
     // of this model is
 
     //     H ≔ - t Σᵢ (a†ᵢₛ aᵢ₊₁ₛ + a†ᵢ₊₁ₛ aᵢₛ) + u Σᵢ a†ᵢ₁ aᵢ₁ a†ᵢ₀ aᵢ₀
@@ -28,14 +28,14 @@ namespace Microsoft.Quantum.Samples.Hubbard {
     // Trotter–Suzuki control sequence to approximate time-evolution by this
     // Hamiltonian. This time-evolution is used to estimate the ground state
     // energy at half-filling.
-    
-    // Energy estimation requires an input state with non-zero overlap with
-    // the ground state, and we use the anti-ferromagnetic state with
-    // alternating  spins for this purpuse.
-    
+
+    // Energy estimation requires an input state with non-zero overlap with 
+    // the ground state, and we use the anti-ferromagnetic state with 
+    // alternating spins for this purpose. 
+
     // The Hubbard Hamiltonian is composed of Fermionic operators which act on
-    // Fermions and satify anti-commutation rules
-    
+    // Fermions and satisfy anti-commutation rules
+    //
     // {aⱼ, aₖ} = 0, {a†ⱼ, aₖ†} = 0, {aⱼ, aₖ†} = δⱼₖ.
 
     // In the above, the subscript indexes both the site and spin.
@@ -57,7 +57,7 @@ namespace Microsoft.Quantum.Samples.Hubbard {
     // assuming that j > k.
 
     // Other possible mapping exist, but we do not consider them further here.
-    // Implementing the Jodan-Wigner transform requires us to define a
+    // Implementing the Jordan-Wigner transform requires us to define a 
     // canonical ordering between the Fermion indices {is} and
     // the qubit index. Let the fermion site be indexed by the qubit i + n*s
 

Samples/src/IntegerFactorization/Shor.qs

@@ -199,14 +199,14 @@ namespace Microsoft.Quantum.Samples.IntegerFactorization {
 
             // Allocate qubits for the superposition of eigenstates of
             // the oracle that is used in period finding
-            using (eignestateRegister = Qubit[bitsize]) {
+            using (eigenstateRegister = Qubit[bitsize]) {
 
-                // Initialize eignestateRegister to 1 which is a superposition of
+                // Initialize eigenstateRegister to 1 which is a superposition of
                 // the eigenstates we are estimating the phases of.
                 // We first interpret the register as encoding unsigned integer
                 // in little endian encoding.
-                let eignestateRegisterLE = LittleEndian(eignestateRegister);
-                InPlaceXorLE(1, eignestateRegisterLE);
+                let eigenstateRegisterLE = LittleEndian(eigenstateRegister);
+                InPlaceXorLE(1, eigenstateRegisterLE);
 
                 // An oracle of type Microsoft.Quantum.Canon.DiscreteOracle
                 // that we are going to use with phase estimation methods below.
@@ -219,7 +219,7 @@ namespace Microsoft.Quantum.Samples.IntegerFactorization {
                     // Use Microsoft.Quantum.Canon.RobustPhaseEstimation to estimate s/r.
                     // RobustPhaseEstimation needs only one extra qubit, but requires
                     // several calls to the oracle
-                    let phase = RobustPhaseEstimation(bitsPrecision, oracle, eignestateRegisterLE!);
+                    let phase = RobustPhaseEstimation(bitsPrecision, oracle, eigenstateRegisterLE!);
 
                     // Compute the numerator k of dyadic fraction k/2^bitsPrecision
                     // approximating s/r. Note that phase estimation project on the eigenstate
@@ -238,7 +238,7 @@ namespace Microsoft.Quantum.Samples.IntegerFactorization {
                         // integer encoded in big-endian format. This is indicated by
                         // use of Microsoft.Quantum.Canon.BigEndian type.
                         let dyadicFractionNumeratorBE = BigEndian(dyadicFractionNumerator);
-                        QuantumPhaseEstimation(oracle, eignestateRegisterLE!, dyadicFractionNumeratorBE);
+                        QuantumPhaseEstimation(oracle, eigenstateRegisterLE!, dyadicFractionNumeratorBE);
 
                         // Directly measure the numerator k of dyadic fraction k/2^bitsPrecision
                         // approximating s/r. Note that phase estimation project on
@@ -249,7 +249,7 @@ namespace Microsoft.Quantum.Samples.IntegerFactorization {
 
                 // Return all the qubits used for oracle's eigenstate back to 0 state
                 // using Microsoft.Quantum.Canon.ResetAll
-                ResetAll(eignestateRegister);
+                ResetAll(eigenstateRegister);
             }
 
             // Sometimes we might measure all zeros state in Phase Estimation.