qsppack 0.1.0__py3-none-any.whl

optimization/QSP_solver.py

@@ -0,0 +1,121 @@
+"""Main solver interface for Quantum Signal Processing optimization.
+
+This module provides the main interface for solving QSP optimization problems,
+coordinating the various optimization methods and utility functions.
+"""
+
+import numpy as np
+from time import time
+from .utils import chebyshev_to_func
+from .objective import obj_sym, grad_sym, grad_sym_real
+from .optimizers import lbfgs, coordinate_minimization, newton
+from .core import reduced_to_full
+
+def solve(coef, parity, opts):
+    """Given coefficients of a polynomial P, yield corresponding phase factors.
+
+    The reference chose the first half of the phase factors as the 
+    optimization variables, while in the code we used the second half of the 
+    phase factors. These two formulations are equivalent.
+
+    To simplify the representation, a constant pi/4 is added to both sides of 
+    the phase factors when evaluating the objective and the gradient. In the
+    output, the FULL phase factors with pi/4 are given.
+
+    Parameters
+    ----------
+    coef : array_like
+        Coefficients of polynomial P under Chebyshev basis. P should be even/odd,
+        only provide non-zero coefficients. Coefficients should be ranked from
+        low order term to high order term.
+    parity : int
+        Parity of polynomial P (0 -- even, 1 -- odd)
+    opts : dict, optional
+        Options dictionary with fields:
+        
+        - criteria : float
+            Stop criteria
+        - useReal : bool
+            Use only real arithmetics if true
+        - targetPre : bool
+            Want Pre to be target function if true
+        - method : {'LBFGS', 'FPI', 'Newton'}
+            Optimization method to use
+        - typePhi : {'full', 'reduced'}
+            Type of phase factors to return
+
+    Returns
+    -------
+    phi_proc : ndarray
+        Solution of optimization problem, FULL phase factors
+    out : dict
+        Information of solving process containing:
+        
+        - iter : int
+            Number of iterations
+        - time : float
+            Runtime in seconds
+        - value : float
+            Final error value
+        - parity : int
+            Input parity value
+        - targetPre : bool
+            Whether Pre was target function
+        - typePhi : str
+            Type of phase factors returned
+    """
+    # Setup options for L-BFGS solver
+    opts.setdefault('maxiter', 5e4)
+    opts.setdefault('criteria', 1e-12)
+    opts.setdefault('useReal', True)
+    opts.setdefault('targetPre', True)
+    opts.setdefault('method', 'FPI')
+    opts.setdefault('typePhi', 'full')
+
+    if opts['method'] == 'LBFGS':
+        # Initial preparation
+        tot_len = len(coef)
+        delta = np.cos((np.arange(1, 2 * tot_len, 2) * (np.pi / (2 * tot_len))))
+        if not opts['targetPre']:
+            opts['target'] = lambda x: -chebyshev_to_func(x, coef, parity, True)
+        else:
+            opts['target'] = lambda x: chebyshev_to_func(x, coef, parity, True)
+        opts['parity'] = parity
+        obj = obj_sym
+        grad = grad_sym_real if opts['useReal'] else grad_sym
+
+        # Solve by L-BFGS with selected initial point
+        start_time = time()
+        phi, err, iter = lbfgs(obj, grad, delta, np.zeros(tot_len), opts)
+        # Convert phi to reduced phase factors
+        if parity == 0:
+            phi[0] = phi[0] / 2
+        runtime = time() - start_time
+
+    elif opts['method'] == 'FPI':
+        phi, err, iter, runtime = coordinate_minimization(coef, parity, opts)
+
+    elif opts['method'] == 'Newton':
+        phi, err, iter, runtime = newton(coef, parity, opts)
+
+    else:
+        print("Assigned method doesn't exist. Please choose method from 'LBFGS', 'FPI' or 'Newton'.")
+        return None, None
+
+    # Output information
+    out = {
+        'iter': iter,
+        'time': runtime,
+        'value': err,
+        'parity': parity,
+        'targetPre': opts['targetPre']
+    }
+
+    if opts['typePhi'] == 'full':
+        phi_proc = reduced_to_full(phi, parity, opts['targetPre'])
+        out['typePhi'] = 'full'
+    else:
+        phi_proc = phi
+        out['typePhi'] = 'reduced'
+
+    return phi_proc, out

optimization/__init__.py

@@ -0,0 +1,25 @@
+"""Quantum Signal Processing Optimization Package.
+
+This package provides tools for optimizing phase factors in Quantum Signal
+Processing problems.
+"""
+
+from .QSP_solver import *
+from .core import *
+from .utils import *
+from .objective import *
+from .optimizers import *
+
+__all__ = [
+    # QSP_solver
+    'solve',
+    # core
+    'get_unitary',
+    'get_unitary_sym',
+    'get_entry',
+    'reduced_to_full',
+    # utils
+    'chebyshev_to_func',
+    'cvx_poly_coef',
+    # Add all other public functions here
+]

optimization/core.py

@@ -0,0 +1,265 @@
+"""Core Quantum Signal Processing functionality.
+
+This module provides the fundamental operations needed for Quantum Signal Processing,
+including unitary matrix construction and manipulation of phase factors.
+"""
+
+import numpy as np
+from .utils import get_unitary_sym, get_pim_sym, get_pim_sym_real, get_pim_deri_sym, get_pim_deri_sym_real
+
+def get_unitary(phase, x):
+    """Compute QSP unitary matrix for given phase factors.
+
+    This function constructs the full QSP unitary matrix for a given set of phase
+    factors at a specific point. The unitary is built by alternating W(x) gates
+    and phase rotations.
+
+    Parameters
+    ----------
+    phase : array_like
+        Phase factors for the QSP circuit. These are used to construct the
+        phase rotation gates in the circuit.
+    x : float
+        Point at which to evaluate the unitary, must be in [-1, 1].
+
+    Returns
+    -------
+    float
+        Real part of the (1,1) element of the QSP unitary matrix, which
+        represents the QSP approximation of the target function.
+
+    Notes
+    -----
+    The unitary is constructed as:
+    U = R(phi_0) * W(x) * R(phi_1) * W(x) * ... * R(phi_n)
+    where R(phi) is a phase rotation gate and W(x) is the signal processing gate.
+    """
+    Wx = np.array([[x, 1j * np.sqrt(1 - x**2)], [1j * np.sqrt(1 - x**2), x]])
+    expphi = np.exp(1j * phase)
+
+    ret = np.array([[expphi[0], 0], [0, np.conj(expphi[0])]])
+
+    for k in range(1, len(expphi)):
+        temp = np.array([[expphi[k], 0], [0, np.conj(expphi[k])]])
+        ret = np.dot(np.dot(ret, Wx), temp)
+
+    targ = np.real(ret[0, 0])
+
+    return targ
+
+def get_entry(xlist, phase, opts):
+    """Compute QSP unitary matrix entries for multiple points.
+
+    This function evaluates the QSP unitary matrix at multiple points, handling
+    both full and reduced phase factors. It can compute either the real or
+    imaginary part of the (1,1) element based on the options.
+
+    Parameters
+    ----------
+    xlist : array_like
+        Points at which to evaluate the QSP unitary, must be in [-1, 1].
+    phase : array_like
+        Phase factors for the QSP circuit. Can be either full or reduced
+        phase factors depending on opts['typePhi'].
+    opts : dict
+        Options dictionary containing:
+        
+        - targetPre : bool
+            If True, compute real part (Pre), otherwise compute imaginary part (Pim)
+        - parity : int
+            Parity of the polynomial (0 for even, 1 for odd)
+        - typePhi : {'full', 'reduced'}
+            Type of phase factors provided:
+            
+            - 'full' : complete set of phase factors
+            - 'reduced' : reduced set of phase factors (will be expanded)
+
+    Returns
+    -------
+    ndarray
+        QSP approximation values at each point in xlist. For targetPre=True,
+        returns real part of (1,1) element; for targetPre=False, returns
+        imaginary part.
+
+    Notes
+    -----
+    When typePhi='reduced', the function expands the reduced phase factors to
+    full phase factors using symmetry. For targetPre=False, it also adjusts
+    the first and last phase factors by -π/4 to compute the imaginary part.
+    """
+    typePhi = opts['typePhi']
+    targetPre = opts['targetPre']
+    parity = opts['parity']
+
+    d = len(xlist)
+    ret = np.zeros(d)
+
+    if typePhi == 'reduced':
+        dd = 2 * len(phase) - 1 + parity
+        phi = np.zeros(dd)
+        phi[(dd - len(phase)):] = phase
+        phi[:len(phase)] += phase[::-1]
+    else:
+        phi = phase
+
+    if not targetPre:
+        phi[0] -= np.pi / 4
+        phi[-1] -= np.pi / 4
+
+    for i in range(d):
+        x = xlist[i]
+        ret[i] = get_unitary(phi, x)
+
+    return ret
+
+def reduced_to_full(phi_cm, parity, targetPre):
+    """Convert reduced phase factors to full phase factors for QSP.
+
+    This function constructs the full set of phase factors required for the
+    Quantum Signal Processing (QSP) unitary matrix from a reduced set. The
+    conversion uses symmetry properties of the phase factors and handles
+    both even and odd parity cases.
+
+    Parameters
+    ----------
+    phi_cm : array_like
+        Reduced phase factors. For even parity, these represent half the
+        total phase factors; for odd parity, they represent the unique
+        phase factors.
+    parity : int
+        Parity of the phase factors:
+        
+        - 0 : even parity (full length = 2*len(phi_cm) - 1)
+        - 1 : odd parity (full length = 2*len(phi_cm))
+    targetPre : bool
+        Whether to adjust for target preparation:
+        
+        - True : add π/4 to the last phase factor
+        - False : use phase factors as is
+
+    Returns
+    -------
+    ndarray
+        Full phase factors constructed by mirroring the reduced factors.
+        The length depends on parity:
+        
+        - For even parity: 2*len(phi_cm) - 1
+        - For odd parity: 2*len(phi_cm)
+
+    Notes
+    -----
+    The full phase factors are constructed by:
+    1. Copying the reduced factors to the right half
+    2. Mirroring them to the left half
+    3. Adjusting the last factor if targetPre is True
+    """
+    phi_right = phi_cm.copy()
+    if targetPre:
+        phi_right[-1] += np.pi / 4
+
+    dd = 2 * len(phi_right)
+    if parity == 0:
+        dd -= 1
+
+    phi_full = np.zeros(dd)
+    phi_full[(dd - len(phi_right)):] = phi_right
+    phi_full[:len(phi_right)] += phi_right[::-1]
+
+    return phi_full
+
+def F(phi, parity, opts):
+    """Compute the Chebyshev coefficients of P_im.
+    
+    P_im is the imaginary part of the (1,1) element of the QSP unitary matrix.
+
+    Parameters
+    ----------
+    phi : array_like
+        Reduced phase factors
+    parity : int
+        Parity of phi (0 for even, 1 for odd)
+    opts : dict
+        Options dictionary with fields:
+            - useReal : bool
+                Whether to use real matrix multiplication
+
+    Returns
+    -------
+    ndarray
+        Chebyshev coefficients of P_im w.r.t. 
+        T_(2k) for even parity or T_(2k-1) for odd parity
+    """
+    # Setup options for CM solver
+    opts.setdefault('useReal', True)
+
+    # Initial preparation
+    d = len(phi)
+    dd = 2 * d
+    theta = np.arange(d + 1) * np.pi / dd
+    M = np.zeros(2 * dd)
+
+    if opts['useReal']:
+        f = lambda x: [get_pim_sym_real(phi, xval, parity) for xval in x]
+    else:
+        f = lambda x: [get_pim_sym(phi, xval, parity) for xval in x]
+
+    # Start Chebyshev coefficients evaluation
+    M[:d+1] = f(np.cos(theta))
+    M[d+1:dd+1] = (-1)**parity * M[d-1::-1]
+    M[dd+1:] = M[dd-1:0:-1]
+    M = np.fft.fft(M)  # FFT w.r.t. columns.
+    M = np.real(M)
+    M /= (2 * dd)
+    M[1:-1] *= 2
+    coe = M[parity:2*d:2]
+
+    return coe
+
+def F_Jacobian(phi, parity, opts):
+    """Compute the Jacobian matrix of Chebyshev coefficients.
+
+    Parameters
+    ----------
+    phi : array_like
+        Reduced phase factors
+    parity : int
+        Parity of phi (0 for even, 1 for odd)
+    opts : dict
+        Options dictionary with fields:
+            - useReal : bool
+                Whether to use real matrix multiplication
+
+    Returns
+    -------
+    ndarray
+        Jacobian matrix of Chebyshev coefficients
+    """
+    # Setup options
+    opts.setdefault('useReal', True)
+
+    # Initial preparation
+    if opts['useReal']:
+        f = lambda x: get_pim_deri_sym_real(phi, x, parity)
+    else:
+        f = lambda x: get_pim_deri_sym(phi, x, parity)
+
+    d = len(phi)
+    dd = 2 * d
+    theta = np.arange(d + 1) * np.pi / dd
+    M = np.zeros((2 * dd, d + 1))
+
+    for n in range(d + 1):
+        M[n, :] = f(np.cos(theta[n]))
+
+    M[d + 1:dd + 1, :] = (-1) ** parity * M[d - 1::-1, :]
+    M[dd + 1:, :] = M[dd - 1:0:-1, :]
+
+    M = np.fft.fft(M, axis=0)  # FFT w.r.t. columns.
+    M = np.real(M[:dd + 1, :])
+    M[1:-1, :] *= 2
+    M /= (2 * dd)
+
+    f = M[parity::2, -1][:d]
+    df = M[parity::2, :-1][:d]
+
+    return f, df

optimization/objective.py

@@ -0,0 +1,140 @@
+"""Objective and gradient functions for QSP optimization.
+
+This module provides functions for computing objective values and gradients
+needed in QSP optimization problems.
+"""
+
+import numpy as np
+from .utils import get_unitary_sym, get_pim_sym, get_pim_sym_real, get_pim_deri_sym, get_pim_deri_sym_real
+from .core import get_entry
+
+def obj_sym(phi, delta, opts):
+    """Compute objective function value for QSP optimization.
+
+    Parameters
+    ----------
+    phi : array_like
+        Phase factors for QSP circuit
+    delta : array_like
+        Samples
+    opts : dict
+        Options dictionary containing target function and parameters
+
+    Returns
+    -------
+    float
+        Objective function value
+    """
+    m = len(delta)
+    obj = np.zeros(m)
+    for i in range(m):
+        qspmat = get_unitary_sym(phi, delta[i], opts['parity'])
+        obj[i] = 0.5 * (np.real(qspmat[0, 0]) - opts['target']([delta[i]]))**2
+
+    return obj
+
+def grad_sym(phi, delta, opts):
+    """Compute gradient of objective function.
+
+    Parameters
+    ----------
+    phi : array_like
+        Phase factors for QSP circuit
+    delta : array_like
+        Samples
+    opts : dict
+        Options dictionary containing target function and parameters
+
+    Returns
+    -------
+    grad : ndarray
+        Gradient of objective function
+    obj : ndarray
+        Objective function value
+    """
+    # Initial computation
+    m = len(delta)
+    d = len(phi)
+    obj = np.zeros(m)
+    grad = np.zeros((m, d))
+    gate = np.array([[np.exp(1j * np.pi / 4), 0], [0, np.conj(np.exp(1j * np.pi / 4))]])
+    exptheta = np.exp(1j * phi)
+    targetx = opts['target']
+    parity = opts['parity']
+
+    # Start gradient evaluation
+    for i in range(m):
+        x = delta[i]
+        Wx = np.array([[x, 1j * np.sqrt(1 - x**2)], [1j * np.sqrt(1 - x**2), x]])
+        tmp_save1 = np.zeros((2, 2, d), dtype=complex)
+        tmp_save2 = np.zeros((2, 2, d), dtype=complex)
+        tmp_save1[:, :, 0] = np.eye(2)
+        tmp_save2[:, :, 0] = np.dot(np.array([[exptheta[d-1], 0], [0, np.conj(exptheta[d-1])]]), gate)
+        for j in range(1, d):
+            tmp_save1[:, :, j] = np.dot(tmp_save1[:, :, j-1], np.dot(np.diag([exptheta[j-1], np.conj(exptheta[j-1])]), Wx))
+            tmp_save2[:, :, j] = np.dot(np.dot(np.array([[exptheta[d-j-1], 0], [0, np.conj(exptheta[d-j-1])]]), Wx), tmp_save2[:, :, j-1])
+        if parity == 1:
+            qspmat = np.dot(np.dot(tmp_save2[:, :, d-1].T, Wx), tmp_save2[:, :, d-1])
+            gap = np.real(qspmat[0, 0]) - targetx(x)
+            leftmat = np.dot(tmp_save2[:, :, d-1].T, Wx)
+            for j in range(d):
+                grad_tmp = np.dot(np.dot(leftmat, tmp_save1[:, :, j]), np.array([[1j, -1j]]).T) * tmp_save2[:, :, d-j-1]
+                grad[i, j] = 2 * np.real(grad_tmp[0, 0]) * gap
+            obj[i] = 0.5 * (np.real(qspmat[0, 0]) - targetx(x))**2
+        else:
+            qspmat = np.dot(np.dot(tmp_save2[:, :, d-2].T, Wx), tmp_save2[:, :, d-1])
+            gap = np.real(qspmat[0, 0]) - targetx(x)
+            leftmat = np.dot(tmp_save2[:, :, d-2].T, Wx)
+            for j in range(d):
+                grad_tmp = np.dot(np.dot(leftmat, tmp_save1[:, :, j]), np.array([[1j, -1j]]).T) * tmp_save2[:, :, d-j-1]
+                grad[i, j] = 2 * np.real(grad_tmp[0, 0]) * gap
+            grad[i, 0] /= 2
+            obj[i] = 0.5 * (np.real(qspmat[0, 0]) - targetx(x))**2
+
+    return grad, obj
+
+def grad_sym_real(phi, delta, opts):
+    """Compute gradient using real arithmetic.
+
+    Similar to grad_sym but uses only real arithmetic for efficiency.
+
+    Parameters
+    ----------
+    phi : array_like
+        Phase factors for QSP circuit
+    delta : array_like
+        Samples
+    opts : dict
+        Options dictionary containing target function and parameters
+
+    Returns
+    -------
+    grad : ndarray
+        Gradient of objective function
+    obj : ndarray
+        Objective function value
+    """
+    # Initial computation
+    m = len(delta)
+    d = len(phi)
+    obj = np.zeros(m)
+    grad = np.zeros((m, d))
+    targetx = opts['target']
+    parity = opts['parity']
+
+    # Convert the phase factor used in LBFGS solver to reduced phase factors
+    if parity == 0:
+        phi[0] = phi[0] / 2
+
+    # Start gradient evaluation
+    for i in range(m):
+        x = delta[i]
+        y = get_pim_deri_sym_real(phi, x, parity)
+        if parity == 0:
+            y[0] = y[0] / 2
+        y = -y  # Flip the sign
+        gap = y[-1] - targetx([x])
+        obj[i] = 0.5 * gap**2
+        grad[i, :] = y[:-1] * gap
+
+    return grad, obj

optimization/optimizers.py

@@ -0,0 +1,308 @@
+"""Optimization methods for Quantum Signal Processing.
+
+This module provides various optimization algorithms for finding phase factors
+in Quantum Signal Processing problems.
+"""
+
+import numpy as np
+import time
+from .objective import (
+    obj_sym, grad_sym, grad_sym_real,
+    get_pim_sym, get_pim_sym_real,
+    get_pim_deri_sym, get_pim_deri_sym_real
+)
+from .core import F, F_Jacobian
+
+def lbfgs(obj, grad, delta, phi, opts):
+    """L-BFGS optimization for QSP phase factors.
+
+    This function implements the Limited-memory BFGS optimization algorithm
+    for finding optimal phase factors in QSP problems.
+
+    Parameters
+    ----------
+    obj : callable
+        Objective function to minimize
+    grad : callable
+        Gradient function of the objective
+    x0 : array_like
+        Initial points for evaluation
+    phi0 : array_like
+        Initial phase factors
+    opts : dict
+        Options dictionary containing:
+        
+        - maxiter : int
+            Maximum number of iterations
+        - criteria : float
+            Convergence criteria
+        - gamma : float
+            Line search retraction rate (default 0.5)
+        - accrate : float
+            Line search accept ratio (default 1e-3)
+        - minstep : float
+            Minimal step size (default 1e-5)
+        - lmem : int
+            L-BFGS memory size (default 200)
+        - print : bool
+            Whether to print progress (default True)
+        - itprint : int
+            Print frequency (default 1)
+        - parity : int
+            Parity of polynomial (0 for even, 1 for odd)
+
+    Returns
+    -------
+    phi : ndarray
+        Optimized phase factors
+    obj_value : float
+        Objective value at optimal point
+    iter : int
+        Number of iterations performed
+    """
+    # Options for L-BFGS solver
+    opts.setdefault('maxiter', 50000)
+    opts.setdefault('gamma', 0.5)
+    opts.setdefault('accrate', 1e-3)
+    opts.setdefault('minstep', 1e-5)
+    opts.setdefault('criteria', 1e-12)
+    opts.setdefault('lmem', 200)
+    opts.setdefault('print', 1)
+    opts.setdefault('itprint', 1)
+
+    # Copy value to parameters
+    maxiter = opts['maxiter']
+    gamma = opts['gamma']
+    accrate = opts['accrate']
+    lmem = opts['lmem']
+    minstep = opts['minstep']
+    pri = opts['print']
+    itprint = opts['itprint']
+    crit = opts['criteria']
+
+    # Setup print format
+    str_head = "{:4s} {:13s} {:10s} {:10s}\n".format('iter', 'obj', 'stepsize', 'des_ratio')
+    str_num = "{:4d}  {:+5.4e} {:+3.2e} {:+3.2e}\n"
+
+    # Initial computation
+    iter = 0
+    d = len(phi)
+    mem_size = 0
+    mem_now = 0
+    mem_grad = np.zeros((lmem, d))
+    mem_obj = np.zeros((lmem, d))
+    mem_dot = np.zeros(lmem)
+    grad_s, obj_s = grad(phi, delta, opts)
+    obj_value = np.mean(obj_s)
+    GRAD = np.mean(grad_s, axis=0)
+
+    # Start L-BFGS algorithm
+    if pri:
+        print('L-BFGS solver started')
+
+    while True:
+        iter += 1
+        theta_d = GRAD.copy()
+        alpha = np.zeros(mem_size)
+        for i in range(mem_size):
+            subsc = (mem_now - i - 1) % lmem
+            alpha[i] = mem_dot[subsc] * np.dot(mem_obj[subsc, :], theta_d)
+            theta_d -= alpha[i] * mem_grad[subsc, :]
+
+        theta_d *= 0.5
+        if opts['parity'] == 0:
+            theta_d[0] *= 2
+
+        for i in range(mem_size):
+            subsc = (mem_now - (mem_size - i) - 1) % lmem
+            beta = mem_dot[subsc] * np.dot(mem_grad[subsc, :], theta_d)
+            theta_d += (alpha[mem_size - i - 1] - beta) * mem_obj[subsc, :]
+
+        step = 1
+        exp_des = np.dot(GRAD, theta_d)
+        while True:
+            theta_new = phi - step * theta_d
+            obj_snew = obj(theta_new, delta, opts)
+            obj_valuenew = np.mean(obj_snew)
+            ad = obj_value - obj_valuenew
+            if ad > exp_des * accrate * step or step < minstep:
+                break
+            step *= gamma
+
+        phi = theta_new
+        obj_value = obj_valuenew
+        obj_max = np.max(obj_snew)
+        grad_s, _ = grad(phi, delta, opts)
+        GRAD_new = np.mean(grad_s, axis=0)
+        mem_size = min(lmem, mem_size + 1)
+        mem_now = (mem_now + 1) % lmem
+        mem_grad[mem_now, :] = GRAD_new - GRAD
+        mem_obj[mem_now, :] = -step * theta_d
+        mem_dot[mem_now] = 1 / np.dot(mem_grad[mem_now, :], mem_obj[mem_now, :])
+        GRAD = GRAD_new
+
+        if pri and iter % itprint == 0:
+            if iter == 1 or (iter - itprint) % (itprint * 10) == 0:
+                print(str_head, end='')
+            print(str_num.format(iter, obj_max, step, ad / (exp_des * step)), end='')
+
+        if iter >= maxiter:
+            print("Max iteration reached.")
+            break
+        if obj_max < crit**2:
+            print("Stop criteria satisfied.")
+            break
+
+    return phi, obj_value, iter
+
+def coordinate_minimization(coef, parity, opts):
+    """Coordinate minimization optimization for QSP phase factors.
+
+    This function implements the coordinate minimization algorithm for
+    finding optimal phase factors in QSP problems.
+
+    Parameters
+    ----------
+    coef : array_like
+        Coefficients of polynomial P under Chebyshev basis
+    parity : int
+        Parity of polynomial P (0 for even, 1 for odd)
+    opts : dict
+        Options dictionary containing optimization parameters
+
+    Returns
+    -------
+    phi : ndarray
+        Optimized phase factors
+    err : float
+        Final error value
+    iter : int
+        Number of iterations performed
+    runtime : float
+        Total runtime in seconds
+    """
+    # Setup options for CM solver
+    opts.setdefault('maxiter', int(1e5))
+    opts.setdefault('criteria', 1e-12)
+    opts.setdefault('targetPre', True)
+    opts.setdefault('useReal', True)
+    opts.setdefault('print', 1)
+    opts.setdefault('itprint', 1)
+
+    start_time = time.time()
+
+    # Copy value to parameters
+    maxiter = opts['maxiter']
+    crit = opts['criteria']
+    pri = opts['print']
+    itprint = opts['itprint']
+
+    # Setup print format
+    str_head = "{:4s} {:13s}\n".format('iter', 'err')
+    str_num = "{:4d}  {:+5.4e}\n"
+
+    # Initial preparation
+    if opts['targetPre']:
+        coef = -coef  # inverse is necessary
+    phi = coef / 2
+    iter = 0
+
+    # Solve by contraction mapping algorithm
+    while True:
+        Fval = F(phi, parity, opts)
+        res = Fval - coef
+
+        # debugging
+        # Fval_j, DFval = F_Jacobian(phi, parity, opts)
+        # print("Fval from F:", Fval)
+        # print("Fval from F_Jacobian:", Fval_j)
+
+        err = np.linalg.norm(res, 1)
+        iter += 1
+        if iter >= maxiter:
+            print("Max iteration reached.")
+            break
+        if err < crit:
+            print("Stop criteria satisfied.")
+            break
+        phi = phi - res / 2
+        if pri and iter % itprint == 0:
+            if iter == 1 or (iter - itprint) % (itprint * 10) == 0:
+                print(str_head, end='')
+            print(str_num.format(iter, err), end='')
+
+    runtime = time.time() - start_time
+    return phi, err, iter, runtime
+
+def newton(coef, parity, opts):
+    """Newton's method optimization for QSP phase factors.
+
+    This function implements Newton's method for finding optimal phase
+    factors in QSP problems.
+
+    Parameters
+    ----------
+    coef : array_like
+        Coefficients of polynomial P under Chebyshev basis
+    parity : int
+        Parity of polynomial P (0 for even, 1 for odd)
+    opts : dict
+        Options dictionary containing optimization parameters
+
+    Returns
+    -------
+    phi : ndarray
+        Optimized phase factors
+    err : float
+        Final error value
+    iter : int
+        Number of iterations performed
+    runtime : float
+        Total runtime in seconds
+    """
+    # Setup options for Newton solver
+    opts.setdefault('maxiter', int(1e5))
+    opts.setdefault('criteria', 1e-12)
+    opts.setdefault('targetPre', True)
+    opts.setdefault('useReal', True)
+    opts.setdefault('print', 1)
+    opts.setdefault('itprint', 1)
+
+    start_time = time.time()
+
+    # Copy value to parameters
+    maxiter = opts['maxiter']
+    crit = opts['criteria']
+    pri = opts['print']
+    itprint = opts['itprint']
+
+    # Setup print format
+    str_head = "{:4s} {:13s}\n".format('iter', 'err')
+    str_num = "{:4d}  {:+5.4e}\n"
+
+    # Initial preparation
+    if opts['targetPre']:
+        coef = -coef  # inverse is necessary
+    phi = coef / 2
+    iter = 0
+
+    # Solve by Newton method
+    while True:
+        Fval, DFval = F_Jacobian(phi, parity, opts)
+        res = Fval - coef
+        err = np.linalg.norm(res, 1)
+        iter += 1
+        if iter >= maxiter:
+            print("Max iteration reached.")
+            break
+        if err < crit:
+            print("Stop criteria satisfied.")
+            break
+        phi = phi - np.linalg.solve(DFval, res)
+        if pri and iter % itprint == 0:
+            if iter == 1 or (iter - itprint) % (itprint * 10) == 0:
+                print(str_head, end='')
+            print(str_num.format(iter, err), end='')
+
+    runtime = time.time() - start_time
+    return phi, err, iter, runtime

optimization/utils.py

@@ -0,0 +1,449 @@
+"""Utility functions for QSP optimization.
+
+This module provides utility functions for working with Chebyshev polynomials
+and other mathematical operations needed in QSP optimization.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.optimize import minimize, linprog
+from scipy.special import chebyt
+import cvxpy as cp
+
+def chebyshev_to_func(x, coef, parity, partialcoef):
+    """Convert Chebyshev coefficients to function values.
+
+    This function evaluates a polynomial represented in the Chebyshev basis
+    at given points.
+
+    Parameters
+    ----------
+    x : array_like or float
+        Points at which to evaluate the polynomial. Can be a single point
+        or an array of points.
+    coef : array_like
+        Coefficients in Chebyshev basis, ordered from lowest to highest degree
+    parity : int
+        Parity of the polynomial (0 for even, 1 for odd)
+    partialcoef : bool, optional
+        Whether to return only coefficients of odd/even order
+
+    Returns
+    -------
+    ndarray or float
+        Function values at the given points. Returns a scalar if input is
+        scalar, array otherwise.
+    """
+    ret = np.zeros(len(x))
+    y = np.arccos(x)
+    if partialcoef:
+        if parity == 0:
+            for k in range(len(coef)):
+                ret += coef[k] * np.cos(2 * k * y)
+        else:
+            for k in range(len(coef)):
+                ret += coef[k] * np.cos((2 * k + 1) * y)
+    else:
+        if parity == 0:
+            for k in range(0, len(coef), 2):
+                ret += coef[k] * np.cos(k * y)
+        else:
+            for k in range(1, len(coef), 2):
+                ret += coef[k] * np.cos(k * y)
+    return ret
+
+def cvx_poly_coef(func, deg, opts):
+    """Compute coefficients for a polynomial approximation using convex optimization.
+
+    This function computes the coefficients of a polynomial that best approximates
+    a target function over specified intervals in a least-squares sense. The function
+    is called with a target function, the degree of the polynomial, and an options
+    dictionary.
+
+    Parameters
+    ----------
+    func : callable
+        The target function to approximate.
+    deg : int
+        The degree of the polynomial.
+    opts : dict
+        Options dictionary with the following fields:
+        
+        - intervals : list
+            [min, max] interval for x values.
+        - npts : int
+            Number of points to evaluate the function at.
+        - objnorm : float
+            Norm to use for optimization.
+        - epsil : float
+            Epsilon for numerical stability.
+        - fscale : float
+            Scale factor for function values.
+        - isplot : bool
+            Whether to plot results.
+
+    Returns
+    -------
+    ndarray
+        Coefficients of the best-fit polynomial in the Chebyshev basis.
+    """
+    # Set default options if not provided
+    opts.setdefault('npts', 200)
+    opts.setdefault('epsil', 0.01)
+    opts.setdefault('fscale', 1 - opts['epsil'])
+    opts.setdefault('intervals', [0, 1])
+    opts.setdefault('isplot', False)
+    opts.setdefault('objnorm', np.inf)
+    opts.setdefault('method', 'SLSQP')
+
+    # Check variables and assign local variables
+    assert len(opts['intervals']) % 2 == 0
+    parity = deg % 2
+    epsil = opts['epsil']
+    npts = opts['npts']
+
+    # Generate Chebyshev points
+    xpts = np.cos(np.pi * np.arange(2 * npts) / (2 * npts - 1))
+    xpts = np.union1d(xpts, opts['intervals'])
+    xpts = xpts[xpts >= 0]
+    npts = len(xpts)
+
+    n_interval = len(opts['intervals']) // 2
+    ind_union = np.array([], dtype=int)
+    ind_set = []
+
+    for i in range(n_interval):
+        ind = np.where((xpts >= opts['intervals'][2 * i]) & (xpts <= opts['intervals'][2 * i + 1]))[0]
+        ind_set.append(ind)
+        ind_union = np.union1d(ind_union, ind)
+
+    # Evaluate the target function
+    fx = np.zeros(npts)
+    fx[ind_union] = opts['fscale'] * func(xpts[ind_union])
+
+    # Prepare the Chebyshev polynomials
+    n_coef = deg // 2 + 1 if parity == 0 else (deg + 1) // 2
+    Ax = np.zeros((npts, n_coef))
+
+    for k in range(1, n_coef + 1):
+        Tcheb = chebyt(2 * (k - 1)) if parity == 0 else chebyt(2 * k - 1)
+        Ax[:, k-1] = Tcheb(xpts)
+
+    # Use optimization to find the Chebyshev coefficients
+    coef = np.zeros(n_coef)
+    if opts['method'] == 'SLSQP':
+        def objective(coef):
+            y = Ax @ coef
+            return np.linalg.norm(y[ind_union] - fx[ind_union], opts['objnorm'])
+
+        constraints = [{'type': 'ineq', 'fun': lambda coef: 1 - epsil - Ax @ coef},
+                    {'type': 'ineq', 'fun': lambda coef: Ax @ coef + (1 - epsil)}]
+
+        result = minimize(objective, np.zeros(n_coef), constraints=constraints)
+        coef = result.x
+    
+    elif opts['method'] == 'cvxpy':
+        c = cp.Variable(n_coef)
+        y = Ax @ c
+        residual = y[ind_union] - fx[ind_union]
+        objective = cp.Minimize(cp.norm_inf(residual))
+        constraints = [
+            y <= 1 - epsil,
+            y >= -(1-epsil)
+        ]
+        problem = cp.Problem(objective, constraints)
+        problem.solve()
+        coef = c.value
+
+    elif opts['method'] == 'linprog':
+        e0 = np.zeros(n_coef+1)
+        e0[0] = 1
+        A_prime = Ax[ind_union, :]
+
+        # Build A_ub and b_ub
+        neg_one = -np.ones((A_prime.shape[0], 1))
+        zero_one = np.zeros((Ax.shape[0], 1))
+
+        A_ub = np.vstack([
+            np.hstack([neg_one, A_prime]),       # A'c - t <= f
+            np.hstack([neg_one, -A_prime]),      # -A'c - t <= -f
+            np.hstack([zero_one, Ax]),            # A c <= 1 - epsil
+            np.hstack([zero_one, -Ax])            # -A c <= 1 - epsil
+        ])
+
+        b_ub = np.concatenate([
+            fx[ind_union],
+            -fx[ind_union],
+            (1 - epsil) * np.ones(Ax.shape[0]),
+            (1 - epsil) * np.ones(Ax.shape[0])
+        ])
+
+        # Solve
+        result = linprog(c=e0, A_ub=A_ub, b_ub=b_ub, method='highs')
+
+        if result.success:
+            coef = result.x[1:n_coef+1]
+        else:
+            raise ValueError(f'Linear programming failed to find an optimal solution, status: {result.status}')
+
+    else:
+        raise ValueError(f'Method {opts["method"]} not supported')
+
+    err_inf = np.linalg.norm((Ax @ coef)[ind_union] - fx[ind_union], opts['objnorm'])
+    print(f'norm error = {err_inf}')
+
+    # Make sure the maximum is less than 1
+    coef_full = np.zeros(deg + 1)
+    if parity == 0:
+        coef_full[::2] = coef
+    else:
+        coef_full[1::2] = coef
+
+    max_sol = np.max(np.abs(np.polynomial.chebyshev.chebval(xpts, coef_full)))
+    print(f'max of solution = {max_sol}')
+    if max_sol > 1.0 - 1e-10:
+        raise ValueError('Solution is not bounded by 1. Increase npts')
+
+    if opts['isplot']:
+        plt.figure(1)
+        plt.clf()
+        plt.plot(xpts, Ax @ coef, 'ro', linewidth=1.5)
+        for ind in ind_set:
+            plt.plot(xpts[ind], fx[ind], 'b-', linewidth=2)
+        plt.xlabel('$x$', fontsize=15)
+        plt.ylabel('$f(x)$', fontsize=15)
+        plt.legend(['polynomial', 'target'], fontsize=15)
+
+        plt.figure(2)
+        plt.clf()
+        for ind in ind_set:
+            plt.plot(xpts[ind], np.abs(Ax[ind] @ coef - fx[ind]), 'k-', linewidth=1.5)
+        plt.xlabel('$x$', fontsize=15)
+        plt.ylabel('$|f_\\mathrm{poly}(x)-f(x)|$', fontsize=15)
+        plt.show()
+
+    return coef_full
+
+def get_unitary_sym(phi, x, parity):
+    """Get the QSP unitary matrix based on given phase vector and point x.
+
+    This function constructs the full QSP unitary matrix for a given set of
+    phase factors at a specific point, handling both even and odd parity cases.
+
+    Parameters
+    ----------
+    phi : array_like
+        Phase factors for the QSP circuit:
+        
+        - For parity=1: reduced phase factors
+        - For parity=0: phi[0] differs from reduced phase factors by factor of 2
+    x : float
+        Point at which to evaluate the unitary, must be in [-1, 1].
+    parity : int
+        Parity of the phase factors:
+        
+        - 0 : even parity
+        - 1 : odd parity
+
+    Returns
+    -------
+    ndarray
+        The QSP unitary matrix constructed from the phase factors and point x.
+
+    Notes
+    -----
+    The construction of the unitary matrix differs based on parity:
+    
+    - For odd parity: Uses full phase factors with a final gate transformation
+    - For even parity: Uses a different construction with modified first phase
+    """
+    Wx = np.array([[x, 1j * np.sqrt(1 - x**2)], [1j * np.sqrt(1 - x**2), x]])
+    gate = np.array([[np.exp(1j * np.pi / 4), 0], [0, np.conj(np.exp(1j * np.pi / 4))]])
+    expphi = np.exp(1j * phi)
+
+    if parity == 1:
+        ret = np.array([[expphi[0], 0], [0, np.conj(expphi[0])]])
+        for k in range(1, len(expphi)):
+            ret = np.dot(np.dot(ret, Wx), np.array([[expphi[k], 0], [0, np.conj(expphi[k])]]))
+        ret = np.dot(ret, gate)
+        qspmat = np.dot(np.dot(ret.T, Wx), ret)
+    else:
+        ret = np.eye(2)
+        for k in range(1, len(expphi)):
+            ret = np.dot(ret, Wx * np.array([[expphi[k], np.conj(expphi[k])]]))
+        ret = np.dot(ret, gate)
+        qspmat = np.dot(np.dot(ret.T, np.array([[expphi[0], 0], [0, np.conj(expphi[0])]])), ret)
+
+    return qspmat
+
+def get_pim_sym(phi, x, parity):
+    """Compute imaginary part of QSP unitary matrix element.
+
+    Parameters
+    ----------
+    phi : array_like
+        Phase factors for QSP circuit
+    x : float
+        Point at which to evaluate
+    parity : int
+        Parity of phase factors (0 for even, 1 for odd)
+
+    Returns
+    -------
+    float
+        Imaginary part of (1,1) element of QSP unitary
+    """
+    qspmat = get_unitary_sym(phi, x, parity)
+    return np.imag(qspmat[0, 0])
+
+def get_pim_sym_real(phi, x, parity):
+    """Compute imaginary part using real arithmetic.
+
+    Similar to get_pim_sym but uses only real arithmetic for efficiency.
+
+    Parameters
+    ----------
+    phi : array_like
+        Phase factors for QSP circuit
+    x : float
+        Point at which to evaluate
+    parity : int
+        Parity of phase factors (0 for even, 1 for odd)
+
+    Returns
+    -------
+    float
+        Imaginary part of (1,1) element of QSP unitary
+    """
+    n = len(phi)
+    theta = np.arccos(x)
+    B = np.array([[np.cos(2 * theta), 0, -np.sin(2 * theta)],
+                  [0, 1, 0],
+                  [np.sin(2 * theta), 0, np.cos(2 * theta)]])
+    
+    L = np.zeros((n, 3))
+    L[n-1, :] = [0, 1, 0]
+    
+    for k in range(n-2, -1, -1):
+        L[k, :] = np.dot(L[k+1, :], np.dot(np.array([[np.cos(2 * phi[k+1]), -np.sin(2 * phi[k+1]), 0],
+                                                     [np.sin(2 * phi[k+1]), np.cos(2 * phi[k+1]), 0],
+                                                     [0, 0, 1]]), B))
+    
+    R = np.zeros((3, n))
+    if parity == 0:
+        R[:, 0] = [1, 0, 0]
+    else:
+        R[:, 0] = [np.cos(theta), 0, np.sin(theta)]
+    
+    for k in range(1, n):
+        R[:, k] = np.dot(B, np.dot(np.array([[np.cos(2 * phi[k-1]), -np.sin(2 * phi[k-1]), 0],
+                                             [np.sin(2 * phi[k-1]), np.cos(2 * phi[k-1]), 0],
+                                             [0, 0, 1]]), R[:, k-1]))
+    
+    return np.dot(L[n-1, :], np.dot(np.array([[np.cos(2 * phi[n-1]), -np.sin(2 * phi[n-1]), 0],
+                                              [np.sin(2 * phi[n-1]), np.cos(2 * phi[n-1]), 0],
+                                              [0, 0, 1]]), R[:, n-1]))
+
+def get_pim_deri_sym(phi, x, parity):
+    """Compute Pim and its derivatives.
+
+    Parameters
+    ----------
+    phi : array_like
+        Phase factors for QSP circuit
+    x : float
+        Point at which to evaluate
+    parity : int
+        Parity of phase factors (0 for even, 1 for odd)
+
+    Returns
+    -------
+    ndarray
+        Array containing Pim and its derivatives
+    """
+    n = len(phi)
+    theta = np.arccos(x)
+    B = np.array([[np.cos(2 * theta), 0, -np.sin(2 * theta)],
+                  [0, 1, 0],
+                  [np.sin(2 * theta), 0, np.cos(2 * theta)]])
+    
+    L = np.zeros((n, 3))
+    L[n-1, :] = [0, 1, 0]
+    
+    for k in range(n-2, -1, -1):
+        L[k, :] = np.dot(L[k+1, :], np.dot(np.array([[np.cos(2 * phi[k+1]), -np.sin(2 * phi[k+1]), 0],
+                                                     [np.sin(2 * phi[k+1]), np.cos(2 * phi[k+1]), 0],
+                                                     [0, 0, 1]]), B))
+    
+    R = np.zeros((3, n))
+    if parity == 0:
+        R[:, 0] = [1, 0, 0]
+    else:
+        R[:, 0] = [np.cos(theta), 0, np.sin(theta)]
+    
+    for k in range(1, n):
+        R[:, k] = np.dot(B, np.dot(np.array([[np.cos(2 * phi[k-1]), -np.sin(2 * phi[k-1]), 0],
+                                             [np.sin(2 * phi[k-1]), np.cos(2 * phi[k-1]), 0],
+                                             [0, 0, 1]]), R[:, k-1]))
+    
+    y = np.zeros(n+1)
+    for k in range(n):
+        y[k] = 2 * np.dot(L[k, :], np.dot(np.array([[-np.sin(2 * phi[k]), -np.cos(2 * phi[k]), 0],
+                                                    [np.cos(2 * phi[k]), -np.sin(2 * phi[k]), 0],
+                                                    [0, 0, 0]]), R[:, k]))
+    y[n] = np.dot(L[n-1, :], np.dot(np.array([[np.cos(2 * phi[n-1]), -np.sin(2 * phi[n-1]), 0],
+                                              [np.sin(2 * phi[n-1]), np.cos(2 * phi[n-1]), 0],
+                                              [0, 0, 1]]), R[:, n-1]))
+    
+    return y
+
+def get_pim_deri_sym_real(phi, x, parity):
+    """
+    Compute Pim and its Jacobian matrix values at a single point x using the real matrix representation of Pim.
+
+    P_im: the imaginary part of the (1,1) element of the QSP unitary matrix.
+    
+    .. note::
+        Theta MUST be a number.
+
+    :param phi: Phase factors for QSP circuit
+    :type phi: array_like
+    :param x: Point at which to evaluate
+    :type x: float
+    :param parity: Parity of phase factors (0 for even, 1 for odd)
+    :type parity: int
+
+    :returns: Array containing Pim and its derivatives
+    :rtype: ndarray
+    """
+    n = len(phi)
+    theta = np.arccos(x)
+    B = np.array([[np.cos(2 * theta), 0, -np.sin(2 * theta)],
+                  [0, 1, 0],
+                  [np.sin(2 * theta), 0, np.cos(2 * theta)]])
+    L = np.zeros((n, 3))
+    L[n-1, :] = [0, 1, 0]
+    for k in range(n-2, -1, -1):
+        L[k, :] = np.dot(L[k+1, :], np.dot(np.array([[np.cos(2 * phi[k+1]), -np.sin(2 * phi[k+1]), 0],
+                                                     [np.sin(2 * phi[k+1]), np.cos(2 * phi[k+1]), 0],
+                                                     [0, 0, 1]]), B))
+    R = np.zeros((3, n))
+    if parity == 0:
+        R[:, 0] = [1, 0, 0]
+    else:
+        R[:, 0] = [np.cos(theta), 0, np.sin(theta)]
+    for k in range(1, n):
+        R[:, k] = np.dot(B, np.dot(np.array([[np.cos(2 * phi[k-1]), -np.sin(2 * phi[k-1]), 0],
+                                             [np.sin(2 * phi[k-1]), np.cos(2 * phi[k-1]), 0],
+                                             [0, 0, 1]]), R[:, k-1]))
+
+    y = np.zeros(n+1)
+    for k in range(n):
+        y[k] = 2 * np.dot(L[k, :], np.dot(np.array([[-np.sin(2 * phi[k]), -np.cos(2 * phi[k]), 0],
+                                                    [np.cos(2 * phi[k]), -np.sin(2 * phi[k]), 0],
+                                                    [0, 0, 0]]), R[:, k]))
+    y[n] = np.dot(L[n-1, :], np.dot(np.array([[np.cos(2 * phi[n-1]), -np.sin(2 * phi[n-1]), 0],
+                                              [np.sin(2 * phi[n-1]), np.cos(2 * phi[n-1]), 0],
+                                              [0, 0, 1]]), R[:, n-1]))
+
+    return y

qsppack-0.1.0.dist-info/METADATA

@@ -0,0 +1,56 @@
+Metadata-Version: 2.4
+Name: qsppack
+Version: 0.1.0
+Summary: Quantum Signal Processing optimization and analysis
+Author: James Larsen
+License: MIT
+Project-URL: Homepage, https://github.com/beevus77/qsp
+Project-URL: Bug Tracker, https://github.com/beevus77/qsp/issues
+Project-URL: Documentation, https://qsp.readthedocs.io/
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.8
+Description-Content-Type: text/x-rst
+
+qsp - Quantum Signal Processing Optimization
+============================================
+
+A Python package for Quantum Signal Processing optimization and analysis.
+
+Installation
+------------
+
+You can install the package using pip:
+
+.. code-block:: bash
+
+    pip install qsppack
+
+Or install from source:
+
+.. code-block:: bash
+
+    git clone https://github.com/beevus77/qsp.git
+    cd qsp
+    pip install -e .
+
+Documentation
+-------------
+
+Full documentation is available at: https://qsp.readthedocs.io/
+
+Features
+--------
+
+* Quantum Signal Processing optimization
+* Support for various optimization methods (L-BFGS, FPI, Newton)
+* Utility functions for Chebyshev polynomials and phase factor manipulation
+
+License
+-------
+
+This project is licensed under the MIT License - see the LICENSE file for details.

qsppack-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+optimization/QSP_solver.py,sha256=Z7-HrzyL1ZTw9UN2yS70cA-3qmtvpT-SCqKH_TdVf1g,4121
+optimization/__init__.py,sha256=hHIga6VRxuEy0pm80PaJ9ULMcKF1n-VJ-z4W4p2n5S4,509
+optimization/core.py,sha256=fHrjqc4-Qmuod5T_MSjaZrL9_wCRJEINQzzdya-S8Hw,7848
+optimization/objective.py,sha256=qrCRLS__C5IYZQ1piag0dLkhnUk2Ac9Mu_o6B5S_xoc,4550
+optimization/optimizers.py,sha256=pqtHnwceV0Gi5qhaU5yzmuo-ge2HEzUh6lfWSR5BWok,9086
+optimization/utils.py,sha256=CuIye-f7x38zU5HpiX74VAXU5MZ4SoNWt11WGGeVOpE,15650
+qsppack-0.1.0.dist-info/METADATA,sha256=v0pPfoodYS1aOONGPRSPG19ZAcxyUxbmFSW73Wa-ADA,1484
+qsppack-0.1.0.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
+qsppack-0.1.0.dist-info/top_level.txt,sha256=D7HS9oMRtMUQK6kRIxQd_mgO-5CsfzYsxq7rht6vXQU,13
+qsppack-0.1.0.dist-info/RECORD,,

qsppack-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.7.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

qsppack-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+optimization