Logo
ScienceStack
Table of Contents
Fetching ...
Sign In

Parallel Domain-Decomposition Algorithms for Complexity Certification of Branch-and-Bound Algorithms for Mixed-Integer Linear and Quadratic Programming

Shamisa Shoja, Daniel Arnström, Daniel Axehill

TL;DR

The paper tackles the challenge of certifying the worst-case computational complexity of branch-and-bound solvers for multi-parametric MILP and MIQP problems arising in MPC for hybrid systems. It extends the existing serial complexity certification framework with two parallel domain-decomposition strategies (static and dynamic) to leverage HPC resources, while introducing memory-reduction techniques to curb peak resource usage. A modified parallel algorithm integrates early termination and delayed cut-condition evaluation to maintain scalability without compromising correctness, ensuring the parallel certification matches the online B&B behavior for any fixed parameter. Numerical experiments on random mp-MILP/MIQP instances and a hybrid MPC example demonstrate substantial reductions in computation time and meaningful memory savings, validating the effectiveness and practicality of the approach in real-time-like settings.

Abstract

When implementing model predictive control (MPC) for hybrid systems with a linear or a quadratic performance measure, a mixed-integer linear program (MILP) or a mixed-integer quadratic program (MIQP) needs to be solved, respectively, at each sampling instant. Recent work has introduced the possibility to certify the computational complexity of branch-and-bound (B&B) algorithms when solving MILP and MIQP problems formulated as multi-parametric MILPs (mp-MILPs) and mp-MIQPs. Such a framework allows for computing the worst-case computational complexity of standard B&B-based MILP and MIQP solvers, quantified by metrics such as the total number of LP/QP iterations and B&B nodes. These results are highly relevant for real-time hybrid MPC applications. In this paper, we extend this framework by developing parallel, domain-decomposition versions of the previously proposed algorithm, allowing it to scale to larger problem sizes and enable the use of high-performance computing (HPC) resources. Furthermore, to reduce peak memory consumption, we introduce two novel modifications to the existing (serial) complexity certification framework, integrating them into the proposed parallel algorithms. Numerical experiments show that the parallel algorithms significantly reduce computation time while maintaining the correctness of the original framework.

Parallel Domain-Decomposition Algorithms for Complexity Certification of Branch-and-Bound Algorithms for Mixed-Integer Linear and Quadratic Programming

TL;DR

The paper tackles the challenge of certifying the worst-case computational complexity of branch-and-bound solvers for multi-parametric MILP and MIQP problems arising in MPC for hybrid systems. It extends the existing serial complexity certification framework with two parallel domain-decomposition strategies (static and dynamic) to leverage HPC resources, while introducing memory-reduction techniques to curb peak resource usage. A modified parallel algorithm integrates early termination and delayed cut-condition evaluation to maintain scalability without compromising correctness, ensuring the parallel certification matches the online B&B behavior for any fixed parameter. Numerical experiments on random mp-MILP/MIQP instances and a hybrid MPC example demonstrate substantial reductions in computation time and meaningful memory savings, validating the effectiveness and practicality of the approach in real-time-like settings.

Abstract

When implementing model predictive control (MPC) for hybrid systems with a linear or a quadratic performance measure, a mixed-integer linear program (MILP) or a mixed-integer quadratic program (MIQP) needs to be solved, respectively, at each sampling instant. Recent work has introduced the possibility to certify the computational complexity of branch-and-bound (B&B) algorithms when solving MILP and MIQP problems formulated as multi-parametric MILPs (mp-MILPs) and mp-MIQPs. Such a framework allows for computing the worst-case computational complexity of standard B&B-based MILP and MIQP solvers, quantified by metrics such as the total number of LP/QP iterations and B&B nodes. These results are highly relevant for real-time hybrid MPC applications. In this paper, we extend this framework by developing parallel, domain-decomposition versions of the previously proposed algorithm, allowing it to scale to larger problem sizes and enable the use of high-performance computing (HPC) resources. Furthermore, to reduce peak memory consumption, we introduce two novel modifications to the existing (serial) complexity certification framework, integrating them into the proposed parallel algorithms. Numerical experiments show that the parallel algorithms significantly reduce computation time while maintaining the correctness of the original framework.

Paper Structure

This paper contains 15 sections, 4 theorems, 3 equations, 6 figures, 1 table, 4 algorithms.

Table of Contents

  1. Introduction
  2. Problem formulation
  3. Serial complexity certification framework
  4. Parallel complexity certification framework
  5. Static domain decomposition
  6. Dynamic domain decomposition
  7. Properties of the parallel algorithms
  8. Reducing peak resource consumption
  9. Early termination of relaxation's certification
  10. Delayed cut-condition evaluation
  11. Modified parallel certification algorithm
  12. Numerical experiments
  13. Random examples
  14. MPC application
  15. Conclusion

Key Result

Theorem 1

Let $\mathbb{B}_s(\theta)$ denote the sequence of nodes explored by Algorithm alg:cert_par_dom (B&BCertStat) applied to the problem eq:mpMILP_par/eq:mpMIQP_par for a fixed $\theta \in \Theta_0$ in a terminated region in $\mathcal{F}_s$. Moreover, let $\mathbb{B}(\theta)$ represent the sequence of no

Figures (6)

  • Figure 1: Topology of the proposed parallel Algorithm \ref{['alg:cert_par']}.
  • Figure 2: Average worst-case number of iterations and B&B nodes as a function of $n_b$ for random experiments.
  • Figure 3: Speed-up factor of Algorithm \ref{['alg:cert_par_dom']} (dashed red line) alongside the speed-up factor of Algorithm \ref{['alg:cert_par']} for three different ratios (solid lines), compared to the ideal linear speed-up (dotted black line), as a function of the number of workers for random experiments.
  • Figure 4: The number of tuples stored in $\mathcal{S}_d$ in the master during Algorithms \ref{['alg:cert_par']} (solid blue line) and \ref{['alg:cert_par_mod']} (dotted red line).
  • Figure 5: Resulting parameter space partitions for two randomly generated examples, determined using Algorithm \ref{['alg:cert_par']} in (a) and (c), and Algorithm \ref{['alg:cert_par_dom']} in (b) and (d). Results are shown for $n_b = 10$ in (a) and (b), and $n_b = 20$ in (c) and (d).
  • ...and 1 more figures

Theorems & Definitions (9)

  • Remark 1
  • Theorem 1
  • proof
  • Theorem 2
  • proof
  • Corollary 1
  • proof
  • Corollary 2
  • proof