qsharp-lang 1.0.33 → 1.1.0-dev

package/dist/browser.d.ts

@@ -23,11 +23,11 @@ export { type CompilerState } from "./compiler/compiler.js";
 export { QscEventTarget } from "./compiler/events.js";
 export { getAllKatas, getExerciseSources, getKata, type ContentItem, type Example, type Exercise, type ExplainedSolution, type ExplainedSolutionItem, type Kata, type KataSection, type Lesson, type LessonItem, type Question, } from "./katas.js";
 export { default as samples } from "./samples.generated.js";
-export { type VSDiagnostic } from "./vsdiagnostic.js";
 export { log, type LogLevel, type TargetProfile };
 export type { ICompilerWorker, ICompiler };
 export type { ILanguageServiceWorker, ILanguageService };
 export type { IDebugServiceWorker, IDebugService };
-export type { IBreakpointSpan, IStackFrame } from "../lib/web/qsc_wasm.js";
+export type { IBreakpointSpan, IStackFrame, IPosition, IRange, ILocation, VSDiagnostic, } from "../lib/web/qsc_wasm.js";
 export { type IStructStepResult, StepResultId } from "../lib/web/qsc_wasm.js";
 export { type LanguageServiceEvent } from "./language-service/language-service.js";
+export * as utils from "./utils.js";

package/dist/browser.js

@@ -158,3 +158,4 @@ export { getAllKatas, getExerciseSources, getKata, } from "./katas.js";
 export { default as samples } from "./samples.generated.js";
 export { log };
 export { StepResultId } from "../lib/web/qsc_wasm.js";
+export * as utils from "./utils.js";

package/dist/compiler/common.d.ts

@@ -1,4 +1,4 @@
-import { VSDiagnostic } from "../vsdiagnostic.js";
+import { type VSDiagnostic } from "../../lib/web/qsc_wasm.js";
 export type Dump = {
     [index: string]: [number, number];
 };

package/dist/compiler/compiler.d.ts

@@ -1,4 +1,4 @@
-import { VSDiagnostic } from "../vsdiagnostic.js";
+import { type VSDiagnostic } from "../../lib/web/qsc_wasm.js";
 import { IServiceProxy, ServiceState } from "../worker-proxy.js";
 import { IQscEventTarget } from "./events.js";
 type Wasm = typeof import("../../lib/node/qsc_wasm.cjs");

package/dist/compiler/compiler.js

@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 import { log } from "../log.js";
-import { mapDiagnostics } from "../vsdiagnostic.js";
 import { eventStringToMsg } from "./common.js";
 import { makeEvent } from "./events.js";
 export class Compiler {
@@ -24,7 +23,7 @@ export class Compiler {
         languageService.stop_background_work();
         await work;
         languageService.free();
-        return mapDiagnostics(diags, code);
+        return diags;
     }
     async getQir(sources) {
         return this.wasm.get_qir(sources);

package/dist/debug-service/debug-service.d.ts

@@ -19,7 +19,6 @@ export type IDebugServiceWorker = IDebugService & IServiceProxy;
 export declare class QSharpDebugService implements IDebugService {
     private wasm;
     private debugService;
-    private code;
     constructor(wasm: QscWasm);
     loadSource(sources: [string, string][], target: TargetProfile, entry: string | undefined): Promise<string>;
     getStackFrames(): Promise<IStackFrame[]>;

package/dist/debug-service/debug-service.js

@@ -3,46 +3,17 @@
 import { eventStringToMsg } from "../compiler/common.js";
 import { makeEvent } from "../compiler/events.js";
 import { log } from "../log.js";
-import { mapUtf8UnitsToUtf16Units } from "../vsdiagnostic.js";
 export class QSharpDebugService {
     constructor(wasm) {
-        // We need to keep a copy of the code for mapping diagnostics to utf16 offsets
-        this.code = {};
         log.info("Constructing a QSharpDebugService instance");
         this.wasm = wasm;
         this.debugService = new wasm.DebugService();
     }
     async loadSource(sources, target, entry) {
-        for (const [path, source] of sources) {
-            this.code[path] = source;
-        }
         return this.debugService.load_source(sources, target, entry);
     }
     async getStackFrames() {
-        const stack_frame_list = this.debugService.get_stack_frames();
-        const stack_frames = await Promise.all(stack_frame_list.frames.map(async (frame) => {
-            // get any missing sources if possible
-            if (!(frame.path in this.code)) {
-                const content = await this.wasm.get_library_source_content(frame.path);
-                if (content) {
-                    this.code[frame.path] = content;
-                }
-            }
-            if (frame.path in this.code) {
-                const mappedSpan = mapUtf8UnitsToUtf16Units([frame.lo, frame.hi], this.code[frame.path]);
-                return {
-                    ...frame,
-                    lo: mappedSpan[frame.lo],
-                    hi: mappedSpan[frame.hi],
-                };
-            }
-            else {
-                // We don't have a source file for this frame,
-                // and we couldn't load it, so just return it as-is
-                return frame;
-            }
-        }));
-        return stack_frames;
+        return this.debugService.get_stack_frames().frames;
     }
     async evalNext(bps, eventHandler) {
         const event_cb = (msg) => onCompilerEvent(msg, eventHandler);
@@ -65,20 +36,7 @@ export class QSharpDebugService {
         return this.debugService.eval_continue(event_cb, ids);
     }
     async getBreakpoints(path) {
-        const breakpoint_list = this.debugService.get_breakpoints(path);
-        // Get a map of the Rust source positions to the JavaScript source positions
-        const positions = [];
-        breakpoint_list.spans.forEach((span) => {
-            positions.push(span.lo);
-            positions.push(span.hi);
-        });
-        const positionMap = mapUtf8UnitsToUtf16Units(positions, this.code[path]);
-        const breakpoint_spans = breakpoint_list.spans.map((span) => ({
-            id: span.id,
-            lo: positionMap[span.lo],
-            hi: positionMap[span.hi],
-        }));
-        return breakpoint_spans;
+        return this.debugService.get_breakpoints(path).spans;
     }
     async captureQuantumState() {
         const state = this.debugService.capture_quantum_state();

package/dist/katas-content.generated.js

@@ -71,8 +71,8 @@ export default {
                     "items": [
                         {
                             "type": "text-content",
-                            "asHtml": "<p>The basic building block of a classical computer is the bit - a single memory cell that is either in state $0$ or in state $1$. Similarly, the basic building block of a quantum computer is the quantum bit, or <strong>qubit</strong>. Like the classical bit, a qubit can be in state $0$ or in state $1$. Unlike the classical bit, however, the qubit isn&#39;t limited to just those two states - it may also be in a combination, or <strong>superposition</strong> of those states.</p>\n<blockquote>\n<p>A common misconception about quantum computing is that a qubit is always in state $1$ or state $0$, we just don&#39;t know which one until we &quot;measure&quot; it. That is not the case. A qubit in a superposition is in a linear combination of the states 0 and 1. When a qubit is measured, it is forced to collapse into one state or the other - in other words, measuring a qubit is a drastic process that changes its initial state.</p>\n</blockquote>\n<h2>Matrix Representation</h2>\n<p>The state of a qubit is represented by a complex vector of size 2:</p>\n<p>$$\\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix}$$</p>\n<p>Here $\\alpha$ and $\\beta$ are complex numbers. $\\alpha$ represents how &quot;close&quot; the qubit is to state $0$, and $\\beta$ represents how &quot;close&quot; the qubit is to state $1$. This vector is normalized: $|\\alpha|^2 + |\\beta|^2 = 1$.\nα and β are known as the probability amplitudes of states 0 and 1, respectively.</p>\n<p>$\\alpha$ and $\\beta$ are known as the probability amplitudes of states $0$ and $1$, respectively.</p>\n<h2>Basis States</h2>\n<p>A qubit in state $0$ would be represented by the following vector:</p>\n<p>$$\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$$</p>\n<p>Likewise, a qubit in state $1$ would be represented by this vector:</p>\n<p>$$\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}$$</p>\n<p>Note that you can use scalar multiplication and vector addition to express any qubit state $\\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix}$ as a sum of these two vectors with certain probability amplitudes $\\alpha$ and $\\beta$, known as linear combination.</p>\n<p>$$\n\\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix} =\n\\begin{bmatrix} \\alpha \\\\ 0 \\end{bmatrix} + \\begin{bmatrix} 0 \\\\ \\beta \\end{bmatrix} =\n\\alpha \\cdot \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} + \\beta \\cdot \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}\n$$</p>\n<p>Because of this, qubit states $0$ and $1$ are known as basis states. These two vectors have two properties.</p>\n<ol>\n<li>They are normalized.</li>\n</ol>\n<p>$$\n\\langle \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} , \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\rangle =\n\\langle \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} , \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} \\rangle = 1\n$$</p>\n<ol start=\"2\">\n<li>They are orthogonal to each other.</li>\n</ol>\n<p>$$\n\\langle \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} , \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} \\rangle =\n\\langle \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} , \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\rangle = 0\n$$</p>\n<blockquote>\n<p>As a reminder, $\\langle V , W \\rangle$ is the inner product of $V$ and $W$.</p>\n</blockquote>\n<p>This means that these vectors form an <strong>orthonormal basis</strong>. The basis of $\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$ and $\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}$ is called the <strong>computational basis</strong>, also known as the <strong>canonical basis</strong>.</p>\n<blockquote>\n<p>There exist other orthonormal bases, for example, the <strong>Hadamard basis</strong>, formed by the vectors</p>\n<p>$$\\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\ \\frac{1}{\\sqrt{2}} \\end{bmatrix} \\text{ and } \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\ -\\frac{1}{\\sqrt{2}} \\end{bmatrix}$$</p>\n<p>You can check that these vectors are normalized, and orthogonal to each other. Any qubit state can be expressed as a linear combination of these vectors:</p>\n<p>$$\n\\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix} =\n\\frac{\\alpha + \\beta}{\\sqrt{2}} \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\ \\frac{1}{\\sqrt{2}} \\end{bmatrix} +\n\\frac{\\alpha - \\beta}{\\sqrt{2}} \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\ -\\frac{1}{\\sqrt{2}} \\end{bmatrix}\n$$</p>\n<p>The Hadamard basis is widely used in quantum computing, for example, in the <a href=\"https://en.wikipedia.org/wiki/BB84\" target=\"_blank\">BB84 quantum key distribution protocol</a>.</p>\n</blockquote>\n",
-                            "asMarkdown": "\nThe basic building block of a classical computer is the bit - a single memory cell that is either in state $0$ or in state $1$. Similarly, the basic building block of a quantum computer is the quantum bit, or **qubit**. Like the classical bit, a qubit can be in state $0$ or in state $1$. Unlike the classical bit, however, the qubit isn't limited to just those two states - it may also be in a combination, or **superposition** of those states.\n\n> A common misconception about quantum computing is that a qubit is always in state $1$ or state $0$, we just don't know which one until we \"measure\" it. That is not the case. A qubit in a superposition is in a linear combination of the states 0 and 1. When a qubit is measured, it is forced to collapse into one state or the other - in other words, measuring a qubit is a drastic process that changes its initial state.\n\n## Matrix Representation\n\nThe state of a qubit is represented by a complex vector of size 2:\n\n$$\\begin{bmatrix} \\alpha \\\\\\ \\beta \\end{bmatrix}$$\n\nHere $\\alpha$ and $\\beta$ are complex numbers. $\\alpha$ represents how \"close\" the qubit is to state $0$, and $\\beta$ represents how \"close\" the qubit is to state $1$. This vector is normalized: $|\\alpha|^2 + |\\beta|^2 = 1$.\nα and β are known as the probability amplitudes of states 0 and 1, respectively.\n\n$\\alpha$ and $\\beta$ are known as the probability amplitudes of states $0$ and $1$, respectively.\n\n## Basis States\n\nA qubit in state $0$ would be represented by the following vector:\n\n$$\\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix}$$\n\nLikewise, a qubit in state $1$ would be represented by this vector:\n\n$$\\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix}$$\n\nNote that you can use scalar multiplication and vector addition to express any qubit state $\\begin{bmatrix} \\alpha \\\\\\ \\beta \\end{bmatrix}$ as a sum of these two vectors with certain probability amplitudes $\\alpha$ and $\\beta$, known as linear combination.\n\n$$\n\\begin{bmatrix} \\alpha \\\\\\ \\beta \\\\end{bmatrix} =\n\\begin{bmatrix} \\alpha \\\\\\ 0 \\end{bmatrix} + \\begin{bmatrix} 0 \\\\\\ \\beta \\\\end{bmatrix} =\n\\alpha \\cdot \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} + \\beta \\cdot \\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix}\n$$\n\nBecause of this, qubit states $0$ and $1$ are known as basis states. These two vectors have two properties.\n\n1. They are normalized.\n\n$$\n\\langle \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} , \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} \\rangle =\n\\langle \\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix} , \\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix} \\rangle = 1\n$$\n\n2. They are orthogonal to each other.\n\n$$\n\\langle \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} , \\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix} \\rangle =\n\\langle \\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix} , \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} \\\\rangle = 0\n$$\n\n> As a reminder, $\\langle V , W \\rangle$ is the inner product of $V$ and $W$.\n\nThis means that these vectors form an **orthonormal basis**. The basis of $\\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix}$ and $\\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix}$ is called the **computational basis**, also known as the **canonical basis**.\n\n> There exist other orthonormal bases, for example, the **Hadamard basis**, formed by the vectors\n>\n> $$\\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\\\ \\frac{1}{\\sqrt{2}} \\end{bmatrix} \\text{ and } \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\\\ -\\frac{1}{\\sqrt{2}} \\end{bmatrix}$$\n>\n> You can check that these vectors are normalized, and orthogonal to each other. Any qubit state can be expressed as a linear combination of these vectors:\n>\n> $$\n> \\begin{bmatrix} \\alpha \\\\\\ \\beta \\end{bmatrix} =\n> \\frac{\\alpha + \\beta}{\\sqrt{2}} \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\\\ \\frac{1}{\\sqrt{2}} \\end{bmatrix} +\n> \\frac{\\alpha - \\beta}{\\sqrt{2}} \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\\\ -\\frac{1}{\\sqrt{2}} \\end{bmatrix}\n> $$\n>\n> The Hadamard basis is widely used in quantum computing, for example, in the <a href=\"https://en.wikipedia.org/wiki/BB84\" target=\"_blank\">BB84 quantum key distribution protocol</a>."
+                            "asHtml": "<p>The basic building block of a classical computer is the bit - a single memory cell that is either in state $0$ or in state $1$. Similarly, the basic building block of a quantum computer is the quantum bit, or <strong>qubit</strong>. Like the classical bit, a qubit can be in state $0$ or in state $1$. Unlike the classical bit, however, the qubit isn&#39;t limited to just those two states - it may also be in a combination, or <strong>superposition</strong> of those states.</p>\n<blockquote>\n<p>A common misconception about quantum computing is that a qubit is always in state $1$ or state $0$, we just don&#39;t know which one until we &quot;measure&quot; it. That is not the case. A qubit in a superposition is in a linear combination of the states 0 and 1. When a qubit is measured, it is forced to collapse into one state or the other - in other words, measuring a qubit is a drastic process that changes its initial state.</p>\n</blockquote>\n<h2>Matrix Representation</h2>\n<p>The state of a qubit is represented by a complex vector of size 2:</p>\n<p>$$\\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix}$$</p>\n<p>Here $\\alpha$ and $\\beta$ are complex numbers. $\\alpha$ represents how &quot;close&quot; the qubit is to state $0$, and $\\beta$ represents how &quot;close&quot; the qubit is to state $1$. This vector is normalized: $|\\alpha|^2 + |\\beta|^2 = 1$.\n$\\alpha$ and $\\beta$ are known as the probability amplitudes of states $0$ and $1$, respectively.</p>\n<h2>Basis States</h2>\n<p>A qubit in state $0$ would be represented by the following vector:</p>\n<p>$$\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$$</p>\n<p>Likewise, a qubit in state $1$ would be represented by this vector:</p>\n<p>$$\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}$$</p>\n<p>Note that you can use scalar multiplication and vector addition to express any qubit state $\\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix}$ as a sum of these two vectors with certain probability amplitudes $\\alpha$ and $\\beta$, known as linear combination.</p>\n<p>$$\n\\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix} =\n\\begin{bmatrix} \\alpha \\\\ 0 \\end{bmatrix} + \\begin{bmatrix} 0 \\\\ \\beta \\end{bmatrix} =\n\\alpha \\cdot \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} + \\beta \\cdot \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}\n$$</p>\n<p>Because of this, qubit states $0$ and $1$ are known as basis states. These two vectors have two properties.</p>\n<ol>\n<li>They are normalized.</li>\n</ol>\n<p>$$\n\\langle \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} , \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\rangle =\n\\langle \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} , \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} \\rangle = 1\n$$</p>\n<ol start=\"2\">\n<li>They are orthogonal to each other.</li>\n</ol>\n<p>$$\n\\langle \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} , \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} \\rangle =\n\\langle \\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix} , \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\rangle = 0\n$$</p>\n<blockquote>\n<p>As a reminder, $\\langle V , W \\rangle$ is the inner product of $V$ and $W$.</p>\n</blockquote>\n<p>This means that these vectors form an <strong>orthonormal basis</strong>. The basis of $\\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix}$ and $\\begin{bmatrix} 0 \\\\ 1 \\end{bmatrix}$ is called the <strong>computational basis</strong>, also known as the <strong>canonical basis</strong>.</p>\n<blockquote>\n<p>There exist other orthonormal bases, for example, the <strong>Hadamard basis</strong>, formed by the vectors</p>\n<p>$$\\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\ \\frac{1}{\\sqrt{2}} \\end{bmatrix} \\text{ and } \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\ -\\frac{1}{\\sqrt{2}} \\end{bmatrix}$$</p>\n<p>You can check that these vectors are normalized, and orthogonal to each other. Any qubit state can be expressed as a linear combination of these vectors:</p>\n<p>$$\n\\begin{bmatrix} \\alpha \\\\ \\beta \\end{bmatrix} =\n\\frac{\\alpha + \\beta}{\\sqrt{2}} \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\ \\frac{1}{\\sqrt{2}} \\end{bmatrix} +\n\\frac{\\alpha - \\beta}{\\sqrt{2}} \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\ -\\frac{1}{\\sqrt{2}} \\end{bmatrix}\n$$</p>\n<p>The Hadamard basis is widely used in quantum computing, for example, in the <a href=\"https://en.wikipedia.org/wiki/BB84\" target=\"_blank\">BB84 quantum key distribution protocol</a>.</p>\n</blockquote>\n",
+                            "asMarkdown": "\nThe basic building block of a classical computer is the bit - a single memory cell that is either in state $0$ or in state $1$. Similarly, the basic building block of a quantum computer is the quantum bit, or **qubit**. Like the classical bit, a qubit can be in state $0$ or in state $1$. Unlike the classical bit, however, the qubit isn't limited to just those two states - it may also be in a combination, or **superposition** of those states.\n\n> A common misconception about quantum computing is that a qubit is always in state $1$ or state $0$, we just don't know which one until we \"measure\" it. That is not the case. A qubit in a superposition is in a linear combination of the states 0 and 1. When a qubit is measured, it is forced to collapse into one state or the other - in other words, measuring a qubit is a drastic process that changes its initial state.\n\n## Matrix Representation\n\nThe state of a qubit is represented by a complex vector of size 2:\n\n$$\\begin{bmatrix} \\alpha \\\\\\ \\beta \\end{bmatrix}$$\n\nHere $\\alpha$ and $\\beta$ are complex numbers. $\\alpha$ represents how \"close\" the qubit is to state $0$, and $\\beta$ represents how \"close\" the qubit is to state $1$. This vector is normalized: $|\\alpha|^2 + |\\beta|^2 = 1$.\n$\\alpha$ and $\\beta$ are known as the probability amplitudes of states $0$ and $1$, respectively.\n\n## Basis States\n\nA qubit in state $0$ would be represented by the following vector:\n\n$$\\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix}$$\n\nLikewise, a qubit in state $1$ would be represented by this vector:\n\n$$\\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix}$$\n\nNote that you can use scalar multiplication and vector addition to express any qubit state $\\begin{bmatrix} \\alpha \\\\\\ \\beta \\end{bmatrix}$ as a sum of these two vectors with certain probability amplitudes $\\alpha$ and $\\beta$, known as linear combination.\n\n$$\n\\begin{bmatrix} \\alpha \\\\\\ \\beta \\\\end{bmatrix} =\n\\begin{bmatrix} \\alpha \\\\\\ 0 \\end{bmatrix} + \\begin{bmatrix} 0 \\\\\\ \\beta \\\\end{bmatrix} =\n\\alpha \\cdot \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} + \\beta \\cdot \\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix}\n$$\n\nBecause of this, qubit states $0$ and $1$ are known as basis states. These two vectors have two properties.\n\n1. They are normalized.\n\n$$\n\\langle \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} , \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} \\rangle =\n\\langle \\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix} , \\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix} \\rangle = 1\n$$\n\n2. They are orthogonal to each other.\n\n$$\n\\langle \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} , \\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix} \\rangle =\n\\langle \\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix} , \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} \\\\rangle = 0\n$$\n\n> As a reminder, $\\langle V , W \\rangle$ is the inner product of $V$ and $W$.\n\nThis means that these vectors form an **orthonormal basis**. The basis of $\\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix}$ and $\\begin{bmatrix} 0 \\\\\\ 1 \\end{bmatrix}$ is called the **computational basis**, also known as the **canonical basis**.\n\n> There exist other orthonormal bases, for example, the **Hadamard basis**, formed by the vectors\n>\n> $$\\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\\\ \\frac{1}{\\sqrt{2}} \\end{bmatrix} \\text{ and } \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\\\ -\\frac{1}{\\sqrt{2}} \\end{bmatrix}$$\n>\n> You can check that these vectors are normalized, and orthogonal to each other. Any qubit state can be expressed as a linear combination of these vectors:\n>\n> $$\n> \\begin{bmatrix} \\alpha \\\\\\ \\beta \\end{bmatrix} =\n> \\frac{\\alpha + \\beta}{\\sqrt{2}} \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\\\ \\frac{1}{\\sqrt{2}} \\end{bmatrix} +\n> \\frac{\\alpha - \\beta}{\\sqrt{2}} \\begin{bmatrix} \\frac{1}{\\sqrt{2}} \\\\\\ -\\frac{1}{\\sqrt{2}} \\end{bmatrix}\n> $$\n>\n> The Hadamard basis is widely used in quantum computing, for example, in the <a href=\"https://en.wikipedia.org/wiki/BB84\" target=\"_blank\">BB84 quantum key distribution protocol</a>."
                         }
                     ]
                 },
@@ -117,8 +117,8 @@ export default {
                         },
                         {
                             "type": "text-content",
-                            "asHtml": "<p>The exact behavior of this operation called <code>RunExample</code> depends on the quantum simulator or processor you are using.</p>\n<p>On the simulator used in these demos, this function prints the information on each basis state that has a non-zero amplitude, one basis state per row.\nThis includes information about the amplitude of the state, the probability of measuring that state, and the phase of the state.</p>\n<p>Note that each row has the following format:</p>\n<table>\n    <thead>\n        <tr>\n            <th>Basis State<br>(|𝜓ₙ…𝜓₁⟩)</th>\n            <th>Amplitude</th>\n            <th>Measurement Probability</th>\n            <th>Phase</th>\n        </tr>\n    </thead>\n</table>\n\n<p>For example, the state $|0\\rangle$ would be represented as follows:</p>\n<table>\n    <tbody>\n        <tr>\n            <td>|0⟩</td>\n            <td>1.0000+0.0000𝑖</td>\n            <td>100.0000%</td>\n            <td>↑ 0.0000</td></tr>\n    </tbody>\n</table>\n\n<blockquote>\n<p>It is important to note that although we reason about quantum systems in terms of their state, Q# does not have any representation of the quantum state in the language. Instead, state is an internal property of the quantum system, modified using gates. For more information, see <a href=\"https://docs.microsoft.com/azure/quantum/concepts-dirac-notation#q-gate-sequences-equivalent-to-quantum-states\" target=\"_blank\">Q# documentation on quantum states</a>.</p>\n</blockquote>\n",
-                            "asMarkdown": "\nThe exact behavior of this operation called `RunExample` depends on the quantum simulator or processor you are using.\n\nOn the simulator used in these demos, this function prints the information on each basis state that has a non-zero amplitude, one basis state per row.\nThis includes information about the amplitude of the state, the probability of measuring that state, and the phase of the state.\n\nNote that each row has the following format:\n\n<table>\n    <thead>\n        <tr>\n            <th>Basis State<br>(|𝜓ₙ…𝜓₁⟩)</th>\n            <th>Amplitude</th>\n            <th>Measurement Probability</th>\n            <th>Phase</th>\n        </tr>\n    </thead>\n</table>\n\nFor example, the state $|0\\rangle$ would be represented as follows:\n\n<table>\n    <tbody>\n        <tr>\n            <td>|0⟩</td>\n            <td>1.0000+0.0000𝑖</td>\n            <td>100.0000%</td>\n            <td>↑ 0.0000</td></tr>\n    </tbody>\n</table>\n\n> It is important to note that although we reason about quantum systems in terms of their state, Q# does not have any representation of the quantum state in the language. Instead, state is an internal property of the quantum system, modified using gates. For more information, see <a href=\"https://docs.microsoft.com/azure/quantum/concepts-dirac-notation#q-gate-sequences-equivalent-to-quantum-states\" target=\"_blank\">Q# documentation on quantum states</a>."
+                            "asHtml": "<p>The exact behavior of this operation called <code>RunExample</code> depends on the quantum simulator or processor you are using.</p>\n<p>On the simulator used in these demos, this function prints the information on each basis state that has a non-zero amplitude, one basis state per row.\nThis includes information about the amplitude of the state, the probability of measuring that state, and the phase of the state.</p>\n<p>Note that each row has the following format:</p>\n<table>\n    <thead>\n        <tr>\n            <th>Basis State<br>(|𝜓₁…𝜓ₙ⟩)</th>\n            <th>Amplitude</th>\n            <th>Measurement Probability</th>\n            <th>Phase</th>\n        </tr>\n    </thead>\n</table>\n\n<p>For example, the state $|0\\rangle$ would be represented as follows:</p>\n<table>\n    <tbody>\n        <tr>\n            <td>|0⟩</td>\n            <td>1.0000+0.0000𝑖</td>\n            <td>100.0000%</td>\n            <td>↑ 0.0000</td></tr>\n    </tbody>\n</table>\n\n<blockquote>\n<p>It is important to note that although we reason about quantum systems in terms of their state, Q# does not have any representation of the quantum state in the language. Instead, state is an internal property of the quantum system, modified using gates. For more information, see <a href=\"https://docs.microsoft.com/azure/quantum/concepts-dirac-notation#q-gate-sequences-equivalent-to-quantum-states\" target=\"_blank\">Q# documentation on quantum states</a>.</p>\n</blockquote>\n",
+                            "asMarkdown": "\nThe exact behavior of this operation called `RunExample` depends on the quantum simulator or processor you are using.\n\nOn the simulator used in these demos, this function prints the information on each basis state that has a non-zero amplitude, one basis state per row.\nThis includes information about the amplitude of the state, the probability of measuring that state, and the phase of the state.\n\nNote that each row has the following format:\n\n<table>\n    <thead>\n        <tr>\n            <th>Basis State<br>(|𝜓₁…𝜓ₙ⟩)</th>\n            <th>Amplitude</th>\n            <th>Measurement Probability</th>\n            <th>Phase</th>\n        </tr>\n    </thead>\n</table>\n\nFor example, the state $|0\\rangle$ would be represented as follows:\n\n<table>\n    <tbody>\n        <tr>\n            <td>|0⟩</td>\n            <td>1.0000+0.0000𝑖</td>\n            <td>100.0000%</td>\n            <td>↑ 0.0000</td></tr>\n    </tbody>\n</table>\n\n> It is important to note that although we reason about quantum systems in terms of their state, Q# does not have any representation of the quantum state in the language. Instead, state is an internal property of the quantum system, modified using gates. For more information, see <a href=\"https://docs.microsoft.com/azure/quantum/concepts-dirac-notation#q-gate-sequences-equivalent-to-quantum-states\" target=\"_blank\">Q# documentation on quantum states</a>."
                         }
                     ]
                 },
@@ -741,8 +741,8 @@ export default {
                         "items": [
                             {
                                 "type": "text-content",
-                                "asHtml": "<p>The start state is the same as the previous exercises:\n$$ \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} = |0\\rangle \\otimes |0\\rangle $$</p>\n<p>The goal state, factored as a tensor product, looks like this (remember that $e^{3i\\pi/4} = e^{i\\pi/4} e^{i\\pi/2}$):</p>\n<p>$$\n\\frac{1}{2}\\begin{bmatrix} 1 \\\\ e^{i\\pi/4} \\\\ e^{i\\pi/2} \\\\ e^{3i\\pi/4} \\end{bmatrix} =\n\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ e^{i\\pi/2} \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ e^{i\\pi/4} \\end{bmatrix} =\n\\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/2}|1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/4}|1\\rangle\\big) $$</p>\n<p>We will again need to adjust the states of both qubits independently.</p>\n<p>For the first qubit, we&#39;ll start by applying the <strong>H</strong> gate, getting the state $\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix}$, as we&#39;ve seen in the previous task. Afterwards we&#39;ll apply the <strong>S</strong> gate with the following result:</p>\n<p>$$ \\begin{bmatrix} 1 &amp; 0 \\\\ 0 &amp; i \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ i \\end{bmatrix}$$</p>\n<p>If we recall that $i = e^{i\\pi/2}$, we can write the final state of the second qubit as:\n$$ \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ e^{i\\pi/2} \\end{bmatrix} $$</p>\n<p>For the second qubit. we&#39;ll apply the <strong>H</strong> gate, followed by the <strong>T</strong> gate, with the following result:\n$$ \\begin{bmatrix} 1 &amp; 0 \\\\ 0 &amp; e^{i\\pi/4} \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ e^{i\\pi/4} \\end{bmatrix} $$</p>\n",
-                                "asMarkdown": "\nThe start state is the same as the previous exercises:\n$$ \\begin{bmatrix} 1 \\\\\\ 0 \\\\\\ 0 \\\\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} = |0\\rangle \\otimes |0\\rangle $$\n\nThe goal state, factored as a tensor product, looks like this (remember that $e^{3i\\pi/4} = e^{i\\pi/4} e^{i\\pi/2}$):\n\n$$\n\\frac{1}{2}\\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\\\\\ e^{i\\pi/2} \\\\\\ e^{3i\\pi/4} \\end{bmatrix} =\n\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/2} \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\end{bmatrix} =\n\\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/2}|1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/4}|1\\rangle\\big) $$\n\nWe will again need to adjust the states of both qubits independently.\n\nFor the first qubit, we'll start by applying the **H** gate, getting the state $\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix}$, as we've seen in the previous task. Afterwards we'll apply the **S** gate with the following result:\n\n$$ \\begin{bmatrix} 1 & 0 \\\\\\ 0 & i \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ i \\end{bmatrix}$$\n\nIf we recall that $i = e^{i\\pi/2}$, we can write the final state of the second qubit as:\n$$ \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/2} \\end{bmatrix} $$\n\nFor the second qubit. we'll apply the **H** gate, followed by the **T** gate, with the following result:\n$$ \\begin{bmatrix} 1 & 0 \\\\\\ 0 & e^{i\\pi/4} \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\end{bmatrix} $$"
+                                "asHtml": "<p>The start state is the same as the previous exercises:\n$$ \\begin{bmatrix} 1 \\\\ 0 \\\\ 0 \\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\ 0 \\end{bmatrix} = |0\\rangle \\otimes |0\\rangle $$</p>\n<p>The goal state, factored as a tensor product, looks like this (remember that $e^{3i\\pi/4} = e^{i\\pi/4} e^{i\\pi/2}$):</p>\n<p>$$\n\\frac{1}{2}\\begin{bmatrix} 1 \\\\ e^{i\\pi/4} \\\\ e^{i\\pi/2} \\\\ e^{3i\\pi/4} \\end{bmatrix} =\n\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ e^{i\\pi/2} \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\ e^{i\\pi/4} \\end{bmatrix} =\n\\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/2}|1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/4}|1\\rangle\\big) $$</p>\n<p>We will again need to adjust the states of both qubits independently.</p>\n<p>For the first qubit, we&#39;ll start by applying the <strong>H</strong> gate, getting the state $\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix}$, as we&#39;ve seen in the previous task. Afterwards we&#39;ll apply the <strong>S</strong> gate with the following result:</p>\n<p>$$ \\begin{bmatrix} 1 &amp; 0 \\\\ 0 &amp; i \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ i \\end{bmatrix}$$</p>\n<p>If we recall that $i = e^{i\\pi/2}$, we can write the final state of the first qubit as:\n$$ \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ e^{i\\pi/2} \\end{bmatrix} $$</p>\n<p>For the second qubit. we&#39;ll apply the <strong>H</strong> gate, followed by the <strong>T</strong> gate, with the following result:\n$$ \\begin{bmatrix} 1 &amp; 0 \\\\ 0 &amp; e^{i\\pi/4} \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\ e^{i\\pi/4} \\end{bmatrix} $$</p>\n",
+                                "asMarkdown": "\nThe start state is the same as the previous exercises:\n$$ \\begin{bmatrix} 1 \\\\\\ 0 \\\\\\ 0 \\\\\\ 0 \\end{bmatrix} = \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} \\otimes \\begin{bmatrix} 1 \\\\\\ 0 \\end{bmatrix} = |0\\rangle \\otimes |0\\rangle $$\n\nThe goal state, factored as a tensor product, looks like this (remember that $e^{3i\\pi/4} = e^{i\\pi/4} e^{i\\pi/2}$):\n\n$$\n\\frac{1}{2}\\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\\\\\ e^{i\\pi/2} \\\\\\ e^{3i\\pi/4} \\end{bmatrix} =\n\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/2} \\end{bmatrix} \\otimes \\frac{1}{\\sqrt2}\\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\end{bmatrix} =\n\\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/2}|1\\rangle\\big) \\otimes \\frac{1}{\\sqrt2}\\big(|0\\rangle + e^{i\\pi/4}|1\\rangle\\big) $$\n\nWe will again need to adjust the states of both qubits independently.\n\nFor the first qubit, we'll start by applying the **H** gate, getting the state $\\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix}$, as we've seen in the previous task. Afterwards we'll apply the **S** gate with the following result:\n\n$$ \\begin{bmatrix} 1 & 0 \\\\\\ 0 & i \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ i \\end{bmatrix}$$\n\nIf we recall that $i = e^{i\\pi/2}$, we can write the final state of the first qubit as:\n$$ \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/2} \\end{bmatrix} $$\n\nFor the second qubit. we'll apply the **H** gate, followed by the **T** gate, with the following result:\n$$ \\begin{bmatrix} 1 & 0 \\\\\\ 0 & e^{i\\pi/4} \\end{bmatrix} \\cdot \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ 1 \\end{bmatrix} = \\frac{1}{\\sqrt2} \\begin{bmatrix} 1 \\\\\\ e^{i\\pi/4} \\end{bmatrix} $$"
                             },
                             {
                                 "type": "solution",
@@ -1751,8 +1751,8 @@ export default {
                     "title": "Generate a Number of Arbitrary Size",
                     "description": {
                         "type": "text-content",
-                        "asHtml": "<p>Let&#39;s take it a step further and generate an $N$-bit number. </p>\n<p><strong>Input:</strong> An integer $N$ ($1 \\le N \\le 10$).</p>\n<p><strong>Goal:</strong> Generate a random number in the range $[0, 2^N - 1]$ with an equal probability of getting each of the numbers in this range.</p>\n<blockquote>\n<p>Useful Q# documentation: </p>\n<ul>\n<li><a href=\"https://docs.microsoft.com/azure/quantum/user-guide/language/statements/iterations\" target=\"_blank\">for` loops</a></li>\n<li><a href=\"https://docs.microsoft.com/azure/quantum/user-guide/language/typesystem/immutability\" target=\"_blank\">mutable variables</a></li>\n<li><a href=\"https://docs.microsoft.com/qsharp/api/qsharp/microsoft.quantum.math.powi\" target=\"_blank\">exponents</a></li>\n</ul>\n</blockquote>\n<details>\n  <summary><b>Need a hint?</b></summary>\n  Remember that you can use previously defined operations to implement your solution. For convenience, the <b>RandomBit</b> operation is already available for you to use in this exercise.\n</details>\n",
-                        "asMarkdown": "Let's take it a step further and generate an $N$-bit number. \n\n**Input:** An integer $N$ ($1 \\le N \\le 10$).\n\n**Goal:** Generate a random number in the range $[0, 2^N - 1]$ with an equal probability of getting each of the numbers in this range.\n\n> Useful Q# documentation: \n> * <a href=\"https://docs.microsoft.com/azure/quantum/user-guide/language/statements/iterations\" target=\"_blank\">for` loops</a>\n> * <a href=\"https://docs.microsoft.com/azure/quantum/user-guide/language/typesystem/immutability\" target=\"_blank\">mutable variables</a>\n> * <a href=\"https://docs.microsoft.com/qsharp/api/qsharp/microsoft.quantum.math.powi\" target=\"_blank\">exponents</a>\n\n<details>\n  <summary><b>Need a hint?</b></summary>\n  Remember that you can use previously defined operations to implement your solution. For convenience, the <b>RandomBit</b> operation is already available for you to use in this exercise.\n</details>\n"
+                        "asHtml": "<p>Let&#39;s take it a step further and generate an $N$-bit number.</p>\n<p><strong>Input:</strong> An integer $N$ ($1 \\le N \\le 10$).</p>\n<p><strong>Goal:</strong> Generate a random number in the range $[0, 2^N - 1]$ with an equal probability of getting each of the numbers in this range.</p>\n<blockquote>\n<p>Useful Q# documentation:</p>\n<ul>\n<li><a href=\"https://docs.microsoft.com/azure/quantum/user-guide/language/statements/iterations\" target=\"_blank\">for loops</a></li>\n<li><a href=\"https://docs.microsoft.com/azure/quantum/user-guide/language/typesystem/immutability\" target=\"_blank\">mutable variables</a></li>\n<li><a href=\"https://docs.microsoft.com/qsharp/api/qsharp/microsoft.quantum.math.powi\" target=\"_blank\">exponents</a></li>\n</ul>\n</blockquote>\n<details>\n  <summary><b>Need a hint?</b></summary>\n  Remember that you can use previously defined operations to implement your solution. For convenience, the <b>RandomBit</b> operation is already available for you to use in this exercise.\n</details>\n",
+                        "asMarkdown": "Let's take it a step further and generate an $N$-bit number.\n\n**Input:** An integer $N$ ($1 \\le N \\le 10$).\n\n**Goal:** Generate a random number in the range $[0, 2^N - 1]$ with an equal probability of getting each of the numbers in this range.\n\n> Useful Q# documentation:\n>\n> * <a href=\"https://docs.microsoft.com/azure/quantum/user-guide/language/statements/iterations\" target=\"_blank\">for loops</a>\n> * <a href=\"https://docs.microsoft.com/azure/quantum/user-guide/language/typesystem/immutability\" target=\"_blank\">mutable variables</a>\n> * <a href=\"https://docs.microsoft.com/qsharp/api/qsharp/microsoft.quantum.math.powi\" target=\"_blank\">exponents</a>\n\n<details>\n  <summary><b>Need a hint?</b></summary>\n  Remember that you can use previously defined operations to implement your solution. For convenience, the <b>RandomBit</b> operation is already available for you to use in this exercise.\n</details>\n"
                     },
                     "sourceIds": [
                         "random_numbers__random_n_bits__verification.qs",
@@ -2341,23 +2341,23 @@ export default {
         },
         {
             "id": "multi_qubit_systems__common.qs",
-            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Diagnostics;\n\n    operation AssertEqualOnZeroState(\n        testImpl : (Qubit[] => Unit is Ctl),\n        refImpl : (Qubit[] => Unit is Adj+Ctl)) : Bool {\n\n        use qs = Qubit[3];\n        within {\n            H(qs[0]);\n        }\n        apply {\n            // apply operation that needs to be tested\n            Controlled testImpl([qs[0]], qs[1..2]);\n\n            // apply adjoint reference operation\n            Adjoint Controlled refImpl([qs[0]], qs[1..2]);\n        }\n\n        // Implementation is correct when all qubits end up in |0⟩ state\n        let isCorrect = CheckAllZero(qs);\n        if not isCorrect {\n            Message(\"The prepared state is not the same as reference state.\");\n        }\n        ResetAll(qs);\n        isCorrect\n    }\n\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation CheckEqualOnZeroState(\n        testImpl : (Qubit[] => Unit is Adj + Ctl),\n        refImpl : (Qubit[] => Unit is Adj + Ctl)) : Bool {\n\n        let isCorrect = CheckOperationsEquivalenceOnZeroStateStrict(testImpl, refImpl, 2);\n\n        // Output different feedback to the user depending on whether the exercise was correct.\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n            use target = Qubit[2]; // |00〉\n            ShowQuantumStateComparison(target, testImpl, refImpl);\n            ResetAll(target);\n        }\n        isCorrect\n    }\n\n}\n"
         },
         {
             "id": "multi_qubit_systems__prepare_basis_state__verification.qs",
-            "code": "namespace Kata.Verification {\n    operation PrepareBasisState_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        X(qs[0]);\n        X(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = AssertEqualOnZeroState(Kata.PrepareBasisState, PrepareBasisState_Reference);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n        return isCorrect;\n    }\n}"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation PrepareBasisState_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        X(qs[0]);\n        X(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        CheckEqualOnZeroState(Kata.PrepareBasisState, PrepareBasisState_Reference)\n    }\n}\n"
         },
         {
             "id": "multi_qubit_systems__prepare_superposition__verification.qs",
-            "code": "namespace Kata.Verification {\n    operation PrepareSuperposition_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        X(qs[1]);\n        H(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = AssertEqualOnZeroState(Kata.PrepareSuperposition, PrepareSuperposition_Reference);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n        return isCorrect;\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation PrepareSuperposition_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        X(qs[1]);\n        H(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        CheckEqualOnZeroState(Kata.PrepareSuperposition, PrepareSuperposition_Reference)\n    }\n}\n"
         },
         {
             "id": "multi_qubit_systems__prepare_with_real__verification.qs",
-            "code": "namespace Kata.Verification {\n    operation PrepareWithReal_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        H(qs[0]);\n        X(qs[1]);\n        H(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = AssertEqualOnZeroState(Kata.PrepareWithReal, PrepareWithReal_Reference);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n        return isCorrect;\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation PrepareWithReal_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        H(qs[0]);\n        X(qs[1]);\n        H(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        CheckEqualOnZeroState(Kata.PrepareWithReal, PrepareWithReal_Reference)\n    }\n}\n"
         },
         {
             "id": "multi_qubit_systems__prepare_with_complex__verification.qs",
-            "code": "namespace Kata.Verification {\n    operation PrepareWithComplex_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        H(qs[0]);\n        H(qs[1]);\n        S(qs[0]);\n        T(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        let isCorrect = AssertEqualOnZeroState(Kata.PrepareWithComplex, PrepareWithComplex_Reference);\n        if isCorrect {\n            Message(\"Correct!\");\n        } else {\n            Message(\"Incorrect.\");\n        }\n        return isCorrect;\n    }\n}\n"
+            "code": "namespace Kata.Verification {\n    open Microsoft.Quantum.Katas;\n\n    operation PrepareWithComplex_Reference(qs : Qubit[]) : Unit is Adj + Ctl {\n        H(qs[0]);\n        H(qs[1]);\n        S(qs[0]);\n        T(qs[1]);\n    }\n\n    @EntryPoint()\n    operation CheckSolution() : Bool {\n        CheckEqualOnZeroState(Kata.PrepareWithComplex, PrepareWithComplex_Reference)\n    }\n}\n"
         },
         {
             "id": "multi_qubit_gates__compound_gate__Verification.qs",

package/dist/language-service/language-service.d.ts

@@ -1,5 +1,4 @@
-import type { ICompletionList, IHover, ILocation, ISignatureHelp, INotebookMetadata, IWorkspaceConfiguration, IWorkspaceEdit, ITextEdit } from "../../lib/node/qsc_wasm.cjs";
-import { VSDiagnostic } from "../vsdiagnostic.js";
+import type { ICompletionList, IHover, ILocation, ISignatureHelp, INotebookMetadata, IWorkspaceConfiguration, IWorkspaceEdit, ITextEdit, IPosition, VSDiagnostic } from "../../lib/node/qsc_wasm.cjs";
 import { IServiceProxy } from "../worker-proxy.js";
 type QscWasm = typeof import("../../lib/node/qsc_wasm.cjs");
 export type LanguageServiceEvent = {
@@ -20,13 +19,13 @@ export interface ILanguageService {
     }[]): Promise<void>;
     closeDocument(uri: string): Promise<void>;
     closeNotebookDocument(notebookUri: string): Promise<void>;
-    getCompletions(documentUri: string, offset: number): Promise<ICompletionList>;
-    getHover(documentUri: string, offset: number): Promise<IHover | undefined>;
-    getDefinition(documentUri: string, offset: number): Promise<ILocation | undefined>;
-    getReferences(documentUri: string, offset: number, includeDeclaration: boolean): Promise<ILocation[]>;
-    getSignatureHelp(documentUri: string, offset: number): Promise<ISignatureHelp | undefined>;
-    getRename(documentUri: string, offset: number, newName: string): Promise<IWorkspaceEdit | undefined>;
-    prepareRename(documentUri: string, offset: number): Promise<ITextEdit | undefined>;
+    getCompletions(documentUri: string, position: IPosition): Promise<ICompletionList>;
+    getHover(documentUri: string, position: IPosition): Promise<IHover | undefined>;
+    getDefinition(documentUri: string, position: IPosition): Promise<ILocation | undefined>;
+    getReferences(documentUri: string, position: IPosition, includeDeclaration: boolean): Promise<ILocation[]>;
+    getSignatureHelp(documentUri: string, position: IPosition): Promise<ISignatureHelp | undefined>;
+    getRename(documentUri: string, position: IPosition, newName: string): Promise<IWorkspaceEdit | undefined>;
+    prepareRename(documentUri: string, position: IPosition): Promise<ITextEdit | undefined>;
     dispose(): Promise<void>;
     addEventListener<T extends LanguageServiceEvent["type"]>(type: T, listener: (event: Extract<LanguageServiceEvent, {
         type: T;
@@ -40,13 +39,11 @@ export type ILanguageServiceWorker = ILanguageService & IServiceProxy;
 export declare class QSharpLanguageService implements ILanguageService {
     private languageService;
     private eventHandler;
-    private code;
     private readFile;
     private backgroundWork;
     constructor(wasm: QscWasm, readFile?: (uri: string) => Promise<string | null>, listDir?: (uri: string) => Promise<[string, number][]>, getManifest?: (uri: string) => Promise<{
         manifestDirectory: string;
     } | null>);
-    loadFile(uri: string): Promise<string | null>;
     updateConfiguration(config: IWorkspaceConfiguration): Promise<void>;
     updateDocument(documentUri: string, version: number, code: string): Promise<void>;
     updateNotebookDocument(notebookUri: string, version: number, metadata: INotebookMetadata, cells: {
@@ -56,13 +53,13 @@ export declare class QSharpLanguageService implements ILanguageService {
     }[]): Promise<void>;
     closeDocument(documentUri: string): Promise<void>;
     closeNotebookDocument(documentUri: string): Promise<void>;
-    getCompletions(documentUri: string, offset: number): Promise<ICompletionList>;
-    getHover(documentUri: string, offset: number): Promise<IHover | undefined>;
-    getDefinition(documentUri: string, offset: number): Promise<ILocation | undefined>;
-    getReferences(documentUri: string, offset: number, includeDeclaration: boolean): Promise<ILocation[]>;
-    getSignatureHelp(documentUri: string, offset: number): Promise<ISignatureHelp | undefined>;
-    getRename(documentUri: string, offset: number, newName: string): Promise<IWorkspaceEdit | undefined>;
-    prepareRename(documentUri: string, offset: number): Promise<ITextEdit | undefined>;
+    getCompletions(documentUri: string, position: IPosition): Promise<ICompletionList>;
+    getHover(documentUri: string, position: IPosition): Promise<IHover | undefined>;
+    getDefinition(documentUri: string, position: IPosition): Promise<ILocation | undefined>;
+    getReferences(documentUri: string, position: IPosition, includeDeclaration: boolean): Promise<ILocation[]>;
+    getSignatureHelp(documentUri: string, position: IPosition): Promise<ISignatureHelp | undefined>;
+    getRename(documentUri: string, position: IPosition, newName: string): Promise<IWorkspaceEdit | undefined>;
+    prepareRename(documentUri: string, position: IPosition): Promise<ITextEdit | undefined>;
     dispose(): Promise<void>;
     addEventListener<T extends LanguageServiceEvent["type"]>(type: T, listener: (event: Extract<LanguageServiceEvent, {
         type: T;

package/dist/language-service/language-service.js

@@ -1,202 +1,50 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-import * as wasm from "../../lib/web/qsc_wasm.js";
 import { log } from "../log.js";
-import { mapDiagnostics, mapUtf16UnitsToUtf8Units, mapUtf8UnitsToUtf16Units, } from "../vsdiagnostic.js";
 export const qsharpLibraryUriScheme = "qsharp-library-source";
 export class QSharpLanguageService {
     constructor(wasm, readFile = () => Promise.resolve(null), listDir = () => Promise.resolve([]), getManifest = () => Promise.resolve(null)) {
         this.eventHandler = new EventTarget();
-        // We need to keep a copy of the code for mapping diagnostics to utf16 offsets
-        this.code = {};
         log.info("Constructing a QSharpLanguageService instance");
         this.languageService = new wasm.LanguageService();
         this.backgroundWork = this.languageService.start_background_work(this.onDiagnostics.bind(this), readFile, listDir, getManifest);
         this.readFile = readFile;
     }
-    async loadFile(uri) {
-        const result = this.code[uri];
-        if (result === undefined || result === null) {
-            return await this.readFile(uri);
-        }
-        if (result === null || result === undefined) {
-            log.error("File", uri, "wasn't in document map when we expected it to be");
-            return null;
-        }
-        return result;
-    }
     async updateConfiguration(config) {
         this.languageService.update_configuration(config);
     }
     async updateDocument(documentUri, version, code) {
-        this.code[documentUri] = code;
         this.languageService.update_document(documentUri, version, code);
     }
     async updateNotebookDocument(notebookUri, version, metadata, cells) {
-        // Note: If a cell was deleted, its uri & contents will remain in the map.
-        // This is harmless and it keeps the code simpler to just leave it this way
-        // instead of trying to maintain a perfect map.
-        for (const cell of cells) {
-            this.code[cell.uri] = cell.code;
-        }
         this.languageService.update_notebook_document(notebookUri, metadata, cells);
     }
     async closeDocument(documentUri) {
-        delete this.code[documentUri];
         this.languageService.close_document(documentUri);
     }
     async closeNotebookDocument(documentUri) {
         this.languageService.close_notebook_document(documentUri);
     }
-    async getCompletions(documentUri, offset) {
-        const code = await this.loadFile(documentUri);
-        if (code === null) {
-            log.error(`getCompletions: expected ${documentUri} to be in the document map`);
-            return { items: [] };
-        }
-        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], code)[offset];
-        const result = this.languageService.get_completions(documentUri, convertedOffset);
-        result.items.forEach((item) => item.additionalTextEdits?.forEach((edit) => {
-            updateSpanFromUtf8ToUtf16(edit.range, code);
-        }));
-        return result;
-    }
-    async getHover(documentUri, offset) {
-        const code = await this.loadFile(documentUri);
-        if (code === null) {
-            log.error(`getHover: expected ${documentUri} to be in the document map`);
-            return undefined;
-        }
-        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], code)[offset];
-        const result = this.languageService.get_hover(documentUri, convertedOffset);
-        if (result) {
-            updateSpanFromUtf8ToUtf16(result.span, code);
-        }
-        return result;
+    async getCompletions(documentUri, position) {
+        return this.languageService.get_completions(documentUri, position);
     }
-    async getDefinition(documentUri, offset) {
-        const sourceCode = await this.loadFile(documentUri);
-        if (sourceCode === undefined || sourceCode === null) {
-            log.error(`getDefinition: expected ${documentUri} to be in the document map`);
-            return undefined;
-        }
-        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], sourceCode)[offset];
-        const result = this.languageService.get_definition(documentUri, convertedOffset);
-        if (result) {
-            let targetCode = (await this.loadFile(result.source)) || null;
-            if (targetCode === null) {
-                // Inspect the URL protocol (equivalent to the URI scheme + ":").
-                // If the scheme is our library scheme, we need to call the wasm to
-                // provide the library file's contents to do the utf8->utf16 mapping.
-                const url = new URL(result.source);
-                if (url.protocol === qsharpLibraryUriScheme + ":") {
-                    targetCode = wasm.get_library_source_content(url.pathname) || null;
-                    if (targetCode === undefined) {
-                        log.error(`getDefinition: expected ${url} to be in the library`);
-                        return undefined;
-                    }
-                }
-            }
-            if (targetCode) {
-                updateSpanFromUtf8ToUtf16(result.span, targetCode);
-            }
-            else {
-                // https://github.com/microsoft/qsharp/issues/851
-                log.error(`cannot do utf8->utf16 mapping for ${result.source} since contents are not available`);
-            }
-        }
-        return result;
+    async getHover(documentUri, position) {
+        return this.languageService.get_hover(documentUri, position);
     }
-    async getReferences(documentUri, offset, includeDeclaration) {
-        const sourceCode = await this.loadFile(documentUri);
-        if (sourceCode === undefined || sourceCode === null) {
-            log.error(`getReferences: expected ${documentUri} to be in the document map`);
-            return [];
-        }
-        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], sourceCode)[offset];
-        const results = this.languageService.get_references(documentUri, convertedOffset, includeDeclaration);
-        if (results && results.length > 0) {
-            const references = [];
-            for (const result of results) {
-                let resultCode = await this.loadFile(result.source);
-                // Inspect the URL protocol (equivalent to the URI scheme + ":").
-                // If the scheme is our library scheme, we need to call the wasm to
-                // provide the library file's contents to do the utf8->utf16 mapping.
-                const url = new URL(result.source);
-                if (url.protocol === qsharpLibraryUriScheme + ":") {
-                    resultCode = wasm.get_library_source_content(url.pathname) || null;
-                    if (resultCode === undefined) {
-                        log.error(`getReferences: expected ${url} to be in the library`);
-                    }
-                }
-                if (resultCode) {
-                    updateSpanFromUtf8ToUtf16(result.span, resultCode);
-                    references.push(result);
-                }
-                else {
-                    // https://github.com/microsoft/qsharp/issues/851
-                    log.error(`cannot do utf8->utf16 mapping for ${result.source} since contents are not available`);
-                }
-            }
-            return references;
-        }
-        else {
-            return [];
-        }
+    async getDefinition(documentUri, position) {
+        return this.languageService.get_definition(documentUri, position);
     }
-    async getSignatureHelp(documentUri, offset) {
-        const code = await this.loadFile(documentUri);
-        if (code === null) {
-            log.error(`expected ${documentUri} to be in the document map`);
-            return undefined;
-        }
-        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], code)[offset];
-        const result = this.languageService.get_signature_help(documentUri, convertedOffset);
-        if (result) {
-            result.signatures = result.signatures.map((sig) => {
-                sig.parameters = sig.parameters.map((param) => {
-                    updateSpanFromUtf8ToUtf16(param.label, sig.label);
-                    return param;
-                });
-                return sig;
-            });
-        }
-        return result;
+    async getReferences(documentUri, position, includeDeclaration) {
+        return this.languageService.get_references(documentUri, position, includeDeclaration);
     }
-    async getRename(documentUri, offset, newName) {
-        const code = await this.loadFile(documentUri);
-        if (code === null) {
-            log.error(`expected ${documentUri} to be in the document map`);
-            return undefined;
-        }
-        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], code)[offset];
-        const result = this.languageService.get_rename(documentUri, convertedOffset, newName);
-        const mappedChanges = [];
-        for (const [uri, edits] of result.changes) {
-            const code = await this.loadFile(uri);
-            if (code) {
-                const mappedEdits = edits.map((edit) => {
-                    updateSpanFromUtf8ToUtf16(edit.range, code);
-                    return edit;
-                });
-                mappedChanges.push([uri, mappedEdits]);
-            }
-        }
-        result.changes = mappedChanges;
-        return result;
-    }
-    async prepareRename(documentUri, offset) {
-        const code = await this.loadFile(documentUri);
-        if (code === null) {
-            log.error(`expected ${documentUri} to be in the document map`);
-            return undefined;
-        }
-        const convertedOffset = mapUtf16UnitsToUtf8Units([offset], code)[offset];
-        const result = this.languageService.prepare_rename(documentUri, convertedOffset);
-        if (result) {
-            updateSpanFromUtf8ToUtf16(result.range, code);
-        }
-        return result;
+    async getSignatureHelp(documentUri, position) {
+        return this.languageService.get_signature_help(documentUri, position);
+    }
+    async getRename(documentUri, position, newName) {
+        return this.languageService.get_rename(documentUri, position, newName);
+    }
+    async prepareRename(documentUri, position) {
+        return this.languageService.prepare_rename(documentUri, position);
     }
     async dispose() {
         this.languageService.stop_background_work();
@@ -211,26 +59,11 @@ export class QSharpLanguageService {
     }
     async onDiagnostics(uri, version, diagnostics) {
         try {
-            const code = await this.loadFile(uri);
-            const empty = diagnostics.length === 0;
-            if (code === null && !empty) {
-                // We need the contents of the document to convert error offsets to utf16.
-                // But the contents aren't available after a document is closed.
-                // It is possible to get diagnostics events for a document after it's been closed,
-                // since document events are handled asynchronously by the language service.
-                // We just drop those diagnostics, assuming that eventually we will receive further
-                // events that will bring the diagnostics up to date.
-                // However, if we receive an *empty* array of diagnostics for a document, we don't want
-                // to drop that update. It's necessary for the diagnostics to get cleared for a document
-                // that has been closed.
-                log.warn(`onDiagnostics: received diagnostics for ${uri} which is not in the document map`);
-                return;
-            }
             const event = new Event("diagnostics");
             event.detail = {
                 uri,
                 version: version ?? 0,
-                diagnostics: empty ? [] : mapDiagnostics(diagnostics, code),
+                diagnostics,
             };
             this.eventHandler.dispatchEvent(event);
         }
@@ -239,8 +72,3 @@ export class QSharpLanguageService {
         }
     }
 }
-function updateSpanFromUtf8ToUtf16(span, code) {
-    const mappedSpan = mapUtf8UnitsToUtf16Units([span.start, span.end], code);
-    span.start = mappedSpan[span.start];
-    span.end = mappedSpan[span.end];
-}

package/dist/log.js

@@ -55,9 +55,8 @@ export const log = {
      * @param args - The format string and args to log, e.g. ["Index of %s is %i", str, index]
      */
     logWithLevel(level, target, ...args) {
-        // Convert to a format string containing the target (if present)
-        const [, ...trailingArgs] = args; // All but first element of args
-        const outArgs = [`[%s] ${args[0]}`, target || "", ...trailingArgs];
+        const [firstArg, ...trailingArgs] = args;
+        const outArgs = [`[${target || ""}] ${firstArg}`, ...trailingArgs];
         switch (level) {
             case 1:
                 log.error(...outArgs);