qsppack 0.1.0__tar.gz

qsppack-0.1.0/PKG-INFO

@@ -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/README.rst

@@ -0,0 +1,38 @@
+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/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

qsppack-0.1.0/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
+]

qsppack-0.1.0/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

qsppack-0.1.0/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