qflux 0.0.1__py3-none-any.whl

qflux/open_systems/trans_basis.py

@@ -0,0 +1,121 @@
+import numpy as np
+import scipy.fft as sfft
+
+#the module in the current package
+from . import params as pa
+    
+def x2k_wave(dx,psi):
+    """
+    transform the wavefunction from x space to k space
+    dx: the interval of the x-space grid point
+    psi: the wavefunction in the x-space
+    """
+    pre_fac = dx/(2*np.pi)**0.5
+    psik = sfft.fft(psi)*pre_fac
+    return psik
+
+def k2x_wave(dx,psik):
+    """
+    transform the wavefunction from x space to k space
+    dx: the interval of the x-space grid point
+    psi: the wavefunction in the k-space
+    """
+    pre_fac = (2*np.pi)**0.5/dx
+    psix  = sfft.ifft(psik.copy())*pre_fac
+    return psix
+
+def nested_kronecker_product(pauli_str):
+    '''
+    Handles Kronecker Products for list (i.e., pauli_str = 'ZZZ' will evaluate Z Z Z).
+    Given string 'pauli_str' this evaluates the kronecker product of all elements.
+    '''
+
+    # Define a dictionary with the four Pauli matrices:
+    pms = {'I': pa.I,'X': pa.X,'Y': pa.Y,'Z': pa.Z}
+
+    result = 1
+    for i in range(len(pauli_str)):
+     result = np.kron(result,pms[pauli_str[i]])
+    return result
+
+
+def pauli_to_ham(pauli_dict, Nqb):
+    ''' 
+        Function that Assembles the Hamiltonian based on their Pauli string
+        
+        pauli_dict: A dictionary that contain all the pauli string and the value of the Hamiltonian
+            (the key is pauli string and the value is coefficient)
+        
+        Nqb: number of qubits, should match the length of the pauli string
+        
+        return: Hamiltonian matrix 
+    '''
+        
+    Hmat = np.zeros((2**Nqb,2**Nqb),dtype=np.complex128)
+    for key in pauli_dict:
+        Hmat += pauli_dict[key]*nested_kronecker_product(key)
+
+    return Hmat
+
+def ham_to_pauli(Ham_arr, Nqb, tol=1E-5):
+    '''
+    Function that decomposes `Ham_arr` into a sum of Pauli strings.
+    result: a dictionary with the key is pauli string and the value is coefficient
+    '''
+    import itertools
+
+    pauli_keys = ['I','X','Y','Z'] # Keys of the dictionary
+
+    if(2**Nqb != Ham_arr.shape[0]):
+        print('Nqb and Matrix size not matched!')
+
+    # Make all possible tensor products of Pauli matrices sigma
+    sigma_combinations = list(itertools.product(pauli_keys, repeat=Nqb))
+
+    result = {} # Initialize an empty dictionary to the results
+    for ii in range(len(sigma_combinations)):
+        pauli_str = ''.join(sigma_combinations[ii])
+
+        # Evaluate the Kronecker product of the matrix array
+        tmp_p_matrix = nested_kronecker_product(pauli_str)
+
+        # Compute the coefficient for each Pauli string
+        a_coeff = (1/(2**Nqb)) * np.trace(tmp_p_matrix @ Ham_arr)
+
+        # If the coefficient is non-zero, we want to use it!
+        if abs(a_coeff) > tol:
+            result[pauli_str] = a_coeff.real
+
+    return result
+
+def trans_basis(operator,nbasis,psi_newbasis):
+    """
+    operator: the operator matrix in the old basis
+    nbasis: the truncation in the new basis
+    psi_newbasis: the new basis wave function expressed in the old basis 
+               psi_newbasis[i,j] = <i|psi_newbasis|j>, with i is old basis, j new basis
+    """
+    
+    operator_new = np.zeros((nbasis,nbasis),dtype=np.complex128)
+    
+    for i in range(nbasis):
+      for j in range(nbasis):
+        operator_new[i,j] = np.dot(np.dot(psi_newbasis[:,i].conj(),operator),psi_newbasis[:,j])
+
+    return operator_new
+
+def trans_basis_diag(diag_opr,nbasis,psi_newbasis):
+    """
+    diag_opr: the array represent the diagnoal operator in the old basis
+    nbasis: the truncation in the new basis
+    psi_newbasis: the new basis wave function expressed in the old basis 
+               psi_newbasis[i,j] = <i|psi_newbasis|j>, with i is old basis, j new basis
+    """
+    
+    operator_new = np.zeros((nbasis,nbasis),dtype=np.complex128)
+    
+    for i in range(nbasis):
+      for j in range(nbasis):
+        operator_new[i,j] = np.dot(np.multiply(psi_newbasis[:,i].conj(),diag_opr),psi_newbasis[:,j])
+
+    return operator_new

qflux/open_systems/walsh_gray_optimization.py

@@ -0,0 +1,311 @@
+import numpy as np
+from qiskit import QuantumRegister, QuantumCircuit
+
+from .params import I,X,Y,Z
+
+##=======the Walsh operator scheme===========
+#1. functions for Walsh representation
+#(a). the binary and qubit state representation of a integer
+#(b). the function to calculate walsh coefficient
+#this is binary representation of a integer j!
+#j=[j1,j2,j3] for example: 3=[1,1,0]
+def binary(j,nbits):
+  arr = np.zeros(nbits,dtype=int)
+  res = j
+  for i in range(nbits):
+    if(res>1):
+        arr[i] = res%2
+        res=res//2
+    else:
+        arr[i] = res
+        break
+  return arr
+
+#input: array of 0 or 1
+#output: max index of 1
+#e.g.: j=4 binary is [0,0,1,0], max_bit is 2
+def max_bit(arr):
+  iflag = 0
+  for i in range(len(arr)-1,-1,-1):
+    if(arr[i]==1):
+        iflag = i
+        break
+  return iflag
+
+#j-th gray code:
+#first do the right shift of the binary representation
+#then do the bit wise XOR
+def gray(j,nbits):
+  arr_n1 = binary(j//2,nbits) #
+  arr_j = binary(j,nbits) #
+  arr_res = np.zeros_like(arr_n1)
+  for i in range(nbits):
+    if(arr_n1[i]==arr_j[i]):
+        arr_res[i] = 0
+    else:
+        arr_res[i] = 1
+  return arr_res
+
+# return the decimal of arr_j
+# [1,1,0] is j0=1,j1=1, which is 3
+def decimal(arr_j):
+  res = 0
+  nbits = len(arr_j)
+  for i in range(nbits):
+    res+= 2**i*arr_j[i]
+  return res
+
+#2. The Walsh coefficient and operator
+#input an fk array
+#(that's the discretize array in qubit statevector) |qn,...,q1>
+#e.g. f3 is the coefficient of |0,1,1>, which is q0=1, q1=1
+#this just match the definition of function binary
+#output the coefficient in the walsh function representation
+def walsh_coef(fk,nbits):
+  nlen = 2**nbits
+  if(nlen!=len(fk)): print('walsh_coef: err in array length')
+
+  a_arr = np.zeros(nlen)
+  for i in range(nlen):
+    arr_j = binary(i,nbits)
+    for k in range(nlen):
+      fac = (-1)**(np.dot(arr_j,binary(k,nbits)))
+      a_arr[i] += fk[k]*fac
+    a_arr[i] /= nlen
+  return a_arr
+
+#walsh operator, \Prod \otimes Z^(j)
+#j=[1,1,0] return IZZ (q0,q1 is Z, q2 is I, in qiskit convention order)
+def walsh_oprQ(arr_j,nbits):
+  res = 1.0
+  for i in range(nbits-1,-1,-1):
+    if(arr_j[i]==0):
+      res = np.kron(res,I)
+    elif(arr_j[i]==1):
+      res = np.kron(res,Z)
+    else:
+      print('err')
+  return res
+
+
+#3. Walsh circuit list and Gray code optimize for diagonal unitaries
+#  functions to generate the quantum circuit of the diagnoal unitaries in the Walsh Operator representation
+#input an walsh coefficient (arra) of f_k array,
+#output the list that contain all the parameters to construct the circuit for U=diag(e^(i f_k))
+def cirq_list_walsh(arra,Nqb,epsilon):
+  if(len(arra)!=2**Nqb): print('err')
+
+  U=[]
+
+  for j in range(1,2**Nqb):
+
+    #encoding: Gray Code or Binary Code
+    #arr_j = binary(j,Nqb)
+    arr_j = gray(j,Nqb)
+    j_code = decimal(gray(j,Nqb))
+
+    if(abs(arra[j_code])<epsilon): continue
+
+    max_index = max_bit(arr_j) #the R gate will located at the max index
+
+    for ibit in range(max_index):
+      if(arr_j[ibit]==1):
+        U.append(('C',ibit,max_index))
+
+    U.append(('R',max_index,-2.0*arra[j_code]))
+
+    for ibit in range(max_index-1,-1,-1):
+      if(arr_j[ibit]==1):
+        U.append(('C',ibit,max_index))
+  return U
+
+#generate circuit from list of turple U
+def cirq_from_U(U,Nqb):
+  nlen = len(U)
+
+  #the quantum circuit
+  qr = QuantumRegister(Nqb)
+  #cr = ClassicalRegister(1)
+  qc = QuantumCircuit(qr)
+
+  for i in range(nlen):
+    gate_str = U[i]
+    if(gate_str[0]=='C'):
+      qc.cx(gate_str[1],gate_str[2])
+    elif(gate_str[0]=='R'):
+      qc.rz(gate_str[2],gate_str[1])
+    else:
+      print('err in reading circuit')
+  return qc
+
+
+#Optimize the quantum circuit
+def optimize(U):
+  U0,iflag0 = scanI(U)
+  U0,iflag1 = scanRule2(U0)
+
+  #some possible exchange and check
+  i = 0
+  while(i<len(U0)-1):
+
+    if(U0[i+1][0] == 'C' and U0[i][0] =='C'):
+
+      ictrl = U0[i][1]; itarg = U0[i][2]
+      if(ictrl == U0[i+1][1] or itarg == U0[i+1][2]):
+        Utmp = U0.copy()
+        Utmp[i] = U0[i+1]
+        Utmp[i+1] = U0[i]
+        Utmp,iflag0 = scanI(Utmp)
+        Utmp,iflag1 = scanRule2(Utmp)
+
+        #if(iflag0 or iflag1): U0 = Utmp
+        U0 = Utmp
+
+    i += 1
+  return U0
+
+#scan if there are identical adjacent CNOT gate
+def scanI(U):
+  nlen = len(U)
+  newU = []
+  i=0
+  iflag = 0
+  while(i<nlen-1):
+    if(U[i]==U[i+1] and U[i][0] =='C'):
+      i += 2
+      iflag = 1
+    else:
+      newU.append(U[i])
+      i += 1
+  #end
+  if(i==nlen-1): newU.append(U[nlen-1])
+  return newU,iflag
+
+#scan if there have 3 gate can reduced to:
+#the target of one CNOT is the control of another.
+#CijCjk = CjkCikCij
+def scanRule2(U):
+  nlen = len(U)
+  newU = []
+  i=0
+  iflag = 0
+  while(i<nlen-2):
+
+    if(U[i][0] == U[i+1][0] == U[i+2][0] =='C'):
+      sj = U[i][1]
+      sk = U[i][2]
+      si = U[i+1][1]
+      if(sj == U[i+2][2] and si == U[i+2][1] and sk == U[i+1][2]):
+        i += 3
+        newU.append(('C',si,sj))
+        newU.append(('C',sj,sk))
+        print('Rule2')
+        iflag = 1
+      else:
+        newU.append(U[i])
+        i += 1
+    else:
+      newU.append(U[i])
+      i += 1
+  #end
+  if(i==nlen-2):
+    newU.append(U[nlen-2])
+    newU.append(U[nlen-1])
+  return newU,iflag
+##=======end the Walsh operator scheme===========
+
+##=======test functions for Walsh operator scheme=========
+#extented matrix of the quantum gate
+#note that this is the reverse order with qiskit convention
+def ext_cx(ictrl,itarg,Nqb):
+  if(ictrl>=Nqb or itarg>=Nqb): print('err')
+  Proj00 = np.array([[1.0,0],[0,0]])
+  Proj11 = np.array([[0.0,0],[0,1]])
+
+  res00 = 1
+  res11 = 1
+  for i in range(Nqb-1,-1,-1):
+  #for i in range(Nqb):
+    if(i!=ictrl and i!=itarg):
+      res00 = np.kron(res00,I)
+      res11 = np.kron(res11,I)
+    if(i==ictrl):
+      res00 = np.kron(res00,Proj00)
+      res11 = np.kron(res11,Proj11)
+    if(i==itarg):
+      res00 = np.kron(res00,I)
+      res11 = np.kron(res11,X)
+  return res00+res11
+
+def ext_Rz(phi,iqb,Nqb):
+  if(iqb>=Nqb): print('err')
+  mat_rz = np.array([[np.exp(-1j*phi/2),0],[0,np.exp(1j*phi/2)]])
+  res = 1
+  for i in range(Nqb-1,-1,-1):
+  #for i in range(Nqb):
+    if(i!=iqb):
+      res = np.kron(res,I)
+    if(i==iqb):
+      res = np.kron(res,mat_rz)
+  return res
+
+def ext_Z(iqb,Nqb):
+  if(iqb>=Nqb): print('err')
+  res = 1
+  for i in range(Nqb-1,-1,-1):
+  #for i in range(Nqb):
+    if(i!=iqb):
+      res = np.kron(res,I)
+    if(i==iqb):
+      res = np.kron(res,Z)
+  return res
+
+#generate matrix of quantum circuit from list of turple U
+#convient for verify the result
+def cirqmat_from_U(U,Nqb):
+  nlen = len(U)
+
+  Umat = []
+
+  for i in range(nlen):
+    gate_str = U[i]
+    if(gate_str[0]=='C'):
+      Umat.append(ext_cx(gate_str[1],gate_str[2],Nqb))
+    elif(gate_str[0]=='R'):
+      Umat.append(ext_Rz(gate_str[2],gate_str[1],Nqb))
+    else:
+      print('err in reading circuit')
+
+  #connect all the gates
+  res = Umat[-1]
+  for i in range(nlen-2,-1,-1):
+    res = res@Umat[i]
+  return res
+
+#input an walsh coefficient (arra) of f_k array, output the circuit matrix for U=diag(e^(i f_k))
+def cirqmat_walsh(arra,Nqb,epsilon):
+  if(len(arra)!=2**Nqb): print('err')
+
+  U = []
+
+  for j in range(1,2**Nqb):
+    if(abs(arra[j])<epsilon): continue
+    arr_j = binary(j,Nqb)
+    max_index = max_bit(arr_j) #the R gate will located at the max index
+
+    for ibit in range(max_index):
+      if(arr_j[ibit]==1):
+        U.append(ext_cx(ibit,max_index,Nqb))
+
+    U.append(ext_Rz(-2*arra[j],max_index,Nqb))
+
+    for ibit in range(max_index-1,-1,-1):
+      if(arr_j[ibit]==1):
+        U.append(ext_cx(ibit,max_index,Nqb))
+
+  #connect all the gates
+  res = U[-1]
+  for i in range(len(U)-2,-1,-1):
+    res = res@U[i]
+  return res
+#============================

qflux/typing/examples.py

@@ -0,0 +1,24 @@
+from typing import Annotated
+
+import numpy as np
+from numpy.typing import NDArray
+
+# Basic numerical types
+type Real = float | np.float64
+type Complex = complex | np.complex128
+
+# General vector and matrix types
+type FloatVector = NDArray[np.float64]  # Shape: (n,)
+type ComplexVector = NDArray[np.complex128]  # Shape: (n,)
+type Float2D = NDArray[np.float64]  # Shape: (n, m)
+type Complex2D = NDArray[np.complex128]  # Shape: (n, m)
+
+type AtomicCoordinates = NDArray[np.float64]  # Shape: (n_atoms, 3)
+type AtomicNumbers = NDArray[np.int32]  # Shape: (n_atoms,)
+
+# Type for atomic symbols with validation
+type AtomicSymbol = Annotated[str, "Valid chemical element symbol"]
+
+# Energy types with units (keeping these as they're fundamental)
+type Energy = Annotated[float, "Energy in Hartree"]
+type EnergyEV = Annotated[float, "Energy in electron volts"]

qflux/utils/io.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+
+
+def load_dataset(ds_path: Path) -> None:
+    """Loads a dataset from the specified path.
+
+    This function is intended to load a dataset from the given file path.
+    Currently, it is not implemented and always raises a NotImplementedError.
+
+    Args:
+        ds_path: The path to the dataset file.
+
+    Raises:
+        NotImplementedError: Always raised as the function is not yet implemented.
+    """
+    raise NotImplementedError("Not implemented")

qflux/utils/logging_config.py

@@ -0,0 +1,61 @@
+import logging
+import logging.config
+import os
+from pathlib import Path
+
+import tomli
+
+
+def setup_logging() -> None:
+    """Configures logging for the application.
+
+    Reads the logging configuration from the 'pyproject.toml' file
+    and applies it using `logging.config.dictConfig`.
+
+    The log level can be overridden by setting the
+    'QFLUX_LOG_LEVEL' environment variable. If the environment
+    variable is not set or set to an invalid level, it defaults to 'INFO'.
+
+    Raises:
+        FileNotFoundError: If 'pyproject.toml' is not found.
+        tomli.TOMLDecodeError: If 'pyproject.toml' is not a valid TOML file.
+        KeyError: If the 'tool.logging' section is missing in 'pyproject.toml'.
+    """
+    # Construct the path to pyproject.toml, assuming it's 3 levels up from this file.
+    pyproject_path = Path(__file__).parents[3] / "pyproject.toml"
+
+    try:
+        with open(pyproject_path, "rb") as f:
+            config = tomli.load(f)
+    except FileNotFoundError as e:
+        raise FileNotFoundError(f"pyproject.toml not found at {pyproject_path}: {e}") from e
+    except tomli.TOMLDecodeError as e:
+        raise tomli.TOMLDecodeError(f"Failed to decode pyproject.toml: {e}") from e
+
+    # Determine the log level:
+    # 1. Check for QFLUX_LOG_LEVEL environment variable.
+    # 2. Default to 'INFO' if not set or invalid.
+    log_level_env = os.getenv("QFLUX_LOG_LEVEL", "INFO").upper()
+
+    valid_levels = {"DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"}
+    if log_level_env not in valid_levels:
+        print(f"Invalid log level '{log_level_env}' from environment, defaulting to INFO")
+        log_level = "INFO"
+    else:
+        log_level = log_level_env
+
+    try:
+        # Extract logging configuration from pyproject.toml
+        logging_config = config["tool"]["logging"]
+    except KeyError as e:
+        raise KeyError(f"'tool.logging' section not found in pyproject.toml: {e}") from e
+
+    # Override the log level specified in pyproject.toml with the determined log level.
+    logging_config["loggers"]["qflux"]["level"] = log_level
+
+    # Configure logging using the dictionary configuration.
+    logging.config.dictConfig(logging_config)
+
+
+# Get the logger for the 'qflux' application.
+logger = logging.getLogger("qflux")

qflux/variational_methods/__init__.py

@@ -0,0 +1 @@
+# initialization

qflux/variational_methods/qmad/ansatz.py

@@ -0,0 +1,64 @@
+import numpy as np
+from itertools import combinations, product
+from scipy.linalg import expm, kron
+
+# Ansatz Class and Operators
+
+class Ansatz_class:
+    def __init__(self, nqbit, u0, relrcut, pool, theta=[], ansatz=[]):
+        self.theta = np.array(theta)
+        self.A = ansatz
+        self.state = u0.copy()
+        self.ref = u0.copy()
+        self.relrcut = relrcut
+        self.nqbit = nqbit
+        self.pool = pool
+
+class AnsatzOperatorBase:
+    pass
+
+class PauliOperator_class(AnsatzOperatorBase):
+    def __init__(self, mat, tag, nqbit):
+        self.mat = mat
+        self.tag = tag
+        self.nqbit = nqbit
+
+def single_clause(ops, q_ind, weight, num_qubit):
+    si = np.eye(2)
+    res = weight * np.eye(1)
+    for i in range(1, num_qubit + 1):
+        if i in q_ind:
+            op2 = eval(f"{ops[q_ind.index(i)]}")
+            res = kron(res, op2)
+        else:
+            res = kron(res, si)
+    return res
+
+def PauliOperator(ops, idx, w, nqbit):
+    sortedRep = sorted(zip(ops, idx), key=lambda x: x[1])
+    tag = ''.join([f"{o}{i}" for o, i in sortedRep])
+    mat = single_clause(ops, idx, w, nqbit)
+    return PauliOperator_class(mat, tag, nqbit)
+
+# Defining pool of operators/gates
+sx = np.array([[0, 1], [1, 0]])
+sy = np.array([[0, -1j], [1j, 0]])
+sz = np.array([[1, 0], [0, -1]])
+# S = np.array([[1, 0], [0, 1j]])
+
+
+def build_pool(nqbit):
+    pauliStr = ["sx", "sz", "sy"]
+    res = []
+    for order in range(1, nqbit+1):
+        for idx in combinations(range(1, nqbit + 1), order):
+            for op in product(pauliStr, repeat=order):
+                res.append(PauliOperator(op, list(idx), 1, nqbit))
+    return res
+
+def Ansatz(u0, relrcut, theta=[], ansatz=[]):
+    nqbit = int(np.log2(len(u0)))
+    pool_qubit =  nqbit
+    # u0 = np.outer(u0, u0).flatten()
+    pool = build_pool(pool_qubit)
+    return Ansatz_class(nqbit, u0, relrcut, pool, theta, ansatz)

qflux/variational_methods/qmad/ansatzVect.py

@@ -0,0 +1,61 @@
+import numpy as np
+from itertools import combinations, product
+from scipy.linalg import expm, kron
+
+# Ansatz Class and Operators
+class Ansatz_class:
+    def __init__(self, nqbit, u0, relrcut, pool, theta=[], ansatz=[]):
+        self.theta = np.array(theta)
+        self.A = ansatz
+        self.state = u0.copy()
+        self.ref = u0.copy()
+        self.relrcut = relrcut
+        self.nqbit = nqbit
+        self.pool = pool
+
+class AnsatzOperatorBase:
+    pass
+
+class PauliOperator_class(AnsatzOperatorBase):
+    def __init__(self, mat, tag, nqbit):
+        self.mat = mat
+        self.tag = tag
+        self.nqbit = nqbit
+
+def single_clause(ops, q_ind, weight, num_qubit):
+    si = np.eye(2)
+    res = weight * np.eye(1)
+    for i in range(1, num_qubit + 1):
+        if i in q_ind:
+            op2 = eval(f"{ops[q_ind.index(i)]}")
+            res = kron(res, op2)
+        else:
+            res = kron(res, si)
+    return res
+
+def PauliOperator(ops, idx, w, nqbit):
+    sortedRep = sorted(zip(ops, idx), key=lambda x: x[1])
+    tag = ''.join([f"{o}{i}" for o, i in sortedRep])
+    mat = single_clause(ops, idx, w, nqbit)
+    return PauliOperator_class(mat, tag, nqbit)
+
+# Defining pool of operators/gates
+sx = np.array([[0, 1], [1, 0]])
+sy = np.array([[0, -1j], [1j, 0]])
+sz = np.array([[1, 0], [0, -1]])
+
+def build_pool(nqbit):
+    pauliStr = ["sx", "sz", "sy"]
+    res = []
+    for order in range(1, nqbit+1):
+        for idx in combinations(range(1, nqbit + 1), order):
+            for op in product(pauliStr, repeat=order):
+                res.append(PauliOperator(op, list(idx), 1, nqbit))
+    return res
+
+def Ansatz(u0, relrcut, theta=[], ansatz=[]):
+    nqbit = int(np.log2(len(u0)))
+    pool_qubit = 2 * nqbit
+    u0 = np.outer(u0, u0).flatten()
+    pool = build_pool(pool_qubit)
+    return Ansatz_class(nqbit, u0, relrcut, pool, theta, ansatz)