qsharp-lang 1.15.0 → 1.15.1-dev

package/dist/browser.d.ts

@@ -24,4 +24,4 @@ export { default as samples } from "./samples.generated.js";
 export { log, type LogLevel, type TargetProfile };
 export type { ICompiler, ICompilerWorker, IDebugService, IDebugServiceWorker, ILanguageService, ILanguageServiceWorker, };
 export * as utils from "./utils.js";
-export type { Circuit as CircuitData } from "./shared/circuit.js";
+export type { CircuitGroup as CircuitData } from "./shared/circuit.js";

package/dist/compiler/compiler.d.ts

@@ -1,4 +1,4 @@
-import { type Circuit as CircuitData } from "../shared/circuit.js";
+import { type CircuitGroup as CircuitData } from "../shared/circuit.js";
 import { IDocFile, IOperationInfo, IPackageGraphSources, IProgramConfig as wasmIProgramConfig, TargetProfile, type VSDiagnostic } from "../../lib/web/qsc_wasm.js";
 import { IServiceProxy, ServiceProtocol, ServiceState } from "../workers/common.js";
 import { IQscEventTarget, QscEventData } from "./events.js";

package/dist/compiler/compiler.js

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+import { CURRENT_VERSION, } from "../shared/circuit.js";
 import { log } from "../log.js";
 import { eventStringToMsg } from "./common.js";
 import { makeEvent, } from "./events.js";
@@ -59,7 +60,11 @@ export class Compiler {
         return this.wasm.get_estimates(toWasmProgramConfig(program, "unrestricted"), expr, params);
     }
     async getCircuit(program, simulate, operation) {
-        return this.wasm.get_circuit(toWasmProgramConfig(program, "unrestricted"), simulate, operation);
+        const circuit = this.wasm.get_circuit(toWasmProgramConfig(program, "unrestricted"), simulate, operation);
+        return {
+            circuits: [circuit],
+            version: CURRENT_VERSION,
+        };
     }
     // Returns all autogenerated documentation files for the standard library
     // and loaded project (if requested). This include file names and metadata,

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

@@ -1,4 +1,4 @@
-import { type Circuit as CircuitData } from "../shared/circuit.js";
+import { type CircuitGroup as CircuitData } from "../shared/circuit.js";
 import type { IBreakpointSpan, IQuantumState, IStackFrame, IStructStepResult, IVariable } from "../../lib/web/qsc_wasm.js";
 import { ProgramConfig } from "../browser.js";
 import { IQscEventTarget, QscEventData } from "../compiler/events.js";

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

@@ -1,5 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
+import { CURRENT_VERSION, } from "../shared/circuit.js";
 import { eventStringToMsg } from "../compiler/common.js";
 import { makeEvent, } from "../compiler/events.js";
 import { log } from "../log.js";
@@ -25,7 +26,11 @@ export class QSharpDebugService {
         return state.entries;
     }
     async getCircuit() {
-        return this.debugService.get_circuit();
+        const circuit = this.debugService.get_circuit();
+        return {
+            circuits: [circuit],
+            version: CURRENT_VERSION,
+        };
     }
     async getStackFrames() {
         return this.debugService.get_stack_frames().frames;

package/dist/katas-content.generated.js

@@ -1666,7 +1666,7 @@ export default {
                         {
                             "type": "example",
                             "id": "multi_qubit_systems__multi_qubit_systems_demo",
-                            "code": "namespace Kata {\n    import Std.Diagnostics.*;\n\n    @EntryPoint()\n    operation MultiQubitSystemsDemo() : Unit {\n        // This allocates an array of 2 qubits, each of them in state |0⟩.\n        // The overall state of the system is |00⟩.\n        use qs = Qubit[2];\n        // X gate changes the first qubit into state |1⟩.\n        X(qs[0]);\n        Message(\"The system in now in state |10⟩:\");\n        DumpMachine();\n\n        // This changes the second qubit into state |+⟩ = (1/sqrt(2))(|0⟩ + |1⟩).\n        H(qs[1]);\n        Message(\"The system in now in state  (1/sqrt(2))(|10⟩ + |11⟩):\");\n        DumpMachine();\n\n        // This changes the first qubit into state |-⟩ = (1/sqrt(2))(|0⟩ - |1⟩)\n        H(qs[0]);\n        Message(\"The system in now in state 0.5(|00⟩ + |01⟩ - |10⟩ - |11⟩):\");\n        DumpMachine();\n\n        // The next lines entangle the qubits (don't worry about what exactly they do for now).\n        H(qs[1]);\n        CNOT(qs[0], qs[1]);\n        Message(\"The system in now in entangled state 0.5(|00⟩ - |11⟩):\");\n        DumpMachine();\n\n        // This returns the system into state |00⟩.\n        ResetAll(qs);\n    }\n}\n"
+                            "code": "namespace Kata {\n    import Std.Diagnostics.*;\n\n    @EntryPoint()\n    operation MultiQubitSystemsDemo() : Unit {\n        // This allocates an array of 2 qubits, each of them in state |0⟩.\n        // The overall state of the system is |00⟩.\n        use qs = Qubit[2];\n        // X gate changes the first qubit into state |1⟩.\n        X(qs[0]);\n        Message(\"The system in now in state |10⟩:\");\n        DumpMachine();\n\n        // This changes the second qubit into state |+⟩ = (1/sqrt(2))(|0⟩ + |1⟩).\n        H(qs[1]);\n        Message(\"The system in now in state  (1/sqrt(2))(|10⟩ + |11⟩):\");\n        DumpMachine();\n\n        // This changes the first qubit into state |-⟩ = (1/sqrt(2))(|0⟩ - |1⟩)\n        H(qs[0]);\n        Message(\"The system in now in state 0.5(|00⟩ + |01⟩ - |10⟩ - |11⟩):\");\n        DumpMachine();\n\n        // The next lines entangle the qubits (don't worry about what exactly they do for now).\n        H(qs[1]);\n        CNOT(qs[0], qs[1]);\n        Message(\"The system in now in entangled state (1/sqrt(2))(|00⟩ - |11⟩):\");\n        DumpMachine();\n\n        // This returns the system into state |00⟩.\n        ResetAll(qs);\n    }\n}\n"
                         },
                         {
                             "type": "text-content",

package/dist/katas-content.generated.md.js

@@ -1666,7 +1666,7 @@ export default {
                         {
                             "type": "example",
                             "id": "multi_qubit_systems__multi_qubit_systems_demo",
-                            "code": "namespace Kata {\n    import Std.Diagnostics.*;\n\n    @EntryPoint()\n    operation MultiQubitSystemsDemo() : Unit {\n        // This allocates an array of 2 qubits, each of them in state |0⟩.\n        // The overall state of the system is |00⟩.\n        use qs = Qubit[2];\n        // X gate changes the first qubit into state |1⟩.\n        X(qs[0]);\n        Message(\"The system in now in state |10⟩:\");\n        DumpMachine();\n\n        // This changes the second qubit into state |+⟩ = (1/sqrt(2))(|0⟩ + |1⟩).\n        H(qs[1]);\n        Message(\"The system in now in state  (1/sqrt(2))(|10⟩ + |11⟩):\");\n        DumpMachine();\n\n        // This changes the first qubit into state |-⟩ = (1/sqrt(2))(|0⟩ - |1⟩)\n        H(qs[0]);\n        Message(\"The system in now in state 0.5(|00⟩ + |01⟩ - |10⟩ - |11⟩):\");\n        DumpMachine();\n\n        // The next lines entangle the qubits (don't worry about what exactly they do for now).\n        H(qs[1]);\n        CNOT(qs[0], qs[1]);\n        Message(\"The system in now in entangled state 0.5(|00⟩ - |11⟩):\");\n        DumpMachine();\n\n        // This returns the system into state |00⟩.\n        ResetAll(qs);\n    }\n}\n"
+                            "code": "namespace Kata {\n    import Std.Diagnostics.*;\n\n    @EntryPoint()\n    operation MultiQubitSystemsDemo() : Unit {\n        // This allocates an array of 2 qubits, each of them in state |0⟩.\n        // The overall state of the system is |00⟩.\n        use qs = Qubit[2];\n        // X gate changes the first qubit into state |1⟩.\n        X(qs[0]);\n        Message(\"The system in now in state |10⟩:\");\n        DumpMachine();\n\n        // This changes the second qubit into state |+⟩ = (1/sqrt(2))(|0⟩ + |1⟩).\n        H(qs[1]);\n        Message(\"The system in now in state  (1/sqrt(2))(|10⟩ + |11⟩):\");\n        DumpMachine();\n\n        // This changes the first qubit into state |-⟩ = (1/sqrt(2))(|0⟩ - |1⟩)\n        H(qs[0]);\n        Message(\"The system in now in state 0.5(|00⟩ + |01⟩ - |10⟩ - |11⟩):\");\n        DumpMachine();\n\n        // The next lines entangle the qubits (don't worry about what exactly they do for now).\n        H(qs[1]);\n        CNOT(qs[0], qs[1]);\n        Message(\"The system in now in entangled state (1/sqrt(2))(|00⟩ - |11⟩):\");\n        DumpMachine();\n\n        // This returns the system into state |00⟩.\n        ResetAll(qs);\n    }\n}\n"
                         },
                         {
                             "type": "text-content",

package/dist/shared/circuit.d.ts

@@ -1,20 +1,103 @@
 import { Register } from "./register.js";
+/**
+ * Current format version.
+ */
+export declare const CURRENT_VERSION = 1;
+export interface CircuitGroup {
+    circuits: Circuit[];
+    version: number;
+}
 /**
  * Circuit to be visualized.
  */
 export interface Circuit {
     /** Array of qubit resources. */
     qubits: Qubit[];
-    operations: Operation[];
+    componentGrid: ComponentGrid;
+}
+export type ComponentGrid = Column[];
+export interface Column {
+    components: Component[];
 }
+/**
+ * Represents a component of a circuit. Currently, the only component is an operation.
+ * In the future, this may be extended to include other components.
+ */
+export type Component = Operation;
 /**
  * Represents a unique qubit resource bit.
  */
 export interface Qubit {
     /** Qubit ID. */
     id: number;
-    /** Number of classical registers attached to quantum register. */
-    numChildren?: number;
+    /** Number of measurement results associated to the qubit. */
+    numResults?: number;
+}
+/**
+ * Base type for operations.
+ */
+export interface BaseOperation {
+    /** Gate label. */
+    gate: string;
+    /** Formatted gate arguments. */
+    args?: string[];
+    /** The parameters expected for the operation. */
+    params?: Parameter[];
+    /** Nested operations within this operation. */
+    children?: ComponentGrid;
+    /** Custom data attributes to attach to gate element.
+    Note that this is never written to file, so it is not part of the circuit schema */
+    dataAttributes?: DataAttributes;
+    /** Whether gate is a conditional operation. */
+    isConditional?: boolean;
+    /** Specify conditions on when to render operation. */
+    conditionalRender?: ConditionalRender;
+}
+/**
+ * Represents a measurement operation and the registers it acts on.
+ */
+export interface Measurement extends BaseOperation {
+    /** Discriminator for the Operation type */
+    kind: "measurement";
+    /** The qubit registers the gate measures. */
+    qubits: Register[];
+    /** The classical registers the gate writes to. */
+    results: Register[];
+}
+/**
+ * Represents a unitary operation and the registers it acts on.
+ */
+export interface Unitary extends BaseOperation {
+    /** Discriminator for the Operation type */
+    kind: "unitary";
+    /** Target registers the gate acts on. */
+    targets: Register[];
+    /** Control registers the gate acts on. */
+    controls?: Register[];
+    /** Whether gate is an adjoint operation. */
+    isAdjoint?: boolean;
+}
+/**
+ * Represents a gate that sets its targets to a specific state.
+ */
+export interface Ket extends BaseOperation {
+    /** Discriminator for the Operation type */
+    kind: "ket";
+    /** Target registers the gate acts on. */
+    targets: Register[];
+}
+/**
+ * Union type for operations.
+ */
+export type Operation = Unitary | Measurement | Ket;
+/**
+ * A parameter for an operation.
+ */
+export interface Parameter {
+    /** Parameter name. */
+    name: string;
+    /** Parameter's Q# type. */
+    type: string;
 }
 /**
  * Conditions on when to render the given operation.
@@ -35,30 +118,3 @@ export declare enum ConditionalRender {
 export interface DataAttributes {
     [attr: string]: string;
 }
-/**
- * Represents an operation and the registers it acts on.
- */
-export interface Operation {
-    /** Gate label. */
-    gate: string;
-    /** Formatted gate arguments to be displayed. */
-    displayArgs?: string;
-    /** Nested operations within this operation. */
-    children?: Operation[];
-    /** Whether gate is a measurement operation. */
-    isMeasurement: boolean;
-    /** Whether gate is a conditional operation. */
-    isConditional: boolean;
-    /** Whether gate is a controlled operation. */
-    isControlled: boolean;
-    /** Whether gate is an adjoint operation. */
-    isAdjoint: boolean;
-    /** Control registers the gate acts on. */
-    controls?: Register[];
-    /** Target registers the gate acts on. */
-    targets: Register[];
-    /** Specify conditions on when to render operation. */
-    conditionalRender?: ConditionalRender;
-    /** Custom data attributes to attach to gate element. */
-    dataAttributes?: DataAttributes;
-}

package/dist/shared/circuit.js

@@ -1,5 +1,9 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT license.
+/**
+ * Current format version.
+ */
+export const CURRENT_VERSION = 1;
 /**
  * Conditions on when to render the given operation.
  */

package/dist/shared/legacyCircuitUpdate.d.ts

@@ -0,0 +1,9 @@
+import { CircuitGroup } from "./circuit.js";
+/**
+ * Ensures that the given circuit object is a CircuitGroup, doing any
+ * necessary conversions from Circuit or legacy formats.
+ *
+ * @param circuit The circuit to convert.
+ * @returns The converted CircuitGroup.
+ */
+export declare function toCircuitGroup(circuit: any): CircuitGroup;

package/dist/shared/legacyCircuitUpdate.js

@@ -0,0 +1,312 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT license.
+import { getMinMaxRegIdx } from "../utils.js";
+import { CURRENT_VERSION, } from "./circuit.js";
+/**
+ * Ensures that the given circuit object is a CircuitGroup, doing any
+ * necessary conversions from Circuit or legacy formats.
+ *
+ * @param circuit The circuit to convert.
+ * @returns The converted CircuitGroup.
+ */
+export function toCircuitGroup(circuit) {
+    const emptyCircuit = {
+        qubits: [],
+        componentGrid: [],
+    };
+    const emptyCircuitGroup = {
+        version: CURRENT_VERSION,
+        circuits: [emptyCircuit],
+    };
+    if (circuit && Object.keys(circuit).length === 0) {
+        return emptyCircuitGroup;
+    }
+    if (circuit?.version) {
+        const version = circuit.version;
+        // If it has a "version" field, it is up-to-date
+        if (isCircuitGroup(circuit)) {
+            // If it's already a CircuitGroup, return it as is
+            return circuit;
+        }
+        else if (isCircuit(circuit)) {
+            // If it's a Circuit, wrap it in a CircuitGroup
+            return {
+                version,
+                circuits: [circuit],
+            };
+        }
+        else {
+            console.error("Unknown schema: circuit is neither a CircuitGroup nor a Circuit.");
+            return emptyCircuitGroup;
+        }
+    }
+    else if (isCircuit(circuit)) {
+        // If it's a Circuit without a version, wrap it in a CircuitGroup
+        return {
+            version: CURRENT_VERSION,
+            circuits: [circuit],
+        };
+    }
+    else if (circuit?.operations) {
+        // Legacy schema: convert to CircuitGroup
+        if (circuit.qubits === undefined || !Array.isArray(circuit.qubits)) {
+            console.error("Unknown schema: circuit is missing qubit information.");
+            return emptyCircuitGroup;
+        }
+        const qubits = circuit.qubits.map((qubit) => {
+            return {
+                id: qubit.id,
+                numResults: qubit.numChildren || 0, // Rename "numChildren" to "numResults"
+            };
+        });
+        const componentGrid = operationListToGrid(circuit.operations.map(toOperation), qubits.length);
+        return {
+            version: CURRENT_VERSION,
+            circuits: [
+                {
+                    qubits,
+                    componentGrid,
+                },
+            ],
+        };
+    }
+    else {
+        console.error("Unknown schema: circuit does not match any known format.");
+        return emptyCircuitGroup;
+    }
+}
+/**
+ * Converts a legacy operation object to the new Operation format.
+ *
+ * @param op The operation to convert.
+ * @returns The converted Operation.
+ */
+function toOperation(op) {
+    let targets = [];
+    if (op.targets) {
+        targets = op.targets.map((t) => {
+            return {
+                qubit: t.qId,
+                result: t.cId,
+            };
+        });
+    }
+    let controls = undefined;
+    if (op.controls) {
+        controls = op.controls.map((c) => {
+            return {
+                qubit: c.qId,
+                result: c.cId,
+            };
+        });
+    }
+    if (op.isMeasurement) {
+        return {
+            ...op,
+            kind: "measurement",
+            qubits: controls || [],
+            results: targets,
+        };
+    }
+    else {
+        const ket = getKetLabel(op.gate);
+        if (ket.length > 0) {
+            return {
+                ...op,
+                kind: "ket",
+                gate: ket,
+                targets,
+            };
+        }
+        else {
+            const convertedOp = {
+                ...op,
+                kind: "unitary",
+                targets,
+                controls,
+            };
+            if (op.displayArgs) {
+                convertedOp.args = [op.displayArgs];
+                // Assume the parameter is always "theta" for now
+                convertedOp.params = [{ name: "theta", type: "Double" }];
+            }
+            if (op.children) {
+                convertedOp.children = [
+                    {
+                        components: op.children.map((child) => toOperation(child)),
+                    },
+                ];
+            }
+            return convertedOp;
+        }
+    }
+}
+/**
+ * Checks if the given object is a CircuitGroup.
+ *
+ * @param circuit The object to check.
+ * @returns True if the object is a CircuitGroup, false otherwise.
+ */
+function isCircuitGroup(circuit) {
+    return circuit && Array.isArray(circuit.circuits);
+}
+/**
+ * Checks if the given object is a Circuit.
+ *
+ * @param circuit The object to check.
+ * @returns True if the object is a Circuit, false otherwise.
+ */
+function isCircuit(circuit) {
+    return (circuit &&
+        Array.isArray(circuit.qubits) &&
+        Array.isArray(circuit.componentGrid));
+}
+/**
+ * Get the label from a ket string.
+ *
+ * @param ket The ket string to extract the label from.
+ * @returns The label extracted from the ket string.
+ */
+function getKetLabel(ket) {
+    // Check that the ket conforms to the format |{label}> or |{label}⟩
+    const ketRegex = /^\|([^\s〉⟩〉>]+)(?:[〉⟩〉>])$/;
+    // Match the ket string against the regex
+    const match = ket.match(ketRegex);
+    // If valid, return the inner label (captured group 1), otherwise return an empty string
+    return match ? match[1] : "";
+}
+/**
+ * Converts a list of operations into a 2D grid of operations in col-row format.
+ * Operations will be left-justified as much as possible in the resulting grid.
+ * Children operations are recursively converted into a grid.
+ *
+ * @param operations Array of operations.
+ * @param numQubits  Number of qubits in the circuit.
+ *
+ * @returns A 2D array of operations.
+ */
+function operationListToGrid(operations, numQubits) {
+    operations.forEach((op) => {
+        // The children data structure is a grid, so checking if it is
+        // length 1 is actually checking if it has a single column,
+        // or in other words, we are checking if its children are in a single list.
+        // If the operation has children in a single list, it needs to be converted to a grid.
+        // If it was already converted to a grid, but the grid was still a single list,
+        // then doing it again won't effect anything.
+        if (op.children && op.children.length == 1) {
+            op.children = operationListToGrid(op.children[0].components, numQubits);
+        }
+    });
+    return removePadding(operationListToPaddedArray(operations, numQubits)).map((col) => ({
+        components: col,
+    }));
+}
+/**
+ * Converts a list of operations into a padded 2D array of operations.
+ *
+ * @param operations Array of operations.
+ * @param numQubits  Number of qubits in the circuit.
+ *
+ * @returns A 2D array of operations padded with `null`s.
+ */
+function operationListToPaddedArray(operations, numQubits) {
+    if (operations.length === 0)
+        return [];
+    // Group operations based on registers
+    const groupedOps = groupOperations(operations, numQubits);
+    // Align operations on multiple registers
+    const alignedOps = transformToColRow(alignOps(groupedOps));
+    const operationArray = alignedOps.map((col) => col.map((opIdx) => {
+        if (opIdx == null)
+            return null;
+        return operations[opIdx];
+    }));
+    return operationArray;
+}
+/**
+ * Removes padding (`null` values) from a 2D array of operations.
+ *
+ * @param operations 2D array of operations padded with `null`s.
+ *
+ * @returns A 2D array of operations without `null` values.
+ */
+function removePadding(operations) {
+    return operations.map((col) => col.filter((op) => op != null));
+}
+/**
+ * Transforms a row-col 2D array into an equivalent col-row 2D array.
+ *
+ * @param alignedOps 2D array of operations in row-col format.
+ *
+ * @returns 2D array of operations in col-row format.
+ */
+function transformToColRow(alignedOps) {
+    if (alignedOps.length === 0)
+        return [];
+    const numRows = alignedOps.length;
+    const numCols = Math.max(...alignedOps.map((row) => row.length));
+    const colRowArray = Array.from({ length: numCols }, () => Array(numRows).fill(null));
+    for (let row = 0; row < numRows; row++) {
+        for (let col = 0; col < alignedOps[row].length; col++) {
+            colRowArray[col][row] = alignedOps[row][col];
+        }
+    }
+    return colRowArray;
+}
+/**
+ * Group gates provided by operations into their respective registers.
+ *
+ * @param operations Array of operations.
+ * @param numQubits  Number of qubits in the circuit.
+ *
+ * @returns 2D array of indices where `groupedOps[i][j]` is the index of the operations
+ *          at register `i` and column `j` (not yet aligned/padded).
+ */
+function groupOperations(operations, numQubits) {
+    const groupedOps = Array.from(Array(numQubits), () => new Array(0));
+    operations.forEach((operation, instrIdx) => {
+        const [minRegIdx, maxRegIdx] = getMinMaxRegIdx(operation, numQubits);
+        // Add operation also to registers that are in-between target registers
+        // so that other gates won't render in the middle.
+        for (let i = minRegIdx; i <= maxRegIdx; i++) {
+            groupedOps[i].push(instrIdx);
+        }
+    });
+    return groupedOps;
+}
+/**
+ * Aligns operations by padding registers with `null`s to make sure that multiqubit
+ * gates are in the same column.
+ * e.g. ---[x]---[x]--
+ *      ----------|---
+ *
+ * @param ops 2D array of operations. Each row represents a register
+ *            and the operations acting on it (in-order).
+ *
+ * @returns 2D array of aligned operations padded with `null`s.
+ */
+function alignOps(ops) {
+    let maxNumOps = Math.max(0, ...ops.map((regOps) => regOps.length));
+    let col = 0;
+    // Deep copy ops to be returned as paddedOps
+    const paddedOps = ops.map((regOps) => [...regOps]);
+    while (col < maxNumOps) {
+        for (let regIdx = 0; regIdx < paddedOps.length; regIdx++) {
+            const reg = paddedOps[regIdx];
+            if (reg.length <= col)
+                continue;
+            // Should never be null (nulls are only padded to previous columns)
+            const opIdx = reg[col];
+            // Get position of gate
+            const targetsPos = paddedOps.map((regOps) => regOps.indexOf(opIdx));
+            const gatePos = Math.max(-1, ...targetsPos);
+            // If current column is not desired gate position, pad with null
+            if (col < gatePos) {
+                paddedOps[regIdx].splice(col, 0, null);
+                maxNumOps = Math.max(maxNumOps, paddedOps[regIdx].length);
+            }
+        }
+        col++;
+    }
+    return paddedOps;
+}

package/dist/shared/register.d.ts

@@ -9,12 +9,10 @@ export declare enum RegisterType {
  * Represents a register resource.
  */
 export interface Register {
-    /** Type of register. If missing defaults to Qubit. */
-    type?: RegisterType;
     /** Qubit register ID. */
-    qId: number;
-    /** Classical register ID (if classical register). */
-    cId?: number;
+    qubit: number;
+    /** Classical register ID. If present, register is classical register. */
+    result?: number;
 }
 /**
  * Metadata for qubit register.

package/dist/utils.d.ts

@@ -1,3 +1,4 @@
+import { Operation } from "./shared/circuit.js";
 export type Tick = {
     value: number;
     label: string;
@@ -21,4 +22,12 @@ export declare function getRanges(data: SeriesOfPoints, rangeCoefficient: number
         max: number;
     };
 };
+/**
+ * Get the minimum and maximum register indices for a given operation.
+ *
+ * @param operation The operation for which to get the register indices.
+ * @param numQubits The number of qubits in the circuit.
+ * @returns A tuple containing the minimum and maximum register indices.
+ */
+export declare function getMinMaxRegIdx(operation: Operation, numQubits: number): [number, number];
 export {};

package/dist/utils.js

@@ -146,3 +146,44 @@ export function getRanges(data, rangeCoefficient) {
     };
     return { rangeX, rangeY };
 }
+/**
+ * Get the minimum and maximum register indices for a given operation.
+ *
+ * @param operation The operation for which to get the register indices.
+ * @param numQubits The number of qubits in the circuit.
+ * @returns A tuple containing the minimum and maximum register indices.
+ */
+export function getMinMaxRegIdx(operation, numQubits) {
+    let targets;
+    let controls;
+    switch (operation.kind) {
+        case "measurement":
+            targets = operation.results;
+            controls = operation.qubits;
+            break;
+        case "unitary":
+            targets = operation.targets;
+            controls = operation.controls || [];
+            break;
+        case "ket":
+            targets = operation.targets;
+            controls = [];
+            break;
+    }
+    const ctrls = controls || [];
+    const qRegs = [...ctrls, ...targets].filter(({ result }) => result === undefined);
+    const qRegIdxList = qRegs.map(({ qubit }) => qubit);
+    const clsControls = ctrls.filter(({ result }) => result !== undefined);
+    const isClassicallyControlled = clsControls.length > 0;
+    if (!isClassicallyControlled && qRegs.length === 0)
+        return [-1, -1];
+    // If operation is classically-controlled, pad all qubit registers. Otherwise, only pad
+    // the contiguous range of registers that it covers.
+    const minRegIdx = isClassicallyControlled
+        ? 0
+        : Math.min(...qRegIdxList);
+    const maxRegIdx = isClassicallyControlled
+        ? numQubits - 1
+        : Math.max(...qRegIdxList);
+    return [minRegIdx, maxRegIdx];
+}

package/docs/Microsoft.Quantum.Core/Length.md

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core.Length
 title: Length exported item
 description: "Q# Length exported item: This is an exported item. The actual definition is found here: [Std.Core.Length](xref:Qdk.Std.Core.Length)"
-ms.date: 03/31/2025
+ms.date: 04/17/2025
 ms.topic: managed-reference
 qsharp.kind: export
 qsharp.package: __Std__

package/docs/Microsoft.Quantum.Core/Repeated.md

@@ -2,7 +2,7 @@
 uid: Qdk.Microsoft.Quantum.Core.Repeated
 title: Repeated exported item
 description: "Q# Repeated exported item: This is an exported item. The actual definition is found here: [Std.Core.Repeated](xref:Qdk.Std.Core.Repeated)"
-ms.date: 03/31/2025
+ms.date: 04/17/2025
 ms.topic: managed-reference
 qsharp.kind: export
 qsharp.package: __Std__

package/docs/Microsoft.Quantum.Core/index.md

@@ -4,7 +4,7 @@ title: Microsoft.Quantum.Core namespace
 description: Table of contents for the Q# Microsoft.Quantum.Core namespace
 author: {AUTHOR}
 ms.author: {MS_AUTHOR}
-ms.date: 03/31/2025
+ms.date: 04/17/2025
 ms.topic: landing-page
 ---