[BUG] Creation of Qnode with a Azure device via Qiskit

[Willem-de-kok]

Expected behavior

I would expect that via 'qiskit.remote', I could actually create a qml.QNode where I use as a device an azure.quantum device. I expect that, because the azure.quantum.qiskit package is set up via Qiskit. And the docs on remote devices https://docs.pennylane.ai/projects/qiskit/en/latest/devices/remote.html state:

The 'qiskit.remote' device is a generic adapter to use any Qiskit backend as interface for a PennyLane device.

Actual behavior

'num_qubits' property of the azure backend is not identified, and hence the Qnode can not be created.

Additional information

I recently discussed with some of the Pennylane colleagues the 'way-to-go' when wanting to run Pennylane circuits on Azure devices. They suggested to go from a QuantumTape through OpenQasm to a qiskit.QuantumCircuit representation, to then eventually run the qiskit.QuantumCircuit on an Azure-device.

I think that is a valid way and probably most stable under new updates of Pennylane, Qiskit or Azure.quantum SDKs. Nevertheless, it would be great if this was also a possibility.

If there is some clear reason why this won't work, I am also very happy to learn why that is the case.

Source code

from azure.quantum.qiskit import AzureQuantumProvider
from azure.quantum import Workspace
import pennylane as qml

workspace = Workspace.from_connection_string("<key>")
provider = AzureQuantumProvider(workspace)

azure_backend = provider.get_backend("quantinuum.sim.h2-1sc")
device = qml.device('qiskit.remote', wires=2, backend=azure_backend, shots=10)

def circuit():
    qml.Hadamard(0)
    qml.CNOT([0, 1])
    return qml.probs([0, 1])

qnode = qml.QNode(circuit, device)
print(qnode())

Tracebacks

PennyLaneDeprecationWarning: Setting shots on device is deprecated. Please use the `set_shots` transform on the respective QNode instead.
  warnings.warn(
Traceback (most recent call last):
  File "C:\pennylane_qiskit_converter\azure_connect_via_pennylane.py", line 57, in <module>
    device = qml.device('qiskit.remote', wires=2, backend=azure_backend, shots=10)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\pennylane-qiskit-converter\venv\Lib\site-packages\pennylane\devices\device_constructor.py", line 264, in device
    dev = plugin_device_class(*args, **options)
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "C:\pennylane-qiskit-converter\venv\Lib\site-packages\pennylane_qiskit\remote.py", line 146, in __init__
    super().__init__(wires, backend=backend, shots=shots, **kwargs)
  File "C:\pennylane_qiskit\qiskit_device.py", line 358, in __init__
    if len(self.wires) > int(self.backend.num_qubits):
                             ^^^^^^^^^^^^^^^^^^^^^^^
AttributeError: 'QuantinuumSyntaxCheckerQirBackend' object has no attribute 'num_qubits'

System information

Name: pennylane
Version: 0.43.1
Summary: PennyLane is a cross-platform Python library for quantum computing, quantum machine learning, and quantum chemistry. Train a quantum computer the same way as a neural network.
Home-page: 
Author: 
Author-email: 
License-Expression: Apache-2.0
Location: C:\pennylane-qiskit-converter\venv\Lib\site-packages
Requires: appdirs, autograd, autoray, cachetools, diastatic-malt, networkx, numpy, packaging, pennylane-lightning, requests, rustworkx, scipy, tomlkit, typing_extensions
Required-by: PennyLane-qiskit, pennylane_lightning, tno.quantum.plugins.pennylane_qiskit_converter

Platform info:           Windows-10-10.0.26100-SP0
Python version:          3.11.10
Numpy version:           2.3.4
Scipy version:           1.16.3
JAX version:             None
Installed devices:
- default.clifford (pennylane-0.43.1)
- default.gaussian (pennylane-0.43.1)
- default.mixed (pennylane-0.43.1)
- default.qubit (pennylane-0.43.1)
- default.qutrit (pennylane-0.43.1)
- default.qutrit.mixed (pennylane-0.43.1)
- default.tensor (pennylane-0.43.1)
- null.qubit (pennylane-0.43.1)
- reference.qubit (pennylane-0.43.1)
- lightning.qubit (pennylane_lightning-0.43.0)
- qiskit.aer (PennyLane-qiskit-0.43.0)
- qiskit.basicaer (PennyLane-qiskit-0.43.0)
- qiskit.basicsim (PennyLane-qiskit-0.43.0)
- qiskit.remote (PennyLane-qiskit-0.43.0)

Existing GitHub issues

• I have searched existing GitHub issues to make sure the issue does not already exist.

[DSGuala]

Hi @Willem-de-kok, thanks for opening this issue. We're taking a look.
There may be a workaround using the cirq plugin, which is also capable of dispatching to Azure Quantum.

If there is some clear reason why this won't work, I am also very happy to learn why that is the case.

For now, I don't think there is a reason. But we'll update as we investigate.

One hypothesis for why this isn't working is that Azure Quantum may still be using qiskit's BackendV1. We may be able to supoprt this with an extra logic branch that handles BackendV1 requirements.

[Willem-de-kok]

Thanks @DSGuala!

The workaround via the cirq plugin is a useful suggestion. We might want to have a look into it.

If it is indeed the case that Azure Quantum is still using BackendV1, I would say this is an issue to be resolved by the Azure Quantum team, as I don't want to encourage your team to put work in supporting older versions of qiskit. Would it be an option for you to reach out to the Azure Quantum team to see whether they are willing to improve their qiskit connection?

[DSGuala]

Looks like the Azure Quantum team just migrated to BackendV2 yesterday 😆
Related PR here: microsoft/azure-quantum-python#694

Would you mind trying again using the main branch of the Azure Quantum repo?

[jessetvogel]

Hi @DSGuala (I'm a colleague of @Willem-de-kok), thanks for your help!

I tried running the initial script of Willem again, using the main branch of the azure-quantum repository. Unfortunately, it does not work yet, the job fails. There seems to be something wrong with the job input that is sent to Azure. See below the job input and the resulting error output.

Job input that was sent to Azure:

%Result = type opaque
%Qubit = type opaque

@empty_tag = internal constant [1 x i8] c"\00"
@0 = internal constant [6 x i8] c"0_a0r\00"
@1 = internal constant [6 x i8] c"1_a1r\00"

define i64 @ENTRYPOINT__main() #0 {
block_0:
  call void @__quantum__rt__initialize(i8* null)
  call void @__quantum__qis__h__body(%Qubit* inttoptr (i64 0 to %Qubit*))
  call void @__quantum__qis__cx__body(%Qubit* inttoptr (i64 0 to %Qubit*), %Qubit* inttoptr (i64 1 to %Qubit*))
  call void @__quantum__qis__barrier__body()
  call void @__quantum__qis__m__body(%Qubit* inttoptr (i64 0 to %Qubit*), %Result* inttoptr (i64 0 to %Result*))
  call void @__quantum__qis__m__body(%Qubit* inttoptr (i64 1 to %Qubit*), %Result* inttoptr (i64 1 to %Result*))
  call void @__quantum__rt__array_record_output(i64 2, i8* getelementptr inbounds ([1 x i8], [1 x i8]* @empty_tag, i64 0, i64 0))
  call void @__quantum__rt__result_record_output(%Result* inttoptr (i64 1 to %Result*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @0, i64 0, i64 0))
  call void @__quantum__rt__result_record_output(%Result* inttoptr (i64 0 to %Result*), i8* getelementptr inbounds ([6 x i8], [6 x i8]* @1, i64 0, i64 0))
  ret i64 0
}

declare void @__quantum__rt__initialize(i8*)

declare void @__quantum__qis__h__body(%Qubit*)

declare void @__quantum__qis__cx__body(%Qubit*, %Qubit*)

declare void @__quantum__qis__barrier__body()

declare void @__quantum__qis__m__body(%Qubit*, %Result*) #1

declare void @__quantum__rt__array_record_output(i64, i8*)

declare void @__quantum__rt__result_record_output(%Result*, i8*)

attributes #0 = { "entry_point" "output_labeling_schema" "qir_profiles"="base_profile" "required_num_qubits"="2" "required_num_results"="2" }
attributes #1 = { "irreversible" }

; module flags

!llvm.module.flags = !{!0, !1, !2, !3}

!0 = !{i32 1, !"qir_major_version", i32 1}
!1 = !{i32 7, !"qir_minor_version", i32 0}
!2 = !{i32 1, !"dynamic_qubit_management", i1 false}
!3 = !{i32 1, !"dynamic_result_management", i1 false}

Error output:

Error code: QATTransformationFailed

Error message: error - /controller/artifacts/preProcessedQir.bc:15,45 - External call '__quantum__qis__barrier__body:void ()' is not allowed for this adaptor (generic). error - /controller/artifacts/preProcessedQir.bc:15,45 - Fatal error: QIR is not valid within the defined adaptor IR did not validate to the adaptor constraints. ;
# Components ;
disable-spec......................................: false ;
disable-qat.......................................: false ;
disable-adaptor.replacement-linking...............: false ;
disable-adaptor.llvm-optimization.................: false ;
disable-adaptor.remove-non-entrypoint-functions...: false ;
disable-adaptor.target-qis-mapping................: false ;
disable-adaptor.target-profile-mapping............: false ;
disable-adaptor.straightline-code-requirement.....: false ;
disable-adaptor.static-resources..................: false ;
disable-adaptor.grouping..........................: false ;
disable-target.profile............................: false ;
disable-target.qis................................: false ;
; # Specification ;
spec-version......................................: 0.9 ;
entry-point-attr..................................: entry_point ;
qir-profiles-attr.................................: qir_profiles ;
output-labeling-schema-attr.......................: output_labeling_schema ;
required-num-qubits-attr..........................: requiredQubits ;
required-num-results-attr.........................: requiredResults ;
max-index-qubits-attr.............................: maxQubitIndex ;
max-index-results-attr............................: maxResultIndex ;
replace-with-attr.................................: replaceWith ;
irreversible-attr.................................: irreversible ;
qir-runtime-prefix................................: __quantum__rt__ ;
; # QAT base configuration ;
load..............................................: ;
apply.............................................: true ;
validate..........................................: true ;
adaptor...........................................: provider_ea35 ;
adaptor-pipeline..................................: replacement-linking,llvm-optimization,remove-non-entrypoint-functions,target-qis-mapping,static-resources,target-profile-mapping,straightline-code-requirement,grouping ;
emit-human-readable-llvm..........................: false ;
target-def........................................: /controller/target_ea35.yaml ;
save-config.......................................: ;
verify-module.....................................: true ;
experimental......................................: false ;
dump-config.......................................: true ;
add-ir-debug......................................: false ;
strip-existing-dbg................................: false ;
output............................................: /controller/artifacts/QATOutput.bc ;
save-logs.........................................: ;
version...........................................: false ;
help..............................................: false ;
; # Replacement linking ;
replace-functions.................................: ;
remove-call-attributes............................: false ;
; # LLVM optimizations ;
unroll-loops......................................: true ;
allow-partial.....................................: true ;
allow-peeling.....................................: true ;
allow-runtime.....................................: true ;
allow-upper-bound.................................: true ;
allow-profile-based-peeling.......................: true ;
full-unroll-count.................................: 1024 ;
unroll-opt-level..................................: 3 ;
only-when-forced..................................: false ;
forget-scev.......................................: false ;
always-inline.....................................: true ;
inlining-parameter................................: 2147483647 ;
eliminate-constants...............................: true ;
eliminate-dead-code...............................: true ;
eliminate-memory..................................: true ;
; # Remove Non-Entrypoint Functions ;
; # Target QIS mapping ;
delete-dead-code..................................: false ;
clone-functions...................................: false ;
transform-execution-path-only.....................: false ;
max-recursion.....................................: 1 ;
assume-no-except..................................: false ;
reuse-qubits......................................: false ;
reuse-results.....................................: false ;
optimize-result-one...............................: true ;
optimize-result-zero..............................: true ;
optimize-result-comparison........................: true ;
use-static-qubit-array-allocation.................: true ;
use-static-qubit-allocation.......................: true ;
use-static-result-allocation......................: true ;
disable-reference-counting........................: true ;
disable-alias-counting............................: true ;
disable-string-support............................: true ;
disable-initialize-support........................: true ;
disable-record-output-support.....................: false ;
; # Target profile mapping ;
lower-switch......................................: true ;
should-eleminate-zext-i1..........................: true ;
defer-measurements................................: true ;
; # Post transform validation ;
disable-straightline-code-requirement.............: true ;
; # Static resource manipulation ;
annotate-qubit-use................................: true ;
annotate-result-use...............................: true ;
annotate-max-qubit-index..........................: true ;
annotate-max-result-index.........................: true ;
reindex-qubits....................................: true ;
replace-qubit-on-reset............................: true ;
inline-after-id-change............................: true ;
; # Grouping quantum instructions ;
group-qis.........................................: false ;
; # Target profile validation ;
allow-internal-calls..............................: true ;
allow-poison......................................: false ;
allow-undef.......................................: false ;
opcodes...........................................: inttoptr,;ret,;call, ;
allowlist-opcodes.................................: true ;
allowlist-external-calls..........................: true ;
allowlist-pointer-types...........................: true ;
allow-primitive-return............................: true ;
allow-struct-return...............................: true ;
allow-pointer-return..............................: true ;
external-calls....................................: __quantum__rt__tuple_record_output:void (i64, i8*),__quantum__rt__result_record_output:void (%Result*, i8*),__quantum__rt__array_record_output:void (i64, i8*) ;
allowed-pointer-types.............................: Qubit*,Result*,i8* ;
; # Target QIS validation ;
allowed-qis.......................................: __quantum__qis__ry__body:void (double, %Qubit*),__quantum__qis__rx__body:void (double, %Qubit*),__quantum__qis__y__body:void (%Qubit*),__quantum__qis__h__body:void (%Qubit*),__quantum__qis__t__adj:void (%Qubit*),__quantum__qis__s__body:void (%Qubit*),__quantum__qis__z__body:void (%Qubit*),__quantum__qis__cnot__body:void (%Qubit*, %Qubit*),__quantum__qis__rz__body:void (double, %Qubit*),__quantum__qis__swap__body:void (%Qubit*, %Qubit*),__quantum__qis__cz__body:void (%Qubit*, %Qubit*),__quantum__qis__x__body:void (%Qubit*),__quantum__qis__mz__body:void (%Qubit*, %Result*),__quantum__qis__t__body:void (%Qubit*),__quantum__qis__read_result__body:i1 (%Result*),__quantum__qis__s__adj:void (%Qubit*) ;
allow-any-qis.....................................: false ;
irreversible-operations...........................: __quantum__qis__mz__body ;
requires-qubits...................................: true ;
requires-results..................................: true ;

For completeness, my system information:

Name: pennylane
Version: 0.43.1
Summary: PennyLane is a cross-platform Python library for quantum computing, quantum machine learning, and quantum chemistry. Train a quantum computer the same way as a neural network.
Home-page: 
Author: 
Author-email: 
License-Expression: Apache-2.0
Location: /workspaces/PENNYLANE-AZURE/.venv/lib/python3.13/site-packages
Requires: appdirs, autograd, autoray, cachetools, diastatic-malt, networkx, numpy, packaging, pennylane-lightning, requests, rustworkx, scipy, tomlkit, typing_extensions
Required-by: PennyLane-qiskit, pennylane_lightning

Platform info:           Linux-6.6.87.2-microsoft-standard-WSL2-x86_64-with-glibc2.39
Python version:          3.13.1
Numpy version:           2.3.5
Scipy version:           1.16.3
JAX version:             None
Installed devices:
- qiskit.aer (PennyLane-qiskit-0.43.0)
- qiskit.basicaer (PennyLane-qiskit-0.43.0)
- qiskit.basicsim (PennyLane-qiskit-0.43.0)
- qiskit.remote (PennyLane-qiskit-0.43.0)
- lightning.qubit (pennylane_lightning-0.43.0)
- default.clifford (pennylane-0.43.1)
- default.gaussian (pennylane-0.43.1)
- default.mixed (pennylane-0.43.1)
- default.qubit (pennylane-0.43.1)
- default.qutrit (pennylane-0.43.1)
- default.qutrit.mixed (pennylane-0.43.1)
- default.tensor (pennylane-0.43.1)
- null.qubit (pennylane-0.43.1)
- reference.qubit (pennylane-0.43.1)

Let me know if you need more information.

[CatalinaAlbornoz]

Hi @jessetvogel ,

Thanks for adding these details. We will get back to you on this next week.

[DSGuala]

Hi @jessetvogel ,

Our current thinking is that the Barrier operation may not be necessary in this context. The next step on our side is to troubleshoot skipping it in our standard Qiskit function conversion and see if that fixes the problem without introducing any other errors. (Thanks @lillian542 for this insight)

[DSGuala]

@jessetvogel @Willem-de-kok ,

Do you want to try again with this branch of the pennylane-qiskit plugin that skips the barrier operation? Still using the master version of Azure Quantum.

I think this command should do the trick:

pip install git+https://github.com/PennyLaneAI/pennylane-qiskit@skip-barrier

[idavis]

The latest public release of the azure-quantum package should support BackendV2.

In the original issue the backend being used is Quantinuum based and later when the QIR input is provided the user is submitting to an IonQ target which doesn't allow barrier.

To the best of my knowledge, Qiskit users are expected to transpile, or generate_preset_pass_manager using the BackendV2 and Target they are trying to use. This should remove the barrier calls in the ciruit for all backends except those for Quantinuum.

In the case where PennLane is accepting a BackendV2 instance, it seems like there is a decision to be made of how to handle barrier. Whether PennyLane transpiles already, transpile doesn't effect barrier emissions. Those have to be processed separately as Qiskit refuses fo remove them by default as far as I can tell.

Transpile sample:

circuit = ...
backend = ...
from qiskit.transpiler import transpile
circuit = transpile(circuit, backend, optimization_level=0)

generate_preset_pass_manager example:

circuit = ...
backend = ...
from qiskit.transpiler import generate_preset_pass_manager
pass_manager = generate_preset_pass_manager(optimization_level=0, backend=backend)
circuit = pass_manager.run(circuit)

Barriers can be explicitly pruned with the Qiskit PassManager

circuit = ...
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import RemoveBarriers
pass_manager = PassManager()
pass_manager.append(RemoveBarriers())
circuit = pass_manager.run(circuit)

[jessetvogel]

Thanks @DSGuala and @idavis ! Due to Azure subscription problems I couldn't test it myself, but a colleague of mine reported that removing the barriers indeed solves the problem.

[CatalinaAlbornoz]

Thanks for sharing these details @idavis !!
And thanks for confirming that this fixes the issue @jessetvogel.
Are we ok with closing this issue since it's not a bug but more of an unsupported feature in IonQ devices?

[jessetvogel]

I agree that it is not a bug of QiskitDevice (the transpile method should just remove the barriers to make the circuit compatible with the backend), but the issue remains that we cannot use IonQ devices using PennyLane.

As far as I can see, it is not possible to add transforms / preprocess methods to the QiskitDevice to remove the barriers, right?

The fix of @DSGuala does solve our issue, so if that fix does not have any unwanted consequences, we would be very happy if you used that.

Otherwise, it seems that for us the most practical solution would be to create our own Device derived from QiskitDevice that does remove the barriers (e.g. by overriding compile_circuits) ?

[DSGuala]

Thanks @jessetvogel , we opened a PR to merge that fix and are aiming to have it in for the next PennyLane release around January. We just need to make sure it doesn't have any unintended consequences.