A Berry
email: berry@isima.fr

R Krueger

G Simonet
email: simonet@lirmm.fr

Maximal Label Search algorithms to compute perfect and minimal elimination orderings

Keywords: Graph search, peo, meo, minimal triangulation, elimination scheme, MLS

Many graph search algorithms use a vertex labeling to compute an ordering of the vertices. We examine such algorithms which compute a peo (perfect elimination ordering) of a chordal graph, and corresponding algorithms which compute an meo (minimal elimination ordering) of a non-chordal graph, an ordering used to compute a minimal triangulation of the input graph.

We express all known peo-computing search algorithms as instances of a generic algorithm called MLS (Maximal Label Search) and generalize Algorithm MLS into CompMLS, which can compute any peo.

We then extend these algorithms to versions which compute an meo, and likewise generalize all known meo-computing search algorithms. We show that not all minimal triangulations can be computed by such a graph search, and, more surprisingly, that all these search algorithms compute the same set of minimal triangulations, even though the computed meos are different.

Finally, we present a complexity analysis of these algorithms.

Introduction

Graph searching plays a fundamental role in many algorithms, particularly using Breadth-First or Depth-First searches and their many variants. One important application is to compute special graph orderings related to the chordality of a graph. When the input graph is chordal, one wants to find an ordering of the vertices called a peo (perfect elimination ordering), which repeatedly selects a vertex whose neighborhood is a clique (called a simplicial vertex ), and removes it from the graph. This is a certificate of chordality, as, given an ordering of the vertices, one can determine in linear time whether it is a peo of the graph.

When the input graph fails to be chordal, it is often interesting to embed it into a chordal graph by adding an inclusion-minimal set of edges, a process called minimal triangulation. One of the ways of accomplishing this is to use an ordering of the vertices called an meo (minimal elimination ordering), and use this to simulate a peo by repeatedly adding any edges whose absence would violate the simplicial condition.

Though some earlier work had been done on these problems ( [START_REF] Ohtsuki | Minimal triangulation of a graph and optimal pivoting order in a sparse matrix[END_REF]13]), the seminal paper is that of Rose, Tarjan and Lueker [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF], which presented two very efficient algorithms to compute a peo or an meo. They introduced the concept of lexicographic order (which roughly speaking is a dictionary order), and used this for graph searches which at each step choose an unnumbered vertex of maximal label. With this technique, they introduced Algorithm LEX M, which for a non-chordal graph G = (V, E) computes an meo in a very efficient O(nm) time, (where n = |V | and m = |E|), and then streamlined this for use on a chordal graph, introducing what is now called Algorithm LexBFS, a Breadth-First Search which runs in optimal O(n + m) time and computes a peo if the input graph is chordal (see a survey on LexBFS in [START_REF] Corneil | Lexicographic Breadth First Search -a survey 30th International Workshop on Graph Theory[END_REF]).

Later work has been done on computing peos. Tarjan and Yannakakis [START_REF] Tarjan | Simple linear-time algorithms to test chordality of graphs, test acyclicity of hypergraphs, and selectively reduce acyclic hypergraphs[END_REF] presented Algorithm MCS (Maximal Cardinality Search) which is similar to LexBFS but uses a simplified labeling (a cardinality choice criterion is used instead of a lexicographic one). M CS also computes in linear time a peo if the input graph is chordal.

Shier [START_REF] Shier | Some aspects of perfect elimination orderings in chordal graphs[END_REF] remarks that neither LexBFS nor MCS is capable of computing all peos. He proposes Algorithms MEC and MCC, which can both compute any peo of a chordal graph.

Recently, Corneil and Krueger [START_REF] Corneil | A unified view of graph searching[END_REF] introduced Algorithm LexDFS as a Depth-First analogue to LexBFS. They also introduced Algorithm MNS (Maximal Neighborhood Search) which chooses at each step a vertex whose set of numbered neighbors is inclusion-maximal. They gave characterizations of the orderings computed by these search algorithms and observed, from a result of Tarjan and Yannakakis [START_REF] Tarjan | Simple linear-time algorithms to test chordality of graphs, test acyclicity of hypergraphs, and selectively reduce acyclic hypergraphs[END_REF] on the property characterizing MNS orderings, that every MNS ordering yields a peo if the input graph is chordal. They showed with these characterizations that any ordering computed by LexBFS, MCS or LexDFS can also be computed by MNS.

Berry, Blair, Heggernes and Peyton [START_REF] Berry | Maximum Cardinality Search for computing minimal triangulations of graphs[END_REF] recently introduced Algorithm MCS-M, which computes an meo. MCS-M is extended from MCS in the same fashion LEX M can be extended from LexBFS. The sets of meos defined by LEX M and by MCS-M are different, but Villanger [START_REF] Villanger | Lex M versus MCS-M[END_REF] recently showed that the same sets of minimal triangulations were obtained.

In this paper, we address natural questions which arise about peos and meos: how can the existing algorithms be generalized? Do these new algorithms compute all peos of a chordal graph? Can they all be extended to compute meos? What sets of minimal triangulations are obtained? Algorithms LexBFS, MCS, LexDFS and MNS clearly process in a similar way: they number the vertices of the input graph by repeatedly numbering an unnumbered vertex with maximal label and incrementing the labels of its neighbors. They only differ by their vertex labeling, i.e. the nature of labels and the way they are compared, initialized and incremented. We show that they can be described as instances of a generic algorithm called MLS (Maximal Label Search) having the vertex labeling as a parameter.

We show that every instance of MLS computes a peo of a chordal graph, but cannot compute every peo of every chordal graph. In order to obtain all possible peos, we extend MLS to CompMLS, which uses Shier's idea of working on the connected components of the subgraph induced by the unnumbered vertices. We show that every instance of generic CompMLS is capable of computing any peo of a chordal graph.

We then go on to examine the issues pertaining to meos and minimal triangulations. We show that MNS, MLS and CompMLS can all be extended to compute an meo, in the same way that LEX M is extended from LexBFS. We show the very strong result that all the sets of minimal triangulations computed are the same, independent of the meo-computing algorithm which is used, and that not all minimal triangulations can be computed by this new family of algorithms.

The paper is organized as follows: Section 2 gives some definitions and notations, in Section 3 we discuss peos, in Section 4 we discuss meos and in Section 5 we present a complexity analysis of the algorithms defined in the paper.

Preliminaries

All graphs in this work are undirected and finite. A graph is denoted G = (V, E), with n = |V |, and m = |E|. The neighborhood of a vertex x in G is denoted N G (x), or simply N (x) if the meaning is clear. An ordering on V is a one-to-one mapping from {1, 2, ..., n} to V . In every figure in this paper showing an ordering α on V , α is defined by giving on the figure the number α -1 (x) for every vertex x. Z + denotes the set of positive integers {1, 2, 3, . . . } and for any positive integer i, Z + i denotes the set of positive integers strictly larger than i.

A chordal (or triangulated) graph is a graph with no chordless cycle of length greater or equal to 4. To recognize chordal graphs efficiently, Fulkerson and Gross [START_REF] Fulkerson | Incidence matrixes and interval graphs[END_REF] used a greedy elimination structure on simplicial vertices: "A graph is chordal iff one can repeatedly find a simplicial vertex and delete it from the graph, until no vertex is left" (a vertex is simplicial if its neighborhood is a clique). This defines an ordering on the vertices which is called a perfect elimination ordering (peo) of the graph.

When a graph G fails to be chordal, any ordering α on the vertices can be used to embed G into a chordal graph (called a triangulation of G) by repeatedly choosing the next vertex x, adding any edges necessary to make it simplicial, and removing x. If F is the set of added edges, the graph obtained is chordal and is denoted

H = (V, E + F ) = G + α . If H = (V, E + F ) is a triangulation of G = (V, E)
, and if for every proper subset

F ′ ⊂ F , graph (V, E + F ′ ) fails to be chordal, H is called a minimal triangulation of G. If moreover α is an ordering such that H = G + α , α is called a minimal elimination ordering (meo) of G.
In [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF], two very important characterizations are given:

Path Lemma

For any graph G = (V, E), any ordering α on V and any x, y in V such that

α -1 (y) < α -1 (x), xy is an edge of G + α iff there is a path µ in G from x to y such that ∀t ∈ µ \ {x, y}, α -1 (t) < α -1 (y).

Unique Chord Property

For any graph G = (V, E) and any triangulation

H = (V, E + F ) of G, H is a minimal triangulation of G iff each edge in F is the unique chord of a 4-cycle of H.

Computing peos

Everyone of Algorithms LexBFS, MCS, LexDFS and MNS works in the following fashion: start with a graph where all vertices are unnumbered and have the same label. Repeatedly choose an unnumbered vertex x whose label is maximal (with respect to a given partial order on labels), give x the following number i (in increasing or decreasing order according to the algorithm), and increment the label of each as yet unnumbered neighbor of x into a new value depending.on its current value and i. Algorithms LexBFS and MCS, as defined in [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF] and [START_REF] Tarjan | Simple linear-time algorithms to test chordality of graphs, test acyclicity of hypergraphs, and selectively reduce acyclic hypergraphs[END_REF], number vertices from n down to 1 whereas LexDFS and MNS, as defined in [START_REF] Corneil | A unified view of graph searching[END_REF], number vertices from 1 to n, so that they actually compute the reverse of a peo of every chordal graph. In this paper, our algorithms compute peos and meos directly, and thus number vertices from n down to 1: thus vertex number 1 of a peocomputing algorithm will be a simplicial vertex of the graph.

In order to define a generic peo-computing algorithm, we first define a labeling structure: Definition 3.1 A labeling structure is a structure (L, , l 0 , Inc), where:

• L is a set (the set of labels),
• is a partial order on L (which may be total or not, with ≺ denoting the corresponding strict order), which will be used to choose a vertex of maximal label,

• l 0 is an element of L, which will be used to initialize the labels,

• Inc is a mapping from L × Z + to L, which will be used to increment a label, and such that the following condition IC (Inclusion Condition) holds:

IC : for any subsets I and I ′ of Z + 2 , if I ⊂ I ′ then lab S (I) ≺ lab S (I ′ ), where lab S (I) = Inc(...(Inc(Inc(l 0 , i 1 ), i 2 ), ...), i k ), where I = {i 1 , i 2 , ..., i k } with i 1 > i 2 > ... > i k .

It will sometimes be useful to use the number n of vertices of the graph to be labeled in the definition of Inc(l, i). It will be the case for instance for the labeling structure S 3 associated with Algorithm LexDFS. In that case, Inc can be seen as a family of mappings Inc n from L × Z + to L for each positive integer n.

The corresponding algorithm, which we introduce as MLS (Maximal Label Search), is given by Figure 1. MLS iteratively selects a vertex to add to the ordering and increments the labels of its unselected neighbors. We will refer to the iteration of the loop that defines α(i) as Step i of the algorithm.

Algorithm MLS (Maximal Label Search) input : A graph G = (V, E) and a labeling structure (L, , l 0 , Inc). output: An ordering α on V . Initialize all labels as l 0 ; G ′ ← G;

for i = n downto 1 do Choose a vertex x of G ′ of maximal label; α(i) ← x; foreach y in N G ′ (x) do label(y) ← Inc(label(y), i); Remove x from G ′ ; Figure 1: Algorithm MLS.
LexBFS, MCS, LexDFS and MNS are all special cases of MLS, with the following labeling structures (L, , l 0 , Inc); in each case, we also give the value of lab S (I) for any subset I of Z + .

LexBFS (Structure S 1 ): L is the set of lists of elements of Z + , is the lexicographic order (a total order), l 0 is the empty list, Inc(l, i) is obtained from l by adding i to the end of the list, lab S 1 (I) is the string of the integers in I in decreasing order. MCS (Structure S 2 ):

L = Z + ∪ {0}, is ≤ (a total order), l 0 = 0, Inc(l, i) = l + 1, lab S 2 (I) = |I|.
LexDFS (Structure S 3 ): L is the set of lists of elements of Z + , is the lexicographic order (a total order), l 0 is the empty list, Inc(l, i) is obtained from l by adding n + 1i to the beginning of the list, lab S 3 (I) is the string of the complements to n + 1 of the integers in I in decreasing order. MNS (Structure S 4 ): L is the power set of Z + , is ⊆ (not a total order), l 0 = ∅, Inc(l, i) = l ∪ {i}, lab S 4 (I) = I.

In our proofs, we will use the following notations.

Notations 3.2 For any graph G = (V, E), any execution of our algorithms on G computing some ordering α on V , and any integer i between 1 and n, -V i is the set of still unnumbered vertices at the beginning of Step i, i.e. the set {α(j), The following Lemma is clear from Algorithm MLS: Lemma 3.3 For any graph G = (V, E), any labeling structure S, any execution of MLS on G and S computing some ordering α on V , any integer i between 1 and n and any y ∈ V i , label i (y) = lab S (N um i (y)), and N um i (y) = N um α G,i (y), where N um α G,i (y) denotes the set of integers j > i such that α(j) is adjacent to y in G.

1 ≤ j ≤ i}, -G ′ i is graph G ′ at
Thus the label of y at the beginning of Step i is equal to lab S (N um α G,i (y)), where N um α G,i (y) is defined from the ordering α computed so far on numbered vertices, independently from the labeling structure involved. This property will allow us to characterize the orderings computed by MLS, and to compare the sets of orderings computed with different labeling structures (Characterization 3.4 and Lemma 3.5).

We can view MLS as a generic algorithm with parameter S. For every labeling structure S, we denote by S-MLS the instance of generic Algorithm MLS using this particular labeling structure S and by "S-MLS ordering of a graph G" any ordering that can be computed by S-MLS on input graph G. Thus, LexBFS is S 1 -MLS, MCS is S 2 -MLS, LexDFS is S 3 -MLS, and MNS is S 4 -MLS.

The set of S-MLS orderings of a given graph depends on S. An MLS ordering of a graph G is an ordering that can be computed by MLS on G, i.e. by S-MLS for some labeling structure S. Thus, the set of MLS orderings of G is the union of the sets of S-MLS orderings of G for all labeling structures S.

The following theorem shows that MNS can compute every S-MLS ordering of a given graph for every labeling structure S. This theorem can be proved using the MNS characterization presented in [START_REF] Corneil | A unified view of graph searching[END_REF]. We will prove it by using the following more general results. Characterization 3.4 For any graph G, any labeling structure S, and any ordering α of V , α is an S-MLS ordering of G if and only if for any integers i, j such that

1 ≤ j < i ≤ n, lab S (N um α G,i (α(i))) ≺ lab S (N um α G,i (α(j))).
Proof: α is an S-MLS ordering of G if and only if for any integer i between 1 and n, the label of α(i) at the beginning of Step i is maximal among the labels of vertices α(j), i ≤ j ≤ n. We conclude with Lemma 3.3. 2 Lemma 3.5 Let S and S ′ be labeling structures with partial orders S and S ′ resp. such that for any subsets I and

I ′ of Z + 2 , if lab S ′ (I) ≺ S ′ lab S ′ (I ′ ) then lab S (I) ≺ S lab S (I ′ ).
Then every S-MLS ordering of G is also an S ′ -MLS ordering of G for every graph G.

Proof: Let G be a graph and α be an S-MLS ordering of G. By Characterization 3.4, for any integers i, j such that: A corollary of Theorem 3.6 is that any instance of MLS computes a peo of a chordal graph, since this is true for MNS [START_REF] Corneil | A unified view of graph searching[END_REF].

1 ≤ i < j ≤ n, lab S (N um α G,i (α(i))) ≺ S lab S (N um α G,i (α(j))), where N um α G,i (α(i)) and N um α G,i (α(j)) are subsets of Z + 2 since i > 1, so lab S ′ (N um α G,i (α(i))) ≺ S ′ lab S ′ (N um α G,i (α(j))). By Characterization 3.4 again α is an S ′ -MLS ordering of G. 2
Another consequence is that any LexBFS, MCS or LexDFS ordering of a graph is also an MNS ordering, which already follows from the characterizations given in [START_REF] Corneil | A unified view of graph searching[END_REF]. However, for arbitrary labeling structures S and S ′ , an ordering computed by S-MLS need not be computable by S ′ -MLS. For instance, Figure 2(a) shows a LexBFS ordering which is not an MCS ordering, while Figure 2(b) shows an MCS ordering which is not a LexBFS ordering. There also exist graphs with MNS orderings that are neither LexBFS nor MCS orderings. As the set of MLS orderings of a graph G is the union of the sets of S-MLS orderings of G for all labeling structures S and as MNS is equal to S 4 -MLS, it follows from Theorem 3.6 that every graph has the same MLS and MNS orderings. However, be careful that MLS and MNS are different algorithms since MLS has a graph and a labelling structure as input whereas MNS only has a graph (or, if MLS is seen as a generic algorithm with a labeling structure as a parameter, MNS is only an instance of MLS). Figure 3 gives two different relations on peo-computing algorithms. Figure 3 (a) shows some instances of generic Algorithm MLS, each arrow from MLS to one of its instances being labeled with the corresponding value of parameter S. It is interesting to remark that even though MLS, or equivalently MNS, is more general (in the sense that it can compute more peos) than LexBFS and MCS, it still is not powerful enough to compute every possible peo of a given chordal graph. This is shown by the simple counterexample in Figure 4: no MLS execution on this graph will find the ordering indicated, although it is clearly a peo. In order to make it possible to find any peo, we further generalize MLS using Shier's idea [START_REF] Shier | Some aspects of perfect elimination orderings in chordal graphs[END_REF] of using the connected components of the subgraph G ′ induced by the unnumbered vertices. We thus introduce Algorithm CompMLS, defined from Algorithm MLS by replacing:

"Choose a vertex x of G ′ of maximal label;" with "Choose a connected component C of G ′ ; Choose a vertex x of C of maximal label in C;".
This generalizes the entire family of peo-computing algorithms discussed in this paper: for any X in {LexBFS, MCS, LexDFS, MNS, MLS}, Algorithm CompX is a generalization of X, and we will show that it computes a peo if the graph is chordal. Algorithms MEC and MCC defined by Shier [START_REF] Shier | Some aspects of perfect elimination orderings in chordal graphs[END_REF] are instances of generic Algorithm CompMLS: MEC is CompMNS, i.e. S 4 -CompMLS, and MCC is CompMCS, i.e. S 2 -CompMLS. Algorithm CompMNS can compute the peo of Figure 4. In fact, Shier proved in [START_REF] Shier | Some aspects of perfect elimination orderings in chordal graphs[END_REF] that CompMNS and even CompMCS compute all peos of a chordal graph. We show that this holds for every instance of Algorithm CompMLS, using some results from Section 4. Theorem 3.7 For any chordal graph G and any labeling structure S, the S-CompMLS orderings of G are exactly its peos.

Proof: Let G be a chordal graph and S be a labeling structure. By [START_REF] Shier | Some aspects of perfect elimination orderings in chordal graphs[END_REF] the CompMNS orderings of G are exactly its peos, and by Theorem 4.15 from Section 4, G has the same S-CompMLSM and CompMNSM orderings, which are also its S-CompMLS and CompMNS orderings since G is chordal (by the extension of Property 4.7 from Section 4 to CompMLS and CompMLSM). 2

We consider here that a labeling structure is defined without the condition IC, and we discuss the choice of the condition IC in view of obtaining an algorithm computing peos of chordal graphs. By Theorem 3.6 IC is a sufficient condition on a labeling structure S for S-MLS to compute only peos of every chordal graph. It turns out that it is also a necessary one, so that IC is exactly the condition required on a labeling structure for MLS to compute only peos of every chordal graph.

Theorem 3.8 The condition IC imposed on a labeling structure S is a necessary and sufficient condition for S-MLS to compute only peos of every chordal graph.

Proof: IC is a sufficient condition since by Theorem 3.6, S-MLS only computes MNS orderings, and therefore peos, of every chordal graph. Conversely, suppose there are some subsets I and I ′ of Z + 2 such that I ⊂ I ′ and lab S (I) ≺ lab S (I ′ ), and let us show that there is a chordal graph G and an S-MLS ordering of G that is not a peo of G. Let q = max(I ′ ). We choose two subset I and I ′ of Z + 2 such that I ⊂ I ′ , lab S (I) ≺ lab S (I ′ ), max(I ′ ) = q and min(I ′ ) is the largest possible with these conditions. Let p = min(I ′ ).

p > 2 since I ′ is a subset of of Z + 2 . Let G = (V, E) with V = {z 1 , z 2 , ..., z q } and E = {z i z j , p ≤ i < j ≤ q}∪{z i z p-1 , i ∈ I ′ }∪{z i z p-2 , i ∈ I}∪{z p-1 z p-2 }. G is chordal since (z 1 , z 2 , ..., z q ) is a peo of G.
By the choice of I and I ′ there is an execution of S-MLS on G choosing z q , z q-1 , ... z p first, and then choosing z p-2 before z p-1 . The resulting S-MLS ordering of G is not a peo of G because the set of neighbors of z p-1 with higher numbers than z p-1 in this ordering is not a clique, since z p-2 is not adjacent to the vertices of the form z i , i ∈ I ′ \ I. 2

The condition imposed on a labeling structure was defined in a different way in [START_REF] Berry | Ultimate generalizations of LexBFS and LEX M[END_REF]. Instead of satisfying IC, the mapping Inc had to satisfy the following condition: for any integer n in Z + , any integer i between 1 and n and any labels l and l ′ in L n i , the following properties hold:

(ls1) l ≺ Inc(l, i) (ls2) if l ≺ l ′ then Inc(l, i) ≺ Inc(l ′ , i)
where L n i is the subset of L defined by induction on i by: L n n = {l 0 }, and

L n i-1 = L n i ∪ {l = Inc(l ′ , i) | l ′ ∈ L n i }, for any i from n down to 2.
It is easy to show that this condition implies IC, but the converse is not true. For instance, let S be the labeling structure obtained from S 4 (the structure used for MNS) by replacing the inclusion order S 4 by the partial order on L defined by: for any l, l ′ ∈ L, l l ′ iff (l ⊆ l ′ or (l = {4} and 5 ∈ l ′ )) (checking that is a partial order on L is left to the reader). IC holds since the inclusion order is a suborder of , but not (ls2) since {4} ≺ {5} but Inc({4}, 3) = {4, 3} ≺ {5, 3} = Inc({5}, 3). Thus IC is more appropriate than the conjunction of (ls1) and (ls2) in the context of peocomputing algorithms, though a labeling structure satisfying IC necessarily satisfies (ls1) and often satisfies (ls2) in practice.

Let us conclude this section by some remarks on running the MLS family of algorithms on non-chordal graphs. LexBFS has been used on AT-free graphs [START_REF] Corneil | Linear Time Algorithms for Dominating Pairs in Asteroidal Triple-free Graphs[END_REF] and has been shown to have very interesting invariants even on an arbitrary graph ( [START_REF] Berry | Separability generalizes Dirac's theorem[END_REF][START_REF] Berry | Moplex elimination orderings[END_REF]). Likewise, MCS has also been used on various graph classes ( [START_REF] Dahlhaus | On Domination Elimination Orderings and Domination Graphs[END_REF][START_REF] Bodlaender | On the Maximum Cardinality Search Lower Bound for Treewidth[END_REF][START_REF] Bodlaender | On the Maximum Cardinality Search Lower Bound for Treewidth[END_REF]).

Unlike a chordal graph, a non-chordal graph does not necessarily have the same CompLexBFS, CompMCS, CompLexDFS, and CompMNS orderings.

Computing meos

We will now introduce the extensions of Algorithms MNS, MLS and CompMLS into their meo-computing counterparts.

To extend LexBFS into LEX M, at each step choosing a vertex x of maximum label label(x), an edge is added between x and any unnumbered vertex y whenever there is a path from x to y in the subgraph induced by the unnumbered vertices such that all internal vertices on the path have a label strictly smaller than the label of y. This approach has been used recently in [START_REF] Berry | Maximum Cardinality Search for computing minimal triangulations of graphs[END_REF] to extend MCS into meo-computing Algorithm MCS-M; here, we extend MLS into MLSM, as given by Figure 6. Thus LEX M is S 1 -MLSM, MCS-M is S 2 -MLSM, LexDFS-M is defined as S 3 -MLSM, and MNSM is defined as S 4 -MLSM. We will see that Algorithm MNSM is in fact as general as MLSM: every MLSM ordering of a graph is an MNSM ordering.

Algorithm MLSM (Maximal Label Search for Meo)

input : A graph G = (V, E) and a labeling structure (L, , l 0 , Inc). output: An meo α on V and a minimal triangulation

H = G + α of G. Initialize all labels as l 0 ; E ′ ← ∅; G ′ ← G; for i =n downto 1 do Choose a vertex x of G ′ of maximal label; α(i) ← x; foreach vertex y of G ′ different from x do
if there is a path from x to y in G ′ such that every internal vertex on the path has a label strictly smaller than label(y) then For any labeling structure S, we call S-MLSM the instance of Algorithm MLSM using S, and S-MLSM ordering an ordering computed by S-MLSM.

E ′ ← E ′ ∪ {xy}; foreach y in V such that xy ∈ E ′ do label(y) ← Inc(label(y), i); Remove x from G ′ ; H ← (V, E ′ );
Clearly, the relation between label i (y) and N um i (y) in an execution of MLS still holds in an execution of MLSM. Lemma 4.1 For any graph G = (V, E), any labeling structure S, any execution of MLSM on G and S, any integer i between 1 and n and any y ∈ V i , label i (y) = lab S (N um i (y)).

We will show that as for MLS, N um i (y) can be defined from the ordering α computed so far on numbered vertices, independently from the labeling structure involved, with similar consequences in terms of characterizing MLSM orderings and comparing the sets of orderings computed by MLSM with different labeling structures. To prove this, we will need several technical lemmas. Lemma 4.3 is clear from algorithm MLSM, Lemma 4.4 immediately follows from Lemma 4.1 and condition IC. The proof of Lemma 4.5 is long and technical, and so for reasons of readability is given in the Appendix. Lemma 4.3 For any graph G = (V, E), any execution of MLSM on G computing ordering α and graph H, any integers i, j such that 1 ≤ i < j ≤ n and any y in V i , the following propositions are equivalent:

The MLSM family of algorithms

1. j ∈ N um i 2. α(j)y is an edge of H, 3. there is a path µ in G ′ j from α(j) to y such that ∀t ∈ µ \ {α(j), y}, label j (t) ≺ label j (y).

V i , (i) if N um i (x) = N um i (y) then label i (x) = label i (y), and (ii) if N um i (x) ⊂ N um i (y) then label i (x) ≺ label i (y).
Lemma 4.5 For any graph G, any execution of MLSM on G computing ordering α, any integer i between 1 and n and any path µ in

G ′ i ending in some vertex y, a) ∀t ∈ µ\{y}, label i (t) ≺ label i (y) iff ∀t ∈ µ\{y}, N um i (t) ⊂ N um i (y), b) if ∀t ∈ µ\{y}, label i (t) ≺ label i (y) then ∀t ∈ µ\{y}, α -1 (t) < α -1 (y), c) if ∀t ∈ µ \ {y}, α -1 (t) < α -1 (y) then ∀t ∈ µ \ {y}, N um i (t) ⊆ N um i (y).
Proof: [of Theorem 4.2] We first show that for any execution of MLSM,

H = G + α . Let x, y ∈ V such that α -1 (y) < α -1 (x) = i.
Let us show that xy is an edge of H iff it is an edge of G + α . If xy is an edge of H then, by Lemma 4.3, there is a path µ in G ′ i from x to y such that ∀t ∈ µ \ {x, y}, label i (t) ≺ label i (y). By Lemma 4.5 b), ∀t ∈ µ \ {x, y}, α -1 (t) < α -1 (y) and, by the Path Lemma, xy is an edge of G + α . Conversely, let xy be an edge of G + α . Let us show that xy is an edge of H. By the Path Lemma, there is a path µ in G from x to y such that ∀t ∈ µ \ {x, y}, α -1 (t) < α -1 (y) < i, so µ \ {x} ⊆ V i-1 . By Lemma 4.5 c), ∀t ∈ µ \ {x, y}, N um i-1 (t) ⊆ N um i-1 (y). Let t 1 be the neighbor of x in µ. xt 1 is an edge of H, so, by Lemma 4.3, i ∈ N um i-1 (t 1 ), hence i ∈ N um i-1 (y), and by Lemma 4.3 xy is an edge of H.

We now show that

G + α is a minimal triangulation of G. Let H = G + α = (V, E + F ). As G +
α is a triangulation of G, by the Unique Chord Property, it is sufficient to show that each edge in F is the unique chord of a cycle in H of length 4. Let xy be an edge in F with α -1 (y) < α -1 (x) = i. xy is an edge of H so by Lemma 4.3 there is a path µ in G ′ i from x to y such that ∀t ∈ µ\{x, y}, label i (t) ≺ label i (y), and also α -1 (t) < α -1 (y) by Lemma 4.5 b). µ \ {x, y} = ∅ since xy is not an edge in G. Let t 1 be the vertex in µ \ {x, y} such that α -1 (t 1 ) is maximum. By the Path Lemma, xt 1 and t 1 y are edges of G + α and therefore of H. As label i (t 1 ) ≺ label i (y), by Lemma 4.4 N um i (y) ⊆ N um i (t 1 ). Let j ∈ N um i (y) \ N um i (t 1 ), and z = α(j). j > i and by Lemma 4.3 yz is an edge of H (and therefore of G + α ) but t 1 z is not. Since yx and yz are edges of G + α with α -1 (y) < α -1 (x) = i < j = α -1 (z), by definition of G + α xz is an edge of G + α , and therefore of H. Hence xy is the unique chord of cycle (x, t 1 , y, z, x) in H of length 4. 2 MLSM (and also LEX M, MCS-M, LexDFS-M and MNSM) computes an meo and a minimal triangulation of the input graph. An execution of MLSM has the same behaviour (same labeling and numbering) on the input graph G as an execution of MLS on the output minimal triangulation G + α , breaking ties in the same way. If moreover G is chordal then G is equal to its minimal triangulation G + α , so that MLS and MLSM have the same behaviour on G. We immediately obtain the following two properties: Let us remark that for two given structures S and S ′ , the sets of orderings computed by S-MLSM and S ′ -MLSM may be different, as is the case for S-MLS and S ′ -MLS. LEX M and MCS-M for example compute different orderings, as shown in Figure 2 (since MLS and MLSM compute the same orderings on a chordal graph). In the same way that MNS is as general as MLS, it turns out that MNSM is as general as MLSM, thus every graph has the same MLSM and MNSM orderings. The proof goes as for MLS and MNS since by Lemma 4.5 a) N um i (y) can be defined from the ordering α computed on numbered vertices, independently from the labeling structure used. Lemma 4.9 For any graph G = (V, E), any execution of MLSM on G computing some ordering α on V , any integer i between 1 and n and any y ∈ V i , N um i (y)) = N umM α G,i (y)), where N umM α G,i is defined on V i by induction on i from n down to 1 by: N umM α G,n (y) = ∅, and for any i from n down to 2,

N umM α G,i-1 (y) = N umM α G,i (y) ∪ {i} if there is a path µ in G ′ i from α(i) to y such that ∀t ∈ µ \ {α(i), y}, N umM α G,i (t) ⊂ N umM α G,i (y), otherwise N umM α G,i-1 (y) = N umM α G,i (y).
Characterization 4.10 For any graph G, labeling structure S, and any ordering α of V , α is an S-MLSM ordering of G if and only if for any integers i, j such that:

1 ≤ j < i ≤ n, lab S (N umM α G,i (α(i))) ≺ lab S (N umM α G,i (α(j))).
Lemma 4.11 Let S and S ′ be labeling structures with partial orders S and S ′ resp. such that for any subsets I and

I ′ of Z + 2 , if lab S ′ (I) ≺ S ′ lab S ′ (I ′ ) then lab S (I) ≺ S lab S (I ′ ).
Then every S-MLSM ordering of G is also an S ′ -MLSM ordering of G for every graph G. Theorem 4.12 For any graph G = (V, E) and any labeling structure S, any S-MLSM ordering of G is an MNSM ordering of G.

The CompMLSM family of algorithms

We define CompMLSM from MLSM in the same way we defined CompMLS from MLS. Properties extend readily from an MLSM algorithm to its CompMLSM version: at Step i, our proofs only compare the label of α(i) to labels of vertices along paths in the graph G ′ i , so α(i) needs only be maximal within the connected component of G ′ i containing it. We thus have similar results: We also easily extend results such as Properties 4.6 and 4.7 and Characterization 4.10.

An important difference between MLSM and CompMLSM is that the set of orderings CompMLSM can find is independent of the labeling structure used, and is a superset of the set of orderings obtainable by any algorithm of the MLSM family. Lemma 4.14 For any execution of MLSM or CompMLSM on a graph G, any integer i between 1 and n and any vertex y of the connected component of

G ′ i containing α(i), N um i (y) ⊆ N um i (α(i)).
Proof: Let µ be a path in G ′ i between α(i) and y. ∀t ∈ µ\{α(i)}, α -1 (t) < i, so by Lemma 4.5 c) N um i (y) ⊆ N um i (α(i)). 2 Proof: Let G be a graph and S, S ′ be labeling structures. Let α be an S-CompMLSM ordering of G, let us show that α is a S ′ -CompMLSM ordering G. By the extension of Characterization 4.10 to CompMLSM, it is sufficient to show that for any integers i, j such that 1 ≤ j < i ≤ n and α(i) and α(j) are in the same connected component of the subgraph of G induced by

{α(k), 1 ≤ k < i}, lab S ′ (N umM α G,i (α(i))) ≺ lab S ′ (N umM α G,i (α(j))
). Let i, j be such integers. By Lemma 4.14 N um i (α(j)) ⊆ N um i (α(i)) in an execution of S-CompMLSM computing α, so by Lemma 4.9

N umM α G,i (α(j)) ⊆ N umM α G,i (α(i)). It follows by condition IC that lab S ′ (N umM α G,i (α(j))) lab S ′ (N umM α G,i (α(i))
), and therefore:

lab S ′ (N umM α G,i (α(i))) ≺ lab S ′ (N umM α G,i (α(j))). 2
Every chordal graph G has the same S-CompMLSM and S-CompMLS orderings, which are exactly its peos (Theorem 3.7, whose proof uses Theorem 4.15).

Computing all peos does not extend to meos for the MLSM family of algorithms: Figure 7 shows an meo which CompMLSM is not capable of computing. This raises the question of which minimal triangulations can be obtained by various algorithms of this family. Villanger in [START_REF] Villanger | Lex M versus MCS-M[END_REF] proved the surprising result that the sets of minimal triangulations obtainable by LEX M and MCS-M are the same. Upon investigation, it turns out that, given one of these algorithms, using its Comp version does not enlarge the set of computable triangulations, although the set of computable meos may be larger. Proof: Let G = (V, E) be a graph and let S be a labeling structure. Clearly, any S-MLSM minimal triangulation of G is an S-CompMLSM one.

Conversely, let H be an S-CompMLSM minimal triangulation of G and let us show that it is an S-MLSM one. Let α be the ordering on V computed by some execution of S-CompMLSM computing H, and, for any i from 1 to n, let C i be the connected component of G ′ i chosen at step i of this execution. Let α ′ be the ordering on V and H ′ be the minimal triangulation of G computed by an execution S-MLSM, choosing, for any i from 1 to n, α ′ (i) at step i in the following way (every variable v is denoted v in the execution of CompMLSM and v ′ in that of MLSM): 1) Choose a connected component

C ′ i of G ′′ i containing a vertex of maximal label in G ′′ i . 2) If there is some j from 1 to n such that C ′ i = C j and label ′ i (α(j)) is maximuM in C ′ i then choose α ′ (i) = α(j), otherwise choose α ′ (i) equal to any vertex of C ′ i of maximal label in G ′′ i .
Note that there is at most one integer j such that

C ′ i = C j since for any j, k such that j < k, C j = C k since α(k) ∈ C k \ C j . Let us show that H ′ = H.
For any subset J of {1, 2, ..., n}, let α(J) denote the set of vertices {α(j) | j ∈ J}, and, for any i from 1 to n, let P (i) be the following property. P (i) : if there is some j from 1 to n such that

C ′ i = C j and ∀y ∈ C ′ i , α ′ (N um ′ i (y)) = α(N um j (y)
) then the edges of H ′ produced when processing the vertices of C ′ i (in the execution of MLSM) are exactly those of H produced when processing the vertices of C j (in the execution of CompMLSM). Let us show P (i) by induction on i from 1 to n. P (1) holds since C ′ 1 contains a single vertex and processing this vertex produces no edge of H (or H ′ ). We suppose P (i -1) for some i, 1 < i ≤ n. Let us show P (i). We suppose that there is some j from 1 to n such that

C ′ i = C j and ∀y ∈ C ′ i , α ′ (N um ′ i (y)) = α(N um j (y)). By Lemma 4.14 ∀y ∈ C j , N um j (y) ⊆ N um j (α(j)), so ∀y ∈ C ′ i , α ′ (N um ′ i (y)) = α(N um j (y)) ⊆ α(N um j (α(j))) = α ′ (N um ′ i (α(j))
) and therefore N um ′ i (y) ⊆ N um ′ i (α(j)). It follows by Lemma 4.4 that label ′ i (α(j)) is maximum in C ′ i . By definition of α ′ , α ′ (i) = α(j). The edges of H ′ produced when processing α ′ (i) are exactly those of H produced when processing α(j) by Lemma 4.5 a) and the fact that ∀y ∈ C ′ i , α ′ (N um ′ i (y)) = α(N um j (y)), and the connected components of G ′′ i-1 obtained from C ′ i by removing α ′ (i) are exactly those of G ′ j-1 obtained from C j by removing α(j) with ∀y ∈

C ′ i \ {α ′ (i)}, α ′ (N um ′ i-1 (y)) = α(N um j-1 (y))
. For each such connected component C, there is some k < i and some l < j such that

C = C ′ k = C l and ∀y ∈ C ′ k , α ′ (N um ′ k (y)) = α ′ (N um ′ i-1 (y)) = α(N um j-1 (y)) = α(N um l (y)
), so by induction hypothesis, the edges of H ′ produced when processing the vertices of C are exactly those of H produced when processing the vertices of C. Hence the edges of H ′ produced when processing the vertices of C ′ i are exactly those of H produced when processing the vertices of C j . So P (i) holds, which completes the induction on i. Now, for each connected component C of G there are some i and j from 1 to n such that C = C ′ i = C j and ∀y ∈ C, N um ′ i (y) = N um j (y) = ∅, so by P (i) the edges of H ′ produced when processing the vertices of C are exactly those of H produced when processing the vertices of C. Hence H ′ = H. 2 Theorem 4.16, together with Theorem 4.15, yields the following interesting result: Theorem 4.17 For any graph G, whichever meo-computing algorithm of the MLSM and CompMLSM families is used (e.g., LEX M, MCS-M, LexDFS-MNSM, or their Comp extensions), the set of computable minimal triangulations is the same.

These minimal triangulations fail to cover all possible minimal triangulations: Figure 7(b) shows a minimal triangulation which is obtainable by none of our graph search meo-computing algorithms.

Complexity of MLS and MLSM

We now consider the question of implementing Algorithms MLS and MLSM.

In the following, we use the word "implementation" in an algorithmic sense and not in a programming one. We will give a detailed version of each algorithm studied in this paper and precise the data structures used in order to compute its time and space complexity, but we will not give any real implementation in a programming language. We will also explore variants Test-MLS and Test-MLSM: Algorithm Test-MLS takes as input a graph G = (V, E), a labeling structure S and an ordering α of V and returns YES if α is an S-MLS ordering of G and NO otherwise. It is obtained from Algorithm MLS by replacing the instructions Choose a vertex x of G ′ of maximal label; α(i) ← x by if the label of α(i) is not maximal in G ′ then return NO x ← α(i) and by adding the instruction return YES at the end of the algorithm.

Test-MLSM is defined from MLSM in the same way, and we denote by Test-S-MLS, Test-S-MLSM,Test-LexBFS etc the corresponding variants of S-MLS, S-MLSM, LexBFS etc.

An implementation of S-MLS is required to compute only S-MLS orderings, but not to be able to compute every S-MLS ordering of a graph. For instance, as any MCS ordering is a MNS ordering, any implementation of MCS is also an implementation of MNS. However, an implementation finding out if a given ordering is a MCS ordering or not will not be able to find out if this ordering is a MNS ordering or not. An implementation of Test-S-MLS (resp. Test-S-MLSM) will in general have to keep closer to S than S-MLS (resp. S-MLSM). By Lemmas 3.5 and 4.11 we have the following property.

Property 5.1 Let S and S ′ be labeling structures with partial orders S and S ′ resp. such that for any subsets I and

I ′ of Z + 2 , if lab S ′ (I) ≺ S ′ lab S ′ (I ′ ) then lab S (I) ≺ S lab S (I ′ ).
Then any implementation of S-MLS (resp. S-MLSM) is also an implementation of S ′ -MLS (resp. S ′ -MLSM).

In particular, S-MLS (resp. S-MLSM) can be implemented by replacing the partial order on labels by anyone of its linear extensions.

Complexity of MLS and Test-MLS

will first study the main instances of MLS, namely LexBFS, MCS, LexDFS and MNS, then we will give an implementation of S-MLS with a stratified tree, which is a data structure designed to manipulate priority queues, for any labeling structure S such that labels are positive integers ordered by ≤.

An implementation of LexBFS is given by Rose, Tarjan and Lueker [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF], and an implementation of MCS is given by Tarjan and Yannakakis [START_REF] Tarjan | Simple linear-time algorithms to test chordality of graphs, test acyclicity of hypergraphs, and selectively reduce acyclic hypergraphs[END_REF] with the following complexity results. Theorem 5.2 [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF][START_REF] Tarjan | Simple linear-time algorithms to test chordality of graphs, test acyclicity of hypergraphs, and selectively reduce acyclic hypergraphs[END_REF] LexBFS and MCS can be implemented in O(n + m) time and space.

It is easy to check that the data structures used in [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF] for LexBFS and in [START_REF] Tarjan | Simple linear-time algorithms to test chordality of graphs, test acyclicity of hypergraphs, and selectively reduce acyclic hypergraphs[END_REF] for MCS can be used without extra cost for Test-LexBFS and Test-MCS respectively. Moreover, as by Theorem 3.6 any LexBFS or MCS ordering is an MNS one, we have the following Corollary of Theorem 5.2. We can derive from the implementation of LexBFS given in [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF] an implementation of LexDFS.

Implementation of LexDFS and Test-LexDFS with a list of lists.

As in the implementation of LexBFS, the current state of labels is represented by a list L of non-empty lists l. Each list l contains the unnumbered vertices bearing a given label, and the list L is ordered in decreasing order on the labels associated with the lists l (see [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF] for a full description of the data structure). It is initialized with a unique list l containing all the vertices of the graph. At Step i, α(i) is chosen in the first list in L and removed from this list, and for each list l in L, the neighbors of α(i) in l are removed from l and put into a new list l 1 which is placed just before l in L. This corresponds to the new decreasing LexBFS order in an execution of LexBFS. To obtain an implementation of LexDFS, it is sufficient to add the following instruction at the end of each Step i: scan the list L to extract the lists l 1 and form a list L 1 with these lists l 1 in the same order, then concatenate L 1 with the remaining list L to obtain the new list L in decreasing LexDFS order. For Test-LexDFS, we test at iteration i whether α(i) is in the first list of L or not. Proof: The time complexity of LexDFS is obtained from the time complexity of LexBFS by adding the cost of scanning the list L to form the list 1 at each step. As there are n scans and each scan requires O(n) time, we obtain an O(n 2 ) time complexity for LexDFS. The space complexity is the same as that of LexBFS, i.e. O(n + m). These complexity bounds also hold for Test-LexDFS. 2

We will now discuss implementing Test-MNS. We remark that for any vertices v and w of G ′ i , the Boolean value of label i-1 (v) label i-1 (w) only depends on the value of label i (v) label i (w) and on whether v and w are neighbors of α(i) or not. Thus we can implement Test-MNS by storing these Boolean values instead of storing and comparing explicit labels.

Implementation of Test-MNS.

We use a Boolean matrix P receq such that at the beginning of Step i, for any vertices v and w of G ′ i , P receq(v, w) = T rue iff label i (v) label i (w). P receq is initialized with True. Testing the maximality of the label of α(i) in G ′ is implemented by testing the absence of a vertex v of G ′ such that P receq(α(i), v) and not P receq(v, α(i)). Labels are updated at Step i by the following procedure, where x = α(i):

foreach neighbor v of x in G ′ do foreach non-neighbor w of x in G ′ do P receq(v, w) ← F alse It is easy to check that this procedure correctly updates matrix P receq with respect to its desired meaning, so that this implementation of Test-MNS is correct. Note that we can derive from this implementation of Test-MNS an implementation of MNS which is able to compute every MNS ordering of the input graph with the same time and space bounds. In addition to matrix P receq, we use an array containing for each vertex v of G ′ the number of vertices w of G ′ having a larger label than v (i.e. such that P receq(v, w) and not P receq(w, v)). This array allows to choose at each step a vertex of maximal label in G ′ in O(n) time.

Using a stratified tree

For any labeling structure S such that labels are positive integers ordered by ≤, S-MLS can be implemented with the data structure of a stratified tree defined by Van Emde Boas [START_REF] Van Emde | Preserving order in a forest in less than logarithmic time and linear space[END_REF][START_REF] Van Emde Boas | Design and implementation of an efficient priority queue[END_REF] to manipulate priority queues. This data structure is used to implement subset C of an interval of integers in the form [1, n] ordered by ≤, which here will be the set of current labels, i.e. the set of labels assigned to unnumbered vertices at some point of the execution of S-MLS. The stratified tree can be initialized in O(n log log n) time. Inserting or removing an element, or finding the maximum element in C requires O(log log n) time. The structure requires O(n) space. These bounds are computed in the model of the unit-cost RAM.

Implementation of S-MLS and Test-S-MLS with a stratified tree.

We suppose that labels are positive integers in some interval I ordered by ≤. The set C of current labels is stored in a stratified tree. With each current label is associated the non-empty list of unnumbered vertices having this label. These lists can be stored in an array indexed by the integers in I. At the initialization step, the unique element l 0 of C is associated with the list of all vertices of the graph. To choose an unnumbered vertex with maximal label at Step i, we find the maximum element l max of C, remove a vertex from the list associated with l max and remove l max from C if this list has become empty. For Test-S-MLS, it is tested whether σ(i) has label l max or not. To update the label of a vertex v from l to l ′ , we transfer v from the list associated with l to the list associated with l ′ , with a possible removal of l from C and a possible insertion of l ′ into C. Proof: Implementing the set C of current labels with a stratified tree requires O(n log log n) initialization time, O(log log n) time per operation and O(n) space [START_REF] Van Emde | Preserving order in a forest in less than logarithmic time and linear space[END_REF][START_REF] Van Emde Boas | Design and implementation of an efficient priority queue[END_REF]. As choosing a vertex with maximal label and updating the label of a vertex require at most a constant number of operations on the stratified tree, we obtain the announced bounds. 2

As for CompMLS, for any labeling structure S, S-CompMLS can be implemented by any implementation of S-MLS since any S-MLS ordering is an S-CompMLS one. Moreover, by Theorem 3.7 S-CompMLS restricted to chordal graphs can be implemented by an implementation of LexBFS or MCS. Test-S-CompMLS restricted to chordal graphs only has to determine if the given ordering is a peo of the graph or not, which can be implemented in linear time and space [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF].

Complexity of MLSM and Test-MLSM

MLSM is more complex than MLS since graph G ′ must additionally be searched at each Step i to determine the vertices whose label has to be i.e. the neighbors of α(i) in the minimal triangulation H of G. We will show that this search can be performed using another labeling structure than the input labeling structure S, which will allow us to deduce an implementation and complexity bounds of S-MLSM from those of LEX M and S-MLS.

An implementation of LEX M is given by Rose, Tarjan and Lueker [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF] with the following complexity results, where m ′ denotes the number of edges of the computed minimal triangulation H of G. Note that the implementation of LEX M given in [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF] only requires O(n + m) space because it only computes an meo α of G and not its minimal triangulation H = G + α . We will show that this implementation of LEX M can be used implement S-MLS for any labeling structure S. We first extend Lemma 4.5 a) to the following lemma: Lemma 5.8 For any graph G, any labeling structures S and S ′ with partial orders S and S ′ resp., any execution of MLSM on G and S, any integer i between 1 and n and any path µ in

G ′ i ending in some vertex y, ∀t ∈ µ \ {y}, label i (t) ≺ S label i (y) iff ∀t ∈ µ \ {y}, lab S ′ (N um i (t)) ≺ S ′ lab S ′ (N um i (y)).
Proof: By Lemma 4.5 a) it is sufficient to show that: ∀t ∈ µ\{y}, lab S ′ (N um i (t)) ≺ S ′ lab S ′ (N um i (y)) iff ∀t ∈ µ\{y}, N um i (t) ⊂ N um i (y). The proof of this last equivalence is similar to that of Lemma 4.5 a), replacing the references to Lemma 4.4 with references to condition IC. 2

We distinguish in an execution of MLSM the specific MLSM part which is the search in G ′ at each Step i from α(i) to determine the vertices whose label has to be incremented, from the MLS part which corresponds to an execution of MLS on the output graph G + α . We suppose in the following result that the MLS part of MLSM on G can be implemented with the same time and space complexity as MLS on G + α . In other words, we assume that the fact that G + α is only partially known at each step of an execution of MLSM does not affect the complexity of MLS, which seems reasonable since the unknown edges of G + α are between unnumbered edges and therefore play no role in the algorithm. Proof: We implement the specific MLSM part of Algorithm S-MLSM or Test-S-MLSM with the part of the implementation of LEX M given in [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF] corresponding to the specific MLSM part the updating of the integer labels l(v) at each Step. As the order on these labels l(v) at the beginning of Step i is the same as the lexicographic order on the lab S 1 (N um i (v)) with S 1 -MLSM = LEX M [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF], Lemma 5.8 ensures that this correctly implements the specific MLSM part of the algorithm. By our assumption, the MLS part of S-MLSM (resp. Test-S-MLSM) can be implemented by an implementation of S-MLS (resp. Test-S-MLS) with the same complexity as this algorithm on G + α . The result follows from Theorem 5. For some labeling structures S, we can directly derive from the implementation of LEX M given in [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF] an implementation of S-MLSM by just modifying the way labels l(v) are updated to make them correspond to the labels obtained with the labeling structure S. For instance, we obtain an implementation of LexDFS-M by replacing the instruction l(z) := l(z) + 1/2 by l(z) := l(z)+n, and we obtain an implementation of MCS-M by replacing this instruction by l(z) := l(z) + 1 and by replacing the procedure sort by: set k to the maximum value of l(v) for unnumbered vertices v. This implementation of MCS-M is a little simpler than the implementation of LEX M (with the same complexity bounds) since it avoids renaming all labels in the procedure sort. It can be used in the implementation of S-MLSM and Test-S-MLSM instead of the implementation of LEX M, and is itself an implementation of MNSM by Theorem 4.12. In the same way, we can define direct implementations of Test-LexDFS-M and Test-MCS-M, but not of Test-MNSM. If labels are positive integers ordered by ≤, we can implement the MLS part with a stratified tree, and deduce complexity bounds from Proposition 5.6 and Theorem 5.9. By Theorem 4.15, for any labeling structure S, S-CompMLSM can be implemented by an implementation of LEX M or MCS-M.

Conclusion

We have extended Algorithm LexBFS into Algorithm MLS by defining a general labeling structure, and shown how to extend this further to CompMLS to enable any possible peo to be computed. We have also extended all these algorithms to meo-computing versions. Our work yields alternate (and often simpler) proofs for the results of several papers, as [START_REF] Berry | Maximum Cardinality Search for computing minimal triangulations of graphs[END_REF][START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF][START_REF] Shier | Some aspects of perfect elimination orderings in chordal graphs[END_REF][START_REF] Tarjan | Simple linear-time algorithms to test chordality of graphs, test acyclicity of hypergraphs, and selectively reduce acyclic hypergraphs[END_REF][START_REF] Villanger | Lex M versus MCS-M[END_REF].

However, we have shown that these new meo-computing algorithms fail to enhance the possibility for finding a wider range of minimal triangulations. LEX M has been studied experimentally, and shown to be very restrictive ( [START_REF] Blair | A practical algorithm for making filled graphs minimal[END_REF]), yielding triangulations which for example are far from edge-number This problem remains with the enlarged family of new meocomputing algorithms we present here, and appears to be a fundamental limitation of graph search.

We presented time and space complexity bounds of some algorithms of the MLS and MLSM families. These results mostly derive from the known complexity bounds of LexBFS, MCS and LEX M. An interesting fact is that the search in G ′ at each step of an execution of MLSM can be performed using any other labeling structure than the input labeling structure S, which allows to implement S-MLSM by combining implementations of LEX M and S-MLS.

As mentioned in the Introduction, LexBFS and MCS, though designed for chordal graphs, have been used for graph classes other than chordal graphs. The more general peo-finding algorithms discussed in this paper could also prove useful on non-chordal graphs, on a wider variety of graph classes and problems.

Theorem 3 . 6

 36 For any graph G = (V, E) and any labeling structure S, any S-MLS ordering of G is an MNS ordering of G. Proof: This follows immediately from Lemma 3.5 and condition IC, since MNS = S 4 -MLS with lab S 4 (I) = I and ≺ S 4 =⊂. 2

4 Figure 2 :

 42 Figure 2: A chordal graph with different (a) LexBFS and (b) MCS orderings.

Figure 3 (Figure 3 :

 33 Figure 3: (a) Instances of MLS and (b) Inclusion order on the sets of computable orderings.

Figure 4 :

 4 Figure 4: α is a CompMNS ordering of G but not an MNS one.

Figure 5 (

 5 a) shows a CompLexBFS ordering which is not a CompMCS one, while Figure 5(b) shows a CompMCS ordering which is not a CompLexBFS one.

Figure 5 :

 5 Figure 5: A non-chordal graph with different (a) CompLexBFS and (b) CompMCS orderings.

Figure 6 :

 6 Figure 6: Algorithm MLSM.

Theorem 4 . 2

 42 For any execution of MLSM, H = G + α , and α is a meo of G.

Lemma 4 . 4

 44 For any graph G = (V, E), any execution of MLS or MLSM on G, any integer i between 1 and n and any x, y in

Property 4 . 6 Property 4 . 7

 4647 For any graph G and any labeling structure S, any S-MLSM ordering α of G is an S-MLS ordering of G + α . For any chordal graph G and any labeling structure S, G has the same S-MLS and S-MLSM orderings. It follows from Property 4.7 and Theorems 3.8 and 4.2 that IC is exactly the condition required on a labeling structure S for S-MLSM to compute only meos of every graph. Corollary 4.8 Condition IC imposed on a labeling structure S is a necessary and sufficient condition for S-MLSM to compute only meos of every graph. Proof: IC is a sufficient condition by Theorem 4.2. Conversely, if S-MLSM computes only meos of every graph, then it computes only peos of every chordal graph, and so does S-MLS by Property 4.7. It follows by Theorem 3.8 that S satisfies IC. 2

Theorem 4 .

 4 13 For any input graph G and any X in {LEX M, MCS-M, LexDFS-M, MNSM, MLSM}, CompX computes a meo α of G and the associated minimal triangulation G + α of G.

Theorem 4 . 15

 415 Any graph has the same S-CompMLSM orderings for all labeling structures S.

Figure 7 :

 7 Figure 7: (a) Graph G and an meo α of G. (b) The corresponding minimal triangulation G + α of G. No version of CompMLSM or MLSM can compute this meo, and the corresponding minimal triangulation is not obtainable by any of these algorithms.

Theorem 4 . 16

 416 For any graph G and any given labeling structure S, G has the same sets of S-MLSM and of S-CompMLSM minimal triangulations.

Corollary 5 . 3

 53 Test-LexBFS, Test-MCS and MNS can be implemented in O(n + m) time and space.

Theorem 5 . 4

 54 LexDFS and Test-LexDFS can be implemented in O(n 2 ) time and O(n + m) space.

Theorem 5 . 5

 55 Test-MNS can be implemented in O(n(n + m)) time and O(n 2 ) space. Proof: Initialization requires O(n 2 ) time and at each step i, testing the maximality of the label of α(i) in G ′ requires O(n) time and updating matrix P receq requires O(n|N (α(i))|) time, which makes a global O(n(n+m)) time bound. Matrix P receq requires O(n 2 ) space, which is the space bound of the algorithm. 2

Proposition 5 . 6

 56 Let S be a labeling structure such that for any integer n ≥ 1, set L n = {lab S (I), I ⊆ [1, n]} is a subset of an interval [1, r(n)] of integers ordered by ≤, with r(n) in O(n). Then S-MLS and Test-S-MLS can be implemented in O((n + m) log log n + m t Inc (n)) time and O(n + m) space, where t Inc (n)) is the time required to increment a label of L n .

Theorem 5 . 7

 57 [START_REF] Rose | Algorithmic aspects of vertex elimination on graphs[END_REF] LEX M can be implemented in O(n(n + m)) time and O(n + m ′ ) space.

Theorem 5 . 9

 59 For any labeling structure S, if S-MLS (resp. Test-S-MLS) can be implemented in O(f (n, m)) time and O(g(n, m)) space then S-MLSM (resp. Test-S-MLSM) can be implemented in O(n(n + m) + f (n, m ′ )) time and O(g(n, m ′ )) space.

7 . 2 Corollary 5 .

 725 10 MCS-M, LexDFS-M, MNSM, Test-LEX M, Test-MCS-M and Test-LexDFS-M can be implemented in O(n(n+m)) time and O(n+m ′ ) space. Test-MNSM can be implemented in O(n(n + m ′ )) time and O(n 2 ) space.

We give the proof of Lemma 4.5.

Lemma 4.5 For any graph G, any execution of MLSM on G computing ordering α, any integer i from 1 to n and any path µ in G ′ i ending in some vertex y, a) ∀t ∈ µ\{y}, label i (t) ≺ label i (y) iff ∀t ∈ µ\{y}, N um i (t)

The proof uses the following technical Lemmas 6.1 and 6.2. For any path µ containing vertices x and y, µ[x, y] denotes the subpath of µ between x and y. Lemma 6.1 For any graph G, any execution of MLSM on G, any integer i from 1 to n and any path µ in

Proof: We suppose that ∀t ∈ µ \ {y}, N um i (t) ⊂ N um i (y) (and therefore label i (t) ≺ label i (y) by Lemma 4.4). Let t ∈ µ \ {y} and let us show that N um i-1 (t) ⊂ N um i-1 (y). It is sufficient to show that if i ∈ N um i-1 (t) then i ∈ N um i-1 (y). We suppose that i ∈ N um i-1 (t). By Lemma 4.3 there is a path λ in G ′ i from α(i) to t such that ∀t ′ ∈ λ\{α(i), t}, label i (t ′ ) ≺ label i (t). Let µ ′ be the path obtained by concatenation of λ and µ

Hence by Lemma 4.3 i ∈ N um i-1 (y). 2 Lemma 6.2 For any graph G, any execution of MLSM on G, any integer i from 1 to n and any path µ in G ′ i ending in some vertex y,

Proof: We suppose that ∃t ∈ µ \ {y} | N um i (t) ⊆ N um i (y). Let j be the largest integer such that ∃t ∈ µ\{y} | N um j-1 (t) ⊆ N um j-1 (y) and let t 1 be the vertex of µ closest to y such that N um j-1 (t 1 ) ⊆ N um j-1 (y). So j -1 ≥ i, j ∈ N um j-1 (t 1 ) and ∀t ∈ µ[t 1 , y] \ {t 1 }, j ∈ N um j-1 (t). Let us show that N um j (t 1 ) = N um j (y). We assume for contradiction that N um j (t 1 ) = N um j (y). Let t 2 be the vertex of µ[t 1 , y] closest to t 1 such that N um j (t 2 ) = N um j (y). By the choice of j, ∀t ∈ µ[t 1 , t 2 ] \ {t 2 }, N um j (t) ⊂ N um j (t 2 ) and by Lemma 6.1 N um j-1 (t 1 ) ⊂ N um j-1 (t 2 ). So j ∈ N um j-1 (t 2 ) with

Proof: (of Lemma 4.5) a) For the forward direction, we assume for contradiction that ∀t ∈ µ \ {y}, label i (t) ≺ label i (y) and ∃t ∈ µ \ {y} | N um i (t) ⊂ N um i (y) (and therefore N um i (t) ⊆ N um i (y) since, by Lemma 4.4 (i), N um i (t) = N um i (y)). By Lemma 6.2, ∃t 1 ∈ µ \ {y} | N um i (y) ⊂ N um i (t 1 ) and by Lemma 4.4 label i (y) ≺ label i (t 1 ), a contradiction. The reverse direction follows immediately from Lemma 4.4. b) We suppose that ∀t ∈ µ \ {y}, label i (t) ≺ label i (y). Let k = max{α -1 (t), t ∈ µ}. By a) and Lemma 6.1, ∀t ∈ µ\{y}, label k (t) ≺ label k (y). So α(k) = y, which completes the proof. c) We assume for contradiction that ∀t ∈ µ \ {y}, α -1 (t) < α -1 (y) and ∃t ∈ µ \ {y} | N um i (t) ⊆ N um i (y). By Lemma 6.2 ∃t 1 ∈ µ \ {y} | ∀t ∈ µ[t 1 , y] \ {t 1 }, N um i (t) ⊂ N um i (t 1 ) and by a) and b), α -1 (y) < α -1 (t 1 ), a contradiction, 2