Double Threshold Digraphs

TL;DR

This paper introduces a double-threshold semiorder model to better represent preference relations with uncertainty and non-transitivity, characterizing subclasses via forbidden subgraphs and providing algorithms for utility assignment and complexity measurement.

Contribution

It proposes a novel double-threshold semiorder model, characterizes subclasses through forbidden subgraphs, and develops algorithms for utility assignment and complexity analysis.

Findings

Every directed acyclic graph is a double threshold graph.

Bounds on $t_2/t_1$ define a hierarchy of subclasses.

The minimum $ ext{lambda}$ measures the complexity of DAGs.

Abstract

A semiorder is a model of preference relations where each element $x$ is associated with a utility value $\alpha(x)$, and there is a threshold $t$ such that $y$ is preferred to $x$ iff $\alpha(y) > \alpha(x)+t$. These are motivated by the notion that there is some uncertainty in the utility values we assign an object or that a subject may be unable to distinguish a preference between objects whose values are close. However, they fail to model the well-known phenomenon that preferences are not always transitive. Also, if we are uncertain of the utility values, it is not logical that preference is determined absolutely by a comparison of them with an exact threshold. We propose a new model in which there are two thresholds, $t_1$ and $t_2$; if the difference $\alpha(y) - \alpha(x)$ less than $t_1$, then $y$ is not preferred to $x$; if the difference is greater than $t_2$ then $y$ is preferred to $x$; if it is between $t_1$ and $t_2$, then then $y$ may or may not be preferred to $x$. We call such a relation a double-threshold semiorder, and the corresponding directed graph $G = (V,E)$ a double threshold digraph. Every directed acyclic graph is a double threshold graph; bounds on $t_2/t_1$ give a nested hierarchy of subclasses of the directed acyclic graphs. In this paper we characterize the subclasses in terms of forbidden subgraphs, and give algorithms for finding an assignment of of utility values that explains the relation in terms of a given $(t_1,t_2)$ or else produces a forbidden subgraph, and finding the minimum value $\lambda$ of $t_2/t_1$ that is satisfiable for a given directed acyclic graph. We show that $\lambda$ gives a measure of the complexity of a directed acyclic graph with respect to several optimization problems that are NP-hard on arbitrary directed acyclic graphs.

Figures

Full text

1. Introduction

A poset $P$ can be identified with a transitive digraph on its elements. The poset $P=P(V,<)$ is a semiorder [12] if for some utility function $\alpha:V\rightarrow{\mathbb{R}}$ we have $u<_{P}v$ if and only if $\alpha(v)-\alpha(u)>1$. Semiorders were introduced as a possible mathematical model for preference in the social sciences. A first possible model for preference is the weak orders, in which each element is assigned a utility value, such that $u$ is preferred to $v$ iff the value of $u$ is greater than the value of $v$. This was viewed as too restrictive; many preference relationships cannot be modeled by a weak order. Semi-orders were designed to model imprecision in the valuation function; we may be indifferent between elements not only if they have exactly the same values, but also if the difference between the values is smaller than some threshold. There is a great deal of literature on the subject of semiorders and preference; see the books [5, 14].

Our original motivation for defining double-threshold digraphs comes from an attempt to deal with an issue in mathematical psychology. Intuitively, it is natural to think that preference is transitive; if one prefers $a$ to $b$ and $b$ to $c$, then one “should” prefer $a$ to $c$. However, a variety of evidence exists showing that preferences are not always transitive. This has led to a great deal of discussion; for a summary of this issue, see [6]. Viewpoints range from the idea that the intuitive notion that preference is transitive are simply wrong and must be thrown away entirely to questioning whether what was being measured in the non-transitive findings was really a preference relation. Between these two views, there has been work on finding mathematical models that explain non-transitive preference; Fishburn [6] gives some possible models.

One approach to mathematical modeling is to try to give a reasonable model of extremely non-transitive preference; the famous cyclic voter’s paradoxes can be viewed as a model of preference which can allow not just non-transitivity, but also cycles.

Unlike these approaches, we generalize semi-orders to allow non-transitivity, but we require that the given set of preferences continue to be acyclic. In other words, we consider any preference relation represented by a directed acyclic graph (a dag). As in the case of semiorders, we assume that reported preferences are influenced by an underlying hidden utility function, which may be approximate, imperfectly known by a subject, or otherwise fail to capture all factors influencing a report of a preference.

One of our objectives is to obtain a measure of the departure of a given arbitrary acyclic set of pairwise preferences from a model where preferences are driven exclusively by an underlying hidden utility function, as well as derive an assignment of utility values that has the most explanatory power, in a sense that we define within a new model that we propose.

We propose a generalization of a semiorder, a double-threshold semiorder. We loosen the definition of a semiorder to a broader class of relations that are acyclic but not necessarily transitive, by allowing two thresholds $t_{1}$ and $t_{2}$ such that $t_{1}\leq t_{2}$, and finding a valuation $\alpha(x)$ for each element $x$. For two elements $x$ and $y$, $(x,y)$ is not reported as a preference if $\alpha(y)-\alpha(x)<t_{1}$, $(x,y)$ can freely be reported as a preference or not if $t_{1}\leq\alpha(y)-\alpha(x)\leq t_{2}$, and $(x,y)$ is reported as a preference if $\alpha(y)-\alpha(x)>t_{2}$. Let a satisfying utility function or a satisfying assignment of $\alpha$ values for $(t_{1},t_{2})$ be a utility function $\alpha$ that meets these constraints. This accommodates within the model the well-known phenomenon in the literature on perception that there can be a range of differences between the minimum difference that is sometimes perceived and the minimum difference that is perceived reliably.

When the relation of the double-threshold semiorder is modeled by a dag, it is called a double-threshold digraph. If a dag can be represented with thresholds $(t_{1},t_{2})$, then it can be represented with any pair $(t^{\prime}_{1},t^{\prime}_{2})$ of thresholds such that $t^{\prime}_{2}/t^{\prime}_{1}=t_{2}/t_{1}$, since a solution $\alpha$ for $(t_{1},t_{2})$ can be turned into a solution for $(t^{\prime}_{1},t^{\prime}_{2})$ by rescaling all $\alpha$ values by the factor $t^{\prime}_{1}/t_{1}=t^{\prime}_{2}/t_{2}$. Therefore, for any pair $(t_{1},t_{2})$ of thresholds, the question of whether a particular dag can be represented with them depends on the ratio $r=t_{2}/t_{1}$; larger ratios allow representations of more dags.

Henceforth, given a digraph $G$, let $n(G)$ denote the number of vertices and $m(G)$ the number of edges. When $G$ is understood, we may denote these as $n$ and $m$. For a dag $G$, let $\lambda(G)$ denote the minimum ratio of $t_{2}/t_{1}$ such that $G$ has a satisfying utility function for $(t_{1},t_{2})$. When $G$ models a weak order, $t_{1}=1$ and $t_{2}=\epsilon$ for any $\epsilon>0$ has a satisfying utility function. For this trivial special case, which is easily recognized in linear time, we define $\lambda(G)$ to be 0, the lower bound on the satisfiable ratios $t_{2}/t_{1}$, and call such a dag a degenerate dag. All other dags are nondegenerate.

When $G$ or the preference relation it models is understood, we denote $\lambda(G)$ simply by $\lambda$. For a dag that models a nondegenerate semiorder, $\lambda=1$; higher values of $\lambda$ provide a measure of the degree to which a given set of preferences depart from a semiorder. An acyclic preference relation is a $(t_{1},t_{2})$-semiorder if it has a satisfying utility function for $(t_{1},t_{2})$, that is, if $t_{2}/t_{1}\geq\lambda$. When such a preference relation is modeled as a digraph, we say the digraph is a $(t_{1},t_{2})$ double-threshold digraph. We show that for any nondegenerate dag $G$, $\lambda(G)$ can be expressed as a ratio $j/i$ where $i$ and $j$ are integers such that $1\leq i\leq j<i+j\leq n$ (Theorem 2.4), allowing $t_{1}$, $t_{2}$, and the utility function to have small integer values. Also, for any dag, $t_{1}=1$ and $t_{2}=n-1$ is always satisfiable, so $\lambda\leq n-1$. An example of when the bound is tight is when $G$ is a directed path.

Thus, the classes of dags with $\lambda$ bounded by different values give a nested hierarchy of dags, starting with weak orders and semiorders. For each class in the hierarchy, we give a characterization of the class in terms of a set of forbidden subgraphs for the class.

When $G$ has no satisfying utility function for $t_{1}$, $t_{2}$, we show how to return a forbidden subgraph as a certificate of this in $O(nm/r)$ time, where $r=t_{2}/t_{1}$, and an $O(nm/\lambda)$ time bound for finding $\lambda$ (Theorem 18). The algorithm combines elements of the Bellman-Ford single-source shortest paths algorithm [1], Karp’s minimum mean cycle algorithm [10], and dynamic programming techniques based on a topological sort of a dag. For $t_{2}/t_{1}=\lambda$, a satisfying assignment, together with a forbidden subgraph for a smaller ratio, give a certificate that $\lambda=t_{2}/t_{1}$, and these take $O(nm/\lambda)$ time to produce.

If $\lambda$ is less than $2$, $G$ must be transitive. The converse is not true: it is easy to show that the class of posets does not have bounded $\lambda$. Consider a chain $(v_{1},v_{2},\ldots,v_{n-1})$ in a poset and a vertex $v_{n}$ that is incomparable to the others; $t_{2}\geq t_{1}(n-2)/2$. Even though they are transitive, some posets are not good models of a preference relation that is based on an underlying utility function.

Although we show that bounding $\lambda$ can make some NP-complete problems tractable, bounded-ratio double-threshold digraphs are in one sense enormously larger than semiorders. Semiorders correspond to digraphs that can be represented with ratio 1. These classes of digraphs both have implicit representations [15], implying that there are $2^{O(n\log n)}$ such digraphs on a set of $n$ labeled vertices. By contrast, every height 1 digraph can be represented with ratio $1$: for each vertex $x$, assign $\alpha(x)=0$ if is it a source or $\alpha(x)=1$ if it is a sink and make the thresholds $t_{1}=t_{2}=1$. The number of such digraphs on $n$ labeled vertices, hence the number with ratio $\lambda$ for any $\lambda$ greater than or equal to 1, is $2^{\Theta(n^{2})}$.

The underlying undirected graph of a dag is the symmetric closure, that is, the undirected graph obtained by ignoring the orientations of the edges. In this paper, we say that a dag is connected if its underlying undirected graph is connected. Similarly, by a clique, coloring, independent set, or clique cover of a dag, we mean a clique, coloring, independent set or clique cover of the underlying undirected graph. Hardness results about these problems on undirected graphs also apply to dags, since every undirected graph $G$ is the underlying undirected graph of the dag obtained by assigning an acyclic orientation to $G$’s edges.

Finding a maximum independent set or clique in a dag takes polynomial time if the dag is transitive (a poset), hence if it is a semiorder, but for arbitrary dags, there is no polynomial-time approximation algorithm for finding a independent set or clique whose size is within a factor of $n^{1-\epsilon}$ of the largest unless P = NP [9]. However, for a connected dag $G$, we give an $O(\lambda m^{\lfloor\lambda+1\rfloor/2})$ algorithm for finding a maximum clique (Corollary 4.3), and an approximation algorithm that finds a clique whose size is within a desired factor of $i$ of that of a maximum clique in $O(nm/\lambda+m^{\lfloor\lambda/i+1\rfloor/2})$ time (Corollary 4.5).

We show that finding a maximum independent set is still NP-hard when $\lambda\geq 2$, but we give a polynomial-time approximation algorithm that produces an independent set whose size is within a factor of $\lfloor\lambda+1\rfloor$ of the optimum (Theorem 4.7). We give approximation bounds of $\lfloor\lambda+1\rfloor$ for minimum coloring and minimum clique cover (Theorems 4.9 and 4.10), which also have no polynomial algorithms for finding an $n^{1-\epsilon}$ approximation for arbitrary dags unless P = NP.

Thus, restricting attention to dags such that $\lambda$ is bounded by a constant makes some otherwise NP-hard problems easy and gives rise to polynomial-time approximation algorithms that cannot exist in general unless P = NP. In each case, the time bound or the approximation bound is an increasing function of $\lambda$. This supports the view of $\lambda$ as a measure of complexity of a dag. By contrast, for most similar attempts to measure complexity of a graph or digraph, the measurement is NP-hard to compute; examples include dimension of a poset, interval number, boxicity, and many others; see [15].

A concept similar to $\lambda$ was given previously by Gimbel and Trenk in [7]. They developed a generalization of weak orders to partial orders that corresponds to the special case of a $(1,k)$ transitive dag. Not assuming transitivity requires us to use different algorithmic methods, but our bounds improve their bounds for their special case from $O(n^{4}k)$ and $O(n^{6})$ to $O(mn/k)$. Most of their structural results are disjoint from ours because they are relevant to partial orders and their underlying undirected graphs, the comparability graphs.

2. Satisfying utility functions and forbidden subgraphs

We give the following formal definition:

Definition 2.1**.**

A dag is a $(t_{1},t_{2})$ double-threshold digraph if there exists an assignment of a real value $\alpha(v)$ to each vertex $v$ such that whenever $(u,v)$ is an edge, $\alpha(v)-\alpha(u)\geq t_{1}$ and whenever $(u,v)$ is not an edge, $\alpha(v)-\alpha(u)\leq t_{2}$.

Whether the constraints can be satisfied can be formulated as the problem of finding a feasible solution to a linear program:

• •

$\alpha(v)-\alpha(u)\geq t_{1}$ for each $(u,v)$ such that $(u,v)$ is an edge;

• •

$\alpha(v)-\alpha(u)\leq t_{2}$ for each $(u,v)$ such that neither $(u,v)$ nor $(v,u)$ is an edge;

• •

$\alpha(v)\leq 0$ for all $v\in V(G)$.

The last constraint is added as a convenience; for any satisfying assignment, an arbitrary constant can be subtracted from all of the $\alpha$ values to obtain a new satisfying assignment, so the constraint cannot affect the existence of a feasible solution.

This is a special case of a linear program, a system of difference constraints, where each constraint is an upper bound on the difference of two variables. This reduces to the problem of finding the weight of a least-weight path ending at each vertex in a digraph derived from the constraints, as described in [1], where there is a satisfying assignment if and only if the digraph of the reduction has no negative-weight cycle. Applying the reduction to the problem of determining whether there is a satisfying utility function on $G$ yields a digraph $G_{d}$, where $V(G_{d})=V(G)$ (see Figure 1). $G_{d}$ has an edge $(y,x)$ of weight $-t_{1}$ for each edge $(x,y)$ of $G$, and edges $(u,v)$ and $(v,u)$ of weight $t_{2}$ for each pair $\{u,v\}$ such that neither of $(u,v)$ and $(v,u)$ is an edge of $G$. A negative cycle in $G_{d}$ proves that the system is not satisfiable; otherwise, for each $x\in V$, assigning $\alpha(x)$ to be the minimum weight of any path ending at $x$ gives a satisfying assignment for $(t_{1},t_{2})$.

The single-source least-weight paths problem where some weights are negative can be solved in $O(nm)$ time, but $G_{d}$ has $\Theta(n^{2})$ edges, so a direct application of this approach takes $\Theta(n^{3})$ time to find a satisfying assignment or produce a negative-weight cycle in $G_{d}$. We derive tighter bounds below.

In terms of $G$, a negative cycle of $G_{d}$ translates to a forbidden subgraph characterization of $(t_{1},t_{2})$ double-threshold digraphs:

Definition 2.2**.**

Let $(u,v)$ be a hop in $G$ if neither $(u,v)$ nor $(v,u)$ is an edge of $G$. Let a forcing cycle be a simple cycle $(v_{1},v_{2},...,v_{k})$ such that such that for each consecutive pair $(v_{i},v_{i+1})$ (indices mod $k$), the pair is either a directed edge of $G$ or a hop. Let the ratio of the forcing cycle be the ratio of the number of edges to the number of hops.

Theorem 2.3**.**

For a nondegenerate dag $G$, the minimum satisfiable ratio $\lambda$ is equal to the maximum ratio of a forcing cycle in $G$.

One consequence of the theorem is that when $G$ is a nondegenerate dag, a satisfying assignment of $\alpha$ values for thresholds $(t_{1},t_{2})$, together with a forcing cycle with ratio equal to $t_{2}/t_{1}$ gives a certificate that $\lambda(G)=t_{2}/t_{1}$, as illustrated in Figure 2.

Theorem 2.4**.**

For every nondegenerate dag $G$, $\lambda(G)$ can be expressed as a ratio $i/j$ of integers such that $1\leq i\leq j<i+j\leq n$.

Proof 2.5**.**

This follows from the fact that $\lambda\geq 1$ and is the ratio of the number $j$ of edges to the number $i$ of hops on a forcing cycle.

Aside from showing that optimum values of $t_{1}$ and $t_{2}$ can be expressed as small integers, the theorem gives an immediate $O(n^{3}\log n)$ bound for finding $\lambda$. This is because it implies that the number of possible values $j/i$ that $\lambda$ can take on is $O(n^{2})$, and that these can be generated and sorted in $O(n^{2}\log n)$ time. A binary search on this list, spending $O(n^{3})$ time at each probe $j/i$ to determine whether $G$ is an $(i,j)$ double-threshold digraph, as described above, can then be used to find $\lambda$. Once $\lambda$ is known, a satisfying assignment of utility values for $t_{2}/t_{1}=\lambda$, together with a forcing cycle with forcing ratio equal to $\lambda$ gives a certificate that the claimed value of $\lambda$ is correct. We improve these bounds to $O(nm/\lambda)$ in section 5.

3. $k$-clique extendable orderings

In the book [15], Spinrad introduced the class of $k$-clique extendable orderings of the vertices of graphs, which we explain below. Finding whether a graph has a 2-clique extendable ordering takes polynomial time, but no polynomial time bounds are known for $k\geq 3$. However, we show in the next section that a topological sort of a nondegenerate dag $G$ is a $k$-clique extendable ordering for $k=\lfloor\lambda(G)\rfloor+1$, and develop several applications of this result to optimization problems. In this section, we give the details and analysis of the time bound of an algorithm suggested in [15] for finding a maximum clique, given a $k$-clique extendable ordering.

Two sets overlap if they intersect and neither is a subset of the other. Let $\sigma=(v_{1},v_{2},$ $\ldots,$ $v_{n})$ be an ordering of the vertices of a graph, $G=(V,E)$. For $U\subseteq W\subseteq V$ let us say that $W$ ends with $U$ if the elements of $U$ are the last elements of $W$ in $\sigma$, that is, if no element of $W\setminus U$ occurs after an element of $U$. $W$ begins with $U$ if $W$ ends with $U$ in $(v_{n},v_{n-1},\ldots,v_{1})$.

Definition 3.1**.**

An ordering $\sigma=(v_{1},v_{2},\ldots,v_{n})$ of vertices of a graph $G=(V,E)$ is $k$-clique extendable ordering of $G$ if, whenever $X$ and $Y$ are two overlapping cliques of size $k$, $|X\cap Y|=k-1$, and $X\cup Y$ begins with $X\setminus Y=\{a\}$ and ends with $Y\setminus X=\{b\}$ in $\sigma$, then $a$ and $b$ are adjacent and $X\cup Y$ is a clique.

This is a generalization of transitivity, since a dag is transitive if and only if its topological sorts are two-clique extendable orderings, hence a graph is a comparability graph if and only if it has a two-clique extendable orderings. In [15], it is shown that three-clique extendable orderings arise naturally in connection with visibility graphs, and that it takes polynomial time to find a maximum clique in a graph, given a three-clique extendable ordering. A polynomial-time generalization for $k$-clique extendable orderings is implied; we give details and a time bound next.

Lemma 3.2**.**

If $\sigma=(v_{1},v_{2},\ldots,v_{n})$ is a $k$-clique extendable ordering of a graph $G$ and $X$ and $Y$ are overlapping cliques of any size greater than or equal to $k$, such that $|X\cap Y|\geq k-1$ and $X\cup Y$ begins with $X\setminus Y$ and ends with $Y\setminus X$ in $\sigma$, then $X\cup Y$ is a clique.

Proof 3.3**.**

It suffices to show that every element of $X\setminus Y$ is adjacent to every element of $Y\setminus X$. Let $x$ be an arbitrary element of $X\setminus Y$, $y$ be an arbitrary element of $Y\setminus X$, and $Z$ be any $k-1$ elements of $X\cap Y$. Then $\{x\}\cup Z$ and $Z\cup\{y\}$ are two $k$-cliques and, by the definition of a $k$-clique extendable ordering, their union is a clique, and $x$ and $y$ are adjacent.

Corollary 3.4**.**

If $\sigma=(v_{1},v_{2},\ldots,v_{n})$ is a $k$-clique extendable ordering of a graph $G$, $X$ is a $k$-clique ending with $\{v\}$ and $Z$ is a largest clique of $G$ ending with the $(k-1)$-clique $X\setminus\{v\}$, then $Z\cup\{v\}$ is a largest clique of $G$ ending with $X$.

Proof 3.5**.**

For any clique $Y$ ending with $X$, $Y\setminus\{v\}$ is a clique ending with $X\setminus\{v\}$. $Z\cup\{v\}=Z\cup X$, which is a clique by Lemma 3.2.

Corollary 3.4 is the basis of the recurrence for a dynamic programming algorithm for finding a maximum clique of $G$, given a $k$-clique extendable ordering. We enumerate all $k$-cliques and then label each $k$-clique $K$ with the maximum size $h_{K}$ of a clique that ends with $K$. If $(u_{1},u_{3},\ldots,u_{k})$ is the left-to-right ordering of a $k$-clique in the ordering, then its label is one plus the maximum of the labels of cliques of the form $(x,u_{1},u_{2},\ldots,u_{k-1})$. The size of the maximum clique of $G$ is the maximum of the labels. Details and the proof of the following resulting time bound is given in the appendix.

Theorem 3.6**.**

Given a $k$-clique extendable ordering of a graph $G$, a maximum clique can be found in $O(km^{k/2})$ time.

It is easy to see that when the vertices of $G$ have positive weights, the problem of finding a maximum weighted clique can be solved in the same time bound, using a trivial variant of Corollary 3.4.

4. Optimization problems on dags with bounded $\lambda$ values

We now show that restricting attention to dags such that $\lambda$ is bounded by a constant makes some otherwise NP-hard problems easy or gives rise to polynomial-time approximation algorithms that cannot exist for the class of all dags unless P = NP. The NP-hard problems we consider can be trivially solved in linear time on degenerate dags, so we focus on nondegenerate dags.

Theorem 4.1**.**

Let $G$ be a nondegenerate dag and $k=\lfloor\lambda(G)\rfloor+1$. A topological sort of $G$ is a $k$-clique extendable ordering.

Proof 4.2**.**

Let $(v_{1},v_{2},\ldots,v_{n})$ be a topological sort, and let $\alpha$ be a satisfying utility function for $(t_{1},t_{2})$ such that $t_{2}/t_{1}=\lambda$. Let $(w_{1},w_{2},\ldots,w_{k})$ and $(w_{2},w_{3},\ldots,w_{k},w_{k+1})$ be the left-to-right orderings of two $k$-cliques $K^{\prime}$ and $K$. Then $(w_{1},w_{2},\ldots,w_{k+1})$ is a directed path in $G$, hence $\alpha(w_{k+1})-\alpha(w_{1})\geq kt_{1}>t_{2}$, $(w_{1},w_{k+1})$ is an edge and $K\cup K^{\prime}$ is a clique.

Corollary 4.3**.**

It takes $O(\lambda m^{\lfloor\lambda+1\rfloor/2})$ time to find a maximum clique in a connected nondegenerate dag $G$.

Proof 4.4**.**

To avoid an additive $O(nm/\lambda)$ term, run the dynamic programming algorithm on a topological sort under the assumption that it is a 2-clique extendable ordering in $O(m)$ time by Theorem 3.6, and return the result if it is a clique. Otherwise, do the same under the assumption that it is a 3-clique extendable ordering, in $O(m^{3/2})$ time. If a max clique has not yet been returned, then $\lambda\geq 3$ by Theorem 4.1, so compute $\lambda$ in $O(nm/\lambda)=O(m^{2})$ time, which is now subsumed by the bound we want to show. A topological sort is a $\lfloor\lambda\rfloor+1$ extendable ordering by Theorem 4.1, so it takes $O(\lambda m^{\lfloor\lambda+1\rfloor/2})$ time to find a maximum clique by Theorem 3.6.

Even if $\lambda$ is bounded by a moderately large constant, this bound could be prohibitive in practice, but it also gives an approximation algorithm that allows a tradeoff between time and approximation factor:

Corollary 4.5**.**

Given a connected nondegenerate dag $G$ and integer $i$ such that $1\leq i\leq\lambda$, a clique whose size is within a factor of $i$ of the size of a maximum clique can be found in $O((\lambda/i)m^{(\lfloor\lambda/i\rfloor+1)/2})$ time.

Proof 4.6**.**

Let $G^{\prime}$ be the result of removing the edges $\{(u,v)|(u,v)\in E(G)$ and $\alpha(v)-\alpha(u)<i\}$. A satisfying function $\alpha$ for $G$ and thresholds $(1,\lambda(G))$ is also a satisfying function for $G^{\prime}$ and thresholds $(i,\lambda(G))$, so $\lambda(G^{\prime})\leq\lambda(G)/i$. Applying Theorems 3.6 and 4.1, we get a maximum clique of $G^{\prime}$ in $O((\lambda/i)m^{(\lfloor\lambda/i\rfloor+1)/2})$ time. A maximum clique of $G$ induces a directed path $(v_{0},v_{1},...,v_{k})$ in $G$, and $\{v_{0},v_{i},v_{2i},\ldots,v_{\lfloor k/i\rfloor}\}$ is a clique of $G^{\prime}$, so the size of a maximum clique in $G^{\prime}$ is within a factor of $i$ of the size of a maximum clique in $G$.

If $\lambda(G)<2$, a maximum independent set in $G$ can be obtained in polynomial time, since $G$ is transitive [8]. However, even when $\lambda(G)=2$, the problem of determining whether $G$ has an independent set of size $k$ is NP-complete. This is seen as follows. It is NP-complete to decide whether a 3-colorable graph has an independent set of a given size $k$, even when the 3-coloring is given [11]. Given such a graph $G^{\prime}$, $k$, and three-coloring, let $C_{1}$, $C_{2}$, and $C_{3}$ be the three color classes. Every edge $e$ has endpoints in two of the classes; orient $e$ from the endpoint in the class with the smaller subscript to the endpoint in the class with the larger subscript. Doing this for all edges results in a dag $G$ such that $\lambda(G)=2$, since, for each vertex $x$, if $x\in C_{i}$, assigning $\alpha(x)=i$ gives a satisfying assignment of utility values for $t_{2}=2$ and $t_{1}=1$. There is an independent set of size $k$ in $G$ if and only if there is one in $G^{\prime}$.

Theorem 4.7**.**

For $G$ in the class of dags where $\lfloor\lambda(G)\rfloor+1\leq k$, there is a polynomial $k$-approximation algorithm for the problem of finding a maximum independent set in $G$.

Proof 4.8**.**

Find a satisfying assignment of utility values for $(t_{1},t_{2})$ such that $t_{2}/t_{1}=\lambda(G)$, then find an interval of the form $[x,x+t_{1})$ such that the size of the set $Y$ whose $\alpha$ values are in the interval is maximized. $Y$ is an independent set, since no pair of them has $\alpha$ values that differ by $t_{1}$. Return these vertices as an independent set.

For the approximation bound, let $X$ be a maximum independent set. The $\alpha$ values of $X$ lie in an interval of the form $[y,y+t_{2}]$, which is a subset of the union $[y,y+kt_{1})$, of $k$ intervals of the form $[x,x+t_{1})$, hence $|X|\leq k|Y|$.

Proofs of the following make similar use of the availability of satisfying $\alpha$ values are given in the appendix.

Theorem 4.9**.**

For $G$ in the class of dags where $\lfloor\lambda(G)\rfloor+1\leq k$, there is a polynomial $k$-approximation algorithm for the problem of finding a minimum coloring of $G$.

Theorem 4.10**.**

For $G$ in the class of dags where $\lfloor\lambda(G)\rfloor+1=k$, there is a polynomial $k$-approximation algorithm for the problem of finding a minimum clique cover of $G$.

5. $O(nm/\lambda)$ bounds for finding satisfying utility

functions, $\lambda$, and certificates

In this section, we first show how to find a satisfying assignment of utility values for given thresholds $(t_{1},t_{2})$, in $O(nm/r)$ time, where $r=t_{2}/t_{1}$. We then show how to find $\lambda$ in $O(nm/\lambda)$ time. By solving the second problem to find $\lambda$, then selecting $(t_{1},t_{2})$ such that $t_{2}/t_{1}=\lambda$ and solving the first, we get the certificates for $\lambda$, that is, a satisfying assignment and a cycle such that the ratio of edges to hops is $\lambda$, which comes from a zero-weight cycle in $G_{d}$.

For both of these problems, we use the following. When $G$ is an arbitrary digraph where each vertex $x$ has a weight $w(x)$ and each edge $(y,z)$ has a weight $w(y,z)$, it takes $O(m)$ time to find $w^{\prime}(v)=\min(\{\infty\}\cup\{w(u)+w(u,v)|(u,v)$ is an edge of $G\}$ for each vertex $v$ of $G$. Let us call this the general relaxation procedure. In the special case where $G$ is a dag, it takes $O(m)$ time to find $w^{\prime}(v)=\min_{u}(\{w(u)+w_{uv})\})$, where $w_{uv}$ is the minimum weight of any path from $u$ to $v$ and $w_{vv}$ = 0. This can be used to solve the single-source shortest paths problem on a connected dag in $O(m)$ time [1]. Let us call this the dag variant of the relaxation procedure.

In a digraph with edge weights, let the length of a walk be the number of occurrences of edges on the walk and its weight be the sum of weights of occurrences of edges. If an edge occurs $k$ times on the walk, it contributes $k$ to the length, and if its weight is $w$, it contributes $kw$ to the weight and $kw$ to the number of (occurrences of) edges of weight $w$ on the walk.

5.1. Finding a satisfying utility function or a forbidden subgraph for

$(t_{1},t_{2})$.

The Bellman-Ford algorithm is a dynamic programming algorithm that works as follows on a connected digraph $G$ where a vertex $s$ has been added that has an edge of weight zero to all other vertices. Let $D(i,v)$ be the minimum weight of any walk from $s$ to $v$ that has at most $i+1$ edges. $D(i,v)$ is just the minimum weight of any walk of length at most $i$ in $G$ ending at $v$; henceforth we omit $s$ from the discussion. $D(0,v)=0$ for all $v\in V$. During the “$i^{th}$ pass” the algorithm computes $D(i,v)$ as $min(\{(D(i-1,u)+w(u,v)|(u,v)\in E\})$. This is just an instance of the general relaxation procedure where $w(v)=D(i-1,v)$ and the loop $(v,v)$ is considered to be an edge of weight 0 for each $v\in V$. If there is no negative cycle, there is always a path ending at $v$ that is a minimum-weight walk ending at $v$, so $D(n-1,v)$ gives the minimum weight of any path ending at $v$. If there is a negative cycle, this is detected when $D(n,v)<D(n-1,v)$ for some $v$, indicating a walk of length $n$ of smaller weight of any path, which must have a negative cycle on it. By annotating the dynamic programming entries with suitable pointers, it is possible to find such a cycle within the same bound. The $n$ passes to compute $D(n,v)$ for all $v$ each take $O(m)$ time, for a total of $O(nm)$ time.

To exploit the structure of $G_{d}$ to improve the running time, we let $B(i,v)$ denote the minimum weight of any path that has at most $i$ edges of weight $t_{2}$, rather than at most $i$ edges in total. We use the elements $B(i,v)$, rather than the elements of $D(i,v)$, as the elements of the dynamic programming table. Let us call this reindexing the dynamic programming table. We obtain $B(0,v)$ by assigning $w(v)=0$ and running the dag variant of the relaxation procedure on the edges of weight $-t_{1}$, since they are acyclic. For pass $i$ such that $i>0$, any improvements obtained by allowing an $i^{th}$ edge of weight $t_{2}$ are computed with the general relaxation procedure, where loops are considered to be edges of weight 0, and, after this, any additional improvements obtained by appending additional edges of weight $-t_{1}$ are computed by the dag variant of the relaxation procedure.

Because every vertex has a walk of length and weight 0 ending at it, $B(i,v)\leq 0$ for $i\geq 0$. Therefore, for $i>0$, if $B(i,v)<B(i-1,v)$, the ratio of edges of weight $-t_{1}$ to edges of weight $t_{2}$ is greater than $r=t_{2}/t_{1}$. Any such walk must have more than $ir$ edges of weight $-t_{1}$, hence length greater than $i(r+1)$. Therefore, if there is no negative cycle in $G_{d}$, for $i=\lfloor(n-1)/(r+1)\rfloor+1$, $B(i,v)=D(n-1,v)$, and a negative cycle occurs if $B(i+1,v)<B(i,v)$ for this $i$ and some $v$. A negative cycle can be found by the standard technique of annotating the results of the relaxation operations with pointers to earlier results. The advantage of reindexing the table is that the algorithm now takes $O(n/r)$ passes instead of $n$ of them.

To get the $O(nm/r)$ bound, it remains to show how to perform each pass in $O(m)$ time. The bottleneck is evaluating $w^{\prime}(v)=\min\{\{w(v)\}\cup\{w(u)+t_{2}|(u,v)$ is an edge of weight $t_{2}\}$ for the general relaxation step. Since all of the edges have the same weight, we rewrite this as $w^{\prime}(v)=min\{w(v),w(x)+t_{2}\}$ where $x$ minimizes $w(u)=B(i-1,u)$ for all $u$ such that $w(u,v)=t_{2}$. To evaluate this, we just have to find $x$. At the beginning of the pass, we radix sort the vertices in ascending order of $B(i-1,*)$, giving list $L$. To compute $B^{\prime}(i,v)$, we mark the vertices that have an edge to $v$, then traverse $L$ until we find $x$ as the first unmarked vertex we encounter, then unmark the vertices that have edges to $v$. This takes time proportional to the in-degree of $v$, hence $O(m)$ time for all vertices in the pass.

5.2. Finding $\lambda$

To find $\lambda(G)$, we use the fact that that if $t_{2}/t_{1}=\lambda$, the corresponding weighting of $G_{d}$ will give it a zero-weight cycle in $G_{d}$, which gives a forcing cycle of ratio $\lambda$ in $G$ as a certificate.

For arbitrary $(t_{1},t_{2})$, let the mean weight of a directed cycle or path of length at least one in $G_{d}$ be the weight of the cycle divided by the number of edges. The minimum mean weight of a cycle is the minimum cycle mean. Subtracting a constant $c$ from the weight of all edges in $G_{d}$ subtracts $c$ from the mean weight of every cycle and path of length at least one. For arbitrary $t_{1}$ and $t_{2}$, weighting $G_{d}$ in accordance with $(t_{1}+c,t_{2}-c)$ in place of $(t_{1},t_{2})$ has the same effect of subtracting $c$ from the weights of all edges. Thus, for arbitrary $(t_{1},t_{2})$, if $c$ is the minimum cycle mean of the corresponding weighting of $G_{d}$, then $\lambda=(t_{2}-c)/(t_{1}+c)$. Finding $\lambda$ reduces to finding the minimum cycle mean in the weighting of $G_{d}$ obtained from an arbitrarily assigned $(t_{1},t_{2})$.

In a digraph $G$ with edge weights, let $F(i,v)$ be the minimum weight of any walk of length exactly $i$ ending at $v$. In [10], Karp showed the following:

Theorem 5.1**.**

*The minimum cycle mean of a digraph with edge weights is

$\min_{v\in V}\max_{0\leq i<n}[(F(n,v)-F(i,v))/(n-i)]$.*

Karp actually shows this when an arbitrary vertex $s$ is selected and $F(i,v)$ is defined to be the minimum weight of all walks of length $i$ from $s$ to $v$, but if it is true for walks beginning at an arbitrary vertex $s$, then it is true when $s$ is allowed to vary over all vertices of $V$. Omitting $s$ from consideration in this way in his proof gives a direct proof of this variant of his theorem. He reduces the problem to the special case where $G$ is strongly connected by working on each strongly-connected component separately, but the only purpose of this in his proof is to ensure that there is a path from $s$ to all other vertices, and this is unnecessary when $s$ is allowed to vary over all vertices.

$F(i,v)$ can be computed by a variant of Bellman-Ford, by using the recurrence $F(i,v)=\min(\{\infty\}\cup\{F(i-1,u)+w(u,v)|(u,v)\in E\})$ in place of $D(i,v)=\min(\{D(i-1,v)\}\cup\{D(i-1,u)+w(u,v)|(u,v)\in E\})$. The only difference from the algorithm of Section 5.1 is that loops of the form $(v,v)$ are not considered to be edges. Computing $F(n,v)$ for all $v\in V$ takes $n$ passes, each of which applies the general relaxation operation, for a total of $O(nm)$ time.

An obstacle to an $O(nm/\lambda)$ bound that we did not have in Section 5.1 is that in Theorem 5.1, computing $[(F(n,v)-F(i,v))/(n-i)]$ for $0\leq i<n$ requires $\Theta(n^{2})$ computations, which is not $O(nm/\lambda)$.

We again reindex the dynamic programming table (Section 5.1), letting $H(i,v)$ denote the minimum-weight walk ending at $v$ in $G_{d}$ that has exactly $i$ edges of weight $t_{2}$. We compute the values in passes, computing $H(i,v)$ for each $v\in V$ during pass $i$. As in Section 5.1, each pass takes takes $O(m)$ time; the only change is that in the general relaxation step, loops are not considered to be edges. We claim that $O(n/\lambda)$ passes suffice, but a new difficulty is knowing when to stop, since, unlike $r$ of the Section 5.1, $\lambda$ is not known in advance.

A walk with $i$ edges of weight $t_{2}$ and weight $H(i,v)$ has $i$ edges of weight $t_{2}$, so it must have $(it_{2}-F(i,v))/t_{1}$ edges of weight $-t_{1}$. Its length, $l(i,v)$, can be computed as $i+it_{2}-F(i,v)$ in $O(1)$ time.

Let a term $H(i,v)$ be term of interest if $l(i,v)=n$, that is, if it corresponds to a walk of interest of length $n$. We use the following reindexed variant of Karp’s theorem, which says that it suffices to compute an inner maximum over a smaller set, and only for terms of interest. The proof is the one Karp gives, reindexed, and omitting reference to a start vertex $s$ by allowing the start vertex to vary over all vertices. For completeness, we give the modified proof in the appendix.

Theorem 5.2**.**

*In $G_{d}$, the minimum mean weight of a cycle is equal to

$\min_{\{(i,v)|l(i,v)=n\}}\max_{0\leq j<i}(H(i,v)-H(j,v))/(n-l(j,v))$*

The solution is given as Algorithm 1. During the $i^{th}$ pass, the algorithm computes $H(i,v)$ for all $v\in V$. Before proceeding to the next pass, it updates a partial computation of the expression of Theorem 5.2, computing $\max_{0\leq j<i}(H(i,v)-H(j,v))/(l(i,v)-l(j,v))$ for each the terms of interest $H(i,v)$ that has been computed during the pass, and keeping track of the minimum of these computations so far. Let a term of interest $H(i,v)$ be critical if the minimum cycle mean is equal to $\max_{0\leq j<i}(H(i,v)-H(j,v))/(l(i,v)-l(j,v))$. The strategy of the algorithm is to return the minimum it has found so far once it detects that a critical term has been evaluated.

Let a critical walk be a walk of length $n$ giving rise to a critical term.

Lemma 5.3**.**

In $G_{d}$, the mean weight of a critical walk is less than or equal to the minimum cycle mean.

The proof is given in the appendix.

Theorem 5.4**.**

Given a nondegenerate dag $G$, it takes $O(nm/\lambda)$ time to find $\lambda(G)$.

Proof 5.5**.**

The basis of this is Algorithm 1. For a term of interest, $H(i,v)$, the mean weight of the corresponding walk is $(it_{2}-(n-i)t_{1})/n$, which is an increasing function of $i$. Thus, once this exceeds the minimum value, $min$, found so far a critical term has been found and is already reflected in the value of $min$. Thus, Algorithm 1 returns the minimum cycle mean.

The minimum cycle mean is the ratio of edges of weight $-t_{1}$ to edges of weight $t_{2}$ on a cycle of minimum mean. This must also be true for a critical walk, by Lemma 5.3. This ratio for the walks of interest in pass $i$ is $(n-i)/i$, so the algorithm halts before the first pass $i^{\prime}$ such that $(n-i^{\prime})/i^{\prime}>\lambda$, and $i^{\prime}=O(n/\lambda)$. Thus, Algorithm 1 halts after $O(n/\lambda)$ passes.

Using the approach of Section 5.1, the operations in a pass take $O(m)$ time except for evaluating $\max_{0\leq j<i}(H(i,v)-H(j,v))/(n-l(j,v))$ for terms $H(i,v)$ of interest. For any vertex $v$, $H(i,v)$ is a term of interest for at most one value of $i$. Therefore, the cost of evaluating $\max_{0\leq j<i}(H(i,v)-H(j,v))/(n-l(j,v))$ for terms of interests is bounded by the total number of dynamic programming table entries $H(j,w)$ for $0\leq j\leq i$ and $w\in V$ computed by the algorithm, which is the number $n$ of them computed in each pass times $O(n/\lambda)$ passes. This is $O(n^{2}/\lambda)$.

6. Appendix

Theorem 3.6: Given a $k$-clique extendable ordering of a graph $G$, a maximum clique can be found in $O(km^{k/2})$ time.

Proof 6.1**.**

Let $(v_{1},v_{2},\ldots,v_{n})$ be the $k$-clique extendable ordering. There are $O(m^{k/2})$ cliques in a connected graph with $m$ edges, and they can be enumerated in $O(km^{k/2})$ time [2]. If there are no $k$-cliques, a maximum clique can be found in $O(km^{k/2})$ time by applying this algorithm to find all $i$-cliques for $i<k$.

Otherwise, we denote each $k$-clique with a tuple $(u_{1},u_{2},\ldots,u_{k})$ where $\{u_{1},u_{2},\ldots,u_{k}\}$ are the elements of the clique and $u_{1}<u_{2}<u_{3},\ldots,u_{k}$ in the $k$-clique extendable ordering. We order the cliques lexicographically by the reverse of its tuple (cliques sharing the last $j<k$ members are consecutive in the list). The lexicographic sort takes $O(km^{k/2})$ time, since there are $O(m^{k/2})$ of them. This list serves as the dynamic programming table, which has one entry for each $k$-clique. In addition we create a block, identified as $(u_{2},u_{3},\ldots,u_{k})$ for each nonempty block of cliques that share $(u_{2},u_{3},\ldots,u_{k})$ as their rightmost $k-1$ elements; they are consecutive in the dynamic programming table. This block is relevant to each $k$-clique of the form $(u_{2},u_{3},\ldots,u_{k},x)$. We precompute a pointer from each clique to its relevant block by lexicographically sorting the cliques by their first $k-1$ elements in reverse order. This order is the order of their blocks in the table, so traversing this list and the table concurrently allows assignment of the pointers from cliques to their relevant blocks $O(km^{k/2})$ time.

The dynamic programming labels each $k$-clique with the size of the maximum clique of $G$ ending with its $k$ elements, and each block with the maximum of the labels of cliques in the block. This can be done in lexicographic order: when the last clique in a block has been labeled, the block is labeled with the maximum of the labels of the cliques in the block, and when clique $(u_{1},u_{2},\ldots,u_{k})$ is reached, its label is one plus the maximum of the labels in its relevant block $(u_{1},u_{2},\ldots,u_{k-1})$, which is already labeled. Traversing the table performing these operations, using the precomputed pointers to blocks, takes $O(m^{k/2})$ time.

The maximum label of any $k$-clique tells the size of a maximum clique in the graph. Let $K=(u_{1},u_{2},\ldots,u_{k})$ be a $k$-clique with maximum label. To reconstruct the maximum clique of the graph, note that the last $k-1$ elements of this clique are $\{u_{2},u_{2},\ldots,u_{k}\}$. Find the remaining elements, as follows: recursively find all but the last $k-1$ elements of the largest clique ending on a $k$-clique in $K$’s relevant block, which is empty if $K$ has no relevant block, and add $u_{1}$ to this result.

Theorem 4.9: For $G$ in the class of dags where $\lfloor\lambda(G)\rfloor+1\leq k$, there is a polynomial $k$-approximation algorithm for the problem of finding a minimum coloring of $G$.

Proof 6.2**.**

Given a nondegenerate dag $G$, find a satisfying assignment of utility values for $(t_{1},t_{2})$ such that $t_{2}/t_{1}=\lambda(G)$.

Let $x$ be the lowest value assigned by the algorithm to any of the vertices, and let $y$ be the highest. Partition the interval $[x,y]$ into buckets of the form $[x,y]\cap[x+it_{1},x+(i+1)t_{1})$ for $i\geq 0$. For each bucket, return the vertices whose $\alpha$ values lie in each bucket as the color classes.

Let $v$ be a vertex such that $\alpha(v)=x$. In an optimum coloring, ${\cal C}$, removal of the color class containing $v$ removes a subset of the set of vertices in the first $k$ buckets since it is an independent set. Removal of the color classes of the returned coloring that correspond to the first $k$ buckets advances the minimum $\alpha$ value among the remaining vertices by $kt_{1}$. Removal of the of the color class in an optimum coloring containing $v$ advances it by at most that much. By induction on the number of vertices, we may assume that the number of remaining color classes of the returned coloring is at most $k$ times the number of color classes in the remainder of ${\cal C}$. Thus, for every color class in an optimum coloring, there are at most $k$ in the coloring returned by the algorithm.

Theorem 4.10: For $G$ in the class of dags where $\lfloor\lambda(G)\rfloor+1=k$, there is a polynomial $k$-approximation algorithm for the problem of finding a minimum clique cover of $G$.

Proof 6.3**.**

Given a nondegenerate dag $G$, find a satisfying assignment of utility values for $(t_{1},t_{2})$ such that $t_{2}/t_{1}=\lambda(G)$.

Let $y$ be a value such that $[y,y+t_{2}]$ contains the $\alpha$ values of a maximum number of vertices. Select $v$ from among the vertices whose $\alpha$ value lie in $[y,y+t_{2}]$. Select $\{v=v_{1},v_{2},\ldots,v_{j}\}$ so that for $i>1$, $v_{i}$ minimizes $\alpha(v_{i})$ over all vertices $x$ such that $\alpha(x)>\alpha(v_{i-1})+t_{2}$. Select $\{v=w_{1},w_{2},\ldots,v_{j^{\prime}}\}$ such that for $i>1$, $w_{i}$ maximizes $\alpha(w_{i})$ over all vertices $x$ such that $\alpha(x)<\alpha(v_{i-1})-t_{2}$. Let $K$ be the union of these two sets. Because the pairwise differences in $\alpha$ values are greater than $t_{2}$, $K$ is a clique. Let this be one of the cliques in the clique cover. Remove it from the set of vertices, and recurse on the remaining vertices to get the remaining cliques of the cover.

To see that this has an approximation ratio of at most $k$, let $X$ be the set of vertices whose $\alpha$ values are in $[y,y+t_{2}]$. Each clique of the clique cover returned by the algorithm removes one vertex from $X$. In a minimum clique cover, each pair of vertices must have $\alpha$ values that differ by at least $t_{1}$. Thus, no clique can contain more than $k$ vertices from $X$. The clique cover returned by the algorithm has at most $k$ times the number of cliques as a minimum clique cover.

Lemma 5.3: In $G_{d}$, the mean weight of a critical walk is less than or equal to the minimum cycle mean.

Proof 6.4**.**

Let $(t_{1},t_{2})$ be assigned arbitrarily. Since we may apply the result separately to each strongly connected component of $G_{d}$, we may assume that $G_{d}$ is strongly connected. Let $G^{\prime}_{d}$ be the result of subtracting $c$ from every edge weight in $G_{d}$. The mean weight of $C$, hence its total weight, is 0 in $G^{\prime}_{d}$. Since they all have the same length $n$, the paths of interest in $G_{d}$ are the same as they are in $G^{\prime}_{d}$.

Out of all paths ending at a vertex on $C$, let $P$ be one of minimum weight in $G^{\prime}_{d}$, let $w_{1}$ be its weight in $G^{\prime}_{d}$, and let $u\in C$ be the last vertex of $P$. Let $W^{\prime}$ be the walk of length $n-|P|$ obtained by walking round and round $C$, starting at $u$, let $v$ be the last vertex of $W^{\prime}$, and let $W$ be the walk of length $n$ obtained by concatenating $P$ and $W^{\prime}$. Let $s$ be the first vertex of $W$.

In $G^{\prime}_{d}$, the weight $w$ of $W$ is equal to the minimum weight of a walk of any length ending at $v$, which is seen as follows. Suppose there is a walk $W^{\prime}$ of weight $w^{\prime}<w$, ending at $v$. Let $w_{2}$ be the weight of the portion of $C$ directed from $u$ to $v$, and let $w_{3}$ be the weight of the portion of $C$ directed from $v$ to $u$. Since $C$ has weight 0, $w=w_{1}+w_{2}>w^{\prime}$. Appending to $W^{\prime}$ the portion of $C$ from $v$ to $u$ gives a walk ending at $u$ of weight $w^{\prime}+w_{3}<w_{1}+w_{2}+w_{3}$, and, since $C$ has weight 0, this is just $w_{1}$. Removing any cycles from this walk, we get a path of weight $w_{1}$, contradicting that $P$ is a path of minimum weight to $u$.

Thus, $W$ is a walk of interest in $G^{\prime}_{d}$, hence in $G_{d}$. In $G^{\prime}_{d}$, since there is a walk of length 0 and weight [math] ending at $v$, so the weight of $W$ in $G^{\prime}_{d}$, hence its mean weight in $G^{\prime}_{d}$ is at most the minimum cycle mean of 0 in in $G^{\prime}_{d}$. Its mean weight in $G_{d}$ is at most the minimum cycle mean of $G_{d}$.

Since the edges of weight $-t_{1}$ are acyclic there is at least one edge of weight $t_{2}$ on $C$. Since $W$ has length $n$ and $C$ is the only cycle on it, $W$ makes at least one complete revolution of $C$, and the weight of $W$ is $H(i,v)$ for some $i>0$. Therefore, $l(i,v)=n$ and $H(i,v)$ is a term of interest, and the mean weight of its walk of interest is the minimum cycle mean.

Theorem 5.2: *In $G_{d}$, the minimum mean weight of a cycle is equal to

$\min_{\{(i,v)|l(i,v)=n\}}\max_{0\leq j<i}(H(i,v)-H(j,v))/(n-l(j,v))$*

The proof requires a lemma:

Lemma: If the minimum cycle mean is zero, then

$\min_{(i,v)|l(i,v)=n}\max_{0\leq j<i}(H(i,v)-H(j,v))/(n-l(j,v))=0$.

Proof 6.5**.**

Suppose $l(i,v)=n$. Because there are no negative cycles, there is a minimum-weight walk ending at $v$ whose length is less than $n$. Let its weight be $\pi(v)$. $H(i,v)\geq\pi(v)$. Also, $\pi(v)=\min_{0\leq k<i}H(k,v)$, so $H(i,v)-\pi(v)=\max_{0\leq k<i}(H(i,v)-H(k,v))\geq 0$, and $\max_{0\leq k<i}(H(i,v)-F(k,v))/(n-l(k,v))\geq 0$.

Equality holds if and only if $H(i,v)=\pi(v)$. We complete the proof by showing that there exists $v$ such that there exists $i$ where $l(i,v)=n$ and $H(i,v)=\pi(v)$. Let $C$ be a cycle of weight zero and let $w$ be a vertex on $C$. Let $P(w)$ be a path of weight $\pi(w)$ ending at $w$. Then $P(w)$, followed by any number of repetitions of $C$, is also a minimum-weight walk to its endpoint. After sufficiently many repetitions of $C$, such an initial part of length $n$ will occur; let its endpoint be $w^{\prime}$. Then $l(i,w^{\prime})=n$ for some $i$, and $H(i,w^{\prime})=\pi(w^{\prime})$. Choosing $v=w^{\prime}$, the proof is complete.

Proof of Theorem 5.2. Reducing the weight of each edge weight by a constant $c$ reduces the minimum cycle mean by $c$, and $H(k,v)$ is reduced by $l(k,v)c$. If $l(i,v)=n$, $(H(i,v)-H(k,v))/(n-l(k,v))$ is reduced by $c$, and $\min_{l(i,v)=n}\max_{0\leq k<i}(H(i,v)-H(k,v))/(n-l(k,v))$ is reduced by $c$. The minimum cycle mean and this expression are affected equally. Choosing $c$ to be the minimum cycle mean and then applying the lemma, we complete the proof.