PySparQ.pysparq.algorithms.cks_solver

CKS (Childs-Kothari-Somma) Linear System Solver Implementation

Classes

ChebyshevPolynomialCoefficient	Computes Chebyshev polynomial coefficients for quantum walk.
CondRotQW	Conditional rotation for quantum walk.
LCUContainer	LCU (Linear Combination of Unitaries) container for CKS.
QuantumBinarySearch	Quantum binary search for sparse matrix access.
QuantumWalk	Quantum walk operator for CKS algorithm.
QuantumWalkNSteps	Multiple quantum walk steps for CKS algorithm.
SparseMatrix	Sparse matrix representation for CKS algorithm.
SparseMatrixData	Sparse matrix data for quantum simulation.
TOperator	T operator for CKS algorithm.

Functions

get_coef_common(→ list[complex])	Get rotation matrix coefficients for general (signed) matrix elements.
get_coef_positive_only(→ list[complex])	Get rotation matrix coefficients for positive-only matrix elements.
make_walk_angle_func(→ Callable[[int, int, int], ...)	Create walk angle function for a matrix.

Module Contents

class PySparQ.pysparq.algorithms.cks_solver.ChebyshevPolynomialCoefficient(b: int)

Computes Chebyshev polynomial coefficients for quantum walk.

C(Big: int, Small: int) → float

coef(j: int) → float

sign(j: int) → bool

step(j: int) → int

b: int

class PySparQ.pysparq.algorithms.cks_solver.CondRotQW(j_reg: str, k_reg: str, data_reg: str, output_reg: str, mat: SparseMatrix)

Conditional rotation for quantum walk.

clear_conditions() → None

conditioned_by_all_ones(conds: str | int | list[str | int]) → CondRotQW

conditioned_by_bit(reg: str | int, pos: int) → CondRotQW

conditioned_by_nonzeros(cond: str | int | list[str | int]) → CondRotQW

dag(state: pysparq.SparseState) → None

data_reg: str

j_reg: str

k_reg: str

mat: SparseMatrix

output_reg: str

class PySparQ.pysparq.algorithms.cks_solver.LCUContainer(mat: SparseMatrix, kappa: float, eps: float, qram: pysparq.QRAMCircuit_qutrit | None = ...)

LCU (Linear Combination of Unitaries) container for CKS.

clear_conditions() → None

conditioned_by_all_ones(conds: str | int | list[str | int]) → LCUContainer

conditioned_by_bit(reg: str | int, pos: int) → LCUContainer

conditioned_by_nonzeros(cond: str | int | list[str | int]) → LCUContainer

dag(state: pysparq.SparseState) → None

external_input(init_op: Callable[[pysparq.SparseState], None]) → None

get_input_reg() → str

initialize() → None

iterate() → bool

b: int

chebyshev: ChebyshevPolynomialCoefficient

current_state: pysparq.SparseState | None

eps: float

j0: int

kappa: float

step_state: pysparq.SparseState | None

walk: QuantumWalkNSteps

class PySparQ.pysparq.algorithms.cks_solver.QuantumBinarySearch(qram: pysparq.QRAMCircuit_qutrit, address_offset_reg: str, total_length: int, target_reg: str, result_reg: str)

Quantum binary search for sparse matrix access.

clear_conditions() → None

conditioned_by_all_ones(conds: str | int | list[str | int]) → QuantumBinarySearch

conditioned_by_bit(reg: str | int, pos: int) → QuantumBinarySearch

conditioned_by_nonzeros(cond: str | int | list[str | int]) → QuantumBinarySearch

dag(state: pysparq.SparseState) → None

address_offset_reg: str

max_step: int

qram: pysparq.QRAMCircuit_qutrit

result_reg: str

target_reg: str

total_length: int

class PySparQ.pysparq.algorithms.cks_solver.QuantumWalk(qram: pysparq.QRAMCircuit_qutrit, j_reg: str, b1_reg: str, k_reg: str, b2_reg: str, j_comp_reg: str, k_comp_reg: str, data_offset_reg: str, sparse_offset_reg: str, mat: SparseMatrix)

Quantum walk operator for CKS algorithm.

clear_conditions() → None

conditioned_by_all_ones(conds: str | int | list[str | int]) → QuantumWalk

conditioned_by_bit(reg: str | int, pos: int) → QuantumWalk

conditioned_by_nonzeros(cond: str | int | list[str | int]) → QuantumWalk

dag(state: pysparq.SparseState) → None

b1_reg: str

b2_reg: str

data_offset_reg: str

j_comp_reg: str

j_reg: str

k_comp_reg: str

k_reg: str

mat: SparseMatrix

qram: pysparq.QRAMCircuit_qutrit

sparse_offset_reg: str

class PySparQ.pysparq.algorithms.cks_solver.QuantumWalkNSteps(mat: SparseMatrix, qram: pysparq.QRAMCircuit_qutrit | None = ...)

Multiple quantum walk steps for CKS algorithm.

clear_conditions() → None

conditioned_by_all_ones(conds: str | int | list[str | int]) → QuantumWalkNSteps

conditioned_by_bit(reg: str | int, pos: int) → QuantumWalkNSteps

conditioned_by_nonzeros(cond: str | int | list[str | int]) → QuantumWalkNSteps

create_state() → pysparq.SparseState

dag(state: pysparq.SparseState) → None

first_step(state: pysparq.SparseState) → None

init_environment(state: pysparq.SparseState) → None

make_n_step_state(n_steps: int) → pysparq.SparseState

step(state: pysparq.SparseState) → None

addr_size: int

b1: str

b2: str

data_offset: str

data_size: int

default_reg_size: int

j: str

j_comp: str

k: str

k_comp: str

mat: SparseMatrix

n_row: int

nnz_col: int

qram: pysparq.QRAMCircuit_qutrit

sparse_offset: str

class PySparQ.pysparq.algorithms.cks_solver.SparseMatrix(n_row: int, nnz_col: int, data: list[int], data_size: int, positive_only: bool = ...)

Sparse matrix representation for CKS algorithm.

classmethod from_dense(matrix: numpy.ndarray, data_size: int = ..., positive_only: bool | None = ...) → SparseMatrix

get_data() → list[int]

get_sparsity_offset() → int

get_walk_angle_func() → Callable[[int, int, int], list[complex]]

data: list[int]

data_size: int

n_row: int

nnz_col: int

positive_only: bool

sparsity_offset: int

class PySparQ.pysparq.algorithms.cks_solver.SparseMatrixData(n_row: int, nnz_col: int, data: list[int], data_size: int, positive_only: bool = ..., sparsity_offset: int = ...)

Sparse matrix data for quantum simulation.

data: list[int]

data_size: int

n_row: int

nnz_col: int

positive_only: bool

sparsity_offset: int

class PySparQ.pysparq.algorithms.cks_solver.TOperator(qram: pysparq.QRAMCircuit_qutrit, data_offset_reg: str, sparse_offset_reg: str, j_reg: str, b1_reg: str, k_reg: str, b2_reg: str, search_result_reg: str, nnz_col: int, data_size: int, mat: SparseMatrix)

T operator for CKS algorithm.

clear_conditions() → None

conditioned_by_all_ones(conds: str | int | list[str | int]) → TOperator

conditioned_by_bit(reg: str | int, pos: int) → TOperator

conditioned_by_nonzeros(cond: str | int | list[str | int]) → TOperator

dag(state: pysparq.SparseState) → None

b1_reg: str

b2_reg: str

data_offset_reg: str

data_size: int

j_reg: str

k_reg: str

mat: SparseMatrix

nnz_col: int

qram: pysparq.QRAMCircuit_qutrit

search_result_reg: str

sparse_offset_reg: str

PySparQ.pysparq.algorithms.cks_solver.get_coef_common(mat_data_size: int, v: int, row: int, col: int) → list[complex]

Get rotation matrix coefficients for general (signed) matrix elements.

PySparQ.pysparq.algorithms.cks_solver.get_coef_positive_only(mat_data_size: int, v: int, row: int, col: int) → list[complex]

Get rotation matrix coefficients for positive-only matrix elements.

PySparQ.pysparq.algorithms.cks_solver.make_walk_angle_func(mat_data_size: int, positive_only: bool) → Callable[[int, int, int], list[complex]]

Create walk angle function for a matrix.