Efficient Quantum Solution for the Constrained Tactical Capacity Problem for Distributed Electricity Generation

Abstract

With the transition to sustainable energy sources and devices, the demand for and supply of energy increases ever more. With energy grids struggling to keep up with this increase, we need to ensure that supply and demand are correctly matched. The Tactical Capacity Problem tackles this issue by choosing the optimal location of sustainable power sources to minimise the total energy loss. We extend an existing quantum approach of solving this problem in two ways. Firstly, we extend the problem to include capacity constraints, resulting in the Constrained Tactical Capacity Problem. Secondly, we propose two ways of optimising the performance of the resulting model via variable reduction. These optimisations are supported by numerical results obtained on both classical and quantum solvers.

Appendices

A Derivation of the Penalty Functions

First, the constraint describing the upper bound, as shown in (13), will be transformed into a penalty function. We start by adding the total demand at time interval t to both sides of the equation. Because all $s_{ijt}$ are non-negative, the left hand side is bounded from below by 0. Therefore, (13) is equivalent to

$$\begin{aligned} 0\le \sum _{i=1}^{N}\sum _{j=1}^{M}s_{ijt}x_{ij} \le C+\sum _{i=1}^{N}d_{it} \qquad \text {for all } t\in T_\text {up}. \end{aligned}$$

(22)

Furthermore, $s_{ijt}$ and $d_{it}$ are integer values. Therefore, the inequality constraint in (22) is equivalent to

$$\begin{aligned} \sum _{i=1}^{N}\sum _{j=1}^{M}s_{ijt}x_{ij} = I(\boldsymbol{y}_t; C+\sum _{i=1}^{N}d_{it}) \qquad \text {for all } t\in T_\text {up}, \end{aligned}$$

(23)

where I is the integer encoding function shown in (4) and $\boldsymbol{y}_t$ is a vector containing auxiliary binary variables. Hence, the penalty function for the upper bound constraint is given by

$$\begin{aligned} P_\text {up}(\boldsymbol{x}, \boldsymbol{y}) = \sum _{t\in T_\text {up}}\left( \sum _{i=1}^{N}\sum _{j=1}^{M}s_{ijt}x_{ij} - I(\boldsymbol{y}_t; C+\sum _{i=1}^{N}d_{it})\right) ^2. \end{aligned}$$

(24)

The constraint describing the lower bound, as shown in (14), can be transformed in a penalty function in a similar manner. Note that (13) is equal to

$$\begin{aligned} \sum _{i=1}^{N}\sum _{j=1}^{M}s_{ijt}(1-x_{ij}) \le C + \sum _{i=1}^{N}\sum _{j=1}^{M}s_{ijt} - d_{it}. \end{aligned}$$

(25)

Both $s_{ijt}$ and $1-x_{ij}$ are non-negative. Therefore, (25) is bounded from below by 0, i.e.,

$$\begin{aligned} 0\le \sum _{i=1}^{N}\sum _{j=1}^{M}s_{ijt}(1-x_{ij})\le C + \sum _{i=1}^{N}\sum _{j=1}^{M}s_{ijt} - d_{it}. \end{aligned}$$

(26)

Similarly to the upper bound constraint, the fact that $s_{ijt}$ and $d_{it}$ are integer values can be used to transform the inequality constraint in (26) to the following equality constraint:

$$\begin{aligned} \sum _{i=1}^{N}\sum _{j=1}^{M}s_{ijt}(1-x_{ij}) = I(\boldsymbol{z}_t,C + \sum _{i=1}^{N}\sum _{j=1}^{M}s_{ijt}-d_{it}), \end{aligned}$$

(27)

where $\boldsymbol{z}_t$ is a vector containing auxiliary binary variables. Therefore, the penalty function for the lower bound constraint is given by

$$\begin{aligned} P_\text {low}(\boldsymbol{x}, \boldsymbol{z}) = \sum _{t\in T_\text {low}}\left( \sum _{i=1}^{N}\sum _{j=1}^{M}s_{ijt}(1-x_{ij}) - I(\boldsymbol{z}_t,C + \sum _{i=1}^{N}\sum _{j=1}^{M}s_{ijt}-d_{it})\right) ^2. \end{aligned}$$

(28)

B Settings for Simulated Annealing and Quantum Annealing runs

For Simulated Annealing we used the D-Wave SimulatedAnnealingSampler with 500 reads, while all other settings were left as default. For Quantum Annealing, we used the D-Wave Advantage system. The number of reads was set to 500 and the annealing time was set to 1000 $\mu$s, while all other settings were left as default. From our experience, these values often yield good results for medium to large problem sizes. With these settings, the total QPU time was approximately 0.6 s. Lastly, $\lambda _0$ and $\lambda _1$ were set to 10N. An empirical study showed that these values did not have a significant influence on the result. Using these settings the results depicted in Fig. 4 were obtained.

C Python Packages

To generate the results shown in this work, we used the script below. We used Python 3.11 with packages as depicted in Table 1:

Table 1. Packages and versions used