the _ parma polyhedra library _ ( ppl ) is a collaborative project started in january 2001 at the department of mathematics of the university of parma , italy . since 2002, the library is actively being developed also at the school of computing of the university of leeds , united kingdom .the ppl , that was initially limited as the name implies to the handling of ( not necessarily topologically closed ) convex polyhedra , is now aimed at becoming a truly professional , functionally complete library for the handling of numeric approximations targeted at abstract interpretation and computer - aided verification of hardware and software systems .  in this paperwe briefly describe the main features of the ppl .unless otherwise stated , the description refers to version 0.9 of the library , released on march 12 , 2006 . in other casesthe described features have not yet been included into an official release , but are still available from the ppl s public cvs repository ( since development of the library takes place on that repository , the ppl is always in a state of continuous release ) .  in the sequelwe will compare the ppl with other libraries for the manipulation of convex polyhedra .these are :  * _ polylib _ ( version 5.22.1 ) , originally designed by d. k. wilde , based on an efficient c implementation of n. v. chernikova s algorithm written by h. le verge , and further developed and maintained by v. loechner ; * _ new polka _( version 2.1.0a ) , by b. jeannet ; * the polyhedra library that comes with the _ hytech _ tool ( version 1.04f ) ; * the _ octagon abstract domain library _ ( version 0.9.8 ) , by a. min .  for reasons of space andopportunity , the paper concentrates on introducing the library to prospective users . as a consequence , we assume the reader has some familiarity with the applications of numerical abstractions in formal analysis and verification methods and that she is not immediately concerned by the theory that lies behind those abstractions. however , the paper provides a complete set of references that enable any interested reader to reconstruct every detail concerning the library , the applications and the relevant theory .the paper is structured as follows : section [ sec : abstractions ] introduces the numerical abstractions currently supported by the parma polyhedra library ; section [ sec : features ] describes , also by means of examples , some of the most important features of the library ; section [ sec : efficiency ] gives some indications concerning efficiency ; section [ sec : development - plans ] illustrates the current development plans for the library ; section [ sec : discussion ] reviews some of the applications using the ppl and concludes .the numerical abstractions currently supported by the parma polyhedra library are the domains of polyhedra , bounded difference shapes , octagonal shapes and grids ; powersets of these using the generic powerset construction ; and linear programming problems . for each of the supported abstractions, the library features all the operators required by semantic constructions based on _ abstract interpretation _ ; these are summarized in the following paragraphs .  [[ construction ] ] construction + + + + + + + + + + + +  the domain elements can be initialized by means of a variety of constructors ; in particular , they can be defined to be a vector space for a specified number of dimensions each dimension representing some concrete entity relevant for the particular analysis indicating that at this stage nothing is known about the entities , or the empty abstraction ( again for a given number of dimensions ) , describing an inconsistent ( unreachable ) state .an element can also be initialized by means of _ constraints _ , specifying conditions its points must satisfy ; alternatively , it can be described by _generators _ , that are meant to be parametrically combined so as to describe all of its points .new elements can also be constructed by copying an existing element in the same abstraction .[ [ refinement - and - expansion ] ] refinement and expansion + + + + + + + + + + + + + + + + + + + + + + + +  any domain element can be refined by the addition of further constraints its points must satisfy , thereby improving the precision of the description : a typical application of refinement is to model the effect of conditional guards in if - then - else and while - loop statements .the expansion operators allow users to add new generators so as to expand the set of points the element must contain ; these may be used , for instance , to `` forget '' some information regarding a space dimension , so as to model arbitrary input by the user .  [ [ upper - and - lower - bounds ] ] upper and lower bounds + + + + + + + + + + + + + + + + + + + + + +  it is often useful to compute an upper or lower bound of two domain elements so as to obtain a correct approximation of their union or intersection .for example , an analyzer could use an upper bound operator to combine approximations that have been computed along the alternative branches of an if - then - else statement while lower bound operators are needed , in combination with conversion operators ( see below ) , when conjunctively merging different approximations computed along the same set of computation paths .[ [ affine - images - and - preimages ] ] affine images and preimages + + + + + + + + + + + + + + + + + + + + + + + + + + +  a common form of statement in an imperative language is the assignment of an affine expression to a program variable .their semantics can be modeled by images ( in a forward analysis ) and/or preimages ( in a backward analysis ) of affine transformations on domain elements .all domains fully support the efficient ( and possibly approximate ) computation of affine images and preimages . also available are generalizations of these operators , useful for approximating more complex assignment statements ( e.g. , to model constrained nondeterministic assignments or when a non - linear expression can be bounded from below and/or above by affine expressions ) .[ [ changing - dimensions ] ] changing dimensions + + + + + + + + + + + + + + + + + + +  an analyzer needs to be able to add , remove , and more generally reorganize the space dimensions that are associated with the values of the concrete entities it is approximating .the simple addition and removal of dimensions is often needed at the entry and exit points of various kinds of programming contexts , such as declaration blocks where concrete entities ( modeled by some of the space dimensions ) may be local to the block .more complex operators are useful to support the integration of the results computed using different abstractions , that typically provide information about different sets of concrete entities . in the simplest case , when the abstractions are of the same kind but provide information about disjoint sets of concrete entities, it is enough to _ concatenate _ the two abstract elements into a new one . in more complex cases , when the described sets of concrete entities have an overlap , the space dimensions of one of the abstract elements need to be reconciled with those of the other , allowing for a correct integration of the information .this can be obtained by efficiently _ mapping _ the space dimensions according to a ( partial ) injective function .the library also supports the _ folding _ ( and unfolding ) of space dimensions , which is needed to correctly and efficiently summarize the information regarding collections of concrete entities  .[ [ conversion ] ] conversion + + + + + + + + + +  non - trivial analyses are typically based on a combination of domains .it is therefore important to be able to safely and efficiently convert between different abstractions .these conversions enable , for instance , the combination of domain elements representing different kinds of information , implementing so - called _ reduction _ operators .another important application is the dynamic control of the precision / efficiency ratio : in order to gain efficiency in the analysis of a specific context , an element of a relatively precise domain can temporarily be converted into an element of a weaker domain and then back to the stronger abstraction on exit from that context .[ [ comparison ] ] comparison + + + + + + + + + +  the analysis of a program fragment is implemented by computing an over - approximation of its semantics .since the latter is usually modeled as the least fixpoint of a continuous operator , a safe analysis typically needs to iteratively compute an over - approximation of this fixpoint .therefore , a suitable lattice - theoretic comparison operator is needed so as to check for the convergence of the analysis .comparison operators are also useful in selected contexts so as to efficiently predict whether or not some precision improving techniques ( e.g. , reductions , widening variants and so on ) are applicable .for all of the reasons above , each domain provides three different comparison operators checking , respectively , equality , containment and strict containment .[ [ widening ] ] widening + + + + + + + +  most of the domains supported by the library admit _infinite ascending chains_. these are infinite sequences of domain elements such that every element in the sequence is contained in the element that follows it . with these characteristics ,the fixpoint computations upon which abstract interpretation analysis techniques are based could be non - terminating .for this reason , the domains can be so employed only in conjunction with appropriate mechanisms for enforcing and/or accelerating the convergence of fixpoint computations : widening operators provide a simple and general characterization for such mechanisms .the ppl offers also several variations of the available widenings : widening `` with tokens '' ( an improvement to the widening delay technique proposed in ) ; and widening `` up to '' ( a technique whereby constraints that are judged to be important by the application can be preserved from the action of the widening ) .[ [ other - operators ] ] other operators + + + + + + + + + + + + + + +  the library offers many other operators for use in a variety of more specialized contexts .for instance , before performing a non - trivial domain combination , an analyzer may need information about a particular domain element ( such as , checking whether it denotes the empty set or the whole vector space ; the dimension of the vector space ; the affine dimension of the element ; its relation with respect to a given constraint or generator , and so on ) . another operator supported by the libraryis the _ difference _ operator , which computes the smallest domain element that contains the set difference of two elements ; this is exploited in the implementation of the finite powerset widening operator proposed in  .the library also provides the _ time - elapse _operator used to model hybrid systems .the following sections briefly describe each of the supported domains .the emphasis here is on the features that are unique to the ppl .the reader is referred to the cited literature and to the library s documentation for all the details .the parma polyhedra library supports computations on the abstract domain of convex polyhedra .the ppl implements both the abstract domain of topologically _ closed convex polyhedra _( briefly called _ c polyhedra _ and implemented by class ` c_polyhedron ` ) and the abstract domain of _ not necessarily closed convex polyhedra _( _ nnc polyhedra _ for short , class ` nnc_polyhedron ` ) . in both cases ,polyhedra are represented and manipulated using the _double description _( dd ) method of motzkin et al . . in this approach ,a closed convex polyhedron can be specified in two ways , using a _ constraint system _ ( class ` constraint_system ` ) or a _ generator system _ ( class ` generator_system ` ) : the constraint system is a finite set of linear equality or inequality constraints ( class ` constraint ` ) ; the generator system is a finite set of different kinds of vectors , collectively called _generators _ , which are rays and points of the polyhedron ( class ` generator ` ) .an example of double description is depicted in figure [ fig : polyhedron - double - description ] : the polyhedron represented by the shaded region can be represented by the set of vectors satisfying the constraints or , equivalently , by the set where , , , , and is the set of non - negative real numbers . in words ,each vector can be obtained by adding a non - negative combination of the rays and a convex combination of the points .(-2,-2)(25,25 ) \pspolygon[fillstyle = solid , fillcolor = green , linecolor = green](1,4)(11,24)(24,24)(24,11)(4,1 ) \psline[linecolor = blue](-2,7)(7,-2 ) \psline[linecolor = blue](-1.5,-1)(11,24 ) \psline[linecolor = blue](-1,-1.5)(24,11 ) \psdots*[linecolor = red , dotstyle = square*,dotsize=0.6 0.6](1,4)(4,1 ) \psline[linecolor = red]{->}(2.5,2.5)(4.5,6.5 ) \psline[linecolor = red]{->}(2.5,2.5)(6.5,4.5 ) \psline{->}(-2,0)(24,0 ) \psline{->}(0,-2)(0,24 ) \rput(23,-0.8){ } \rput(-0.8,23){ } \endpspicture\ ] ]   & \begin{cases }  \red{\text{points : } \bigl\ { ( 4 , 1 ) , ( 1 , 4 ) \bigr\ } } \\  \red{\text{rays : } \ { ( 1 , 2 ) , ( 2 , 1 ) \ } } \end{cases}\end{aligned}\ ] ]  implementation of convex polyhedra using the dd method offer some important advantages to analysis and verification applications .the first one is due to the `` mix '' of operations such applications require : some of them are more efficiently performed on the representation with constraints .this is the case for the addition of constraints and for the intersection , which is simply implemented as the union of constraint systems , and for deciding whether a generator is subsumed or not by a polyhedron ( e.g. , to decide whether a point is inside or outside ) .some operations are instead more efficiently performed on generators : computing the convex polyhedral hull ( just by taking the union of generator systems ) , adding individual generators ( e.g. , the addition of the rays and to the set of rays for the polyhedron in figure [ fig : polyhedron - double - description ] is the easiest way to `` forget '' all the information concerning the space dimension  ) , projection onto designated dimensions , deciding whether the space defined by a constraint is disjoint , intersects or includes a given polyhedron , finiteness / boundedness tests ( a polyhedron is finite / bounded if and only if it has no rays among its generators ) , and the _ time - elapse _ operator of  .there are also important operations , such as the inclusion and equality tests and the widenings , that are more efficiently performed when _ both _ representations are available .systems of constraints and generators enjoy a quite strong and useful duality property .very roughly speaking , the constraints of a polyhedron are ( almost ) the generators of the _ polar _ of the polyhedron , the generators of a polyhedron are ( almost ) the constraints of the polar of the polyhedron , and the polar of the polar of a polyhedron is the polyhedron itself .this implies that computing constraints from generators is the same problem as computing generators from constraints .the algorithm of n. v. chernikova ( later improved by h. le verge and by k. fukuda and a. prodon ) solves both problems yielding a minimized system and can be implemented so that the source system is also minimized in the process .this is basically the algorithm employed by polylib , new polka and the parma polyhedra library .it is worth noticing that it is not restrictive to express the coefficients of constraints and rays by integer numbers , as using rational numbers would not result in increased expressivity ( but would have a negative impact on efficiency ) . for points, a common integer denominator suffices .  restricting the attention to convex polyhedra ,two of the main innovations introduced by the ppl are the complete handling of nnc polyhedra and the introduction of a new widening operator . apart from the ppl , the only libraries among those that provide the services required by applications in static analysis and computer - aided verification that support nnc polyhedra are the already mentioned new polka and the library by n. halbwachs , a. kerbrat and y .- e .proy called , simply , _ polka _ . the polka library ,however , is not available in source format and binaries are distributed under rather restrictive conditions ( until about the year 1996 they could be freely downloaded ) , so our knowledge of it is as given in , the programmer s manual in a package that includes the actual library .the support provided by polka and new polka for nnc polyhedra is incomplete , incurs avoidable inefficiencies and leaves the client application with the non - trivial task of a correct interpretation of the results . in particular , even though an nnc polyhedron can be described by using constraint systems that may contain strict inequalities , the polka and new polka libraries lack a corresponding extension for generator systems . in contrast , the ppl implements the proposal put forward in , whereby the introduction of _ closure points _ as a new kind of generator , allows a clean user interface , symmetric to the constraint system interface for nnc polyhedra , that is decoupled from the implementation . as explained in detail in , a user of the ppl is fully shielded from implementation details such as the extra dimension that users of the other libraries have to carefully take into account .another feature that is unique to the ppl is the support for the minimization of the descriptions of an nnc polyhedron : we refer the interested reader to for a precise account of the impact this new feature has on performance and usability .the original widening operator proposed by cousot and halbwachs is termed _ standard widening _ since , for 25 years , all analysis and verification tools that employed convex polyhedra also employed that operator .nonetheless , there was an unfulfilled demand for more precise widening operators .the parma polyhedra library , besides the standard widening , offers the new widening proposed in : on a single application this is always more precise than the standard widening . as these wideningsare not monotonic , increased precision on a single application does not imply increased precision on the final result of the analysis . in practice , however , an overall increase of precision is almost always achieved .both widenings can be improved , as said before , by applying the `` widening with tokens '' delay strategy or the `` widening up - to '' technique ; moreover , `` bounded '' extrapolation operators are available that provide additional precision guarantees over the widenings upon which they are built .   by restricting to particular subclasses of linear constraints , it is possible to obtain domains that are simpler and computationally more efficient than the one of convex polyhedra .one possibility , which has a long tradition in computer science  , is to only consider _ potential constraints _ , also known as _ bounded differences _ : these are restricted to take the form or , where and are variables and , the _ inhomogeneous term _, belongs to some computable number family .systems of bounded differences have been used by the artificial intelligence community as a way to reason about temporal quantities , as well as by the model checking community as an efficient yet precise way to model and propagate timing requirements during the verification of various kinds of concurrent systems . in the abstract interpretation field , the idea of using an abstract domain of bounded differences was put forward in and the first fully developed application of bounded differences in this field can be found in  .possible representations for finite systems of bounded differences are matrix - like data structures called _ difference - bound matrices _( dbm ) and weighted graphs called _ constraint networks _ .these representations , however , have a `` syntactic '' nature : they encode sets of constraints rather than geometric shapes .as pointed out in this nature has several drawbacks , the most important one being that natural extrapolation operators do not provide a convergence guarantee , that is , they are not widenings .this results into an extra burden on the client application , which has to take into account the implementation details and use the domain elements with care so as to avoid non - termination of the analysis .  in order to overcome the difficulties mentioned above and to continue pursuing a complete separation between interface ( which must be natural and easy to use ) and implementation ( which must be efficient and robust ) , the parma polyhedra library offers the `` semantic '' domain of _ bounded difference shapes_. a bounded difference shapeis nothing but a geometric shape , that is , a convex polyhedron : its internal representation needs not concern ( and , in fact , is completely hidden from ) the client application .the class template implementing this domain in the ppl is ` bd_shape < t > ` , where the class template type parameter ` t ` defines the family of numbers that are used to ( correctly ) approximate the inhomogeneous terms of bounded differences .the value of ` t ` may be one of the following :  * a bounded precision native integer type ( that is , from ` signed ` ` char ` to ` long ` ` long ` and from ` int8_t ` to ` int64_t ` ) ; * a bounded precision floating point type ( ` float ` , ` double ` or ` long ` ` double ` ) ; * an unbounded integer or rational type , as provided by gmp ( ` mpz_class ` or ` mpq_class ` ) .  among other things ,ppl s ` bd_shape < t > ` offers the proper widening operator defined in and a user interface that matches the interfaces of the general polyhedra classes ` c_polyhedron ` and ` nnc_polyhedron ` .another restricted class of linear constraints was introduced in  .these are of the form , where and belongs to some computable number family .systems of such constraints were called _ simple sections _ in  and have been given the structure of an abstract domain by a. min . the resulting _ octagon abstract domain _ has , due to its syntactic nature , the same problems outlined in the previous section .this is why , as explained in detail in , the parma polyhedra library offers a semantic domain of _ octagonal shapes _ , for which it provides a widening operator .this is implemented by the class template ` octagonal_shape < t > ` , where the class template type parameter ` t ` can be instantiated as for bounded difference shapes .another feature of this class is that its implementation uses the strong closure algorithm introduced in , which has lower complexity than the one used in the octagon abstract domain library .given , ,  , , , the _ linear congruence relation _ denotes the subset of given by when , the relation is said to be _ proper _ ; when , the relation is equivalent to ( i.e. , it denotes the same hyperplane as ) .a _ congruence system _ is a finite set of congruence relations and a _ grid _ is any subset of whose elements satisfy all the congruences of such a system .the _ grid domain _ is the set of all such grids .(-3.5,0)(3.6,6.2 ) \psline{->}(-2.2,3)(3.6,3 ) \psline{->}(0,0.5)(0,6.2 ) \rput(2.35,2.45){ } \rput(-1.3,5.65){ } \psline[linecolor = blue , linestyle = dashed , dash=6pt 2pt ] ( -2,0.7)(-2,5.8 ) \psline[linecolor = blue , linestyle = dashed , dash=6pt 2pt ] ( -1,0.7)(-1,5.8 ) \psline[linecolor = blue , linestyle = dashed , dash=6pt 2pt ] ( 0,0.7)(0,5.8 ) \psline[linecolor = blue , linestyle = dashed , dash=6pt 2pt ] ( 1,0.7)(1,5.8 ) \psline[linecolor = blue , linestyle = dashed , dash=6pt 2pt ] ( 2,0.7)(2,5.8 ) \psline[linecolor = blue , linestyle = dashed , dash=6pt 2pt ] ( 3,0.7)(3,5.8 ) \psline[linecolor = blue , linestyle = dashed , dash=6pt 2pt ] ( 1.4,5.8)(3.2,4.9 ) \psline[linecolor = blue , linestyle = dashed , dash=6pt 2pt ] ( -0.6,5.8)(3.2,3.9 ) \psline[linecolor = blue , linestyle = dashed , dash=6pt 2pt ] ( -2.2,5.6)(3.2,2.9 ) \psline[linecolor = blue , linestyle = dashed , dash=6pt 2pt ] ( -2.2,4.6)(3.2,1.9 ) \psline[linecolor = blue , linestyle = dashed , dash=6pt 2pt ] ( -2.2,3.6)(3.2,0.9 ) \psline[linecolor = blue , linestyle = dashed , dash=6pt 2pt ] ( -2.2,2.6)(1.6,0.7 ) \psline[linecolor = blue , linestyle = dashed , dash=6pt 2pt ] ( -2.2,1.6)(-0.4,0.7 ) \psdots*[linecolor = red , dotstyle = square , dotsize=0.15 0.15 ] ( -2,1.5)(-2,2.5)(-2,3.5)(-2,4.5)(-2,5.5 ) ( -1,1)(-1,2)(-1,3)(-1,4)(-1,5 ) ( 0,1.5)(0,2.5)(0,3.5)(0,4.5)(0,5.5 ) ( 1,1)(1,2)(1,3)(1,4)(1,5 ) ( 2,1.5)(2,2.5)(2,3.5)(2,4.5)(2,5.5 ) ( 3,1)(3,2)(3,3)(3,4)(3,5 ) \psdots*[linecolor = red , dotstyle = square*,dotsize=0.15 0.15 ] ( 1,3)(3,3)(2,3.5 ) \psline[linecolor = red]{->}(1,3)(2.92,3 ) \psline[linecolor = red]{->}(1,3)(1.92,3.475 ) \endpspicture\ ] ]   & \begin{cases }  \red{\text{points : } \bigl\ { ( 2 , 0 ) , ( 6 , 0 ) , ( 4 , 1 ) \bigr\ } } \end{cases } \\[1 cm ] & \begin{cases }  \red{\text{points : } \bigl\ { ( 2 , 0 ) \bigr\ } } \\\red{\text{parameters : } \bigl\ { ( 4 , 0 ) , ( 2 , 1 ) \bigr\ } } \\ \end{cases}\end{aligned}\ ] ]  an example of grid is given in figure [ fig : grid - double - description ] , where the solutions of the congruence relations are given by the dashed lines and the grid elements by the ( filled and unfilled ) squares .the figure shows also that there is an alternative way of describing the same grid : if we call the points marked by the filled squares , and , we can see that the grid is given by we say that the set of _ points _ _ generates _ the grid .some of these generating points can be replaced by _parameters _ that give the direction and spacing for the neighboring points . specifically , by subtracting the point from each of the other two generating points and , we obtain the parameters and and can now express the grid as notice that , in the generator representation for grids , points and parameters can have rational , non integer coordinates .the domain of grids , as briefly described above , has been introduced by p. granger and its design has been completed in by including refined algorithms and new operators for affine images , preimages and their generalizations , grid - difference and widening .the parma polyhedra library includes the first truly complete implementation of this abstract domain by means of the ` grid ` class .congruence relations and systems thereof are realized by the classes ` congruence ` and ` congruence_system ` , and likewise for generators with the classes ` grid_generator ` , and ` grid_generator_system ` .  a more restricted domain ,the domain of _ integral lattices _ has been partly implemented in polylib  following the approach in  .an integral lattice in dimension is the grid generated by the affine integral combination as in of exactly affinely independent points that are additionally bound to have integer coordinates .these restrictions have the consequences that only the generator representation is supported and , as explained in , the reduced expressivity has an impact on the possibility to solve concrete analysis problems .the implementation of the domain of integral lattices in polylib is incomplete in the sense that it misses domain operators such as the join .instead , it provides a union operator which , given two lattices returns a _ set _ of lattices representing the precise set union of the points of the given lattices .similarly the difference operation on a pair of lattices returns a set of lattices whose union contains the exact set difference of their points . moreover , although image and preimage operators are supported by polylib , as the integral lattice must be full dimensional , only invertible image operators are allowed .   for applications requiring a high degree of precision ,the parma polyhedra library provides a generic implementation of the _ finite powerset _ construction .this upgrades an abstract domain into a refined one where finite disjunctions of non redundant elements are precisely representable .the construction is implemented generically by the class template ` powerset < d > ` , where the type parameter ` d ` must provide about ten methods and operators implementing , among other things , an entailment predicate and operators for obtaining an upper bound and the `` meet '' of two given elements .no other requirements are imposed and , in fact , the test suite of the ppl includes a program where ` powerset < d > ` is instantiated with a non numerical domain .the class template ` pointset_powerset < ps > ` provides a specialization of class ` powerset < d > ` that is suitable for the instantiation with the `` semantic '' numerical domains of the ppl : ( c or nnc ) polyhedra , bounded difference shapes , octagonal shapes , grids and combinations thereof .a most notable and , at the time of writing , unique feature of this implementation is the provision in addition to the extrapolation operator proposed in of provably correct , _ certificate - based _ widening operators that lift the widening operators defined on the underlying domain ` ps ` .the library includes a linear programming ( lp ) solver based on the simplex algorithm and using exact arithmetic .note that the absence of rounding errors is essential for most ( if not all ) of the intended applications .since it is common practice to solve an lp problem by exploiting duality results , correctness may be lost even if _ controlled rounding _ is used ; this is because a feasible but possibly non - optimal solution for the dual of an lp problem may actually correspond to an unfeasible solution for the original lp problem .the lp solver interface allows for both satisfiability checks and optimization of linear objective functions .a limited form of incrementality allows for the efficient re - optimization of an lp problem after modification of the objective function .ongoing implementation work is focusing on improving the efficiency of the solver as well as providing better support for incremental computations , so as to also allow for the efficient re - optimization of the lp problem after a modification of the feasible region caused by the addition of further constraints .in this section we will briefly review the main features of the parma polyhedra library .we will focus on usability , on the absence of arbitrary limits due to the use of fully dynamic data structures , on some of the measures that contribute to the library s robustness , on the support for resource - bounded computations , on the possibility to use machine integer coefficients without compromising correctness , on portability and on the availability of complete documentation .   by `` usability '' of the parma polyhedra librarywe actually mean two things :  1 .  that the library provides natural , easy to use interfaces that can be used , even by the non expert , to quickly prototype an application ; 2 .  that, nonetheless , the library and its interfaces provide all the functionalities that allow their use in the development of professional , reliable applications .  in other words , simplicity of the interfaceshas not been obtained with simplistic solutions or by the omission of functionalities .  as mentioned before particular care has been taken ( to the point of developing the necessary theoretical concepts ) in the complete decoupling of the user interfaces from all implementation details .so , the internal representation of , say , constraints , congruences , generators and systems thereof need not concern the client application .all the user interfaces , whatever language they interface to , refer to high - level concepts and never to their possible implementation in terms of vectors , matrices or other data structures .for instance , unlike polylib and new polka , implementation devices ( such as so - called _ positivity constraints _ or _ -representations _ ) never surface at the user level and need not concern the client application . as another example, a user of the octagon abstract domain library must know that octagons are represented there by means of difference - bound matrices , that some of the operations on octagons do `` close '' these matrices , and that one argument to the widening is better closed for improved accuracy while the other should _ not _ be closed as this would prevent convergence .the parma polyhedra library currently offers , besides the c interface , a portable prolog interface and a c interface .the prolog interface is `` portable '' in that it supports ( despite the lack of standardization of prolog foreign language interfaces ) six major prolog systems : ciao , gnu prolog , swi - prolog , sicstus , xsb and yap .the c interface is particularly important , as it allows to interface the ppl with almost anything else : for example , third parties have already built interfaces for haskell , java and objective caml .the design of the interfaces to directly supported languages has been focused on ensuring that programmers can use the library following the most natural programming style in _ that _ language . as a simple example , in the appropriate contexts , `` x < 5*z ` ' and `` x + 2*y + 5*z > = 7 ` ' is valid syntax expressing a strict and a non - strict inequality , both in the c and the prolog interfaces .this can be done because both languages allow to override ( or freely interpret ) operators and provide exceptions as a powerful method of reporting run - time errors . hereis how a nnc polyhedron in a space of dimension  can be created using the c interface : and here is how the same polyhedron can be created using the prolog interface :  in standard c things are more complicate as the language syntax does not allow to represent , say , constraints as easily .thus , in order to build constraints the c application will have to build the linear expressions occurring in them and the memory used to hold these intermediate data structures will have to be explicitly managed , unless a conservative garbage collector is used .moreover , lack of exceptions means that non - trivial error detection and handling will demand significantly more effort in c than in c or prolog ( _ all _ the functions of the c interface return an ` int ` : a negative value indicates an error has occurred ) . the best approach to development usingthe c interface is to begin by developing a layer of interface functions that are suited to the application at hand : the ppl s c interface provides all the required services .  still on the subject of ease of use , the numeric abstractions provided by the library provide similar interfaces .a high degree of integration is obtained through the adoption of common data types and the availability of methods specifically designed for interoperability . as a consequence, the specification and implementation of new abstractions and tools can be easily obtained by composition of the available services . as a simple example , the code in listing [ lst : lp_solver ] is exploiting the lp solver capabilities to efficiently compute ( and print ) all the upper bounds for the variables corresponding to the dimensions of a closed polyhedron .note that the code in listing [ lst : lp_solver ] is taking advantage of a limited form of incrementality provided by the lp solver : the check for satisfiability ( corresponding to the first phase of the simplex algorithm ) is executed only once and it is not repeated when optimizing the different objective functions ( namely , only the second phase of the simplex algorithm is executed in the for - loop ) .code similar to the one above is actually used in the library itself to precisely approximate a polyhedron by means of a bounded difference or octagonal shape without incurring the potentially high cost of converting from the constraint to the generator representation of the polyhedron .the only real restrictions imposed by the library on the client application are those caused by limitations of the available virtual memory .all data structures are fully dynamic and automatically expand ( in amortized constant time ) and shrink in a way that is completely transparent to the user , ensuring the best use of available memory .in contrast , in the polylib , new polka and hytech libraries , matrices of coefficients , which are the main data structures used to represent polyhedra , can not grow dynamically and the client application is ultimately responsible for specifying their dimensions .since the worst case space complexity of the methods employed is exponential , in general the client application can not make a safe and practical choice : specifying small dimensions may provoke a run - time failure ; generous dimensions may waste significant amounts of memory and , again , result in unnecessary run - time failures .   the clean separation between interface and implementation , among other important advantages , allows for the adoption of incremental and lazy computation techniques .the increased efficiency due to these techniques amply repays the cost of the interface checks that contribute to the library s robustness , which , as it will be explained in the sequel , is one of its most important features .first , the library systematically checks all the interface invariants and throws an exception if any one of them is violated .this makes it very difficult to inadvertently create invalid objects and greatly simplifies the debugging of client applications .secondly , the library is exception - safe , that is , it never leaks resources or leaves invalid object fragments around , even in the presence of exceptions .in particular , if an exception is raised , then all the memory allocated by the failed computation is discarded .these features allows applications using the ppl to use timeouts or to sensibly deal with run - time errors such as arithmetic overflows and out - of - memory conditions , so as to continue the computation in a reliable state ( see below for more on this subject ) .it is important to stress that , while error handling and recovery are somewhat optional features ( there may be no interest in continuing the computation after an error has occurred ) , error detection should be considered a mandatory feature in the field of system s analysis and verification , since failure to detect an error can easily result into undefined ( i.e. , completely unpredictable ) behavior , therefore compromising any statement about correctness .  for comparison, polylib detects only some errors , sometimes setting a flag and sometimes printing a message and aborting , whereas new polka and the hytech libraries detect some errors , print an error message and abort .the octagon abstract domain library makes no attempt at detecting errors .none of these libraries perform a systematic check of interface invariants .the library , thanks to its exception - safety characteristics , naturally supports resource - bounded computations , that is , computations that are limited in the amount of cpu time or virtual memory or both .the client application can take advantage of this feature by attempting a computation that is potentially very expensive imposing a maximum limit on the resources to be used .should this bound be exceeded , an exception is raised and the client application can resort to a simplified computation ( possibly using a simpler numerical abstraction ) trusting that the ppl will release all the resources allocated by the interrupted computation . with these facilities at hand , users of the library can quite easily code resource - bounded or , at least , resource - conscious numerical abstractions .an example is shown in listing [ lst : decl - rcc ] .this uses the _parma watchdog library _ ( pwl ) , a library that virtualizes the interval timers for any xsi - conforming implementation of unix .the pwl , which is currently distributed with the ppl , gives an application the ability to work with an unbounded number of independent `` watchdog '' timers .the example class ` up_appr_polyhedron ` is meant to provide convex polyhedra with `` upward approximated '' , resource - conscious operations . as the main representation it uses closed convex polyhedra ; the user can set a timeout for the operations and externally impose a limit on the virtual memory available to the process .when a resource limit is reached , the class temporarily switches to a simpler family of polyhedra : bounded difference shapes .listing [ lst : def - rcc ] shows a simple implementation for the intersection operation .if no timeout has been requested , then the operation is performed without any overhead .otherwise the polyhedra are copied , a watchdog timer , ` w ` , is set and the operation is attempted . when ` w ` expires , the ppl is asked to abandon all expensive computations and to throw ` timeout_object ` . alternatively ,if the process exceeds the virtual memory it has been allotted , then the ` bad_alloc ` standard exception will be thrown .if none of those happen , then control will be returned to the caller . otherwise , bounded difference shapes approximating the argument polyhedra will be computed using a polynomial complexity method , , it is also possible to compute these approximations using a `` simplex complexity '' algorithm ( i.e. , theoretically exponential but very efficient in practice ) . ]these shapes will be intersected and the intersection will be used to construct the resulting convex polyhedron .the technique illustrated in a simplified way by listings [ lst : decl - rcc ] and [ lst : def - rcc ] is quite powerful and allows to deal with the complexity - precision trade - off in a very flexible way .in particular , it is possible , thanks to the pwl , to work with multiple timers : while individual polyhedra operations can be guarded by a timer , other timers can monitor operations of greater granularity , such as entire analysis phases .when an analysis phase is taking too much , then the timeouts used for the individual operations can be shortened or the analyzer can switch to a totally different , less complex analysis technique .it is worth observing that , notwithstanding the friendliness of the ppl s user interfaces , professional applications in the field of system s analysis and verification are not expected to be directly based on the abstractions provided by the library .rather , the ppl abstractions have been designed so as to serve as building blocks for the actual analysis domains : in this field the complexity - precision trade - off is often so serious that the right way to face it is , by necessity , application - dependent .   for the representation of general convex polyhedra , with the default configuration ,the parma polyhedra library uses unbounded precision integers . on the other hand , if speed is important and the numerical coefficients involved are likely to be small , applications may use native integers ( 8 , 16 , 32 and 64 bit integers are supported by the ppl ) .this is a safe strategy since , when using native integers , the library also performs systematic ( yet efficient ) overflow detection .it is thus possible to adopt an approach whereby computations are first attempted with native integers . if a computation runs to completion , the user can be certain that no overflow occurred .otherwise an exception is raised ( as in the case seen before for resource - bounded computations ) , so that the client application can be restarted with bigger native integers or with unbounded integers .this is another application of the library s exception - safety , as one can rather simply code the above approach as follows : again , the client application does not need to be concerned about the resources allocated by the ppl during the computation of the ` try ` block : everything will be deallocated automatically .concerning other libraries , polylib and new polka can use unbounded integers as coefficients , whereas the library of hytech does not support them . differently from the ppl ,these libraries use finite integral types without any mechanism for overflow detection . technically speaking and according to the c standard ( the language in which they are written ), this means that the effects of an overflow are completely undefined , i.e. , client applications can not make any assumption about what can happen should an overflow occur .in addition , polylib ( and , according to , some versions of hytech ) can use floating point values , in which case underflows and rounding errors , in addition to overflows , can affect the results .great care has been taken to ensure the portability of the ppl .the library is written in standard c , it follows all the available applicable standards and uses sophisticated automatic configuration mechanisms .it is known to run on all major unix - like operating systems , on mac os x ( whether intel- or powerpc - based ) and on windows ( via cygwin or mingw ) .a big investment has also been made on documentation and at several levels .first , the theoretical underpinnings have been thoroughly investigated , integrated when necessary and written down : an extensive bibliography is available on the ppl web site . secondly , during the entire development of the library , the quality , accessibility and completeness of the documentation has always been given a particular emphasis : while some parts of the library need more work in this respect , the vast majority of the code is thoroughly documented and some parts of it approach the ideal of `` literate programming . ''the library has been documented using the doxygen tool .doxygen is a documentation system for c++ , c , java , and other languages that allows to generate high - quality documentation from a collection of documented source files .the source files can be documented by means of ordinary comments , that can be placed near the program elements being documented : just above the declaration or definition of a member , class or namespace , for instance .this makes it much easier to keep the documentation consistent with the actual source code .moreover , doxygen allows the typesetting of mathematical formulas within comments by means of the relevant subset of latex , which is an important feature for a project like the ppl .it is also able to automatically extract the code structure and use this information to generate include dependency graphs , inheritance diagrams , and collaboration diagrams .doxygen can generate documentation in various formats , such as html , postscript and pdf .the html and pdf output are fully hyperlinked , a feature that greatly facilitates `` navigation '' in the available documentation .the parma polyhedra library is equipped with two manuals generated with the help of doxygen : a user s manual , containing all and only the information needed by people wishing to use the library ; and a developer s reference manual that contains , in addition , all the details concerning the library implementation .all manuals are available , in various formats , from the ppl web site and the user s manual is also included in each source distribution .one natural question is how does the efficiency of the parma polyhedra library compare with that of other polyhedra libraries .of course , such a question does not have a definite answer .apart from clarifying whether cpu or memory efficiency or both are the intended measures of interest , the answer will depend on the targeted applications : with different applications the results can vary wildly .moreover , even within the same application , big variations may be observed for different inputs . for these reasons, it must be admitted that the only way to meaningfully assess the performance of the library is with respect to a particular application , a particular set of problem instances , and a particular definition of ` performance ' .for the same reasons , it is nonetheless instructive to compare the performance of various polyhedra libraries on a well - defined problem with a large set of freely available inputs .one such problem , called _vertex / facet enumeration _ , is particularly relevant for implementations based on the double description method such as the parma polyhedra library , new polka and polylib , as this problem has to be solved whenever one description has to be converted into the other one .the vertex / facet enumeration problem is a well - studied one and several systems have been expressly developed to solve it .we have thus compared the above mentioned libraries with the following ( in parentheses , the versions we have tested ) :  * cddlib ( version 0.94b ) , a c implementation of the double description method , by k. fukuda ; * lrslib ( version 0.42b ) , a c implementation of the reverse search algorithm for vertex enumeration / convex hull problems , by d. avis ; * pd ( version 1.7 ) , a c program implementing a primal - dual algorithm using rational arithmetic , by a. marzetta and maintained by d. bremner .both cddlib and lrslib come with driver programs that support a polyhedra input format that was introduced by k. fukuda and extended by d. avis ; this input format is also supported by the pd program .the distributions of cddlib and lrslib provide more than 100 different inputs of varying complexity for these programs .driver programs that can read the same input format and use the ppl , new polka and polylib are part of the ppl distribution since version 0.7 .the tests have been performed on a pc equipped with an amd athlon 2800 + with 1 gb of ram and running gnu / linux and gmp version 4.2 .all the software has been compiled with gcc 4.0.3 at the optimization level that is the default for each package ( i.e. , the ppl was compiled with `` -o2 ` ' , its default ; polylib , cddlib , and pd with ` -o2 ` ; new polka and lrslib with `` -o3 ` ' ) .the obtained running times , in seconds , are reported in tables [ tab : efficiency - vertex - enumeration ] and [ tab : efficiency - vertex - enumeration - hard ] .the entries marked with ` n.a . ' in the pd s column indicate the problems that can not be solved by pd , which can only handle polyhedra that contain the origin .entries marked with ` ovfl ' indicate the problems on which pd runs into an arithmetic overflow . it should be noted that strictly speaking , lrslib solves a slightly different , easier problem than the one solved by the other systems :while the latter guarantee the result is minimized , the output of lrslib may contain duplicate rays .l ......   + & & & & & & +   + & & & & & & + ` ccc4.e`&0.00&0.11&0.03&0.00&0.00 & + ` ccc5.e`&0.00&0.10&0.04&0.02&0.00 & + ` ccc6.e`&0.03&0.14&0.26&0.61&3.12 & + ` ccp4.e`&0.00&0.10&0.02&0.00&0.00&0.01 + ` ccp5.e`&0.00&0.10&0.04&0.02&0.00&5.36 + ` ccp6.e`&0.05&0.15&0.31&0.90&3.95 & + ` cp4.e`&0.00&0.08&0.03&0.00&0.00&0.01 + ` cp5.e`&0.00&0.12&0.05&0.02&0.00&5.29 + ` cp6.e`&0.05&0.18&0.30&0.88&3.86 & + ` cube.e`&0.00&0.05&0.02&0.00&0.00&0.00 + ` cut16_11.e`&0.00&0.12&0.04&0.02&0.00&3.86 + ` cut32_16.e`&0.05&0.17&0.28&0.91&4.32 & + ` cyclic10 - 4.e`&0.00&0.07&0.02&0.00&0.00&0.00 + ` cyclic12 - 6.e`&0.00&0.08&0.03&0.01&0.00&0.44 + ` cyclic14 - 8.e`&0.00&0.09&0.04&0.06&0.01&172.10 + ` cyclic16 - 10.e`&0.02&0.14&0.07&0.24&0.04 & + ` dcube10.e`&0.02&0.13&0.10&0.23&0.02 & + ` dcube12.e`&0.17&0.22&2.66&1.29&0.10 & + ` dcube3.e`&0.00&0.08&0.02&0.00&0.00&0.00 + ` dcube6.e`&0.00&0.07&0.03&0.00&0.00&0.35 + `dcube8.e`&0.00&0.12&0.03&0.04&0.00&119.53 + ` irbox20 - 4.e`&0.00&0.08&0.01&0.01&0.00&0.01 + ` irbox200 - 4.e`&0.02&0.07&0.02&0.98&0.05&0.18 + ` mp5.e`&0.00&0.11&0.05&0.59&0.84&3.93 + ` prodst62.e`&34.78&161.09&123.28 & & & + ` redcheck.e`&0.00&0.06&0.01&0.00&0.00&0.00 + ` reg24 - 5.e`&0.00&0.08&0.03&0.01&0.00&0.01 +` reg600 - 5_m.e`&5.05&19.12&12.37&135.49&33.63 & + ` samplev1.e`&0.00&0.09&0.02&0.00&0.00 & + ` samplev2.e`&0.00&0.06&0.02&0.00&0.00 & + ` samplev3.e`&0.00&0.07&0.02&0.00&0.00 & + ` tsp5.e`&0.00&0.12&0.04&0.00&0.00 & + ` allzero.i`&0.00&0.06&0.01&0.00&0.00 & + ` cp4.i`&0.00&0.09&0.02&0.00&0.00 & + ` cp5.i`&0.01&0.12&0.05&0.14&5.91 & + ` cross10.i`&0.08&0.22&0.14&10.50&&1.38 + ` cross12.i`&0.84&3.04&2.86&166.15&&15.24 + ` cross4.i`&0.00&0.07&0.02&0.00&0.00&0.00 + ` cross6.i`&0.00&0.06&0.03&0.04&0.09&0.01 + ` cross8.i`&0.01&0.07&0.03&0.54&28.90&0.14 + ` cube.i`&0.00&0.09&0.02&0.00&0.00&0.00 + ` cube10.i`&0.02&0.15&0.16&0.24&0.03 & + ` cube12.i`&0.19&0.32&3.70&1.35&0.18 & + ` cube3.i`&0.00&0.06&0.02&0.00&0.00&0.00 + ` cube6.i`&0.00&0.10&0.03&0.01&0.00&0.34 + ` cube8.i`&0.00&0.10&0.05&0.06&0.00&123.23 + ` cubetop.i`&0.00&0.08&0.02&0.00&0.00 & + ` cubocta.i`&0.00&0.10&0.02&0.00&0.00&0.00 + ` cyc.i`&0.00&0.08&0.01&0.00&0.00&0.00 + ` cyclic17_8.i`&0.04&0.15&0.14&0.32&0.08 & + ` diamond.i`&0.00&0.08&0.01&0.00&0.00&0.00 + ` dodeca_m.i`&0.00&0.07&0.02&0.00&0.00 & + ` ex1.i`&0.00&0.07&0.02&0.00&0.00 & + ` grcubocta.i`&0.00&0.06&0.02&0.01&0.00&0.01 + ` hexocta.i`&0.00&0.05&0.01&0.02&0.00&0.01 + ` icododeca_m.i`&0.00&0.07&0.02&0.05&0.00 & + ` in0.i`&0.00&0.06&0.02&0.00&0.00 & + ` in1.i`&0.00&0.08&0.02&0.01&0.00 & + ` in2.i`&0.00&0.08&0.03&0.00&0.00 & + ` in3.i`&0.00&0.05&0.02&0.00&0.00 & + ` in4.i`&0.00&0.10&0.03&0.01&0.00 & + ` in5.i`&0.00&0.07&0.04&0.03&0.00 & + ` in6.i`&0.02&0.14&0.09&0.42&0.03 & + ` in7.i`&0.18&0.40&0.44&0.96&0.08 & + ` infeas.i`&0.00&0.09&0.02&0.00&0.00 & + ` integpoints.i`&0.00&0.10&0.04&0.05&0.00 & + ` kkd18_4.i`&0.00&0.10&0.02&0.02&0.00 & + ` kkd27_5.i`&0.05&0.12&0.07&0.08&0.01 & + ` kkd38_6.i`&2.95&5.26&1.52&0.32&0.05 & + ` kq20_11_m.i`&0.19&0.41&0.45&0.99&0.08 & + ` metric40_11.i`&0.00&0.11&0.04&0.07&0.57 & + ` metric80_16.i`&0.13&0.24&0.07&0.54&32.09 & + ` mit31 - 20.i`&23.34&27.21&115.00&103.19&25.53 & + ` mp5.i`&0.00&0.08&0.04&0.06&0.58 & + ` mp5a.i`&0.00&0.10&0.03&0.06&0.57 & + ` mp6.i`&0.33&0.42&0.75&4.66&1177.96 & + ` nonfull.i`&0.00&0.06&0.02&0.00&0.00 & + ` origin.i`&0.00&0.08&0.02&0.00&0.00 & + ` project1_m.i`&0.00&0.10&0.04&0.03&0.00&1.10 + ` project1res.i`&0.00&0.08&0.02&0.00&0.00&0.00 + ` project2_m.i`&0.02&0.09&0.05&0.46&0.13 & + ` project2res.i`&0.00&0.08&0.02&0.08&0.01 & + ` rcubocta.i`&0.00&0.08&0.01&0.01&0.00&0.01 + ` reg24 - 5.i`&0.00&0.08&0.02&0.01&0.00&0.01 + ` rhomtria_m.i`&0.00&0.09&0.02&0.04&0.00 & + ` sample.i`&0.00&0.08&0.01&0.00&0.00&0.00 + ` sampleh1.i`&0.00&0.05&0.02&0.00&0.00 & + ` sampleh2.i`&0.00&0.06&0.01&0.00&0.00 & + ` sampleh3.i`&0.00&0.04&0.02&0.00&0.00 & + ` sampleh4.i`&0.00&0.07&0.01&0.00&0.00 & + ` sampleh5.i`&0.00&0.05&0.01&0.00&0.00 & + ` sampleh6.i`&0.00&0.06&0.01&0.00&0.00 & + ` sampleh7.i`&0.00&0.09&0.01&0.00&0.00 & + ` sampleh8.i`&52.87&73.64&78.76&&4.59 & + ` trunc10.i`&8.81&9.06&0.08&1.66&9.15&737.37 + ` trunc7.i`&0.02&0.13&0.04&0.13&0.16&17.51 + ` tsp5.i`&0.00&0.10&0.04&0.02&0.00 & + total&130.34&308.12&345.70  in table [ tab : efficiency - vertex - enumeration - hard ] we have collected the data concerning the hardest of these problems . herewe have imposed a memory limit of 768 mb : entries marked with ` mem ' indicate the problems on which this limit was exceeded .the entries marked with ` tab ' in the new polka s column indicate the problems where new polka ran `` out of table space '' in the conversion algorithm .l ......   + & & & & & & + ` cp7.e ` & & & & & & + ` cyclic25_13.e`&89.94&&354.83&221.98&12.10 & + ` cp6.i ` & & & & & & + ` mit.i`&&&&950.00&2024.16 & + ` mit288 - 281.i ` & & & & & & + ` mit41 - 16.i`&137.14&&320.37&325.65&33.89 & + ` mit708 - 9.i`&&&&1016.23&1927.18 & + ` mit71 - 61.i ` & & & & & & + ` mit90 - 86.i ` & & & & & & +  another possibility of evaluating the performance of the parma polyhedra library on a standard problem with standard data is offered by linear programming , which is the paradigm upon which several approaches to analysis and verification ( such as , e.g. , ) rest upon .this requires either a version of the simplex based on exact arithmetic , or , in case a classical floating - point implementation is used , it forces to validate the obtained result with some alternative methods ._ mathsat _ _ decision procedure , which is applicable to the formal verification of infinite state systems ( such as timed and hybrid systems ) , is based on a version of the _ cassowary constraint solving toolkit _ , modified so as to use exact arithmetic instead of floating - point numbers .moreover , the algorithm employed by mathsat requires incremental satisfiability checks : a set of constraints is added and satisfiability is checked , more constraints are added and satisfiability is re - checked , and so forth .we have thus measured the efficiency of the ppl s incremental constraint solver by comparison with the version of cassowary used in mathsat and with the _ wallaroo linear constraint solving library _ , another descendant of cassowary .the benchmarks we used are quite standard in the linear programming community : they come from the `` lp ` ' directory of _ netlib_. the solution times , in seconds , obtained for the problem of adding one constraint at a time , checking for satisfiability at each step , are given in table [ tab : efficiency - simplex - incremental - satisfiability ] .l ......   + & & & + ` adlittle.mps ` & 0.33 & 1.46 & 1.51 + ` afiro.mps ` & 0.02 & 0.05 & 0.07 + ` blend.mps ` & 13.45 & 5.40 & 8.23 + ` boeing1.mps ` & 47.28 & 87.80 & 75.48 + ` boeing2.mps ` & 2.32 & 10.58 & 14.67 + ` kb2.mps ` & 0.11 & 0.30 & 0.46 + ` sc105.mps ` & 0.48 & 10.95 & 7.23 + ` sc50a.mps ` & 0.05 & 0.64 & 0.56 + ` sc50b.mps ` & 0.06 & 0.70 & 0.94 + total & 64.10 & 117.88 & 109.15in this section we briefly review the short- and mid - term development plans we have for the library .we deliberately omit all long - term projects : for all those we mention here , code whether in the form of a prototype or as a proof - of - concept exercise has already been developed that proves the feasibility of the proposal .   [ [ intervals - and - bounding - boxes ] ] intervals and bounding boxes + + + + + + + + + + + + + + + + + + + + + + + + + + + +  an important numerical domain is the domain of _ bounding boxes _ : these are representable by means of finite set of _ intervals _ or be seen as finite conjunctions of constraints of the form or . despite the fact that bounding boxes have been one of the first abstract domains ever proposed and that they have been implemented and reimplemented dozens of times , no freely available implementation is really suitable for the purposes of abstract interpretation . in fact , the available interval libraries either lack support for non - closed intervals ( so that they are unable to represent constraints of the form ) , or they do not provide the right support for approximation in the sense of partial correctness ( e.g. , division by an interval containing zero gives rise to a run - time error instead of giving an interval containing the result under the assumption that the concrete division being approximated was not a division by zero ) , or they disregard rounding errors and are therefore unsafe .we are thus working at a complete implementation of bounding boxes based on intervals .such intervals are parametric on a number of features : they support open as well as closed boundaries ; boundaries can be chosen within one of the number families mentioned in section [ sec : bounded - difference - shapes ] ( when boundaries are floating point numbers , rounding is of course controlled to maintain soundness ) ; independently from the type of the boundaries , both plain intervals of real numbers and intervals subject to generic _ restrictions _ are supported .this notion of restriction can be instantiated to obtain intervals of integer numbers , _ modulo intervals _ , and generalizations of the latter providing more precise information .[ [ grid - polyhedra ] ] grid - polyhedra + + + + + + + + + + + + + +  an interesting line of development consists in the combination of the grids domain with the several polyhedral domains provided by the ppl : not only the -polyhedra domain , but also many variations such as grid - polyhedra , grid - octagon , grid - bounded - difference , grid - interval domains ( not to mention their powersets ) .[ [ polynomial - equalities - and - inequalities ] ] polynomial equalities and inequalities + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +  the work in proved the feasibility of representing systems of polynomial inequalities of bounded degree by encoding them into convex polyhedra .the prototype implementation used for the experimental evaluation presented in is being turned into a complete abstract domain and will be incorporated into the ppl .the current version of the ppl only offers c and prolog interfaces for ( c and nnc ) polyhedra and lp problems. it would not be difficult to add , along the same lines , interfaces for all the other abstractions .it can be done , rather quickly , mostly as a `` copy and paste '' exercise . instead of following that route ( which would imply substantial code duplication and an unaffordable maintenance burden ) ,we are working at an automatic way of obtaining these interfaces out of a few `` templates . '' as part of this ongoing effort , we are extending the set of available _ direct _ interfaces with java and objective caml .finally there are plans to develop an interface that allows to use the ppl s numerical abstractions within _mathematica_.   other features on the horizon of the parma polyhedra library include the inclusion of : bidirectional serialization functions for all the supported abstractions ; the ask - and - tell generic construction of ; and the extrapolation operators defined in and ; we also plan to add support for more complexity - throttling techniques such as : breaking down the set of the variables of interests into `` packs '' of manageable size ; support for cartesian factoring as defined in ; and the limitation of the number of constraints and generators and/or the size of coefficients in the representation of polyhedra .in this paper , we have presented the parma polyhedra library , a library of numerical abstractions especially targeted to applications in the field of analysis and verification of software and hardware systems .we have illustrated the general philosophy that is behind the design of the library , its main features , examples highlighting the advantages offered to client applications , and the avenue we have prepared for future developments .the parma polyhedra library is being used on several applications in the field of verification of hardware and software systems .it has been used for the verification of properties of oscillator circuits ; to verify the soundness of _ batch workflow networks _ ( a kind of petri nets used in workflow management ) ; in the field of safety analysis of continuous and hybrid systems to overapproximate the systems of linear differential equations expressing the dynamics of hybrid automata and , in particular , the ppl is used in phaver , an innovative tool for the verification of such systems .the ppl is also used : in a version of _ tvla _( 3-valued logic analysis engine , http://www.cs.tau.ac.il/~tvla/ ) , a system for the verification of properties of arrays and heap - allocated data ; in _ icssv _ ( interprocedural c string static verifier ) , a tool for verifying the safety of string operations in c programs ; and in a static analyzer for _ gated data dependence graphs _ , an intermediate representation for optimizing compilation .this analyzer employs , in particular , the precise widening operator and the widening with tokens technique introduced in . in the pplis used to derive invariant linear equalities and inequalities for a subset of the c language ; it is used in _ sting _ and _ lpinv _ , two systems for the analysis of transition systems ; it is used for the model - checking of reconfigurable hybrid systems ; it is used in a static analysis tool for x86 binaries that automatically identifies instructions that can be used to redirect control flow , thus constituting vulnerabilities that can be exploited in order to bypass intrusion detection systems ; it is also used to represent and validate real - time systems constraints and behaviors and to automatically derive the _ argument size relations _ that are needed for termination analysis of prolog programs .  in conclusion , even though the library is still not mature and functionally complete , it already offers a combination of functionality , reliability , usability and performance that is not matched by similar , freely available libraries .moreover , since the ppl is free software and distributed under the terms of the gnu general public license ( gpl ) , and due to the presence of extensive documentation , the library can already be regarded as an important contribution secured to the community .* acknowledgments .* we would like to express our gratitude and appreciation to all the present and past developers of the parma polyhedra library : , , , , , katy dobson , , , , david merchat , matthew mundell , , , , enric rodrguez - carbonell , , , , , .thanks also to aaron bradley , for contributing to the project his _ mathematica _ interface , to goran frehse , for contributing his code to limit the complexity of polyhedra , and to all the users of the library that provided us with helpful feedback .d. avis . : a revised implementation of the reverse search vertex enumeration algorithm . in g.kalai and g. m. ziegler , editors , _ polytopes combinatorics and computation _ , volume 29 of _ oberwolfach seminars _, pages 177198 .birkhuser - verlag , 2000 .r. bagnara , k. dobson , p. m. hill , m. mundell , and e. zaffanella .grids : a domain for analyzing the distribution of numerical values , 2006 . accepted for publication and presented at the international symposium on logic - based program synthesis and transformation .r. bagnara , k. dobson , p. m. hill , m. mundell , and e. zaffanella . a practical tool for analyzing the distribution of numerical values , 2006 . submitted for publication .available at http://www.comp.leeds.ac.uk/hill/papers/papers.html .r. bagnara , p. m. hill , e. mazzi , and e. zaffanella .widening operators for weakly - relational numeric abstractions . in c. hankin and i. siveroni , editors , _static analysis : proceedings of the 12th international symposium _, volume 3672 of _ lecture notes in computer science _ , pages 318 , london , uk , 2005 .springer - verlag , berlin .r. bagnara , p. m. hill , e. ricci , and e. zaffanella .precise widening operators for convex polyhedra . in r.cousot , editor , _ static analysis : proceedings of the 10th international symposium _, volume 2694 of _ lecture notes in computer science _ , pages 337354 , san diego , california , usa , 2003 .springer - verlag , berlin .r. bagnara , e. ricci , e. zaffanella , and p. m. hill .possibly not closed convex polyhedra and the parma polyhedra library . in m.v. hermenegildo and g. puebla , editors , _static analysis : proceedings of the 9th international symposium _ ,volume 2477 of _ lecture notes in computer science _ , pages 213229 , madrid , spain , 2002 .springer - verlag , berlin .r. bagnara , e. rodrguez - carbonell , and e. zaffanella .generation of basic semi - algebraic invariants using convex polyhedra . in c.hankin and i. siveroni , editors , _ static analysis : proceedings of the 12th international symposium _ , volume 3672 of _ lecture notes in computer science _ , pages 1934 , london , uk , 2005 .springer - verlag , berlin .v. balasundaram and k. kennedy . a technique for summarizing data access and its use in parallelism enhancing transformations . in b.knobe , editor , _ proceedings of the acm sigplan89 conference on programming language design and implementation ( pldi ) _ , volume 24(7 ) of _ acm sigplan notices _ , pages 4153 , portland , oregon , usa , 1989 .acm press .b. brard and l. fribourg : .reachability analysis of ( timed ) petri nets using real arithmetic . in j. c. m. baeten and s. mauw , editors , _ concur99 : concurrency theory , proceedings of the 10th international conference _ , volume 1664 of _ lecture notes in computer science_ , pages 178193 , eindhoven , the netherlands , 1999 .springer - verlag , berlin .b. blanchet , p. cousot , r. cousot , j. feret , l. mauborgne , a. min , d. monniaux , and x. rival . a static analyzer for large safety - critical software . in _ proceedings of the acm sigplan 2003 conference on programming language design and implementation ( pldi03 )_ , pages 196207 , san diego , california , usa , 2003 .acm press .m. bozzano , r. bruttomesso , a. cimatti , t. a. junttila , p. van rossum , s. schulz , and r. sebastiani .the mathsat 3 system . in r.nieuwenhuis , editor , _ automated deduction : proceedings of the 20th international conference _ ,volume 3632 of _ lecture notes in computer science _ , pages 315321 , tallinn , estonia , 2005 .springer - verlag , berlin .p. cousot .semantic foundations of program analysis . in s.s. muchnick and n. d. jones , editors , _ program flow analysis : theory and applications _ , chapter 10 , pages 303342 .prentice hall , inc ., englewood cliffs , new jersey , 1981 .  p. cousot and r. cousot . static determination of dynamic properties of programs . in b.robinet , editor , _ proceedings of the second international symposium on programming _ , pages 106130 , paris , france , 1976 .dunod , paris , france .p. cousot and r. cousot .abstract interpretation : a unified lattice model for static analysis of programs by construction or approximation of fixpoints . in _ proceedings of the fourth annual acm symposium on principles of programming languages _ , pages 238252 , new york , 1977 .acm press .p. cousot and r. cousot. systematic design of program analysis frameworks . in_ proceedings of the sixth annual acm symposium on principles of programming languages _ , pages 269282 , new york , 1979 .acm press .p. cousot and r. cousot .comparing the galois connection and widening / narrowing approaches to abstract interpretation . in m.bruynooghe and m. wirsing , editors , _ proceedings of the 4th international symposium on programming language implementation and logic programming _ , volume 631 of _ lecture notes in computer science _ ,pages 269295 , leuven , belgium , 1992 .springer - verlag , berlin .p. cousot , r. cousot , j. feret , l. mauborgne , a. min , d. monniaux , and x. rival .the astre analyzer . in m.sagiv , editor , _ programming languages and systems , proceedings of the 14th european symposium on programming _ , volume 3444 of _ lecture notes in computer science _ , pages 2130 , edinburgh , uk , 2005 .springer - verlag , berlin .p. cousot and n. halbwachs .automatic discovery of linear restraints among variables of a program . in _conference record of the fifth annual acm symposium on principles of programming languages _ , pages 8496 , tucson , arizona , 1978 ..   d. l. dill .timing assumptions and verification of finite - state concurrent systems . in j.sifakis , editor , _ proceedings of the international workshop on automatic verification methods for finite state systems _ , volume 407 of _ lecture notes in computer science _ , pages 197212 , grenoble , france , 1989 .springer - verlag , berlin .d. doose and z. mammeri .polyhedra - based approach for incremental validation of real - time systems . in l.t. yang , m. amamiya , z. liu , m. guo , and f. j. rammig , editors , _ proceedings of the international conference on embedded and ubiquitous computing ( euc 2005 ) _ , volume 3824 of _ lecture notes in computer science _ , pages 184193 ,nagasaki , japan , 2005 .springer - verlag , berlin .l. doyen , t. a. henzinger , and j .- f .automatic rectangular refinement of affine hybrid systems .technical report 2005.47 , centre fdr en vrification , universit libre de bruxelles , belgium , 2005 .r. ellenbogen. fully automatic verification of absence of errors via interprocedural integer analysis .master s thesis , school of computer science , tel - aviv university , tel - aviv , israel , december 2004 .g. frehse. compositional verification of hybrid systems with discrete interaction using simulation relations . in _ proceedings of the ieee conference on computer aided control systems design ( cacsd 2004 ) _ ,taipei , taiwan , 2004 .g. frehse . : algorithmic verification of hybrid systems past hytech . in m.morari and l. thiele , editors , _ hybrid systems : computation and control : proceedings of the 8th international workshop ( hscc 2005 ) _ , volume 3414 of _ lecture notes in computer science _ , pages 258273 , zrich , switzerland , 2005 .springer - verlag , berlin .g. frehse , z. han , and b. krogh .assume - guarantee reasoning for hybridi / o - automata by over - approximation of continuous interaction . in _ proceedings of the 43rd ieee conference on decision and control ( cdc 2004 ) _ , atlantis , paradise island , bahamas , 2004 .g. frehse , b. h. krogh , and r. a. rutenbar .verifying analog oscillator circuits using forward / backward refinement . in _ proceedings of the 9th conference on design , automation and test in europe ( date 06 ) _ , munich , germany , 2006 .acm sigda . publication .g. frehse , b. h. krogh , r. a. rutenbar , and o. maler . time domain verification of oscillator circuit properties .available at http://www-verimag.imag.fr/~maler/papers/oscil.pdf , 2005 .presented at the 2005 workshop on formal verification of analog circuits ( a satellite event of etaps 2005 ) .k. fukuda and a. prodon .double description method revisited . in m.deza , r. euler , and y. manoussakis , editors , _ combinatorics and computer science , 8th franco - japanese and 4th franco - chinese conference , brest , france , july 3 - 5 , 1995 , selected papers _ , volume 1120 of _ lecture notes in computer science _ , pages 91111 .springer - verlag , berlin , 1996 .d. gopan , f. dimaio , n. dor , t. reps , and m. sagiv .numeric domains with summarized dimensions . in k.jensen and a. podelski , editors , _ tools and algorithms for the construction and analysis of systems , 10th international conference , tacas 2004 _ , volume 2988 of _ lecture notes in computer science _ , pages 512529 , barcelona , spain , 2004 .springer - verlag , berlin .d. gopan , t. reps , and m. sagiv .a framework for numeric analysis of array operations . in _ proceedings of the 32nd acm sigplan - sigact symposium on principles of programming languages _ , pages 338350 , long beach , california , usa , 2005 .p. granger .static analysis of linear congruence equalities among variables of a program . in s.abramsky and t. s. e. maibaum , editors , _ tapsoft91 : proceedings of the international joint conference on theory and practice of software development , volume 1 : colloquium on trees in algebra and programming ( caap91 ) _ , volume 493 of _ lecture notes in computer science _ , pages 169192 ,brighton , uk , 1991 .springer - verlag , berlin .p. granger .static analyses of congruence properties on rational numbers ( extended abstract ) . in p. van hentenryck , editor , _ static analysis : proceedings of the 4th international symposium _ ,volume 1302 of _ lecture notes in computer science _ , pages 278292 ,paris , france , 1997 .springer - verlag , berlin .n. halbwachs .delay analysis in synchronous programs . in c.courcoubetis , editor , _ computer aided verification : proceedings of the 5th international conference _ , volume 697 of _ lecture notes in computer science _ , pages 333346 , elounda , greece , 1993 .springer - verlag , berlin .n. halbwachs , d. merchat , and c. parent - vigouroux .cartesian factoring of polyhedra in linear relation analysis . in r.cousot , editor , _ static analysis : proceedings of the 10th international symposium _ ,volume 2694 of _ lecture notes in computer science _ , pages 355365 , san diego , california , usa , 2003 .springer - verlag , berlin .n. halbwachs , y .- e .proy , and p. raymond .verification of linear hybrid systems by means of convex approximations . in b.le charlier , editor , _ static analysis : proceedings of the 1st international symposium _ ,volume 864 of _ lecture notes in computer science _ , pages 223237 , namur , belgium , 1994 .springer - verlag , berlin .t. a. henzinger and p .- h . ho . a note on abstract interpretation strategies for hybrid automata . in p.j. antsaklis , w. kohn , a. nerode , and s. sastry , editors , _ hybrid systems ii _ ,volume 999 of _ lecture notes in computer science _ , pages 252264 .springer - verlag , berlin , 1995 .t. a. henzinger , j. preussig , and h. wong - toi . some lessons from the hytech experience . in _ proceedings of the 40th annual conference on decision and control _ , pages 28872892 .ieee computer society press , 2001 .  c. hymans and e. upton .static analysis of gated data dependence graphs . in r.giacobazzi , editor , _ static analysis : proceedings of the 11th international symposium _ ,volume 3148 of _ lecture notes in computer science _ , pages 197211 , verona , italy , 2004 .springer - verlag , berlin .   c. kruegel , e. kirda , d. mutz , w. robertson , and g. vigna . automating mimicry attacks using static binary analysis . in _ proceedings of security 05 ,the 14th usenix security symposium _ , pages 161176 , baltimore , md , usa , 2005 .  k. larsen , f. larsson , p. pettersson , and w. yi .efficient verification of real - time systems : compact data structure and state - space reduction . in _ proceedings of the 18th ieee real - time systems symposium ( rtss97 ) _ , pages 1424 , san francisco , ca , 1997 .ieee computer society press .t. s. motzkin , h. raiffa , g. l. thompson , and r. m. thrall . the double description method . in h.w. kuhn and a. w. tucker , editors , _ contributions to the theory of games volume ii _ , number 28 in annals of mathematics studies , pages 5173 .princeton university press , princeton , new jersey , 1953 .t. nakanishi , k. joe , c. d. polychronopoulos , and a. fukuda .the modulo interval : a simple and practical representation for program analysis . in _ proceedings of the 1999 international conference on parallel architectures and compilation techniques _ , pages 9196 , newport beach , california , usa , 1999 .ieee computer society .s. sankaranarayanan , m. coln , h. b. sipma , and z. manna .efficient strongly relational polyhedral analysis . in e.a. emerson and k. s. namjoshi , editors , _ verification , model checking and abstract interpretation : proceedings of the 7th international conference ( vmcai 2006 ) _ , volume 3855 of _ lecture notes in computer science _ , pages 111125 , charleston , sc , usa , 2006 .springer - verlag , berlin .s. sankaranarayanan , h. b. sipma , and z. manna . constraint - based linear - relations analysis . in r.giacobazzi , editor , _ static analysis : proceedings of the 11th international symposium _ ,volume 3148 of _ lecture notes in computer science _ , pages 5368 , verona , italy , 2004 .springer - verlag , berlin .s. sankaranarayanan , h. b. sipma , and z. manna .scalable analysis of linear systems using mathematical programming . in r.cousot , editor , _ verification , model checking and abstract interpretation : proceedings of the 6th international conference ( vmcai 2005 ) _ , volume 3385 of _ lecture notes in computer science _ , pages 2541 , paris , france , 2005 .springer - verlag , berlin .s. sankaranarayanan , h. b. sipma , and z. manna .fixed point iteration for computing the time elapse operator . in j.hespanha and a. tiwari , editors , _ hybrid systems : computation and control : proceedings of the 9th international workshop ( hscc 2006 ) _ , volume 3927 of _ lecture notes in computer science _ ,pages 537551 , santa barbara , ca , usa , 2006 .springer - verlag , berlin .r. shaham , e. k. kolodner , and s. sagiv .automatic removal of array memory leaks in java . in d. a. watt , editor , _ proceedings of the 9th international conference on compiler construction ( cc 2000 ) _ , volume 1781 of _ lecture notes in computer science _ , pages 5066 , berlin , germany , 2000 .springer - verlag , berlin .h. song , k. compton , and w. rounds .a model checker for reconfigurable hybrid systems based on spin . in r.lazic and r. nagarajan , editors , _ proceedings of the 5rd workshop on automated verification of critical systems _ , university of warwick , uk , 2005 .k. van hee , o. oanea , n. sidorova , and m. voorhoeve .verifying generalized soundness for workflow nets . in i.virbitskaite and a. voronkov , editors , _ perspectives of system informatics : proceedings of the sixth international andrei ershov memorial conference _ , lecture notes in computer science , akademgorodok , novosibirsk , russia , 2006 .springer - verlag , berlin . to appear .a. venet and g. brat .precise and efficient static array bound checking for large embedded c programs . in _ proceedings of the acm sigplan 2004 conference on programming language design and implementation ( pldi04 ) _ , pages 231242 , washington , dc , usa , 2004 .acm press .

Abstract: since its inception as a student project in 2001 , initially just for the handling ( as the name implies ) of convex polyhedra , the _ parma polyhedra library _ has been continuously improved and extended by joining scrupulous research on the theoretical foundations of ( possibly non - convex ) numerical abstractions to a total adherence to the best available practices in software development . even though it is still not fully mature and functionally complete , the parma polyhedra library already offers a combination of functionality , reliability , usability and performance that is not matched by similar , freely available libraries . in this paper , we present the main features of the current version of the library , emphasizing those that distinguish it from other similar libraries and those that are important for applications in the field of analysis and verification of hardware and software systems .  ,   ,  formal methods , static analysis , computer - aided verification , abstract interpretation , numerical properties .


complex networked systems are widespread in nature , society and engineering .some examples from biology are regulatory gene and metabolic networks , the neural network of the brain , the immune system , and , on larger scales , food webs and the ecosystem .another example , now from the social sciences , is multiagent economics , where a multitude of large and small traders are interwoven together to curse the course of exchange rates and stock prices .also engineering contributes with communication networks , such as the internet , the world wide web and grid computing .recently physics has started a new branch , the statistical physics of complex networks , which takes a generic and unifying perspective at all of those examples .so far , most of the focus has been on the structure of such networks .the analysis of a great deal of the above mentioned examples has led to the unifying scale - free discovery and its respective growth modeling with preferential attachment . beyond structure ,it is now also dynamics on and function of networks , which are about to move onto center stage .the new insight which along these lines has already been given to regulatory gene networks constitutes for sure a remarkable highlight .the impact of structure on dynamics is also key to epidemic spreading and the proposal of efficient immunization strategies for populations and computer networks .the structure and dynamical properties of engineered communication networks in general and computer as well as internet traffic in particular were also discussed heavily within the physics community over the last years .key issues have been besides network structure also phase transition like behavior from a noncongested to a congested traffic regime and selfsimilar data traffic .so far the analysis of network structure and dynamics has been mostly separated from each other . only very recentlya first coupling of these issues has been picked up , focusing on the impact of structure on synchronization dynamics . in this paper we introduce a new and intriguing complex technological system to the physics community , so - called wireless multihop ad hoc communication networks , and discuss the impact of network structure onto their performance to handle data traffic .wireless multihop ad hoc communication networks represent an infrastructureless generalization of todays wireless cellular phone networks . lacking a central control authority in the form of base stations , each end device acts as router and relays packets for other participants .end - to - end communications are possible via multihop connections . in order to ensure network connectivity , efficient discovery and execution of end - to - end routes and avoidance of data packet collisions on shared radio channels , the participating devices need coordination amongst themselves .proposals for such a coordination have already been put forward upon focusing on the connectivity issue . for the other two issues ,routing and medium access control , the coordination is much more delicate .routing efficiency would require rather short end - to - end routes , resulting in a small network diameter .due to the overall presence of interference , medium access control takes care of collision avoidance for data packets traveling on different routes .it blocks all neighboring devices of an active one - hop transmission and thus would rather favor a small neighborhood , implying a small node degree .the opposite demands of these counteracting mechanisms leave the network in a state of frustration .this opens the door for the generic statistical physics of complex networks , asking the question what is the impact of network structure on the performance of wireless multihop ad hoc communication .well - performing network structures would be those which find an efficient compromise out of this frustration .they would come with a small end - to - end time delay and a large end - to - end throughput . in this paperwe analyze and compare different wireless multihop ad hoc network structures that are created by different transmission power assignments .note that the regulation of its transmission power is the only intrinsic control action a communication node is able to perform to enforce a certain structure of the network .a generic data traffic simulation as well as a semi - analytic approach is used to calculate the end - to - end throughput associated to these network structures .this allows us to study the impact of network structure on the data - traffic performance of such communication networks .2 explains the used network model and various transmission power assignments .some properties of the resulting geometric network graphs are also discussed .the performance of these network structure classes with respect to end - to - end throughput is evaluated in sect .[ sec : traffic ] by employing a generic data traffic simulation , the emphasis being on scalability .semi - analytic insights are presented in sect .[ sec : meanfield ] and finally a conclusion is given in sect . [ sec : conclusion ] .the appendix summarizes the graph - theoretical variables , which are used throughout the paper .in this section we are only concerned with structural aspects of wireless multihop ad hoc communication networks . upon invoking some justifiable idealizations in subsect .[ subsec : networkmodel ] , various classes of random geometric graphs are constructed in subsects .[ subsec : constp]-[subsec : shortestvsenergy ] , which we will from then on reference as network models i - v .the various network models differ in the way how transmission power is assigned to the communication nodes .their structural properties will be discussed in subsect .[ subsec : properties ] .wireless multihop ad hoc networks consist of communication nodes , which are distributed in space and communicate to each other via a wireless medium . for simplicity , mobility of the communication nodesis discarded .exactly communication nodes are given random positions \times [ 0,l] ] is another popular observable .it counts the number of existing bidirected links with respect to all possible bidirected links among the nodes belonging to the bidirected neighborhood of node .one - directed variants of the cluster coefficient are not considered .analogous to the distinction between node and link degree , the cluster coefficient can not only be defined in the node - based manner , but also in the link - based manner ) \sum_{m_1>m_2\in{\mathcal n}_{i{\leftrightarrow}j } } a_{m_1m_2 } a_{m_2m_1}$ ] .it counts the number of existing bidirected links with respect to all possible bidirected links among the nodes belonging to the bidirected neighborhood of link .the shortest - path distance counts the number of bidirected hops along the shortest ( in units of hops ) path between nodes and .the diameter is given by double averaging , in the first step a mean over all node pairs of one network realization and in the second step a mean over a sample of network realizations .   for simplicity , we assume table - based shortest - path routing using bidirected links for all possible end - to - end communications within the network . in general different nodes will be used with different frequency for the relaying of packets .a measure of this frequency is given by the node inbetweeness , which counts the number of shortest paths out of the different shortest end - to - end communication routes going via node . to be more precise ,all nodes that are subsequently transmitting along such a shortest path , add a one to their respective node - inbetweeness counter ; this includes the initially transmitting node , but not the final recipient .if between two ends more than one , say shortest paths exist , then each path is weighted with and nodes along such a path add this weight to their node - inbetweeness counter .this definition of node inbetweeness is similar to the well known betweenness centrality .contrary to the former , the latter excludes contributions from the initial and final node . for the calculation of the node inbetweeness we use an all - pairs shortest path algorithm similar tothat described in ref .the sum rule relates the average node inbetweeness to the network diameter .   similar to the definition of node inbetweeness the link inbetweeness is a measure for the importance of a link .the link inbetweeness counts the number of shortest paths that contain the link .if there exist shortest paths between two nodes , we proceed as described above for the node inbetweeness , where each of these paths gets the weight .the link inbetweeness is connected with the node inbetweeness by the flux rule which allows to express the mean link inbetweeness in terms of the network diameter and the mean node degree .   for our discussion in sect .[ sec : meanfield ] on the end - to - end throughput the quantity is of relevance .we call it the cumulative node inbetweeness , since it adds the node inbetweennesses of all ingoing neighbors to the node inbetweeness of node . the second term on the right - hand side of ( [ eq : zweib7 ] ) , when divided by , can be seen as an inbetweeness - weighted ingoing node degree . by reordering ,the mean can be expressed as .r. albert and a.l .barabasi , rev . mod . phys . 74 ( 2002 ) 47 .dorogovtsev and j.f.f .mendes , _ evolution of networks from biological nets to the internet and www _ , oxford university press , oxford ( 2003 ) .newman , siam review 45 ( 2003 ) 167 .r. albert and h. othmer , j. theo .bio . 223 ( 2003 ) 1 .r. cohen , s. havlin and d. ben - avraham , phys .lett . 91 ( 2003 ) 247901 .c. faloutsos , p. faloutsos and m. faloutsos , _ on power - law relationships of the internet topology _ , in proc .( september 1999 ) .q. chen , h. chang , r. govindan , s. jasmin , s. shenker and w. willinger , _ the origin of power laws in internet topologies revisited _ , in proc .ieee infocom , new york , ny ( june 2002 ) .h. chang , s. jasmin and w. willinger , _ what causal forces shape internet connectivity at the as - level ? _ , technical report cse-475 - 03 , eecs dept ., univ . of michigan ( 2003 ) , http://citeseer.nj.nec.com/chang03what.html .h. fuks and a. lawniczak , math . comp .51 ( 1999 ) 101 .h. fuks , a. lawniczak and s. volkov , acm trans .11 ( 2001 ) 233 .r. sole and s. valverde , physica a 289 ( 2001 ) 595 .s. valverde and r. sole , physica a 312 ( 2002 ) 636 .k. park and w. willinger ( eds ) , _ self - similar network traffic and performance evaluation _ , john wiley & sons , new york ( 2000 ). z. toroczkai , g. korniss , m.a .novotny and h. guclu , _ virtual time horizon control via communication network design _ , arxiv : cond - mat/0304617 .mobile ad hoc networks ( manet ) working group , + http://www.ietf.org/html.charters/manet-charter.html .wireless ad hoc networks bibliography , + http://w3.antd.nist.gov/wctg/manet/manet_bibliog.html .mobihoc 2002 , proc .of 3rd acm int .symp . on mobile ad hoc networking and computing , lausanne , switzerland ( june 9 - 11 , 2002 ) .mobihoc 2003 , proc . of 4th acm int .symp . on mobile ad hoc networking and computing , annapolis , md , usa ( june 1 - 3 , 2003 ) .proakis , _ digital communications _ , mcgraw - hill , singapore ( 1995 ) .r. prasad , _ universal wireless personal communications _ , artech house , boston ( 1998 ) .rappaport , _ wireless communications principles & practice _ , prentice hall , upper saddle river ( 1999 ) .v. rodoplu and t.h .meng , ieee journal on selected areas in communications special issue on ad hoc networks 17 ( 1999 ) 1333 .i. glauche , w. krause , r. sollacher and m. greiner , physica a 325 ( 2003 ) 577 .p. gupta and p.r .kumar , ieee trans .theory it-46 ( 2000 ) 388 . c. bettstetter , _ on the minimum node degree and connectivity of a wireless multihop network _, in proc .mobihoc 2002 , pp .80 - 91 , lausanne , switzerland ( june 9 - 11 , 2002 ) .o. dousse , p. thiran and m. hasler , presented at ieee infocom 2002 , new york ( june 23 - 27 , 2002 ) , http://www.ieee-infocom.org/2002/papers/481.pdf . f. xue and p.r .kumar , _ the number of neighbors needed for connectivity of wireless networks _ , wireless networks 10 ( 2004 ) 169 .press , s.a .teukolsky , w.t .vetterling , and b.p .flannery , _ numerical recipes _, cambridge university press , cambridge ( 1992 ) .rozenfeld , r. cohen , d. ben - avraham and s. havlin , phys . rev. lett . 89 ( 2002 ) 218701 .m. barthelemy , europhys .63 ( 2003 ) 915 . c. herrmann , m. barthelemy and p. provero , phys .e 68 ( 2003 ) 026128 .s.s . manna , g. mukherjee and p. sen , arxiv : cond - mat/0307137 .e. dijkstra , numer . math . 1 ( 1959 ) 269 .f. kuhn , r. wattenhofer and a. zollinger , _ worst - case optimal and average - case efficient geometric ad hoc routing _, in proc .mobihoc 2003 , pp . 267 - 278 , annapolis , md , usa ( june 1 - 3 , 2003 ) .d. watts and s. strogatz , nature 393 ( 1998 ) 440 . m.e.j .newman , phys .e 64 ( 2001 ) 016132 .

Abstract: as a representative of a complex technological system , so - called wireless multihop ad hoc communication networks are discussed . they represent an infrastructure - less generalization of todays wireless cellular phone networks . lacking a central control authority , the ad hoc nodes have to coordinate themselves such that the overall network performs in an optimal way . a performance indicator is the end - to - end throughput capacity . various models , generating differing ad hoc network structure via differing transmission power assignments , are constructed and characterized . they serve as input for a generic data traffic simulation as well as some semi - analytic estimations . the latter reveal that due to the most - critical - node effect the end - to - end throughput capacity sensitively depends on the underlying network structure , resulting in differing scaling laws with respect to network size .   statistical physics of complex networks , network structure , information and communication technology , wireless ad hoc networks , data traffic  02.40.pc , 05.10.ln , 05.65.+b , 84.40.ua , 89.20.-a , 89.75.fb