A Direct Encoding for NNC Polyhedra

. We present an alternative Double Description representation for the domain of NNC (not necessarily closed) polyhedra, together with the corresponding Chernikova-like conversion procedure. The representation uses no slack variable at all and provides a solution to a few technical issues caused by the encoding of an NNC polyhedron as a closed polyhedron in a higher dimension space. A preliminary experimental evaluation shows that the new conversion algorithm is able to achieve signiﬁcant eﬃciency improvements.


Introduction
The Double Description (DD) method [28] allows for the representation and manipulation of convex polyhedra by using two different geometric representations: one based on a finite collection of constraints, the other based on a finite collection of generators.Starting from any one of these representations, the other can be derived by application of a conversion procedure [10,11,12], thereby obtaining a DD pair.The procedure is incremental, capitalizing on the work already done when new constraints and/or generators need to be added to an input DD pair.
In the classical setting, the DD method is meant to compute geometric representations for topologically closed polyhedra in an n-dimensional vector space.However, there are applications requiring the ability to also deal with linear strict inequality constraints, leading to the definition of not necessarily closed (NNC) polyhedra.For example, this is the case for some of the analysis tools developed for the verification of hybrid systems [8,18,22,23], static analysis tools such as Pagai [24], and tools for the automatic discovery of ranking functions [13].
The few DD method implementations providing support for NNC polyhedra (Apron and PPL) are all based on an indirect representation.The approach, proposed in [22,23] and studied in more detail in [3,5], encodes the strict inequality constraints by means of an additional space dimension, playing the role of a slack variable; the new space dimension, usually denoted as , needs to be non-negative and bounded from above, i.e., the constraints 0 ≤ ≤ 1 are added to the topologically closed representation R (called -representation) of the NNC polyhedron P. The main advantage of this approach is the possibility of reusing, almost unchanged, all of the well-studied algorithms and optimizations that have been developed for the classical case of closed polyhedra.However, the addition of a slack variable carries with itself a few technical issues.
-At the implementation level, more work is needed to make the dimension transparent to the end user.-The -representation causes an intrinsic overhead : in any generator system for an -polyhedron, most of the "proper" points (those having a positive coordinate) need to be paired with the corresponding "closure" point (having a zero coordinate), almost doubling the number of generators.-The DD pair in minimal form computed for an -representation R, when reinterpreted as encoding the NNC polyhedron P, typically includes many redundant constraints and/or generators, leading to inefficiencies.To avoid this problem, strong minimization procedures were defined in [3,5] that are able to detect and remove those redundancies.Even though effective, these procedures are not fully integrated into the DD conversion: they can only be applied after the conversion, since they interfere with incrementality.Hence, during the iterations of the conversion the -redundancies are not removed, causing the computation of bigger intermediate results.
In this paper, we pursue a different approach for the handling of NNC polyhedra in the DD method.Namely, we specify a direct representation, dispensing with the need of the slack variable.The main insight of this new approach is the separation of the (constraints or generators) geometric representation into two components, the skeleton and the non-skeleton of the representation, playing quite different roles: while keeping a geometric encoding for the skeleton component, we will adopt a combinatorial encoding for the non-skeleton one.For this new representation, we propose the corresponding variant of the Chernikova's conversion procedure, where both components are handled by respective processing phases, so as to take advantage of their peculiarities.In particular, we develop ad hoc functions and procedures for the combinatorial non-skeleton part.
The new representation and conversion procedure, in principle, can be integrated into any of the available implementations of the DD method.Our experimental evaluation is conducted in the context of the PPL and shows that the new algorithm, while computing the correct results for all of the considered tests, achieves impressive efficiency improvements with respect to the implementation based on the slack variable.
The paper is structured as follows.Section 2 briefly introduces the required notation, terminology and background concepts.Section 3 proposes the new representation for NNC polyhedra; the proofs of the stated results are in [7].The extension of the Chernikova's conversion algorithm to this new representation is presented in Section 4. Section 5 reports the results obtained by the experimental evaluation.We conclude in Section 6.

Preliminaries
We assume some familiarity with the basic notions of lattice theory [9].For a lattice L, , ⊥, , , , an element a ∈ L is an atom if ⊥ a and there exists no element b ∈ L such that ⊥ b a.For S ⊆ L, the upward closure of S is defined as we denote by ℘ ↑ (L) the set of all the upward closed subsets of L. For x ∈ L, ↑ x is a shorthand for ↑{x}.The notation for downward closure is similar.Given two posets L, and L , and two monotonic functions α : L → L and γ : L → L, the pair (α, γ) is a Galois connection [14] between L and L if ∀x ∈ L, x ∈ L : α(x) x ⇔ x γ(x ).We write R n to denote the Euclidean topological space of dimension n > 0 and R + for the set of non-negative reals; for S ⊆ R n , cl(S) and relint(S) denote the topological closure and the relative interior of S, respectively.A topologically closed convex polyhedron (for short, closed polyhedron) is defined as the set of solutions of a finite system C of linear non-strict inequality and linear equality constraints; namely, P = con(C) where A vector r ∈ R n such that r = 0 is a ray of a non-empty polyhedron P ⊆ R n if, ∀p ∈ P and ∀ρ ∈ R + , it holds p + ρr ∈ P. The empty polyhedron has no rays.If both r and −r are rays of P, then r is a line of P. The set P ⊆ R n is a closed polyhedron if there exist finite sets L, R, P ⊆ R n such that 0 / ∈ (L ∪ R) and P = gen L, R, P , where gen L, R, P When P = ∅, we say that P is described by the generator system G = L, R, P .
In the following, we will abuse notation by adopting the usual set operator and relation symbols to denote the corresponding component-wise extensions on systems.For instance, for G = L, R, P and G = L , R , P , we will write G ⊆ G to mean L ⊆ L , R ⊆ R and P ⊆ P .The DD method due to Motzkin et al. [28] allows combining the constraints and the generators of a polyhedron P into a DD pair (C, G): a conversion procedure [10,11,12] is used to obtain each description starting from the other one, also removing the redundant elements.For presentation purposes, we focus on the conversion from constraints to generators; the opposite conversion works in the same way, using duality to switch the roles of constraints and generators.We do not describe lower level details such as the homogenization process, mapping the polyhedron into a polyhedral cone, or the simplification step, needed for computing DD pairs in minimal form.
The conversion procedure starts from a DD pair (C 0 , G 0 ) representing the whole vector space and adds, one at a time, the elements of the input constraint system C = {β 0 , . . ., β m }, producing a sequence of DD pairs (C k , G k ) 0≤k≤m+1 representing the polyhedra At each iteration, when adding the constraint β k to polyhedron P k = gen(G k ), the generator system G k is partitioned into the three components G + k , G 0 k , G − k , according to the sign of the scalar products of the generators with β k (those in G 0 k are the saturators of β k ); the new generator system for polyhedron P k+1 is computed as Function 'comb β k ' computes a linear combination of its arguments, yielding a generator that saturates the constraint β k ; predicate 'adj P k ' is used to select only those pairs of generators that are adjacent in P k .
The set CP n of all closed polyhedra on the vector space R n , partially ordered by set inclusion, is a lattice CP n , ⊆, ∅, R n , ∩, , where the empty set and R n are the bottom and top elements, the binary meet operator is set intersection and the binary join operator ' ' is the convex polyhedral hull.A constraint β = (a T x b) is said to be valid for P ∈ CP n if all the points in P satisfy β; for each such β, the subset F = { p ∈ P | a T p = b } is a face of P. We write cFaces P (possibly omitting the subscript) to denote the finite set of faces of P ∈ CP n .This is a meet sublattice of CP n and P = relint(F ) F ∈ cFaces P .When C is extended to allow for strict inequalities, P = con(C) is an NNC (not necessarily closed) polyhedron.The set P n of all NNC polyhedra on R n is a lattice P n , ⊆, ∅, R n , ∩, and CP n is a sublattice of P n .As shown in [3, Theorem 4.4], a description of an NNC polyhedron P ∈ P n can be obtained by extending the generator system with a finite set C of closure points.Namely, for G = L, R, C, P , we define P = gen(G), where gen L, R, C, P .
For an NNC polyhedron P ∈ P n , the finite set nncFaces P of its faces is a meet sublattice of P n and P = relint(F ) F ∈ nncFaces P .Letting Q = cl(P), the closure operator cl : nncFaces P → cFaces Q maps each NNC face of P into a face of Q.The image cl(nncFaces P ) is a join sublattice of cFaces Q and its nonempty elements form an upward closed subset, which can be described by recording the minimal elements only (i.e., the atoms of the nncFaces P lattice).

Direct Representations for NNC Polyhedra
An NNC polyhedron can be described by using an extended constraint system C = C = , C ≥ , C > and/or an extended generator system G = L, R, C, P .These representations are said to be geometric, meaning that they provide a precise description of the position of their elements.For a closed polyhedron P ∈ CP n , the use of completely geometric representations is an adequate choice.In the case of an NNC polyhedron P ∈ P n such a choice is questionable, since the precise geometric position of some of the elements is not really needed.
Example 1.Consider the NNC polyhedron P ∈ P 2 in the next figure, where the (strict) inequality constraints are denoted by (dashed) lines and the (closure) points are denoted by (unfilled) circles.
However, there is no need to know the position of point p 1 , since it can be replaced by any other point on the open segment (c 0 , c 1 ).Similarly, when considering the constraint representation, there is no need to know the exact slope of the strict inequality constraint β.
We now show that P ∈ P n can be more appropriately represented by integrating a geometric description of Q = cl(P) ∈ CP n (the skeleton) with a combinatorial description of nncFaces P (the non-skeleton).We consider here the generator system representation; the extension to constraints will be briefly outlined in a later section.
Definition 1 (Skeleton of a generator system).Let G = L, R, C, P be a generator system in minimal form, P = gen(G) and Q = cl(P).The skeleton of , where SP ⊆ P holds the points that can not be obtained by combining the other generators in G.
Note that the skeleton has no points at all, so that gen(SK Q ) = ∅.However, we can define a variant function gen L, R, C, P def = gen L, R, ∅, C ∪ P , showing that the skeleton of an NNC polyhedron provides a non-redundant representation of its topological closure.
The elements of SP ⊆ P are called skeleton points; the non-skeleton points in P \ SP are redundant when representing the topological closure; these nonskeleton points are the elements in G that need not be represented geometrically.
Consider a point p ∈ Q = cl(P) (not necessarily in P ).There exists a single face F ∈ cFaces Q such that p ∈ relint(F ).By definition of function 'gen', point p behaves as a filler for relint(F ) meaning that, when combined with the skeleton, it generates relint(F ).Note that p also behaves as a filler for the relative interiors of all the faces in the set ↑ F .The choice of p ∈ relint(F ) is actually arbitrary: any other point of relint(F ) would be equivalent as a filler.A less arbitrary representation for relint(F ) is thus provided by its own skeleton SK F ⊆ SK Q ; we say that SK F is the support for the points in relint(F ) and that any point p ∈ relint gen(SK F ) = relint(F ) is a materialization of SK F .
In the following we will sometimes omit subscripts when clear from context.
Definition 2 (Support sets for a skeleton).Let SK be the skeleton of an NNC polyhedron and let Q = gen(SK) ∈ CP n .The set of all supports for SK is defined as We now define functions mapping a subset of the (geometric) points of an NNC polyhedron into the set of supports filled by these points, and vice versa.
Definition 3 (Filled supports).Let SK be the skeleton of the polyhedron P ∈ P n , Q = cl(P) and NS be the corresponding set of supports.The abstraction function α SK : The non-skeleton component of a geometric generator system can be abstracted by 'α SK ' and described as a combination of skeleton generators.Definition 4 (Non-skeleton of a generator system).Let P ∈ P n be defined by generator system G = L, R, C, P and let SK be the corresponding skeleton component.The non-skeleton component of G is defined as NS G def = α SK (P ).
The new representation is semantically equivalent to the fully geometric one.
Corollary 1.For a polyhedron P = gen(G) ∈ P n , let SK, NS be the skeleton and non-skeleton components for G. Then P = γ SK (NS ).

The New Conversion Algorithm
The conversion function in Pseudocode 1 incrementally processes each of the input constraints β ∈ C in keeping the generator system SK, NS up-to-date.The distinction between the skeleton and non-skeleton allows for a corresponding separation in the conversion procedure.Moreover, a few minor adaptations to their representation, discussed below, allow for efficiency improvements.
First, observe that every support ns ∈ NS always includes all of the lines in the L skeleton component; hence, these lines can be left implicit in the representation of the supports in NS .Note that, even after removing the lines, each ns ∈ NS is still a non-empty set, since it includes at least one closure point.
When lines are implicit, those supports ns ∈ NS that happen to be singletons3 can be seen to play a special role: they correspond to the combinatorial encoding of the skeleton points in SP (see Definition 1).These points are not going to benefit from the combinatorial representation, hence we move them from the non-skeleton to the skeleton component; namely,  4.1 Processing the skeleton Line 3 of conversion partitions the skeleton SK into SK + , SK 0 and SK − , according to the signs of the scalar products with constraint β.Note that the partition information is logically computed (no copies are performed) and it is stored in the SK component itself; therefore, any update to SK + , SK 0 and SK − directly propagates to SK.In line 7 the generators in SK + and SK − are combined to produce SK , which is merged into SK 0 .These steps are similar to the ones for closed polyhedra, except that we now have to consider more kinds of combinations: the systematic case analysis is presented in Table 1.For instance, when processing a non-strict inequality β ≥ , if we combine a closure point in SK + with a ray in SK − we obtain a closure point in SK (row 3, column 6).Since it is restricted to work on the skeleton component, this combination phase can safely apply the adjacency tests to quickly get rid of redundant elements.1. Case analysis for function 'comb β ' when adding an equality (β=), a non-strict (β ≥ ) or a strict (β>) inequality constraint to a pair of generators from SK + and SK − (R = ray, C = closure point, SP = skeleton point).

Processing the non-skeleton
Line 4 partitions the supports in NS by exploiting the partition information for the skeleton SK, so that no additional scalar product is computed.Namely, each support ns ∈ NS is classified as follows: This partitioning is consistent with the previous one.For instance, if ns ∈ NS + , then for every possible materialization p ∈ relint(gen(ns)) the scalar product of p and β is strictly positive.The supports in NS ± are those whose materializations can satisfy, saturate and violate the constraint β (i.e., the corresponding face crosses the constraint hyperplane).
In lines 8 and 9, we find the calls to the two main functions processing the non-skeleton component.A set NS of new supports is built as the union of the contributes provided by functions move-ns and create-ns.
Moving supports.The move-ns function, shown in Pseudocode 2, processes the supports in NS ± : this function "moves" the fillers of the faces that are crossed by the new constraint, making sure they lie on the correct side.
Let ns ∈ NS ± and F = relint(gen(ns)).Note that ns = SK F before the addition of the new constraint β; at this point, the elements in SK have been added to SK 0 , but this change still has to be propagated to the non-skeleton component NS .Therefore, we compute the support closure 'supp.clSK (ns)' according to the updated skeleton SK.Intuitively, supp.clSK (ns) ⊆ SK is the subset of all the skeleton elements that are included in face F .
At the implementation level, support closures can be efficiently computed by exploiting the same saturation information used for the adjacency tests.Namely, for constraints C and generators G, we can define Then, if C and SK = L, R, C, SP are the constraint system and the skeleton generator system for the polyhedron, for each ns ∈ NS we can compute [26]: Face F is split by constraint β into F + , F 0 and F − .When β is a strict inequality, only F + shall be kept in the polyhedron; when the new constraint is a non-strict inequality, both F + and F 0 shall be kept.A minimal non-skeleton representation for these subsets can be obtained by projecting the support: To summarize, by composing support closure and projection in line 3 of move-ns, each support in NS ± is moved to the correct side of β.When processing β = (y < 1), we obtain the polyhedron in the right hand side of the figure.In the skeleton phase of the conversion function the adjacent skeleton generators are combined: c 4 (from c 0 ∈ SK + and c 3 ∈ SK − ) and c 5 (from c 1 ∈ SK + and c 2 ∈ SK − ) are added to SK 0 .Since the non-skeleton support ns belongs to NS ± , it is processed in the move-ns function: In contrast, if we were processing the non-strict inequality β = (y ≤ 1), we would have obtained ns = proj β SK supp.cl SK (ns) = {c 4 }.Since ns is a singleton, it is upgraded to become a skeleton point by procedure promote-singletons.Hence, in this case the new skeleton is SK = ∅, ∅, C, SP , where C = {c 0 , c 1 , c 5 } and SP = {c 4 }, while the non-skeleton component is empty.
Creating new supports.Consider the case of a support ns ∈ NS − violating a non-strict inequality constraint β: this support has to be removed from NS .However, the upward closed set NS is represented by its minimal elements only so that, by removing ns, we are also implicitly removing other supports from the set ↑ ns, including some that do not belong to NS − and hence should be kept.Therefore, we have to explore the set of faces and detect those that are going to lose their filler: their minimal supports will be added to NS .Similarly, when processing a non-strict inequality constraint, we need to consider the new faces introduced by the constraint: the corresponding supports can be found by projecting on the constraint hyperplane those faces that are possibly filled by an element in SP + or NS + .This is the task of the create-ns function, shown in Pseudocode 2. It uses enumerate-faces as a helper:4 the latter provides an enumeration of all the (higher dimensional) faces that contain the initial support ns.The new faces are obtained by adding to ns a new generator g and then composing the support closure and projection functions, as done in move-ns.For efficiency purposes, a case analysis is performed so as to restrict the search area of the enumeration phase, by considering only the faces crossing the constraint.The partition for SK induced by the non-strict inequality is as follows: There are no adjacent generators in SK + and SK − , so that SK is empty.When processing the non-skeleton component, the skeleton point in SK + will be considered in line 15 of function create-ns.The corresponding call to function enumerate-faces computes It is worth noting that, when handling Example 4 adopting an entirely geometric representation, closure point c 1 needs to be combined with point p even if the two generators are not adjacent: this leads to a significant efficiency penalty.Similarly, an implementation based on the -representation will have to combine closure point c 1 with point p (and/or with some other -redundant points), because the addition of the slack variable makes them adjacent.Therefore, an implementation based on the new approach obtains a twofold benefit: first, the distinction between skeleton and non-skeleton allows for restricting the handling of non-adjacent combinations to the non-skeleton phase; second, thanks to the combinatorial representation, the non-skeleton component can be processed by using set index operations only, i.e., computing no linear combination at all.
Preparing for next iteration.In lines 10 to 15 of conversion the generator system is updated for the next iteration.The new supports in NS are merged (using '⊕' to remove redundancies) into the appropriate portions of the nonskeleton component.In particular, when processing a strict inequality, in line 12 the helper function points become closure points L, R, C, SP def = L, R, C ∪ SP , ∅ is applied to SK 0 , making sure that all of the skeleton points saturating β are transformed into closure points having the same position.The final processing step (line 15) calls helper procedure promote-singletons (see Pseudocode 2), making sure that all singleton supports get promoted to skeleton points.
Note that line 5 of conversion, by calling procedure violating-line (see Pseudocode 3) handles the special case of a line violating β.This is just an optimization: the helper procedure strict-on-eq-points can be seen as a tailored version of create-ns, also including the final updating of SK and NS .

Duality
The definitions given in Section 3 for a geometric generator system have their dual versions working on a geometric constraint system.We provide a brief overview of these correspondences, which are summarized in Table 2.  2. Correspondences between generator and constraint concepts.
strict inequalities (i.e., those whose corresponding non-strict inequality is not The ghost faces of P are the faces of the closure Q that do not intersect P: The set gFaces def = gFaces ∪ {Q} is a meet sublattice of cFaces; also, gFaces is downward closed and can be represented by its maximal elements.
The skeleton support SK F of a face F ∈ cFaces Q is defined as the set of all the skeleton constraints that are saturated by all the points in F .Each face F ∈ gFaces saturates a strict inequality β > ∈ C > : we can represent such a face using its skeleton support SK F of which β > is a possible materialization.A constraint system non-skeleton component NS ⊆ NS is thus a combinatorial representation of the strict inequalities of the polyhedron.
Hence, the non-skeleton components for generators and constraints have a complementary role: in the case of generators they are face fillers, marking the minimal faces that are included in nncFaces; in the case of constraints they are face cutters, marking the maximal faces that are excluded from nncFaces.Note that the non-redundant cutters in gFaces are those having a minimal skeleton support, as is the case for the fillers.
As it happens with lines, all the equalities in C = are included in all the supports ns ∈ NS so that, for efficiency, they are not represented explicitly.After removing the equalities, a singleton ns ∈ NS stands for a skeleton strict inequality constraint, which is better represented in the skeleton component, thereby obtaining SK = C = , C ≥ , SC > .Hence, a support ns ∈ NS is redundant if there exists ns ∈ NS such that ns ⊂ ns or if ns ∩ SC > = ∅.
When the concepts underlying the skeleton and non-skeleton representation are reinterpreted as discussed above, it is possible to define a conversion procedure mapping a generator representation into a constraint representation which is very similar to the one from constraints to generators.

Experimental Evaluation
The new representation and conversion algorithms for NNC polyhedra have been implemented and tested in the context of the PPL (Parma Polyhedra Library).A full integration in the PPL domain of NNC polyhedra is not possible, since the latter assumes the presence of the slack variable .The approach, summarized by the diagram in Figure 1, is to intercept each call to the PPL's conversion (working on -representations in CP n+1 ) and pair it with a corresponding call to the new algorithm (working on the new representations in P n ).On the left hand side of the diagram we see the application of the standard PPL conversion procedure: the input -representation is processed by 'old conversion' so as to produce the output -representation DD pair.The ' -less encoding' phase produces a copy of the input without the slack variable; this is processed by 'new conversion' to produce the output DD pair, based on the new skeleton/non-skeleton representation.After the two conversions are completed, the outputs are checked for both semantic equivalence and non-redundancy.This final checking phase was successful on all the experiments performed, which include all of the tests in the PPL.In order to assess efficiency, additional code was added to measure the time spent inside the old and new conversion procedures, disregarding the input encoding and output checking phases.It is worth stressing that several experimental evaluations, including recent ones [2], confirm that the PPL is a state-of-the-art implementation of the DD method for a wide spectrum of application contexts.
The first experiment5 on efficiency is meant to evaluate the overhead incurred by the new representation and algorithm for NNC polyhedra when processing topologically closed polyhedra, so as to compare it with the corresponding overhead incurred by the -representation.To this end, we considered the ppl lcdd demo application of the PPL, which solves the vertex/facet enumeration problem.In Table 3 we report the results obtained on a selection of the test benchmarks 6 when using: the conversion algorithm for closed polyhedra (columns 2-3); the conversion algorithm for the -representation of NNC polyhedra (columns 4-5); and the new conversion algorithm for the new representation of NNC polyhedra (columns 6-7).Columns 'time' report the number of milliseconds spent; columns 'sat' report the number of saturation (i.e., bit vector) operations, in millions.
The results in Table 3 show that the use of the -representation for closed polyhedra incurs a significant overhead.In contrast, the new representation and algorithm go beyond all expectations: in almost all of the tests there is no overhead at all (that is, any overhead incurred is so small to be masked by the improvements obtained in other parts of the algorithm The second experiment is meant to evaluate the efficiency gains obtained in a more appropriate context, i.e., when processing polyhedra that are not topologically closed.To this end, we consider the same benchmark discussed in [3, Table 2],7 which highlights the efficiency improvement resulting from the adoption of an enhanced evaluation strategy (where a knowledgeable user of the library explicitly invokes, when appropriate, the strong minimization procedures for -representations) with respect to the standard evaluation strategy (where the user simply performs the required computation, leaving the burden of optimization to the library developers).In Table 4 we report the results obtained for the most expensive test among those described in [3,Table 2], comparing the standard and enhanced evaluation strategies for the -representation (rows 1 and 2) with the new algorithm (row 3).For each algorithm we show in column 2 the total number of iterations of the conversion procedures and, in the next two columns, the median and maximum sizes of the representations computed at each iteration (i.e., the size of the intermediate results); in columns from 5 to 8 we show the numbers of incremental and non-incremental calls to the conver-sion procedures, together with the corresponding time spent (in milliseconds); in column 9 we show the time spent in strong minimization of -representations; in the final column, we show the overall time ratio, computed with respect to the time spent by the new algorithm.Even though adopting the standard computation strategy (requiring no clever guess by the end user), the new algorithm obtains impressive time improvements, outperforming not only the standard, but also the enhanced computation strategy for the -representation.The reason for the latter efficiency improvement is that the enhanced computation strategy, when invoking the strong minimization procedures, interferes with incrementality: the figures in Table 4 confirm that the new algorithm performs three of the seven required conversions in an incremental way, while in the enhanced case they are all non-incremental.Moreover, a comparison of the iteration counts and the sizes of the intermediate results provides further evidence that the new algorithm is able to maintain a non-redundant description even during the iterations of a conversion.

Conclusion
We have presented a new approach for the representation of NNC polyhedra in the Double Description framework, avoiding the use of slack variables and distinguishing between the skeleton component, encoded geometrically, and the nonskeleton component, provided with a combinatorial encoding.We have proposed and implemented a variant of the Chernikova conversion procedure achieving significant efficiency improvements with respect to a state-of-the-art implementation of the domain of NNC polyhedra, thereby providing a solution to all the issues affecting the -representation approach.As future work, we plan to develop a full implementation of the domain of NNC polyhedra based on this new representation.To this end, we will have to reconsider each semantic operator already implemented by the existing libraries (which are based on the addition of a slack variable), so as to propose, implement and experimentally evaluate a corresponding correct specification based on the new approach.
R, C, SP .The formalization presented in Section 3 is still valid, replacing 'γ SK ' with γ SK (NS ) def = gen(SK) ∪ γ SK (NS ).At the implementation level, each support ns ∈ NS can be encoded by using a set of indices on the data structure representing the skeleton component SK.Since NS is a finite upward closed set, the representation only needs to record its minimal elements.A support ns ∈ NS is redundant in SK, NS if there exists ns ∈ NS such that ns ⊂ ns or if ns ∩ SP = ∅, where SK = L, R, C, SP .We write NS 1 ⊕ NS 2 to denote the non-redundant union of NS 1 , NS 2 ⊆ NS SK .Pseudocode 1 Incremental conversion from constraints to generators.

Example 3 .
Consider P ∈ P 2 in the left hand side of the next figure.

ns
The skeleton SK = ∅, ∅, C, ∅ contains the closure points in C = {c 0 , c 1 , c 2 , c 3 }; the non-skeleton NS = {ns} contains a single support ns = {c 0 , c 3 }, which makes sure that the open segment (c 0 , c 3 ) is included in P; the shows a single materialization for ns.
thereby producing the filler for the open segment (c 0 , c 2 ).The resulting polyhedron, shown in the right hand side of the figure, is thus described by the skeleton SK = ∅, ∅, {c 0 , c 2 }, {p} and the non-skeleton NS = {ns }.
For a non-empty P = con(C) ∈ P n , the skeleton of C = C = , C ≥ , C > includes the non-redundant constraints defining Q = cl(P).Denoting by SC > the skeleton

Table 4 .
Comparing -representation based (standard and enhanced) computations for NNC polyhedra with the new conversion procedures.