Real Edge Weights Research Articles

A Complexity Trichotomy for k-Regular Asymmetric Spin Systems Using Number Theory

Suppose $$\varphi$$ and $$\psi$$ are two angles satisfying $$\tan(\varphi) = 2 \tan(\psi) > 0$$ . We prove that under this condition $$\varphi$$ and $$\psi$$ cannot be both rational multiples of π. We use this number theoretic result to prove a classification of the computational complexity of spin systems on k-regular graphs with general (not necessarily symmetric) real valued edge weights. We establish explicit criteria, according to which the partition functions of all such systems are classified into three classes: (1) Polynomial time computable, (2) #P-hard in general but polynomial time computable on planar graphs, and (3) #P-hard on planar graphs. In particular, problems in (2) are precisely those that can be transformed by a holographic reduction to a form solvable by the Fisher-Kasteleyn-Temperley algorithm for counting perfect matchings in a planar graph.

Cospectrality preserving graph modifications and eigenvector properties via walk equivalence of vertices

Originating from spectral graph theory, cospectrality is a powerful generalization of exchange symmetry and can be applied to all real-valued symmetric matrices. Two vertices of an undirected graph with real edge weights are cospectral if and only if the underlying weighted adjacency matrix M fulfills [Mk]u,u=[Mk]v,v for all non-negative integer k, and as a result any eigenvector ϕ of M has (or, in the presence of degeneracies, can be chosen to have) definite parity on u and v. We here show that the powers of a matrix with cospectral vertices induce further local relations on its eigenvectors, and also can be used to design cospectrality preserving modifications. To this end, we introduce the concept of walk equivalence of cospectral vertices with respect to walk multiplets which are special vertex subsets of a graph. Walk multiplets allow for systematic and flexible modifications of a graph with a given cospectral pair while preserving this cospectrality. The set of modifications includes the addition and removal of both vertices and edges, such that the underlying topology of the graph can be altered. In particular, we prove that any new vertex connected to a walk multiplet by suitable connection weights becomes a so-called unrestricted substitution point (USP), meaning that any arbitrary graph may be connected to it without breaking cospectrality. Also, suitable interconnections between walk multiplets within a graph are shown to preserve the associated cospectrality. Importantly, we demonstrate that the walk equivalence of cospectral vertices u,v imposes a local structure on every eigenvector ϕ obeying ϕu=±ϕv≠0 (in the case of degeneracies, a specific choice of the eigenvector basis is needed). Our work paves the way for flexibly exploiting hidden structural symmetries in the design of generic complex network-like systems.

Positive graphs

We call a graph positive if it has a nonnegative homomorphism number into any target graph with real edge weights. The Positive Graphs Conjecture offers a structural characterization: these are exactly the graphs that can be obtained by gluing together two copies of the same graph along an independent set of vertices. In this talk I will discuss our recent results on the Positive Graphs Conjecture.

Dynamic Maintenance of a Shortest-Path Tree on Homogeneous Batches of Updates

A dynamic graph algorithm is called batch if it is able to update efficiently the solution of a given graph problem after multiple updates at a time (i.e., a batch) take place on the input graph. In this article, we study batch algorithms for maintaining a single-source shortest-path tree in graphs with positive real edge weights. In particular, we focus our attention on homogeneous batches, that is, either incremental (containing only edge insertion and weight decrease operations) or decremental (containing only edge deletion and weight increase operations) batches, which model realistic dynamic scenarios like transient vertex failures in communication networks and traffic congestion/decongestion phenomena in road networks. We propose two new algorithms to process either incremental or decremental batches, respectively, and a combination of these two algorithms that is able to process arbitrary sequences of incremental and decremental batches. All these algorithms are update sensitive ; namely, they are efficient with respect to the number of vertices in the shortest-path tree that change their parents and/or their distances from the source as a consequence of a batch. This makes unfeasible an effective comparison on a theoretical basis of our new algorithms with the solutions known in the literature, which in turn are analyzed with respect to others and different parameters. For this reason, in order to evaluate the quality of our approach, we provide also an extensive experimental study including our new algorithms and the most efficient previous batch algorithms. Our experimental results complement previous studies and show that the various solutions can be consistently ranked on the basis of the type of homogeneous batch and of the underlying network. As a result, our work can be helpful in selecting a proper solution depending on the specific application scenario.

Complexity of the cluster deletion problem on subclasses of chordal graphs

We consider the following vertex-partition problem on graphs, known as the CLUSTER DELETION (CD) problem: given a graph with real nonnegative edge weights, partition the vertices into clusters (in this case, cliques) to minimize the total weight of edges outside the clusters. The decision version of this optimization problem is known to be NP-complete even for unweighted graphs and has been studied extensively. We investigate the complexity of the decision CD problem for the family of chordal graphs, showing that it is NP-complete for weighted split graphs, weighted interval graphs and unweighted chordal graphs. We also prove that the problem is NP-complete for weighted cographs. Some polynomial-time solvable cases of the optimization problem are also identified, in particular CD for unweighted split graphs, unweighted proper interval graphs and weighted block graphs.

Prograph Based Analysis of Single Source Shortest Path Problem with Few Distinct Positive Lengths

In this paper we propose an experimental study model S3P2 of a fast fully dynamic programming algorithm design technique in finite directed graphs with few distinct nonnegative real edge weights. The Bellman-Ford’s approach for shortest path problems has come out in various implementations. In this paper the approach once again is re-investigated with adjacency matrix selection in associate least running time. The model tests proposed algorithm against arbitrarily but positive valued weighted digraphs introducing notion of Prograph that speeds up finding the shortest path over previous implementations. Our experiments have established abstract results with the intention that the proposed algorithm can consistently dominate other existing algorithms for Single Source Shortest Path Problems. A comparison study is also shown among Dijkstra’s algorithm, Bellman-Ford algorithm, and our algorithm.

A shortest cycle for each vertex of a graph

We present an algorithm that finds, for each vertex of an undirected graph, a shortest cycle containing it. While for directed graphs this problem reduces to the All-Pairs Shortest Paths problem, this is not known to be the case for undirected graphs. We present a truly sub-cubic randomized algorithm for the undirected case. Given an undirected graph with n vertices and integer weights in 1 , … , M , it runs in O ˜ ( M n ( ω + 3 ) / 2 ) time where ω < 2.376 is the exponent of matrix multiplication. As a by-product, our algorithm can be used to determine which vertices lie on cycles of length at most t in O ˜ ( M n ω t ) time. For the case of bounded real edge weights, a variant of our algorithm solves the problem up to an additive error of ϵ in O ˜ ( n ( ω + 6 ) / 3 ) time.

A Simple and Fast Min-Cut Algorithm

We present an algorithm which calculates a minimum cut and its weight in an undirected graph with nonnegative real edge weights, n vertices and m edges, in time O(max(log n, min(m/n,δG/e)) n2), where e is the minimal edge weight, and δG is the minimal weighted degree. For integer edge weights this time is further improved to O(δG n2) and O(λG n2). In both cases these bounds are improvements of the previously known best bounds of deterministic algorithms. These were O(nm + n2 log n) for real edge weights and O(nM + n2) and O(M + λG n2) for integer weights, where M is the sum of all edge weights.

Correlation clustering in general weighted graphs

We consider the following general correlation-clustering problem [N. Bansal, A. Blum, S. Chawla, Correlation clustering, in: Proc. 43rd Annu. IEEE Symp. on Foundations of Computer Science, Vancouver, Canada, November 2002, pp. 238–250]: given a graph with real nonnegative edge weights and a 〈 + 〉 / 〈 - 〉 edge labelling, partition the vertices into clusters to minimize the total weight of cut 〈 + 〉 edges and uncut 〈 - 〉 edges. Thus, 〈 + 〉 edges with large weights (representing strong correlations between endpoints) encourage those endpoints to belong to a common cluster while 〈 - 〉 edges with large weights encourage the endpoints to belong to different clusters. In contrast to most clustering problems, correlation clustering specifies neither the desired number of clusters nor a distance threshold for clustering; both of these parameters are effectively chosen to be the best possible by the problem definition. Correlation clustering was introduced by Bansal et al. [Correlation clustering, in: Proc. 43rd Annu. IEEE Symp. on Foundations of Computer Science, Vancouver, Canada, November 2002, pp. 238–250], motivated by both document clustering and agnostic learning. They proved NP-hardness and gave constant-factor approximation algorithms for the special case in which the graph is complete (full information) and every edge has the same weight. We give an O ( log n ) -approximation algorithm for the general case based on a linear-programming rounding and the “region-growing’’ technique. We also prove that this linear program has a gap of Ω ( log n ) , and therefore our approximation is tight under this approach. We also give an O ( r 3 ) -approximation algorithm for K r , r -minor-free graphs. On the other hand, we show that the problem is equivalent to minimum multicut, and therefore APX-hard and difficult to approximate better than Θ ( log n ) .

Two equivalent measures on weighted hypergraphs

Let H = ( N , E , w ) be a hypergraph with a node set N = { 0 , 1 , … , n - 1 } , a hyperedge set E ⊆ 2 N , and real edge-weights w ( e ) for e ∈ E . Given a convex n-gon P in the plane with vertices x 0 , x 1 , … , x n - 1 which are arranged in this order clockwisely, let each node i ∈ N correspond to the vertex x i and define the area A P ( H ) of H on P by the sum of the weighted areas of convex hulls for all hyperedges in H. For 0 ⩽ i < j < k ⩽ n - 1 , a convex three-cut C ( i , j , k ) of N is { { i , … , j - 1 } , { j , … , k - 1 } , { k , … , n - 1 , 0 , … , i - 1 } } and its size c H ( i , j , k ) in H is defined as the sum of weights of edges e ∈ E such that e contains at least one node from each of { i , … , j - 1 } , { j , … , k - 1 } and { k , … , n - 1 , 0 , … , i - 1 } . We show that the following two conditions are equivalent: • A P ( H ) ⩽ A P ( H ′ ) for all convex n-gons P. • c H ( i , j , k ) ⩽ c H ′ ( i , j , k ) for all convex three-cuts C ( i , j , k ) . From this property, a polynomial time algorithm for determining whether or not given weighted hypergraphs H and H ′ satisfy “ A P ( H ) ⩽ A P ( H ′ ) for all convex n-gons P” is immediately obtained.

Fully dynamic all pairs shortest paths with real edge weights

We present the first fully dynamic algorithm for maintaining all pairs shortest paths in directed graphs with real-valued edge weights. Given a dynamic directed graph G such that each edge can assume at most S different real values, we show how to support updates in O ( n 2.5 S log 3 n ) amortized time and queries in optimal worst-case time. This algorithm is deterministic: no previous fully dynamic algorithm was known before for this problem. In the special case where edge weights can only be increased, we give a randomized algorithm with one-sided error that supports updates faster in O ( S ⋅ n log 3 n ) amortized time. We also show how to obtain query/update trade-offs for this problem, by introducing two new families of randomized algorithms. Algorithms in the first family achieve an update bound of O ˜ ( S ⋅ k ⋅ n 2 ) 1 and a query bound of O ˜ ( n / k ) , and improve over the previous best known update bounds for k in the range ( n / S ) 1 / 3 ⩽ k < ( n / S ) 1 / 2 . Algorithms in the second family achieve an update bound of O ˜ ( S ⋅ k ⋅ n 2 ) and a query bound of O ˜ ( n 2 / k 2 ) , and are competitive with the previous best known update bounds (first family included) for k in the range ( n / S ) 1 / 6 ⩽ k < ( n / S ) 1 / 3 .

A fully dynamic algorithm for distributed shortest paths

We propose a fully dynamic distributed algorithm for the all-pairs shortest paths problem on general networks with positive real edge weights. If Δ σ is the number of pairs of nodes changing the distance after a single edge modification σ ( insert, delete, weight decrease, or weight increase) then the message complexity of the proposed algorithm is O( nΔ σ ) in the worst case, where n is the number of nodes of the network. If Δ σ = o(n 2) , this is better than recomputing everything from scratch after each edge modification. Up to now only a result of Ramarao and Venkatesan was known, stating that the problem of updating shortest paths in a dynamic distributed environment is as hard as that of computing shortest paths.

A Simple Parallel Algorithm for the Single-Source Shortest Path Problem on Planar Digraphs

We present a simple parallel algorithm for the single-source shortest path problem in planar digraphs with nonnegative real edge weights. The algorithm runs on the EREW PRAM model of parallel computation in O((n2ε+n1−ε)logn) time, performing O(n1+εlogn) work for any 0<ε<1/2. The strength of the algorithm is its simplicity, making it easy to implement and presumable quite efficient in practice. The algorithm improves upon the work of all previous parallel algorithms. Our algorithm is based on a region decomposition of the input graph and uses a well-known parallel implementation of Dijkstra's algorithm. The logarithmic factor in both the work and the time can be eliminated by plugging in a less practical, sequential planar shortest path algorithm together with an improved parallel implementation of Dijkstra's algorithm.

Shortest Paths in Digraphs of Small Treewidth. Part I: Sequential Algorithms

We consider the problem of preprocessing an n -vertex digraph with real edge weights so that subsequent queries for the shortest path or distance between any two vertices can be efficiently answered. We give algorithms that depend on the treewidth of the input graph. When the treewidth is a constant, our algorithms can answer distance queries in O(α(n)) time after O(n) preprocessing. This improves upon previously known results for the same problem. We also give a dynamic algorithm which, after a change in an edge weight, updates the data structure in time O(n β ) , for any constant 0 < β < 1 . Furthermore, an algorithm of independent interest is given: computing a shortest path tree, or finding a negative cycle in linear time.

Fully Dynamic Algorithms for Maintaining Shortest Paths Trees

We propose fully dynamic algorithms for maintaining the distances and the shortest paths from a single source in either a directed or an undirected graph with positive real edge weights, handling insertions, deletions, and weight updates of edges. The algorithms require linear space and optimal query time. The cost of the update operations depends on the class of the considered graph and on the number of the output updates, i.e., on the number of vertices that, due to an edge modification, either change the distance from the source or change the parent in the shortest paths tree. We first show that, if we deal only with updates on the weights of edges, then the update procedures require O(logn) worst case time per output update for several classes of graphs, as in the case of graphs with bounded genus, bounded arboricity, bounded degree, bounded treewidth, and bounded pagenumber. For general graphs with n vertices and m edges the algorithms require O(mlogn) worst case time per output update. We also show that, if insertions and deletions of edges are allowed, then similar amortized bounds hold.

Semidynamic Algorithms for Maintaining Single-Source Shortest Path Trees

We consider the problem of updating a single-source shortest path in either a directed or an undirected graph, with positive real edge weights. Our algorithms for the incremental problem (handling edge insertions and cost decrements) work for any graph; they have optimal space requirements and query time, but their performances depend on the class of the considered graph. The cost of updates is computed in terms of amortized complexity and depends on the size of the output modifications. In the case of graphs with bounded genus (including planar graphs), graphs with bounded arboricity (including bounded degree graphs), and graphs with bounded treewidth, the incremental algorithms require O(log n) amortized time per vertex update, where a vertex is considered updated if it reduces its distance from the source. For general graphs with n vertices and m edges our incremental solution requires O(\(\)log n) amortized time per vertex update. We also consider the decremental problem for planar graphs, providing algorithms and data structures with analogous performances. The algorithms, based on Dijkstra's technique [6], require simple data structures that are really suitable for a practical and straightforward implementation.

Experimental analysis of dynamic algorithms for the single source shortest paths problem

In this paper we propose the first experimental study of the fully dynamic single-source shortest-paths problem on directed graphs with positive real edge weights. In particular, we perform an experimental analysis of three different algorithms: Dijkstra's algorithm, and the two output bounded algorithms proposed by Ramalingam and Reps in [30] and by Frigioni, Marchetti-Spaccamela and Nanni in [18], respectively. The main goal of this paper is to provide a first experimental evidence for: (&lt;i&gt;a&lt;/i&gt;) the effectiveness of dynamic algorithms for shortest paths with respect to a traditional static approach to this problem; (&lt;i&gt;b&lt;/i&gt;) the validity of the theoretical model of output boundedness to analyze dynamic graph algorithms. Beside random generated graphs, useful to capture the "asymptotic" behavior of the algorithms, we also developed experiments by considering a widely used graph from the real world, i.e., the Internet graph.

Shortest paths in digraphs of small treewidth. Part II: Optimal parallel algorithms

We consider the problem of preprocessing an n-vertex digraph with real edge weights so that subsequent queries for the shortest path or distance between any two vertices can be efficiently answered. We give parallel algorithms for the EREW PRAM model of computation that depend on the treewidth of the input graph. When the treewidth is a constant, our algorithms can answer distance queries in O( α( n)) time using a single processor, after a preprocessing of O( log 2 n) time and O( n) work, where α( n) is the inverse of Ackermann's function. The class of constant treewidth graphs contains outerplanar graphs and series-parallel graphs, among others. To the best of our knowledge, these are the first parallel algorithms which achieve these bounds for any class of graphs except trees. We also give a dynamic algorithm which, after a change in an edge weight, updates our data structures in O( log n) time using O( n β ) work, for any constant 0 < β < 1. Moreover, we give an algorithm of independent interest: computing a shortest path tree, or finding a negative cycle in O( log 2 n) time using O( n) work.

Symmetric Matrices Representable by Weighted Trees over a Cancellative Abelian Monoid

The classical result that characterizes metrics induced by paths in a labeled tree having positive real edge weights is generalized to allow the edge weights to take values in any cancellative abelian monoid satisfying the additional requirement that $x + x = y + y$ implies $x = y$. This includes the case of arbitrary real-valued edge weights, which applies to distance-hereditary graphs, thus yielding (unique) weighted tree representations for the latter.