QuPRS 0.1.0__py3-none-any.whl

QuPRS/__init__.py

@@ -0,0 +1,12 @@
+# __init__.py
+
+try:
+    from ._version import * 
+except ImportError:
+    # Fallback for development mode or when setuptools_scm hasn't generated the file yet
+    import warnings
+    warnings.warn("Version not found in _version.py, likely in development mode or during sdist build.", stacklevel=2)
+    __version__ = "0.0.0+unknown"
+    __version_tuple__ = (0, 0, 0, "unknown")
+    version = __version__
+    version_tuple = __version_tuple__

QuPRS/_version.py

@@ -0,0 +1,21 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = ["__version__", "__version_tuple__", "version", "version_tuple"]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+else:
+    VERSION_TUPLE = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)

QuPRS/cache_manager/__init__.py

@@ -0,0 +1,5 @@
+# cache_manager/__init__.py
+from .global_cache_manager import GlobalCacheManager
+from .cache_decorator import tracked_lru_cache
+
+cache_manager = GlobalCacheManager()

QuPRS/cache_manager/cache_decorator.py

@@ -0,0 +1,18 @@
+# cache_manager/cache_decorator.py
+
+from functools import lru_cache, wraps
+
+
+def tracked_lru_cache(maxsize=128):
+    
+    def decorator(func):
+        from . import cache_manager
+        cached_func = lru_cache(maxsize=maxsize)(func)
+        cache_manager.register(cached_func)
+        
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            return cached_func(*args, **kwargs)
+        
+        return wrapper
+    return decorator

QuPRS/cache_manager/global_cache_manager.py

@@ -0,0 +1,24 @@
+# cache_manager/global_cache_manager.py
+
+class GlobalCacheManager:
+    def __init__(self):
+        self._caches = []
+        
+    def register(self, func):
+        self._caches.append(func)
+    def __repr__(self) -> str:
+        return  str(self.cache_info)
+    @property
+    def cache(self):
+        return self._caches
+    @property
+    def cache_info(self):
+        return {f"{item.__name__}": item.cache_info() for item in self._caches}
+    @property
+    def hit_rate(self):
+        return {f"{item.__name__}": (item.cache_info().hits/(item.cache_info().misses+item.cache_info().hits) if item.cache_info().misses+item.cache_info().hits>0 else 0)  for item in self._caches}
+    def clear_all_caches(self):
+        for func in self._caches:
+            func.cache_clear()
+    def clear_cache(self, func):
+        func.cache_clear()

QuPRS/config.py

@@ -0,0 +1,14 @@
+# config.py
+TOLERANCE = 1e-10  
+
+def set_tolerance(new_tolerance: float):
+    global TOLERANCE
+    if not isinstance(new_tolerance, (int, float)):
+        raise ValueError("Tolerance must be a numeric type")
+    if new_tolerance <= 0:
+        raise ValueError("Tolerance must be a positive number")
+    TOLERANCE = new_tolerance
+
+def get_tolerance() -> float:
+
+    return TOLERANCE

QuPRS/interface/gate_library.py

@@ -0,0 +1,26 @@
+from QuPRS.pathsum import PathSum
+
+def support_gate_set():
+    return ('h','x','y','z', 'p', 's','sdg', 't','tdg','sx','sxdg',
+            'rx', 'ry','rz', 'u','u1','u2','u3',
+            'cx','ch','cz','cp','ccx','mcx',
+            'crx','cry','crz','cu1','cu3','cu',
+            'swap','barrier','measure' )
+
+def gate_map(circuit:PathSum, gate_name:str, qubit, gate_params = [], is_bra: bool =False, debug = False):
+    if debug:
+        print('add gate: %s, %s, %s, %s'%(gate_name, qubit, gate_params, is_bra))
+        print('circuit in',circuit) 
+
+    assert gate_name in support_gate_set(), 'Not support %s gate yet.'%gate_name
+    if gate_name in ['barrier','measure']:
+        return circuit
+    func = getattr(circuit, gate_name)
+    if gate_params == []:
+        circuit = func(*qubit, is_bra)
+    else:
+        circuit = func(*gate_params, *qubit, is_bra)
+    
+    if debug:
+        print('circuit out', circuit)
+    return circuit

QuPRS/interface/load_qiskit.py

@@ -0,0 +1,225 @@
+from qiskit import QuantumCircuit, qasm2, qasm3 
+import numpy as np
+import symengine as se
+import signal,time, os
+
+from QuPRS import config
+from QuPRS.pathsum import PathSum, Register
+from QuPRS.interface.gate_library import support_gate_set, gate_map
+
+# global support_gate_set 
+support_gate_set = support_gate_set()
+
+def timeout_handler(signum, frame):
+    raise TimeoutError("Operation timed out")  
+signal.signal(signal.SIGALRM, timeout_handler)
+
+def build_circuit(circuit: QuantumCircuit, initial_state: bool|list|tuple = None):
+    pathsum_circuit = initialize(circuit, initial_state)
+    gate_list = get_gates(circuit)
+    # support_gate_set = support_gate_set()
+    for gate in gate_list:
+        assert gate[0] in support_gate_set, 'Not support %s gate yet.'%gate[0]
+        # print(pathsum_circuit, gate)
+        pathsum_circuit= gate_map(pathsum_circuit, gate[0], [f'{item[0]}_{item[1]}' for item in gate[1]], gate[2])
+            
+    return pathsum_circuit
+
+def initialize(circuit: QuantumCircuit, initial_state: bool|list|tuple = None):
+    '''
+    Construct initial PathSum and the name mapping.
+    '''
+    qiskit_regs = circuit.qregs
+    regs =[]
+    for reg in qiskit_regs:
+        regs.append(Register(reg.size, reg.name ))
+
+    return PathSum.QuantumCircuit(*regs, initial_state = initial_state)
+
+def get_gate(circuit: QuantumCircuit, gate):
+    '''Get a gate properties.'''
+    gate_name = gate.operation.name
+    gate_params = gate.operation.params
+    qubits_old = gate.qubits
+    qubits = []
+    for qubit in qubits_old:
+        QuantumRegister = circuit.find_bit(qubit).registers
+        qubits.append((QuantumRegister[0][0].name, QuantumRegister[0][1]))
+    return gate_name, tuple(qubits), tuple(gate_params)
+
+def get_gates(circuit: QuantumCircuit):
+    gates = []
+    for gate in circuit.data:
+        gates.append(get_gate(circuit, gate))
+    return gates
+
+def add_gate(pathsum_circuit: PathSum.QuantumCircuit, gate, is_bra = False, count = 0, debug = False) -> tuple[PathSum, int]:
+    assert gate[0] in support_gate_set, 'Not support %s gate yet.'%gate[0]
+    if debug:
+        print(f'gate:{gate}, is_bra: {is_bra}')
+    pathsum_circuit= gate_map(pathsum_circuit, gate[0], [f'{item[0]}_{item[1]}' for item in gate[1]], gate[2], is_bra)
+    
+    count += 1
+    if debug:
+        print(count, pathsum_circuit)
+    return pathsum_circuit, count
+
+def load_circuit(circuit: str) -> QuantumCircuit:
+    """
+    Load a Qiskit circuit from a file or qasm string.
+
+    Args:
+        circuit (str): The path to the QASM file or a QASM string.
+
+    Returns:
+        QuantumCircuit: The loaded Qiskit circuit.
+    """
+    if os.path.isfile(circuit):
+        with open(circuit, 'r') as f:
+            data = f.read()
+    else:
+        data = circuit
+    flag = True if 'OPENQASM 3.0' in data else False
+    if flag:
+        qiskit_circuit = qasm3.loads(data)
+    else:
+        qiskit_circuit = qasm2.loads(data)
+    return qiskit_circuit
+
+def qasm_eq_check(circuit1: str|QuantumCircuit, circuit2:str|QuantumCircuit, strategy ='Difference' , Benchmark_Name=None, timeout= 600):
+    tolerance = config.TOLERANCE
+    def load_circuit(circuit):
+        if isinstance(circuit, str):
+            if circuit.endswith('.qasm'):
+                f = open(circuit, 'r')
+                data = f.read()
+                if 'OPENQASM 3.0' in data:
+                    return qasm3.load(circuit)
+                else:
+                    return qasm2.load(circuit)
+            elif 'OPENQASM' in circuit:
+                if 'OPENQASM 3.0' in circuit:
+                    return qasm3.loads(circuit)
+                else:
+                    return qasm2.loads(circuit)
+            else:
+                raise ValueError("Invalid circuit format")
+        elif isinstance(circuit, QuantumCircuit):
+            return circuit
+
+    qiskit_circuit = load_circuit(circuit1)
+    qiskit_circuit2 = load_circuit(circuit2)
+
+    start_time = time.time()
+
+    initial_state = initialize(qiskit_circuit)
+    pathsum_circuit = initial_state
+    qubit_num = initial_state.num_qubits
+    
+    l1 = len(qiskit_circuit.data)
+    l2 = len(qiskit_circuit2.data)
+
+    output_dict = {"Benchmark_Name": Benchmark_Name,
+                   "qubit_num": qubit_num,
+                   "gate_num": l1,
+                   "gate_num2": l2}
+    
+    if strategy == 'Proportional':
+        from QuPRS.utils.strategy import proportional
+        output_dict, pathsum_circuit = proportional(pathsum_circuit, qiskit_circuit, qiskit_circuit2, l1, l2, output_dict, timeout)
+    elif strategy == 'Naive':
+        from QuPRS.utils.strategy import naive
+        output_dict, pathsum_circuit = naive(pathsum_circuit, qiskit_circuit, qiskit_circuit2, l1, l2, output_dict, timeout)
+    elif strategy == "Straightforward":
+        from QuPRS.utils.strategy import straightforward
+        output_dict, pathsum_circuit = straightforward(pathsum_circuit, qiskit_circuit, qiskit_circuit2, l1, l2, output_dict, timeout)
+    elif strategy == "Difference":
+        from QuPRS.utils.strategy import difference
+        output_dict, pathsum_circuit = difference(pathsum_circuit, qiskit_circuit, qiskit_circuit2, l1, l2, output_dict, timeout)
+    else:
+        raise ValueError("Invalid strategy")
+    if "equivalent" in output_dict:
+        return output_dict, pathsum_circuit
+    else:
+        total_time = time.time() - start_time
+        output_dict["Time"] = round(total_time, 3)
+
+        # if pathsum_circuit.f == initial_state.f and pathsum_circuit.pathvar == initial_state.pathvar:
+        if pathsum_circuit.f == initial_state.f:
+            if pathsum_circuit.P == initial_state.P:
+                output_dict["equivalent"] = 'equivalent'
+            P_free_symbols = pathsum_circuit.P.free_symbols
+            check_P_symbol = tuple(filter(lambda x: x.name in pathsum_circuit.f.bits, P_free_symbols))
+            if len(P_free_symbols) == 0:
+                if pathsum_circuit.P < tolerance:
+                    output_dict["equivalent"] = 'equivalent'
+                else:
+                    output_dict["equivalent"] = 'equivalent*'
+            elif len(check_P_symbol) == 0:
+                output_dict["equivalent"] = 'equivalent*'
+            else:
+                output_dict["equivalent"] = 'not_equivalent'
+            return output_dict, pathsum_circuit
+        else:
+            output_dict["equivalent"] = 'unknown'
+            return output_dict, pathsum_circuit
+
+def qasm_eq_check_with_wmc(circuit1: str|QuantumCircuit, circuit2:str|QuantumCircuit, strategy ='Difference' , Benchmark_Name=None, timeout= 600):
+    tolerance = config.TOLERANCE
+
+    output_dict, circuit = qasm_eq_check(circuit1=circuit1, circuit2=circuit2, strategy =strategy , Benchmark_Name=Benchmark_Name, timeout= timeout)
+    wmc_time = 0
+    log_wmc = None
+    expect = None
+    theta = None
+    to_DIMACS_time = 0
+    if output_dict["equivalent"] == "unknown":
+        from QuPRS.interface.ps2wmc import to_DIMACS, run_wmc
+        from QuPRS.utils.util import get_theta
+        
+        expect = circuit.num_qubits+circuit.num_pathvar/2
+        signal.alarm(timeout)
+        start_time = time.time()
+        try:
+            to_DIMACS(circuit)
+            to_DIMACS_time = round(time.time() - start_time, 3)
+        except TimeoutError:
+            to_DIMACS_time = f'>{timeout}'
+        finally:
+            signal.alarm(0)
+
+        if to_DIMACS_time != f'>{timeout}':
+            signal.alarm(timeout)
+            start_time = time.time()
+            try:
+                complex_number = run_wmc()
+                wmc_time = round(time.time() - start_time, 3)
+                abs_num = np.sqrt(complex_number[0]**2 + complex_number[1]**2)
+                log_wmc = round(np.log2(abs_num), 3)
+                theta = get_theta(complex_number[1]/abs_num, complex_number[0]/abs_num)
+                if abs(log_wmc - expect) < tolerance:
+                    if abs(theta) < tolerance * 2 * np.pi:
+                        output_dict["equivalent"] = "equivalent"
+                    else:
+                        output_dict["equivalent"] = "equivalent*"
+                else:
+                    output_dict["equivalent"] = "not_equivalent"
+            except TimeoutError:
+                wmc_time = f'>{timeout}'
+            finally:
+                signal.alarm(0)
+        
+    elif output_dict["equivalent"] == "equivalent*":
+        theta = str((circuit.P* 2 * se.pi).evalf())
+    elif output_dict["equivalent"] == "equivalent":
+        theta = 0
+
+    output_dict["PathSum_time"] = output_dict["Time"]
+    output_dict["to_DIMACS_time"] = to_DIMACS_time
+    output_dict["wmc_time"] = wmc_time
+    if output_dict["equivalent"] == "Timeout" or to_DIMACS_time == f'>{timeout}' or wmc_time == f'>{timeout}':
+        output_dict["equivalent"] = "Timeout"
+        output_dict["Time"] = f'>{timeout}'
+    else:
+        output_dict["Time"] = round(wmc_time + to_DIMACS_time + output_dict["PathSum_time"],3)
+    return output_dict 

QuPRS/interface/ps2wmc.py

@@ -0,0 +1,252 @@
+import symengine as se
+import sympy as sp
+from sympy.logic.boolalg import Xor, And, Or, Not
+
+import subprocess, re
+
+from QuPRS.utils import WMC
+from QuPRS.utils.util import algebraic_to_logical
+
+counter = {'idx': 0}
+def fresh_var():
+    counter['idx'] += 1
+    return sp.Symbol(f'e_{counter["idx"]-1}')
+def extend_symbols_map(symbols_map, new_symbol):
+    if new_symbol not in symbols_map:
+        symbols_map[new_symbol] = len(symbols_map) + 1
+    return symbols_map
+# Convert a logical equivalence to CNF
+def a_eq_b_cnf(a, b):
+    if a == b:
+        return sp.true
+    return sp.to_cnf(Or(And(a, b), And(Not(a), Not(b))), simplify=True, force=True)
+def encode_equivalence(c, cnf):
+    if c == cnf:
+        return sp.true
+    cnf_clauses = []
+    # cnf = and(a1, a2, ...) or or(o1, o2, ...), a1 = or(o1, o2, ...)
+    if isinstance(cnf, And):
+        args = cnf.args
+        new_args = list(args)
+        for i, arg in enumerate(args):
+            if isinstance(arg, Or):
+                args2 = arg.args
+                new_args[i] = fresh_var()
+                cnf_clauses.append(Or(Not(new_args[i]), *args2)) # e -> or(o1, o2, ...)
+                cnf_clauses.extend([Or(Not(arg2), new_args[i]) for arg2 in args2]) # or(o1, o2, ...) -> e
+            elif isinstance(arg, sp.Symbol) or isinstance(arg, Not):
+                continue
+            else:
+                raise ValueError(f"Unsupported CNF clause {arg} type {type(arg)}")
+
+        cnf_clauses.append(Or(c, *[Not(arg) for arg in new_args])) # and(a1, a2, ...) -> c
+        cnf_clauses.extend([Or(Not(c), arg) for arg in new_args])  # c-> and(a1, a2, ...)
+    elif isinstance(cnf, Or):
+        args = cnf.args
+        cnf_clauses.append(Or(Not(c), *args)) # c -> or(o1, o2, ...)
+        cnf_clauses.extend([Or(Not(arg), c) for arg in args]) # or(o1, o2, ...) -> c
+    elif isinstance(cnf, Not) or isinstance(cnf, sp.Symbol) or isinstance(cnf, se.Symbol):
+        cnf_clauses.append(Or(Not(c), cnf)) # c -> o1
+        cnf_clauses.append(Or(Not(cnf), c)) # o1 -> c
+    elif cnf == sp.true:
+        cnf_clauses.append(c) # c -> True
+    elif cnf == sp.false:
+        cnf_clauses.append(Not(c)) # c -> False
+    else:
+        raise ValueError(f"Unsupported CNF clause {cnf} type {type(cnf)}")
+    return And(*cnf_clauses)
+def anf_to_cnf(anf):
+    """
+    Convert ANF to CNF using Tseitin transformation.
+    """
+    if anf == sp.true or anf == sp.false or \
+        isinstance(anf, sp.Symbol) or \
+        isinstance(anf, se.Symbol) or \
+        isinstance(anf, And):
+        return (anf,)
+    
+    clauses = []
+    def tseitin(c, anf): # c <-> anf
+        # print(f"tseitin: {c} <-> {anf}")
+        if anf == sp.true:
+            clauses.append(c)
+        elif anf == sp.false:
+            clauses.append(Not(c))
+        elif isinstance(anf, Not):
+            args = anf.args
+            if isinstance(args[0], And):
+                a = fresh_var()
+                tseitin(a, args[0])
+            elif isinstance(args[0], Xor):
+                a = fresh_var()
+                tseitin(a, Xor(*args[0].args))
+            else:
+                a = args[0]
+            clauses.append(Or(Not(c), Not(a))) # c -> Not(a)
+            clauses.append(Or(c, a)) # Not(a) -> c
+        elif isinstance(anf, Xor):
+            args = anf.args
+            if isinstance(args[0], And):
+                a = fresh_var()
+                tseitin(a, args[0])
+            else:
+                a = args[0]
+
+            if len(args) > 2:
+                b = fresh_var()
+                tseitin(b, Xor(*args[1:]))
+            elif isinstance(args[1], And):
+                b = fresh_var()
+                tseitin(b, args[1])
+            else:
+                b = args[1]
+
+            clauses.extend([
+                Or(Not(a), Not(b), Not(c)),
+                Or(a, b, Not(c)),
+                Or(a, Not(b), c),
+                Or(Not(a), b, c),
+            ]) # c <-> a xor b
+            
+        elif isinstance(anf, And):
+            args = anf.args
+            clauses.extend([Or(Not(c), arg) for arg in args]) # c -> anf
+            clauses.append(Or(c, *[Not(arg) for arg in args])) # anf -> c
+        elif isinstance(anf, sp.Symbol) or isinstance(anf, se.Symbol):
+            clauses.append(Or(Not(c), anf)) # c -> anf
+            clauses.append(Or(c, Not(anf))) # anf -> c
+        else:
+            raise ValueError(f"Unsupported ANF clause {anf} type {type(anf)}")
+
+    new_var = fresh_var()
+    tseitin(new_var, anf)
+    # print(f"clauses: {clauses}")
+    return (new_var, And(*clauses))
+
+# Convert polynomial P to weighted logical expressions
+def P_to_wlogi(P):
+    if P == 0:
+        return []
+    args = P.as_coefficients_dict()
+    output = [(v, algebraic_to_logical(k)) if v != 0 and v != 1 else (k, algebraic_to_logical(v)) for k, v in args.items() if v != 0]
+    return output
+
+# Convert CNF to clauses
+def cnf_to_clauses(cnf, symbols_map, flag=False):
+    if isinstance(cnf, And):
+        return [cnf_to_clauses(arg, symbols_map, flag) for arg in cnf.args]
+    elif isinstance(cnf, Or):
+        clause = ' '.join(cnf_to_clauses(arg, symbols_map, flag=True) for arg in cnf.args) + ' 0'
+        return clause
+    elif isinstance(cnf, Not):
+        return f'-{cnf_to_clauses(cnf.args[0], symbols_map, flag)}'
+    elif isinstance(cnf, sp.Symbol):
+        clause = f'{symbols_map[cnf] }'
+        return clause if flag else [clause + ' 0']
+    elif cnf == sp.true:
+        return []
+    else:
+        raise ValueError(f'Invalid CNF: {cnf}')
+
+# Convert weighted logical expressions to clauses
+def wlogi_to_clauses(wlogi_list, symbols_map):
+    clauses = []
+    weights = []
+    z = sp.symbols(f'z_:{len(wlogi_list)}')
+    l = len(symbols_map)
+    for symbol in z:
+        extend_symbols_map(symbols_map, symbol)
+    for i, (w, logi) in enumerate(wlogi_list):
+        weights.append(f'c p weight {l + i + 1} {se.cos(2*se.pi*w).evalf()} {se.sin(2*se.pi*w).evalf()} 0')
+        idx = counter["idx"]
+        temp = encode_equivalence(z[i], logi)
+        for i in range(idx, counter["idx"]):
+            extend_symbols_map(symbols_map, sp.Symbol(f'e_{i}'))
+        clauses.extend(cnf_to_clauses(temp, symbols_map))
+    return weights, clauses, symbols_map
+
+# Convert PathSum object to DIMACS format
+def to_DIMACS(pathsum, filename='wmc.cnf'):
+    counter["idx"] = 0
+    free_symbols_list = [sp.Symbol(item) for item in pathsum.bits]
+    free_symbols_list.extend(sp.sympify(free_symbol) for free_symbol in pathsum.pathvar)
+    symbols_map ={}
+    for symbol in free_symbols_list:
+        extend_symbols_map(symbols_map, symbol)
+
+    weights, clauses, symbols_map = wlogi_to_clauses(P_to_wlogi(pathsum.P), symbols_map)
+    for qubit in range(pathsum.num_qubits):
+        a = sp.Symbol(pathsum.bits[qubit])
+        idx = counter["idx"]
+        b = anf_to_cnf(pathsum.f[qubit])
+        if len(b) == 1:
+            b = b[0]
+        else:
+            for i in range(idx, counter["idx"]):
+                extend_symbols_map(symbols_map, sp.Symbol(f'e_{i}'))
+            clauses.extend(cnf_to_clauses(b[1], symbols_map))
+            b = b[0]
+        temp = encode_equivalence(a, b)
+        clauses.extend(cnf_to_clauses(temp, symbols_map))
+        
+    DIMACS_text = f'p cnf {len(symbols_map)} {len(clauses)}\nc t wmc'
+    DIMACS_text += '\n' + '\n'.join(weights + clauses)
+    with open(filename, 'w') as file:
+        file.write(DIMACS_text.strip())
+    return DIMACS_text
+
+def run_wmc(file='wmc.cnf'):
+    result = subprocess.run([str(WMC()), "-mode=1", file], capture_output=True, text=True)
+
+    output_lines = result.stdout.split("\n")
+
+    for line in output_lines:
+        if line.startswith("c s exact double prec-sci"):
+            match = re.search(r"([-+]?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)([-+]\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)i", line)
+            if match:
+                real_part = float(match.group(1))  
+                imag_part = float(match.group(2)) 
+                return real_part, imag_part
+            match = re.search(r"([-+]?\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)", line)
+            if match:
+                real_part = float(match.group(1))  
+                imag_part = 0 
+                return real_part, imag_part
+            match = re.search(r"([-+]\d+(?:\.\d+)?(?:[eE][-+]?\d+)?)i", line)
+            if match:
+                real_part = 0 
+                imag_part = float(match.group(1))  
+                return real_part, imag_part
+    return None
+
+if __name__ == "__main__":
+    # from pathsum.pathsum import PathSum, F, Register
+    # y = se.symbols('y_:2')
+    # x = se.symbols('x_:2')
+    # P = se.Rational(1, 2) * x[0] * y[0] + se.Rational(1, 2) * y[0] * y[1]
+
+    # reg = Register(2)
+    # data = {reg[0].name: y[1]}
+    # bits = tuple(data.keys())
+    # f = F(reg, data=data, bits=bits)
+
+    # pathvar = frozenset(y)
+    # circuit = PathSum(P, f, pathvar)
+
+    # print(to_DIMACS(circuit, filename='wmc.cnf'))
+    # print("result:",run_wmc(file='wmc.cnf'))
+
+    x = sp.symbols('x_:10')
+    # A = sp.Symbol('A')
+    # B = And(Or(x,y),z)
+    A = x[0]
+    B = (x[3] | x[4] | ~x[1]) & (x[3] | x[1] | ~x[4]) & (x[4] | x[1] | ~x[3]) 
+    # & (x[4] | x[2] | ~x[5]) & (x[4] | x[5] | ~x[2]) & (x[2] | x[5] | ~x[4]) & (~x[3] | ~x[4] | ~x[1]) & (~x[4] | ~x[2] | ~x[5]) 
+
+    eq_cnf = encode_equivalence(A, B)
+    print(eq_cnf)
+
+    # anf = Xor(*x)
+    # print('anf:', anf)
+    # cnf = anf_to_cnf(anf)
+    # print('cnf:', cnf)

QuPRS/interface/qasm2qc.py

@@ -0,0 +1,68 @@
+import re
+import sys
+from pathlib import Path
+
+def convert_qasm_to_qc(oldfile, output_dir=None):
+    # Determine the output directory
+    if output_dir:
+        output_dir = Path(output_dir)
+    else:
+        output_dir = Path(oldfile).parent
+
+    # Define the new file name in the specified or default directory
+    newfile = output_dir / f"{Path(oldfile).stem}.qc"
+    
+    # Copy the content from the old file to the new file
+    with open(oldfile, 'r') as infile, open(newfile, 'w') as outfile:
+        for line in infile:
+            # Ignore specific lines
+            if 'OPENQASM 2.0;' in line or 'include "qelib1.inc";' in line:
+                continue
+            # Write the line to the new file
+            outfile.write(line)
+
+    # Read the contents of the new file
+    with open(newfile, 'r') as file:
+        content = file.read()
+
+    # Replacement patterns
+    replacements = [
+        (r'qreg [^\d]*\[(\d+)\];', lambda m: f".v {' '.join(map(str, range(int(m.group(1)))))}\nBEGIN"),
+        (r'h qubits\[(\d+)\];', r'H \1'),
+        (r'x qubits\[(\d+)\];', r'X \1'),
+        (r'y qubits\[(\d+)\];', r'Y \1'),
+        (r'z qubits\[(\d+)\];', r'Z \1'),
+        (r'cx qubits\[(\d+)\][^a-z]+qubits\[(\d+)\];', r'tof \1 \2'),
+        (r'cz qubits\[(\d+)\][^a-z]+qubits\[(\d+)\];', r'CZ \1 \2'),
+        (r's qubits\[(\d+)\];', r'S \1'),
+        (r'sdg qubits\[(\d+)\];', r'S* \1'),
+        (r't qubits\[(\d+)\];', r'T \1'),
+        (r'tdg qubits\[(\d+)\];', r'T* \1'),
+        (r'swap qubits\[(\d+)\][^a-z]+qubits\[(\d+)\];', r'Swap \1 \2'),
+        (r'rz\((.+)\) qubits\[(\d+)\];', r'Rz \1 \2'),
+        (r'rx\((.+)\) qubits\[(\d+)\];', r'Rx \1 \2'),
+        (r'ry\((.+)\) qubits\[(\d+)\];', r'Ry \1 \2'),
+        (r'ccx qubits\[(\d+)\][^a-z]+qubits\[(\d+)\][^a-z]+qubits\[(\d+)\];', r'tof \1 \2 \3'),
+    ]
+    
+
+    # Apply the replacements
+    for pattern, replacement in replacements:
+        content = re.sub(pattern, replacement, content)
+    # Append "END" to the file
+    content += "END"
+
+    # Write the modified content back to the file
+    with open(newfile, 'w') as file:
+        file.write(content)
+
+    print(f"Conversion completed. Output saved to: {newfile}")
+
+
+if __name__ == "__main__":
+    if len(sys.argv) < 2 or len(sys.argv) > 3:
+        print("Usage: python script.py <oldfile.qasm> [output_dir]")
+    else:
+        oldfile = sys.argv[1]
+        output_dir = sys.argv[2] if len(sys.argv) == 3 else None
+        convert_qasm_to_qc(oldfile, output_dir)