qrisp.jasp.Jaspr.to_catalyst_mlir

Jaspr.to_catalyst_mlir() → str | None

Compiles the Jaspr to MLIR using the Catalyst dialect.

Requires the Catalyst package to be installed (pip install qrisp[catalyst]).

Returns:

str

The MLIR string.

Examples

We create a simple script and inspect the MLIR string:

from qrisp import *
from qrisp.jasp import make_jaspr

def example_function(i):

    qv = QuantumFloat(i)
    cx(qv[0], qv[1])
    t(qv[1])
    meas_res = measure(qv)
    meas_res += 1
    return meas_res

jaspr = make_jaspr(example_function)(2)
print(jaspr.to_catalyst_mlir())

module @jaspr_function {
  func.func public @jit_jaspr_function(%arg0: tensor<i64>)
      -> tensor<f64> attributes {llvm.emit_c_interface} {
    %cst = stablehlo.constant dense<1.000000e+00> : tensor<f64>
    %c_4 = stablehlo.constant dense<0> : tensor<i64>
    %c0_i64 = arith.constant 0 : i64
    quantum.device shots(%c0_i64) [..., "LightningSimulator",
        "{'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"] {auto_qubit_management}
    %0 = quantum.alloc( 20) : !quantum.reg
    ... (bookkeeping: a %c_3-seeded ``stablehlo.while`` populates a
         30-entry index stack via calls to @_pop/@_append, resolving
         the dynamic qubit positions %11 and %19 used below) ...
    %extracted = tensor.extract %11[] : tensor<i64>
    %20 = quantum.extract %0[%extracted] : !quantum.reg -> !quantum.bit
    %extracted_5 = tensor.extract %19[] : tensor<i64>
    %21 = quantum.extract %0[%extracted_5] : !quantum.reg -> !quantum.bit
    %out_qubits:2 = quantum.custom "CNOT"() %20, %21 : !quantum.bit, !quantum.bit
    %extracted_6 = tensor.extract %11[] : tensor<i64>
    %22 = quantum.insert %0[%extracted_6], %out_qubits#0 : !quantum.reg, !quantum.bit
    %extracted_7 = tensor.extract %19[] : tensor<i64>
    %23 = quantum.insert %22[%extracted_7], %out_qubits#1 : !quantum.reg, !quantum.bit
    %extracted_8 = tensor.extract %19[] : tensor<i64>
    %24 = quantum.extract %23[%extracted_8] : !quantum.reg -> !quantum.bit
    %out_qubits_9 = quantum.custom "T"() %24 : !quantum.bit
    %extracted_10 = tensor.extract %19[] : tensor<i64>
    %25 = quantum.insert %23[%extracted_10], %out_qubits_9 : !quantum.reg, !quantum.bit
    %26:3 = scf.while (%arg1 = %c_4, %arg2 = %c_4, %arg3 = %25) : (tensor<i64>, tensor<i64>, !quantum.reg)
        -> (tensor<i64>, tensor<i64>, !quantum.reg) {
      ...
    } do {
    ^bb0(%arg1: tensor<i64>, %arg2: tensor<i64>, %arg3: !quantum.reg):
      ...
      %mres, %out_qubit = quantum.measure %35 : i1, !quantum.bit
      ...
      scf.yield %41, %40, %36 : tensor<i64>, tensor<i64>, !quantum.reg
    }
    %27 = stablehlo.convert %26#1 : (tensor<i64>) -> tensor<f64>
    %28 = stablehlo.multiply %27, %cst : tensor<f64>
    %29 = stablehlo.add %28, %cst : tensor<f64>
    return %29 : tensor<f64>
  }
  func.func private @make_tracer(...) { ... }
  func.func private @_pop(...) { ... }
  func.func private @_append(...) { ... }
  func.func @setup() {
    quantum.init
    return
  }
  func.func @teardown() {
    quantum.finalize
    return
  }
}