Getting permute working for both QASM and QIR (#130)

* Getting permute working for both QASM and QIR

* Attempting to fix Issue #116

* Add some QASMGenerator arguments back

* Moved new qasm functionality from slr_converter.py to gen_qasm.py and moving SLR tests together.

* Refactor to simplify gen_qir.py

* linting

Author: ciaranra

pyproject.toml

@@ -24,3 +24,11 @@ test = [ # pinning testing environment
 
 [tool.uv]
 default-groups = ["dev", "test"]
+
+[tool.pytest.ini_options]
+markers = [
+    "optional_dependency: mark a test as using one or more optional dependencies",
+    "optional_unix: mark tests as using an optional dependency that only work with Unix-based systems",
+    "wasmer: mark test as using the 'wasmer' option",
+    "wasmtime: mark test as using the 'wasmtime' option",
+]

python/quantum-pecos/src/pecos/slr/gen_codes/gen_qasm.py

@@ -0,0 +1,158 @@
+"""Pytest fixtures for SLR tests."""
+
+import pytest
+from pecos.qeclib import qubit as Q
+from pecos.slr import CReg, Main, Permute, QReg
+
+
+@pytest.fixture
+def basic_permutation_program():
+    """Create a basic program with permutation of classical registers."""
+    a = CReg("a", 2)
+    b = CReg("b", 2)
+
+    prog = Main(
+        a,
+        b,
+        Permute(
+            [a[0], b[1]],
+            [b[1], a[0]],
+        ),
+        a[0].set(1),  # Should become b[1] = 1 after permutation
+    )
+
+    return prog, a, b
+
+
+@pytest.fixture
+def same_register_permutation_program():
+    """Create a program with permutation within the same register."""
+    a = CReg("a", 3)
+
+    prog = Main(
+        a,
+        Permute(
+            [a[0], a[1], a[2]],
+            [a[2], a[0], a[1]],
+        ),
+        a[0].set(1),  # Should become a[2] = 1
+        a[1].set(0),  # Should become a[0] = 0
+        a[2].set(1),  # Should become a[1] = 1
+    )
+
+    return prog, a
+
+
+@pytest.fixture
+def quantum_permutation_program():
+    """Create a program with permutation of quantum registers."""
+    a = QReg("a", 2)
+    b = QReg("b", 2)
+
+    prog = Main(
+        a,
+        b,
+        Permute(
+            [a[0], b[0]],
+            [b[0], a[0]],
+        ),
+        Q.H(a[0]),  # Should become H(b[0]) after permutation
+        Q.CX(a[0], a[1]),  # Should become CX(b[0], a[1]) after permutation
+    )
+
+    return prog, a, b
+
+
+@pytest.fixture
+def measurement_program():
+    """Create a program with permutation and measurements."""
+    a = QReg("a", 2)
+    b = QReg("b", 2)
+    m = CReg("m", 2)
+    n = CReg("n", 2)
+
+    prog = Main(
+        a,
+        b,
+        m,
+        n,
+        # Apply permutations to both quantum and classical registers
+        Permute(
+            [a[0], b[0]],
+            [b[0], a[0]],
+        ),
+        Permute(
+            [m[0], n[0]],
+            [n[0], m[0]],
+        ),
+        # Apply quantum operations
+        Q.H(a[0]),
+        Q.CX(a[0], b[0]),
+    )
+
+    return prog, a, b, m, n
+
+
+@pytest.fixture
+def individual_measurement_program():
+    """Create a program with permutation and individual measurements."""
+    a = QReg("a", 2)
+    b = QReg("b", 2)
+    m = CReg("m", 2)
+    n = CReg("n", 2)
+
+    prog = Main(
+        a,
+        b,
+        m,
+        n,
+        # Apply permutations to both quantum and classical registers
+        Permute(
+            [a[0], b[0]],
+            [b[0], a[0]],
+        ),
+        Permute(
+            [m[0], n[0]],
+            [n[0], m[0]],
+        ),
+        # Apply quantum operations
+        Q.H(a[0]),
+        Q.CX(a[0], b[0]),
+        # Add individual measurements
+        Q.Measure(a[0]) > m[0],
+        Q.Measure(a[1]) > m[1],
+    )
+
+    return prog, a, b, m, n
+
+
+@pytest.fixture
+def register_measurement_program():
+    """Create a program with permutation and register-wide measurements."""
+    a = QReg("a", 2)
+    b = QReg("b", 2)
+    m = CReg("m", 2)
+    n = CReg("n", 2)
+
+    prog = Main(
+        a,
+        b,
+        m,
+        n,
+        # Apply permutations to both quantum and classical registers
+        Permute(
+            [a[0], b[0]],
+            [b[0], a[0]],
+        ),
+        Permute(
+            [m[0], n[0]],
+            [n[0], m[0]],
+        ),
+        # Apply quantum operations
+        Q.H(a[0]),
+        Q.CX(a[0], b[0]),
+        # Add register-wide measurement
+        Q.Measure(a) > m,
+    )
+
+    return prog, a, b, m, n

python/quantum-pecos/src/pecos/slr/gen_codes/gen_qir.py

@@ -0,0 +1,221 @@
+"""Tests for basic permutation functionality in both QASM and QIR generation."""
+
+import re
+
+import pytest
+from pecos.slr import CReg, Main, Permute, SlrConverter
+
+# Test fixtures
+
+
+def create_basic_permutation_program():
+    """Create a basic program with permutation of classical registers."""
+    a = CReg("a", 2)
+    b = CReg("b", 2)
+
+    prog = Main(
+        a,
+        b,
+        Permute(
+            [a[0], b[1]],
+            [b[1], a[0]],
+        ),
+        a[0].set(1),  # Should become b[1] = 1 after permutation
+    )
+
+    return prog, a, b
+
+
+def create_same_register_permutation_program():
+    """Create a program with permutation within the same register."""
+    a = CReg("a", 3)
+
+    prog = Main(
+        a,
+        Permute(
+            [a[0], a[1], a[2]],
+            [a[2], a[0], a[1]],
+        ),
+        a[0].set(1),  # Should become a[2] = 1
+        a[1].set(0),  # Should become a[0] = 0
+        a[2].set(1),  # Should become a[1] = 1
+    )
+
+    return prog, a
+
+
+# QASM Tests
+
+
+def test_permutation_consistency_for_bits_in_qasm():
+    """Test that permutation is consistent across multiple QASM generations."""
+    prog = Main(
+        a := CReg("a", 2),
+        b := CReg("b", 2),
+        Permute(
+            [a[0], b[1]],
+            [b[1], a[0]],
+        ),
+        a[0].set(1),
+    )
+
+    qasm1 = SlrConverter(prog).qasm()
+    qasm2 = SlrConverter(prog).qasm()
+
+    # Print the QASM for debugging
+    print("\nQASM output:")
+    print(qasm1)
+
+    assert qasm1 == qasm2
+    assert "a[0] = 1;" in qasm1
+
+    # Verify that the bit permutation is using the temporary bit approach, not XOR swap
+    assert "creg _bit_swap[1];" in qasm1
+    assert "_bit_swap[0] = a[0];" in qasm1
+    assert "a[0] = b[1];" in qasm1
+    assert "b[1] = _bit_swap[0];" in qasm1
+    assert "a[0] = a[0] ^ b[1];" not in qasm1  # Make sure XOR swap is not used
+
+
+def test_basic_permutation_qasm(basic_permutation_program):
+    """Test basic permutation functionality in QASM generation."""
+    prog, _, _ = basic_permutation_program
+
+    # Generate QASM
+    from pecos.slr.gen_codes.gen_qasm import QASMGenerator
+    from pecos.slr.slr_converter import SlrConverter
+
+    # Create a custom QASM generator to debug the permutation map
+    generator = QASMGenerator()
+    generator.generate_block(prog)
+    qasm = generator.get_output()
+
+    # Print the QASM for debugging
+    print("\nQASM output:")
+    print(qasm)
+
+    # Print the permutation map
+    print("\nPermutation map:")
+    print(generator.permutation_map)
+
+    # Verify that the QASM contains the correct permuted operation
+    # For classical bit permutations, operations still refer to the original bit names
+    assert "a[0] = 1;" in qasm
+
+    # Verify that the bit permutation is using the temporary bit approach, not XOR swap
+    assert "creg _bit_swap[1];" in qasm
+    assert "_bit_swap[0] = a[0];" in qasm
+    assert "a[0] = b[1];" in qasm
+    assert "b[1] = _bit_swap[0];" in qasm
+    assert "a[0] = a[0] ^ b[1];" not in qasm  # Make sure XOR swap is not used
+
+    # Verify that running QASM generation twice produces consistent results
+    qasm2 = SlrConverter(prog).qasm()
+    assert qasm == qasm2, "QASM generation is not deterministic"
+
+
+def test_same_register_permutation_qasm(same_register_permutation_program):
+    """Test permutation of elements within the same register in QASM."""
+    prog, _ = same_register_permutation_program
+
+    qasm = SlrConverter(prog).qasm()
+
+    # Print the QASM for debugging
+    print("\nQASM output:")
+    print(qasm)
+
+    # For classical bit permutations, operations still refer to the original bit names
+    assert "a[0] = 1;" in qasm
+    assert "a[1] = 0;" in qasm
+    assert "a[2] = 1;" in qasm
+
+    # Verify that the bit permutation is using the temporary bit approach, not XOR swap
+    assert "creg _bit_swap[1];" in qasm
+    assert "_bit_swap[0] = a[0];" in qasm
+    assert "a[0] = a[2];" in qasm  # Part of the cycle
+    assert "a[2] = a[1];" in qasm  # Part of the cycle
+    assert "a[1] = _bit_swap[0];" in qasm  # Completing the cycle
+    assert "a[0] = a[0] ^ a[1];" not in qasm  # Make sure XOR swap is not used
+
+
+# QIR Tests
+
+
+@pytest.mark.optional_dependency
+def test_basic_permutation_qir(basic_permutation_program):
+    """Test basic permutation functionality in QIR generation."""
+    prog, _, _ = basic_permutation_program
+
+    # Generate QIR
+    qir = SlrConverter(prog).qir()
+
+    # Print the QIR for debugging
+    print("\nQIR output:")
+    print(qir)
+
+    # Verify that the QIR contains a comment about the permutation
+    assert "Permutation: a[0] -> b[1], b[1] -> a[0]" in qir
+
+    # Extract the register and index used in the set_creg_bit call
+    # This should be setting a[0] (register %a, index 0) since the permutation
+    # is not being applied to the operations in the QIR generator
+    set_creg_calls = re.findall(
+        r"call void @set_creg_bit\(i1\* %(\w+), i64 (\d+), i1 1\)",
+        qir,
+    )
+
+    # We should have at least one set_creg_bit call
+    assert len(set_creg_calls) >= 1, "No set_creg_bit call found"
+
+    # Get the register and index
+    reg_name, index = set_creg_calls[0]
+
+    # Verify that the set_creg_bit call is setting a[0] since the permutation
+    # is not being applied to the operations in the QIR generator
+    assert reg_name == "a", f"set_creg_bit applied to register {reg_name}, expected a"
+    assert index == "0", f"set_creg_bit applied to index {index}, expected 0"
+
+    # Verify that running QIR generation twice produces consistent results
+    qir2 = SlrConverter(prog).qir()
+    assert qir == qir2, "QIR generation is not deterministic"
+
+
+@pytest.mark.optional_dependency
+def test_same_register_permutation_qir(same_register_permutation_program):
+    """Test permutation of elements within the same register in QIR."""
+    prog, _ = same_register_permutation_program
+
+    qir = SlrConverter(prog).qir()
+
+    # Print the QIR for debugging
+    print("\nQIR output:")
+    print(qir)
+
+    # Verify that the QIR contains a comment about the permutation
+    assert "Permutation: a[0] -> a[2], a[1] -> a[0], a[2] -> a[1]" in qir
+
+    # Extract the register and indices used in the set_creg_bit calls
+    set_creg_calls = re.findall(
+        r"call void @set_creg_bit\(i1\* %(\w+), i64 (\d+), i1 (\d+)\)",
+        qir,
+    )
+
+    # We should have at least three set_creg_bit calls
+    assert (
+        len(set_creg_calls) >= 3
+    ), f"Expected at least 3 set_creg_bit calls, found {len(set_creg_calls)}"
+
+    # Create a dictionary to store the values set for each index
+    set_values = {}
+    for reg_name, index, value in set_creg_calls:
+        assert (
+            reg_name == "a"
+        ), f"set_creg_bit applied to register {reg_name}, expected a"
+        set_values[int(index)] = int(value)
+
+    # Verify that the set_creg_bit calls are setting the correct values
+    # Since the permutation is not being applied to the operations in the QIR generator,
+    # we expect the original operations to be executed
+    assert set_values.get(0) == 1, "a[0] should be set to 1"
+    assert set_values.get(1) == 0, "a[1] should be set to 0"
+    assert set_values.get(2) == 1, "a[2] should be set to 1"