qrisp.jasp.Jaspr.to_catalyst_jaxpr#

Jaspr.to_catalyst_jaxpr() → Any[source]#

Compiles the jaspr to the corresponding Catalyst jaxpr.

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

Returns:

object: A ClosedJaxpr-like object using Catalyst primitives.

Examples

We create a simple script and inspect the Catalyst Jaxpr:

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_jaxpr())
# Yields
# { lambda ; a:i64[] b:AbstractQreg() c:i64[30] d:i64[]. let
#   ... (bookkeeping: a `while` loop populates a 30-entry index
#        stack `c` via jit-wrapped `_pop`/`_append` helpers,
#        producing the dynamic qubit positions `br`/`bz` used
#        below; `h`/`i` are the (unused past this point) final
#        stack/size outputs) ...
#   ca:AbstractQbit() = qextract b br
#   cb:AbstractQbit() = qextract b bz
#   cc:AbstractQbit() cd:AbstractQbit() = qinst[
#     adjoint=False
#     ctrl_len=0
#     op=CNOT
#     params_len=0
#     qubits_len=2
#   ] ca cb
#   ce:AbstractQreg() = qinsert b br cc
#   cf:AbstractQreg() = qinsert ce bz cd
#   cg:AbstractQbit() = qextract cf bz
#   ch:AbstractQbit() = qinst[
#     adjoint=False
#     ctrl_len=0
#     op=T
#     params_len=0
#     qubits_len=1
#   ] cg
#   ci:AbstractQreg() = qinsert cf bz ch
#   _:i64[] cj:i64[] ck:AbstractQreg() _:i64[1024] _:i64[] = while_loop[
#     body_jaxpr={ lambda ; cl:i64[] cm:i64[] cn:AbstractQreg() co:i64[1024] cp:i64[]. let
#         ...
#         cv:AbstractQbit() = qextract cn cu
#         cw:bool[] cx:AbstractQbit() = measure cv
#         cy:AbstractQreg() = qinsert cn cu cx
#         ...
#       in (dd, dc, cy, co, cp) }
#     body_nconsts=0
#     cond_jaxpr={ lambda ; de:i64[] df:i64[] dg:AbstractQreg() dh:i64[1024] di:i64[]. let
#         dj:bool[] = lt de di
#       in (dj,) }
#     cond_nconsts=0
#     num_implicit_inputs=0
#     preserve_dimensions=True
#   ] 0:i64[] 0:i64[] ci h i
#   dk:f64[] = integer_pow[y=0] 2.0:f64[]
#   dl:f64[] = convert_element_type[new_dtype=float64 weak_type=False] cj
#   dm:f64[] = mul dl dk
#   dn:f64[] = add dm 1.0:f64[]
# in (dn, ck, c, g) }