Add experimental OpenQASM 3 support for switch

[jakelishman]

Summary

This changes Terra's OpenQASM 3 exporter to add support for the IBM QSS switch extension to the OpenQASM 3 language. This is currently only a pull request to the OpenQASM 3 specification, so its syntax might be subject to some amount of change, and it is hidden behind an "experimental" flag in the exporter.

Details and comments

See openqasm/openqasm#463. Since the PR is not formally accepted yet, it is possible that the syntax might change slightly. Terra is adding support for the feature eagerly, before acceptance, but essentially hidden behind a "vendor" flag (c.f. web browsers' --moz, --webkit etc CSS prefixes) until the proposal is formally accepted into the language. The experimental feature flag is versioned as a precaution, so we can eagerly add support for new syntaxes if they are suggested, but the merge process still takes time. Without any flag specified, Terra will not produce any extra-spec OpenQASM 3, but instead will raise an exception.

---

Note: before merge, I need to re-verify that this can pass all the way through the IBM QSS stack. I last did that in December, so there's a chance that I've screwed something up / things have changed a little since.

[qiskit-bot]

Thank you for opening a new pull request.

Before your PR can be merged it will first need to pass continuous integration tests and be reviewed. Sometimes the review process can be slow, so please be patient.

While you're waiting, please feel free to review other open PRs. While only a subset of people are authorized to approve pull requests for merging, everyone is encouraged to review open pull requests. Doing reviews helps reduce the burden on the core team and helps make the project's code better for everyone.

One or more of the the following people are requested to review this:

• @Qiskit/terra-core

[coveralls]

Pull Request Test Coverage Report for Build 4705344190

• 132 of 136 (97.06%) changed or added relevant lines in 5 files are covered.
• 15 unchanged lines in 4 files lost coverage.
• Overall coverage increased (+0.04%) to 85.821%

---

Changes Missing Coverage	Covered Lines	Changed/Added Lines	%
qiskit/qasm3/exporter.py	62	63	98.41%
qiskit/qasm3/printer.py	44	47	93.62%

Files with Coverage Reduction	New Missed Lines	%
qiskit/circuit/tools/pi_check.py	1	91.23%
qiskit/pulse/library/waveform.py	3	91.67%
crates/accelerate/src/sabre_swap/layer.rs	4	97.32%
crates/qasm2/src/lex.rs	7	90.89%

Totals
Change from base Build 4704167625:	0.04%
Covered Lines:	70600
Relevant Lines:	82264

---

💛 - Coveralls

[mtreinish]

Overall this LGTM, just a few minor comments inline mostly docs stuff.

[mtreinish]

I tagged this as on hold to put the block in place until the manual validation is done. Once you confirm it's all working we can remove the tag (not that it blocks the merge queue like it did with mergify)

[jakelishman]

I've fixed the documentation, and with all of the current switch PRs merged together, I was able to run this script on Wellington:

from qiskit import (
    QuantumCircuit,
    QuantumRegister,
    ClassicalRegister,
    transpile,
    qasm3,
)
from qiskit_ibm_provider import IBMProvider

backend = IBMProvider().get_backend("ibm_wellington")

def hacky_execute(qc, backend):
    # Temporary workaround 1: trick Qiskit into knowing Wellington supports
    # switch-case. Fixing this requires re-deployment of Wellington's config,
    # and for the IBM Provider to learn about `SwitchCaseOp` in order to update
    # its reported `Target`.
    if "switch_case" not in backend.target:
        from qiskit.circuit import SwitchCaseOp

        backend.target.add_instruction(SwitchCaseOp, name="switch_case")

    transpiled = transpile(qc, backend)

    # Temporary workaround 2: I can't directly call `backend.run` with the
    # circuit, because the IBM Provider doesn't yet know how to
    # serialise/deserialise the new operation.
    qasm3_program = qasm3.dumps(
        transpiled,
        disable_constants=True,
        experimental=qasm3.ExperimentalFeatures.SWITCH_CASE_V1,
    )
    print(qasm3_program)

    job = backend.run(qasm3_program, dynamic=True)
    print(job.job_id())
    print(job.result().get_counts())


regs = [QuantumRegister(3), ClassicalRegister(3)]

# Generate |000> + |001> + ... + |111>.
qc1 = QuantumCircuit(*regs)
qc1.h(regs[0])
qc1.measure(regs[0], regs[1])
with qc1.switch(regs[1]) as case:
    # Reset back to zero, unless we measured 7, in which case leave it in
    # place.  This is obviously an inefficient way of doing that on hardware.
    for i in range(7):
        with case(i):
            for j in range(3):
                if i & (1 << j):
                    qc1.x(j)
    # qss-compiler requires a `default` case (but Qiskit doesn't).
    with case(case.DEFAULT):
        pass
qc1.measure(regs[0], regs[1])

# The builder interface can also accept multiple cases pointing to the same
# block.  The syntax for that is like:
qc2 = QuantumCircuit(*regs)
qc2.h([0, 1, 2])
qc2.measure([0, 1, 2], [0, 1, 2])
with qc2.switch(regs[1]) as case:
    with case(0, 1, 2, 3):
        qc2.x(0)
    with case(4, 5, 6, 7):
        qc2.h(0)
        qc2.cx(0, 1)
    with case(case.DEFAULT):
        pass
qc2.measure([0, 1, 2], [0, 1, 2])


hacky_execute(qc1, backend)
print("\n" + "-" * 80 + "\n")
hacky_execute(qc2, backend)

with the result:

OPENQASM 3;
include "stdgates.inc";
bit[3] c2;
int switch_dummy;
rz(1.5707963267949) $0;
sx $0;
rz(1.5707963267949) $0;
rz(1.5707963267949) $1;
sx $1;
rz(1.5707963267949) $1;
rz(1.5707963267949) $2;
sx $2;
rz(1.5707963267949) $2;
c2[0] = measure $0;
c2[1] = measure $1;
c2[2] = measure $2;
switch_dummy = c2;
switch (switch_dummy) {
  case 0: {
  }
  break;
  case 1: {
    x $0;
  }
  break;
  case 2: {
    x $1;
  }
  break;
  case 3: {
    x $0;
    x $1;
  }
  break;
  case 4: {
    x $2;
  }
  break;
  case 5: {
    x $2;
    x $0;
  }
  break;
  case 6: {
    x $2;
    x $1;
  }
  break;
  default: {
  }
  break;
}
c2[0] = measure $0;
c2[1] = measure $1;
c2[2] = measure $2;

cgsvh9tc26uins2q1aig
{'0': 3234, '1': 39, '10': 367, '11': 4, '100': 76, '101': 259, '110': 6, '111': 15}

--------------------------------------------------------------------------------

OPENQASM 3;
include "stdgates.inc";
bit[3] c2;
int switch_dummy;
rz(1.5707963267949) $0;
sx $0;
rz(1.5707963267949) $0;
rz(1.5707963267949) $1;
sx $1;
rz(1.5707963267949) $1;
rz(1.5707963267949) $2;
sx $2;
rz(1.5707963267949) $2;
c2[0] = measure $0;
c2[1] = measure $1;
c2[2] = measure $2;
switch_dummy = c2;
switch (switch_dummy) {
  case 0:
  case 1:
  case 2:
  case 3: {
    x $0;
  }
  break;
  case 4:
  case 5:
  case 6:
  case 7: {
    rz(1.5707963267949) $0;
    sx $0;
    rz(1.5707963267949) $0;
    cx $0, $1;
  }
  break;
  default: {
  }
  break;
}
c2[0] = measure $0;
c2[1] = measure $1;
c2[2] = measure $2;

cgsvhdg2tle0vokl6h3g
{'0': 1260, '1': 723, '10': 37, '11': 9, '100': 1025, '101': 736, '110': 122, '111': 88}

So it works in principle. There's only so much testing I can do as a single person manually before we have support all the way through the stack, but at least the base cases work.