Ensure support for new rx and rzz gates

[cqc-alec]

No description provided.

[CalMacCQ]

We could have an enum for the available gatesets

class GateSet(Enum):
    FALCON = {OpType.X, OpType.SX, OpType.Rz, OpType.CX} # No longer supported
    EAGLE = {OpType.X, OpType.SX, OpType.Rz, OpType.ECR}
    HERON = {OpType.Rx, OpType.ZZPhase, ...}
    ...

Also whatever the name for the ${X, CZ, SX, Rz}$ gateset is (although maybe thats being replaced)

[CalMacCQ]

Blogpost -> https://www.ibm.com/quantum/blog/fractional-gates
docs -> https://docs.quantum.ibm.com/guides/fractional-gates

[CalMacCQ]

Had a look into whether I could compile and run circuits with the new gates. Good news and bad news. The good news is that the backends already recognise that ZZPhase and Rx gates are part of the native gateset for ibm_torino. However at least for the example I tried the Rx gate isn't used in the compiled circuit indicating that we may need to update the rebasing. It also seems we have trouble running a circuit on the real ibm torino device although execution on the emulator seems to work fine.

from pytket.extensions.qiskit import IBMQEmulatorBackend

emulator = IBMQEmulatorBackend("ibm_torino")
print(emulator.backend_info.gate_set)

Output:

{<OpType.RangePredicate: 17>,
 <OpType.X: 23>,
 <OpType.SX: 31>,
 <OpType.Rx: 34>,
 <OpType.Rz: 36>,
 <OpType.CZ: 47>,
 <OpType.noop: 65>,
 <OpType.Measure: 66>,
 <OpType.Reset: 68>,
 <OpType.ZZPhase: 76>,
 <OpType.Conditional: 110>}

Lets test compilation with a simple three qubit circuit

from pytket import Circuit
from pytket.circuit.display import render_circuit_jupyter as draw

test_circ = Circuit(3).CX(0, 1).CX(0, 2).measure_all()

cc_emulator = emulator.get_compiled_circuit(test_circ)

print("Circuit valid?", emulator.valid_circuit(cc_emulator))
draw(c_emulator_circ)

Output

Circuit valid? True

Note the presence of ZZPhase gates and absence of Rx gates. We may need to update the rebasing to reduce the number of single qubit gates (using Rx gates where its advantageous to do so).

Execution of this circuit on the emulator seems to work fine

emulator_result = emulator.run_circuit(cc_emulator, n_shots=100)
# executes successfully

What about the real device? i.e. IBMQBackend

from pytket.extensions.qiskit import IBMQBackend

torino_device = IBMQBackend("ibm_torino")

device_circ = cc_emulator.copy()
print("Circuit valid?", torino_device.valid_circuit(device_circ))

Output:

Circuit valid? True

Execution on the backend seems not to work though

torino_handle = torino_device.process_circuit(device_circ, n_shots=100)

gives

IBMInputValueError: 'The instruction rzz on qubits (79, 80) is not supported by the target system. Circuits that do not match the target hardware definition are no longer supported after March 4, 2024. See the transpilation documentation (https://docs.quantum.ibm.com/guides/transpile) for instructions to transform circuits and the primitive examples (https://docs.quantum.ibm.com/guides/primitives-examples) to see this coupled with operator transformations.'

This seems reminicant of the ECR directionality issue -> #312

Also weird as interactions between Nodes 79 and 80 are recognised as valid

from pytket._tket.unit_id import Node

print((Node(79), Node(80)) in torino_device.backend_info.architecture.coupling)

Output:

True

This also agrees with a direct check from ibm

print( (79, 80) in list(ibm_torino.coupling_map))

Output:

True