Parameter Precision#

Precision Conversion Requirements#

In practical modeling problems, a QUBO formulation is often obtained first, which must then be converted into an Ising model to be executed on physical quantum hardware. The QUBO model needs to be transformed into an Ising model $\mathcal{H}=-\sum_{i,j}J_{ij}s_is_j-\mu\sum_ih_is_i$ for real physical computation.

In actual computation, the coefficient bit-width is constrained by the physical hardware and can only take limited ranges.

1.CIM hardware only supports 8-bit signed integer range [-128, 127].

2.Users must ensure that the converted Ising matrix satisfies this precision requirement.

3.The conversion logic provided is for reference. Users can apply methods more suitable for their own matrices.

QUBO to Ising Transformation#

This section describes how to transform QUBO into Ising to illustrate how dynamic range limits the QUBO matrix.

The QUBO model is defined as follows:

$\mathcal{H}= \sum_{i}{q_{ii}x_{i}} +\sum_{i\neq j}{q_{ij}x_{i}x_{j}}$

Before computation, it must be converted into an Ising matrix. Let $s_{i} = 2x_{i}-1 \in \{1,-1\}$ ,

$\mathcal{H} =& \sum_{i}{q_{ii}\cdot \frac{s_{i}+1}{2}} +\sum_{i\neq j}{q_{ij}\cdot \frac{(s_{i}+1)(s_{j}+1)}{4}} \\ = &\sum_{i\neq j} \frac{q_{ij}}{4}s_{i}s_{j} +\sum_{i} \Big(\frac{q_{ii}}{2}+\frac{\sum_{k\neq i}{(q_{ik}+q_{ki})}}{4}\Big) s_{i} + \Big(\frac{\sum_{i} q_{ii}}{2} +\frac{\sum_{i\neq j}q_{ij}}{4}\Big)$

QUBO variables satisfy $x^2 = x$ , allowing linear terms to be represented by diagonal elements. In the Ising model, $x^2 = 1$ , so this representation is not applicable.

The linear terms are converted into quadratic terms by introducing auxiliary spin variables $s$ , whose values 1 and -1 correspond to the original two solution states. Thus, introducing auxiliary variables preserves equivalence with the original problem.

Constant terms are recorded separately and added back into the final Hamiltonian calculation.

Example:

$x^\top\left( \begin{array}{ll} 0 & 2\\ 1 & 1 \end{array}\right)x$

After the transformation, it becomes

$s^\top\left( \begin{array}{lll} 0 & 3/8 & 3/8\\ 3/8 & 0 & 5/8 \\ 3/8 & 5/8 & 0 \end{array} \right) s+3/2$

Methods for reducing precision in kaiwuSDK#

kaiwuSDK provides two methods for reducing parameter precision: perform_precision_adaption_mutate and perform_precision_adaption_split. The mutate method preserves the optimal solution while modifying the matrix, but the extent of precision reduction depends on the matrix’s reducible space. The split method can adjust a matrix to any precision level; however, the number of bits grows rapidly with the magnitude of the required precision reduction.

perform_precision_adaption_mutate#

1 Dynamic Range#

1.1 Definitions Related to QUBO Matrix

Definition Let Q be a QUBO matrix. $Q \subseteq Q'$ indicates that the optimal solution space of Q is included in that of Q’.

Definition $\lfloor Q \rceil$ denotes rounding each element of Q to the nearest integer.

1.2 Dynamic Range Definitions

Definition $X$ denotes a coefficient matrix.

$\hat{D}(X)$ denotes the maximum distance between elements of X.

$\check{D}(X)$ denotes the minimum non-zero distance between elements of X.

$DR(X):=\log_2(\frac{\hat{D}(X)}{\check{D}(X)})$ defines the dynamic range of X.

Proposition If $\hat{D}(Q)=1$ , then for any $\alpha > 0$ , $DR(\lfloor \alpha Q \rceil) \leq \log_2(1 + \alpha)$ .

The definition of dynamic range applies to both QUBO and Ising matrices. By reducing dynamic range, the required coefficient precision is reduced.

Since the final computation is performed on the Ising matrix, dynamic-range reduction is applied directly to the Ising matrix in kaiwuSDK.

2 Example Usage#

import kaiwu as kw
import numpy as np

mat0 = np.array([[0, -20, 0, 40, 1.1],
                [0, 0, 12240, 1, 120],
                [0, 0, 0, 0, -10240],
                [0, 0, 0, 0, 2.05],
                [0, 0, 0, 0, 0]])
mutated_mat = kw.preprocess.perform_precision_adaption_mutate(mat0)
print(mutated_mat)

perform_precision_adaption_split#

1 Parameter Precision#

Currently, Ising matrix coefficients are stored as fixed-point values with only 8-bit precision. Therefore, if the ratio between the maximum and minimum coefficients exceeds $2^8$ , large coefficients must be split.

This is achieved by replacing a single bit with multiple equivalent bits whose equality is enforced via constraint terms, thereby reducing the magnitude of each coefficient.

With QUBO-to-Ising transformation commonly applied, the splitting method converts $f(\mathbf{x})$ into:

$f(\mathbf{x}, \mathbf{x'})+M\sum_i (x_i - x_{i1})^2+M\sum_{i,j} (x_{ij}-x_{i(j+1)})^2= \\ f(\mathbf{x}, \mathbf{x'})+M\sum_i (x_i + x_{i1} - 2x_ix_{i1})+M\sum_{i,j} (x_{ij} + x_{i(j+1)} - 2x_{ij}x_{i(j+1)})$

For example, for $x_1 + 2x_2 + 200x_3$ , if the coefficient ratio must not exceed 150, the polynomial is modified as: $x_1 + 2x_2 + 100x_3 + 100x_{31} + 50(x_3 - x_{31})^2 = x_1 + 2x_2 + 100x_3 + 100x_{31} + 50(x_3 + x_{31} - 2x_3x_{31})$ .

2 Example Usage#

import kaiwu as kw
import numpy as np

mat = np.array([[0, -15,0, 40],
                [-15,0, 0, 1],
                [0,  0, 0, 0],
                [40, 1, 0, 0]])
splitted_ret, last_idx = kw.preprocess.perform_precision_adaption_split(mat, 4)
print(splitted_ret)

The default min_increment computed value is 1. With precision set to 4 bits, values range from −7 to 7.

The program outputs the converted matrix as follows:

As shown, red arrows indicate the correspondence before and after splitting. Values in blue boxes are penalty terms that enforce equality of newly introduced variables. This allows reducing parameter precision while preserving the original optimal solution.

Precision reduction is controlled by parameters such as param_bit, min_increment, penalty, and round_to_increment.

Matrix values must be integer multiples of min_increment, which defaults to the smallest positive difference.

round_to_increment adjusts elements to ensure the sum of split values equals the original value. For example, splitting 15 into 7.5 + 7.5 would round to 8 + 8; with reduce_error=True, it becomes 7 + 8.

splitted_ret2, last_idx2 = kw.preprocess.perform_precision_adaption_split(mat, 4, min_increment=3, round_to_increment=True)
print(splitted_ret2)

Result:

[[ 0. 21. -6.  0.  3. 12.]
[21.  0. -9.  0. 12. 12.]
[-6. -9.  0.  0.  0.  0.]
[ 0.  0.  0.  0.  0.  0.]
[ 3. 12.  0.  0.  0. 21.]
[12. 12.  0.  0. 21.  0.]]

After solving the reduced-precision matrix, the original matrix solution can be recovered using restore_split_solution.

worker = kw.classical.SimulatedAnnealingOptimizer()
output = worker.solve(splitted_ret)
sol = output[0]
org_sol = kw.preprocess.restore_split_solution(sol, last_idx)
print(org_sol)

Result:

[-1.  1. -1. -1.]

PrecisionReducer#

To support iterative computation using the CIM quantum solver, PrecisionReducer is provided based on the decorator design pattern. Users can wrap CIMOptimizer with PrecisionReducer and pass the PrecisionReducer into the Solver as the optimizer. For details, refer to:

Parameter Precision#

Precision Conversion Requirements#

QUBO to Ising Transformation#

Methods for reducing precision in kaiwuSDK#

perform_precision_adaption_mutate#

1 Dynamic Range#

2 Example Usage#

perform_precision_adaption_split#

1 Parameter Precision#

2 Example Usage#

PrecisionReducer#

More methods for precision handling#