- Starting skills
- Basic quantum circuits, programming types and control flow
- Portfolio output
- Three-program semantic contract and backend capability table
- A useful completion check
- Every claimed supported feature has versioned implementation evidence
- Hardware needed
- No
- Execution status
- Proposed conformance cases unless actual logs are later added
The OpenQASM 3.1 specification describes a language for expressing quantum programs together with classical computation and control. A language specification, however, does not establish that every backend implements every feature. This pathway uses a few small programs to build a capability contract between a program’s meaning and an execution target. The project is an original compatibility review, not a claim that a particular provider accepts the examples, a compiler speed benchmark or a current software vacancy.
Begin with three short examples that require different capabilities. One can use only a fixed gate sequence, another can depend on a measured value, and a third can use an explicitly documented classical or timing feature. For each example, write a plain-language statement of the required behaviour. Keep syntax and semantics separate: a parser may accept a construct even when the selected execution target cannot provide its intended behaviour. The contract should identify the earliest stage at which an unsupported requirement becomes visible.
The next step is a capability table. List the required feature, the evidence for its meaning in the specification and the evidence, if any, for support by a named implementation. Use unknown when support has not been checked. Do not infer support from the broad label OpenQASM compatible. If a compiler lowers a feature into another representation, record the assumptions and limitations of that transformation. A program that runs after a silent approximation may answer a different question from the one written in the source.
Add a small negative test that produces a useful diagnostic. The goal is not to create a large test suite that mirrors the implementation. It is to show how a reviewer would distinguish a syntax error, an unsupported capability and an invalid physical assumption. Include the exact software version and the full diagnostic message for any executed test. Where execution is unavailable, keep the example as a proposed conformance case and do not invent a compiler response. This distinction makes the portfolio credible even when it covers more than one execution environment.
Questions to take with you
Does parsing a program prove it can run?
No. Parsing checks syntax. Execution also requires the implementation and physical target to support the program’s required capabilities and constraints.
What belongs in an unknown cell?
The missing evidence and a specific verification action, such as checking the provider’s current feature documentation or running a small authorised conformance case. Unknown should not be replaced by assumed compatibility.
Self-directed project; no vacancy, completed execution, certification or employer endorsement is implied. Pin the software environment before presenting runnable code.
Sources and what they show (2)
- OpenQASM 3.1 specification ↗OpenQASM project · Version 3.1
Quantum and classical language specification
Language definition is distinct from backend implementation support.
- OpenQASM 3.1 classical instructions ↗OpenQASM project · Version 3.1
Classical types and computation boundaries
Externally implemented operations can have execution constraints; do not assume universal real-time support.