99,198 research outputs found
Abstraction of Elementary Hybrid Systems by Variable Transformation
Elementary hybrid systems (EHSs) are those hybrid systems (HSs) containing
elementary functions such as exp, ln, sin, cos, etc. EHSs are very common in
practice, especially in safety-critical domains. Due to the non-polynomial
expressions which lead to undecidable arithmetic, verification of EHSs is very
hard. Existing approaches based on partition of state space or
over-approximation of reachable sets suffer from state explosion or inflation
of numerical errors. In this paper, we propose a symbolic abstraction approach
that reduces EHSs to polynomial hybrid systems (PHSs), by replacing all
non-polynomial terms with newly introduced variables. Thus the verification of
EHSs is reduced to the one of PHSs, enabling us to apply all the
well-established verification techniques and tools for PHSs to EHSs. In this
way, it is possible to avoid the limitations of many existing methods. We
illustrate the abstraction approach and its application in safety verification
of EHSs by several real world examples
Algorithmic Verification of Continuous and Hybrid Systems
We provide a tutorial introduction to reachability computation, a class of
computational techniques that exports verification technology toward continuous
and hybrid systems. For open under-determined systems, this technique can
sometimes replace an infinite number of simulations.Comment: In Proceedings INFINITY 2013, arXiv:1402.661
Numerical Verification of Affine Systems with up to a Billion Dimensions
Affine systems reachability is the basis of many verification methods. With
further computation, methods exist to reason about richer models with inputs,
nonlinear differential equations, and hybrid dynamics. As such, the scalability
of affine systems verification is a prerequisite to scalable analysis for more
complex systems. In this paper, we improve the scalability of affine systems
verification, in terms of the number of dimensions (variables) in the system.
The reachable states of affine systems can be written in terms of the matrix
exponential, and safety checking can be performed at specific time steps with
linear programming. Unfortunately, for large systems with many state variables,
this direct approach requires an intractable amount of memory while using an
intractable amount of computation time. We overcome these challenges by
combining several methods that leverage common problem structure. Memory is
reduced by exploiting initial states that are not full-dimensional and safety
properties (outputs) over a few linear projections of the state variables.
Computation time is saved by using numerical simulations to compute only
projections of the matrix exponential relevant for the verification problem.
Since large systems often have sparse dynamics, we use Krylov-subspace
simulation approaches based on the Arnoldi or Lanczos iterations. Our method
produces accurate counter-examples when properties are violated and, in the
extreme case with sufficient problem structure, can analyze a system with one
billion real-valued state variables
Efficient time stepping for numerical integration using reinforcement learning
Many problems in science and engineering require the efficient numerical
approximation of integrals, a particularly important application being the
numerical solution of initial value problems for differential equations. For
complex systems, an equidistant discretization is often inadvisable, as it
either results in prohibitively large errors or computational effort. To this
end, adaptive schemes have been developed that rely on error estimators based
on Taylor series expansions. While these estimators a) rely on strong
smoothness assumptions and b) may still result in erroneous steps for complex
systems (and thus require step rejection mechanisms), we here propose a
data-driven time stepping scheme based on machine learning, and more
specifically on reinforcement learning (RL) and meta-learning. First, one or
several (in the case of non-smooth or hybrid systems) base learners are trained
using RL. Then, a meta-learner is trained which (depending on the system state)
selects the base learner that appears to be optimal for the current situation.
Several examples including both smooth and non-smooth problems demonstrate the
superior performance of our approach over state-of-the-art numerical schemes.
The code is available under https://github.com/lueckem/quadrature-ML
Satisfiability Modulo Transcendental Functions via Incremental Linearization
In this paper we present an abstraction-refinement approach to Satisfiability
Modulo the theory of transcendental functions, such as exponentiation and
trigonometric functions. The transcendental functions are represented as
uninterpreted in the abstract space, which is described in terms of the
combined theory of linear arithmetic on the rationals with uninterpreted
functions, and are incrementally axiomatized by means of upper- and
lower-bounding piecewise-linear functions. Suitable numerical techniques are
used to ensure that the abstractions of the transcendental functions are sound
even in presence of irrationals. Our experimental evaluation on benchmarks from
verification and mathematics demonstrates the potential of our approach,
showing that it compares favorably with delta-satisfiability /interval
propagation and methods based on theorem proving
Making big steps in trajectories
We consider the solution of initial value problems within the context of
hybrid systems and emphasise the use of high precision approximations (in
software for exact real arithmetic). We propose a novel algorithm for the
computation of trajectories up to the area where discontinuous jumps appear,
applicable for holomorphic flow functions. Examples with a prototypical
implementation illustrate that the algorithm might provide results with higher
precision than well-known ODE solvers at a similar computation time
- …