Improvements to Q# library documentation (#3083)

- fixed typos and inconsistencies in documentation
 - in some cases the same typos were copied/propagated to many places:
     - `auxilliary` instead of `auxiliary`
     - `anthing` instead of `anything`
     - `lease` instead of `least`
     - `Identitfy` instead of `Identify`
- in some cases the symbol names in the docs did not match the actual
symbols in the code

There are no logical code changes here, it's only docs, so it should be
sage to merge.

Author: filipw

library/chemistry/src/JordanWigner/OptimizedBlockEncoding.qs

@@ -114,7 +114,7 @@ function OptimizedBEGeneratorSystemCoeff(optimizedBEGeneratorSystem : OptimizedB
 /// `GeneratorIndex` representing a Z term.
 ///
 /// # Output
-/// `GeneratorIndex[]` expressing Z term as Pauli terms.
+/// `OptimizedBETermIndex` expressing Z term as Pauli terms.
 function ZTermToPauliMajIdx(term : GeneratorIndex) : OptimizedBETermIndex {
     let (_, coeff) = term.Term;
     let idxFermions = term.Subsystem;
@@ -143,7 +143,7 @@ function ZTermToPauliMajIdx(term : GeneratorIndex) : OptimizedBETermIndex {
 /// `GeneratorIndex` representing a ZZ term.
 ///
 /// # Output
-/// `GeneratorIndex[]` expressing ZZ term as Pauli terms.
+/// `OptimizedBETermIndex` expressing ZZ term as Pauli terms.
 function ZZTermToPauliMajIdx(term : GeneratorIndex) : OptimizedBETermIndex {
     let (_, coeff) = term.Term;
     let idxFermions = term.Subsystem;
@@ -172,7 +172,7 @@ function ZZTermToPauliMajIdx(term : GeneratorIndex) : OptimizedBETermIndex {
 /// `GeneratorIndex` representing a PQ term.
 ///
 /// # Output
-/// `GeneratorIndex[]` expressing PQ term as Pauli terms.
+/// `OptimizedBETermIndex` expressing PQ term as Pauli terms.
 function PQTermToPauliMajIdx(term : GeneratorIndex) : OptimizedBETermIndex {
     let (_, coeff) = term.Term;
     let idxFermions = term.Subsystem;
@@ -201,7 +201,7 @@ function PQTermToPauliMajIdx(term : GeneratorIndex) : OptimizedBETermIndex {
 /// `GeneratorIndex` representing a PQ or PQQR term.
 ///
 /// # Output
-/// `GeneratorIndex[]` expressing PQ or PQQR term as Pauli terms.
+/// `OptimizedBETermIndex` expressing PQ or PQQR term as Pauli terms.
 function PQandPQQRTermToPauliMajIdx(term : GeneratorIndex) : OptimizedBETermIndex {
     let (_, coeff) = term.Term;
     let idxFermions = term.Subsystem;
@@ -238,7 +238,7 @@ function PQandPQQRTermToPauliMajIdx(term : GeneratorIndex) : OptimizedBETermInde
 /// `GeneratorIndex` representing a PQRS term.
 ///
 /// # Output
-/// `GeneratorIndex[]` expressing PQRS term as Pauli terms.
+/// `OptimizedBETermIndex[]` expressing PQRS term as Pauli terms.
 function V0123TermToPauliMajIdx(term : GeneratorIndex) : OptimizedBETermIndex[] {
     let (_, v0123) = term.Term;
     let idxFermions = term.Subsystem;

library/chemistry/src/MixedStatePreparation.qs

@@ -28,7 +28,7 @@ import Utils.RangeAsIntArray;
 /// state.
 /// ## Prepare
 /// An operation that, given an index register, a data register, and a
-/// garbage register initially in the $\ket{0}$, $\let{00\dots 0}$, and
+/// garbage register initially in the $\ket{0}$, $\ket{00\dots 0}$, and
 /// $\ket{00\dots 0}$ states (respectively),
 /// prepares the state represented by this UDT value on those registers.
 struct MixedStatePreparation {
@@ -42,13 +42,13 @@ struct MixedStatePreparation {
 /// mixed state.
 ///
 /// # Input
-/// ## NTotalQubits
+/// ## NumTotalQubits
 /// The total number of qubits required by the represented state preparation
 /// operation.
-/// ## NIndexQubits
+/// ## NumIndexQubits
 /// The number of qubits required for the index register used by the
 /// represented state preparation operation.
-/// ## NGarbageQubits
+/// ## NumGarbageQubits
 /// The number of qubits required for the garbage register used by the
 /// represented state preparation operation.
 struct MixedStatePreparationRequirements {
@@ -58,7 +58,7 @@ struct MixedStatePreparationRequirements {
 }
 
 /// # Summary
-/// Returns an operation that prepares a a purification of a given mixed state.
+/// Returns an operation that prepares a purification of a given mixed state.
 /// A "purified mixed state" refers to states of the form |ψ⟩ = Σᵢ √𝑝ᵢ |𝑖⟩ |garbageᵢ⟩ specified by a vector of
 /// coefficients {𝑝ᵢ}. States of this form can be reduced to mixed states ρ ≔ 𝑝ᵢ |𝑖⟩⟨𝑖| by tracing over the "garbage"
 /// register (that is, a mixed state that is diagonal in the computational basis).
@@ -128,8 +128,8 @@ struct MixedStatePreparationRequirements {
 /// let coefficients = [1.0, 2.0, 3.0, 4.0, 5.0];
 /// let targetError = 1e-3;
 /// let purifiedState = PurifiedMixedState(targetError, coefficients);
-/// using (indexRegister = Qubit[purifiedState.Requirements.NIndexQubits]) {
-///     using (garbageRegister = Qubit[purifiedState.Requirements.NGarbageQubits]) {
+/// using (indexRegister = Qubit[purifiedState.Requirements.NumIndexQubits]) {
+///     using (garbageRegister = Qubit[purifiedState.Requirements.NumGarbageQubits]) {
 ///         purifiedState.Prepare(LittleEndian(indexRegister), [], garbageRegister);
 ///     }
 /// }

library/chemistry/src/Tests.qs

@@ -81,7 +81,7 @@ operation OptimizedBEOperatorZeroTestHelper(pauliBasis : Pauli, targetRegisterSi
             }
         } else {
 
-            // Test Identitfy Pauli
+            // Test Identify Pauli
             // |0> -> |0>
             // |+> -> |+>
             Message($"Test ZI Pauli on qubit {idxTest}");
@@ -175,7 +175,7 @@ operation OptimizedBEOperatorPlusTestHelper(pauliBasis : Pauli, targetRegisterSi
             }
 
         } else {
-            // Test Identitfy Pauli
+            // Test Identify Pauli
             // |0> -> |0>
             // |+> -> |+>
             Message($"Test I Pauli on qubit {idxTest}");

library/fixed_point/src/Operations.qs

@@ -165,4 +165,4 @@ export
     InvertFxP,
     SubtractFxP,
     MultiplyFxP,
-    SquareFxP;
+    SquareFxP;

library/fixed_point/src/Tests.qs

@@ -91,7 +91,7 @@ operation TestOperation(a : Double, b : Double, op : (FixedPoint, FixedPoint) =>
 
     let expected = reference(a, b);
     let difference = expected - measured;
-    Fact(difference < 0.001, $"Difference of {difference} is outside of the expected range. Expected {expected} and measured result was {measured}. (Inputs were {name}({a}, {b})");
+    Fact(difference < 0.001, $"Difference of {difference} is outside of the expected range. Expected {expected} and measured result was {measured}. (Inputs were {name}({a}, {b}))");
     ResetAll(register1 + register2);
 }
 
@@ -117,6 +117,6 @@ operation TestOperation3(a : Double, b : Double, op : (FixedPoint, FixedPoint, F
 
     let expected = reference(a, b);
     let difference = expected - measured;
-    Fact(difference < 0.001, $"Difference of {difference} is outside of the expected range. Expected {expected} and measured result was {measured}. (Inputs were {name}({a}, {b})");
+    Fact(difference < 0.001, $"Difference of {difference} is outside of the expected range. Expected {expected} and measured result was {measured}. (Inputs were {name}({a}, {b}))");
     ResetAll(register1 + register2);
 }

library/qtest/src/Operations.qs

@@ -35,9 +35,9 @@ operation CheckAllTestCases<'T : Eq + Show>(test_cases : (String, Int, Qubit[] =
 /// This is a good alternative to `CheckAllTestCases` when you want custom output based on the results of your tests,
 /// or more control over how test results are rendered.
 /// # Input
-/// Takes a list of test cases. A test case is a tuple of `(String, () => 'T, 'T)`, where
-/// the first String is the name of the test, the function is the test case itself, and the
-/// final element of the tuple is the expected return value from the test case.
+/// Takes a list of test cases. A test case is a tuple of `(String, Int, Qubit[] => Unit, Qubit[] => 'T, 'T)`, where
+/// the first String is the name of the test, the Int is the number of qubits, the first operation prepares the state,
+/// the second operation is the test case itself, and the final element is the expected return value.
 ///
 /// # Example
 /// ```qsharp

library/signed/src/Measurement.qs

@@ -47,4 +47,4 @@ operation MeasureSignedInteger(target : Qubit[], width : Int) : Int {
     number * coefficient
 }
 
-export MeasureSignedInteger;
+export MeasureSignedInteger;

library/signed/src/Operations.qs

@@ -260,7 +260,7 @@ operation Invert2sSI(xs : Qubit[]) : Unit is Adj + Ctl {
 ///
 /// # Remarks
 /// Uses a standard shift-and-subtract approach to implement the division.
-/// The controlled version is specialized such the subtraction does not
+/// The controlled version is specialized such that the subtraction does not
 /// require additional controls.
 operation DivideI(xs : Qubit[], ys : Qubit[], result : Qubit[]) : Unit is Adj + Ctl {
     body (...) {

library/std/src/Std/ArithmeticUtils.qs

@@ -29,7 +29,7 @@ import
 ///   Computation, Vol. 10, 2010.
 ///   https://arxiv.org/abs/0910.2530
 operation ApplyOuterTTKAdder(xs : Qubit[], ys : Qubit[]) : Unit is Adj + Ctl {
-    Fact(Length(xs) <= Length(ys), "Input register ys must be at lease as long as xs.");
+    Fact(Length(xs) <= Length(ys), "Input register ys must be at least as long as xs.");
     for i in 1..Length(xs) - 1 {
         CNOT(xs[i], ys[i]);
     }
@@ -106,7 +106,7 @@ operation ApplyInnerTTKAdderWithCarry(xs : Qubit[], ys : Qubit[]) : Unit is Adj
         (Controlled ApplyInnerTTKAdderWithCarry)([], (xs, ys));
     }
     controlled (controls, ...) {
-        Fact(Length(xs) + 1 == Length(ys), "ys must be one qubit longer then xs.");
+        Fact(Length(xs) + 1 == Length(ys), "ys must be one qubit longer than xs.");
         Fact(Length(xs) > 0, "Array should not be empty.");
 
 

library/std/src/Std/TableLookup.qs

@@ -303,7 +303,7 @@ operation PhaseLookup(qs : Qubit[], data : Bool[]) : Unit {
     let m2 = 1 <<< n2;
     Fact(m1 * m2 == m, "Length of halves must match total length.");
 
-    // Allocate auxilliary qubits
+    // Allocate auxiliary qubits
     use aux_qubits1 = Qubit[2^n1 - n1 - 1];
     use aux_qubits2 = Qubit[2^n2 - n2 - 1];
 
@@ -361,7 +361,7 @@ operation ConstructPowerProducts(qubits : Qubit[], aux_qubits : Qubit[]) : Qubit
             power_products += [next_power_product];
         }
     }
-    Fact(next_available == Length(aux_qubits), "All auxilliary qubits should be used.");
+    Fact(next_available == Length(aux_qubits), "All auxiliary qubits should be used.");
     return power_products;
 }