qrisp.jasp.Jaspr.to_mlir

Jaspr.to_mlir()

Compiles the Jaspr to MLIR using the Catalyst dialect.

Parameters:

None

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_mlir())

            module @jaspr_function {
  func.func public @jit_jaspr_function(%arg0: tensor<i64>) -> tensor<i32> attributes {llvm.emit_c_interface} {
    %0 = stablehlo.constant dense<1> : tensor<i32>
    %1 = stablehlo.constant dense<2> : tensor<i64>
    %2 = stablehlo.constant dense<1> : tensor<i64>
    %3 = stablehlo.constant dense<0> : tensor<i64>
    quantum.device["/home/positr0nium/miniconda3/envs/qrisp/lib/python3.10/site-packages/catalyst/utils/../lib/librtd_lightning.so", "lightning.qubit", "{'shots': 0, 'mcmc': False, 'num_burnin': 0, 'kernel_name': None}"]
    %4 = quantum.alloc( 20) : !quantum.reg
    %5 = quantum.extract %4[ 0] : !quantum.reg -> !quantum.bit
    %6 = quantum.extract %4[ 1] : !quantum.reg -> !quantum.bit
    %out_qubits:2 = quantum.custom "CNOT"() %5, %6 : !quantum.bit, !quantum.bit
    %7 = quantum.insert %4[ 0], %out_qubits#0 : !quantum.reg, !quantum.bit
    %8 = quantum.insert %7[ 1], %out_qubits#1 : !quantum.reg, !quantum.bit
    %9 = quantum.extract %8[ 1] : !quantum.reg -> !quantum.bit
    %out_qubits_0 = quantum.custom "T"() %9 : !quantum.bit
    %10 = quantum.insert %8[ 1], %out_qubits_0 : !quantum.reg, !quantum.bit
    %11 = stablehlo.add %3, %arg0 : tensor<i64>
    %12:3 = scf.while (%arg1 = %3, %arg2 = %3, %arg3 = %10) : (tensor<i64>, tensor<i64>, !quantum.reg) -> (tensor<i64>, tensor<i64>, !quantum.reg) {
      %16 = stablehlo.compare  GE, %arg1, %11,  SIGNED : (tensor<i64>, tensor<i64>) -> tensor<i1>
      %extracted = tensor.extract %16[] : tensor<i1>
      scf.condition(%extracted) %arg1, %arg2, %arg3 : tensor<i64>, tensor<i64>, !quantum.reg
    } do {
    ^bb0(%arg1: tensor<i64>, %arg2: tensor<i64>, %arg3: !quantum.reg):
      %extracted = tensor.extract %arg1[] : tensor<i64>
      %16 = quantum.extract %arg3[%extracted] : !quantum.reg -> !quantum.bit
      %mres, %out_qubit = quantum.measure %16 : i1, !quantum.bit
      %from_elements = tensor.from_elements %mres : tensor<i1>
      %extracted_1 = tensor.extract %arg1[] : tensor<i64>
      %17 = quantum.insert %arg3[%extracted_1], %out_qubit : !quantum.reg, !quantum.bit
      %18 = stablehlo.subtract %arg1, %3 : tensor<i64>
      %19 = stablehlo.shift_left %1, %18 : tensor<i64>
      %20 = stablehlo.convert %from_elements : (tensor<i1>) -> tensor<i64>
      %21 = stablehlo.multiply %19, %20 : tensor<i64>
      %22 = stablehlo.add %arg2, %21 : tensor<i64>
      %23 = stablehlo.add %arg1, %2 : tensor<i64>
      scf.yield %23, %22, %17 : tensor<i64>, tensor<i64>, !quantum.reg
    }
    %13 = stablehlo.convert %12#1 : (tensor<i64>) -> tensor<i32>
    %14 = stablehlo.multiply %13, %0 : tensor<i32>
    %15 = stablehlo.add %14, %0 : tensor<i32>
    return %15 : tensor<i32>
  }
  func.func @setup() {
    quantum.init
    return
  }
  func.func @teardown() {
    quantum.finalize
    return
  }
}