Repository: Qiskit/qiskit

Issue:
OpenQASM3 dumper does not work with repeated conditionals
### Environment

- **Qiskit version**: 1.1.0.dev0+197e78c
- **Python version**: 3.11.7
- **Operating system**: MacOS


### What is happening?

While I was trying to reproduce https://github.com/Qiskit/qiskit/issues/11935 (and succeeding), I noticed that the OpenQASM3  dumper has the same problem. It seems that is not working with repeated conditionals 

### How can we reproduce the issue?

```python
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.circuit.library.standard_gates import CXGate

qr = QuantumRegister(2, name='qr')
cr = ClassicalRegister(2, name='cr')
qc = QuantumCircuit(qr, cr, name='qc')
qc.append(CXGate().c_if(cr, 0).repeat(1), qargs=qr)

from qiskit.qasm3 import dumps

print(dumps(qc))
```
```
KeyError: "'ClassicalRegister(2, 'cr')' is not defined in the current context"
```


### What should happen?

Notice that the example works with OpenQASM 2 dumper:

```python
from qiskit.qasm2 import dumps

print(dumps(qc))
```
```
OPENQASM 2.0;
include "qelib1.inc";
gate cx_1 q0,q1 { if(cr==0) cx q0,q1; }
qreg qr[2];
creg cr[2];
cx_1 qr[0],qr[1];
```


### Any suggestions?

_No response_


Discussion:
The problem here is happening some time before we get to the OQ2 and OQ3 dumpers (note that the OQ2 dumper's output is invalid OQ2).  Looks like a `Gate` with a condition is being allowed to be used in some other `Gate` object, but classical conditions aren't unitary so that should have been forbidden.  The error's more likely in `Gate.repeat` than the dumpers, here.

Resolving patch:
diff --git a/qiskit/circuit/instruction.py b/qiskit/circuit/instruction.py
--- a/qiskit/circuit/instruction.py
+++ b/qiskit/circuit/instruction.py
@@ -41,7 +41,6 @@
 import numpy
 
 from qiskit.circuit.exceptions import CircuitError
-from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
 from qiskit.qobj.qasm_qobj import QasmQobjInstruction
 from qiskit.circuit.parameter import ParameterExpression
@@ -572,7 +571,13 @@ def _return_repeat(self, exponent):
         )
 
     def repeat(self, n):
-        """Creates an instruction with `gate` repeated `n` amount of times.
+        """Creates an instruction with ``self`` repeated :math`n` times.
+
+        If this operation has a conditional, the output instruction will have the same conditional
+        and the inner repeated operations will be unconditional; instructions within a compound
+        definition cannot be conditioned on registers within Qiskit's data model.  This means that
+        it is not valid to apply a repeated instruction to a clbit that it both writes to and reads
+        from in its condition.
 
         Args:
             n (int): Number of times to repeat the instruction
@@ -589,22 +594,24 @@ def repeat(self, n):
         n = int(n)
 
         instruction = self._return_repeat(n)
-        qargs = [] if self.num_qubits == 0 else QuantumRegister(self.num_qubits, "q")
-        cargs = [] if self.num_clbits == 0 else ClassicalRegister(self.num_clbits, "c")
-
         if instruction.definition is None:
             # pylint: disable=cyclic-import
             from qiskit.circuit import QuantumCircuit, CircuitInstruction
 
-            qc = QuantumCircuit()
-            if qargs:
-                qc.add_register(qargs)
-            if cargs:
-                qc.add_register(cargs)
-            circuit_instruction = CircuitInstruction(self, qargs, cargs)
+            qc = QuantumCircuit(self.num_qubits, self.num_clbits)
+            qargs = tuple(qc.qubits)
+            cargs = tuple(qc.clbits)
+            base = self.copy()
+            if self.condition:
+                # Condition is handled on the outer instruction.
+                base = base.to_mutable()
+                base.condition = None
             for _ in [None] * n:
-                qc._append(circuit_instruction)
-        instruction.definition = qc
+                qc._append(CircuitInstruction(base, qargs, cargs))
+
+            instruction.definition = qc
+        if self.condition:
+            instruction = instruction.c_if(*self.condition)
         return instruction
 
     @property


Test patch:
diff --git a/test/python/circuit/test_instruction_repeat.py b/test/python/circuit/test_instruction_repeat.py
--- a/test/python/circuit/test_instruction_repeat.py
+++ b/test/python/circuit/test_instruction_repeat.py
@@ -52,6 +52,18 @@ def test_standard_1Q_one(self):
         self.assertEqual(result.definition, expected.definition)
         self.assertIsInstance(result, Gate)
 
+    def test_conditional(self):
+        """Test that repetition works with a condition."""
+        cr = ClassicalRegister(3, "cr")
+        gate = SGate().c_if(cr, 7).repeat(5)
+        self.assertEqual(gate.condition, (cr, 7))
+
+        defn = QuantumCircuit(1)
+        for _ in range(5):
+            # No conditions on the inner bit.
+            defn.s(0)
+        self.assertEqual(gate.definition, defn)
+
 
 class TestRepeatInt2Q(QiskitTestCase):
     """Test gate_q2.repeat() with integer"""
@@ -83,6 +95,18 @@ def test_standard_2Q_one(self):
         self.assertEqual(result.definition, expected.definition)
         self.assertIsInstance(result, Gate)
 
+    def test_conditional(self):
+        """Test that repetition works with a condition."""
+        cr = ClassicalRegister(3, "cr")
+        gate = CXGate().c_if(cr, 7).repeat(5)
+        self.assertEqual(gate.condition, (cr, 7))
+
+        defn = QuantumCircuit(2)
+        for _ in range(5):
+            # No conditions on the inner bit.
+            defn.cx(0, 1)
+        self.assertEqual(gate.definition, defn)
+
 
 class TestRepeatIntMeasure(QiskitTestCase):
     """Test Measure.repeat() with integer"""
@@ -118,6 +142,18 @@ def test_measure_one(self):
         self.assertIsInstance(result, Instruction)
         self.assertNotIsInstance(result, Gate)
 
+    def test_measure_conditional(self):
+        """Test conditional measure moves condition to the outside."""
+        cr = ClassicalRegister(3, "cr")
+        measure = Measure().c_if(cr, 7).repeat(5)
+        self.assertEqual(measure.condition, (cr, 7))
+
+        defn = QuantumCircuit(1, 1)
+        for _ in range(5):
+            # No conditions on the inner bit.
+            defn.measure(0, 0)
+        self.assertEqual(measure.definition, defn)
+
 
 class TestRepeatErrors(QiskitTestCase):
     """Test when Gate.repeat() should raise."""