A kinetic data structure is defined as a data structure implemented to track an attribute of a geometric system that is moving continuously. For example, a kinetic convex hull data structure tracks the convex hull of a group of n moving points.
The development of kinetic data structures was inspired by computational geometry problems involving physical objects in continuous motion, for example collision or visibility detection in robotics, animation or computer graphics.
Kinetic data structures are implemented on systems where there is a set of values that are changing as a function of time, in a called fashion. So the system has some values, and for each system value v, it is denoting that v=f(t). Kinetic data structures permit queries on a system at the current virtual time t, and two additional operations
Additional operations can be supported. For example, kinetic data structures are frequently implemented with a set of points. In this case, the structure typically permits points to be inserted and deleted.
A kinetic data structure permits the values stored in it to change continuously with time. In principle, this can be approximated by sampling the position of the points at fixed intervals of time, and deleting and re-inserting each point into a "static" (traditional) data structure. However, such an approach is susceptible to oversampling or undersampling, depending on what interval of time is implemented, and can also be wasteful of computational resources.
The following general approach can be implemented to build kinetic data structures
Certificate failures are denoted to as "events". An event is declared as internal if the property maintained by the kinetic data structure does not change at the time of occurrence of event. An event is declared as external if the property maintained by the data structure changes at the time of occurrence of event.
When implementing the certificates approach, there are four measures of performance. We call a quantity is small if it is a polylogarithmic function of n, or is O(n€) for randomly small €, where n is treated as the number of objects.