From b68f5ddc39842fcae6c978ba238716ba68a53681 Mon Sep 17 00:00:00 2001
From: Chris Granade <chgranad@microsoft.com>
Date: Wed, 7 Oct 2020 13:28:34 -0700
Subject: [PATCH 1/2] Add metadata needed for improved documentation generation
 (#342)

---
 Chemistry/src/Jupyter/BroombridgeMagic.cs        |  2 +-
 Chemistry/src/Jupyter/ChemistryEncodeMagic.cs    |  2 +-
 Chemistry/src/Jupyter/FermionHamiltonianMagic.cs |  7 +++++--
 Chemistry/src/Jupyter/WavefunctionMagic.cs       |  2 +-
 Chemistry/src/Runtime/Runtime.csproj             |  5 ++++-
 MachineLearning/src/MachineLearning.csproj       |  1 +
 MachineLearning/src/Types.qs                     | 12 ++++++------
 Numerics/src/Numerics.csproj                     |  2 +-
 Standard/src/AmplitudeAmplification/Types.qs     | 11 ++++++++---
 Standard/src/Math/Complex.qs                     |  6 +++---
 Standard/src/Math/Types.qs                       | 12 ++++++++++++
 Standard/src/Optimization/Univariate.qs          |  2 +-
 12 files changed, 44 insertions(+), 20 deletions(-)

diff --git a/Chemistry/src/Jupyter/BroombridgeMagic.cs b/Chemistry/src/Jupyter/BroombridgeMagic.cs
index abf5f8f5340..d3bbcc3bf9d 100644
--- a/Chemistry/src/Jupyter/BroombridgeMagic.cs
+++ b/Chemistry/src/Jupyter/BroombridgeMagic.cs
@@ -16,7 +16,7 @@ public class BroombridgeMagic : MagicSymbol
         public BroombridgeMagic()
         {
             this.Name = $"%chemistry.broombridge";
-            this.Documentation = new Documentation() { Summary = "Loads and returns Broombridge electronic structure problem representation from a given .yaml file." };
+            this.Documentation = new Microsoft.Jupyter.Core.Documentation() { Summary = "Loads and returns Broombridge electronic structure problem representation from a given .yaml file." };
             this.Kind = SymbolKind.Magic;
             this.Execute = this.Run;
         }
diff --git a/Chemistry/src/Jupyter/ChemistryEncodeMagic.cs b/Chemistry/src/Jupyter/ChemistryEncodeMagic.cs
index 8eac3a69ca3..6e88be2b0be 100644
--- a/Chemistry/src/Jupyter/ChemistryEncodeMagic.cs
+++ b/Chemistry/src/Jupyter/ChemistryEncodeMagic.cs
@@ -17,7 +17,7 @@ public class ChemistryEncodeMagic : MagicSymbol
         public ChemistryEncodeMagic()
         {
             this.Name = $"%chemistry.encode";
-            this.Documentation = new Documentation() { Summary = "Encodes a fermion Hamiltonian to a format consumable by Q#." };
+            this.Documentation = new Microsoft.Jupyter.Core.Documentation() { Summary = "Encodes a fermion Hamiltonian to a format consumable by Q#." };
             this.Kind = SymbolKind.Magic;
             this.Execute = this.Run;
         }
diff --git a/Chemistry/src/Jupyter/FermionHamiltonianMagic.cs b/Chemistry/src/Jupyter/FermionHamiltonianMagic.cs
index b61954ed4e0..07e3583bd37 100644
--- a/Chemistry/src/Jupyter/FermionHamiltonianMagic.cs
+++ b/Chemistry/src/Jupyter/FermionHamiltonianMagic.cs
@@ -26,7 +26,7 @@ public class FermionHamiltonianLoadMagic : MagicSymbol
         public FermionHamiltonianLoadMagic()
         {
             this.Name = $"%chemistry.fh.load";
-            this.Documentation = new Documentation() { Summary = "Loads the fermion Hamiltonian for an electronic structure problem. The problem is loaded from a file or passed as an argument." };
+            this.Documentation = new Microsoft.Jupyter.Core.Documentation() { Summary = "Loads the fermion Hamiltonian for an electronic structure problem. The problem is loaded from a file or passed as an argument." };
             this.Kind = SymbolKind.Magic;
             this.Execute = this.Run;
         }
@@ -113,7 +113,10 @@ public class FermionHamiltonianAddTermsMagic : MagicSymbol
         public FermionHamiltonianAddTermsMagic()
         {
             this.Name = $"%chemistry.fh.add_terms";
-            this.Documentation = new Documentation() { Summary = "Adds terms to a fermion Hamiltonian." };
+            this.Documentation = new Microsoft.Jupyter.Core.Documentation
+            {
+                Summary = "Adds terms to a fermion Hamiltonian."
+            };
             this.Kind = SymbolKind.Magic;
             this.Execute = this.Run;
         }
diff --git a/Chemistry/src/Jupyter/WavefunctionMagic.cs b/Chemistry/src/Jupyter/WavefunctionMagic.cs
index bed1d935b78..f32b2bf538e 100644
--- a/Chemistry/src/Jupyter/WavefunctionMagic.cs
+++ b/Chemistry/src/Jupyter/WavefunctionMagic.cs
@@ -20,7 +20,7 @@ public class WavefunctionMagic : MagicSymbol
         public WavefunctionMagic()
         {
             this.Name = $"%chemistry.inputstate.load";
-            this.Documentation = new Documentation() { Summary = "Loads Broombridge electronic structure problem and returns selected input state." };
+            this.Documentation = new Microsoft.Jupyter.Core.Documentation() { Summary = "Loads Broombridge electronic structure problem and returns selected input state." };
             this.Kind = SymbolKind.Magic;
             this.Execute = this.Run;
         }
diff --git a/Chemistry/src/Runtime/Runtime.csproj b/Chemistry/src/Runtime/Runtime.csproj
index 902c0c66483..cf29d4dedff 100644
--- a/Chemistry/src/Runtime/Runtime.csproj
+++ b/Chemistry/src/Runtime/Runtime.csproj
@@ -6,6 +6,10 @@
     <QsharpDocsGeneration>true</QsharpDocsGeneration>
     <IncludeQsharpCorePackages>false</IncludeQsharpCorePackages>
     <RunQDocGen>True</RunQDocGen>
+    <!-- List the name of the metapackage that users can
+         use to take a dependency on these Q# APIs, rather
+         than the subpackage directly. -->
+    <QsharpDocsPackageId>Microsoft.Quantum.Chemistry</QsharpDocsPackageId>
   </PropertyGroup>
 
   <PropertyGroup>
@@ -44,4 +48,3 @@
   </ItemGroup>
 
 </Project>
-
diff --git a/MachineLearning/src/MachineLearning.csproj b/MachineLearning/src/MachineLearning.csproj
index 73b86c36b20..e26329dac2b 100644
--- a/MachineLearning/src/MachineLearning.csproj
+++ b/MachineLearning/src/MachineLearning.csproj
@@ -3,6 +3,7 @@
     <TargetFramework>netstandard2.1</TargetFramework>
     <AssemblyName>Microsoft.Quantum.MachineLearning</AssemblyName>
     <QsharpDocsGeneration>true</QsharpDocsGeneration>
+    <QsharpDocsPackageId>Microsoft.Quantum.MachineLearning</QsharpDocsPackageId>
     <!--
       Include core packages using project references instead, since they get
       built at the same time as this project.
diff --git a/MachineLearning/src/Types.qs b/MachineLearning/src/Types.qs
index a495d4687ab..2eee9a9f653 100644
--- a/MachineLearning/src/Types.qs
+++ b/MachineLearning/src/Types.qs
@@ -10,7 +10,7 @@ namespace Microsoft.Quantum.MachineLearning {
     /// Describes a controlled rotation in terms of its target and control
     /// indices, rotation axis, and index into a model parameter vector.
     ///
-    /// # Input
+    /// # Named Items
     /// ## TargetIndex
     /// Index of the target qubit for this controlled rotation.
     /// ## ControlIndices
@@ -50,7 +50,7 @@ namespace Microsoft.Quantum.MachineLearning {
     /// parameterized and controlled rotations, an assignment of rotation
     /// angles, and a bias between the two classes recognized by the model.
     ///
-    /// # Input
+    /// # Named Items
     /// ## Structure
     /// The sequence of controlled rotations used to classify inputs.
     /// ## Parameters
@@ -70,7 +70,7 @@ namespace Microsoft.Quantum.MachineLearning {
     /// Describes an operation that prepares a given input to a sequential
     /// classifier.
     ///
-    /// # Input
+    /// # Named Items
     /// ## NQubits
     /// The number of qubits on which the encoded input is defined.
     /// ## Prepare
@@ -84,7 +84,7 @@ namespace Microsoft.Quantum.MachineLearning {
     /// # Summary
     /// A sample, labeled with a class to which that sample belongs.
     ///
-    /// # Input
+    /// # Named Items
     /// ## Features
     /// A vector of features for the given sample.
     /// ## Label
@@ -152,7 +152,7 @@ namespace Microsoft.Quantum.MachineLearning {
     /// The results from having validated a classifier against a set of
     /// samples.
     ///
-    /// # Input
+    /// # Named Items
     /// ## NMisclassifications
     /// The number of misclassifications observed during validation.
     newtype ValidationResults = (
@@ -163,7 +163,7 @@ namespace Microsoft.Quantum.MachineLearning {
     /// # Summary
     /// A collection of options to be used in training quantum classifiers.
     ///
-    /// # Input
+    /// # Named Items
     /// ## LearningRate
     /// The learning rate by which gradients should be rescaled when updating
     /// model parameters during training steps.
diff --git a/Numerics/src/Numerics.csproj b/Numerics/src/Numerics.csproj
index 9b9abfd7039..be966a5489b 100644
--- a/Numerics/src/Numerics.csproj
+++ b/Numerics/src/Numerics.csproj
@@ -4,6 +4,7 @@
     <TargetFramework>netstandard2.1</TargetFramework>
     <AssemblyName>Microsoft.Quantum.Numerics</AssemblyName>
     <QsharpDocsGeneration>true</QsharpDocsGeneration>
+    <QsharpDocsPackageId>Microsoft.Quantum.Numerics</QsharpDocsPackageId>
     <IncludeQsharpCorePackages>false</IncludeQsharpCorePackages>
   </PropertyGroup>
 
@@ -45,4 +46,3 @@
   </ItemGroup>
 
 </Project>
-
diff --git a/Standard/src/AmplitudeAmplification/Types.qs b/Standard/src/AmplitudeAmplification/Types.qs
index 5addb42ddfa..69a90ce2006 100644
--- a/Standard/src/AmplitudeAmplification/Types.qs
+++ b/Standard/src/AmplitudeAmplification/Types.qs
@@ -6,10 +6,15 @@ namespace Microsoft.Quantum.AmplitudeAmplification {
     /// # Summary
     /// Phases for a sequence of partial reflections in amplitude amplification.
     ///
-    /// # Remarks
-    /// The first parameter is an array of phases for reflection about the
-    /// start state. The second parameter is an array of phases for reflection
+    /// # Named Items
+    /// ## AboutStart
+    /// An array of phases for reflection about the
+    /// start state.
+    /// ## AboutTarget
+    /// An array of phases for reflection
     /// about the target state.
+    ///
+    /// # Remarks
     /// Both arrays must be of equal length. Note that in many cases, the first phase about the start state and last phase about the target state introduces a global phase shift and may be set to $0$.
     newtype ReflectionPhases = (
         AboutStart: Double[],
diff --git a/Standard/src/Math/Complex.qs b/Standard/src/Math/Complex.qs
index 043d360f199..3240352032e 100644
--- a/Standard/src/Math/Complex.qs
+++ b/Standard/src/Math/Complex.qs
@@ -8,10 +8,10 @@ namespace Microsoft.Quantum.Math {
     ///
     /// The polar representation of a complex number is $c=r e^{i t}$.
     ///
-    /// # Input
-    /// ## First Parameter
+    /// # Named Items
+    /// ## Magnitude
     /// `Double` is absolute value $r \ge 0$.
-    /// ## Second Parameter
+    /// ## Argument
     /// `Double` is the phase $t \in \mathbb R$.
     newtype ComplexPolar = (Magnitude: Double, Argument: Double);
 
diff --git a/Standard/src/Math/Types.qs b/Standard/src/Math/Types.qs
index 6e0d05d364a..8bad0920fcf 100644
--- a/Standard/src/Math/Types.qs
+++ b/Standard/src/Math/Types.qs
@@ -4,6 +4,12 @@ namespace Microsoft.Quantum.Math {
     /// Represents a rational number of the form `p/q`. Integer `p` is
     /// the first element of the tuple and `q` is the second element
     /// of the tuple.
+    ///
+    /// # Named Items
+    /// ## Numerator
+    /// Numerator of the fraction.
+    /// ## Denominator
+    /// Denominator of the fraction/
     newtype Fraction = (
         Numerator: Int,
         Denominator: Int
@@ -13,6 +19,12 @@ namespace Microsoft.Quantum.Math {
     /// Represents a rational number of the form `p/q`. Integer `p` is
     /// the first element of the tuple and `q` is the second element
     /// of the tuple.
+    ///
+    /// # Named Items
+    /// ## Numerator
+    /// Numerator of the fraction.
+    /// ## Denominator
+    /// Denominator of the fraction/
     newtype BigFraction = (
         Numerator: BigInt,
         Denominator: BigInt
diff --git a/Standard/src/Optimization/Univariate.qs b/Standard/src/Optimization/Univariate.qs
index fef2d09a672..4b6f6d03aa4 100644
--- a/Standard/src/Optimization/Univariate.qs
+++ b/Standard/src/Optimization/Univariate.qs
@@ -9,7 +9,7 @@ namespace Microsoft.Quantum.Optimization {
     /// # Summary
     /// Represents the result of optimizing a univariate function.
     ///
-    /// # Input
+    /// # Named Items
     /// ## Coordinate
     /// Input at which an optimum was found.
     /// ## Value

From ed143c904e301880df52ac1efbc428fc9324081c Mon Sep 17 00:00:00 2001
From: Chris Granade <chgranad@microsoft.com>
Date: Tue, 20 Oct 2020 18:25:17 -0700
Subject: [PATCH 2/2] Fix documentation warnings (#353)

---
 Build/props/tests.props                       |   3 +-
 Chemistry/src/Runtime/Runtime.csproj          |   4 +-
 .../tests/ChemistryTests/QSharpTests.csproj   |   3 +-
 .../tests/SystemTests/SystemTests.csproj      |   3 +-
 MachineLearning/src/MachineLearning.csproj    |   2 +-
 .../tests/MachineLearningTests.csproj         |   2 +-
 Numerics/src/Numerics.csproj                  |   4 +-
 Numerics/tests/NumericsTests.csproj           |   2 +-
 .../AmplitudeAmplification.qs                 |   8 +-
 Standard/src/Arithmetic/ApplyDual.qs          |   6 +-
 Standard/src/Arithmetic/ApplyReversed.qs      | 114 +++++++++---------
 Standard/src/Arithmetic/Arithmetic.qs         |   2 +-
 Standard/src/Arithmetic/Comparators.qs        |   4 +-
 Standard/src/Arithmetic/Increment.qs          |   5 +-
 Standard/src/Arithmetic/Modular.qs            |   6 +-
 Standard/src/Arithmetic/Types.qs              |   6 +-
 Standard/src/Arrays/Arrays.qs                 |   4 +-
 Standard/src/Arrays/EqualA.qs                 |   4 +-
 Standard/src/Arrays/Map.qs                    |   2 +-
 .../Canon/Combinators/ApplyRepeatedOver.qs    |   8 +-
 .../src/Canon/Combinators/ApplyToArray.qs     |  32 ++---
 .../src/Canon/Combinators/ApplyToElement.qs   |  10 +-
 .../src/Canon/Combinators/ApplyToFirst.qs     |  26 ++--
 .../src/Canon/Combinators/ApplyToPartition.qs |  16 +--
 Standard/src/Canon/Combinators/Curry.qs       |  12 +-
 Standard/src/Canon/Combinators/Delay.qs       |   9 +-
 .../src/Canon/Combinators/OperationPow.qs     |  12 +-
 .../Combinators/RestrictedToSubregister.qs    |  24 ++--
 Standard/src/Canon/Combinators/Transformed.qs |  74 ++++++------
 Standard/src/Canon/Combinators/With.qs        |  59 ++++-----
 Standard/src/Canon/CommonGates.qs             |   3 +-
 Standard/src/Canon/Enumeration/Trotter.qs     |  14 +--
 Standard/src/Canon/Parity.qs                  |   2 +-
 Standard/src/Canon/QFT.qs                     |   2 +-
 Standard/src/Canon/Utils/Multiplexer.qs       |  19 ++-
 Standard/src/Convert/Convert.qs               |   2 -
 Standard/src/ErrorCorrection/5QubitCode.qs    |  16 ++-
 Standard/src/ErrorCorrection/7QubitCode.qs    |  22 ++--
 Standard/src/ErrorCorrection/BitFlipCode.qs   |   8 +-
 Standard/src/ErrorCorrection/Types.qs         |   4 +-
 Standard/src/ErrorCorrection/Utils.qs         |  12 +-
 Standard/src/Math/Complex.qs                  |  24 ++--
 Standard/src/Math/Functions.qs                |  19 ++-
 Standard/src/Oracles/Convert.qs               |  12 +-
 Standard/src/Preparation/Arbitrary.qs         |   2 +-
 Standard/src/Preparation/Mixed.qs             |   2 +-
 Standard/src/Preparation/Reference.qs         |  14 +--
 Standard/src/Simulation/BlockEncoding.qs      |  22 ++--
 .../Data/GeneratorRepresentation.qs           |  31 +++--
 .../QubitizationPauliEvolutionSet.qs          |  11 +-
 Standard/src/Simulation/Techniques.qs         |   4 +-
 Standard/src/Simulation/Types.qs              |   4 +-
 Standard/src/Standard.csproj                  |  13 +-
 Standard/tests/Standard.Tests.csproj          |   2 +-
 Visualization/src/Visualization.csproj        |   4 +-
 55 files changed, 359 insertions(+), 375 deletions(-)

diff --git a/Build/props/tests.props b/Build/props/tests.props
index 1c76f5de1e9..93da9885b9e 100644
--- a/Build/props/tests.props
+++ b/Build/props/tests.props
@@ -6,7 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Quantum.Xunit" Version="0.12.20082515-beta" />
+    <PackageReference Include="Microsoft.Quantum.Xunit" Version="0.12.20102008-beta" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.4.0" />
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="xunit.runner.visualstudio" Version="2.4.1" />
@@ -14,4 +14,3 @@
   </ItemGroup>
 
 </Project>
-
diff --git a/Chemistry/src/Runtime/Runtime.csproj b/Chemistry/src/Runtime/Runtime.csproj
index cf29d4dedff..3c6a82671de 100644
--- a/Chemistry/src/Runtime/Runtime.csproj
+++ b/Chemistry/src/Runtime/Runtime.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.Quantum.Sdk/0.12.20082515-beta">
+<Project Sdk="Microsoft.Quantum.Sdk/0.12.20102008-beta">
 
   <PropertyGroup>
     <TargetFramework>netstandard2.1</TargetFramework>
@@ -40,7 +40,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Quantum.Simulators" Version="0.12.20082515-beta" />
+    <PackageReference Include="Microsoft.Quantum.Simulators" Version="0.12.20102008-beta" />
   </ItemGroup>
 
   <ItemGroup>
diff --git a/Chemistry/tests/ChemistryTests/QSharpTests.csproj b/Chemistry/tests/ChemistryTests/QSharpTests.csproj
index 0c32a5c7541..812d30ef794 100644
--- a/Chemistry/tests/ChemistryTests/QSharpTests.csproj
+++ b/Chemistry/tests/ChemistryTests/QSharpTests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.Quantum.Sdk/0.12.20082515-beta">
+<Project Sdk="Microsoft.Quantum.Sdk/0.12.20102008-beta">
 
   <Import Project="..\..\..\Build\props\tests.props" />
 
@@ -12,4 +12,3 @@
   </ItemGroup>
 
 </Project>
-
diff --git a/Chemistry/tests/SystemTests/SystemTests.csproj b/Chemistry/tests/SystemTests/SystemTests.csproj
index 27269417885..83495463ace 100644
--- a/Chemistry/tests/SystemTests/SystemTests.csproj
+++ b/Chemistry/tests/SystemTests/SystemTests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.Quantum.Sdk/0.12.20082515-beta">
+<Project Sdk="Microsoft.Quantum.Sdk/0.12.20102008-beta">
 
   <Import Project="..\..\..\Build\props\tests.props" />
 
@@ -39,4 +39,3 @@
   </ItemGroup>
 
 </Project>
-
diff --git a/MachineLearning/src/MachineLearning.csproj b/MachineLearning/src/MachineLearning.csproj
index e26329dac2b..6ffd2451c74 100644
--- a/MachineLearning/src/MachineLearning.csproj
+++ b/MachineLearning/src/MachineLearning.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.Quantum.Sdk/0.12.20082515-beta">
+<Project Sdk="Microsoft.Quantum.Sdk/0.12.20102008-beta">
   <PropertyGroup>
     <TargetFramework>netstandard2.1</TargetFramework>
     <AssemblyName>Microsoft.Quantum.MachineLearning</AssemblyName>
diff --git a/MachineLearning/tests/MachineLearningTests.csproj b/MachineLearning/tests/MachineLearningTests.csproj
index c86238619cc..d883fd37d5c 100644
--- a/MachineLearning/tests/MachineLearningTests.csproj
+++ b/MachineLearning/tests/MachineLearningTests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.Quantum.Sdk/0.12.20082515-beta">
+<Project Sdk="Microsoft.Quantum.Sdk/0.12.20102008-beta">
 
   <Import Project="..\..\Build\props\tests.props" />
 
diff --git a/Numerics/src/Numerics.csproj b/Numerics/src/Numerics.csproj
index be966a5489b..6a96efeb443 100644
--- a/Numerics/src/Numerics.csproj
+++ b/Numerics/src/Numerics.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.Quantum.Sdk/0.12.20082515-beta">
+<Project Sdk="Microsoft.Quantum.Sdk/0.12.20102008-beta">
 
   <PropertyGroup>
     <TargetFramework>netstandard2.1</TargetFramework>
@@ -41,7 +41,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Quantum.Simulators" Version="0.12.20082515-beta" />
+    <PackageReference Include="Microsoft.Quantum.Simulators" Version="0.12.20102008-beta" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
   </ItemGroup>
 
diff --git a/Numerics/tests/NumericsTests.csproj b/Numerics/tests/NumericsTests.csproj
index 2cae9395dd8..312522abe65 100644
--- a/Numerics/tests/NumericsTests.csproj
+++ b/Numerics/tests/NumericsTests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.Quantum.Sdk/0.12.20082515-beta">
+<Project Sdk="Microsoft.Quantum.Sdk/0.12.20102008-beta">
 
   <Import Project="..\..\Build\props\tests.props" />
 
diff --git a/Standard/src/AmplitudeAmplification/AmplitudeAmplification.qs b/Standard/src/AmplitudeAmplification/AmplitudeAmplification.qs
index 646943ef900..10533bd1490 100644
--- a/Standard/src/AmplitudeAmplification/AmplitudeAmplification.qs
+++ b/Standard/src/AmplitudeAmplification/AmplitudeAmplification.qs
@@ -185,8 +185,6 @@ namespace Microsoft.Quantum.AmplitudeAmplification {
     /// Reflection operator about start state
     /// ## targetStateReflection
     /// Reflection operator about target state
-    /// ## startQubits
-    /// Qubit register
     ///
     /// # Output
     /// An operation that implements amplitude amplification by partial reflections.
@@ -223,8 +221,6 @@ namespace Microsoft.Quantum.AmplitudeAmplification {
     /// Unitary oracle $A$ that prepares start state
     /// ## idxFlagQubit
     /// Index to flag qubit
-    /// ## qubits
-    /// Start state register
     ///
     /// # Output
     /// An operation that implements amplitude amplification by oracles that are
@@ -259,12 +255,10 @@ namespace Microsoft.Quantum.AmplitudeAmplification {
     /// # Input
     /// ## nIterations
     /// Number of iterations $n$ of amplitude amplification
-    /// ## statePrepOracle
+    /// ## stateOracle
     /// Unitary oracle $A$ that prepares start state
     /// ## idxFlagQubit
     /// Index to flag qubit
-    /// ## qubits
-    /// Start state register
     ///
     /// # Output
     /// An operation that implements the standard amplitude amplification quantum algorithm
diff --git a/Standard/src/Arithmetic/ApplyDual.qs b/Standard/src/Arithmetic/ApplyDual.qs
index cf2cd277131..0eecf879314 100644
--- a/Standard/src/Arithmetic/ApplyDual.qs
+++ b/Standard/src/Arithmetic/ApplyDual.qs
@@ -37,7 +37,7 @@ namespace Microsoft.Quantum.Arithmetic {
     }
 
     /// # See Also
-    /// - ApplyPhaseLEOperationOnLE
+    /// - Microsoft.Quantum.Canon.ApplyPhaseLEOperationOnLE
     operation ApplyPhaseLEOperationOnLEA (op : (PhaseLittleEndian => Unit is Adj), target : LittleEndian) : Unit
     {
         body (...)
@@ -53,7 +53,7 @@ namespace Microsoft.Quantum.Arithmetic {
 
 
     /// # See Also
-    /// - @"microsoft.quantum.canon.applyphaseleoperationonle"
+    /// - Microsoft.Quantum.Canon.ApplyPhaseLEOperationOnLE
     operation ApplyPhaseLEOperationOnLEC (op : (PhaseLittleEndian => Unit is Ctl), target : LittleEndian) : Unit
     {
         body (...)
@@ -75,7 +75,7 @@ namespace Microsoft.Quantum.Arithmetic {
 
 
     /// # See Also
-    /// - @"microsoft.quantum.canon.applyphaseleoperationonle"
+    /// - Microsoft.Quantum.Canon.ApplyPhaseLEOperationOnLE
     operation ApplyPhaseLEOperationOnLECA (op : (PhaseLittleEndian => Unit is Adj + Ctl), target : LittleEndian) : Unit
     {
         body (...)
diff --git a/Standard/src/Arithmetic/ApplyReversed.qs b/Standard/src/Arithmetic/ApplyReversed.qs
index 80a90a6fdbe..8e950eac1b1 100644
--- a/Standard/src/Arithmetic/ApplyReversed.qs
+++ b/Standard/src/Arithmetic/ApplyReversed.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 ///////////////////////////////////////////////////////////////////////////////////////////
@@ -20,9 +20,9 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A big-endian register to be transformed.
     ///
     /// # See Also
-    /// - ApplyReversedOpLEA
-    /// - ApplyReversedOpLEC
-    /// - ApplyReversedOpLECA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLEA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLEC
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLECA
     operation ApplyReversedOpLE(op : (LittleEndian => Unit), register : BigEndian) : Unit {
         ApplyWithInputTransformation(BigEndianAsLittleEndian, op, register);
     }
@@ -38,10 +38,10 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A new operation that accepts its input as a big-endian register.
     ///
     /// # See Also
-    /// - ApplyReversedOpLE
-    /// - ReversedOpLEA
-    /// - ReversedOpLEC
-    /// - ReversedOpLECA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLE
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpLEA
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpLEC
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpLECA
     function ReversedOpLE(op : (LittleEndian => Unit)) : (BigEndian => Unit) {
         return ApplyReversedOpLE(op, _);
     }
@@ -57,9 +57,9 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A big-endian register to be transformed.
     ///
     /// # See Also
-    /// - ApplyReversedOpLE
-    /// - ApplyReversedOpLEC
-    /// - ApplyReversedOpLECA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLE
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLEC
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLECA
     operation ApplyReversedOpLEA (op : (LittleEndian => Unit is Adj), register : BigEndian) : Unit {
         body (...) {
             ApplyWithInputTransformationA(BigEndianAsLittleEndian, op, register);
@@ -81,10 +81,10 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A new operation that accepts its input as a big-endian register.
     ///
     /// # See Also
-    /// - ApplyReversedOpLEA
-    /// - ReversedOpLE
-    /// - ReversedOpLEC
-    /// - ReversedOpLECA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLEA
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpLE
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpLEC
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpLECA
     function ReversedOpLEA(op : (LittleEndian => Unit is Adj)) : (BigEndian => Unit is Adj) {
         return ApplyReversedOpLEA(op, _);
     }
@@ -100,9 +100,9 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A big-endian register to be transformed.
     ///
     /// # See Also
-    /// - ApplyReversedOpLE
-    /// - ApplyReversedOpLEA
-    /// - ApplyReversedOpLECA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLE
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLEA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLECA
     operation ApplyReversedOpLEC(op : (LittleEndian => Unit is Ctl), register : BigEndian) : Unit {
         body (...) {
             ApplyWithInputTransformationC(BigEndianAsLittleEndian, op, register);
@@ -123,10 +123,10 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A new operation that accepts its input as a big-endian register.
     ///
     /// # See Also
-    /// - ApplyReversedOpLEC
-    /// - ReversedOpLE
-    /// - ReversedOpLEA
-    /// - ReversedOpLECA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLEC
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpLE
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpLEA
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpLECA
     function ReversedOpLEC(op : (LittleEndian => Unit is Ctl)) : (BigEndian => Unit is Ctl) {
         return ApplyReversedOpLEC(op, _);
     }
@@ -142,9 +142,9 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A big-endian register to be transformed.
     ///
     /// # See Also
-    /// - ApplyReversedOpLE
-    /// - ApplyReversedOpLEA
-    /// - ApplyReversedOpLEC
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLE
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLEA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLEC
     operation ApplyReversedOpLECA(op : (LittleEndian => Unit is Ctl + Adj), register : BigEndian) : Unit {
         body (...) {
             ApplyWithInputTransformationCA(BigEndianAsLittleEndian, op, register);
@@ -167,10 +167,10 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A new operation that accepts its input as a big-endian register.
     ///
     /// # See Also
-    /// - ApplyReversedOpLECA
-    /// - ReversedOpLE
-    /// - ReversedOpLEA
-    /// - ReversedOpLEC
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpLECA
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpLE
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpLEA
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpLEC
     function ReversedOpLECA(op : (LittleEndian => Unit is Adj + Ctl)) : (BigEndian => Unit is Adj + Ctl) {
         return ApplyReversedOpLECA(op, _);
     }
@@ -186,9 +186,9 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A little-endian register to be transformed.
     ///
     /// # See Also
-    /// - ApplyReversedOpBEA
-    /// - ApplyReversedOpBEC
-    /// - ApplyReversedOpBECA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBEA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBEC
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBECA
     operation ApplyReversedOpBE(op : (BigEndian => Unit), register : LittleEndian) : Unit {
         ApplyWithInputTransformation(LittleEndianAsBigEndian, op, register);
     }
@@ -205,10 +205,10 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A new operation that accepts its input as a little-endian register.
     ///
     /// # See Also
-    /// - ApplyReversedOpBE
-    /// - ReversedOpBEA
-    /// - ReversedOpBEC
-    /// - ReversedOpBECA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBE
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpBEA
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpBEC
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpBECA
     function ReversedOpBE(op : (BigEndian => Unit)) : (LittleEndian => Unit) {
         return ApplyReversedOpBE(op, _);
     }
@@ -224,9 +224,9 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A little-endian register to be transformed.
     ///
     /// # See Also
-    /// - ApplyReversedOpBE
-    /// - ApplyReversedOpBEC
-    /// - ApplyReversedOpBECA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBE
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBEC
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBECA
     operation ApplyReversedOpBEA (op : (BigEndian => Unit is Adj), register : LittleEndian) : Unit {
         body (...) {
             ApplyWithInputTransformationA(LittleEndianAsBigEndian, op, register);
@@ -247,10 +247,10 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A new operation that accepts its input as a little-endian register.
     ///
     /// # See Also
-    /// - ApplyReversedOpBEA
-    /// - ReversedOpBE
-    /// - ReversedOpBEC
-    /// - ReversedOpBECA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBEA
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpBE
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpBEC
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpBECA
     function ReversedOpBEA(op : (BigEndian => Unit is Adj)) : (LittleEndian => Unit is Adj) {
         return ApplyReversedOpBEA(op, _);
     }
@@ -266,9 +266,9 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A little-endian register to be transformed.
     ///
     /// # See Also
-    /// - ApplyReversedOpBE
-    /// - ApplyReversedOpBEA
-    /// - ApplyReversedOpBECA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBE
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBEA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBECA
     operation ApplyReversedOpBEC(op : (BigEndian => Unit is Ctl), register : LittleEndian) : Unit {
         body (...) {
             ApplyWithInputTransformationC(LittleEndianAsBigEndian, op, register);
@@ -289,10 +289,10 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A new operation that accepts its input as a little-endian register.
     ///
     /// # See Also
-    /// - ApplyReversedOpBEC
-    /// - ReversedOpBE
-    /// - ReversedOpBEA
-    /// - ReversedOpBECA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBEC
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpBE
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpBEA
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpBECA
     function ReversedOpBEC(op : (BigEndian => Unit is Ctl)) : (LittleEndian => Unit is Ctl) {
         return ApplyReversedOpBEC(op, _);
     }
@@ -308,9 +308,9 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A little-endian register to be transformed.
     ///
     /// # See Also
-    /// - ApplyReversedOpBE
-    /// - ApplyReversedOpBEA
-    /// - ApplyReversedOpBEC
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBE
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBEA
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBEC
     operation ApplyReversedOpBECA(op : (BigEndian => Unit is Ctl + Adj), register : LittleEndian) : Unit {
         body (...) {
             ApplyWithInputTransformationCA(LittleEndianAsBigEndian, op, register);
@@ -333,10 +333,10 @@ namespace Microsoft.Quantum.Arithmetic {
     /// A new operation that accepts its input as a little-endian register.
     ///
     /// # See Also
-    /// - ApplyReversedOpBECA
-    /// - ReversedOpBE
-    /// - ReversedOpBEA
-    /// - ReversedOpBEC
+    /// - Microsoft.Quantum.Arithmetic.ApplyReversedOpBECA
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpBE
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpBEA
+    /// - Microsoft.Quantum.Arithmetic.ReversedOpBEC
     function ReversedOpBECA(op : (BigEndian => Unit is Adj + Ctl)) : (LittleEndian => Unit is Adj + Ctl) {
         return ApplyReversedOpBECA(op, _);
     }
diff --git a/Standard/src/Arithmetic/Arithmetic.qs b/Standard/src/Arithmetic/Arithmetic.qs
index abab5bed060..d88e6b346bc 100644
--- a/Standard/src/Arithmetic/Arithmetic.qs
+++ b/Standard/src/Arithmetic/Arithmetic.qs
@@ -71,7 +71,7 @@ namespace Microsoft.Quantum.Arithmetic {
     /// in computational basis.
     ///
     /// # See Also
-    /// - LittleEndian
+    /// - Microsoft.Quantum.Arithmetic.LittleEndian
     operation CopyMostSignificantBit (from : LittleEndian, target : Qubit) : Unit {
         body (...) {
             let mostSingificantQubit = Tail(from!);
diff --git a/Standard/src/Arithmetic/Comparators.qs b/Standard/src/Arithmetic/Comparators.qs
index 56446f17d76..f8ad576de8f 100644
--- a/Standard/src/Arithmetic/Comparators.qs
+++ b/Standard/src/Arithmetic/Comparators.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Arithmetic {
@@ -48,7 +48,7 @@ namespace Microsoft.Quantum.Arithmetic {
                 ApplyToEachCA(X, x! + [auxiliary]);
 
                 ApplyMajorityInPlace(x![0], [y![0], auxiliary]);
-                ApplyToEachCA(MAJ, Zip3(Most(x!), Rest(y!), Rest(x!)));
+                ApplyToEachCA(MAJ, Zipped3(Most(x!), Rest(y!), Rest(x!)));
             } apply {
                 X(output);
                 CNOT(Tail(x!), output);
diff --git a/Standard/src/Arithmetic/Increment.qs b/Standard/src/Arithmetic/Increment.qs
index 53066a5b388..861b054e6a2 100644
--- a/Standard/src/Arithmetic/Increment.qs
+++ b/Standard/src/Arithmetic/Increment.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Arithmetic {
@@ -24,8 +24,7 @@ namespace Microsoft.Quantum.Arithmetic {
     /// The integer by which the `target` is incremented by.
     ///
     /// # See Also
-    /// - IncrementByIntegerBE
-    /// - IncrementByIntegerLE
+    /// - Microsoft.Quantum.Arithmetic.IncrementByInteger
     ///
     /// # References
     /// - [ *Thomas G. Draper*,
diff --git a/Standard/src/Arithmetic/Modular.qs b/Standard/src/Arithmetic/Modular.qs
index f9b91b6a7e9..92efb66db23 100644
--- a/Standard/src/Arithmetic/Modular.qs
+++ b/Standard/src/Arithmetic/Modular.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Arithmetic {
@@ -130,7 +130,7 @@ namespace Microsoft.Quantum.Arithmetic {
     /// for a given modulus $N$, constant multiplier $a$, and summand $y$.
     ///
     /// # Input
-    /// ## constantMultiplier
+    /// ## constMultiplier
     /// An integer $a$ to be added to each basis state label.
     /// ## modulus
     /// The modulus $N$ which addition and multiplication is taken with respect to.
@@ -163,7 +163,7 @@ namespace Microsoft.Quantum.Arithmetic {
     /// integers in QFT basis.
     ///
     /// # Input
-    /// ## constantMultiplier
+    /// ## constMultiplier
     /// An integer $a$ to be added to each basis state label.
     /// ## modulus
     /// The modulus $N$ which addition and multiplication is taken with respect to.
diff --git a/Standard/src/Arithmetic/Types.qs b/Standard/src/Arithmetic/Types.qs
index f86a3859948..d5c1eeeba94 100644
--- a/Standard/src/Arithmetic/Types.qs
+++ b/Standard/src/Arithmetic/Types.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Arithmetic {
@@ -31,8 +31,8 @@ namespace Microsoft.Quantum.Arithmetic {
     /// We abbreviate `PhaseLittleEndian` as `PhaseLE` in the documentation.
     ///
     /// # See Also
-    /// - QFT
-    /// - QFTLE
+    /// - Microsoft.Quantum.Canon.QFT
+    /// - Microsoft.Quantum.Canon.QFTLE
     newtype PhaseLittleEndian = Qubit[];
 
 }
diff --git a/Standard/src/Arrays/Arrays.qs b/Standard/src/Arrays/Arrays.qs
index c24f16329ee..ffd0a805a75 100644
--- a/Standard/src/Arrays/Arrays.qs
+++ b/Standard/src/Arrays/Arrays.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Arrays {
@@ -373,7 +373,7 @@ namespace Microsoft.Quantum.Arrays {
     /// that `array` can be interpreted as a permutation on `n` elements.
     ///
     /// # Input
-    /// ## array
+    /// ## permuation
     /// An array that may or may not represent a permutation.
     ///
     /// # Ouput
diff --git a/Standard/src/Arrays/EqualA.qs b/Standard/src/Arrays/EqualA.qs
index eb3cfc4143f..551c5dd69bc 100644
--- a/Standard/src/Arrays/EqualA.qs
+++ b/Standard/src/Arrays/EqualA.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Arrays {
@@ -19,7 +19,7 @@ namespace Microsoft.Quantum.Arrays {
     /// The type of each array's elements.
     ///
     /// # Input
-    /// ## predicate
+    /// ## equal
     /// A function from tuple `('T, 'T)` to `Bool` that is used to check whether two elements of arrays are equal.
     /// ## array1
     /// The first array to be compared.
diff --git a/Standard/src/Arrays/Map.qs b/Standard/src/Arrays/Map.qs
index b541190a738..3f531800f27 100644
--- a/Standard/src/Arrays/Map.qs
+++ b/Standard/src/Arrays/Map.qs
@@ -76,7 +76,7 @@ namespace Microsoft.Quantum.Arrays {
     /// ```
     ///
     /// # See Also
-    /// - Mapped
+    /// - Microsoft.Quantum.Arrays.Mapped
     function MappedByIndex<'T, 'U> (mapper : ((Int, 'T) -> 'U), array : 'T[]) : 'U[] {
         mutable resultArray = new 'U[Length(array)];
 
diff --git a/Standard/src/Canon/Combinators/ApplyRepeatedOver.qs b/Standard/src/Canon/Combinators/ApplyRepeatedOver.qs
index 26cdd7c7b2b..223a6c04360 100644
--- a/Standard/src/Canon/Combinators/ApplyRepeatedOver.qs
+++ b/Standard/src/Canon/Combinators/ApplyRepeatedOver.qs
@@ -22,7 +22,7 @@ namespace Microsoft.Quantum.Canon {
     /// ## register
     /// Qubit register to be acted upon.
     ///
-    /// ## Example
+    /// # Example
     /// // The following applies Exp([PauliX, PauliY], 0.5) to qubits 0, 1
     /// // then X to qubit 2
     /// let ops = [Exp([PauliX, PauliY], 0.5, _), ApplyToFirstQubit(X, _)];
@@ -56,7 +56,7 @@ namespace Microsoft.Quantum.Canon {
     /// ## register
     /// Qubit register to be acted upon.
     ///
-    /// ## Example
+    /// # Example
     /// // The following applies Exp([PauliX, PauliY], 0.5) to qubits 0, 1
     /// // then X to qubit 2
     /// let ops = [Exp([PauliX, PauliY], 0.5, _), ApplyToFirstQubitA(X, _)];
@@ -90,7 +90,7 @@ namespace Microsoft.Quantum.Canon {
     /// ## register
     /// Qubit register to be acted upon.
     ///
-    /// ## Example
+    /// # Example
     /// // The following applies Exp([PauliX, PauliY], 0.5) to qubits 0, 1
     /// // then X to qubit 2
     /// let ops = [Exp([PauliX, PauliY], 0.5, _), ApplyToFirstQubitC(X, _)];
@@ -124,7 +124,7 @@ namespace Microsoft.Quantum.Canon {
     /// ## register
     /// Qubit register to be acted upon.
     ///
-    /// ## Example
+    /// # Example
     /// // The following applies Exp([PauliX, PauliY], 0.5) to qubits 0, 1
     /// // then X to qubit 2
     /// let ops = [Exp([PauliX, PauliY], 0.5, _), ApplyToFirstQubitCA(X, _)];
diff --git a/Standard/src/Canon/Combinators/ApplyToArray.qs b/Standard/src/Canon/Combinators/ApplyToArray.qs
index 1d364e82a13..713966bf712 100644
--- a/Standard/src/Canon/Combinators/ApplyToArray.qs
+++ b/Standard/src/Canon/Combinators/ApplyToArray.qs
@@ -14,7 +14,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which the first will be applied to `op`.
     ///
     /// # Type Parameters
@@ -46,7 +46,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which the first will be applied to `op`.
     ///
     /// # Type Parameters
@@ -71,7 +71,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which the first will be applied to `op`.
     ///
     /// # Type Parameters
@@ -96,7 +96,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which the first will be applied to `op`.
     ///
     /// # Type Parameters
@@ -121,7 +121,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which all but the first will be applied to `op`.
     ///
     /// # Type Parameters
@@ -153,7 +153,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which all but the first will be applied to `op`.
     ///
     /// # Type Parameters
@@ -178,7 +178,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which all but the first will be applied to `op`.
     ///
     /// # Type Parameters
@@ -203,7 +203,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which all but the first will be applied to `op`.
     ///
     /// # Type Parameters
@@ -228,7 +228,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which the last will be applied to `op`.
     ///
     /// # Type Parameters
@@ -260,7 +260,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which the last will be applied to `op`.
     ///
     /// # Type Parameters
@@ -285,7 +285,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which the last will be applied to `op`.
     ///
     /// # Type Parameters
@@ -310,7 +310,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which the last will be applied to `op`.
     ///
     /// # Type Parameters
@@ -335,7 +335,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which all but the last will be applied to `op`.
     ///
     /// # Type Parameters
@@ -367,7 +367,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which all but the last will be applied to `op`.
     ///
     /// # Type Parameters
@@ -392,7 +392,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which all but the last will be applied to `op`.
     ///
     /// # Type Parameters
@@ -417,7 +417,7 @@ namespace Microsoft.Quantum.Canon {
     /// # Input
     /// ## op
     /// An operation to be applied.
-    /// ## target
+    /// ## targets
     /// An array of targets, of which all but the last will be applied to `op`.
     ///
     /// # Type Parameters
diff --git a/Standard/src/Canon/Combinators/ApplyToElement.qs b/Standard/src/Canon/Combinators/ApplyToElement.qs
index 9aaadb70263..b6ff25bade2 100644
--- a/Standard/src/Canon/Combinators/ApplyToElement.qs
+++ b/Standard/src/Canon/Combinators/ApplyToElement.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Canon {
@@ -15,7 +15,7 @@ namespace Microsoft.Quantum.Canon {
     /// An operation to be applied.
     /// ## index
     /// An index into the array of targets.
-    /// ## target
+    /// ## targets
     /// An array of possible targets for `op`.
     ///
     /// # Type Parameters
@@ -42,7 +42,7 @@ namespace Microsoft.Quantum.Canon {
     /// An operation to be applied.
     /// ## index
     /// An index into the array of targets.
-    /// ## target
+    /// ## targets
     /// An array of possible targets for `op`.
     ///
     /// # Type Parameters
@@ -69,7 +69,7 @@ namespace Microsoft.Quantum.Canon {
     /// An operation to be applied.
     /// ## index
     /// An index into the array of targets.
-    /// ## target
+    /// ## targets
     /// An array of possible targets for `op`.
     ///
     /// # Type Parameters
@@ -96,7 +96,7 @@ namespace Microsoft.Quantum.Canon {
     /// An operation to be applied.
     /// ## index
     /// An index into the array of targets.
-    /// ## target
+    /// ## targets
     /// An array of possible targets for `op`.
     ///
     /// # Type Parameters
diff --git a/Standard/src/Canon/Combinators/ApplyToFirst.qs b/Standard/src/Canon/Combinators/ApplyToFirst.qs
index 722b56cfb8e..59eb8055ee8 100644
--- a/Standard/src/Canon/Combinators/ApplyToFirst.qs
+++ b/Standard/src/Canon/Combinators/ApplyToFirst.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Canon
@@ -17,9 +17,9 @@ namespace Microsoft.Quantum.Canon
     /// Qubit array to the first qubit of which the operation is applied
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytofirstqubita"
-    /// - @"microsoft.quantum.canon.applytofirstqubitc"
-    /// - @"microsoft.quantum.canon.applytofirstqubitca"
+    /// - Microsoft.Quantum.Canon.ApplyToFirstQubitA
+    /// - Microsoft.Quantum.Canon.ApplyToFirstQubitC
+    /// - Microsoft.Quantum.Canon.ApplyToFirstQubitCA
     operation ApplyToFirstQubit (op : (Qubit => Unit), register : Qubit[]) : Unit
     {
         if (Length(register) == 0)
@@ -41,7 +41,7 @@ namespace Microsoft.Quantum.Canon
     /// Qubit array to the first qubit of which the operation is applied
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytofirstqubit"
+    /// - Microsoft.Quantum.Canon.ApplyToFirstQubit
     operation ApplyToFirstQubitA (op : (Qubit => Unit is Adj), register : Qubit[]) : Unit
     {
         body (...)
@@ -68,7 +68,7 @@ namespace Microsoft.Quantum.Canon
     /// Qubit array to the first qubit of which the operation is applied
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytofirstqubit"
+    /// - Microsoft.Quantum.Canon.ApplyToFirstQubit
     operation ApplyToFirstQubitC (op : (Qubit => Unit is Ctl), register : Qubit[]) : Unit
     {
         body (...)
@@ -95,7 +95,7 @@ namespace Microsoft.Quantum.Canon
     /// Qubit array to the first qubit of which the operation is applied
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytofirstqubit"
+    /// - Microsoft.Quantum.Canon.ApplyToFirstQubit
     operation ApplyToFirstQubitCA (op : (Qubit => Unit is Adj + Ctl), register : Qubit[]) : Unit
     {
         body (...)
@@ -130,9 +130,9 @@ namespace Microsoft.Quantum.Canon
     /// ```
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytofirsttwoqubitsa"
-    /// - @"microsoft.quantum.canon.applytofirsttwoqubitsc"
-    /// - @"microsoft.quantum.canon.applytofirsttwoqubitsca"
+    /// - Microsoft.Quantum.Canon.ApplyToFirstTwoQubitsA
+    /// - Microsoft.Quantum.Canon.ApplyToFirstTwoQubitsC
+    /// - Microsoft.Quantum.Canon.ApplyToFirstTwoQubitsCA
     operation ApplyToFirstTwoQubits (op : ((Qubit, Qubit) => Unit), register : Qubit[]) : Unit
     {
         if (Length(register) < 2)
@@ -161,7 +161,7 @@ namespace Microsoft.Quantum.Canon
     /// ```
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytofirsttwoqubits"
+    /// - Microsoft.Quantum.Canon.ApplyToFirstTwoQubits
     operation ApplyToFirstTwoQubitsA (op : ((Qubit, Qubit) => Unit is Adj), register : Qubit[]) : Unit
     {
         body (...)
@@ -195,7 +195,7 @@ namespace Microsoft.Quantum.Canon
     /// ```
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytofirsttwoqubits"
+    /// - Microsoft.Quantum.Canon.ApplyToFirstTwoQubits
     operation ApplyToFirstTwoQubitsC (op : ((Qubit, Qubit) => Unit is Ctl), register : Qubit[]) : Unit
     {
         body (...)
@@ -229,7 +229,7 @@ namespace Microsoft.Quantum.Canon
     /// ```
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytofirsttwoqubits"
+    /// - Microsoft.Quantum.Canon.ApplyToFirstTwoQubits
     operation ApplyToFirstTwoQubitsCA (op : ((Qubit, Qubit) => Unit is Adj + Ctl), register : Qubit[]) : Unit
     {
         body (...)
diff --git a/Standard/src/Canon/Combinators/ApplyToPartition.qs b/Standard/src/Canon/Combinators/ApplyToPartition.qs
index e5e2493a74a..f6c5217dba2 100644
--- a/Standard/src/Canon/Combinators/ApplyToPartition.qs
+++ b/Standard/src/Canon/Combinators/ApplyToPartition.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Canon {
@@ -18,10 +18,10 @@ namespace Microsoft.Quantum.Canon {
     /// given two operation.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytopartitiona"
-    /// - @"microsoft.quantum.canon.applytopartitionc"
-    /// - @"microsoft.quantum.canon.applytopartitionca"
-    operation ApplyToPartition (op : ((Qubit[], Qubit[]) => Unit), numberOfQubitsToFirstArgument : Int, target : Qubit[]) : Unit
+    /// - Microsoft.Quantum.Canon.ApplyToPartitionA
+    /// - Microsoft.Quantum.Canon.ApplyToPartitionC
+    /// - Microsoft.Quantum.Canon.ApplyToPartitionCA
+    operation ApplyToPartition(op : ((Qubit[], Qubit[]) => Unit), numberOfQubitsToFirstArgument : Int, target : Qubit[]) : Unit
     {
         EqualityFactB(numberOfQubitsToFirstArgument >= 0, true, $"numberOfQubitsToFirstArgument must be non-negative");
         EqualityFactB(Length(target) >= numberOfQubitsToFirstArgument, true, $"Length(target) must greater or equal to numberOfQubitsToFirstArgument");
@@ -44,7 +44,7 @@ namespace Microsoft.Quantum.Canon {
     /// given two operation.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytopartition"
+    /// - Microsoft.Quantum.Canon.ApplyToPartition
     operation ApplyToPartitionA (op : ((Qubit[], Qubit[]) => Unit is Adj), numberOfQubitsToFirstArgument : Int, target : Qubit[]) : Unit
     {
         body (...)
@@ -73,7 +73,7 @@ namespace Microsoft.Quantum.Canon {
     /// given two operation.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytopartition"
+    /// - Microsoft.Quantum.Canon.ApplyToPartition
     operation ApplyToPartitionC (op : ((Qubit[], Qubit[]) => Unit is Ctl), numberOfQubitsToFirstArgument : Int, target : Qubit[]) : Unit
     {
         body (...)
@@ -102,7 +102,7 @@ namespace Microsoft.Quantum.Canon {
     /// given two operation.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytopartition"
+    /// - Microsoft.Quantum.Canon.ApplyToPartition
     operation ApplyToPartitionCA (op : ((Qubit[], Qubit[]) => Unit is Ctl + Adj), numberOfQubitsToFirstArgument : Int, target : Qubit[]) : Unit
     {
         body (...)
diff --git a/Standard/src/Canon/Combinators/Curry.qs b/Standard/src/Canon/Combinators/Curry.qs
index 0d40e13f6db..e4a2fb5a60e 100644
--- a/Standard/src/Canon/Combinators/Curry.qs
+++ b/Standard/src/Canon/Combinators/Curry.qs
@@ -68,9 +68,9 @@ namespace Microsoft.Quantum.Canon {
     /// ## 'U
     /// The type of the second input to a curried operation.
     /// # See Also
-    /// - @"microsoft.quantum.canon.uncurryopc"
-    /// - @"microsoft.quantum.canon.uncurryopa"
-    /// - @"microsoft.quantum.canon.uncurryopca"
+    /// - Microsoft.Quantum.Canon.UncurriedOpC
+    /// - Microsoft.Quantum.Canon.UncurriedOpA
+    /// - Microsoft.Quantum.Canon.UncurriedOpCA
     function UncurriedOp<'T, 'U> (curriedOp : ('T -> ('U => Unit))) : (('T, 'U) => Unit) {
         return ApplyCurriedOp(curriedOp, _, _);
     }
@@ -104,7 +104,7 @@ namespace Microsoft.Quantum.Canon {
     /// The type of the second argument of a curried function.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.uncurryop"
+    /// - Microsoft.Quantum.Canon.UncurriedOp
     function UncurriedOpC<'T, 'U> (curriedOp : ('T -> ('U => Unit is Ctl)))
     : (('T, 'U) => Unit is Ctl) {
         return ApplyCurriedOpC(curriedOp, _, _);
@@ -139,7 +139,7 @@ namespace Microsoft.Quantum.Canon {
     /// The type of the second argument of a curried function.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.uncurryop"
+    /// - Microsoft.Quantum.Canon.UncurriedOp
     function UncurriedOpA<'T, 'U> (curriedOp : ('T -> ('U => Unit is Adj))) : (('T, 'U) => Unit is Adj) {
         return ApplyCurriedOpA(curriedOp, _, _);
     }
@@ -173,7 +173,7 @@ namespace Microsoft.Quantum.Canon {
     /// The type of the second argument of a curried function.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.uncurryop"
+    /// - Microsoft.Quantum.Canon.UncurriedOp
     function UncurriedOpCA<'T, 'U> (curriedOp : ('T -> ('U => Unit is Ctl + Adj))) : (('T, 'U) => Unit is Ctl + Adj) {
         return ApplyCurriedOpCA(curriedOp, _, _);
     }
diff --git a/Standard/src/Canon/Combinators/Delay.qs b/Standard/src/Canon/Combinators/Delay.qs
index bd85c658695..d908013d479 100644
--- a/Standard/src/Canon/Combinators/Delay.qs
+++ b/Standard/src/Canon/Combinators/Delay.qs
@@ -1,8 +1,7 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-namespace Microsoft.Quantum.Canon
-{
+namespace Microsoft.Quantum.Canon {
 
     /// # Summary
     /// Applies a given operation with a delay.
@@ -34,7 +33,7 @@ namespace Microsoft.Quantum.Canon
     /// - Microsoft.Quantum.Canon.DelayA
     /// - Microsoft.Quantum.Canon.DelayCA
     /// - Microsoft.Quantum.Canon.Delayed
-    operation Delay<'T, 'U> ( op : ('T => 'U), arg : 'T, aux : Unit) : 'U {
+    operation Delay<'T, 'U> (op : ('T => 'U), arg : 'T, aux : Unit) : 'U {
         return op(arg);
     }
 
@@ -157,7 +156,7 @@ namespace Microsoft.Quantum.Canon
     /// # See Also
     /// - Microsoft.Quantum.Canon.DelayedC
     /// - Microsoft.Quantum.Canon.DelayedA
-    /// - Microsoft.Quantum.Canon.DelayedCA    
+    /// - Microsoft.Quantum.Canon.DelayedCA
     /// - Microsoft.Quantum.Canon.Delay
     function Delayed<'T, 'U> ( op : ('T => 'U), arg : 'T) : (Unit => 'U) {
         return Delay(op, arg, _);
diff --git a/Standard/src/Canon/Combinators/OperationPow.qs b/Standard/src/Canon/Combinators/OperationPow.qs
index 0e797d2b9c5..b2b1adb0a52 100644
--- a/Standard/src/Canon/Combinators/OperationPow.qs
+++ b/Standard/src/Canon/Combinators/OperationPow.qs
@@ -55,9 +55,9 @@ namespace Microsoft.Quantum.Canon {
     /// The type of the operation to be powered.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.operationpowc"
-    /// - @"microsoft.quantum.canon.operationpowa"
-    /// - @"microsoft.quantum.canon.operationpowca"
+    /// - Microsoft.Quantum.Canon.OperationPowC
+    /// - Microsoft.Quantum.Canon.OperationPowA
+    /// - Microsoft.Quantum.Canon.OperationPowCA
     function OperationPow<'T> (op : ('T => Unit), power : Int) : ('T => Unit) {
         return ApplyOperationRepeatedly(op, power, _);
     }
@@ -84,7 +84,7 @@ namespace Microsoft.Quantum.Canon {
     /// The type of the operation to be powered.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.operationpow"
+    /// - Microsoft.Quantum.Canon.OperationPow
     function OperationPowC<'T> (op : ('T => Unit is Ctl), power : Int) : ('T => Unit is Ctl) {
         return ApplyOperationRepeatedlyC(op, power, _);
     }
@@ -111,7 +111,7 @@ namespace Microsoft.Quantum.Canon {
     /// The type of the operation to be powered.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.operationpow"
+    /// - Microsoft.Quantum.Canon.OperationPow
     function OperationPowA<'T> (op : ('T => Unit is Adj), power : Int) : ('T => Unit is Adj) {
         return ApplyOperationRepeatedlyA(op, power, _);
     }
@@ -138,7 +138,7 @@ namespace Microsoft.Quantum.Canon {
     /// The type of the operation to be powered.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.operationpow"
+    /// - Microsoft.Quantum.Canon.OperationPow
     function OperationPowCA<'T> (op : ('T => Unit is Ctl + Adj), power : Int) : ('T => Unit is Ctl + Adj) {
         return ApplyOperationRepeatedlyCA(op, power, _);
     }
diff --git a/Standard/src/Canon/Combinators/RestrictedToSubregister.qs b/Standard/src/Canon/Combinators/RestrictedToSubregister.qs
index de603b9631f..e7c937a98d3 100644
--- a/Standard/src/Canon/Combinators/RestrictedToSubregister.qs
+++ b/Standard/src/Canon/Combinators/RestrictedToSubregister.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Canon {
@@ -26,9 +26,9 @@ namespace Microsoft.Quantum.Canon {
     /// ```
     ///
     /// # See Also
-    /// - ApplyToSubregisterA
-    /// - ApplyToSubregisterC
-    /// - ApplyToSubregisterCA
+    /// - Microsoft.Quantum.Canon.ApplyToSubregisterA
+    /// - Microsoft.Quantum.Canon.ApplyToSubregisterC
+    /// - Microsoft.Quantum.Canon.ApplyToSubregisterCA
     operation ApplyToSubregister (op : (Qubit[] => Unit), idxs : Int[], target : Qubit[]) : Unit {
         let subregister = Subarray(idxs, target);
         op(subregister);
@@ -49,7 +49,7 @@ namespace Microsoft.Quantum.Canon {
     /// Register on which the operation acts.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytosubregister"
+    /// - Microsoft.Quantum.Canon.ApplyToSubregister
     operation ApplyToSubregisterA (op : (Qubit[] => Unit is Adj), idxs : Int[], target : Qubit[]) : Unit
     {
         body (...)
@@ -78,7 +78,7 @@ namespace Microsoft.Quantum.Canon {
     /// Register on which the operation acts.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytosubregister"
+    /// - Microsoft.Quantum.Canon.ApplyToSubregister
     operation ApplyToSubregisterC (op : (Qubit[] => Unit is Ctl), idxs : Int[], target : Qubit[]) : Unit
     {
         body (...)
@@ -108,7 +108,7 @@ namespace Microsoft.Quantum.Canon {
     /// Register on which the operation acts.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.applytosubregister"
+    /// - Microsoft.Quantum.Canon.ApplyToSubregister
     operation ApplyToSubregisterCA (op : (Qubit[] => Unit is Ctl + Adj), idxs : Int[], target : Qubit[]) : Unit
     {
         body (...)
@@ -143,8 +143,6 @@ namespace Microsoft.Quantum.Canon {
     /// Operation to be restricted to a subregister.
     /// ## idxs
     /// Array of indices, indicating to which qubits the operation will be restricted.
-    /// ## target
-    /// Register on which the operation acts.
     ///
     /// # See Also
     /// - Microsoft.Quantum.Canon.RestrictedToSubregisterA
@@ -164,11 +162,9 @@ namespace Microsoft.Quantum.Canon {
     /// Operation to be restricted to a subregister.
     /// ## idxs
     /// Array of indices, indicating to which qubits the operation will be restricted.
-    /// ## target
-    /// Register on which the operation acts.
     ///
     /// # See Also
-    /// - RestrictedToSubregister
+    /// - Microsoft.Quantum.Canon.RestrictedToSubregister
     function RestrictedToSubregisterA (op : (Qubit[] => Unit is Adj), idxs : Int[]) : (Qubit[] => Unit is Adj)
     {
         return ApplyToSubregisterA(op, idxs, _);
@@ -184,8 +180,6 @@ namespace Microsoft.Quantum.Canon {
     /// Operation to be restricted to a subregister.
     /// ## idxs
     /// Array of indices, indicating to which qubits the operation will be restricted.
-    /// ## target
-    /// Register on which the operation acts.
     ///
     /// # See Also
     /// - Microsoft.Quantum.Canon.RestrictedToSubregister
@@ -204,8 +198,6 @@ namespace Microsoft.Quantum.Canon {
     /// Operation to be restricted to a subregister.
     /// ## idxs
     /// Array of indices, indicating to which qubits the operation will be restricted.
-    /// ## target
-    /// Register on which the operation acts.
     ///
     /// # See Also
     /// - Microsoft.Quantum.Canon.RestrictedToSubregister
diff --git a/Standard/src/Canon/Combinators/Transformed.qs b/Standard/src/Canon/Combinators/Transformed.qs
index ff6aaa8acc4..3751f68a5ec 100644
--- a/Standard/src/Canon/Combinators/Transformed.qs
+++ b/Standard/src/Canon/Combinators/Transformed.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Canon {
@@ -21,10 +21,10 @@ namespace Microsoft.Quantum.Canon {
     /// An input to the function.
     ///
     /// # See Also
-    /// - ApplyWithInputTransformationA
-    /// - ApplyWithInputTransformationC
-    /// - ApplyWithInputTransformationCA
-    /// - TransformedOperation
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformationA
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformationC
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformationCA
+    /// - Microsoft.Quantum.Canon.TransformedOperation
     ///
     /// # Example
     /// The following call uses
@@ -55,11 +55,11 @@ namespace Microsoft.Quantum.Canon {
     /// resulting output to `op`.
     ///
     /// # See Also
-    /// - TransformedOperationA
-    /// - TransformedOperationC
-    /// - TransformedOperationCA
-    /// - ApplyWithInputTransformation
-    /// - Compose
+    /// - Microsoft.Quantum.Canon.TransformedOperationA
+    /// - Microsoft.Quantum.Canon.TransformedOperationC
+    /// - Microsoft.Quantum.Canon.TransformedOperationCA
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformation
+    /// - Microsoft.Quantum.Canon.Composed
     ///
     /// # Example
     /// The following call uses
@@ -96,10 +96,10 @@ namespace Microsoft.Quantum.Canon {
     /// An input to the function.
     ///
     /// # See Also
-    /// - ApplyWithInputTransformation
-    /// - ApplyWithInputTransformationC
-    /// - ApplyWithInputTransformationCA
-    /// - TransformedOperation
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformation
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformationC
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformationCA
+    /// - Microsoft.Quantum.Canon.TransformedOperation
     ///
     /// # Example
     /// The following call uses
@@ -131,11 +131,11 @@ namespace Microsoft.Quantum.Canon {
     /// resulting output to `op`.
     ///
     /// # See Also
-    /// - TransformedOperation
-    /// - TransformedOperationC
-    /// - TransformedOperationCA
-    /// - ApplyWithInputTransformation
-    /// - Compose
+    /// - Microsoft.Quantum.Canon.TransformedOperation
+    /// - Microsoft.Quantum.Canon.TransformedOperationC
+    /// - Microsoft.Quantum.Canon.TransformedOperationCA
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformation
+    /// - Microsoft.Quantum.Canon.Composed
     ///
     /// # Example
     /// The following call uses
@@ -173,10 +173,10 @@ namespace Microsoft.Quantum.Canon {
     /// An input to the function.
     ///
     /// # See Also
-    /// - ApplyWithInputTransformation
-    /// - ApplyWithInputTransformationA
-    /// - ApplyWithInputTransformationCA
-    /// - TransformedOperation
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformation
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformationA
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformationCA
+    /// - Microsoft.Quantum.Canon.TransformedOperation
     ///
     /// # Example
     /// The following call uses
@@ -208,11 +208,11 @@ namespace Microsoft.Quantum.Canon {
     /// resulting output to `op`.
     ///
     /// # See Also
-    /// - TransformedOperation
-    /// - TransformedOperationA
-    /// - TransformedOperationCA
-    /// - ApplyWithInputTransformation
-    /// - Compose
+    /// - Microsoft.Quantum.Canon.TransformedOperation
+    /// - Microsoft.Quantum.Canon.TransformedOperationA
+    /// - Microsoft.Quantum.Canon.TransformedOperationCA
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformation
+    /// - Microsoft.Quantum.Canon.Composed
     ///
     /// # Example
     /// The following call uses
@@ -249,10 +249,10 @@ namespace Microsoft.Quantum.Canon {
     /// An input to the function.
     ///
     /// # See Also
-    /// - ApplyWithInputTransformation
-    /// - ApplyWithInputTransformationA
-    /// - ApplyWithInputTransformationC
-    /// - TransformedOperation
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformation
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformationA
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformationC
+    /// - Microsoft.Quantum.Canon.TransformedOperation
     ///
     /// # Example
     /// The following call uses
@@ -286,11 +286,11 @@ namespace Microsoft.Quantum.Canon {
     /// resulting output to `op`.
     ///
     /// # See Also
-    /// - TransformedOperation
-    /// - TransformedOperationA
-    /// - TransformedOperationCA
-    /// - ApplyWithInputTransformation
-    /// - Compose
+    /// - Microsoft.Quantum.Canon.TransformedOperation
+    /// - Microsoft.Quantum.Canon.TransformedOperationA
+    /// - Microsoft.Quantum.Canon.TransformedOperationCA
+    /// - Microsoft.Quantum.Canon.ApplyWithInputTransformation
+    /// - Microsoft.Quantum.Canon.Composed
     ///
     /// # Example
     /// The following call uses
diff --git a/Standard/src/Canon/Combinators/With.qs b/Standard/src/Canon/Combinators/With.qs
index 08908862352..3535c6e7690 100644
--- a/Standard/src/Canon/Combinators/With.qs
+++ b/Standard/src/Canon/Combinators/With.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Canon {
@@ -33,14 +33,15 @@ namespace Microsoft.Quantum.Canon {
     /// controllable.
     ///
     /// # See Also
-    /// - ApplyWithA
-    /// - ApplyWithC
-    /// - ApplyWithCA
+    /// - Microsoft.Quantum.Canon.ApplyWithA
+    /// - Microsoft.Quantum.Canon.ApplyWithC
+    /// - Microsoft.Quantum.Canon.ApplyWithCA
     operation ApplyWith<'T>(outerOperation : ('T => Unit is Adj), innerOperation : ('T => Unit), target : 'T) : Unit {
         outerOperation(target);
         innerOperation(target);
         Adjoint outerOperation(target);
     }
+
     /// # Summary
     /// Given outer and inner operations, returns a new operation that
     /// conjugates the inner operation by the outer operation.
@@ -68,10 +69,10 @@ namespace Microsoft.Quantum.Canon {
     /// controllable.
     ///
     /// # See Also
-    /// - ConjugatedByA
-    /// - ConjugatedByC
-    /// - ConjugatedByCA
-    /// - ApplyWith
+    /// - Microsoft.Quantum.Canon.ConjugatedByA
+    /// - Microsoft.Quantum.Canon.ConjugatedByC
+    /// - Microsoft.Quantum.Canon.ConjugatedByCA
+    /// - Microsoft.Quantum.Canon.ApplyWith
     function ConjugatedBy<'T>(outerOperation : ('T => Unit is Adj), innerOperation : ('T => Unit)) : ('T => Unit) {
         return ApplyWith(outerOperation, innerOperation, _);
     }
@@ -105,9 +106,9 @@ namespace Microsoft.Quantum.Canon {
     /// controllable.
     ///
     /// # See Also
-    /// - ApplyWith
-    /// - ApplyWithC
-    /// - ApplyWithCA
+    /// - Microsoft.Quantum.Canon.ApplyWith
+    /// - Microsoft.Quantum.Canon.ApplyWithC
+    /// - Microsoft.Quantum.Canon.ApplyWithCA
     operation ApplyWithA<'T>(outerOperation : ('T => Unit is Adj), innerOperation : ('T => Unit is Adj), target : 'T) : Unit {
         body (...) {
             outerOperation(target);
@@ -145,10 +146,10 @@ namespace Microsoft.Quantum.Canon {
     /// controllable.
     ///
     /// # See Also
-    /// - ConjugatedByA
-    /// - ConjugatedByC
-    /// - ConjugatedByCA
-    /// - ApplyWith
+    /// - Microsoft.Quantum.Canon.ConjugatedByA
+    /// - Microsoft.Quantum.Canon.ConjugatedByC
+    /// - Microsoft.Quantum.Canon.ConjugatedByCA
+    /// - Microsoft.Quantum.Canon.ApplyWith
     function ConjugatedByA<'T>(outerOperation : ('T => Unit is Adj), innerOperation : ('T => Unit is Adj)) : ('T => Unit is Adj) {
         return ApplyWithA(outerOperation, innerOperation, _);
     }
@@ -182,9 +183,9 @@ namespace Microsoft.Quantum.Canon {
     /// controllable.
     ///
     /// # See Also
-    /// - ApplyWith
-    /// - ApplyWithA
-    /// - ApplyWithCA
+    /// - Microsoft.Quantum.Canon.ApplyWith
+    /// - Microsoft.Quantum.Canon.ApplyWithA
+    /// - Microsoft.Quantum.Canon.ApplyWithCA
     operation ApplyWithC<'T>(outerOperation : ('T => Unit is Adj), innerOperation : ('T => Unit is Ctl), target : 'T) : Unit {
         body (...) {
             outerOperation(target);
@@ -226,10 +227,10 @@ namespace Microsoft.Quantum.Canon {
     /// controllable.
     ///
     /// # See Also
-    /// - ConjugatedBy
-    /// - ConjugatedByA
-    /// - ConjugatedByCA
-    /// - ApplyWith
+    /// - Microsoft.Quantum.Canon.ConjugatedBy
+    /// - Microsoft.Quantum.Canon.ConjugatedByA
+    /// - Microsoft.Quantum.Canon.ConjugatedByCA
+    /// - Microsoft.Quantum.Canon.ApplyWith
     function ConjugatedByC<'T>(outerOperation : ('T => Unit is Adj), innerOperation : ('T => Unit is Ctl)) : ('T => Unit is Ctl) {
         return ApplyWithC(outerOperation, innerOperation, _);
     }
@@ -264,9 +265,9 @@ namespace Microsoft.Quantum.Canon {
     /// controllable.
     ///
     /// # See Also
-    /// - ApplyWith
-    /// - ApplyWithA
-    /// - ApplyWithC
+    /// - Microsoft.Quantum.Canon.ApplyWith
+    /// - Microsoft.Quantum.Canon.ApplyWithA
+    /// - Microsoft.Quantum.Canon.ApplyWithC
     operation ApplyWithCA<'T>(outerOperation : ('T => Unit is Adj), innerOperation : ('T => Unit is Adj + Ctl), target : 'T) : Unit {
         body (...) {
             outerOperation(target);
@@ -313,10 +314,10 @@ namespace Microsoft.Quantum.Canon {
     /// controllable.
     ///
     /// # See Also
-    /// - ConjugatedByA
-    /// - ConjugatedByC
-    /// - ConjugatedByCA
-    /// - ApplyWith
+    /// - Microsoft.Quantum.Canon.ConjugatedByA
+    /// - Microsoft.Quantum.Canon.ConjugatedByC
+    /// - Microsoft.Quantum.Canon.ConjugatedByCA
+    /// - Microsoft.Quantum.Canon.ApplyWith
     function ConjugatedByCA<'T>(outerOperation : ('T => Unit is Adj), innerOperation : ('T => Unit is Adj + Ctl)) : ('T => Unit is Adj + Ctl) {
         return ApplyWithCA(outerOperation, innerOperation, _);
     }
diff --git a/Standard/src/Canon/CommonGates.qs b/Standard/src/Canon/CommonGates.qs
index 65e755f6bd5..0217dbb822e 100644
--- a/Standard/src/Canon/CommonGates.qs
+++ b/Standard/src/Canon/CommonGates.qs
@@ -146,7 +146,7 @@ namespace Microsoft.Quantum.Canon {
     ///
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.qft"
+    /// - Microsoft.Quantum.Canon.QFT
     operation QFTLE(qs : LittleEndian) : Unit {
         body (...) {
             ApplyQuantumFourierTransform(qs);
@@ -223,6 +223,7 @@ namespace Microsoft.Quantum.Canon {
     /// Qubit to which the gate should be applied.
     ///
     /// # See Also
+    /// - Microsoft.Quantum.Intrinsic.H
     operation HY (target : Qubit) : Unit {
         body (...) {
             H(target);
diff --git a/Standard/src/Canon/Enumeration/Trotter.qs b/Standard/src/Canon/Enumeration/Trotter.qs
index 853b464a3ad..0f1f5aff7bd 100644
--- a/Standard/src/Canon/Enumeration/Trotter.qs
+++ b/Standard/src/Canon/Enumeration/Trotter.qs
@@ -14,9 +14,9 @@ namespace Microsoft.Quantum.Canon {
     /// `Qubit[]` or `Qubit`.
     ///
     /// # Input
-    /// ### nSteps
+    /// ## nSteps
     /// The number of operations to be decomposed into time steps.
-    /// ### op
+    /// ## op
     /// An operation which accepts an index input (type `Int`) and a time
     /// input (type `Double`) and a quantum register (type `'T`) for decomposition.
     /// ## stepSize
@@ -51,9 +51,9 @@ namespace Microsoft.Quantum.Canon {
     /// `Qubit[]` or `Qubit`.
     ///
     /// # Input
-    /// ### nSteps
+    /// ## nSteps
     /// The number of operations to be decomposed into time steps.
-    /// ### op
+    /// ## op
     /// An operation which accepts an index input (type `Int`) and a time
     /// input (type `Double`) and a quantum register (type `'T`) for decomposition.
     /// ## stepSize
@@ -97,11 +97,11 @@ namespace Microsoft.Quantum.Canon {
     /// `Qubit[]` or `Qubit`.
     ///
     /// # Input
-    /// ### Order
+    /// ## order
     /// Order of Trotter-Suzuki integrator.
-    /// ### nSteps
+    /// ## nSteps
     /// The number of operations to be decomposed into time steps.
-    /// ### op
+    /// ## op
     /// An operation which accepts an index input (type `Int`) and a time
     /// input (type `Double`) and a quantum register (type `'T`) for decomposition.
     /// ## stepSize
diff --git a/Standard/src/Canon/Parity.qs b/Standard/src/Canon/Parity.qs
index 74e32a9b46f..59607868c88 100644
--- a/Standard/src/Canon/Parity.qs
+++ b/Standard/src/Canon/Parity.qs
@@ -51,7 +51,7 @@ namespace Microsoft.Quantum.Canon {
             "Target register must have one more qubit."
         );
 
-        ApplyToEachCA(CCNOT, Zip3(register, Most(targets), Rest(targets)));
+        ApplyToEachCA(CCNOT, Zipped3(register, Most(targets), Rest(targets)));
     }
 
 
diff --git a/Standard/src/Canon/QFT.qs b/Standard/src/Canon/QFT.qs
index 295e9af3815..edaee44337b 100644
--- a/Standard/src/Canon/QFT.qs
+++ b/Standard/src/Canon/QFT.qs
@@ -85,7 +85,7 @@ namespace Microsoft.Quantum.Canon {
     ///
     ///
     /// # See Also
-    /// - ApplyQuantumFourierTransformBE
+    /// - Microsoft.Quantum.Canon.ApplyQuantumFourierTransformBE
     operation ApplyQuantumFourierTransform(qs : LittleEndian) : Unit is Adj + Ctl {
         ApplyReversedOpBECA(ApplyQuantumFourierTransformBE, qs);
     }
diff --git a/Standard/src/Canon/Utils/Multiplexer.qs b/Standard/src/Canon/Utils/Multiplexer.qs
index 3206175f2ce..5777e6bd31b 100644
--- a/Standard/src/Canon/Utils/Multiplexer.qs
+++ b/Standard/src/Canon/Utils/Multiplexer.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Canon {
@@ -43,7 +43,7 @@ namespace Microsoft.Quantum.Canon {
     /// fewer than $2^n$ are specified.
     ///
     /// # See Also
-    /// - ApproximatelyMultiplexPauli
+    /// - Microsoft.Quantum.Canon.ApproximatelyMultiplexPauli
     operation MultiplexPauli(coefficients : Double[], pauli : Pauli, control : LittleEndian, target : Qubit)
     : Unit is Adj + Ctl {
         ApproximatelyMultiplexPauli(0.0, coefficients, pauli, control, target);
@@ -89,7 +89,7 @@ namespace Microsoft.Quantum.Canon {
     /// fewer than $2^n$ are specified.
     ///
     /// # See Also
-    /// - MultiplexPauli
+    /// - Microsoft.Quantum.Canon.MultiplexPauli
     operation ApproximatelyMultiplexPauli(tolerance : Double, coefficients : Double[], pauli : Pauli, control : LittleEndian, target : Qubit)
     : Unit is Adj + Ctl {
         if (pauli == PauliZ) {
@@ -145,7 +145,7 @@ namespace Microsoft.Quantum.Canon {
     ///   https://arxiv.org/abs/quant-ph/0406176
     ///
     /// # See Also
-    /// - ApproximatelyMultiplexZ
+    /// - Microsoft.Quantum.Canon.ApproximatelyMultiplexZ
     operation MultiplexZ(coefficients : Double[], control : LittleEndian, target : Qubit)
     : Unit is Adj + Ctl {
         ApproximatelyMultiplexZ(0.0, coefficients, control, target);
@@ -212,7 +212,7 @@ namespace Microsoft.Quantum.Canon {
     ///   https://arxiv.org/abs/quant-ph/0406176
     ///
     /// # See Also
-    /// - MultiplexZ
+    /// - Microsoft.Quantum.Canon.MultiplexZ
     operation ApproximatelyMultiplexZ(tolerance : Double, coefficients : Double[], control : LittleEndian, target : Qubit) : Unit is Adj + Ctl {
         body (...) {
             // pad coefficients length at tail to a power of 2.
@@ -271,8 +271,7 @@ namespace Microsoft.Quantum.Canon {
     /// ## coefficients
     /// Array of up to $2^n$ coefficients $\theta_j$. The $j$th coefficient
     /// indexes the number state $\ket{j}$ encoded in little-endian format.
-    ///
-    /// ## control
+    /// ## qubits
     /// $n$-qubit control register that encodes number states $\ket{j}$ in
     /// little-endian format.
     ///
@@ -286,7 +285,7 @@ namespace Microsoft.Quantum.Canon {
     ///   https://arxiv.org/abs/quant-ph/0406176
     ///
     /// # See Also
-    /// - ApproximatelyApplyDiagonalUnitary
+    /// - Microsoft.Quantum.Canon.ApproximatelyApplyDiagonalUnitary
     operation ApplyDiagonalUnitary(coefficients : Double[], qubits : LittleEndian) : Unit is Adj + Ctl {
         ApproximatelyApplyDiagonalUnitary(0.0, coefficients, qubits);
     }
@@ -315,7 +314,7 @@ namespace Microsoft.Quantum.Canon {
     /// Array of up to $2^n$ coefficients $\theta_j$. The $j$th coefficient
     /// indexes the number state $\ket{j}$ encoded in little-endian format.
     ///
-    /// ## control
+    /// ## qubits
     /// $n$-qubit control register that encodes number states $\ket{j}$ in
     /// little-endian format.
     ///
@@ -329,7 +328,7 @@ namespace Microsoft.Quantum.Canon {
     ///   https://arxiv.org/abs/quant-ph/0406176
     ///
     /// # See Also
-    /// - ApplyDiagonalUnitary
+    /// - Microsoft.Quantum.Canon.ApplyDiagonalUnitary
     operation ApproximatelyApplyDiagonalUnitary(tolerance : Double, coefficients : Double[], qubits : LittleEndian)
     : Unit is Adj + Ctl {
         if (IsEmpty(qubits!)) {
diff --git a/Standard/src/Convert/Convert.qs b/Standard/src/Convert/Convert.qs
index 85a89b88367..26b6e157a07 100644
--- a/Standard/src/Convert/Convert.qs
+++ b/Standard/src/Convert/Convert.qs
@@ -185,8 +185,6 @@ namespace Microsoft.Quantum.Convert {
     /// apply Pauli if bit is this value.
     /// ## bits
     /// Boolean array.
-    /// ## qubits
-    /// Quantum register to which a Pauli operator is to be applied.
     ///
     /// # Remarks
     /// The Boolean array and the quantum register must be of equal length.
diff --git a/Standard/src/ErrorCorrection/5QubitCode.qs b/Standard/src/ErrorCorrection/5QubitCode.qs
index 9912317434b..27fdd63d52d 100644
--- a/Standard/src/ErrorCorrection/5QubitCode.qs
+++ b/Standard/src/ErrorCorrection/5QubitCode.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.ErrorCorrection {
@@ -18,8 +18,7 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// # Remarks
     /// The particular encoder chosen was taken from the paper V. Kliuchnikov and D. Maslov, "Optimization of Clifford Circuits,"
     /// Phys. Rev. Phys. Rev. A 88, 052307 (2013); https://arxiv.org/abs/1305.0810, Figure 4b) and requires a total of 11 gates.
-    operation FiveQubitCodeEncoderImpl (data : Qubit[], scratch : Qubit[]) : Unit
-    {
+    operation FiveQubitCodeEncoderImpl (data : Qubit[], scratch : Qubit[]) : Unit {
         body (...) {
             Controlled X(data, scratch[1]);
             H(data[0]);
@@ -61,9 +60,8 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// ordering in the table lookup recovery is given by converting the bitvectors to integers (using little endian).
     ///
     /// # See Also
-    /// - RecoveryFn
-    function FiveQubitCodeRecoveryFn () : RecoveryFn
-    {
+    /// - Microsoft.Quantum.ErrorCorrection.RecoveryFn
+    function FiveQubitCodeRecoveryFn () : RecoveryFn {
         return TableLookupRecovery(
             [
                 [PauliI, PauliI, PauliI, PauliI, PauliI],
@@ -102,7 +100,7 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// encoded state.
     ///
     /// # See Also
-    /// - LogicalRegister
+    /// - Microsoft.Quantum.ErrorCorrection.LogicalRegister
     operation EncodeIntoFiveQubitCode(physRegister : Qubit[], auxQubits : Qubit[]) : LogicalRegister {
         FiveQubitCodeEncoderImpl(physRegister, auxQubits);
         let logicalRegister = LogicalRegister(physRegister + auxQubits);
@@ -121,8 +119,8 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// first parameter, together with auxiliary qubits in the second parameter.
     ///
     /// # See Also
-    /// - FiveQubitCodeEncoder
-    /// - LogicalRegister
+    /// - Microsoft.Quantum.ErrorCorrection.FiveQubitCodeEncoder
+    /// - Microsoft.Quantum.ErrorCorrection.LogicalRegister
     operation DecodeFromFiveQubitCode(logicalRegister : LogicalRegister) : (Qubit[], Qubit[]) {
         let physRegister = [(logicalRegister!)[0]];
         let auxQubits = (logicalRegister!)[1 .. 4];
diff --git a/Standard/src/ErrorCorrection/7QubitCode.qs b/Standard/src/ErrorCorrection/7QubitCode.qs
index c749a252ade..07ba6afb795 100644
--- a/Standard/src/ErrorCorrection/7QubitCode.qs
+++ b/Standard/src/ErrorCorrection/7QubitCode.qs
@@ -52,8 +52,8 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// to be applied is the 3-bit encoding of the X, respectively, Z syndrome when considered an integer.
     ///
     /// # See Also
-    /// - SteaneCodeRecoveryX
-    /// - SteaneCodeRecoveryFns
+    /// - Microsoft.Quantum.ErrorCorrection.SteaneCodeRecoveryX
+    /// - Microsoft.Quantum.ErrorCorrection.SteaneCodeRecoveryFns
     ///
     /// # References
     /// - D. Gottesman, "Stabilizer Codes and Quantum Error Correction," Ph.D. Thesis, Caltech, 1997;
@@ -69,8 +69,8 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// Decoder for the Z-part of the stabilizer group of the ⟦7, 1, 3⟧ Steane quantum code.
     ///
     /// # See Also
-    /// - SteaneCodeRecoveryX
-    /// - SteaneCodeRecoveryFns
+    /// - Microsoft.Quantum.ErrorCorrection.SteaneCodeRecoveryX
+    /// - Microsoft.Quantum.ErrorCorrection.SteaneCodeRecoveryFns
     function SteaneCodeRecoveryZ (syndrome : Syndrome) : Pauli[] {
         let idxQubit = ResultArrayAsInt(syndrome!);
         return idxQubit == 0
@@ -88,8 +88,8 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// corrects the detected error.
     ///
     /// # See Also
-    /// - SteaneCodeRecoveryX
-    /// - SteaneCodeRecoveryZ
+    /// - Microsoft.Quantum.ErrorCorrection.SteaneCodeRecoveryX
+    /// - Microsoft.Quantum.ErrorCorrection.SteaneCodeRecoveryZ
     function SteaneCodeRecoveryFns () : (RecoveryFn, RecoveryFn)
     {
         return (RecoveryFn(SteaneCodeRecoveryX), RecoveryFn(SteaneCodeRecoveryZ));
@@ -111,8 +111,8 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// A quantum register holding the state after the Steane encoder has been applied
     ///
     /// # See Also
-    /// - LogicalRegister
-    /// - SteaneCodeDecoder
+    /// - Microsoft.Quantum.ErrorCorrection.LogicalRegister
+    /// - Microsoft.Quantum.ErrorCorrection.SteaneCodeDecoder
     operation EncodeIntoSteaneCode(physRegister : Qubit[], auxQubits : Qubit[]) : LogicalRegister
     {
         SteaneCodeEncoderImpl(physRegister, auxQubits);
@@ -139,9 +139,9 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// to be applied is the 3-bit encoding of the X, respectively, Z syndrome when considered an integer.
     ///
     /// # See Also
-    /// - SteaneCodeEncoder
-    /// - SteaneCodeDecoder
-    /// - LogicalRegister
+    /// - Microsoft.Quantum.ErrorCorrection.SteaneCodeEncoder
+    /// - Microsoft.Quantum.ErrorCorrection.SteaneCodeDecoder
+    /// - Microsoft.Quantum.ErrorCorrection.LogicalRegister
     ///
     /// # References
     /// - D. Gottesman, "Stabilizer Codes and Quantum Error Correction," Ph.D. Thesis, Caltech, 1997;
diff --git a/Standard/src/ErrorCorrection/BitFlipCode.qs b/Standard/src/ErrorCorrection/BitFlipCode.qs
index 0b92035a892..057d277327a 100644
--- a/Standard/src/ErrorCorrection/BitFlipCode.qs
+++ b/Standard/src/ErrorCorrection/BitFlipCode.qs
@@ -43,7 +43,7 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// logical register.
     ///
     /// # See Also
-    /// - LogicalRegister
+    /// - Microsoft.Quantum.ErrorCorrection.LogicalRegister
     operation EncodeIntoBitFlipCode(physRegister : Qubit[], auxQubits : Qubit[])
     : LogicalRegister {
         ApplyBitFlipEncoder(false, physRegister, auxQubits);
@@ -64,8 +64,8 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// qubits used to represent the syndrome.
     ///
     /// # See Also
-    /// - LogicalRegister
-    /// - EncodeIntoBitFlipCode
+    /// - Microsoft.Quantum.ErrorCorrection.LogicalRegister
+    /// - Microsoft.Quantum.ErrorCorrection.EncodeIntoBitFlipCode
     operation DecodeFromBitFlipCode(logicalRegister : LogicalRegister)
     : (Qubit[], Qubit[]) {
         let physRegister = [(logicalRegister!)[0]];
@@ -99,7 +99,7 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// detected error.
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.RecoveryFn
+    /// - Microsoft.Quantum.ErrorCorrection.RecoveryFn
     function BitFlipRecoveryFn () : RecoveryFn {
         return TableLookupRecovery([
             [PauliI, PauliI, PauliI],
diff --git a/Standard/src/ErrorCorrection/Types.qs b/Standard/src/ErrorCorrection/Types.qs
index eeb3f9c1819..ff01203aebe 100644
--- a/Standard/src/ErrorCorrection/Types.qs
+++ b/Standard/src/ErrorCorrection/Types.qs
@@ -63,8 +63,8 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// ```
     ///
     /// # See Also
-    /// - LogicalRegister
-    /// - Syndrome
+    /// - Microsoft.Quantum.ErrorCorrection.LogicalRegister
+    /// - Microsoft.Quantum.ErrorCorrection.Syndrome
     newtype SyndromeMeasOp = (LogicalRegister => Syndrome);
 
     /// # Summary
diff --git a/Standard/src/ErrorCorrection/Utils.qs b/Standard/src/ErrorCorrection/Utils.qs
index 80e9ba916da..208c5562c51 100644
--- a/Standard/src/ErrorCorrection/Utils.qs
+++ b/Standard/src/ErrorCorrection/Utils.qs
@@ -46,9 +46,9 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// An array of qubits where the stabilizer code is defined.
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.QECC
-    /// - Microsoft.Quantum.Canon.RecoveryFn
-    /// - Microsoft.Quantum.Canon.LogicalRegister
+    /// - Microsoft.Quantum.ErrorCorrection.QECC
+    /// - Microsoft.Quantum.ErrorCorrection.RecoveryFn
+    /// - Microsoft.Quantum.ErrorCorrection.LogicalRegister
     operation Recover (code : QECC, fn : RecoveryFn, logicalRegister : LogicalRegister) : Unit
     {
         let (encode, decode, syndMeas) = code!;
@@ -77,9 +77,9 @@ namespace Microsoft.Quantum.ErrorCorrection {
     /// An array of qubits where the stabilizer code is defined.
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.CSS
-    /// - Microsoft.Quantum.Canon.RecoveryFn
-    /// - Microsoft.Quantum.Canon.LogicalRegister
+    /// - Microsoft.Quantum.ErrorCorrection.CSS
+    /// - Microsoft.Quantum.ErrorCorrection.RecoveryFn
+    /// - Microsoft.Quantum.ErrorCorrection.LogicalRegister
     operation RecoverCSS (code : CSS, fnX : RecoveryFn, fnZ : RecoveryFn, logicalRegister : LogicalRegister) : Unit
     {
         let (encode, decode, syndMeasX, syndMeasZ) = code!;
diff --git a/Standard/src/Math/Complex.qs b/Standard/src/Math/Complex.qs
index 3240352032e..15f16886aeb 100644
--- a/Standard/src/Math/Complex.qs
+++ b/Standard/src/Math/Complex.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Math {
@@ -10,9 +10,9 @@ namespace Microsoft.Quantum.Math {
     ///
     /// # Named Items
     /// ## Magnitude
-    /// `Double` is absolute value $r \ge 0$.
+    /// The absolute value $r \ge 0$ of $c$.
     /// ## Argument
-    /// `Double` is the phase $t \in \mathbb R$.
+    /// The phase $t \in \mathbb R$ of $c$.
     newtype ComplexPolar = (Magnitude: Double, Argument: Double);
 
     /// # Summary
@@ -25,7 +25,7 @@ namespace Microsoft.Quantum.Math {
     ///
     /// # Output
     /// Squared absolute value $|c|^2 = x^2 + y^2$.
-    function AbsSquaredComplex (input : Complex) : Double {
+    function AbsSquaredComplex(input : Complex) : Double {
         let (real, imaginary) = input!;
         return real * real + imaginary * imaginary;
     }
@@ -40,7 +40,7 @@ namespace Microsoft.Quantum.Math {
     ///
     /// # Output
     /// Absolute value $|c| = \sqrt{x^2 + y^2}$.
-    function AbsComplex (input : Complex) : Double {
+    function AbsComplex(input : Complex) : Double {
         return Sqrt(AbsSquaredComplex(input));
     }
 
@@ -54,7 +54,7 @@ namespace Microsoft.Quantum.Math {
     ///
     /// # Output
     /// Phase $\text{Arg}[c] = \text{ArcTan}(y,x) \in (-\pi,\pi]$.
-    function ArgComplex (input : Complex) : Double {
+    function ArgComplex(input : Complex) : Double {
         let (real, imaginary) = input!;
         return ArcTan2(imaginary, real);
     }
@@ -69,7 +69,7 @@ namespace Microsoft.Quantum.Math {
     ///
     /// # Output
     /// Squared absolute value $|c|^2 = r^2$.
-    function AbsSquaredComplexPolar (input : ComplexPolar) : Double {
+    function AbsSquaredComplexPolar(input : ComplexPolar) : Double {
         let (abs, arg) = input!;
         return abs * abs;
     }
@@ -85,7 +85,7 @@ namespace Microsoft.Quantum.Math {
     ///
     /// # Output
     /// Absolute value $|c| = r$.
-    function AbsComplexPolar (input : ComplexPolar) : Double {
+    function AbsComplexPolar(input : ComplexPolar) : Double {
         return input::Magnitude;
     }
 
@@ -256,16 +256,16 @@ namespace Microsoft.Quantum.Math {
     /// Returns a number raised to a given power.
     ///
     /// # Input
-    /// ## base
+    /// ## a
     /// The number $a$ that is to be raised.
     /// ## power
     /// The power $b$ to which $a$ should be raised.
     ///
     /// # Output
     /// The power $a^b$
-    function PowC(base_ : Complex, power : Complex) : Complex {
+    function PowC(a : Complex, power : Complex) : Complex {
         return ComplexPolarAsComplex(
-            PowCAsCP(base_, power)
+            PowCAsCP(a, power)
         );
     }
 
@@ -273,7 +273,7 @@ namespace Microsoft.Quantum.Math {
     /// Returns a number raised to a given power.
     ///
     /// # Input
-    /// ## base
+    /// ## a
     /// The number $a$ that is to be raised.
     /// ## power
     /// The power $b$ to which $a$ should be raised.
diff --git a/Standard/src/Math/Functions.qs b/Standard/src/Math/Functions.qs
index 585b711cc7c..edefbc14081 100644
--- a/Standard/src/Math/Functions.qs
+++ b/Standard/src/Math/Functions.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Math {
@@ -51,16 +51,13 @@ namespace Microsoft.Quantum.Math {
     ///
     /// # Output
     /// The smallest element of `values`.
-    function Min (value : Int[]) : Int
-    {
-        mutable min = value[0];
-        let nTerms = Length(value);
+    function Min (values : Int[]) : Int {
+        mutable min = values[0];
+        let nTerms = Length(values);
 
-        for (idx in 0 .. nTerms - 1)
-        {
-            if (value[idx] < min)
-            {
-                set min = value[idx];
+        for (idx in 0 .. nTerms - 1) {
+            if (values[idx] < min) {
+                set min = values[idx];
             }
         }
 
@@ -642,7 +639,7 @@ namespace Microsoft.Quantum.Math {
     /// The array $x$ normalized by the $p$-norm $\|x\|_p$.
     ///
     /// # See Also
-    /// - PNorm
+    /// - Microsoft.Quantum.Math.PNorm
     function PNormalized(p : Double, array : Double[]) : Double[] {
         let nElements = Length(array);
         let norm = PNorm(p, array);
diff --git a/Standard/src/Oracles/Convert.qs b/Standard/src/Oracles/Convert.qs
index 892acae3fa2..ee6ee56db7b 100644
--- a/Standard/src/Oracles/Convert.qs
+++ b/Standard/src/Oracles/Convert.qs
@@ -26,8 +26,8 @@ namespace Microsoft.Quantum.Oracles {
     /// An oracle $O=UA$ of type `ObliviousOracle`.
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.DeterministicStateOracle
-    /// - Microsoft.Quantum.Canon.ObliviousOracle
+    /// - Microsoft.Quantum.Oracles.DeterministicStateOracle
+    /// - Microsoft.Quantum.Oracles.ObliviousOracle
     function ObliviousOracleFromDeterministicStateOracle(ancillaOracle : DeterministicStateOracle, signalOracle : ObliviousOracle)
     : ObliviousOracle {
         return ObliviousOracle(ApplyObliviousOracleFromDeterministicStateOracle(ancillaOracle, signalOracle, _, _));
@@ -59,8 +59,8 @@ namespace Microsoft.Quantum.Oracles {
     /// longer explicitly separate, e.g.  $A\ket{0\psi}\_{as}$.
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.StateOracle
-    /// - Microsoft.Quantum.Canon.DeterministicStateOracle
+    /// - Microsoft.Quantum.Oracles.StateOracle
+    /// - Microsoft.Quantum.Oracles.DeterministicStateOracle
     function DeterministicStateOracleFromStateOracle (idxFlagQubit : Int, stateOracle : StateOracle)
     : DeterministicStateOracle {
         return DeterministicStateOracle(ApplyDeterministicStateOracleFromStateOracle(idxFlagQubit, stateOracle, _));
@@ -88,8 +88,8 @@ namespace Microsoft.Quantum.Oracles {
     /// dummy variable and has no effect.
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.DeterministicStateOracle
-    /// - Microsoft.Quantum.Canon.StateOracle
+    /// - Microsoft.Quantum.Oracles.DeterministicStateOracle
+    /// - Microsoft.Quantum.Oracles.StateOracle
     function StateOracleFromDeterministicStateOracle (deterministicStateOracle : DeterministicStateOracle) : StateOracle
     {
         return StateOracle(ApplyStateOracleFromDeterministicStateOracle(_, deterministicStateOracle, _));
diff --git a/Standard/src/Preparation/Arbitrary.qs b/Standard/src/Preparation/Arbitrary.qs
index 2eed1e0b8e5..c676003020e 100644
--- a/Standard/src/Preparation/Arbitrary.qs
+++ b/Standard/src/Preparation/Arbitrary.qs
@@ -351,7 +351,7 @@ namespace Microsoft.Quantum.Preparation {
     /// # Summary
     /// Implementation step of arbitrary state preparation procedure.
     /// # See Also
-    /// - Microsoft.Quantum.Canon.PrepareArbitraryState
+    /// - Microsoft.Quantum.Preparation.PrepareArbitraryState
     function _StatePreparationSBMComputeCoefficients (coefficients : ComplexPolar[]) : (Double[], Double[], ComplexPolar[]) {
         mutable disentanglingZ = new Double[Length(coefficients) / 2];
         mutable disentanglingY = new Double[Length(coefficients) / 2];
diff --git a/Standard/src/Preparation/Mixed.qs b/Standard/src/Preparation/Mixed.qs
index 6d6eddcf75e..f1807e26a9e 100644
--- a/Standard/src/Preparation/Mixed.qs
+++ b/Standard/src/Preparation/Mixed.qs
@@ -49,7 +49,7 @@ namespace Microsoft.Quantum.Preparation {
     /// described above.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.preparesinglequbitidentity"
+    /// - Microsoft.Quantum.Preparation.PrepareSingleQubitIdentity
     operation PrepareIdentity(register : Qubit[]) : Unit {
         ApplyToEach(PrepareSingleQubitIdentity, register);
     }
diff --git a/Standard/src/Preparation/Reference.qs b/Standard/src/Preparation/Reference.qs
index 74564a6c308..a70b7646457 100644
--- a/Standard/src/Preparation/Reference.qs
+++ b/Standard/src/Preparation/Reference.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Preparation {
@@ -60,9 +60,9 @@ namespace Microsoft.Quantum.Preparation {
     /// *quantum process tomography*.
     ///
     /// # See Also
-    /// - PrepareChoiStateA
-    /// - PrepareChoiStateC
-    /// - PrepareChoiStateCA
+    /// - Microsoft.Quantum.Preparation.PrepareChoiStateA
+    /// - Microsoft.Quantum.Preparation.PrepareChoiStateC
+    /// - Microsoft.Quantum.Preparation.PrepareChoiStateCA
     operation PrepareChoiState (op : (Qubit[] => Unit), reference : Qubit[], target : Qubit[]) : Unit {
         PrepareEntangledState(reference, target);
         op(target);
@@ -74,7 +74,7 @@ namespace Microsoft.Quantum.Preparation {
     /// and target registers.
     ///
     /// # See Also
-    /// - PrepareChoiState
+    /// - Microsoft.Quantum.Preparation.PrepareChoiState
     operation PrepareChoiStateC(op : (Qubit[] => Unit is Ctl), reference : Qubit[], target : Qubit[]) : Unit is Ctl {
         PrepareEntangledState(reference, target);
         op(target);
@@ -86,7 +86,7 @@ namespace Microsoft.Quantum.Preparation {
     /// and target registers.
     ///
     /// # See Also
-    /// - PrepareChoiState
+    /// - Microsoft.Quantum.Preparation.PrepareChoiState
     operation PrepareChoiStateA (op : (Qubit[] => Unit is Adj), reference : Qubit[], target : Qubit[]) : Unit is Adj {
         PrepareEntangledState(reference, target);
         op(target);
@@ -98,7 +98,7 @@ namespace Microsoft.Quantum.Preparation {
     /// and target registers.
     ///
     /// # See Also
-    /// - PrepareChoiState
+    /// - Microsoft.Quantum.Preparation.PrepareChoiState
     operation PrepareChoiStateCA(op : (Qubit[] => Unit is Adj + Ctl), reference : Qubit[], target : Qubit[]) : Unit is Adj + Ctl {
         PrepareEntangledState(reference, target);
         op(target);
diff --git a/Standard/src/Simulation/BlockEncoding.qs b/Standard/src/Simulation/BlockEncoding.qs
index f0e721b522d..628e603f4c4 100644
--- a/Standard/src/Simulation/BlockEncoding.qs
+++ b/Standard/src/Simulation/BlockEncoding.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Simulation {
@@ -54,7 +54,7 @@ namespace Microsoft.Quantum.Simulation {
     /// encodes $H$.
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.BlockEncoding
+    /// - Microsoft.Quantum.Simulation.BlockEncoding
     newtype BlockEncodingReflection = BlockEncoding;
 
     /// # Summary
@@ -110,8 +110,8 @@ namespace Microsoft.Quantum.Simulation {
     ///   https://arxiv.org/abs/1610.06546
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.BlockEncoding
-    /// - Microsoft.Quantum.Canon.BlockEncodingReflection
+    /// - Microsoft.Quantum.Simulation.BlockEncoding
+    /// - Microsoft.Quantum.Simulation.BlockEncodingReflection
     function BlockEncodingToReflection(blockEncoding: BlockEncoding)
     : BlockEncodingReflection {
         return BlockEncodingReflection(BlockEncoding(ApplyBlockEncodingAsReflection(blockEncoding, _, _)));
@@ -137,7 +137,7 @@ namespace Microsoft.Quantum.Simulation {
     /// walk $W$ containing the spectrum of $\pm e^{\pm i\sin^{-1}(H)}$.
     ///
     /// # Input
-    /// ## blockEncodingReflection
+    /// ## blockEncoding
     /// A `BlockEncodingReflection` unitary $U$ to be converted into a Quantum
     /// walk.
     ///
@@ -151,8 +151,8 @@ namespace Microsoft.Quantum.Simulation {
     ///   https://arxiv.org/abs/1610.06546
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.BlockEncoding
-    /// - Microsoft.Quantum.Canon.BlockEncodingReflection
+    /// - Microsoft.Quantum.Simulation.BlockEncoding
+    /// - Microsoft.Quantum.Simulation.BlockEncodingReflection
     function QuantumWalkByQubitization(blockEncoding: BlockEncodingReflection)
     : ((Qubit[], Qubit[]) => Unit is Adj + Ctl) {
         return ApplyQuantumWalkByQubitization(blockEncoding, _, _);
@@ -196,8 +196,8 @@ namespace Microsoft.Quantum.Simulation {
     /// `BlockEncodingReflection`.
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.BlockEncoding
-    /// - Microsoft.Quantum.Canon.BlockEncodingReflection
+    /// - Microsoft.Quantum.Simulation.BlockEncoding
+    /// - Microsoft.Quantum.Simulation.BlockEncodingReflection
     function BlockEncodingByLCU<'T,'S>(
         statePreparation: ('T => Unit is Adj + Ctl),
         selector: (('T, 'S) => Unit is Adj + Ctl)
@@ -242,8 +242,8 @@ namespace Microsoft.Quantum.Simulation {
     /// `BlockEncodingReflection`.
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.BlockEncoding
-    /// - Microsoft.Quantum.Canon.BlockEncodingReflection
+    /// - Microsoft.Quantum.Simulation.BlockEncoding
+    /// - Microsoft.Quantum.Simulation.BlockEncodingReflection
     function BlockEncodingReflectionByLCU(
         statePreparation : (Qubit[] => Unit is Adj + Ctl),
         selector : ((Qubit[], Qubit[]) => Unit is Adj + Ctl)
diff --git a/Standard/src/Simulation/Data/GeneratorRepresentation.qs b/Standard/src/Simulation/Data/GeneratorRepresentation.qs
index 6261ea594b2..7804f4f761b 100644
--- a/Standard/src/Simulation/Data/GeneratorRepresentation.qs
+++ b/Standard/src/Simulation/Data/GeneratorRepresentation.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Simulation {
@@ -31,8 +31,8 @@ namespace Microsoft.Quantum.Simulation {
     /// ```
     ///
     /// # See Also
-    /// - EvolutionSet
-    /// - PauliEvolutionSet
+    /// - Microsoft.Quantum.Simulation.EvolutionSet
+    /// - Microsoft.Quantum.Simulation.PauliEvolutionSet
     newtype GeneratorIndex = ((Int[], Double[]), Int[]);
 
     /// # Summary
@@ -47,7 +47,7 @@ namespace Microsoft.Quantum.Simulation {
     /// <xref:microsoft.quantum.arrays.lookupfunction> function.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.lookupfunction"
+    /// - Microsoft.Quantum.Arrays.LookupFunction
     newtype GeneratorSystem = (Int, (Int -> GeneratorIndex));
     
     /// # Summary
@@ -167,9 +167,8 @@ namespace Microsoft.Quantum.Simulation {
     /// The number of terms in a `GeneratorSystem`.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.generatorsystem"
-    function GetGeneratorSystemNTerms (generatorSystem : GeneratorSystem) : Int
-    {
+    /// - Microsoft.Quantum.Simulation.GeneratorSystem
+    function GetGeneratorSystemNTerms (generatorSystem : GeneratorSystem) : Int {
         let (nTerms, generatorIndexFunction) = generatorSystem!;
         return nTerms;
     }
@@ -186,8 +185,8 @@ namespace Microsoft.Quantum.Simulation {
     /// An function that indexes each `GeneratorIndex` term in a Hamiltonian.
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.generatorindex"
-    /// - @"microsoft.quantum.canon.generatorsystem"
+    /// - Microsoft.Quantum.Simulation.GeneratorIndex
+    /// - Microsoft.Quantum.Simulation.GeneratorSystem
     function GetGeneratorSystemFunction (generatorSystem : GeneratorSystem) : (Int -> GeneratorIndex)
     {
         let (nTerms, generatorIndexFunction) = generatorSystem!;
@@ -219,7 +218,7 @@ namespace Microsoft.Quantum.Simulation {
     /// ```
     ///
     /// # See Also
-    /// - @"microsoft.quantum.canon.generatorindex"
+    /// - Microsoft.Quantum.Simulation.GeneratorIndex
     function MultiplyGeneratorIndex (multiplier : Double, generatorIndex : GeneratorIndex) : GeneratorIndex
     {
         let ((idxTerms, idxDoubles), idxSystems) = generatorIndex!;
@@ -255,7 +254,7 @@ namespace Microsoft.Quantum.Simulation {
     /// `multiplier` larger.
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.GeneratorSystem
+    /// - Microsoft.Quantum.Simulation.GeneratorSystem
     function MultiplyGeneratorSystem (multiplier : Double, generatorSystem : GeneratorSystem) : GeneratorSystem
     {
         let nTerms = GetGeneratorSystemNTerms(generatorSystem);
@@ -295,7 +294,7 @@ namespace Microsoft.Quantum.Simulation {
     /// input generator systems.
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.GeneratorSystem
+    /// - Microsoft.Quantum.Simulation.GeneratorSystem
     function AddGeneratorSystems (generatorSystemA : GeneratorSystem, generatorSystemB : GeneratorSystem) : GeneratorSystem
     {
         let nTermsA = GetGeneratorSystemNTerms(generatorSystemA);
@@ -327,7 +326,7 @@ namespace Microsoft.Quantum.Simulation {
     /// and weight $s$ on `generatorSystemEnd`.
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.GeneratorSystem
+    /// - Microsoft.Quantum.Simulation.GeneratorSystem
     function InterpolateGeneratorSystemsImpl (schedule : Double, generatorSystemStart : GeneratorSystem, generatorSystemEnd : GeneratorSystem) : GeneratorSystem
     {
         let sysStart = MultiplyGeneratorSystem(1.0 - schedule, generatorSystemStart);
@@ -352,8 +351,8 @@ namespace Microsoft.Quantum.Simulation {
     /// `generatorSystemStart` and weight $s$ on `generatorSystemEnd`.
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.GeneratorSystem
-    /// - Microsoft.Quantum.Canon.TimeDependentGeneratorSystem
+    /// - Microsoft.Quantum.Simulation.GeneratorSystem
+    /// - Microsoft.Quantum.Simulation.TimeDependentGeneratorSystem
     function InterpolateGeneratorSystems (generatorSystemStart : GeneratorSystem, generatorSystemEnd : GeneratorSystem) : TimeDependentGeneratorSystem
     {
         return TimeDependentGeneratorSystem(InterpolateGeneratorSystemsImpl(_, generatorSystemStart, generatorSystemEnd));
@@ -371,7 +370,7 @@ namespace Microsoft.Quantum.Simulation {
     /// input generator systems.
     ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.GeneratorSystem
+    /// - Microsoft.Quantum.Simulation.GeneratorSystem
     function SumGeneratorSystems(generatorSystems: GeneratorSystem[]) : GeneratorSystem {
         return Fold(AddGeneratorSystems, IdentityGeneratorSystem(), generatorSystems);
     }
diff --git a/Standard/src/Simulation/QubitizationPauliEvolutionSet.qs b/Standard/src/Simulation/QubitizationPauliEvolutionSet.qs
index 0844ff78618..d9f79a26613 100644
--- a/Standard/src/Simulation/QubitizationPauliEvolutionSet.qs
+++ b/Standard/src/Simulation/QubitizationPauliEvolutionSet.qs
@@ -114,15 +114,16 @@ namespace Microsoft.Quantum.Simulation {
     /// # Summary
     /// Used in implementation of `PauliBlockEncoding`
     /// # See Also
-    /// - Microsoft.Quantum.Canon.PauliBlockEncoding
+    /// - Microsoft.Quantum.Simulation.PauliBlockEncoding
     internal function IdxToCoeff(idx: Int, genFun: (Int -> GeneratorIndex), genIdxToCoeff: (GeneratorIndex -> Double)) : Double {
         return Sqrt(AbsD(genIdxToCoeff(genFun(idx))));
     }
 
     /// # Summary
     /// Used in implementation of `PauliBlockEncoding`
+    ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.PauliBlockEncoding
+    /// - Microsoft.Quantum.Simulation.PauliBlockEncoding
     internal function IdxToUnitary(idx: Int, genFun: (Int -> GeneratorIndex), genIdxToUnitary: (GeneratorIndex -> (Qubit[] => Unit is Adj + Ctl))) : (Qubit[] => Unit is Adj + Ctl) {
         return genIdxToUnitary(genFun(idx));
     }
@@ -130,16 +131,18 @@ namespace Microsoft.Quantum.Simulation {
 
     /// # Summary
     /// Used in implementation of `PauliBlockEncoding`
+    ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.PauliBlockEncoding
+    /// - Microsoft.Quantum.Simulation.PauliBlockEncoding
     internal function PauliLCUUnitary(generatorIndex: GeneratorIndex) : (Qubit[] => Unit is Adj + Ctl) {
         return ApplyPauliLCUUnitary(generatorIndex,_);
     }
 
     /// # Summary
     /// Used in implementation of `PauliBlockEncoding`
+    ///
     /// # See Also
-    /// - Microsoft.Quantum.Canon.PauliBlockEncoding
+    /// - Microsoft.Quantum.Simulation.PauliBlockEncoding
     internal operation ApplyPauliLCUUnitary(generatorIndex: GeneratorIndex, qubits: Qubit[])
     : Unit is Adj + Ctl {
         let ((idxPaulis, coeff), idxQubits) = generatorIndex!;
diff --git a/Standard/src/Simulation/Techniques.qs b/Standard/src/Simulation/Techniques.qs
index ce663ac3ef6..26a8ddaebeb 100644
--- a/Standard/src/Simulation/Techniques.qs
+++ b/Standard/src/Simulation/Techniques.qs
@@ -28,7 +28,7 @@ namespace Microsoft.Quantum.Simulation {
     /// then this function returns an operation which performs adiabatic
     /// state preparation for the final dynamical generator.
     function InterpolatedEvolution(
-            inerpolationTime : Double,
+            interpolationTime : Double,
             evolutionGeneratorStart : EvolutionGenerator,
             evolutionGeneratorEnd : EvolutionGenerator,
             timeDependentSimulationAlgorithm : TimeDependentSimulationAlgorithm
@@ -38,7 +38,7 @@ namespace Microsoft.Quantum.Simulation {
         let (evolutionSetEnd, generatorSystemEnd) = evolutionGeneratorEnd!;
         let generatorSystemTimeDependent = InterpolateGeneratorSystems(generatorSystemStart, generatorSystemEnd);
         let evolutionSchedule = EvolutionSchedule(evolutionSetStart, generatorSystemTimeDependent!);
-        return timeDependentSimulationAlgorithm!(inerpolationTime, evolutionSchedule, _);
+        return timeDependentSimulationAlgorithm!(interpolationTime, evolutionSchedule, _);
     }
     
     
diff --git a/Standard/src/Simulation/Types.qs b/Standard/src/Simulation/Types.qs
index 996a6f4b5c0..4bace915784 100644
--- a/Standard/src/Simulation/Types.qs
+++ b/Standard/src/Simulation/Types.qs
@@ -1,4 +1,4 @@
-// Copyright (c) Microsoft Corporation. All rights reserved.
+// Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
 namespace Microsoft.Quantum.Simulation {
@@ -24,7 +24,7 @@ namespace Microsoft.Quantum.Simulation {
     /// # Output
     /// Unitary evolution by generator for time `Double`.
     newtype SimulationAlgorithm = ((Double, EvolutionGenerator, Qubit[]) => Unit is Adj + Ctl);
-    
+
     /// # Summary
 	/// Represents a time-dependent simulation algorithm.
 	/// 
diff --git a/Standard/src/Standard.csproj b/Standard/src/Standard.csproj
index bb372cd54af..17f676aed0f 100644
--- a/Standard/src/Standard.csproj
+++ b/Standard/src/Standard.csproj
@@ -1,13 +1,20 @@
-<Project Sdk="Microsoft.Quantum.Sdk/0.12.20082515-beta">
+<Project Sdk="Microsoft.Quantum.Sdk/0.12.20102008-beta">
 
   <PropertyGroup>
     <TargetFramework>netstandard2.1</TargetFramework>
     <AssemblyName>Microsoft.Quantum.Standard</AssemblyName>
-    <QsharpDocsGeneration>true</QsharpDocsGeneration>
     <IncludeQsharpCorePackages>false</IncludeQsharpCorePackages> <!-- otherwise the standard library is included by the Sdk -->
     <NoWarn>1591</NoWarn> <!-- warning regarding missing C# doc comments -->
   </PropertyGroup>
 
+  <!-- Documentation generation options -->
+  <PropertyGroup>
+    <QsharpDocsGeneration>true</QsharpDocsGeneration>
+    <!-- Since Microsoft.Quantum.Standard is brought in by default,
+         suppress package ID display in this project only. -->
+    <QsharpDocsPackageId></QsharpDocsPackageId>
+  </PropertyGroup>
+
   <PropertyGroup>
     <Authors>Microsoft</Authors>
     <Description>Microsoft's Quantum standard libraries.</Description>
@@ -30,7 +37,7 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Quantum.Simulators" Version="0.12.20082515-beta" />
+    <PackageReference Include="Microsoft.Quantum.Simulators" Version="0.12.20102008-beta" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
     <PackageReference Include="NumSharp" Version="0.20.5" />
   </ItemGroup>
diff --git a/Standard/tests/Standard.Tests.csproj b/Standard/tests/Standard.Tests.csproj
index 5bf903caf46..c7fdb20e54c 100644
--- a/Standard/tests/Standard.Tests.csproj
+++ b/Standard/tests/Standard.Tests.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.Quantum.Sdk/0.12.20082515-beta">
+<Project Sdk="Microsoft.Quantum.Sdk/0.12.20102008-beta">
 
   <Import Project="..\..\Build\props\tests.props" />
 
diff --git a/Visualization/src/Visualization.csproj b/Visualization/src/Visualization.csproj
index cf3f41e5537..a7ae6e834a2 100644
--- a/Visualization/src/Visualization.csproj
+++ b/Visualization/src/Visualization.csproj
@@ -32,9 +32,9 @@
   </ItemGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.Quantum.Simulators" Version="0.12.20082515-beta" />
+    <PackageReference Include="Microsoft.Quantum.Simulators" Version="0.12.20102008-beta" />
     <PackageReference Include="Microsoft.SourceLink.GitHub" Version="1.0.0" PrivateAssets="All" />
-    <PackageReference Include="Microsoft.Quantum.IQSharp.Jupyter" Version="0.12.20082515-beta" />
+    <PackageReference Include="Microsoft.Quantum.IQSharp.Jupyter" Version="0.12.20102008-beta" />
     <PackageReference Include="NumSharp" Version="0.20.5" />
   </ItemGroup>