Combinatorial Redundancy Detection

The problem of detecting and removing redundant constraints is fundamental in optimization. We focus on the case of linear programs (LPs) in dictionary form, given by $n$ equality constraints in $n+d$ variables, where the variables are constrained to be nonnegative. A variable $x_r$ is called redundant, if after removing $x_r \geq 0$ the LP still has the same feasible region. The time needed to solve such an LP is denoted by $LP(n,d)$. It is easy to see that solving $n+d$ LPs of the above size is sufficient to detect all redundancies. The currently fastest practical method is the one by Clarkson: it solves $n+d$ linear programs, but each of them has at most $s$ variables, where $s$ is the number of nonredundant constraints. In the first part we show that knowing all of the finitely many dictionaries of the LP is sufficient for the purpose of redundancy detection. A dictionary is a matrix that can be thought of as an enriched encoding of a vertex in the LP. Moreover - and this is the combinatorial aspect - it is enough to know only the signs of the entries, the actual values do not matter. Concretely we show that for any variable $x_r$ one can find a dictionary, such that its sign pattern is either a redundancy or nonredundancy certificate for $x_r$. In the second part we show that considering only the sign patterns of the dictionary, there is an output sensitive algorithm of running time $\mathcal{O}(d \cdot (n+d) \cdot s^{d-1} \cdot LP(s,d) + d \cdot s^{d} \cdot LP(n,d))$ to detect all redundancies. In the case where all constraints are in general position, the running time is $\mathcal{O}(s \cdot LP(n,d) + (n+d) \cdot LP(s,d))$, which is essentially the running time of the Clarkson method. Our algorithm extends naturally to a more general setting of arrangements of oriented topological hyperplane arrangements.


Introduction
The problem of detecting and removing redundant constraints is fundamental in optimization. In this paper, we focus on redundancies in systems of linear inequalities. We consider systems of the form where B and N are disjoint finite sets of variable indices with |B| = n, |N | = d, b ∈ R B and A ∈ R B×N are given input vector and matrix. We assume that the system (1) has a feasible solution. Any consistent system of linear equalities and inequalities can be reduced to this form.
A variable x r is called redundant in (1) if x B = b − Ax N and x i ≥ 0 for i ∈ B ∪ N \ {r} implies x r ≥ 0, i.e., if after removing constraint x r ≥ 0 from (1) the resulting system still has the same feasible region. Testing redundancy of x r can be done by solving the linear program (LP) minimize x r subject to Namely, a variable x r is redundant if and only if the LP has an optimal solution and the optimal value is nonnegative. Let LP (n, d) denote the time needed to solve an LP of form (2). Throughout the paper, we are working in the real RAM model of computation, where practical algorithms, but no polynomial bounds on LP (n, d) are known. However, our results translate to the standard Turing machine model, where they would involve bounds of the form LP (n, d, ), with being the bit size of the input. In this case, LP (n, d, ) can be polynomially bounded. The notation LP (n, d) abstracts from the concrete representation of the LP, and also from the algorithm being used; as a consequence, we can also apply it in the context of LPs given by the signs of their dictionaries.
By solving n + d linear programs, O((n + d) · LP (n, d)) time is enough to detect all redundant variables in the real RAM model, but it is natural to ask whether there is a faster method. The currently fastest practical method is the one by Clarkson with running time O((n + d) · LP (s, d) + s · n · d) [4]. This method also solves n + d linear programs, but each of them has at most s variables, where s is the number of nonredundant variables. Hence, if s n, this output-sensitive algorithm is a major improvement. A related (dual) problem is the one of finding the extreme points among a set P of n points in R d . A point p ∈ P is extreme in P , if p is not contained in the convex hull of P \ {p}. It is not hard to see that this problem is a special case of redundancy detection in linear systems.
Specialized (and output-sensitive) algorithms for the extreme points problem exist [14,6], but they are essentially following the ideas of Clarkson's algorithm [4]. For fixed d, Chan uses elaborate data structures from computational geometry to obtain a slight improvement over Clarkson's method [2].
In this paper, we study the combinatorial aspects of redundancy detection in linear systems. The basic questions are: What kind of information about the linear system do we need in order to detect all redundant variables? With this restricted set of information, how fast can we detect all of them? Our motivation is to explore and understand the boundary between geometry and combinatorics with respect to redundancy. For example, Clarkson's method [4] uses ray shooting, an intrinsically geometric procedure; similarly, the dual extreme points algorithms [14,6] use scalar products. In a purely combinatorial setting, neither ray shooting nor scalar products are well-defined notions, so it is natural to ask whether we can do without them.
Our approach is very similar to the combinatorial viewpoint of linear programming pioneered by Matoušek, Sharir and Welzl [13] in form of the concept of LP-type problems. The question they ask is: how quickly can we optimize, given only combinatorial information? As we consider redundancy detection and removal as important towards efficient optimization, it is very natural to extend the combinatorial viewpoint to also include the question of redundancy. The results that we obtain are first steps and leave ample space for improvement. An immediate theoretical benefit is that we can handle redundancy detection in structures that are more general than systems of linear inequalities; most notably, our results naturally extend to the realm of oriented matroids [1].

Statement of Results.
The first point that we will make, is that for the purpose of redundancy testing, it is sufficient to know all the finitely many dictionaries associated with the system of inequalities (1). A dicitonary can be thought of as an encoding of the associated arrangements of hyperplanes (see Section 2). Moreover, we show that it is sufficient to know only the signed dictionaries, i.e., the signs of the dictionary entries. Their actual numerical values do not matter.
In Theorem 4.1, we give a characterization of such a redundancy certificate. More precisely, we show that, for every redundant variable x r there exists at least one signed dictionary such that its sign pattern is a redundancy certificate of x r . Similarly, as shown in Theorem 4.3, for every nonredundant variable there exists a nonredundancy certificate. Such a single certificate can be detected in time LP (n, d) (see Section 4.3). The number of dictionaries needed to detect all redundancies depends on the LP and can vary between constant and linear in n + d (see Appendix A).
In a second part, we present a Clarkson-type, output-sensitive algorithm that detects all redundancies in running time O(d · (n + d) · s d−1 LP (s, d) + d · s d · LP (n, d)) (Theorem 5.1). Under some general position assumptions the running time can be improved to O((n + d) · LP (s, d) + s · LP (n, d)), which is basically the running time of Clarkson's algorithm. In these bounds, LP (d, n) denotes the time to solve an LP to which we have access only through signed dictionaries. As in the real RAM model, no polynomial bounds are known, but algorithms that are fast in practice exist.
In general our algorithm's running time is worse than Clarkson's, but it only requires the combinatorial information of the system and not its actual numerical values. If the feasible region is not full dimensional (i.e. not of dimension d), then a redundant constraint may become nonredundant after the removal of some other redundant constraints. To avoid these dependencies of the redundant constraints we assume full dimensionality of the feasible region. Because of our purely combinatorial characterizations of redundancy and nonredundancy, our algorithm works in the combinatorial setting of oriented matroids [1], and can be applied to remove redundancies from oriented topological hyperplane arrangements.

Basics
Before discussing redundancy removal and combinatorial aspects in linear programs, we fix the basic notation on linear programming, -such as dictionaries and pivots steps -and review finite pivot algorithms. (For further details and proofs see e.g. [3,7].)

LP in Dictionary Form
Throughout, if not stated otherwise, we always consider linear programs (LPs) of the form where as introduced in (1), B and N are disjoint finite sets of variable indices with |B| = n, |N | = d, b ∈ R B and A ∈ R B×N are given input vector and matrix. An LP of this form is called LP in dictionary form and its size is n × d. The set B is called a (initial) basis, N a (initial) nonbasis and c T x N the objective function.
The feasible region of the LP is defined as the set of x ∈ R E that satisfy all constraints, i.e., the set The LP is called unbounded if for every k ∈ R, there exists a feasible solution x, such that c T x ≤ k. If there exists no feasible solution, the LP is called infeasible.
The dictionary D(B) ∈ R B∪{f }×N ∪{g} of an LP (3) w.r.t. a basis B is defined as where f is the index of the first row and g is the index of the first column. For each i ∈ B ∪{f } and j ∈ N ∪ {g}, we denote by d ij its (i, j) entry, by D i. the row indexed by i, and by D .j the column indexed by j.
Hence by setting x f := c T x N , we can rewrite (3) as (4) Whenever we do not care about the objective function, we may set c = 0, and with abuse of The basic solution w.r.t. B is the unique solution x to x B∪{f } = Dx N ∪{g} such that x g = 1, x N = 0 and hence x B∪{f } = D .g .
It is useful to define the following four different types of dictionaries (and bases) as shown in the figure below, where "+" denotes positivity, "⊕" nonnegativity and similarly "−" negativity and " " nonpositivity.
A dictionary D (or the associated basis The following proposition, follows from standard calculations.

Pivot Operations
We now show how to transform the dictionary of an LP into a modified dictionary using elementary matrix operation, preserving the equivalence of the associated linear system. This operation is called a pivot operation.
Let r ∈ B, s ∈ N and d rs = 0. Then it is easy to see that one can transform x B∪{f } = Dx N ∪{g} to an equivalent system (i.e., with the same solution set) : We call a dictionary terminal if it is optimal, inconsistent or dual inconsistent. There are several finite pivot algorithms such as the simplex and the criss-cross method that transform any dictionary into one of the terminal dictionaries [16,10,5]. This will be discussed further in Section 4.3.

Combinatorial Redundancy
Consider an LP in dictionary form as given in (3). Then x r ≥ 0 is redundant, if the removal of the constraint does not change the feasible solution set, i.e., if has the same feasible solution set as (3). Then the variable x r and the index r are called redundant.
If the constraint x r ≥ 0 is not redundant it is called nonredundant, in that case the variable x r and the index r are called nonredundant.
It is not hard to see that solving n + d LPs of the same size as (6) suffices to find all redundancies. Hence running time O((n + d) · LP (n, d)) suffices to find all redundancies, where LP (n, d) is the time needed to solve an LP of size n × d. Clarkson showed that it is possible to find all redundancies in time where s is the number of nonredundant variables [4]. In case where s n this is a major improvement. To be able to execute Clarkson's algorithm, one needs to assume full dimensionality and an interior point of the feasible solution set. In the LP setting this can be done by some preprocessing, including solving a few (O(d)) LPs [9].
In the following we focus on the combinatorial aspect of redundancy removal. We give a combinatorial way, the dictionary oracle, to encode LPs in dictionary form, where we are basically only given the signs of the entries of the dictionaries. In Section 4 we will show how the signs suffice to find all redundant and nonredundant constraints of an LP in dictionary form.
Consider an LP of form (3). For any given basis B, the dictionary oracle returns a matrix Namely, for basis B, the oracle simply returns the matrix containing the signs of D(B), without the entries of the objective row f . For combinatorial redundancy detection the objective function is not needed since redundancy of a constraint only depends on the given set of linear inequalities.

Certificates
We show that the dictionary oracle is enough to detect all redundancies and nonredundancies of the variables in E. More precisely for every r ∈ E, there exists a basis B such that D σ (B) is either a redundancy or nonredundancy certificate for x r . We give a full characterization of the certificates in For convenience throughout we make the following assumptions, which can be satisfied with simple preprocessing. (3) is full dimensional (and hence nonempty).

2.
There is no j ∈ N such that d ij = 0 for all i ∈ B.
In Section 4.3 we will see that both the criss-cross and the simplex method can be used on the dictionary oracle for certain objective functions. Testing whether the feasible solution set is empty can hence be done by solving one linear program in the oracle setting. As mentioned in the introduction the full-dimensionality assumption is made to avoid dependencies between the redundant constraints. This can be achieved by some preprocessing on the LP, including solving a few (O(d)) LPs [9].
It is easy to see that if there exists a column j such that d ij = 0 for all i ∈ B, then x j is nonredundant and we can simply remove the column.

A Certificate for Redundancy in the Dictionary Oracle
We say a that basis B is r-redundant if r ∈ B and D σ r. ≥ 0 i.e. if D σ (B) is as given in the figure below.
Since the r-th row of the dictionary represents Proof. We only have to show the "only if" part.
Suppose x r ≥ 0 is redundant for the system (3). We will show that there exists an r-redundant basis.
Consider the LP minimizing the variable x r subject to the system (3) without the constraint x r ≥ 0. Since x r ≥ 0 is redundant for the system (3), the LP is bounded. By assumption 1 and the fact that every finite pivot algorithm terminates in a terminal dictionary the LP has an optimal dictionary.
If the initial basis contains r, then we can consider the row associated with r as the objective row. Apply any finite pivot algorithm to the LP. Otherwise, r is nonbasic. By assumption 2, one can pivot on the r-th column to make r a basic index. This reduces the case to the first case.
Let's consider an optimal basis and optimal dictionary for the LP where x r is the objective function. Since it is optimal, all entries d rj for j ∈ N are nonnegative. Furthermore, d rg is nonnegative as otherwise we would have found a solution that satisfies all constraints except x r ≥ 0, implying nonredundancy of x r .

A Certificate for Nonredundancy in the Dictionary Oracle
Similarly as in the redundancy case, we introduce a certificate for nonredundancy using the dictionary oracle. A basis B is called r-nonredundant if B is feasible, r ∈ N and d tg = 0 implies d tr ≤ 0 for all t ∈ B i.e. D σ (B) is of the following form.  Before proving the theorem, we observe the following. 1. Unlike in the redundancy certificate an r-nonredundant basis needs to be feasible. To verify the correctness of a nonredundancy certificate we need to check between n and 2n entries, which is typically much larger than the d + 1 entries we need for the redundant case.

2.
If the g-column of a feasible basis does not contain any zeros, then all nonbasic variables are nonredundant. In general when x r ≥ 0 is nonredundant, not necessarily every feasible basis B with r ∈ N is r-nonredundant. Consider the system: Then the basis {3} is not a certificate of nonredundancy of x 1 , as d σ 31 = + in the associated dictionary. On the other hand, the basis {2} is 1-nonredundant: x r subject to Then this LP either has optimal solution −c < 0 or is unbounded. In the first case choose 0 < < c, in the latter 0 < < ∞ and consider the following perturbed version of (LP ), denoted (LP ).
Note that this LP can easily be transformed to an LP of form (3) by the straight forward variable substitution x r = x r + .
Clearly, LP (8) has optimal solution x r = − (x r = 0) and there exists an optimal dictionary where r is a nonbasic variable. This follows because if r is basic in an optimal dictionary, then x r = − , by choice of and after any pivot step in the r-th row, the updated basis corresponds to the same basic feasible solution.
Therefore we know there exists a feasible basis B of (LP ) with r ∈ N that minimizes x r . We show that if we choose small enough, B is r-nonredundant in (LP ). Let B 1 , B 2 , . . . , B m be the set of all bases (feasible and infeasible) of (LP ), that have r as a nonbasic variable. Choose > 0 such that If the RHS is undefined, we choose any < ∞.
Geometrically this means that there exists no t ∈ B i such that x t ≥ 0 is violated in the basic solution corresponding to B i in (LP ), but satisfied in the corresponding basic solution in (LP ).
Let D and D be the dictionaries w.r.t. B in (LP ) and (LP ) respectively. D and D only differ in their entries of column g, where We need to show that d tg ≥ 0 for all t ∈ B. If d tr ≥ 0, then this is clear. In the case where d tr < 0 it follows that ≥ If the RHS is undefined, we choose any < ∞. We claim that for such an , B is still feasible for (LP ) and hence x r ≥ 0 is nonredundant. Again the two dictionaries only differ in row g, where In the case where d tg = 0, it follows that d tg ≥ 0 by r-nonredundancy. If d tg > 0, then

Finite Pivot Algorithms for Certificates
In this section we discuss how to design finite pivot algorithms for the dictionary oracle model. Both the criss-cross method and the simplex method can be used for the dictionary oracle to find redundancy and nonredundancy certificates. A finite pivot algorithm chooses in every step a pivot according to some given rule and terminates in an optimal, inconsistent or dual inconsistent basis in a finite number of steps. Note that both the criss-cross method and the simplex method may not be polynomial in the worst case, but are known to be fast in practice [12,15]. Furthermore there exits no known polynomial algorithm to solve an LP given by the dictionary oracle. Fukuda conjectured that the randomized criss-cross method is an expected polynomial time algorithm [8].
By the proof of Theorem 4.1, in order to find a redundancy certificate in (3) it is enough to solve (3) with objective function x r . Similarly by the proof of Theorem 4.3, for a nonredundancy certificate it is enough to solve the -perturbed version (8).
For the criss-cross method, the pivot rule is solely dependent on the signs of the dictionary entries and not its actual values [16,11,3]. Standard calculations show that the signs in the -perturbed dictionary (for > 0 small enough) are completely determined by the signs of the original dictionary. We recall that the dictionary oracle does not output the objective row, but since we minimize in direction of x r the signs of the objective row are completely determined. (If r is basic then the objective row has the same entries as the r-th row and if r nonbasic then d σ f r = + and all other entries of the objective row are zero.) Therefore the dictionary oracle is enough to decide on the pivot steps of the criss-cross method.
For the simplex method with the smallest index rule, we are given a feasible basis and the nonbasic variable of the pivot element is chosen by its sign only [5]. The basic variable of the pivot is chosen as the smallest index such that feasibility is preserved after a pivot step. Using the dictionary oracle one can test the at most n possibilities and choose the appropriate pivot.

An Output Sensitive Redundancy Detection Algorithm
Throughout this section, we denote by S the set of nonredundant indices and by R the set of redundant indices. Denote by LP (n, d) the time needed to solve an LP. By the discussion in Section 4.3, for any x r , r ∈ E, we can find a certificate in time LP (n, d). Theorem 5.1 presents a Clarkson type, output sensitive algorithm with running time d)), that for a given LP outputs the set S , where s = |S |. Typically s and d are much smaller than n.

General Redundancy Detection
Redundancy Detection Algorithm(D,g,f ); begin Find some sets S F ⊆ S and R F ⊆ R such that S F S; R = R ∪ R F , S = S ∪ S F ; endif; endif; endwhile; S * := S; output S * ; end.
Since in every round at least one variable is added to S or R, the algorithm terminates. The correctness of the output can easily be verified: If in the outer loop r is added to R, r is redundant w.r.t. S and hence redundant w.r.t. S * ⊇ S. If in the inner loop r is added to S, r is nonredundant w.r.t. E \ R and hence nonredundant w.r.t. S * ⊆ E \ R.
The main issue is how to find the sets S F and R F efficiently in the last step. This will be discussed in (the proof of) Lemma 5.2.
A technical problem is that we cannot test for redundancy in the dictionary oracle when S does not contain a nonbasis. Therefore as long as this is the case, we fix an arbitrary nonbasis N and execute the redundancy detection algorithm on S ∪ N instead of S. Since this does not change correctness or the order of the running time, we will omit this detail in the further discussion.

Theorem 5.1. The redundancy detection algorithm outputs S , the set of nonredundant constraints in time
and consequently in time The following Lemma implies Theorem 5.1.  (n, d)) and since in each round at least one variable is added to S, it is executed at most s times. Therefore the total running time is given recursively by The claim follows by solving the recursion and noting that R(n, 0, s) can be set to O(n).
It remains to prove Lemma 5.2, for which we first prove some basic results below, using the dictionary oracle setting. Proof. We only need to show the "if" part. Let r ∈ F ∪ N be nonredundant in LP F with certificate D F . Then there exists a sequence of pivot steps from D F to D F . Using the same ones on D and obtaining dictionary D, this is a nonredundancy certificate for r, since

Lemma 5.4. Let D = [b, −A] be the dictionary of an LP of form (3). Then a variable r ∈ E is nonredundant in the LP given by D if and only if it is nonredundant in the LP given by
Proof. If D(B) is a redundancy certificate for r for some basis B, then D 0 (B) is a redundancy certificate for r as well.
For the converse, let D = D(B) be a nonredundancy certificate for r for some basis B. For simplicity assume that B = {1, 2, . . . , n}. For now assume that b i > 0 for all i ∈ B and let D i the dictionary obtained from D 0 by pivoting on b i , i = 1, 2, . . . , n. We will show that at least one of the D i , i ∈ {0, 1, . . . , n} is a nonredundancy certificate for r. Since after any pivot the first column of D i stays zero, D i is a nonredundancy certificate if and only if D i .r ≤ 0. Let R i = (r i 1 , r i 2 , . . . r i n ) T := D i .r for i ≥ 1 and R = (r 1 , r 2 , . . . , r n ) T := D 0 .r . Claim: Assume that r i i < 0 for any fixed i and there are at least i − 1 additional nonpositive entries (w.l.o.g. we assume them to be r i 1 , r i 2 , . . . , r i i−1 ). If R i has a positive entry (which w.l.o.g. we assume to be r i i+1 ), then r i+1 i+1 < 0 and r i+1 1 , r i+1 2 , . . . , r i+1 i are nonpositive. If D 0 is not a certificate for r, then w.l.o.g. r 1 > 0 and hence r 1 1 = − r1 b1 < 0. Therefore by induction the lemma follows from the claim.
and by (9) and (10), Now suppose that b i = 0 for some i. Then by the nonredundancy certificate r i ≤ 0, and it is easy to see that r j i = r i ≤ 0 for all admissible pivots on b j . Hence we can use the above construction on the nonzero entries of b.

Strong Redundancy Detection
In this section we show how under certain assumptions the running time of the redundancy algorithm can be improved. If we allow the output to also contain some weakly redundant constraints (see definition below), it is basically the same as the running time of Clarkson's method.
A redundant variable r is called strongly redundant if for any basic feasible solution x, x r > 0. In particular for any basic feasible solution, r ∈ B. If r is redundant but not strongly redundant r is called weakly redundant.
As before let S , (with |S | = s,) be the set of nonredundant indices and let R s , (with |R s | = r s ,) and R w , (with |R w | = r w ,) be the set of strongly and weakly redundant indices respectively.
The next corollary follows immediately. The theorem is proven using the following two lemmas, which can be verified with straight forward variable substitutions. Proof of Theorem 5.5. Replace the given LP by it's -perturbed version as in Lemma 5.7 and run the redundancy removal algorithm, which is possible by the same lemma. By Lemma 5.8, S * ⊇ S and S * ∩ R s = ∅. Since by Lemma 5.7, the entries of the g-column of any dictionary D σ, are strictly positive the algorithm never runs the recursive step and the running time follows.

Remark:
The -perturbation makes every feasible LP full dimensional, therefore the full dimensionality assumption can be dropped for Theorem 5.5.

Discussion
In this paper, we presented new combinatorial characterizations of redundancy and nonredundancy in linear inequality systems. We also presented a combinatorial algorithm for redundancy removal.
In contrast to the Clarkson algorithm our redundancy detection algorithm does not need the whole LP but only the combinatorial information of the dictionaries. Although in general the running time is worse, assuming that we have no weak redundancies, our redundancy removal algorithm basically has the same running time as the Clarkson algorithm. Still, a natural goal is to improve the runtime of our algorithm in the general case and get it closer to that of Clarkson's method. We do have a first output-sensitive algorithm for combinatorial redundancy detection, but the exponential dependence on the dimension d is prohibitive already for moderate d.
Our algorithm works in a more general setting of oriented matroids. This means one can remove redundancies from oriented pseudo hyperplane arrangements efficiently. Furthermore, the algorithm can be run in parallel. Yet, analyzing the performance may not be easy because checking redundancy of two distinct variables simultaneously may lead to the discovery of the same (non)redundant constraint. This is an interesting subject of future research.

A Examples
In Section 4 we showed the existence of certificates in the dictionary oracle for both redundant and nonredundant variables. How many dictionaries are needed to detect all certificates? This number depends on the given set of linear inequalities. In A.1 (A.2) we give an example where the number of dictionaries needed to detect all redundancies (nonredundancies) is linear in the number of redundant (nonredundant) variables. In A.3 we give an example where one dictionary suffices to detect all redundancies and nonredundancies.

A.1 Maximum Number of Bases to Detect all Redundancies
Consider the following set of linear inequalities on 2n + 1 variables, with |N | = n.
We claim that for i = 1, 2, . . . n, there exists exactly one i-redundant basis and these bases are distinct. Furthermore the constraints x i ≥ 0 are nonredundant for i = n + 1, n + 2, . . . , 2n + 1. Therefore we need a unique set of n dictionaries to detect all n redundancies.
We prove the claim by enumerating the bases. We will show that there are only the following four types of feasible bases. Note that by symmetry the bases of type 2 (3 and 4 respectively) are all the same up to permutation of the variables. Below the corresponding dictionaries are given for i = 1, j = 2. Correctness can be verified by appropriate pivot steps. g n+1 n+2 n+3 · · · 2n−1 2n 1 1 -1 0 0 · · · 0 0 2 1 0 -1 0 · · · 0 0 3 1 0 0 - Consider any of the dictionaries of the forms above. One can check that any pivot step that preserves feasibility returns to one of the four types.

A.2 Maximum Number of Bases to Detect all Nonredundancies
Consider the following set of inequalities in 2n variables with |N | = n.
For nonredundancy certificates we only need to consider feasible bases. The dictionary corresponding to the given set of linear inequalities is g n+1 n+2 · · · 2n−1 2n 1 Note that this is a nonredundancy certificate for n + 1, n + 2, . . . , 2n. By symmetry all the pivot steps that preserve feasibility (i.e. on the entries (i, n + i)) yield the same dictionary up to permutation. After a pivot step on entry (1, 1 + n) the updated dictionary is