PySparQ.pysparq.algorithms.qda_solver

QDA (Quantum Discrete Adiabatic) Linear System Solver Implementation

Classes

BlockEncoding	Placeholder for block encoding implementation.
BlockEncodingHs	Block encoding of the interpolating Hamiltonian H(s).
BlockEncodingHsPD	Positive-definite version of block encoding H(s).
Filtering	Dolph-Chebyshev filtering for QDA.
LCU	Linear Combination of Unitaries for QDA.
StatePreparation	Placeholder for state preparation implementation.
WalkS	Quantum walk operator at parameter s.

Functions

calculate_angles(→ list[float])	Calculate rotation angles from coefficients for state preparation.
chebyshev_T(→ float)	Compute Chebyshev polynomial T_n(x).
classical_to_quantum(→ tuple[numpy.ndarray, ...)	Convert classical linear system to quantum-compatible form.
compute_fourier_coeffs(→ list[float])	Compute Fourier coefficients for Dolph-Chebyshev filter.
compute_fs(→ float)	Compute the interpolation parameter f(s).
compute_rotation_matrix(→ list[complex])	Compute the rotation matrix R_s for block encoding.
create_qda_demo(→ str)	Generate a demo script for QDA solver.
dolph_chebyshev(→ float)	Compute Dolph-Chebyshev window function.
qda_solve(→ numpy.ndarray)	Solve Ax = b using QDA algorithm (auto-detects matrix type).
qda_solve_tridiagonal(→ numpy.ndarray)	Solve Ax = b using QDA algorithm with tridiagonal block encoding.
qda_solve_via_qram(→ numpy.ndarray)	Solve Ax = b using QDA algorithm via QRAM block encoding.

Module Contents

class PySparQ.pysparq.algorithms.qda_solver.BlockEncoding(A: numpy.ndarray, data_size: int = ...)

Placeholder for block encoding implementation.

conditioned_by_all_ones(conds: str | list[str]) → BlockEncoding

dag(state: pysparq.SparseState) → None

A: numpy.ndarray

data_size: int

class PySparQ.pysparq.algorithms.qda_solver.BlockEncodingHs(enc_A: BlockEncoding, enc_b: StatePreparation, main_reg: str, anc_UA: str, anc_1: str, anc_2: str, anc_3: str, anc_4: str, fs: float)

Block encoding of the interpolating Hamiltonian H(s).

conditioned_by_all_ones(conds: str | list[str]) → BlockEncodingHs

dag(state: pysparq.SparseState) → None

R_s: list[complex]

anc_1: str

anc_2: str

anc_3: str

anc_4: str

anc_UA: str

enc_A: BlockEncoding

enc_b: StatePreparation

fs: float

main_reg: str

class PySparQ.pysparq.algorithms.qda_solver.BlockEncodingHsPD(enc_A: BlockEncoding, enc_b: StatePreparation, main_reg: str, anc_UA: str, anc_1: str, anc_2: str, anc_3: str, anc_4: str, fs: float)

Positive-definite version of block encoding H(s).

R_s: list[complex]

anc_1: str

anc_2: str

anc_3: str

anc_4: str

anc_UA: str

enc_A: BlockEncoding

enc_b: StatePreparation

fs: float

main_reg: str

class PySparQ.pysparq.algorithms.qda_solver.Filtering(walk: WalkS, index_reg: str, anc_h: str, epsilon: float = ..., l: int = ...)

Dolph-Chebyshev filtering for QDA.

anc_h: str

coeffs: list[float]

epsilon: float

index_reg: str

l: int

walk: WalkS

class PySparQ.pysparq.algorithms.qda_solver.LCU(walk: WalkS, index_reg: str, log_file: str = ...)

Linear Combination of Unitaries for QDA.

dag(state: pysparq.SparseState) → None

index_reg: str

index_size: int

log_file: str

walk: WalkS

class PySparQ.pysparq.algorithms.qda_solver.StatePreparation(b: numpy.ndarray)

Placeholder for state preparation implementation.

conditioned_by_all_ones(conds: str | list[str]) → StatePreparation

dag(state: pysparq.SparseState) → None

b: numpy.ndarray

class PySparQ.pysparq.algorithms.qda_solver.WalkS(enc_A: BlockEncoding, enc_b: StatePreparation, main_reg: str, anc_UA: str, anc_1: str, anc_2: str, anc_3: str, anc_4: str, s: float, kappa: float, p: float, is_positive_definite: bool = ...)

Quantum walk operator at parameter s.

clear_conditions() → None

conditioned_by_all_ones(conds: str | list[str]) → WalkS

conditioned_by_bit(reg: str, pos: int) → WalkS

dag(state: pysparq.SparseState) → None

anc_1: str

anc_2: str

anc_3: str

anc_4: str

anc_UA: str

enc_Hs: BlockEncodingHs | BlockEncodingHsPD

fs: float

is_positive_definite: bool

kappa: float

main_reg: str

p: float

phase: complex

s: float

PySparQ.pysparq.algorithms.qda_solver.calculate_angles(coeffs: list[float]) → list[float]

Calculate rotation angles from coefficients for state preparation.

PySparQ.pysparq.algorithms.qda_solver.chebyshev_T(n: int, x: float) → float

Compute Chebyshev polynomial T_n(x).

PySparQ.pysparq.algorithms.qda_solver.classical_to_quantum(A: numpy.ndarray, b: numpy.ndarray) → tuple[numpy.ndarray, numpy.ndarray, Callable[[numpy.ndarray], numpy.ndarray]]

Convert classical linear system to quantum-compatible form.

PySparQ.pysparq.algorithms.qda_solver.compute_fourier_coeffs(epsilon: float, l: int) → list[float]

Compute Fourier coefficients for Dolph-Chebyshev filter.

PySparQ.pysparq.algorithms.qda_solver.compute_fs(s: float, kappa: float, p: float) → float

Compute the interpolation parameter f(s).

PySparQ.pysparq.algorithms.qda_solver.compute_rotation_matrix(fs: float) → list[complex]

Compute the rotation matrix R_s for block encoding.

PySparQ.pysparq.algorithms.qda_solver.create_qda_demo() → str

Generate a demo script for QDA solver.

PySparQ.pysparq.algorithms.qda_solver.dolph_chebyshev(epsilon: float, l: int, phi: float) → float

Compute Dolph-Chebyshev window function.

PySparQ.pysparq.algorithms.qda_solver.qda_solve(A: numpy.ndarray, b: numpy.ndarray, kappa: float | None = ..., p: float = ..., eps: float = ..., step_rate: float = ...) → numpy.ndarray

Solve Ax = b using QDA algorithm (auto-detects matrix type).

PySparQ.pysparq.algorithms.qda_solver.qda_solve_tridiagonal(A: numpy.ndarray, b: numpy.ndarray, kappa: float | None = ..., p: float = ..., eps: float = ..., step_rate: float = ...) → numpy.ndarray

Solve Ax = b using QDA algorithm with tridiagonal block encoding.

PySparQ.pysparq.algorithms.qda_solver.qda_solve_via_qram(A: numpy.ndarray, b: numpy.ndarray, kappa: float | None = ..., p: float = ..., eps: float = ..., step_rate: float = ...) → numpy.ndarray

Solve Ax = b using QDA algorithm via QRAM block encoding.