qflux 0.0.1__py3-none-any.whl

qflux/closed_systems/spin_propagators.py

@@ -0,0 +1,300 @@
+from qiskit.circuit.library import PauliEvolutionGate
+# Trotter-Suzuki implementation for decomposition of exponentials
+# of matrices
+from qiskit.synthesis import SuzukiTrotter
+from qiskit.quantum_info import SparsePauliOp
+from qiskit import QuantumCircuit, QuantumRegister
+import numpy as np
+from itertools import groupby
+import re
+
+
+
+# -----------------------------------------------------------------
+# Hamiltonian Functions
+# -----------------------------------------------------------------
+def get_hamiltonian_n_site_terms(n, coeff, n_qubits):
+    '''
+        Assembles each term in the Hamiltonian based on their Pauli string
+        representation and multiplying by the respective coefficient.
+    '''
+    XX_coeff = coeff[0]
+    YY_coeff = coeff[1]
+    ZZ_coeff = coeff[2]
+    Z_coeff = coeff[3]
+
+    XX_term = SparsePauliOp(("I" * n + "XX" + "I" * (n_qubits - 2 - n)))
+    XX_term *= XX_coeff
+    YY_term = SparsePauliOp(("I" * n + "YY" + "I" * (n_qubits - 2 - n)))
+    YY_term *= YY_coeff
+    ZZ_term = SparsePauliOp(("I" * n + "ZZ" + "I" * (n_qubits - 2 - n)))
+    ZZ_term *= ZZ_coeff
+    Z_term = SparsePauliOp(("I" * n + "Z" + "I" * (n_qubits - 1 - n)))
+    Z_term *= Z_coeff
+
+    return (XX_term + YY_term + ZZ_term + Z_term)
+
+
+def get_heisenberg_hamiltonian(n_qubits, coeff=None):
+    r'''
+        Takes an integer number corresponding to number of spins/qubits
+        and a list of sublists containing the necessary coefficients
+        to assemble the complete Hamiltonian:
+        $$
+            H = \sum _i ^N h_z Z_i
+                + \sum _i ^{N-1} (h_xx X_i X_{i+1}
+                                  + h_yy Y_i Y_{i+1}
+                                  + h_zz Z_i Z_{i+1}
+                                 )
+        $$
+        Each sublist contains the [XX, YY, ZZ, Z] coefficients in this order.
+        The last sublist should have the same shape, but only the Z component
+        is used.
+        If no coefficient list is provided, all are set to 1.
+    '''
+
+    # Three qubits because for 2 we get H_O = 0
+    assert n_qubits >= 3
+
+    if coeff == None:
+        'Setting default values for the coefficients'
+        coeff = [[1.0, 1.0, 1.0, 1.0] for i in range(n_qubits)]
+
+    # Even terms of the Hamiltonian
+    # (summing over individual pair-wise elements)
+    H_E = sum((get_hamiltonian_n_site_terms(i, coeff[i], n_qubits)
+               for i in range(0, n_qubits-1, 2)))
+
+    # Odd terms of the Hamiltonian
+    # (summing over individual pair-wise elements)
+    H_O = sum((get_hamiltonian_n_site_terms(i, coeff[i], n_qubits)
+               for i in range(1, n_qubits-1, 2)))
+
+    # adding final Z term at the Nth site
+    final_term = SparsePauliOp("I" * (n_qubits - 1) + "Z")
+    final_term *= coeff[n_qubits-1][3]
+    if (n_qubits % 2) == 0:
+        H_E += final_term
+    else:
+        H_O += final_term
+
+    # Returns the list of the two sets of terms
+    return [H_E, H_O]
+
+
+def get_time_evolution_operator(num_qubits, tau, trotter_steps, coeff=None):
+    '''
+        Given a number of qubits, generates the corresponding time-evolution for
+        the Ising model with the same number of sites.
+
+        Input:
+            num_qubits (int): number of qubits, which should be equal to the
+                number of spins in the chain
+            evo_time (float): time parameter in time-evolution operator
+            trotter_steps (int): number of time steps for the Suzuki-Trotter
+                decomposition
+            coeff (list of lists): parameters for each term in the Hamiltonian
+                for each site ie ([[XX0, YY0, ZZ0, Z0], [XX1, YY1, ZZ1, Z1], ...])
+        Returns:
+            evo_op.definition: Trotterized time-evolution operator
+    '''
+    # Constructing the Hamiltonian here;
+    # heisenberg_hamiltonian = [H_E, H_O]
+    heisenberg_hamiltonian = get_heisenberg_hamiltonian(num_qubits,
+                                                        coeff)
+
+    # e^ (-i*H*evo_time), with Trotter decomposition
+    # exp[(i * evo_time)*(IIIIXXIIII + IIIIYYIIII + IIIIZZIIII + IIIIZIIIII)]
+    evo_op = PauliEvolutionGate(heisenberg_hamiltonian, tau,
+                                synthesis=SuzukiTrotter(order=2,
+                                    reps=trotter_steps))
+    # The Trotter order=2 applies one set of the operators for
+    # half a timestep, then the other set for a full timestep,
+    # then the first step for another half a step note that reps
+    # includes the number of repetitions of the Trotterized
+    # operator higher number means more repetitions, and thus
+    # allowing larger timestep
+    return evo_op.definition
+
+
+def find_string_pattern(pattern, string):
+    match_list = []
+    for m in re.finditer(pattern, string):
+        match_list.append(m.start())
+    return match_list
+
+
+# efficient propagator for pauli hamiltonians
+def sort_Pauli_by_symmetry(ham):
+    '''
+        Separates a qiskit PauliOp object terms into 1 and 2-qubit
+        operators. Furthermore, 2-qubit operators are separated according
+        to the parity of the index first non-identity operation.
+    '''
+    one_qubit_terms = []
+    two_qubit_terms = []
+    # separating the one-qubit from two-qubit terms
+    for term in ham:
+        matches = find_string_pattern('X|Y|Z', str(term.paulis[0]))
+        pauli_string = term.paulis[0]
+        coeff = np.real(term.coeffs[0])
+        str_tag = pauli_string.to_label().replace('I', '')
+        if len(matches) == 2:
+            two_qubit_terms.append((pauli_string, coeff, matches, str_tag))
+        elif len(matches) == 1:
+            one_qubit_terms.append((pauli_string, coeff, matches, str_tag))
+
+    # sorting the two-qubit terms according to index on which they act
+    two_qubit_terms = sorted(two_qubit_terms, key=lambda x: x[2])
+    # separating the even from the odd two-qubit terms
+    even_two_qubit_terms = list(filter(lambda x: not x[2][0]%2, two_qubit_terms))
+    odd_two_qubit_terms = list(filter(lambda x: x[2][0]%2, two_qubit_terms))
+
+    even_two_qubit_terms = [list(v) for i, v in groupby(even_two_qubit_terms, lambda x: x[2][0])]
+    odd_two_qubit_terms = [list(v) for i, v in groupby(odd_two_qubit_terms, lambda x: x[2][0])]
+
+    return one_qubit_terms, even_two_qubit_terms, odd_two_qubit_terms
+
+
+def generate_circ_pattern_1qubit(circ, term, delta_t):
+    '''
+        General 1-qubit gate for exponential of product identity and
+        a single pauli gate.
+        Only a single rotation operation is required, with the angle
+        being related to the exponential argument:
+
+        R_P(coeff) = exp(-i * coeff * P / 2)
+
+        Where P is the Pauli gate and coeff encompasses the constant
+        coefficient term
+    '''
+    coeff = 2 * term[1] * delta_t
+    if term[3] == 'X':
+        circ.rx(coeff, term[2])
+    elif term[3] == 'Y':
+        circ.ry(coeff, term[2])
+    elif term[3] == 'Z':
+        circ.rz(coeff, term[2])
+
+    return circ
+
+
+def generate_circ_pattern_2qubit(circ, term, delta_t):
+    r'''
+        General 2-qubit gate for exponential of Paulis. This is the
+        optimal decomposition, based on a component of a U(4) operator.
+        (see )
+
+        The circuit structure is as follows:
+
+        - ---- I ---- C - Rz(o) - X --- I --- C - Rz(pi/2) -
+        - Rz(-pi/2) - X - Ry(p) - C - Ry(l) - X ---- I -----
+
+        Where CX represent CNOT operations, R are rotation gates with angles,
+        and I is the identity matrix. The angles are parameterized as follows:
+
+        $ o = \theta = (\pi/2 - A) $
+        $ p = \phi = (A - \pi/2) $
+        $ l = \lambda = (\pi/2 - A) $
+
+        Where A is the exponential argument.
+    '''
+    # wires to which to apply the operation
+    wires = term[0][2]
+
+    # angles to parameterize the circuit,
+    # based on exponential argument
+    if any('XX' in sublist for sublist in term):
+        g_phi = ( 2 * (-1) * term[0][1] * delta_t - np.pi / 2)
+    else:
+        g_phi = - np.pi / 2
+    if any('YY' in sublist for sublist in term):
+        g_lambda = (np.pi/2 - 2 * (-1) * term[1][1] * delta_t)
+    else:
+        g_lambda = np.pi/2
+    if any('ZZ' in sublist for sublist in term):
+        g_theta = (np.pi/2 - 2 * (-1) * term[2][1] * delta_t)
+    else:
+        g_theta = np.pi/2
+
+    # circuit
+    circ.rz(-np.pi/2, wires[1])
+    circ.cx(wires[1], wires[0])
+    circ.rz(g_theta, wires[0])
+    circ.ry(g_phi, wires[1])
+    circ.cx(wires[0], wires[1])
+    circ.ry(g_lambda, wires[1])
+    circ.cx(wires[1], wires[0])
+    circ.rz(np.pi/2, wires[0])
+    return circ
+
+
+def get_manual_Trotter(num_q, pauli_ops, timestep, n_trotter=1,
+                       trotter_type='basic', reverse_bits=True):
+    # sorts the Pauli strings according to qubit number they affect and symmetry
+    one_q, even_two_q, odd_two_q = sort_Pauli_by_symmetry(pauli_ops)
+    # scales the timestep according to the number of trotter steps
+    timestep_even_two_q = timestep / n_trotter
+    timestep_odd_two_q = timestep / n_trotter
+    timestep_one_q = timestep / n_trotter
+    # symmetric places 1/2 of one_q and odd_two_q before and after even_two_q
+    if trotter_type == 'symmetric':
+        timestep_odd_two_q /= 2
+        timestep_one_q /= 2
+    # constructs circuits for each segment of the operators
+    qc_odd_two_q, qc_even_two_q, qc_one_q = QuantumCircuit(num_q), QuantumCircuit(num_q), QuantumCircuit(num_q)
+    for i in even_two_q:
+        qc_even_two_q = generate_circ_pattern_2qubit(qc_even_two_q, i, timestep_even_two_q)
+    for i in odd_two_q:
+        qc_odd_two_q = generate_circ_pattern_2qubit(qc_odd_two_q, i, timestep_odd_two_q)
+    for i in one_q:
+        qc_one_q = generate_circ_pattern_1qubit(qc_one_q, i, timestep_one_q)
+    # assembles the circuit for Trotter decomposition of exponential
+    qr = QuantumRegister(num_q)
+    qc = QuantumCircuit(qr)
+    if trotter_type == 'basic':
+        qc = qc.compose(qc_even_two_q)
+        qc = qc.compose(qc_odd_two_q)
+        qc = qc.compose(qc_one_q)
+    elif trotter_type == 'symmetric':
+        qc = qc.compose(qc_one_q)
+        qc = qc.compose(qc_odd_two_q)
+        qc = qc.compose(qc_even_two_q)
+        qc = qc.compose(qc_odd_two_q)
+        qc = qc.compose(qc_one_q)
+    # repeats the single_trotter circuit several times to match n_trotter
+    for i in range(n_trotter-1):
+        qc = qc.compose(qc)
+    if reverse_bits:
+        return qc.reverse_bits()
+    else:
+        return qc
+
+
+if __name__ == '__main__':
+    num_shots = 100
+    num_q = 3
+    evolution_timestep = 0.1
+    n_trotter_steps = 1
+    # XX YY ZZ, Z
+    ham_coeffs = ([[0.75/2, 0.75/2, 0.0, 0.65]]
+                    + [[0.5, 0.5, 0.0, 1.0]
+                    for i in range(num_q-1)])
+    time_evo_op = get_time_evolution_operator(
+        num_qubits=num_q, tau=evolution_timestep,
+        trotter_steps=n_trotter_steps, coeff=ham_coeffs)
+    print(time_evo_op)
+
+    spin_chain_hamiltonian = get_heisenberg_hamiltonian(num_q,
+                                                        ham_coeffs)
+
+    spin_chain_hamiltonian = sum(spin_chain_hamiltonian)
+    print(get_manual_Trotter(num_q, spin_chain_hamiltonian,
+                             0.1).draw())
+    print(get_manual_Trotter(num_q, spin_chain_hamiltonian, 0.1,
+                             n_trotter=2).draw())
+    print(get_manual_Trotter(num_q, spin_chain_hamiltonian, 0.1,
+                             trotter_type='symmetric').draw())
+    print(get_manual_Trotter(num_q, spin_chain_hamiltonian, 0.1,
+                             n_trotter=2,
+                             trotter_type='symmetric').draw())

qflux/closed_systems/utils.py

@@ -0,0 +1,205 @@
+# Utilities
+# Plotting utilities, conversion factors, etc.
+import numpy as np
+import qiskit_aer
+from qiskit.compiler import transpile
+from qiskit_ibm_runtime import Sampler
+from qiskit.quantum_info import SparsePauliOp
+import itertools
+
+# Conversion Factors:
+def convert_au_to_eV(input_val):
+    au2ev = 27.21138602
+    return(au2ev * input_val)
+
+
+def convert_eV_to_au(input_val):
+    au2ev = 27.21138602
+    ev2au = 1/au2ev
+    return(ev2au * input_val)
+
+
+def convert_bohr_to_au(input_val):
+    bohr2au = 0.52917721092
+    return(bohr2au * input_val)
+
+
+def convert_au_to_bohr(input_val):
+    bohr2au = 0.52917721092
+    au2bohr = 1/bohr2au
+    return(input_val * au2bohr)
+
+
+def convert_fs_to_au(input_val):
+    fs2au = 41.3414
+    return(fs2au * input_val)
+
+
+def convert_au_to_fs(input_val):
+    fs2au = 41.3414
+    au2fs = 1/fs2au
+    return(au2fs * input_val)
+
+
+def get_proton_mass():
+    proton_mass = 1836.15267343 # proton-electron mass ratio
+    return(proton_mass)
+
+
+def execute(QCircuit, backend=None, shots=None, real_backend=False):
+    '''
+        Function to replace the now-deprecated Qiskit
+        `QuantumCircuit.execute()` method.
+
+        Input:
+          - `QCircuit`: qiskit.QuantumCircuit object
+          - `Backend`: qiskit.Backend instance
+          - `shots`: int specifying the number of shots
+          - `real_backend`: bool specifying whether the provided backend is
+            a real device (True) or not (False)
+    '''
+    if shots:
+        n_shots = shots
+    else:
+        n_shots = 1024 # Use the qiskit default if not specified
+
+    if real_backend:
+        QCircuit.measure_all()
+        qc = transpile(QCircuit, backend=backend)
+        sampler = Sampler(backend)
+        job = sampler.run([qc], shots=n_shots)
+    else:
+        # Transpile circuit with statevector backend
+        tmp_circuit = transpile(QCircuit, backend)
+        # Run the transpiled circuit
+        job = backend.run(tmp_circuit, n_shots=shots)
+    return(job)
+
+
+# Calculation of Expectation Value:
+def calculate_expectation_values(dynamics_results, observable_grid, do_FFT=False, dx=None):
+    '''
+    Function to calculate the time-dependent expectation value of an observable O defined on a grid.
+    Inputs:
+
+        - `dynamics_results`: np.ndarray of wavefunctions/propagated states with shape: (n_steps, nx)
+        - `observable_grid`: np.array of observable
+    '''
+    if dx:
+        d_observable = dx
+    else:
+        d_observable = observable_grid[1] - observable_grid[0]
+    if do_FFT:
+        psi_list = np.fft.fft(dynamics_results, axis=1, norm='ortho')
+    else:
+        psi_list = dynamics_results
+    # Compute the expectation value.
+    expectation  = np.real(np.sum(psi_list.conj()*observable_grid*psi_list*d_observable, axis=1))
+
+    return(expectation)
+
+# Pauli Decomposition Utilities
+
+def vec_query(arr, my_dict):
+    '''
+    This function vectorizes dictionary querying, allowing us to query `my_dict` with a np.array `arr` of keys.
+    '''
+
+    return np.vectorize(my_dict.__getitem__, otypes=[tuple])(arr)
+
+
+def nested_kronecker_product(a):
+    '''
+    Handles Kronecker Products for list (i.e.,  a = [Z, Z, Z] will evaluate Z ⊗ Z ⊗ Z)
+    '''
+    if len(a) == 2:
+            return np.kron(a[0],a[1])
+    else:
+        return np.kron(a[0], nested_kronecker_product(a[1:]))
+
+
+def Hilbert_Schmidt(mat1, mat2):
+    'Return the Hilbert-Schmidt Inner Product of two matrices.'
+    return np.trace(mat1.conj().T * mat2)
+
+
+def decompose(Ham_arr, tol=12, subset = None):
+    '''
+    Function that takes an input matrix `H` and decomposes into a sum of tensor products of Pauli Matrices.
+        - The expectation is that `H` will have a shape of 2^n, where n is the number of qubits needed to represent
+        the matrix in this form. n determines the number of terms in the tensor product composing the Pauli strings.
+        - Ex: If H has shape of (16, 16), n = log2(H) = 4 qubits.
+         The Pauli strings will then take the form of ['IIII', 'ZIII', 'ZZII', etc.]
+    Has the option to toggle verbose output, which prints the terms of the pauli sum.
+    '''
+
+    X = np.asarray([[0,1],[1,0]])
+    Y = np.asarray([[0,complex(0,-1)],[complex(0,1),0]])
+    Z = np.asarray([[1,0],[0,-1]])
+    I = Z@Z
+    # Define a dictionary with the four Pauli matrices:
+    global_pms = {'I': I,'X': X,'Y': Y,'Z': Z}
+
+    # The next few lines allow for the function use a reduced basis.
+    pm_keys = []
+    pm_vals = []
+    if subset:
+        for tmp_key in subset:
+            pm_keys.append(tmp_key)
+            pm_vals.append(global_pms[tmp_key])
+        pms = dict(zip(pm_keys, pm_vals))
+    else:
+        pms = global_pms
+
+    pauli_keys = list(pms.keys()) # Keys of the dictionary
+
+    nqb = int(np.log2(Ham_arr.shape[0])) # Determine the # of qubits needed
+
+    # Make all possible tensor products of Pauli matrices sigma
+    sigma_combinations = list(itertools.product(pauli_keys, repeat=nqb))
+
+    output_string = '' # Initialize an empty string to which we can add our terms
+    for ii in range(len(sigma_combinations)):
+        pauli_str = ''.join(sigma_combinations[ii])
+
+        # Convert the Pauli string into a list of matrices
+        tmp_mat_list = vec_query(np.array(sigma_combinations[ii]), pms)
+
+        # Evaluate the Kronecker product of the matrix array
+        tmp_p_matrix = nested_kronecker_product(tmp_mat_list)
+
+        # Compute the coefficient for each Pauli string
+        a_coeff = (1/(2**nqb)) * Hilbert_Schmidt(tmp_p_matrix, Ham_arr)
+
+        # If the coefficient is non-zero, we want to use it!
+        if abs(a_coeff) > 10**(-tol):
+            output_string += str(np.round(a_coeff.real, tol))+'*'+pauli_str
+            output_string += '+' # Add a plus sign for the next term!
+
+    return output_string[:-1] # To ignore that extra plus sign
+
+
+def build_pauli_dict(decomposed_operator):
+    '''
+    Build a Pauli dictionary from the output of the `decompose` function above.
+    This is done by converting the unique Pauli Strings ['IIII', 'IIIZ', etc.] to keys,
+    where the values of the dictionary are the numerical coefficients.
+    '''
+    single_terms = decomposed_operator.split('+')
+    pauli_dict_out = {}
+    for term in single_terms:
+        coeff, pauli_str = term.split('*')
+        pauli_dict_out[pauli_str] = float(coeff)
+    return pauli_dict_out
+
+
+def pauli_strings_2_pauli_sum(operator):
+    '''
+    Function to convert the output of the `decompose` function above into a Qiskit-recognized PauliSumOp.
+    The string representing the Hamiltonian as a sum of product of Paulis is converted into a dictionary where
+    the keys are the Pauli Strings (ex: 'IIII' or 'IXYZ') and the values are the coefficients.
+    '''
+    tmp_pauli_dict = build_pauli_dict(operator)
+    # Convert the dict to a list of tuples of the form [('Pauli String', float_coeff), ...]
+    tmp_pauli_sum = SparsePauliOp(data=list(tmp_pauli_dict.keys()), coeffs=list(tmp_pauli_dict.values()))
+    return tmp_pauli_sum

qflux/open_systems/__init__.py

@@ -0,0 +1,2 @@
+from .numerical_methods import DynamicsOS, DVR_grid
+from .quantum_simulation import QubitDynamicsOS

qflux/open_systems/dilation_circuit.py

@@ -0,0 +1,183 @@
+import numpy as np
+import scipy.linalg as LA
+
+from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
+from qiskit.quantum_info.operators import Operator
+
+from . import walsh_gray_optimization as wo
+
+
+def scale_array(array,scale=1.1):
+    """
+    renormalize an array to make sure it is a contraction
+    """
+    # Normalization factor, divide by martix's norm to ensure contraction
+    # may divide a larger scaling factor controlled by the number (scale)
+    norm = LA.norm(array,2)*scale
+    array_new = array/norm
+    
+    return array_new, norm
+
+def dilate_Sz_Nagy(array):
+    """
+    dilate the non-unitary array (should be a contraction) to a unitary matrix
+    array: ndarray of N*N
+    """
+    ident = np.eye(array.shape[0])
+      
+    # Calculate the conjugate transpose of the G propagator
+    fcon = (array.conjugate()).T
+      
+    # Calculate the defect matrix for dilation
+    fdef = LA.sqrtm(ident - np.dot(fcon, array))
+      
+    # Calculate the defect matrix for the conjugate of the G propagator
+    fcondef = LA.sqrtm(ident - np.dot(array, fcon))
+      
+    # Dilate the G propagator to create a unitary operator
+    array_dilated = np.block([[array, fcondef], [fdef, -fcon]])
+    
+    return array_dilated
+          
+#generate the quantum gate matrices for SVD-dilation
+def dilate_SVD(array):
+    """
+    dilate the non-unitary array to unitary matrices using SVD technique by Schlimgen et al
+    (Phys. Rev. A 2022, 106, 022414.)
+    
+    array: ndarray of N*N (should be a contraction)
+    """
+    
+    #get the dimension of the array
+    Nvec = array.shape[0]
+    
+    #Performing SVD to the array
+    U1,S1,V1 = LA.svd(array)
+
+    Mzero = np.zeros((Nvec,Nvec),dtype=np.complex128)
+    fk=np.zeros(2*Nvec,dtype=np.float64)
+    
+    Sig_p = np.zeros(Nvec,dtype=np.complex128)
+    Sig_m = np.zeros(Nvec,dtype=np.complex128)
+    for i in range(len(S1)):
+        
+        Sig_p[i] = S1[i]+1j*np.sqrt((1-S1[i]**2))
+        Sig_m[i] = S1[i]-1j*np.sqrt((1-S1[i]**2))
+    
+        #here U_Sigma = e^{i f_k}
+        fk[i] = (-1j*np.log(Sig_p[i])).real
+        fk[Nvec+i] = (-1j*np.log(Sig_m[i])).real
+    
+    SG0 = np.block([[np.diag(Sig_p),Mzero],\
+          [Mzero,np.diag(Sig_m)]])
+
+    return U1, V1, SG0, fk
+
+
+def cons_SVD_cirq(Nqb, array, ini_vec, Iswalsh = True):
+    """
+    Construct the SVD-dilation circuit
+    Nqb: number of qubits
+    array: the non-unitary array (should be a contraction)
+    ini_vec: initial qubit state vector (in the dilation space)
+    Iswalsh: If True, then combine with Walsh operator representation to reduce the circuit depth
+    """
+    
+    qc = QuantumCircuit(Nqb,Nqb)
+    qc.initialize(ini_vec,range(0,Nqb))
+    
+    U_matu,U_matv,S_mat0,fk = dilate_SVD(array)
+    
+    qc.append(Operator(U_matv),range(0,Nqb-1))
+    qc.h(Nqb-1)
+
+    if(Iswalsh):
+        #the walsh coeff
+        arr_a = wo.walsh_coef(fk,Nqb)
+        
+        Ulist_diag0 = wo.cirq_list_walsh(arr_a,Nqb,1E-5)
+        Ulist_diag = wo.optimize(Ulist_diag0)
+        qc_diag = wo.cirq_from_U(Ulist_diag,Nqb)
+        
+        qc.append(qc_diag.to_gate(),range(Nqb))
+
+    else:
+        qc.append(Operator(S_mat0),range(Nqb))
+      
+    qc.append(Operator(U_matu),range(0,Nqb-1))
+    qc.h(Nqb-1)
+
+    return qc
+
+def cons_SzNagy_cirq(Nqb, array, ini_vec):
+    """
+    Construct the Sz-Nagy-dilation circuit
+    Nqb: number of qubits
+    array: the non-unitary array (should be a contraction)
+    ini_vec: initial qubit state vector (in the dilation space)
+    """
+    
+    qr = QuantumRegister(Nqb)  # Create a quantum register
+    cr = ClassicalRegister(Nqb)  # Create a classical register to store measurement results
+    qc = QuantumCircuit(qr, cr)  # Combine the quantum and classical registers to create the quantum circuit
+    
+    # Initialize the quantum circuit with the initial state
+    qc.initialize(ini_vec, qr)
+    
+    # Create a custom unitary operator with the dilated propagator
+    U_dil = dilate_Sz_Nagy(array)
+    U_dil_op = Operator(U_dil)
+    
+    # Apply the unitary operator to the quantum circuit's qubits
+    qc.unitary(U_dil_op, qr)
+
+    return qc
+
+def construct_circuit(Nqb, array,statevec,method = 'Sz-Nagy',Isscale = True):
+    """
+    construct the quantum circuit
+    
+    method: specify the dilation method, can be 'Sz-Nagy' or 'SVD' or 'SVD-Walsh'
+        'Sz-Nagy': using Sz-Nagy method do dilation
+        'SVD': using SVD-dilation method 
+        'SVD-Walsh': SVD-dilation combine with Walsh operator representation to reduce the circuit depth
+    
+    Nqb: number of qubits in the original space, should match the dimension of array (N=2^Nqb)
+    array: ndarray of N*N
+    statevec: ndarray of N*1 (initial statevector)
+    
+    Isscale: 
+        if Ture, renormalize the array to make sure it is a contraction
+        if False, do not renormalize. 
+    """   
+    
+    #the number of qubits for the original space
+    if(2**Nqb != array.shape[0]):
+        print('error, array dimension not matched!')
+    
+    #state vector in the dilated space
+    statevec_dil = np.concatenate((statevec, np.zeros_like(statevec)))
+    
+    #first scale the array to make it a contraction
+    if(Isscale):
+        array_new, normfac = scale_array(array)
+    else:
+        array_new = array
+    
+    if(method == 'Sz-Nagy'):
+        qc = cons_SzNagy_cirq(Nqb+1, array_new, statevec_dil)
+    elif(method == 'SVD'):
+        Iswalsh = False
+        qc = cons_SVD_cirq(Nqb+1, array_new, statevec_dil, Iswalsh)
+    elif(method == 'SVD-Walsh'):
+        Iswalsh = True
+        qc = cons_SVD_cirq(Nqb+1, array_new, statevec_dil, Iswalsh)
+    else:
+        print('method error in construct circuit')
+    
+    if(Isscale):
+        return qc,normfac
+    else:
+        return qc
+
+