Learning fixed-complexity polyhedral Lyapunov functions from counterexamples
Abstract
We study the problem of synthesizing polyhedral Lyapunov functions for hybrid linear systems. Such functions are defined as convex piecewise linear functions, with a finite number of pieces. We first prove that deciding whether there exists an -piece polyhedral Lyapunov function for a given hybrid linear system is NP-hard. We then present a counterexample-guided algorithm for solving this problem. The algorithm alternates between choosing a candidate polyhedral function based on a finite set of counterexamples and verifying whether the candidate satisfies the Lyapunov conditions. If the verification fails, we find a new counterexample that is added to our set. We prove that if the algorithm terminates, it discovers a valid Lyapunov function or concludes that no such Lyapunov function exists. However, our initial algorithm can be non-terminating. We modify our algorithm to provide a terminating version based on the so-called cutting-plane argument from nonsmooth optimization. We demonstrate our algorithm on numerical examples.
I Introduction
Stability analysis of dynamical systems is of great importance in control theory, since many controllers seek to stabilize a system to a reference state or trajectory [1, 2]. Lyapunov methods are commonly used to prove stability of dynamical systems using a positive-definite function, called a Lyapunov function, whose value strictly decreases along all trajectories of the systems, except at the equilibrium point.
In this paper, we focus on the stability analysis of hybrid linear systems. These are systems with multiple modes, each with a different continuous-time linear dynamics and state-dependent switching between the modes. These systems appear naturally in a wide range of applications, or as abstractions of more complex dynamical systems [3]. To study the stability of these systems, we rely on polyhedral functions, which are convex piecewise linear functions. This class of functions is interesting for Lyapunov analysis because the expressiveness of the function can be easily modulated by adjusting the number of linear pieces. Furthermore, for a large class of hybrid systems (including switched linear systems), if the system is stable, then a polyhedral Lyapunov function is guaranteed to exist for the system [4].
In this paper, we first establish that the problem of deciding whether there exists a polyhedral Lyapunov function with given number of linear pieces for a given hybrid linear system is NP-hard. Despite the important body of work on polyhedral Lyapunov functions, the study of the algorithmic complexity of the underlying problem when the number of linear pieces is fixed seems to be elusive. We fill this gap, thereby providing an insight on the complexity of algorithms meant to solve the problem with guarantees.
Next, we introduce a counterexample-guided algorithm to compute polyhedral Lyapunov functions for hybrid linear systems. Our approach alternates between choosing a candidate Lyapunov function based on a finite set of counterexamples and verifying whether the candidate satisfies the Lyapunov conditions. If the verification fails, we find a new counterexample that is added to our set. In effect, this new counterexample removes the current candidate (and many others) from further consideration. The learning–verification process is repeated until either a valid Lyapunov function is found or no such function is shown to exist for the system. The key challenges in this approach are twofold. First, there are multiple ways of removing candidates using a counterexample while keeping the set of remaining candidates convex. Our approach uses a tree-based search algorithm to explore these possibilities. Second, the algorithm as presented thus far would be non-terminating. We modify our approach to guarantee termination using the cutting-plane argument, wherein a careful choice of the candidate and the pruning of branches of the tree based on the inner radius of the feasible set of candidates are used to ensure termination and get upper bounds on the complexity of the algorithm. The output of the modified algorithm is either a polyhedral Lyapunov function for the system, or the conclusion that no “-robust” function exists for the system, where is an input to the algorithm. In effect, we conclude that if a polyhedral Lyapunov function were to exist for the system, then perturbing its coefficients by more than in the -norm will cause the function not to be a Lyapunov function.
Comparison with the literature. Blondel et al. provide a comprehensive introduction to the computational complexity of numerous decision problems related to control and stability of dynamical systems [5]. The problem of deciding stability of switched linear systems (a subclass of hybrid linear systems) is shown to be undecidable. The complexity of deciding whether a dynamical system admits a polyhedral Lyapunov function with a given number of linear pieces seems to not have been addressed so far. The same problem without the bound on the number of pieces is closely related to the problem of stability verification using general convex Lyapunov functions (see, e.g., [4]).
The problem of synthesizing Lyapunov functions for dynamical systems has received a lot of attention in the literature [1, 4]. Different classes of functions have been considered for that purpose, resulting in various trade-offs between expressiveness and computational burden. Polynomial functions have proved useful for stability analysis [6], but they can be too conservative for some hybrid systems, as shown in Example 1. Piecewise polynomial Lyapunov functions allow to reduce the conservatism [7], at the cost of introducing hyperparameters and/or increasing the complexity. The computation of polyhedral Lyapunov functions has also received attention, for instance, using optimization-based [8, 9, 10] and set-theoretic methods [11, 12]. One drawback of these approaches is that they generally lack guarantees of convergence (to a valid Lyapunov function), or guarantees of termination and complexity, or involve many hyperparameters. By contrast, the only parameters in our approach are the number of linear pieces and the accuracy , and the algorithm always terminates and finds a polyhedral Lyapunov function, or ensures that no -robust such function exists for the system.
The idea of learning Lyapunov functions from data and verifying the result has been explored by many researchers, starting with [13], whose approach relies on random sampling of states, learning a candidate Lyapunov function from the samples and verifying the result. Our approach falls more precisely into the category of Counterexample-Guided Inductive Synthesis (CeGIS) techniques, which consist in iteratively adding counterexamples from the verification step. These techniques have been used in a wide range of control problems [14, 15, 16, 17, 18, 19, 20]. Particularly related to our work, [20] searches for neural-network Lyapunov functions with ReLU activation functions, using MILP for the verification; and [8] searches for polyhedral Lyapunov functions, using Linear Programming for the verification and updating the domain of the linear pieces from the counterexamples. However, both approaches lack guarantees of convergence and complexity. In a recent work [21], we also studied counterexample-guided approaches to compute polyhedral Lyapunov functions without a bound on the number of linear pieces.
Prabhakar and Soto present a CeGIS approach for verifying stability of polyhedral hybrid systems with piecewise constant differential inclusions by using counterexamples to drive a partitioning of the state-space [22]. The partitioning is used to compute a weighted graph whose cycles provide evidence of stability if the product of weights for each cycle is less than one. Failing this, we conclude potentially unstable behavior. Prabhakar and Soto’s approach is distinct from our approach in two important ways: (a) it does not seek to compute a Lyapunov function but instead focuses on building a finite graph abstracting the behavior of the system and (b) they handle polyhedral inclusions, which are a different type of dynamics from those considered here.
Organization. Section II introduces the problem of interest and preliminary concepts related to Lyapunov analysis and polyhedral functions. In Section III, we describe the algorithm and its properties. Finally, in Section IV, we demonstrate the applicability on numerical examples.
Notation. denotes the set of nonnegative integers. We let and . For , we let .
II Preliminaries and Problem Description
II-A Hybrid linear systems
Hybrid linear systems consist of a finite set of modes , such that for each mode , there is a closed polyhedral cone called the domain, and a flow matrix . Let be the set-valued function defined by . For the purpose of our analysis, describes completely the dynamics of the system. Therefore, in the following, we will refer to the system as system . A function is a trajectory of system if is absolutely continuous and satisfies the differential inclusion for almost all [23].
Remark 1:
Note that the hybrid system considered above is a particular instance of hybrid linear systems, since there is no update of the continuous state at mode switches [3]. Extensions of our work to a more general class of hybrid systems will be considered in the future work.
II-B Polyhedral Lyapunov functions
A polyhedral function can be described as the pointwise maximum of a finite set of linear functions, i.e., where and .
To be a Lyapunov function for system , a piecewise smooth function must (i) be positive everywhere except at the origin, and (ii) strictly decrease along all trajectories of the system not starting at the origin [1]. In the case of polyhedral functions, a sufficient condition for being a Lyapunov function and thereby ensuring stability of the system, is as follows [24, Proposition 3]:
Proposition 1:
A polyhedral function with linear pieces is a Lyapunov function for system if
-
(C1)
for all , there is such that ;
-
(C2)
for all , and with , it holds that .
In other words, a set a vectors represents a polyhedral Lyapunov function for system if
(1) |
The condition in (1) is difficult to enforce because (i) it involves an infinite set of constraints, and (ii) each constraint involves a disjunction of clauses111 clauses come from the “” and one clause comes from the condition between brackets “”.. In the next section, we describe a tree-based counterexample-guided algorithm to tackle this problem. The idea is to (i) consider only a finite set of constraints, obtained from the counterexamples, and (ii) decompose the disjunction by introducing a branch in the tree for each clause.
We define the -Lyap-Fun-Exists problem as that of checking the existence of a polyhedral function satisfying (1), given a hybrid linear system and a number of pieces .
Theorem 2:
The -Lyap-Fun-Exists problem is NP-hard, even for .
Proof: See Appendix -A.
To conclude this section, let us introduce an example of hybrid linear systems that we will use throughout the paper to illustrate the approach.
Example 1 (Running illustrative example):
Consider the hybrid linear system with modes, i.e., , domains corresponding to the quadrants of the 2D plane, namely, , , and , and flow matrices:
This system can be seen as a piecewise linear damped oscillator. The vector field and a trajectory starting from are represented in Fig. 1. The system does not admit a polynomial Lyapunov function (a proof is provided in Appendix -B). Nevertheless, as we will see throughout the paper, we can compute a polyhedral Lyapunov function for the system, thereby ensuring that it is asymptotically stable.

III Counterexample-guided Search
We present a tree-based counterexample-guided algorithm to find a polyhedral function satisfying (1). Our approach maintains a tree, wherein each node is associated with a set of constraints. At each step, the algorithm picks a leaf of the tree and expands it as follows:
-
1.
Learning: Solve a linear program to obtain a candidate polyhedral Lyapunov function compatible with the associated set of constraints .
- 2.
-
3.
Expansion: If a counterexample is found, the algorithm creates child nodes in the tree. Each child node is associated with a set of constraints obtained by adding to one of the clauses in (1) for the counterexample (see below for details).
The sets of constraints associated to each node are sets of triples of the form wherein are obtained from the counterexamples, and is an index indicating which clause of (1) must be enforced at . More precisely, if , we enforce the clause
(2) |
and if , we enforce the clause
(3) |
Our approach systematically explores this tree and stops when one leaf of the tree yields a valid Lyapunov function. Under some modifications of the basic scheme above, we prove that the depth of this tree is bounded. This yields an upper bound on the running-time complexity of the algorithm.
The section is organized as follows: first, we describe the learning phase, then the verification phase, and finally the expansion phase which yields the overall recursive process.
III-A Learning Phase
Given a set of constraints , we aim to find vectors compatible with according to conditions (2)–(3). Therefore, we solve the following feasibility problem:
find | (4a) | |||
s.t. | (4d) |
When is finite, (4) is a Linear Program and thus can be solved efficiently [25, 26]. We denote by the set of feasible solutions of (5). A set of vectors is thus a candidate solution compatible with iff . Note that is a convex set.
III-B Verification Phase
We verify whether a candidate solution computed in the learning phase provides a valid Lyapunov function for system , by checking whether it satisfies (C1) and (C2) in Proposition 1. If this is not the case, we generates a pair , called a counterexample, at which (1) is not satisfied.
First, we verify that (C1) holds for the candidate solution by searching for such that . Without loss of generality, we can set to be on the boundary of . Therefore, we solve Linear Programs, for each facet of :
find | (5a) | |||
s.t. | (5b) | |||
(5c) |
If for all facet , (5) is infeasible, then (C1) holds. However, if there is a facet for which (5) has a feasible solution , then it holds that and . We find index with , yielding a counterexample .
If (C1) is shown to hold, we next verify that (C2) holds too. Therefore, we solve LPs, for each and ,
find | (6a) | |||
s.t. | (6b) | |||
(6c) | ||||
(6d) |
If for all , (6) is infeasible, then (C2) holds. However, if there are for which (6) has a feasible solution , then it holds that , and wherein , so that is a counterexample.
Example 2 (Running illustrative example):
Consider the -piece polyhedral function whose -sublevel set is represented in Fig. 2-left (in yellow). The point (in red) provides a direction in which is in the -sublevel set of for all . This implies that , so that is a feasible solution to (5).
Now, consider the system of Example 1 and the -piece polyhedral function whose -sublevel set is represented in Fig. 2-right (in yellow). For , (6) has a feasible solution (red dot). The flow direction of the system from is represented in Fig. 2-right (red line). We see that the flow direction points towards the exterior of the -sublevel set of .

III-C Expansion and Overall Algorithm
The algorithm organizes the set of constraints as a tree with the following properties: (a) each node is associated with a set of constraints and thus with a convex set of candidates ; (b) the root of the tree is associated with ; and (c) each node has children, , with associated sets of constraints , wherein is the counterexample found during the verification of the candidate at node . Each leaf of the tree is marked as unexplored or infeasible.
Each iteration of our algorithm is as follows:
-
1.
Choose an unexplored leaf .
-
2.
Find a candidate .
- 3.
-
4.
If we find a counterexample , we add children, , to wherein is unexplored and has set of constraints .
Alg. 1 shows the pseudo-code. We will now establish some properties of Alg. 1. Let be a candidate chosen for some leaf (Line 1) and be a counterexample that was found for this candidate (Line 1). Consider for some child of (Line 1).
Proposition 3:
and .
Proof: The first part is straightforward since . To show that , note that by definition of , it holds that . Hence, for all , (2) is not satisfied. Furthermore, satisfies
Thus, (3) is not satisfied. We thus conclude that cannot contain the candidate .
Let us assume that the underlying system has a polyhedral Lyapunov function, given by , satisfying (1) and without loss of generality assume .
Proposition 4:
At every step of any execution of Alg. 1, there is an unexplored leaf such that .
Proof: See Appendix -C.
As a corollary, we get the soundness of the algorithm:
Corollary 5:
Proof: If Alg. 1 returns , it means that has passed the verification phase (Line 1), thereby ensuring that it provides a Lyapunov function for system . If Alg. 1 terminates without finding a Lyapunov function, it means that all leaves are marked infeasible. By applying Proposition 4, we note that no Lyapunov function could have existed in the first place.
Example 3 (Running illustrative example):
Consider the system of Example 1. A -piece polyhedral Lyapunov function for this system was computed using Alg. 1. Its -sublevel set is represented in Fig. 3 (in yellow). The states involved in the constraints of the node that provided this function are represented by blue dots. We have also represented a trajectory of the system starting from (in purple). We observe that the trajectory does not leave the -sublevel set, as expected.

Note that there is no guarantee that Alg. 1 will terminate. To ensure termination, we modify the algorithm by leveraging a central result in convex nonsmooth optimization, known as the cutting-plane argument.
Therefore, assume that at Line 1 of Alg. 1, the candidate is chosen as the center of the Maximum Volume Ellipsoid (MVE) inscribed in . The MVE center of a polyhedron can be computed efficiently using Semidefinite Programming [26, Proposition 4.9.1]. Remember that the rationale of adding constraints from the counterexample (Line 1) is to exclude the candidate from further consideration at all descendant nodes. The choice of the candidate as the MVE center makes the exclusion stronger by guaranteeing a minimum rate of decrease of the volume of when going from one node to any of its children. This follows from the cutting-plane argument:
Lemma 6 (Cutting-plane argument [27]):
Let be a bounded convex set. Let be the MVE center of . Let be a convex set not containing . It holds that .
Based on the above, consider the following modification of the algorithm. Fixed and consider Alg. 1, except that in the learning phase, if does not contain a ball of radius , then is declared infeasible; otherwise, we choose the candidate as the MVE center of . See Alg. 2 for a pseudo-code of the modified learning phase. It holds that the modified algorithm terminates in finite time.
Theorem 7 (Termination and soundness):
Alg. 2 always terminates. Moreover, if Alg. 2 returns vectors , then the polyhedral function associated to is a Lyapunov function for system . If Alg. 2 returns “No Lyapunov Found”, then system does not admit an -robust polyhedral Lyapunov function, that is, a polyhedral function for which any () -perturbation of the linear pieces satisfies (1).
Proof: See Appendix -D.
III-D Complexity analysis
The dominant factor in the complexity of Alg. 2 is the depth of the tree explored during the execution of the algorithm. From the proof of Theorem 7, it holds that
(7) |
where . Alg. 2 explores at most nodes before termination. We deduce the following complexity bound:
Theorem 8:
The complexity of Alg. 2 is
Proof: Using the bound , we get that . The proof then follows from (7).
IV Numerical example
Consider the hybrid linear system with two modes, i.e., , domains and , and flow matrices:
Fig. 4 shows the vector field and a sample trajectory of the system. Although a trivial quadratic Lyapunov function (e.g., ) exists for this system, finding a polyhedral one is challenging because many pieces are required to capture the rotational dynamics of the system.
Using the process described in Section III, we computed a -piece polyhedral Lyapunov function for the system. As an approximation of the MVE center, we used the Chebyshev center (center of the largest enclosed Euclidean ball), which can be computed using Linear Programming (more efficient and reliable than Semidefinite Programming). Although the theoretical guarantees on the termination of the process using the Chebyshev center are weaker than the ones with the MVE center (see Theorem 8), this provides a powerful heuristic in practice (see, e.g., [27, §4.4] and the references therein). The computation takes about 60 seconds.222On a laptop with processor Intel Core i7-7600u and 16 GB RAM running Windows. We use GurobiTM, under academic license, as linear optimization solver. The -sublevel set of the polyhedral Lyapunov function is represented in Fig. 4-right (in yellow).

V Conclusions
In conclusion, we provide a NP-hardness result for finding fixed-complexity polyhedral Lyapunov function for hybrid linear systems. Furthermore, we describe a counterexample-driven approach based on switching between learning and verification followed by a tree of possible refutations. Our approach is modified to yield termination but at the cost of completeness. Our future work will focus on an efficient implementation of the procedure described in this paper and extensions to barrier and control Lyapunov function synthesis.
-A Proof of Theorem 2
We show that -Lyap-Fun-Exist with is NP-hard by reducing NAE-SAT3 to it. NAE-SAT3 (Not All Equal SATisfiability) is a version of the SAT3 problem that takes as input clauses over propositions . Each clause is a triple of literals: wherein .
Given such a tuple of clauses, the NAE-SAT3 problem asks whether there exists an assignment of or to each proposition such that for each clause , at least one literal is true and at least one literal is false. Without loss of generality, we assume that for each clause, the three literals involve distinct propositions (otherwise, the clause is trivially “satisfied”). It is well known that NAE-SAT3 is NP-complete [28].
We will now reduce any given NAE-SAT3 instance with propositions and clauses to yield a hybrid linear system, described by , that has a -piece polyhedral Lyapunov function iff has a truth assignment that makes it NAE-SAT3-satisfiable.
Let . Consider a vector of variables: . Also, consider two vectors of coefficients: and . We look for a -piece polyhedral Lyapunov function, defined by , for the system defined below.
For each , let
and consider the dynamics: ; for all , ; ; (mind the absolute value which can be cast as a piecewise linear dynamics by splitting in two pieces). Condition (1) then becomes
This is equivalent to saying that (i) (i.e., both are nonzero and have opposite signs), (ii) , and (iii) .
If (i.e., ), we assign the value true to ; otherwise, we assign the value false.
Now, for each , let
and consider the dynamics: for all , where
; . Condition (1) then becomes
This is equivalent to saying that , and are negative.
Now, it holds that only if there is such that . Similarly, only if there is such that . Thus, NAE-SAT3 is satisfied with the assignment described above. On the other hand, if satisfies NAE-SAT3, then the assignment: for all , if and if , , and , provides a -piece polyhedral Lyapunov function for the above system. Thus, the above system admits a -piece polyhedral Lyapunov function iff is NAE-SAT3-satisfiable.
-B Further analysis of Example 1
We prove that system in Example 1 does not admit a polynomial Lyapunov function. For the sake of a contradiction, assume that is a polynomial Lyapunov function for the system. Since is radially unbounded, it is of nonzero even degree. Fix and let be the trajectory of the system starting from . It holds that and . Since is of nonzero even degree, we have that whenever is large enough. Since was arbitrary, this contradicts the property that decreases along all trajectories of the system.
-C Proof of Proposition 4
The proof is by induction on the iterations the algorithm. The property is true at the very beginning since . Assume it is true after iterations of the while loop and let be a leaf satisfying the property at this step. If the algorithm stops at this step, there is nothing to prove. Thus, assume some unexplored leaf is to be expanded at this step. If , then the property will be trivially satisfied at the subsequent step. Hence, suppose , and let be the counterexample found by the verifier. Let be such that (which always exists since satisfies (1)). Since , it holds that , so that the child node of satisfies , concluding the proof.
-D Proof of Theorem 7
First, we prove that Alg. 2 always terminates. Let be the leaf that is expanded and let be any of its children. Let . Since is the MVE center of , it holds by Lemma 6 that . At the very start of the algorithm, which has volume . Let be an unexplored leaf at depth of the tree. By induction, we can show that . Let be the volume of the -ball . Since we terminate whenever , it holds that . In other words, the depth of the tree is upper bounded. This proves that Alg. 2 always terminates.
References
- [1] H. K. Khalil, Nonlinear systems, 3rd ed. Upper Saddle River, NJ: Prentice-Hall, 2002.
- [2] E. D. Sontag, Mathematical control theory: deterministic finite dimensional systems, 2nd ed. New York, NY: Springer, 1998.
- [3] R. Goebel, R. G. Sanfelice, and A. R. Teel, Hybrid dynamical systems: modeling stability, and robustness. Princeton, NJ: Princeton University Press, 2012.
- [4] Z. Sun and S. S. Ge, Stability theory of switched dynamical systems. London: Springer, 2011.
- [5] V. D. Blondel and J. N. Tsitsiklis, “A survey of computational complexity results in systems and control,” Automatica, vol. 36, no. 9, pp. 1249–1274, 2000.
- [6] P. A. Parrilo, “Structured semidefinite programs and semialgebraic geometry methods in robustness and optimization,” Ph.D. dissertation, California Institute of Technology, 2000.
- [7] M. Johansson and A. Rantzer, “Computation of piecewise quadratic Lyapunov functions for hybrid systems,” IEEE Transactions on Automatic Control, vol. 43, no. 4, pp. 555–559, 1998.
- [8] A. Polański, “On absolute stability analysis by polyhedral Lyapunov functions,” Automatica, vol. 36, no. 4, pp. 573–578, 2000.
- [9] R. Ambrosino, M. Ariola, and F. Amato, “A convex condition for robust stability analysis via polyhedral Lyapunov functions,” SIAM Journal on Control and Optimization, vol. 50, no. 1, pp. 490–506, 2012.
- [10] D. Kousoulidis and F. Forni, “Polyhedral Lyapunov functions with fixed complexity,” in 2021 60th IEEE Conference on Decision and Control (CDC). IEEE, 2021, pp. 3293–3298.
- [11] F. Blanchini and S. Miani, Set-theoretic methods in control, 2nd ed. Cham: Birkhäuser, 2015.
- [12] N. Guglielmi, L. Laglia, and V. Protasov, “Polytope Lyapunov functions for stable and for stabilizable LSS,” Foundations of Computational Mathematics, vol. 17, no. 2, pp. 567–623, 2017.
- [13] U. Topcu, A. Packard, and P. Seiler, “Local stability analysis using simulations and sum-of-squares programming,” Automatica, vol. 44, no. 10, pp. 2669–2675, 2008.
- [14] J. Kapinski, J. V. Deshmukh, S. Sankaranarayanan, and N. Aréchiga, “Simulation-guided Lyapunov analysis for hybrid dynamical systems,” in Proceedings of the 17th international conference on Hybrid systems: computation and control. ACM, 2014, pp. 133–142.
- [15] Y.-C. Chang, N. Roohi, and S. Gao, “Neural Lyapunov control,” in NIPS’19: Proceedings of the 33rd International Conference on Neural Information Processing Systems. ACM, 2019, pp. 3245–3254.
- [16] H. Ravanbakhsh and S. Sankaranarayanan, “Learning control Lyapunov functions from counterexamples and demonstrations,” Autonomous Robots, vol. 43, no. 2, pp. 275–307, 2019.
- [17] H. A. Poonawala, “Stability analysis via refinement of piece-wise linear Lyapunov functions,” in 2019 IEEE 58th Conference on Decision and Control (CDC). IEEE, 2019, pp. 1442–1447.
- [18] D. Ahmed, A. Peruffo, and A. Abate, “Automated and sound synthesis of Lyapunov functions with SMT solvers,” in International Conference on Tools and Algorithms for the Construction and Analysis of Systems. TACAS 2020., ser. Lecture Notes in Computer Science, A. Biere and D. Parker, Eds., vol. 12078. Springer, 2020, pp. 97–114.
- [19] A. Abate, D. Ahmed, M. Giacobbe, and A. Peruffo, “Formal synthesis of Lyapunov neural networks,” IEEE Control Systems Letters, vol. 5, no. 3, pp. 773–778, 2021.
- [20] H. Dai, B. Landry, L. Yang, M. Pavone, and R. Tedrake, “Lyapunov-stable neural-network control,” in Proceedings of Robotics: Science and Systems, Virtual, 2021.
- [21] G. O. Berger and S. Sankaranarayanan, “Counterexample-guided computation of polyhedral Lyapunov functions for hybrid systems,” 2022, arXiv preprint arXiv:2206.11176.
- [22] P. Prabhakar and M. G. Soto, “Counterexample guided abstraction refinement for stability analysis,” in Computer Aided Verification. CAV 2016., ser. Lecture Notes in Computer Science, S. Chaudhuri and A. Farzan, Eds., vol. 9779. Cham: Springer, 2016, pp. 495–512.
- [23] J.-P. Aubin and A. Cellina, Differential inclusions: set-valued maps and viability theory. Berlin: Springer, 1984.
- [24] M. Della Rossa, A. Tanwani, and L. Zaccarian, “Smooth approximation of patchy Lyapunov functions for switched systems,” IFAC-PapersOnLine, vol. 52, no. 16, pp. 364–369, 2019.
- [25] Y. Nesterov and A. Nemirovskii, Interior-point polynomial algorithms in convex programming. Philadelphia, PA: SIAM, 1994.
- [26] A. Ben-Tal and A. Nemirovski, Lectures on modern convex optimization: analysis, algorithms, and engineering applications. Philadelphia, PA: SIAM, 2001.
- [27] S. Boyd and L. Vandenberghe, “Localization and cutting-plane methods,” 2008, https://see.stanford.edu/materials/lsocoee364b/05-localization˙methods˙notes.pdf.
- [28] C. H. Papadimitriou, Computational Complexity. Reading, MA: Addison-Wesley, 1994.