Add missing gates to QISKIT_CUSTOM_INSTRUCTIONS

Turns out that Terra's legacy importer went pretty overboard with all
the gates it added compared to the paper, and I missed several of them
that are defined in the middle of the file, rather than added onto the
end.

Author: jakelishman

docs/changelog.rst

@@ -2,6 +2,12 @@
 Changelog
 =========
 
+Unreleased
+==========
+
+* Added some missing gates to :data:`.QISKIT_CUSTOM_INSTRUCTIONS`; Qiskit's legacy importer
+  made rather a lot of changes to the file as presented in the paper!
+
 0.3.1 (2023-01-20)
 ==================
 

docs/parse.rst

@@ -56,6 +56,44 @@ In particular, in the Qiskit importers:
     2. the current working directory.
 
 * there are additional instructions defined in ``qelib1.inc``:
+    ``u0(gamma) a``
+      This is ambiguous.  Its provided definition suggests it is a no-op and that the `gamma`
+      parameter is ignored, but a comment above it describes it as a delay for `gamma` times the
+      length of the shortest single-qubit gate.  In compatibility mode, we require `gamma` to be an
+      integer, and set its definition to that many Qiskit :class:`.IGate`\ s.
+
+   ``u(theta, phi, lambda) a``
+      A synonym for the OpenQASM 2 builtin gate ``U``.  Corresponds to
+      :class:`~qiskit.circuit.library.UGate`.
+
+   ``p(lambda) a``
+      A synonym for the paper's ``u1``.  Corresponds to :class:`~qiskit.circuit.library.PhaseGate`,
+      which is a synonym of :class:`~qiskit.circuit.library.U1Gate`.
+
+   ``sx a``
+      :math:`\sqrt X` gate, corresponding to :class:`~qiskit.circuit.library.SXGate`.
+
+   ``sxdg a``
+      :math:`\sqrt X^\dagger` gate, corresponding to :class:`~qiskit.circuit.library.SXdgGate`.
+
+   ``swap a, b``
+      The swap gate, corresponding to :class:`~qiskit.circuit.library.SwapGate`.
+
+   ``cswap a, b, c``
+      The controlled swap gate, corresponding to :class:`~qiskit.circuit.library.CSwapGate`.
+
+   ``crx(theta) a, b``
+      Controlled rotation around the :math:`X` axis. Corresponds to
+      :class:`~qiskit.circuit.library.CRXGate`.
+
+   ``cry(theta) a, b``
+      Controlled rotation around the :math:`Y` axis. Corresponds to
+      :class:`~qiskit.circuit.library.CRYGate`.
+
+   ``cp(lambda) a, b``
+      Controlled phase gate, which is a synonym for the paper gate ``cu1``. Corresponds to
+      :class:`~qiskit.circuit.library.CPhaseGate`.
+
     ``csx a, b``
       Controlled :math:`\sqrt X` gate, corresponding to :class:`~qiskit.circuit.library.CSXGate`.
 

src-python/qiskit_qasm2/parse.py

@@ -89,13 +89,28 @@ def _generate_delay(t: float):
     return Delay(int(t), unit="dt")
 
 
+class _U0Gate(Gate):
+    def __init__(self, count):
+        if int(count) != count:
+            raise QASM2ParseError("the number of single-qubit delay lengths must be an integer")
+        super().__init__("u0", 1, [count])
+
+    def _define(self):
+        self._definition = QuantumCircuit(1)
+        for _ in [None] * self.params[0]:
+            self._definition.id(0)
+
+
 QISKIT_CUSTOM_INSTRUCTIONS = (
     CustomInstruction("u3", 3, 1, lib.U3Gate),
     CustomInstruction("u2", 2, 1, lib.U2Gate),
     CustomInstruction("u1", 1, 1, lib.U1Gate),
     CustomInstruction("cx", 0, 2, lib.CXGate),
     # The Qiskit parser emits IGate for 'id', even if that is not strictly accurate in Terra < 0.24.
     CustomInstruction("id", 0, 1, lib.IGate),
+    CustomInstruction("u0", 1, 1, _U0Gate, builtin=True),
+    CustomInstruction("u", 3, 1, lib.UGate, builtin=True),
+    CustomInstruction("p", 1, 1, lib.PhaseGate, builtin=True),
     CustomInstruction("x", 0, 1, lib.XGate),
     CustomInstruction("y", 0, 1, lib.YGate),
     CustomInstruction("z", 0, 1, lib.ZGate),
@@ -107,12 +122,19 @@ def _generate_delay(t: float):
     CustomInstruction("rx", 1, 1, lib.RXGate),
     CustomInstruction("ry", 1, 1, lib.RYGate),
     CustomInstruction("rz", 1, 1, lib.RZGate),
+    CustomInstruction("sx", 0, 1, lib.SXGate, builtin=True),
+    CustomInstruction("sxdg", 0, 1, lib.SXdgGate, builtin=True),
     CustomInstruction("cz", 0, 2, lib.CZGate),
     CustomInstruction("cy", 0, 2, lib.CYGate),
+    CustomInstruction("swap", 0, 2, lib.SwapGate, builtin=True),
     CustomInstruction("ch", 0, 2, lib.CHGate),
     CustomInstruction("ccx", 0, 3, lib.CCXGate),
+    CustomInstruction("cswap", 0, 3, lib.CSwapGate, builtin=True),
+    CustomInstruction("crx", 1, 2, lib.CRXGate, builtin=True),
+    CustomInstruction("cry", 1, 2, lib.CRYGate, builtin=True),
     CustomInstruction("crz", 1, 2, lib.CRZGate),
     CustomInstruction("cu1", 1, 2, lib.CU1Gate),
+    CustomInstruction("cp", 1, 2, lib.CPhaseGate, builtin=True),
     CustomInstruction("cu3", 3, 2, lib.CU3Gate),
     CustomInstruction("csx", 0, 2, lib.CSXGate, builtin=True),
     CustomInstruction("cu", 4, 2, lib.CUGate, builtin=True),

tests/test_structure.py

@@ -1198,6 +1198,15 @@ def test_qelib1_include_overridden(self):
     def test_qiskit_extra_builtins(self):
         program = """
             qreg q[5];
+            u(0.5 ,0.25, 0.125) q[0];
+            p(0.5) q[0];
+            sx q[0];
+            sxdg q[0];
+            swap q[0], q[1];
+            cswap q[0], q[1], q[2];
+            crx(0.5) q[0], q[1];
+            cry(0.5) q[0], q[1];
+            cp(0.5) q[0], q[1];
             csx q[0], q[1];
             cu(0.5, 0.25, 0.125, 0.0625) q[0], q[1];
             rxx(0.5) q[0], q[1];
@@ -1212,6 +1221,15 @@ def test_qiskit_extra_builtins(self):
             program, custom_instructions=qiskit_qasm2.QISKIT_CUSTOM_INSTRUCTIONS
         )
         qc = QuantumCircuit(QuantumRegister(5, "q"))
+        qc.append(lib.UGate(0.5, 0.25, 0.125), [0])
+        qc.append(lib.PhaseGate(0.5), [0])
+        qc.append(lib.SXGate(), [0])
+        qc.append(lib.SXdgGate(), [0])
+        qc.append(lib.SwapGate(), [0, 1])
+        qc.append(lib.CSwapGate(), [0, 1, 2])
+        qc.append(lib.CRXGate(0.5), [0, 1])
+        qc.append(lib.CRYGate(0.5), [0, 1])
+        qc.append(lib.CPhaseGate(0.5), [0, 1])
         qc.append(lib.CSXGate(), [0, 1])
         qc.append(lib.CUGate(0.5, 0.25, 0.125, 0.0625), [0, 1])
         qc.append(lib.RXXGate(0.5), [0, 1])
@@ -1223,6 +1241,14 @@ def test_qiskit_extra_builtins(self):
         qc.append(lib.C4XGate(), [0, 1, 2, 3, 4])
         assert parsed == qc
 
+        # There's also the 'u0' gate, but this is weird so we don't wildly care what its definition
+        # is and it has no Qiskit equivalent, so we'll just test that it using it doesn't produce an
+        # error.
+        parsed = qiskit_qasm2.loads(
+            'qreg q[1]; u0(1) q[0];', custom_instructions=qiskit_qasm2.QISKIT_CUSTOM_INSTRUCTIONS
+        )
+        assert parsed.data[0].operation.name == "u0"
+
     def test_qiskit_override_delay_opaque(self):
         program = """
             opaque delay(t) q;