N/M diagnostic code explorer

Add a module name before fn main().

Add fn main() { ... } around executable statements.

Keep indexes inside the declared qreg size, for example q[0] and q[1] for QReg<2>.

Use matching syntax such as let q: QReg<2> = qreg[2];

Use a number, PI, a declared constant, or arithmetic such as Ry(q[0], PI / 2);

Use distinct qubits for every operand, for example CNOT(q[0], q[1]) instead of CNOT(q[0], q[0]).

Use reset before more quantum gates, move the measurement later, or add @semantics("strict"); if this should block execution.

Remove the spare qubit or include it in the intended circuit.

Match the register width, for example assert probability(|00>) for QReg<2>.

Measure or derive a Bit first: let parity: Bit = a xor b; if (parity == 1) { ... }

Use measured bits with not/and/xor/or, for example let parity: Bit = a xor b.

Use a fresh Bit name for every measurement and derived Bit.

Only reference measured or earlier derived bits.

Use a form such as let s: Bit = syndrome Z(q[0]) Z(q[1]);

Use each qubit at most once in a syndrome measurement.

Define the circuit before calling adjoint qft(q); or inverse qft(q);

Keep adjoint circuit templates unitary and move non-unitary operations outside.

Pass the register followed by exactly the circuit's declared Angle arguments.

Use controlled q[0] { X(q[1]); } with one control qubit.

Use X, Y, Z, H, Ry, or Rz inside the controlled block.

Use a different target qubit in the controlled block body.

Keep one controlled block level or use explicit controlled gates.

Close the block after the final term, for example observable H = { Z(q[0]), };

Add at least one term such as -1.0 * I or 0.5 * Z(q[0]).

Use a registered import such as std.bell, algorithms.grover2, qec.repetition3, chemistry.h2_minimal, or optimization.maxcut2.

Use metric bell = probability(|00>); or metric energy = expect H;.

Close the block with } after the final metric, expectation, or assertion.

Use observe report_name { metric p00 = probability(|00>); }.

Use test "bell behavior" { assert probability(|00>) > 0.45; }.

Use property "bounded" { forall theta in 0 .. PI step PI / 2 { assert expectation Z(q[0]) <= 1; } }.

Use snapshot "bell golden" { H(q[0]); assert probability(|0>) > 0.4; }.

Use show state; to print the current state vector in Dirac notation.

Use @estimate(code: "surface", distance: 7, target_error: 1e-3); near the top of the program.

Use @dil("tr"); for Turkish keyword aliases or @dil("en"); for canonical N/M.

Use @explain("Describe this step."); before the statement you want to document.

Use @goal("Describe the lab objective."); near the top of the program.

Use @outcome("Explain why H creates a balanced state."); near the top of the program.

Use @rubric("Explain the probability distribution.", weight: 0.5); near the top of the program.

Use @misconception("H is not a random classical coin flip."); near the top of the program.

Use @quiz("What are the final probabilities?", answer: "50% for |0> and 50% for |1>."); near the top of the program.

Use @lab("bell-basics", minutes: 10); near the top of the program.

Use @challenge("bell-from-scratch", difficulty: "beginner"); near the top of the program.

Use @dataset("bell-balanced", split: "train"); near the top of the program.

Use @checkpoint("Predict before running.", kind: "predict"); near the top of the program.

Use @hint("Try changing the rotation angle."); near the top of the program.

Use @concept("superposition"); near the top of the program.

Use @level("beginner");, @level("intermediate");, or @level("advanced"); near the top of the program.

Use @prereq("basic-gates"); near the top of the program.

Rename the user circuit or choose a std import with a different exported circuit name.

Rename the user observable or choose a standard-library Hamiltonian with a different exported name.

Allocate a larger qreg or choose a helper with a smaller minQubits requirement.

Keep observe blocks to metric, expect, assert probability, assert expectation, assert entangled, and assert equivalent statements.

Allocate a larger qreg before using the imported Hamiltonian observable.

Use until (flag == 1) max 10 { ... } with max between 1 and 32.

Use the form if (m == 1) { X(q[1]); } with == or != on a measured bit.

Use numbers, PI, earlier constants and + - * /, e.g. const theta: Angle = PI / 4;

Use H, X, Y, Z, S, T, CNOT, CZ, SWAP, CCNOT, Ry, Rz, CRy, CRz, CP, or mark the example as spec preview.

Use @noise("depolarizing", p), @noise("pauli", p), @noise("readout", p), @noise("amplitude_damping", p), or @noise("phase_damping", p) with p between 0 and 1.

Keep playground examples at 5 qubits or fewer.

Use the supported runtime subset or keep the example as documentation preview.

Use repeat counts of 32 or fewer in browser examples.

Use @target("browser-statevector"), @target("ion-trap"), @target("superconducting"), or @target("neutral-atom").

Treat this as a capability warning; future compiler passes may decompose non-native gates.

Reduce repeat counts, simplify the ansatz, or split the algorithm into shallower stages.

Reduce entangling gates where possible; they usually dominate hardware error.

Read the SWAP routing sketch in the diagnostic hint, then decide whether to route, remap, or choose an all-to-all profile.

Reduce register size or choose a target profile with a larger educational qubit budget.

Use @constraints(maxDepth: 8, maxTwoQubit: 4, connectivity: "line").

Reduce register size or relax maxQubits for this experiment.

Shorten sequential gate chains, split the circuit, or raise maxDepth.

Reduce entangling operations or decompose the algorithm into a smaller budget.

Read the SWAP routing sketch in the diagnostic hint, then decide whether to route, remap, or relax the connectivity constraint.

Use @compiler(trace: true) to show compiler steps in the Trace tab.

Use @mitigation("readout") for readout noise or @mitigation("zne") for zero-noise extrapolation with a sample block.

No action is required; this informational diagnostic confirms tableau execution.

Remove the unsupported feature or use browser-statevector with at most five qubits.

Use 4,096 shots or fewer for local statevector and stabilizer execution.

Enable experimental.typedCollection or pass --experimental-typed-collection.

Use one bounded collection artifact per program.

Reduce K; it is never silently capped because K is part of the result type.

Choose a histogram with sample or an ordered artifact with collect<K>.

End with one let result: BitVec<N> = measure_all(q[start..end]); binding.

Add @seed(<unsigned integer>); before fn main.

Remove @noise/@mitigation or use sample for an aggregate noisy histogram.

Create a tableau with an integer qubit count from 1 through 100.

Resolve every target to an index inside the allocated tableau.

Use the documented native gate set or route the program to statevector execution.

Request an integer number of shots from 1 through 4,096.

Pass --target with one of the target ids published by the N/M spec catalog.

Run nm check and resolve blocking diagnostics before transpiling.

Choose another target, remove the gate, or wait for an additive lowering rule.

Treat the output as unusable and inspect the lowering trace; do not execute it as equivalent code.

Treat the result as failed and report the target, gate, and trace as a compiler defect.

Provide a non-empty id of at most 128 characters.

Use unique non-negative integer physical qubit ids.

Use canonical UTC timestamps, error rates in [0,1], positive durations, and the documented field types.

Enable enough physical qubits or reduce the logical register.

Declare each undirected edge once between two distinct declared qubits.

Provide a connected physical subset large enough for the workload or choose an all-to-all target.

Stay within 512 KiB JSON, 128 id characters, 256 qubits, and 4,096 couplings.

Provide every logical qubit exactly once and use distinct non-negative physical ids.

Declare every gate and coupling duration as a positive integer within JavaScript's safe integer range.

Start the operation at the maximum prior end time of all physical qubits it uses.

Use at most 100,000 operations and keep all accumulated times within the safe integer range.

Reject the schedule and regenerate it with the checked target scheduling API.

Run nm check and resolve blocking source diagnostics before export.

Complete training or provide final trained parameters before QASM3 export.

Declare a non-empty qreg before exporting.

Remove the unsupported operation or use preview mode with an explicit extension boundary.

Reject the carrier and report the source and lowering trace as a compiler defect.

Provide valid UTF-8 JSON produced by the versioned exporter.

Validate the sidecar against the documented 0.1, 0.2, or 0.3 reader contract.

Use nm-qasm3-sidecar@0.3 with nm-json-ir@0.1; legacy 0.1 and 0.2 remain readable.

Use sidecar version 0.1, 0.2, or 0.3, or publish an explicit lossless migrator first.

Remove unknown extensions or introduce them in a new versioned contract.

Stay within 40 MiB JSON and 100,000 IR statements.

Reject the sidecar and regenerate all projections from one canonical IR.

Declare param theta: Angle = 0.1; before the circuit uses it.

Bind a cost first with let cost = expect Z(q[0]); and target cost.

Merge all directives into one train block.

Use 1..100 steps and an lr in (0, 5] with gd, momentum, or adam.

Remove dataset or qng until its advertised capability is enabled.

Choose an id from the versioned embedded dataset catalog.

Add encode(sample_row(), q, method: "angle"); before the objective.

Use a supported method and an integer step count from 1 through 100.

Use a finite learningRate in (0, 5].

Use the name of an expectation binding, up to 128 identifier characters.

Bind a finite expectation cost and resolve runtime diagnostics.

Use a supported differentiable circuit and finite parameter values.

Reject the run and reduce the learning rate or correct invalid numeric inputs.

Use mse, hinge, or cross_entropy.

Provide a finite expectation prediction and a normalized binary label.

Reject the result and report the bounded input as a numerical defect.

Use 1..8 finite parameters, 1..100 steps, and descentSign -1 or 1.

Use a/c > 0, alpha/gamma in (0, 1], and stability >= 0.

Use a deterministic seeded source returning finite samples in [0, 1).

Ensure both perturbed candidates return finite costs.

Reject the update and correct the numeric workload or gain schedule.

Use at most eight finite known parameters and a bounded objective identifier.

Use the documented noiseless unitary subset or fall back to parameter-shift.

Reject the result and report the circuit as a numerical defect.

Use a registered nm-embedded-dataset@0.1 id.

Use 1..8 aligned finite features, -1/+1 labels, and no more than 80 rows.

Publish non-empty disjoint splits that cover each row exactly once and retain both labels in train.

Provide valid UTF-8 JSON produced by the versioned serializer.

Remove unknown fields or publish a new versioned contract first.

Stay within 256 KiB JSON, 80 rows, and eight features.

Use version 0.1 or publish and test a lossless migrator.

Move encode(... method: "amplitude") before every operation on that register.

Use a larger register or reduce the feature vector.

Provide at least one non-zero feature.

Use a normalized finite 1–8 qubit state, unique in-range indices, and 1–8 finite features.

Reject the result and report the bounded input as a numerical defect.

Use fewer layers, layer-wise training, or identity-block initialization.

Validate row features and -1/+1 labels, qubit/encoding options, ridge, model identity, and query values before kernel work.

Remove invalid or duplicate edges and use finite bounded weights, layers, steps, optimizer, and seed values.

Enable experimental.typedClassicalValues explicitly on the active Core, CLI, LSP, VS Code, Worker, or Playground surface.

Use let n: Int = 1; or let bits: Array<Bit, 2> = [a, b]; within the published bounds.

Use explicit bit_to_int or int_to_float conversion and keep array element types uniform.

Reference an earlier value once and keep literal indexes inside 0..N-1.

Reject the run and keep every intermediate value finite, initialized, and inside its declared type bound.

Enable experimental.targetCapabilityConstraints explicitly on the active Core, CLI, LSP, VS Code, Worker, or Playground surface.

Use one bounded @target_capabilities annotation with a profile and at least one valid constraint.

Select one registered profile consistently across both annotations.

Declare every source gate and choose only gates native to the selected profile.

Use the profile connectivity exactly; topology subsumption is intentionally disabled.

Choose a profile with a published reference model or increase the bounded error budget.

Enable experimental.functionResults explicitly on the active Core, CLI, LSP, VS Code, Worker, or Playground surface.

Use one final return ok(value); or return error("UPPER_SNAKE_CODE"); matching a bounded declared T.

Return the declared scalar or fixed array type and use explicit conversions instead of implicit coercion.

Compute the result first and end main with exactly one top-level ok(...) or error(...) return.

Reject the engine execution without fabricating a user-program error result, then correct the referenced runtime value.

Enable experimental.composedNoise explicitly on the active Core, CLI, LSP, VS Code, Worker, or Playground surface.

Declare one through four uniquely named profiles and activate exactly one declared name.

Use one published local, correlated_pauli, or readout channel with a literal probability in 0..0.25.

Stay within four profiles, eight channels per profile, five statevector qubits, 4,096 shots, and probability 0.25.

Use an exact compile-time qreg index or contiguous slice from the current program.

Use a 2..5-character I/X/Y/Z word with at least one non-identity character and exact scope width.

Provide @seed, one bounded sample block, and @target("browser-statevector").

Run the composed profile by itself and keep mitigation or QEC experiments in a separate program.

Correct the exact gate and register view or remove the no-op channel.

Recompile from source and use JSON IR until a versioned target carrier preserves channel scope and ordering.

Place assertions before measurement or adjust the expected threshold.