Space splitting convexification: a local solution method for nonconvex optimal control problems

Many optimal control tasks for engineering problems require the solution of nonconvex optimisation problems, which are rather hard to solve. This article presents a novel iterative optimisation procedure for the fast solution of such problems using successive convexification. The approach considers two types of nonconvexities. Firstly, equality constraints with possibly multiple univariate nonlinearities, which can arise for nonlinear system dynamics. Secondly, nonconvex sets comprised of convex subsets, which may occur for semi-active actuators. By introducing additional decision variables and constraints, the decision variable space is decomposed into affine segments yielding a convex subproblem which is solved efficiently in an iterative manner. Under certain conditions, the algorithm converges to a local optimum of a scalable, piecewise linear approximation of the original problem. Furthermore, the algorithm tolerates infeasible initial guesses. Using a single-mass oscillator application, the procedure is compared with a nonlinear programming algorithm, and the sensitivity regarding initial guesses is analysed.


Introduction
Many optimal control tasks for engineering problems require the solution of nonconvex optimisation problems (OPs), which are harder to solve than convex ones. The nonconvexity can have various causes. Restrictions in the operating range of actuators can result in nonconvex sets. Nonconvexity can also be caused by nonlinear system dynamics resulting in nonlinear and thus nonconvex equality constraints. Since a fast and robust computation of the optimum is always desirable and even essential for real-time control applications, convexification represents a fundamental field in optimal control. Convex OPs can be solved efficiently and robustly with elaborate solvers capable of computing the global optimum with high accuracy and generally short computation times. Various convexification methods have been proposed, which generally solve nonconvex problems by iteratively solving convex substitute problems.

Literature survey on convexification techniques
Lossless convexification (LC) transforms a special class of nonconvex sets into convex ones by lifting the optimisation space into a higher dimension using additional decision variables (Acikmese & Blackmore, 2011;Acikmese & Ploen, 2007). The approach is applicable to a special class of nonconvex sets: sets generated by removing a convex subset from a convex set. This has been used in aeronautic optimal control applications to successfully convexify annulus-shaped sets. An overview regarding the individual findings on LC is given in Raković and Levine (2018, p.338 Another often employed technique for convex approximation is linearisation since linear objectives and constraints are convex (Boyd & Vandenberghe, 2004). However, linearisation can introduce conservativeness and infeasibility since the resulting accuracy strongly depends on the nonlinearity as well as the linearisation point. Various linearisation techniques have been used to approximate nonlinear systems when applying optimal control methods. In the simplest case, the system is linearised at each time instant around the current operating point, exemplarily implemented in Falcone et al. (2007). However, the model approximation is only sufficiently valid in a close neighbourhood around the linearisation point. With increasing distance to this point, the linearised OP can strongly differ from the original one. Thus, this approach can result in poor controller performance or even lead to infeasibility or instability.
In order to mitigate linearisation errors, the system can be linearised around predicted trajectories resulting in efficiently solvable quadratic programming (QP) problems (Diehl et al., 2005;Seki et al., 2004). One method using iterative linearisation around trajectories in a model predictive control (MPC) setup is the so-called real-time iteration approach (Diehl et al., 2005). The procedure assumes that at every time instant, the shifted solution from the preceding time instant represents a good initial guess close to the actual solution. Thus, a full Newton-step is taken, omitting underlying line-search routines to reduce computation time.
Another iterative scheme linearising around changing trajectories has been presented in Mao et al. (2016). Starting from an initial trajectory, the nonlinear system equations are successively linearised around the solution computed in the preceding iteration. Adding virtual control inputs eliminates the artificial infeasibility introduced by the linearisation. Furthermore, including trust regions ensures that the solution does not deviate too much from the preceding succession and thus the linearisation represents a valid approximation. This avoids unboundedness of the linearised OP. Based on the ratio between actual objective change and linearised objective change, the algorithm adjusts the trust regions and terminates if the objectives coincide.
A linearise-and-project (LnP) approach has been used in Mao et al. (2017) to resolve the nonconvexity due to nonlinear system equations and nonconvex constraints. The approach presumes convex functions for the right-hand side of the system differential equations. The satisfaction of the system dynamics is ensured by relaxing the corresponding equality constraints into inequality constraints and using exact penalty functions. In an iterative optimisation routine, the computed solution is projected onto the constraints in each iteration to gain adequate linearisation points.
Instead of linearising the system equations around trajectories, a linear input-to-state behaviour can be enforced via feedback-linearisation (Khalil, 2002, p. 505). An optimal control method can then be used to optimally control the linearised system in an outer control loop (Del Re et al., 1993). However, it is possible that the nonlinear mapping of the feedback linearisation transforms originally convex objective and constraint functions into nonconvex ones (Simon et al., 2013). Then, the exact satisfaction of these constraints requires a nonlinear programming (NLP) strategy or an iterative scheme which both eliminate the computational benefits of the feedbacklinearisation (Kurtz & Henson, 1997). One possible solution to this problem is approximating these constraints by estimating future inputs based on the preceding time instant within an MPC scheme (Kurtz & Henson, 1997;Schnelle & Eberhard, 2015). The authors in Simon et al. (2013) have proposed an alternative MPC approach that replaces such nonlinear constraints via dynamically generated local inner polytopic approximations rendering the OP convex.
Fuzzy MPC with models of Takagi-Sugeno (TS) type has been successfully used for nonlinear MPC. The TS modelling procedure enables an accurate approximation of nonlinear systems by using data combined with model knowledge (Tanaka & Wang, 2004). The modelling approach decomposes nonlinear models into several local approximations which are blended together via fuzzy rules. However, this requires the system matrices to be stored, thus occupying more memory. Although TS fuzzy models have been successfully used in nonlinear MPC, computation time can be strongly reduced by linearising the TS models around predicted trajectories (Mollov et al., 2004(Mollov et al., , 1998. The resulting convex QP problem can be solved efficiently while guaranteeing convergence via a line search mechanism. Differential dynamic programming initially linearises the system equations around a nominal trajectory. Starting from the terminal state, a backward pass identifies the optimal controller gains of a linear quadratic regulator at each time step using the linearised system. Subsequently, a forward pass computes new nominal trajectories via numerical integration using the controller gains previously computed in the backward pass. This procedure is repeated until convergence. Iterative linear quadratic regulators are a variant of differential dynamic programming (Mayne, 1973). The main difference is that only first-order derivatives are used for the approximation of the system dynamics via Taylor expansion instead of second-order ones which decreases computation time (Tassa et al., 2012). Constrained versions of this optimisation technique have been presented in Tassa et al. (2014), Xie et al. (2017) and Chen et al. (2017).
Lifting-based MPC methods represent another class of linearisation approaches used for solving optimal control problems (OCPs) with nonlinear systems. By lifting the nonlinear dynamics to a space of higher dimension, the evolution of the system can be represented in a bilinear or linear fashion via Carleman linearisation or the Koopman operator framework, respectively. Representing the nonlinear system equations via bilinear terms enables the analytical computation of sensitivity functions (Armaou & Ataei, 2014) and of solutions (Fang & Armaou, 2015) which speeds up computation time. The Koopman MPC approach employs a linear predictor of higher order, which is identified via data sets, to approximate the nonlinear system (Korda & Mezić, 2018). The resulting larger OCP is condensed by eliminating the state decision variables and then solved for the input decision variables using linear MPC. Hence, this method enables a fast solution of nonlinear OCPs. However, identifying the linear Koopman system involves some effort requiring an adequate selection of basis functions, non-recurrent data sets and the solution of convex OPs (Cibulka et al., 2019). Furthermore, the Koopman MPC approach does not always outperform the standard MPC method using local linearisations (Cibulka et al., 2020). Depending on the dimension of the lifted states, both approaches can require the storage of a great number of offline computed matrices.
Various local methods for solving nonconvex quadratically constrained quadratic programming (QCQP) problems have been summarised in d' Aspremont and Boyd (2003) and Park and Boyd (2017). A two-phase coordinate descent method first reduces the maximum constraint violation trying to find a feasible point. The second phase is restricted to feasible points only and searches in each iteration for a feasible point with a better objective function value. The convex-concave procedure (CCP) is a method for finding a local optimum for difference-of-convex programming problems, thus suitable for QCQP. The nonconvex part of the constraints is linearised rendering the constraints convex. In order to deal with infeasible initial guesses, penalty CCP relaxes the linearised constraints via slack variables and introduces a gradually increasing penalty objective for constraint violations. The alternating directions method of multipliers (ADMM) is a variant of the augmented Lagrangian method. It forms an equivalent OP by using auxiliary decision variables which must satisfy a consensus constraint. The objective function is augmented using switching indicator functions which penalise individual constraint violations. The augmented objective function terms are separated into two groups of decision variables. Instead of solving the proximal augmented Lagrangian function for both groups of decision variables simultaneously, the solution is computed using an alternating approach. First, the first group of decision variables is fixed and the problem is solved for the second group. Then, the solution of the second group is fixed and the problem is solved for the first one. The results are used for the dual variable update and the procedure is repeated. This alternating approach requires the solution of simplified QCQP problems enhancing computation time compared to simultaneously solving for both groups of decision variables.
Convexification measures for sequential quadratic programming (SQP) approaches on a more algorithmic level have been presented in Verschueren (2018). Many QP solvers do not support an indefinite Hessian of the Lagrangian since then a descent direction is not guaranteed. The author has presented a structure-preserving convexification procedure for indefinite Hessians. The convexified Hessian can be fed to any structureexploiting QP solver (Verschueren, 2018, p. 39). Furthermore, sequential convex quadratic programming is proposed which uses second-order derivatives of convex objective functions and convex constraint functions to construct positive definite Hessians enabling the sequential solution of convex QP problems (Verschueren, 2018, p. 70).
Using the notion of space decomposition for convexification, global optimisation (GO) techniques have similarities with the convexification approach presented in this article. In order to compute the global optimum of continuous, nonconvex OPs, spatial branch-and-bound (BnB) techniques iteratively divide the search space into increasingly smaller subdomains (Liberti, 2008;Liberti & Maculan, 2006;Ryoo & Sahinidis, 1995;Tawarmalani & Sahinidis, 2002). A convex relaxation of nonconvex functions is applied on each subdomain. The efficiently solvable relaxed problem provides a lower bound of the objective function for the corresponding subdomain. The comparison with an upper bound, which can be computed using local optimisation techniques, determines if a further space subdivision is necessary. Thus, this technique searches over a tree whose nodes correspond to individual relaxed problems which consider different subdomains. Comparing the solutions on the individual subdomains provides the global solution. Tree nodes are excluded on the fly based on the evaluation of the lower and upper bounds of the individual nodes eliminating the need to explore the entire domain.

Contribution
In this article, a novel successive convexification method called space splitting convexification (SSC) is proposed aiming at reducing the computation time required to solve nonconvex OPs. The key contribution of the approach is the space decomposition procedure which provides a piecewise linear approximation of the original, nonconvex problem by introducing auxiliary decision variables and absolute value constraints (AVCs). These AVCs possess a beneficial structure for linearisation and point projection onto constraints. The AVCs are transferred to the objective function using the concept of exact penalty functions and then iteratively linearised around changing points. The linearisation of the AVCs results in a binary decision: wrong or right sign of the AVC-linearisation. In each iteration, the computed solution is projected onto the AVCs and the sign is corrected if necessary enabling the linearisation errors to vanish in subsequent iterations. This concludes the iterative solution of a convex QP problem or even linear programming (LP) problem if the original objective is linear. The violation of the linearised AVCs serves as feedback if the correct sign was chosen which is used as an indicator for convergence. The approach is capable of considering two types of nonconvexities. Firstly, a class of nonconvex sets that can be split into convex subsets which are called zonally convex sets (ZCSs) in this article. Such sets arise for instance when semi-active actuators are used. Secondly, equality constraints with possibly multiple but univariate nonlinearities. As already mentioned, a common source for these nonlinear equality constraints are nonlinear system equations when applying optimal control methods. Requiring only simple mathematical operations, the AVC-projection is of linear computational complexity. Furthermore, the binary nature of the AVC-linearisation generally results in few superordinate iterations. Thus, the SSC algorithm greatly reduces computation time enabling an efficient solution in polynomial-time. Furthermore, robust initialisation properties are given since the initial guess is not required to be feasible. The algorithm converges under certain conditions to local optima of the piecewise linear substitute problem, which represents a scalable approximation of the original problem. However, being a local solution method, the computed local solution generally depends on the provided initial guess. For good initialisations, the algorithm computes solutions which are close to the global optimum.

Article structure
The article is organised as follows. The novel successive convexification method is presented in Section 2. Starting with the general formulation of optimal control problems, the original static OP for the numerical solution of the optimal control task is presented in Section 2.1. Afterwards, Section 2.2 derives the successive convexification algorithm and provides a proof of convergence. The specific application of the SSC algorithm to two-dimensional ZCSs and nonlinear equality constraints is illustrated in Section 2.3. Remarks on the computation time of the algorithm are given in Section 2.4. The comparison of the SSC approach with existing methods in Section 2.5 concludes the theoretical part of the article. Using a single mass oscillator (SMO) application as an example, the SSC algorithm is compared with the NLP solver IPOPT (Wächter & Biegler, 2006) in Section 3. The required NLP problem and QP problem are defined in Section 3.1 and the corresponding results are discussed in Section 3.2. Furthermore, the sensitivity regarding initial guesses is analysed in Section 3.3 and rotated space splitting is briefly addressed in Section 3.4. The article closes with concluding remarks in Section 4. In order to promote swift comprehension, a table of notation is included at the end of the article.

Space splitting convexification
Optimal control deals with computing the optimal input and state trajectories for a given system model. The motion of a nonlinear, continuous, time-invariant system is given by the differential equation systeṁ with states x ∈ X ⊆ R n x and inputs u ∈ U ⊆ R n u . An optimal control trajectory u(t) for a system described by (1) and time interval t ∈ [t 0 , t f ] can be computed by solving a dynamic OP of following form: The performance indexJ in (2a) to be minimised is comprised of the terminal cost function ϑ and the intermediate cost term φ. Equality constraint (2b) ensures that the system equations (1) are satisfied. General equality constraintsc ∈ R n c and inequality constraintsh ∈ R n h are included via (2c) and (2d), respectively. Solving the dynamic OP (2) analytically is generally only possible for simple problems. Thus, dynamic OPs are mostly solved numerically via direct or indirect methods (Sedlacek et al., 2020c). While direct methods solve the original OP, indirect methods deduce a boundary-value problem which is analytically derived from the optimality conditions. A discretisation of trajectories via collocation or shooting can be used to obtain a static OP. Collocation methods employ decision variables for the inputs and states at discrete time points and deduce the trajectory via polynomial interpolation between these points. Single shooting methods only employ decision variables for the inputs and compute the corresponding state trajectories via numerical integration. Multiple shooting methods divide the time interval into subintervals on which the numerical integration is performed. The states at the interval margins represent additional decision variables and continuity constraints are introduced to ensure that the boundary points of the individual integration segments coincide. A direct collocation method is employed in this article due to the simpler initialisation of direct methods and the increased sparsity of collocation methods.

Problem formulation
Using separated Hermite-Simpson collocation with a discretisation into n seg segments yields n pts = 2n seg + 1 collocation points and thus the vector of decision variables The SSC procedure is applicable to NLP problems of the form with indices i ∈ I := {i = 0, 1, 2, . . . , n seg − 1} and k ∈ K := {0, 1 2 , 1, . . . , n seg } representing the corresponding collocation segment and collocation point, respectively. Objective (4a) is assumed to be quadratic and convex in the decision variables with r 0 ∈ R, q 0 ∈ R n w and 0 ≤ P 0 ∈ R n w ×n w . The positive semi-definiteness of P 0 concludes the convexity of the objective. Collocation constraints (4b) ensure that the system equations (1) are satisfied. For Hermite-Simpson collocation, these equality constraints are given by (Betts, 2010;Kelly, 2017). The SSC approach considers nonlinear right-hand sides of the form with A ∈ R n x ×n x , B ∈ R n x ×n u and k, f pwl ∈ R n x . Therein f pwl represents a composition of univariate nonlinearities that can be depicted or approximated by piecewise linear curves. For simplicity, it is assumed that the remaining equality constraints (4c) are affine in the decision variables. The inequality constraints (4d) are required to be convex in the decision variables. However, aiming at constructing a QP problem, it is assumed below that the inequality constraints are even affine. This stricter assumption can be posed without loss of generality, since convex inequality constraints can be approximated via a polyhedron using multiple affine functions (Boyd & Vandenberghe, 2004, p. 32). The inequalities (4e) depict ZCSs, which are nonconvex sets that can be split into convex subsets.

Successive convexification procedure
Considering the standard form of convex OPs (Boyd & Vandenberghe, 2004, p. 136), all equality constraints must be affine in the decision variables to enable the convexity of the problem. Hence, a nonlinear right-hand side of the system equations (1) results in nonlinear equality constraints (5), yielding a nonconvex OP. Furthermore, the nonconvex inequality constraints (4e) also prohibit a convex problem. The SSC algorithm iteratively solves a convex substitute problem which is derived from the original problem (4) as schematically illustrated in Figure 1. The core idea of this concept is considering the transformed problem (15) which represents a piecewise linear approximation of the original problem (4). This transformation is achieved by introducing space splitting constraints. These constraints are nonconvex but render the original constraints convex. Furthermore, they possess an advantageous structure which is exploited by the algorithm. In order to deal with the remaining nonconvexity, the nonconvex space splitting constraints are transferred to the objective following the theory of exact penalty functions. The resulting problem (19) possesses a convex feasible set but a nonconvex objective. Thus, the nonconvex part of the objective is iteratively linearised around points that are adjusted based on the previous iterate using an intermediate projection routine. This yields the convex problem (22), which is sequentially solved within the SSC algorithm. A smoothable absolute value function is introduced which recovers the true absolute value for ε s = 0. The intermediate OPs (15) ε and (19) ε depicted in Figure 1 apply ε s > 0 to provide continuous differentiability for the validity of the optimality conditions legitimising the application of exact penalty functions. Afterwards, this smoothing is removed since it represents an approximation which is not required in problem (22) for continuous differentiability. The subsequent sections describe the problem transformation process in more detail.

Space splitting constraints
Before presenting the individual OPs, the basic principle for the space splitting of a decision variable is illustrated in this section providing graphical support. If collocation is used, the inputs as well as states represent decision variables. Thus, the input space and the state space can be split. The splitting procedure is presented using w ∈ W := [w, w] as a representative decision variable which is split at the transition point w = w tr . As illustrated in Figure 2(a), the auxiliary decision variables w low ∈ W low := [w, w tr ] and w up ∈ W up := [w tr , w] are introduced aiming at satisfying the following relations: Proof: Solving (9a) for one of the auxiliary decision variables yields Inserting (10a) into (9b) results in Thus, constraints (9) ensure the desired splitting according to (8).
The AVC (9b) is relaxed into a convex inequality constraint which can be depicted using two linear inequality constraints Furthermore, the linearisation of the AVC based on the result of the preceding iteration w prev is added as an additional objective term in form of an exact penalty function J g := τ l abs (11c) with penalty parameter τ . Considering (11b), the linearisation breaks down to choosing the sign σ w of the absolute value based on the previous solution w prev .Furthermore, the projection of the previous solution onto the constraints in (9) follows from (8) and provides the initial solution, marked as( ·), for the subsequent iteration: The projection step is depicted in Figure 2(c) for an initial guess with a different sign than the computed solution: sign(w prev ) = sign(w prev ). For a graphical interpretation, the additional cost term (11c) can be replaced by an additional relaxed equality constraint with the slack variable s w ≥ 0 being minimised via a penalty objective: Since adding slack variables increases the number of decision variables, this is not desirable from an implementation standpoint; however, it fosters comprehension. The relaxation of constraint (13a) via the slack variable s w is necessary to avoid infeasibility, which is illustrated in Figure 2(b): Since g abs = w − |w| ≥ 0 holds, an unrelaxed constraint (13a) with s w ≡ 0 would only allow values satisfyingw ≤ 0 for σ w = −1 and only valuesw ≥ 0 for σ w = 1. However, the sign is based on the previous iteration and can thus be wrong. Then, a relaxation represented by the slack variable is necessary to allow valuesw of the opposite region and avoid infeasibility. The sign is corrected for the subsequent iteration step to enable eradicating the additional objective (13b) and thus the slack variable. This concludes that the initial solution does not have to represent a feasible solution, which results in robust initialisation behaviour. The relaxation via the slack variable s w in (13a) corresponds to the violation of constraint l abs via (11c). The fact that the constraint violation will be large in case of a wrong sign is used as feedback for the algorithm. The algorithm will iterate until a feasible point satisfying l abs ≈ 0 ≈ s w is reached. Then, the additional objective (11c) vanishes.

Piecewise linear approximation of optimisation problem
The first step towards a convex OP is the derivation of a piecewise linear approximation of the original problem (4). This is achieved by using the concept of space splitting presented in the previous section. Since multiple decision variables can be split, the formulation of the OP is posed using the augmented vector of decision variables with the auxiliary decision variables w aux,k ∈ R n s . Therein some of the original states and inputs are excluded when they are depicted using affine transformations as illustrated in Section 2.3.1. The corresponding substitute problem is given for Therein α(·) : R n s → R n s represents a function which applies the smoothable absolute value function (7) to each vector component individually: No smoothing occurs for ε s = 0. Furthermore, the right-hand side of the system equations (6) is depicted or approximated by the affine expression with u : R n z → R n u and x , pwl : R n z → R n x representing functions which are affine in the decision variables. Thus, (16) enables affine collocation constraints (15b). The transformation function (z) in problem (15) represents the accumulation of the affine transformations x and u with n = (n x + n u )n pts yielding withÂ ∈ R n ×n andb ∈ R n inserting the affine mapping (17) into the affine constraints (4c) and (4d) results in the affine constraints (15c) and (15d), respectively (Boyd & Vandenberghe, 2004, p. 79). Furthermore, the auxiliary variables are used to represent the ZCSs (4e) using convex functionsĥ zcs in (15e). In order to get a QP problem, these constraints are assumed to be affine or approximated by affine inequality constraints. The application of space splitting for the convexification of the original constraints will be shown in more detail in Section 2.3. The splitting constraints (15f) and (15g) represent the constraints (9a) and (9b), respectively. These constraints are necessary to ensure that problem (15) correctly represents the original problem (4). They implement a bisection of selected decision variables at predefined transition values which are stored in the vector w tr . The matrices E ,k , E ,k and E z,k are selection matrices extracting the desired decision variables. It is assumed that n s 2 decision variables are split at each collocation point.
Depending on the individual approximations of the nonlinear constraints, the piecewise linear representation is subject to some error. The approximation error of this substitute problem is defined beforehand by the implemented number of space subdivisions. If the original problem is piecewise linear, this substitute problem can be an exact representation.
Remark 2.1: Let f nl (w) represent a nonlinearity within a constraint depending on the decision variable representative w, as depicted in Figure 3. Then, the total absolute error of the piecewise linear approximation p pwl (w) is given by the sum of absolute errors at each collocation point of the decision variable: An adequate number and position of knot points for the segmentation into piecewise linear parts achieve sufficiently small approximation errors. However, a higher number of splitting segments increases the size of the OP influencing the computation time.

Nonconvex optimisation problem with convex feasible set
The absolute values in equality constraint (15g) still prohibit convexity. Deploying the theory of exact penalty functions (Di Pillo & Grippo, 1989;Han & Mangasarian, 1979), the absolute value equality constraints are moved to the objective without compromising optimality: 19d) with λ representing the Lagrangian multipliers of the corresponding equality constraints. Since a L 1 −norm is an exact penalty function, z is a critical point of problem (15) for ε s > 0 and sufficiently large but finite penalty weights τ ≥ λ ∞ .

Proof:
The prerequisite for the optima recovery is that the optimality conditions are admissible for problem (15) (Nocedal & Wright, 2006, p. 507). For this purpose, the linear independence constraint qualification (LICQ) (Nocedal & Wright, 2006, p. 320) is analysed subsequently. Since the transformation (z) in (17) is affine, the gradients of the transformed basic constraints (15c) and (15d) remain linearly independent if the original constraints c(w) : R n w → R n c and h(w) : R n w → R n h are linearly independent. This can be verified for i ∈ {1, . . . , n_c} and j ∈ {1, . . . , n_h} via The gradients of the splitting constraints (15f) and (15g) are by definition linearly independent from each other and from the remaining constraints. Furthermore, it can be assumed without loss of generality that the gradients of the collocation constraints (15b), of the basic constraints (15c)-(15d) and of the ZCS-constraints (15e) are linearly independent. Thus, if the LICQ holds for the original problem (4), then it is also satisfied by the problem (15). By choosing a sufficiently small but positive smoothing parameter 0 < ε s 1, the prerequisite of continuous differentiable objective and constraint functions is given while approximation errors are kept small. Thus, the optimal solution will satisfy the Karush-Kuhn-Tucker conditions (Nocedal & Wright, 2006, p. 321).
Constraints (19d) are added to enable omitting the norm in the objective as illustrated in (19a). Since g abs,k is a vector of concave functions, the AVCs (19d) represent a convex set. Thus, the feasible set of OP (19) is convex.

Convex optimisation problem for iterative solution
From Theorem 2.1 follows that solving (19) provides the solution for problem (15) assuming ε s > 0. Unfortunately, the augmented objective (19a) is nonconvex, which will be addressed via linearisation. Subsequently, the smoothing is removed by setting ε s = 0 since it will not be required for continuous differentiability. Omitting the smoothing represents an approximation to the smoothed version of (19); however, it is beneficial from a practical standpoint since the splitting constraints are exact for ε s = 0. Furthermore, it enables representing the AVCs (19d) by two affine inequalities which yields exclusively affine constraints required for an LP and QP problem. For a convex OP, the absolute value of the AVCs in the augmented objective is linearised around the pointsz k ∈ R n s yielding the linearised constraints which represent (11b), with the linearisation points being stored in matrix Comparing (15g) and (21a) shows that the linearisation breaks down to a binary decision: choosing the correct sign of the absolute value termz k . The linearisation (21a) is affine in the decision variables. Since the sum of convex functions preserves convexity (Boyd & Vandenberghe, 2004, p. 79), the composite objective function is then convex in the decision variables. With all constraints being affine, using linearisation (21a) results in the convex QP problem For linear objectives J(w), the SSC approach results in a LP problem. The convex problem (22) is iteratively solved, whereas the linearisation points in are updated based on the solu- However, the question arises if replacing the constraint g abs in the objective with its linearisation l abs falsifies the solution. This motivates the following lemma: Lemma 2.2: The satisfaction of h abs,k (z) ≥ 0 and l abs,k (z,z k ) = 0 concludes g abs,k (z) = 0, independently of the linearisation pointz k .
Proof: This can be verified using Figure 2(b) as graphical support. For this purpose, the following equations are given in general notation and are compared with the equations from the illustrative example in Section 2.2.1 using the vector of decision variables z ex = [ w w up w low ] T . The nonsmoothed absolute value constraint g abs,k,j spans the following set of points: with e T ,k representing the jth row of matrix E ,k . The admissible points for the AVC-linearisation l abs,k,j are given by representing the infinite extension of the positive and negative branch of the AVC forz k,j , σ w ≥ 0 andz k,j , σ w ≤ 0, respectively. Then, the intersection with the admissible points of the inequality constraint h abs,k,j which represent the negative and positive branch of the AVC and are thus a subset: This important lemma ensures that convergence of problem (22) to a solution which satisfies the linearised constraints l abs,k (z,z k ) = 0 also fulfils the original nonlinear constraints g abs,k (z) = 0 in (15g).

Space splitting convexification algorithm
Subsequently, the SSC algorithm 1 is presented in detail and the proof of its convergence is provided. The algorithm inputs are described in line 1. An initial solution for the inputs U 0 ∈ R n u ×n pts and states X 0 ∈ R n x ×n pts must be provided. The algorithm iteratively solves the convex problem (22) using the solution of the previous iterate to correct the signs of the linearisation if necessary. The algorithm terminates when all signs are chosen correctly or the maximum number of iterations q max is reached. Thus, if the algorithm converges before reaching the maximum number of iterations q < q max , the largest constraint violation is smaller than a small value l abs ≤ ε g with 0 ≤ ε g 1. As already mentioned, the violation of the linearised AVCs indicates that a wrong sign was chosen. The reason why the constraint violations are a suitable feedback for correct sign selection can be visualised using Figure 2(b). The signs and thus the linearised constraints l abs,k,j in the objective (22a) are fixed before optimisation. Then, running into the region ofw =z k,j with the opposite sign requires increasing w =e T ,k w aux,k due to the constraints h abs =h abs,k ≥ 0, which in turn increases the linearised constraints in the objective. Based on the solution of the preceding iteration, the updating routine in line 7 adjusts the convex QP problem (22) to satisfy (15f)-(15g) using the projection procedure (12): The update routine computes the projected initial solutionZ and the correct Algorithm 1 Space Splitting Convexification: a procedure for iterative optimisation.

1: INPUTS:
(1) U 0 , X 0 : initial solution for input and state decision variables (2) q max : maximum number of iterations (3) ε g : error tolerance for linearised absolute value constraints (AVC) (4) τ , τ : weight bounds for penalty objectives 2: OUTPUT: U , X : system solution within tolerance ε g 3: MAIN FUNCTION: 4: q = 1, l abs = ∞ 5: while q ≤ q max and l abs > ε g do 6: τ = τ −τ qmax · q + τ // weight for additional objectives 7: [ ,Z] = updateQP(U q−1 , X q−1 ) // linearisation and initialisation 8: 10: q = q + 1 11: end while 12: U = U q , X = X q // output final solution signs for the linearisation of the AVCs. Afterwards, the optimiser is invoked in line 8 to solve the convex QP problem or LP problem if the main objective is linear. The theory of exact penalty functions states that the penalty parameter τ must be larger than the largest optimal dual variable of the corresponding constraints. Since estimating the limit value for the penalty parameter is a rather complicated task, Algorithm 1 pursues the straightforward approach in line 6 of gradually increasing the penalty parameter up to a high value. A reasonably high but finite upper bound on the penalty parameter τ avoids numerical problems. Although this is not the best updating approach, it can work well in practice (Nocedal & Wright, 2006, p. 511) as it is the case for the examples considered in this article. Finally, the following theorem verifies that the algorithm produces a sequence of solutions which eventually converges to a local solution satisfying the AVCs: Theorem 2.2: Let the feasible set of problem (22) be denoted with which is a convex set. Starting from a point z (0) , Algorithm 1 generates a sequence {z (q) } according to with J tot being a convex function. This sequence eventually converges to a limit point z which satisfies g abs,k = 0 ∀ k ∈ K.
Proof: Algorithm 1 iteratively solves problem (22) and gradually increases the penalty parameter up to a finite value τ ≤ τ . Let the condition τ ≥ λ ∞ mentioned in Theorem 2.1 hold for q ≥ Q λ ∈ N. Then, the theory of exact penalty functions states that l abs,k = 0 ∀ k ∈ K is satisfied for all q ≥ Q λ . As described in Lemma 2.2, this concludes that only solutions on one branch of the AVCs are admissible. Thus, no sign changes ofz k,j =w are possible for q ≥ Q λ . This concludes that the linearisation points of l abs,k ∀ k ∈ K and thus OP (22) remain unchanged for q ≥ Q λ . The convexity of the problem entails that only one optimum exists yielding This concludes that for every ε τ > 0, there is a Q ∈ N such that z := z (n) − z (m) < ε τ for every n, m ≥ Q since (28) holds at the latest from the value Q = Q λ with z = 0 < ε τ . This proves that (26) is a Cauchy sequence and thus converges (Zorich, 2016, p. 85). Hence, the solutions of the individual iterations can oscillate; however, this oscillation vanishes with an increasing number of iterations finally converging to a single point z . Due to Lemma 2.2, l abs,k = 0 ∀ k ∈ K concludes that this point satisfies g abs,k = 0 ∀ k ∈ K.
Theorem 2.2 concludes that the iterative solution of OP (22) within the SSC algorithm basically solves the OP (15) with ε s = 0: From convergence to l abs,k = 0 ∀ k ∈ K follows that the computed solution satisfies g abs,k = 0 = h abs,k ∀ k ∈ K and the augmented objective term vanishes. The remaining constraints of problems (15) and (22) are identical. Thus, the SSC algorithm computes a solution that is arbitrarily close, but not necessarily identical, to the solution of the piecewise linearly approximated problem (15). The potential discrepancy in solutions is rooted in the necessity to smoothen the problem (15) with ε s > 0 for the admissibility of the optimality conditions in Theorem 2.1. Since the linearisation removes the discontinuity, the smoothing is disregarded within the SSC algorithm. From a practical standpoint, the discrepancy is negligible since the smoothing parameter can be assumed arbitrarily small ε s → 0 making the impact of the smoothing numerically irrelevant. This procedure for the approximation of discontinuities in optimal control problems is common practice, see e.g. (Perantoni & Limebeer, 2014). In summary, the SSC approach chooses one branch of the discontinuity, resulting in the continuously differentiable problem (22) with ε s = 0, and switches in the following iterations to the other branch if the wrong side of the discontinuity was selected.

Constraint convexification via space splitting
The previous sections derived the basic structure of the convex OP (22a), which is solved in an iterative manner. However, the question of how the original constraints can be convexified via space splitting to gain the convex constraints (15b)- (15e) is still open. The basic procedure of bisecting the space of a variable into two subdomains has been illustrated in Section 2.2.1. This can be employed to consider ZCSs and equality constraints with univariate nonlinearities in a convex manner, which is demonstrated in Sections 2.3.1 and 2.3.2, respectively. Subsequently, the index for the collocation discretisation k ∈ K is omitted for readability.

Convexification of zonally convex sets
One prominent physical example of ZCSs are constraints ensuring semi-activity. Semi-active actuators like limited slip differentials and semi-active dampers are used in many engineering applications due to their good compromise between low energy consumption and high performance (Savaresi et al., 2010;Sedlacek et al., 2020aSedlacek et al., , 2020c. A typical ZCS for a semi-active damper is depicted in Figure 4(a) with damper force F d = u and damper velocity v. The nonconvexity of the set is apparent considering that it is easy to draw a line that contains nonadmissible points and connects an admissible point in the first quadrant with an admissible point in the third quadrant. Note that simply linearising the inequality constraints depicting this nonconvex set results in a half-plane, which represents a poor approximation of the set. The main idea for the novel convexification approach is appropriately decomposing nonconvex sets, described in the original decision variables, into convex subsets using auxiliary decision variables. The applicability of the SSC method to the ZCS types depicted in Figure 4 is proven in the subsequent paragraphs.
The approach is initially illustrated using the ZCS depicted in Figure 4(a). Let the convex subset in the first and third quadrant be given by and (29a) respectively. Therein v and u are original decision variables. Moreover,ĥ zcs,p ≤ 0 andĥ zcs,n ≤ 0 are convex sets. The union of convex sets does not necessarily result in a convex set. As illustrated in Figure 4(a), the union S = S p ∪ S n is assumed to be nonconvex in this article. Thus, S is a nonconvex set comprised of convex subsets: a ZCS. The velocity v is split at v = v tr = 0 by a vertical line following Lemma 2.1. The two auxiliary vari- Introducing analogous constraints to (9a) and (11a) as well as additional objective terms in form of (11c) ensures the relations in (30). Furthermore, the auxiliary variables u n ∈ U n := [u, u tr ] and u p ∈ U p := [u tr , u] are introduced for the individual subsets. Therein u tr represents the ordinate value of the common point, which lies on the origin in the current example depicted in Figure 4(a) resulting in u tr = 0. However, the common point of the subsets is not required to lie on the abscissa or ordinate. The vector of auxiliary decision variables is given by w aux = [ v p v n u p u n ]. While the original state variable v remains a decision variable in the problem, the input variable is replaced according to the transformation which is affine in the decision variables. The convex subsets in terms of the auxiliary decision variables are given bŷ Hence, the convex subsetsŜ p andŜ n are now defined for separate decision variables and will be linked via the affine mapping (31). This enables the formulation of convex constraints as depicted in problem (15). The proof that this procedure produces the same set as S will be given in Theorem 2.3. For convexity,ĥ zcs,p andĥ zcs,n in (32a) and (32b) must be convex functions. As exemplarily illustrated in Figure 4(a), the convex subsets are assumed in this article to be representable by n zcs = n zcs,n + n zcs,p affine inequality constraintŝ with A zcs,p ∈ R n zcs,p ×2 , b zcs,p ∈ R n zcs,p , A zcs,n ∈ R n zcs,n ×2 and b zcs,n ∈ R n zcs,n . These constraints represent (15e) in the convex OP. Although nonlinear, convex functions forĥ zcs,p and h zcs,n would not prevent convexity, introducing such constraints would prohibit an LP or QP problem, which can be solved especially efficiently. Asymmetric subsets like the one illustrated in Figure 4(a) can be easily implemented by using varying coefficients in (33a) and (33b) or by using different domains for U n and U p .

Theorem 2.3:
The subsets (32a) and (32b) in combination with the affine mapping (31) depict the set S which is given by the union of the convex subsets (29a) and (29b).
Proof: For proving that the splitting approach provides sets that depict the original one, the individual cases for the bisected variable space are considered subsequently.
Thus, v n = v tr holds according to Lemma 2.1. This concludes u n = u tr since the subsets converge to the common point (u tr , v tr ) when leaving the subset towards the other subset. Lemma 2.1 also concludes v p = v. Then, the affine mapping (31) is given by u = u p ∈Ŝ p .
For v > v tr , S = S p holds. Since v p = v, u ∈ S p and u ∈Ŝ p provide the same feasible set. The chain of conclusions for the remaining cases follows the same reasoning but is given below in equations for conciseness.
Thus, inserting the affine mapping (31) into the constraints while replacing the original set S with the sets (32a) and (32b) yields the same feasible set.
The presented proof requires a space splitting of the variable v which is represented by splitting the convex subsets via a vertical line. Thus, the SSC approach is capable of convexifying two-dimensional ZCSs, which can be divided into two convex subsets connected in a single point using any vertical line. Following theorem is added to show that this also holds for any splitting line which is straight but possibly rotated:

Theorem 2.4: Space splitting applied to a rotated, twodimensional ZCS also results in convex constraints.
Proof: This can be verified by applying the previously described procedure to a rotated coordinate frame, exemplarily depicted in Figure 4(b). The auxiliary decision variables need to split the rotated two-dimensional space spanned by the variables v and u. Assuming the coordinate system is rotated by the angle ϕ with counter-clockwise rotations depicting positive rotations, following relations hold between the original coordinates v−u and the rotated coordinates v − u: The vector of auxiliary decision variables is chosen as w aux = [ v p v n u p u n ]. For a concise notation, the equations below use the abbreviations c ϕ := cos(ϕ) and s ϕ := sin(ϕ). Constraints (33) are analogously formulated on the rotated, auxiliary decision variables:ĥ zcs,p (u p , v p ) andĥ zcs,n (u n , v n ). However, an adjustment using (35) is necessary for the constraints (9a), (11a) and (11b) as well as the input mapping (31): Since the angle ϕ is constant, the trigonometric functions represent constant values. Thus, a rotated space splitting procedure also yields affine constraints and mappings enabling the formulation of a convex OP.
The previous theorems required the subsets to be connected in a single point. Following theorem states that the SSC approach can be used to approximate ZCSs which share a line of points:

Theorem 2.5: When a two-dimensional ZCSs is comprised of two convex subsets sharing a line of points, the SSC approach can only approximate the original set however with sufficiently small approximation error.
Proof: Without loss of generality, this can be analysed considering Figure 4(c) as example. For the depicted case, the transition line lies on the ordinate v tr = 0. Analysing the individual cases shows that using the original subsets within the SSC approach would yield a larger set than the original set: Thus, using the original subsets can render non-admissible points of the original problem admissible. When the input variable is replaced by the auxiliary inputs according to (31), both sets must be adjusted at the transition line v = v tr . The simplest set adjustment is enforcing u n = 0 = u p at the transition axis, as illustrated in Figure 4 by the dotted lines. Then, the subsets are connected in a single point enabling the application of Theorem 2.4. However, other set manipulations are possible and can be numerically better. Generally, such set approximations introduce conservativeness for the sake of feasible trajectories. However, the introduced error is negligible when the removed area is sufficiently small which can be implemented by choosing steep linear constraints at the transition between the subsets.

Remark 2.2:
In this article, only two-dimensional ZCSs which can be split into two convex subsets have been considered. However, the SSC approach can be applied to certain twodimensional ZCSs with more than two subsets. For instance, consider three convex subsets positioned horizontally to each other, whereas each subset is connected to the next subset in a single point on the abscissa. This can be verified using the procedures described previously in this section.
This section illustrated the convexification procedure for ZCSs in regards to inputs. This results in the depicted affine input transformation u . Implementing the approach for a ZCS with state decision variables yields an affine transformation x . This procedure can be applied to multiple inputs and states. The corresponding vector functions for the affine transformations are given by with u,i and x,j representing the transformation for the individual input and state, respectively. If no transformation is necessary, a direct mapping is implemented according to u,i = u i and x,i = x i . The vectors of transformations (38) are used to generate in (17) which is used for the convex depiction of the original constraints in (15b)-(15d).

Convexification of nonlinear equality constraints
Some nonlinearities in physical systems are characterised by a univariate function. Examples are nonlinear springs, saturation, dead-zones or the tire force shape curve of vehicles. Since nonlinear system equations yield nonlinear thus nonconvex equality constraints, this section presents how such nonlinear univariate terms can be convexified. The nonlinear univariate curve is depicted using piecewise affine parts. Hence, if the nonlinearity is not a piecewise linear function, SSC introduces approximation errors. The subsequent paragraphs illustrate the application of the SSC algorithm for convexifying piecewise linear nonlinearities.

Theorem 2.6: The splitting constraints in (9) can be used to convexify equality constraints by transforming a univariate nonlinearity with two piecewise linear segments into an expression which is affine in multiple decision variables.
Proof: Proof is provided using the piecewise linear curve depicted in Figure 5(a) as example, which represents a typical function for piecewise linear springs. Assuming the position x is a state of the system, it represents a decision variable which will be split at the transition point x = x tr < 0. Thus, the auxiliary position variables x low ∈ X low := [x, x tr ] and x up ∈ X up := [x tr , x] are introduced. By including analogous constraints to (9a) and (11a) as well as additional objective terms in form of (11c), following relations are ensured using Lemma 2.1: Hence, the piecewise linear function can be represented by the expression which is affine in the decision variables w aux . The relations in (39) yield following two segments for the piecewise linear function (40): Thus, (41a) and (41b) depict the upper and lower segment of the nonlinearity, respectively.
Since (40) is an affine function in the decision variables, it can be inserted into the differential equations without preventing convexity. The subsequent theorem proves that this approach can be extended to univariate nonlinearities with more than two piecewise linear segments: Theorem 2.7: A repeated application of the space bisection approach using the splitting constraints in (9) can be used to convexify equality constraints by transforming a univariate nonlinearity with more than two piecewise linear segments into an expression which is affine in multiple decision variables.

Proof:
The general procedure for this extension is illustrated using the piecewise linear curve depicted in Figure 5(b). The position x is split at the transition points x = x tr < 0 and x = x tr > 0. Thus, the auxiliary position variables x low ∈ X low := [x, x tr ], x low ∈ X low := [x tr , x], x mid ∈ X mid := [x tr , x tr ] and x up ∈ X up := [x tr , x] are employed. The space is repeatedly bisected following Lemma 2.1 to gain x tr else (42a) which is depicted in Figure 5. Thus, the position space is bisected into a region below and a region above x = x tr whereas the upper region is again bisected into a region below and above x = x tr . The piecewise linear function can then be represented by the expression which is affine in the decision variables w aux . The relations in (42) yield following three segments for the piecewise linear function (43): Hence, (44a), (44b) and (44c) depict the upper, mid and lower segment of the nonlinearity, respectively.
This repeated bisection procedure enables the generation of a characteristic curve with an arbitrary number of segments. However, an increasing number of segments also increases the number of auxiliary decision variables and additional constraints making the OP larger.
The approach presented in this section yields a scalar function pwl which is affine in the decision variables. The procedure can be applied to multiple univariate, nonlinear terms yielding further scalar mapping functions. The affine vectorvalued function in (16)

Remarks on runtime
The application of optimisation methods within a real-time capable controller generally requires upper bounds on the necessary computation time. The SSC approach runs through a loop which is comprised of a projection step and an optimisation step resulting in the following theorem regarding computational complexity: Theorem 2.8: The computational complexity of the SSC algorithm is polynomial.
Proof: SSC solves a sequence of LP problems or convex QP problems, which are known to be solvable in polynomial time (Karmarkar, 1984;Kozlov et al., 1980). The projection step (12) of the SSC algorithm uses minimum and maximum functions which possess linear time complexity. This concludes a polynomial time complexity of the SSC algorithm: Therein n can be interpreted as the number of operations required by the algorithm. The parameters in (46) depend on the utilised solver as well as the number of decision variables which is problem specific. Limiting the maximum number of superordinate iterations to q ≤ q max enables terminating the algorithm prematurely at suboptimal solutions, if necessary.
Theorem 2.8 provides valuable insight for the application in a real-time capable controller. Firstly, a worst-case bound on computation time can be experimentally identified for the specific OP and solver. Secondly, the computation time scales well with increasing problem size. Since the number of superordinate SSC iterations is rather low in practice, this results in a fast solution of optimal control problems. Finally, the influences on computation time are summarised below: (1) System and discretisation. The number of decision variables increases with rising number of inputs, states and collocation segments for both the original and the convexified OP. This increases computation time for NLP methods and the SSC algorithm. Due to the polynomial complexity, this increase in time will be generally less for SSC than for NLP. (2) Nonlinearity. The more complicated the nonlinearity, the more splitting segments are required to reduce approximation errors. However, the space splitting increases the problem size compared to the original problem, which influences the variable n in (46). This can put a practical bound on the number of space divisions via the SSC approach. Nevertheless, many physically motivated nonlinearities can be approximated sufficiently well using a moderate number of affine segments. (3) Initial guess. Being a local method, the solution computed by the SSC approach depends on the provided initial solution. Furthermore, this initial guess can influence the order of sign-corrections regarding the AVC-linearisations, which can impact the number of superordinate iterations and, therefore, the convergence rate. For MPC frameworks, the optimal solution of the preceding time step often represents a good initial guess (Gros et al., 2020) promising low computation times. (4) Penalty parameter update. Too small or too large penalty parameters can slow down convergence (Nocedal & Wright, 2006, p. 511). The straightforward approach of gradually increasing the penalty parameter is used in this article. However, more sophisticated routines have been proposed in Mayne and Maratos (1979) and Maratos (1978).

Comparison with existing methods
In order to highlight the novelty of the proposed algorithm, this section compares the SSC approach with the most related existing methods. From an algorithmic standpoint, linearising only the nonconvex part of constraints combined with a relaxation and an increasing objective term penalising constraint violations corresponds to penalty CCP (Lipp & Boyd, 2016). CCP has the advantage over SQP and other linearisation techniques that it retains more problem information in each iterate: The information of the convex parts is kept and only the concave portions are linearised. Furthermore, CCP does not require to use line-search procedures or limit the progress in each iteration via trust-region methods. Inspired by Mangasarian (2015), the SSC approach avoids additional slack variables by considering the linearised constraints directly in the penalty objective. This avoids further increasing the size of the OP as in penalty CCP. Moreover, SSC employs an intermediate projection to enhance convergence. While CCP linearises the concave part of all nonconvexities, SSC transforms the problem beforehand requiring only the linearisation of AVCs. This enables providing a feedback about the correctness of the selected linearisation points, which are subsequently adjusted. Thus, the linearisation error can vanish completely after the correct signs have been chosen. The binary nature of the linearisation facilitates a rapid convergence in a small number of superordinate iterations. Although the SSC method only computes solutions to the piecewise linear approximation of the original problem, the approximation can be designed to sufficient accuracy enabling small and known approximation errors. Especially the straightforward linearisation of ZCS-constraints yields very poor approximations, which can contain a large set of infeasible points. Thus, the vanishing AVC-linearisation errors result in an advantage of SSC regarding accuracy, also over further linearisation techniques like the ones presented in Mao et al. ( 2016Mao et al. ( , 2017. Generally, a scalable trade-off between accuracy and size of the OP, thus computation time, can be chosen. Opposed to Lipp and Boyd (2016), this article provides a convergence proof, even if only converging to the solution of the approximated problem.
While LC possesses the advantage of avoiding approximation errors, it is only applicable to OPs with annulus-like, nonconvex sets resulting from excluding a convex subset from a convex set (Raković & Levine, 2018, p. 340). Opposed to that, SSC provides a method for the convexification of ZCS which cannot be considered via LC.
Similar to the LnP approach presented in Mao et al. (2017), the SSC method is an iterative linearisation algorithm using intermediate projection steps. The updating routine for SSC is of linear computational complexity with few and simple mathematical operations. The projection step of the LnP approach generally requires the solution of a convex programming problem, which is of polynomial complexity at best. Thus, the projection step used by the SSC approach is computationally less costly, which is beneficial for splitting methods (Ferreau et al., 2017). Additionally, the binary nature of the AVClinearisation provides the advantage that generally only few superordinate iterations are required, resulting in short computation times. Moreover, SSC is more robust regarding the initialisation since the LnP approach requires an additional lifting procedure to cope with arbitrary initialisations, which costs computation time (Mao et al., 2017). Furthermore, the LnP method requires the right-hand side of the system equations to be convex and the inequality constraints to be concave. However, nonconvex collision avoidance constraints can be easily considered via the LnP approach, whereas the SSC procedure requires further measures.
The ADMM is a splitting procedure utilising the augmented Lagrangian method instead of the exact penalty function method, which is employed by the SSC algorithm. Due to the alternating approach, the ADMM requires the solution of two QCQP problems in each iteration. The SSC approach only requires the solution of a single convex QP problem in each iteration, which is beneficial for computation time.
The spatial BnB method also uses space decomposition for the convexification of the optimisation problem. However, the SSC approach solves a piecewise linear approximation of the original problem, which is iteratively adjusted, on the full space domain of the decision variables. Opposed to that, the BnB method solves multiple OPs which represent convexly relaxed versions of the original problem on separate subdomains of the decision variables. BnB techniques determine upper bounds by evaluating the objective function at a feasible point. Since the problem is generally nonconvex, finding a feasible point can be difficult. This is often tackled by solving the nonconvex subproblem locally, which is computationally expensive (Liberti & Maculan, 2006, p. 253). Thus, the convergence rate of the SSC approach is most likely to be superior if sufficiently good initial guesses are provided. However, this depends on the nonlinearities of the OP, which influence the number of decision variables for SSC but also for BnB approaches which decompose factorable functions (Tawarmalani & Sahinidis, 2002, p. 125). Moreover, SSC only guarantees to find local optima of an approximation of the OP and is only applicable to certain classes of OPs. GO techniques cover a wide range of applicability and provide the global optimum.

Applications
In this section, the proposed SSC algorithm is evaluated using a hanging SMO example with piecewise linear spring and semiactive damping as illustrated in Figure 6. Semi-active dampers can only generate a force in the opposite moving direction and cannot impose a force at steady-state complying with the passivity constraint (Savaresi et al., 2010, p. 16). Hence, the admissible set for semi-active dampers always contains a subset in the first quadrant and a subset in the third quadrant which are connected in a single point, namely, the origin. A performance-oriented OP is formulated and solved using NLP and SSC, respectively. The results of both algorithms are compared regarding accuracy and computation time. Both problems are posed using the modelling language JuMP (Dunning et al., 2017) for mathematical OPs. For a fair comparison, the necessary derivatives are computed beforehand via automatic differentiation. Furthermore, the tolerances for constraint feasibility and objective improvement are set to 10 −6 for both solvers. The utilised parameters are listed with description in Table 1.
The NLP problem is solved using the optimiser IPOPT (Wächter & Biegler, 2006), which employs an interior-point method: Using the concept of barrier functions, a sequence of relaxed problems is solved for decreasing values of barrier parameters. The barrier parameter relaxes the inequality constraints and hence represents the distance from the current iterate to the border of the admissible set. Thus, interior-point methods use a central path within the admissible set as opposed to SQP-methods which wander along the border. The resulting nonlinear equation system is solved via a damped Newton method. Furthermore, a filter line-search method, heuristics and further correction measures are employed to enhance convergence and robustness.
The novel SSC method transforms the OP into convex QP subproblems which are solved iteratively. In order to capitalise on this problem structure, the elaborate optimiser Gurobi (Gurobi Optimization, 2020) is selected.

Optimisation problems
The equations of motion for the state vector with x, v, F d and F c denoting the deflection position, deflection speed, damper force and spring force, respectively. The expression of these forces differs for the NLP method and the SSC approach. Starting from a specified initial state x iv = [x iv v iv ] T with damper force F d,iv = dv iv , the goal is to minimise the deviation from the steady-state position x ss while considering the limitations of the system. Applying Simpson quadrature (Betts, 2010;Kelly, 2017), the main objective penalises the steady-state position deviation e ss,j := x j − x ss according to Considering the values listed in Table 1, the steady-state position can be computed using a root-finding approach like Newton's method: At steady-state position, the gravitational force must equal the spring force. For the considered nonlinear springs with two piecewise linear segments the value x ss = x ss,2 is chosen and x ss = x ss,3 if the spring with three segments is used. An uniform discretisation of the time grid t ∈ [t 0 , t f ] = [0, 10] is employed yielding a constant segment width i = = t f −t 0 n seg . Both, the NLP approach and the SSC method, are initialised with zero vectors U 0 = 0 and X 0 = 0. From follows that the Hessian of (48) is a diagonal matrix with only positive and zero diagonal entries and therefore positive semi-definite. Hence, the main objective (48) is a convex function.

Nonlinear nonconvex optimisation problem
For the solution of the OP via NLP, the decision variables are chosen as whereas the input represents the variable damping coefficient d k of the semi-active actuator. With i ∈ I and k ∈ K, the original OP is given by The nonconvex NLP problem (51) is comprised of following parts: objective function (51a), collocation constraints (51b), bounds for the decision variables (51c), damper force bounds (51d) and initial value condition (51e). The piecewise linear spring force is approximated in (51b) via the smoothed minimum-function using ε = 10 −16 to guarantee that the problem is twice continuously differentiable (Sedlacek et al., 2020b). Problem (51) is nonconvex due to the right-hand side of the differential equation system in the collocation constraints (51b) and due to the damper force bounds (51d).

Convex QP-problem for iterative solution
Following the SSC approach, auxiliary optimisation variables are introduced, which results in the subsequent decision variables: Opposed to the inputs (50a) of the NLP problem (51a), the inputs in (53a) represent the positive and negative part of the damper force.
As illustrated in Algorithm 1, a projection routine is executed in each iteration. Based on the preceding solution marked by values (·) , this routine computes the projected initial solution( ·) for k ∈ K viȃ and the correct signs according to For a concise notation in the OP, the decision variables are lumped together in P := {U, X, X aux , V aux }. With i ∈ I and k ∈ K, the convex QP problem, which is iteratively solved for updated values of τ , σ x,k , σ v,k and corresponding initial guesses, is given by min P J ss + τ k∈K l abs,x,k + l abs,v,k with (55a) x low,k ∈ X low := x, x tr , x mid,k ∈ X mid := x tr , x , The QP problem (55) is comprised of following parts: augmented objective function (55a), collocation constraints (55c), bounds for the decision variables (55d), ZCS-constraints (55e), the additional space splitting constraints (55f)-(55g) and initial value condition (55h). Due to the splitting approach, the right-hand side of the differential equation system in (55c) is an affine function in the decision variables. Thus, all constraints are affine in the decision variables and therefore convex. The additional objectives with (55b) are affine in the decision variables representing convex functions. Hence, (55) represents a convex QP problem. Using (55b), the termination criterium in line 9 of Algorithm 1 is computed via l abs = l abs,x,0 l abs,v,0 , . . . , l abs,x,n seg l abs,v,n seg max .
As illustrated in line 6 of Algorithm 1, the penalty weight τ is linearly increased with a maximum iteration number q max = 6 using the lower and upper bound τ and τ , respectively. Both OPs are now fully defined. The results generated by solving NLP problem (51) and by applying the SSC algorithm with QP problem (55) are compared in the following section.

Results
In order to inspect the performance of the proposed SSC algorithm, 100 OPs are analysed in this section using a desktop computer with Intel Core TM i7-9850H CPU to determine the solutions. The OPs vary in size and the initial value condition. The number of collocation segments is gradually increased with n seg ∈ {10, 50, 100, 250, 500}. For each problem size, the OPs (51) and (55) are solved using the 10 random, admissible initial values x iv listed in Table 2. This procedure is also executed for a simplified QP problem (55) with a fully linear spring of stiffness c mid . This simplifies the right-hand side of the differential equation system in (55c) and eliminates the need for the auxiliary variables X aux in (53c), the corresponding additional objectives in (55b) as well as the corresponding constraints in (55f) and (55g). The optimisation results are displayed in Table 3. Firstly, the OPs with initial value x iv = x iv,1 and n seg = 250 segments are studied in more detail. Figure 7(a) depicts the piecewise linear characteristic curve of the spring force and Figure 7(b) the admissible set for the damper force. The resulting trajectories of the states and damper force are illustrated in Figure 7(c). The mean absolute deviance between the damper force trajectory of the NLP solution and the SSC solution is defined as = 2549.86 m 2 s for the SSC solution and NLP solution, respectively. Thus, the SSC objective value is higher but the mean deviance in the steady-state position error is lower. The reason for this is that the cost function is quadratic in the errors which penalises large errors unevenly more than small errors. As illustrated in the top subplot of Figure 7, the position of the NLP solution reaches the steady-state position faster however with an overshoot which slowly reduces. Thus, the larger errors at the beginning are reduced more quickly resulting in a lower cost function value. However, the mean position error, which is a better metric for the actual goal of minimising the deviance from the steadystate position, is worse than for the SSC solution. Although an objective penalising the absolute value of the errors would be more adequate, it is not used since it would prevent continuous differentiability of the objective function. Nevertheless, both algorithms reach the steady-state position x ss in about 3 s resulting in similar state trajectories. The trajectories of the auxiliary variables verify correct switching at x = x tr = −5 m and v = v tr = 0 m s for the position and velocity, respectively. Furthermore, Figure 7(a,b) shows that the spring forces lie on the characteristic line and the computed damper forces lie within the admissible set proving the compliance of the prescribed constraints. The bang-bang-like control strategy confirms correctness since it is expected due to the main objective (48), which demands to reduce the errors as fast as possible. With q = 4 superordinate iterations, the SSC method required a total optimisation time of t SSC = 0.329 s which is 47.71 % of the computation time of t NLP = 0.690 s required by the NLP solver. The cumulative optimisation time t opt, , which represents the time spent in the QP solver in line 8 of the SSC algorithm for all passed loops, is t SSC opt, = 0.262 s representing 37.97 % of the NLP Table 2. Initial values of robustness analysis.
x iv,1 x iv,2 x iv,3 x iv,4 x iv,5 x iv,6 x iv,7 x iv,8 x iv,9 x iv,10   time. Since the SSC algorithm converged in q < q max = 6 iterations, the largest relaxation value of the AVCs is smaller than ε g ensuring conformity with the original problem. Subsequently, the remaining results of Table 3 are analysed to identify tendencies. As stated in Section 2.2.1, the additional objective terms (55b) represent a relaxation of the constraints comparable with slack variables. Besides serving as feedback for determining convergence, this relaxation provides robustness regarding the initialisation. This is reflected in the results by a successful convergence of the SSC algorithm in 100% of the test cases, even though a rather poor initial guess was used. The accuracy of the computed solutions is evaluated using the mean values of the main cost function (48) and of the averaged errors (57) and (58)  These values represent the respective mean value over all 10 OPs, due to 10 different initial values, for one specified number of collocation segments n seg . With e F d ≤ 3.51 N being small compared to the domain of F d , the control trajectories of the SSC approach are close to the trajectories computed by the NLP solver. The small deviation of the mean values in (59) between the SSC solution and the NLP solution indicates that both algorithms converged to a similar solution. Considering the mean value J ss of the main objective function, the NLP solver yields lower objective values than the SSC algorithm. As previously discussed, the mean deviance e ss from the steady-state position is smaller when using the SSC algorithm.
The SSC approach greatly reduces the overall computation time t SSC and requires up to only 18.20% of the computation time needed by the NLP solver. The time advantage of the SSC algorithm over the NLP optimiser will be even bigger for asymmetric zonally convex damper sets. Such asymmetric sets require additional discontinuities in the NLP problem but can be easily implemented within the SSC procedure by using differing parameters for the individual convex subsets. As mentioned in Section 2.4, various aspects influence the runtime of the SSC algorithm which is reflected in the results: With rising number of collocation segments, the mean solution time increases and the computation time of SSC increases less than the NLP solution time. Another mentioned effect on runtime is the quality of the initial guess. The provided guess with zero vectors is of varying quality for the individual initial value conditions. A better initial guess in terms of the correct signs of the state trajectories reduces the number of superordinate iterations and thus the overall computation time. Hence, the sensitivity in regards to the initial guess is elaborated in the following section.
The pure optimisation time t SSC opt, reduces up to 6.45% of the corresponding NLP time and is generally significantly shorter than its overall computation time t SSC . Since the projection step of the SSC algorithm employs only simple computations using minimum and maximum functions with linear time complexity, the time spent outside of the QP solver, which solves convex QPproblems in polynomial time, seems quite long. Unfortunately, substantial time losses occur at building the updated optimisation model via JuMP and the Gurobi-wrapper. For future implementations, it is advisable to implement the SSC algorithm via C-code to circumvent this problem and minimise the overall computation time.

Influence of initial guess on results
In this section, the OPs (51) and (55) are modified to consider the nonlinear spring characteristic with three piecewise linear segments depicted in Figure 5. The NLP problem (51) is adjusted by replacing the spring force F NLP c,2,k in the differential equation system considered in constraint (51b) by using the smooth maximum function The adaptation of the QP problem (55) requires slightly more changes. The auxiliary decision variables for the position (53c) are augmented resulting in Thus, the position space is bisected into a region below and a region above x = x tr , whereas the upper region is again bisected into a region below and above x = x tr . Compared to (54), the update procedure remains unchanged for the decision variables of the inputs, states and auxiliary velocities: ȗ pos,k u neg,k = max(u neg,k + u pos,k , 0) min(u neg,k + u pos,k , 0) , However, since the position space is partitioned into three segments, the updating routine changes for the auxiliary position states according to x up,k x mid,k = max(x low,k , x tr ) min(x low,k , x tr ) .
(63b) Furthermore, the correct signs are now given by With i ∈ I and k ∈ K, the convex QP problem is formulated as min P J ss + τ k∈K l abs,x mu ,k + l abs,x lm ,k + l abs,v,k with (64a) x low,k ∈ X low := x, x tr , x low,k ∈ X low := x tr , x , x mid,k ∈ X mid := x tr , x tr , x up,k ∈ X up := [x tr , x] The termination criterium is computed via In order to analyse the effect of the initialisation on the computed solution, several initial guesses are fed to the SSC algorithm aiming at solving the OP with initial value x iv,1 considering n seg = 250 collocation segments. The maximum number of iterations is increased to q max = 25 to check if poor approximations eventually converge. Using the solution of the NLP optimiser u NLP opt and X NLP opt as reference, the initial guesses are generated using u neg,k = k init min u NLP opt,k , 0 , u pos,k = k init max u NLP opt,k , 0 , with k init ∈ {0.0, 0.5, 0.75, 0.95, 1.0, 1.05, 10.0} which are fed to the SSC update routine. The computations are compared to the results of the NLP problem which is initialised with the same guesses. The results of the individual optimisations are listed in Table 4. As Figure 8(a,b) indicates for k init = 0, all solutions satisfy the prescribed constraints: The spring forces lie on the piecewise linear branches and the damper forces are within the admissible area. Considering the objective value J ss and mean error e ss in Table 4, the NLP solver converges to the same solution independently which initial guess is supplied. Thus, it is assumed that the computed NLP solution represents the global optimum or is at least very close to it. However, initialisation can have a massive impact on the computation time. Generally, the guesses close to the solution result in shorter computation times. It is striking that both algorithms have the most difficulty converging for k init = 0.5 which is not the guess with the biggest difference to the optimal solution. The SSC algorithm converges significantly faster than the NLP solver for all initial guesses. The number of superordinate iterations required by the SSC algorithm is small for good initial guesses. As for k init = 0.5, a high number of superordinate iterations can still yield a faster convergence compared to the NLP solver. As already mentioned, the SSC algorithm represents a local method and does not necessarily provide the global optimum, which is reflected in the results. Considering the objective value J ss and mean error e ss , only the SSC solutions for k init ≥ 0.5 are roughly in the vicinity of the global solution. The mean deviance between the input trajectories e F d is then rather small. Even though the SSC solutions may not represent the global optimum, the solutions satisfy the prescribed constraints since q < q max . Thus, they represent a local solution of the piecewise linear problem, which corresponds to the original problem for the example at hand. The results for k init = {0.95, 1.0, 1.05} confirm that the  (58) and (57); q: # of superordinate iterations; t opt, : cumulative time spent in NLP/QP solver; t : total computation time. SSC algorithm converges to the global optimum if the initial guess is in a close vicinity of it. As mentioned in Section 2.4, increasing the number of space divisions to depict the three-segmented spring raises computation time. This can be confirmed by comparing solution times of the SSC algorithm for k init = 0.0: For the two-segmented spring t SSC opt, = 0.262s, t SSC = 0.329s and q = 4 holds whereas t SSC opt, = 0.493s, t SSC = 0.798s and q = 7 holds for the spring with three segments. Thus, more iterations are required and the average computation time per iteration is increased by 7.52% and 38.6% for t SSC opt, and t SSC , respectively. This highlights the importance of an implementation in C-Code to reduce the time required for the updating routine and therefore the overall computation time.

Rotated space splitting
As elaborated in Section 2.3.1, some sets require to be split using a rotated straight line. Without going into detail, the approach is applied to the example of a hanging SMO with fully linear spring presented in Section 3.1. The OP is parametrised with initial value x iv,1 and n seg = 250 collocation segments. The damper set is rotated by ϕ = 7 • resulting in the set depicted in Figure 9(a). This is implemented by applying the changes (36) to the convex QP problem with fully linear spring. As depicted in Figure 9(a), the SSC algorithm computes damper forces which all lie within the admissible area. Although this example represents an artificial use-case, the corresponding position trajectories in Figure 9(b) prove that the rotated set yields a reduction of the objective. Starting with x iv,1 < x ss in a compression phase with v iv,1 < 0, the mass is first decelerated and then accelerated using F d < 0 at v > 0, hence active forces. These active forces enable a faster attainment of the steady-state position. Due to the similarity to the previous examples, no further discussion is given.

Conclusions
This article has presented a novel local solution method for efficiently solving nonconvex optimal control problems. Splitting the space of inputs and states enables the formulation of QP subproblems which are solved iteratively. The method is capable of considering two types of nonconvexities: ZCSs and equality constraints with possibly multiple univariate nonlinearities. The approach decomposes the nonconvexities into affine parts which are linked appropriately to approximate the original problem with scalable approximation error. It has been shown that the SSC algorithm converges to a local optimum of this approximated problem. The quality of the solution depends on the initial guess. For good initial guesses, the method converges to solutions close to the global one. A comparison of this successive convexification technique with other existing methods has been given, highlighting the advantages SSC provides.
Subsequently, possible directions for future research are disclosed. Even though it would not change the algorithm, using nondifferentiable constraint qualifications (Ye, 2004) could potentially avoid the AVC-smoothing required for continuous differentiability regarding the convergence proof. Due to the low computation time and robust convergence, the SSC method seems to be a promising approach for real-time optimal control applications. In this context, using MPC could provide sufficiently good initial guesses (Diehl et al., 2005;Gros et al., 2020) resulting in good SSC solutions. In order to enhance applicability, the SSC approach could be combined with other iterative linearisation schemes like (Carvalho et al., 2013;Liniger et al., 2015;Mao et al., 2017;Simon et al., 2013) which could enable considering collision avoidance constraints. Furthermore, extending the SSC approach to bivariate nonlinearities in equality constraints would enlarge the possible scope of applications. Moreover, applying a more sophisticated updating procedure for the penalty parameter would improve computation times (Maratos, 1978;Mayne & Maratos, 1979;Nocedal & Wright, 2006). For applications with real-time capability requirement, it is recommended to implement the algorithm via tailored C-code to avoid the overhead introduced by the