How to call custom op with dynamically computed number of qubits?

[OliverAh]

Hi all,

I have a python script that is supposed to simulate some quantum algorithm. The required number of qubits would only be determined at runtime of the script. Within the script I can easily create custom ops using cudaq.register_operation(...).
The problem is, that I failed to call these custom ops in the kernels, with the dynamically computed number of qubits. That is, because the only way I found to call the custom ops is by hardcoding the qubits that the custom op acts on.
Is there any way to avoid this hard coding?

In the mwe below this call of the custom op takes place in the kernel my_kernel(n: int).

I am using the container from nvcr.io/nvidia/quantum/cuda-quantum:cu12-0.11.0

print('Start imports')
import cudaq
import numpy as np
print('Imports done')


def register_custom_op(num_qubits: int):
    """
    This custom op consists of a pauli x gate applied to each qubit.
    The number of qubits is dynamic.
    """
    custom_x = np.array([[0., 1.], [1., 0.]])
    array_custom_op = custom_x.copy()
    for i in range(1, num_qubits):
        array_custom_op = np.kron(array_custom_op, custom_x)
    cudaq.register_operation('my_custom_op', array_custom_op.flatten())

@cudaq.kernel
def my_kernel(n: int):
    """
    This kernel initializes a qvector and applies a custom operation.
    The size of the qvector is given as input.
    The custom operation seems to require hardcoding the indices of the qvector,
    which breaks the workflow for qubit numbers that are evaluated a runtime of the script.
    """
    qvec = cudaq.qvector(n)
    my_custom_op(qvec[0], qvec[1], qvec[2])# How can I avoid hardcoding qvec[i] for each qubit? I n is not 3 also this will fail.
    #my_custom_op(qvec) #Fails with ... error: invalid number of arguments (1) passed to my_custom_op (requires 3 arguments) ...
    #my_custom_op(qvec[:]) #Fails with same error as above
    #my_custom_op(qvec[0:n]) #Fails with same error as above
    #my_custom_op(*[qvec[i] for i in range(n)])  #Fails with same error as above
    #my_custom_op([qvec[i] for i in range(n)].slice(0, n))  #Fails with AttributeError: 'ListComp' object has no attribute 'id'
    
def prepare_custom_ops_and_kernel_inputs():
    """This function prepares necessary custom ops and inputs for the kernel.
    For this mwe, there is only 1 custom op and the number of qubits."""
    
    num_qubits = 3
    register_custom_op(num_qubits)
    return (num_qubits,)


inputs = prepare_custom_ops_and_kernel_inputs()

state = cudaq.get_state(my_kernel, *inputs)
print('State vector:', state)

Which gives:

Start imports
Imports done
State vector: SV: [(0,0), (0,0), (0,0), (0,0), (0,0), (0,0), (0,0), (1,0)]

[khalatepradnya]

Thank you for the question. You are correct, this isn't supported in CUDA-Q.
@boschmitt : What do you think about allowing iterable unpacking? For example,

my_custom_op(*qvec)