[FEATURE] Add support for while statements

[TheGupta2012]

Feature Description

Add support for the while loops in openqasm. The main motivation behind this feature is to provide complete semantic coverage of the openqasm3 grammar

Current

The following code containing a while loop in openqasm fails during unroll -

import pyqasm

qasm_str = """
OPENQASM 3.0;
include "stdgates.inc";
qubit q;
bit result;

int i = 0;
// Keep applying hadamards and measuring a qubit
// until 10, |1>s are measured
while (i < 10) {
    h q;
    result = measure q;
    if (result) {
        i += 1;
    }
}"""

module = pyqasm.loads(qasm_str)

module.unroll()

...
ValidationError: Unsupported statement of type <class 'openqasm3.ast.WhileLoop'>

Implementation (Optional)

• Similar to the handling of for loop statements, we will need to add implementation for the _visit_while_loop method in the QasmVisitor class

• This will require analyzing the structure of openqasm3.ast.WhileLoop class and figuring out how to evaluate the conditions in different iterations.

[atharva-satpute]

What should be the behavior incase of infinite loop? Do we also need to add support for break and continue?

[ryanhill1]

@atharva-satpute An infinite loop should cause a ValidationError. And yes, the solution support both break and continue statements.

[atharva-satpute]

I'm having trouble understanding how do we detect infinite loop? Do we keep track of the number of iterations?

[ryanhill1]

Yeah, perhaps an easier way to handle this would be to implement a “maximum loop limit” threshold—similar to how Python raises a RecursionError: maximum recursion depth exceeded. The idea would be to set a default threshold, say 1000 iterations, and raise something like a LoopLimitError if this limit is exceeded. We could also make this threshold configurable, much like Python’s recursion limit:

import sys

sys.setrecursionlimit(2000)  # Example: Increase recursion limit to 2000

Similarly, in our case:

import pyqasm

pyqasm.unroll(..., loop_limit=2000)

We could also support loop_limit=None to disable this limit entirely, allowing the unrolling process to continue until it hits a MemoryError if it exhausts all available memory.

For this initial implementation, it might make sense to simplify things by not tracking “infinite” while loops—just let those cases proceed until a MemoryError occurs. We could then spin off a separate issue to add the loop_limit feature later.

Maybe @TheGupta2012 can weigh in with his thoughts as well.

[TheGupta2012]

I agree with @ryanhill1 , I don't think that there's a way you can detect infinite loop cycles at compile time as we can easily manipulate the condition variables in the loop body. So the following -

while ( i < 10 ) {  // current i value is 9
    // any num of operations 
    i = i - 1; 
}

will result in an infinite loop but we have no way of raising that error when we are analyzing the condition.

For the loop_limit condition, I think Ryan's draft looks good enough. @atharva-satpute you can start with the implementation without worrying about the limits for now. If there's time left in the hack, we can implement the condition as well, otherwise we'll spin up a new issue for that.

[TheGupta2012]

@bhagyasreey can you please comment on the issue so that I can assign it to you? This is needed for unitary hack bounty distribution

[bhagyasreey]

I would love to work further on the issue. Thank you.