Modulealgebraic-graphs-0.8Haskell2010

Algebra.Graph.ToGraph

Alga is a library for algebraic construction and manipulation of graphs in Haskell. See this paper for the motivation behind the library, the underlying theory, and implementation details.

This module defines the type class ToGraph for capturing data types that can be converted to algebraic graphs. To make an instance of this class you need to define just a single method (toGraph or foldg), which gives you access to many other useful methods for free (although note that the default implementations may be suboptimal performance-wise).

This type class is similar to the standard type class Foldable defined for lists. Furthermore, one can define Foldable methods foldMap and toList using ToGraph.foldg:

foldMap f = foldg mempty f    (<>) (<>)
toList    = foldg []     pure (++) (++)

However, the resulting Foldable instance is problematic. For example, folding equivalent algebraic graphs 1 and 1 + 1 leads to different results:

toList (1    ) == [1]
toList (1 + 1) == [1, 1]

To avoid such cases, we do not provide Foldable instances for algebraic graph datatypes. Furthermore, we require that the four arguments passed to foldg satisfy the laws of the algebra of graphs. The above definitions of foldMap and toList violate this requirement, for example [1] ++ [1] /= [1], and are therefore disallowed.

1 class
4 values

Packagealgebraic-graphs-0.8
Exports5
LanguageHaskell2010
LicenceMIT
SourceToGraph.hs

Type class

1 declaration

classclass ToGraph t where

The ToGraph type class captures data types that can be converted to algebraic graphs. Instances of this type class should satisfy the laws specified by the default method definitions.

Associated types

type family ToVertex t
The type of vertices of the resulting graph.

Methods

toGraph :: t -> Graph (ToVertex t)
Convert a value to the corresponding algebraic graph, see Algebra.Graph.
```
toGraph == foldg Empty Vertex Overlay Connect
```
foldg :: r -> (ToVertex t -> r) -> (r -> r -> r) -> (r -> r -> r) -> t -> r
The method foldg is used for generalised graph folding. It collapses a given value by applying the provided graph construction primitives. The order of arguments is: empty, vertex, overlay and connect, and it is assumed that the arguments satisfy the axioms of the graph algebra.
```
foldg == Algebra.Graph.foldg . toGraph
```

isEmpty :: t -> Bool

Check if a graph is empty.

isEmpty == foldg True (const False) (&&) (&&)

hasVertex :: Eq (ToVertex t) => ToVertex t -> t -> Bool
Check if a graph contains a given vertex.
```
hasVertex x == foldg False (==x) (||) (||)
```
hasEdge :: Eq (ToVertex t) => ToVertex t -> ToVertex t -> t -> Bool
Check if a graph contains a given edge.
```
hasEdge x y == Algebra.Graph.hasEdge x y . toGraph
```
vertexCount :: Ord (ToVertex t) => t -> Int
The number of vertices in a graph.
```
vertexCount == Set.size . vertexSet
```
edgeCount :: Ord (ToVertex t) => t -> Int
The number of edges in a graph.
```
edgeCount == Set.size . edgeSet
```
vertexList :: Ord (ToVertex t) => t -> [ToVertex t]
The sorted list of vertices of a given graph.
```
vertexList == Set.toAscList . vertexSet
```
edgeList :: Ord (ToVertex t) => t -> [(ToVertex t, ToVertex t)]
The sorted list of edges of a graph.
```
edgeList == Set.toAscList . edgeSet
```
vertexSet :: Ord (ToVertex t) => t -> Set (ToVertex t)
The set of vertices of a graph.
```
vertexSet == foldg Set.empty Set.singleton Set.union Set.union
```
vertexIntSet :: ToVertex t ~ Int => t -> IntSet
The set of vertices of a graph. Like vertexSet but specialised for graphs with vertices of type Int.
```
vertexIntSet == foldg IntSet.empty IntSet.singleton IntSet.union IntSet.union
```
edgeSet :: Ord (ToVertex t) => t -> Set (ToVertex t, ToVertex t)
The set of edges of a graph.
```
edgeSet == Algebra.Graph.AdjacencyMap.edgeSet . toAdjacencyMap
```
preSet :: Ord (ToVertex t) => ToVertex t -> t -> Set (ToVertex t)
The preset of a vertex is the set of its direct predecessors.
```
preSet x == Algebra.Graph.AdjacencyMap.preSet x . toAdjacencyMap
```
preIntSet :: ToVertex t ~ Int => Int -> t -> IntSet
The preset (here preIntSet) of a vertex is the set of its direct predecessors. Like preSet but specialised for graphs with vertices of type Int.
```
preIntSet x == Algebra.Graph.AdjacencyIntMap.preIntSet x . toAdjacencyIntMap
```
postSet :: Ord (ToVertex t) => ToVertex t -> t -> Set (ToVertex t)
The postset of a vertex is the set of its direct successors.
```
postSet x == Algebra.Graph.AdjacencyMap.postSet x . toAdjacencyMap
```
postIntSet :: ToVertex t ~ Int => Int -> t -> IntSet
The postset (here postIntSet) of a vertex is the set of its direct successors. Like postSet but specialised for graphs with vertices of type Int.
```
postIntSet x == Algebra.Graph.AdjacencyIntMap.postIntSet x . toAdjacencyIntMap
```
adjacencyList :: Ord (ToVertex t) => t -> [(ToVertex t, [ToVertex t])]
The sorted adjacency list of a graph.
```
adjacencyList == Algebra.Graph.AdjacencyMap.adjacencyList . toAdjacencyMap
```
dfsForest :: Ord (ToVertex t) => t -> Forest (ToVertex t)
Compute the depth-first search forest of a graph that corresponds to searching from each of the graph vertices in the Ord a order.
```
dfsForest == Algebra.Graph.AdjacencyMap.dfsForest . toAdjacencyMap
```
dfsForestFrom :: Ord (ToVertex t) => t -> [ToVertex t] -> Forest (ToVertex t)
Compute the depth-first search forest of a graph, searching from each of the given vertices in order. Note that the resulting forest does not necessarily span the whole graph, as some vertices may be unreachable.
```
dfsForestFrom == Algebra.Graph.AdjacencyMap.dfsForestFrom . toAdjacencyMap
```
dfs :: Ord (ToVertex t) => t -> [ToVertex t] -> [ToVertex t]
Compute the list of vertices visited by the depth-first search in a graph, when searching from each of the given vertices in order.
```
dfs == Algebra.Graph.AdjacencyMap.dfs . toAdjacencyMap
```
reachable :: Ord (ToVertex t) => t -> ToVertex t -> [ToVertex t]
Compute the list of vertices that are reachable from a given source vertex in a graph. The vertices in the resulting list appear in the depth-first order.
```
reachable == Algebra.Graph.AdjacencyMap.reachable . toAdjacencyMap
```
topSort :: Ord (ToVertex t) => t -> Either (Cycle (ToVertex t)) [ToVertex t]
Compute the topological sort of a graph or a AM.Cycle if the graph is cyclic.
```
topSort == Algebra.Graph.AdjacencyMap.topSort . toAdjacencyMap
```

isAcyclic :: Ord (ToVertex t) => t -> Bool

Check if a given graph is acyclic.

isAcyclic == Algebra.Graph.AdjacencyMap.isAcyclic . toAdjacencyMap

toAdjacencyMap :: Ord (ToVertex t) => t -> AdjacencyMap (ToVertex t)
Convert a value to the corresponding AdjacencyMap.
```
toAdjacencyMap == foldg empty vertex overlay connect
```
toAdjacencyMapTranspose :: Ord (ToVertex t) => t -> AdjacencyMap (ToVertex t)
Convert a value to the corresponding AdjacencyMap and transpose the result.
```
toAdjacencyMapTranspose == foldg empty vertex overlay (flip connect)
```
toAdjacencyIntMap :: ToVertex t ~ Int => t -> AdjacencyIntMap
Convert a value to the corresponding AdjacencyIntMap.
```
toAdjacencyIntMap == foldg empty vertex overlay connect
```
toAdjacencyIntMapTranspose :: ToVertex t ~ Int => t -> AdjacencyIntMap
Convert a value to the corresponding AdjacencyIntMap and transpose the result.
```
toAdjacencyIntMapTranspose == foldg empty vertex overlay (flip connect)
```
isDfsForestOf :: Ord (ToVertex t) => Forest (ToVertex t) -> t -> Bool
Check if a given forest is a valid depth-first search forest of a graph.
```
isDfsForestOf f == Algebra.Graph.AdjacencyMap.isDfsForestOf f . toAdjacencyMap
```
isTopSortOf :: Ord (ToVertex t) => [ToVertex t] -> t -> Bool
Check if a given list of vertices is a valid topological sort of a graph.
```
isTopSortOf vs == Algebra.Graph.AdjacencyMap.isTopSortOf vs . toAdjacencyMap
```

Instances9ToGraph, …

ToGraph AdjacencyIntMapDefined in algebraic-graphs-0.8 · Algebra.Graph.ToGraph
See Algebra.Graph.AdjacencyIntMap.
ToGraph (Graph a)Defined in algebraic-graphs-0.8 · Algebra.Graph.NonEmpty
Ord a => ToGraph (Graph a)Defined in algebraic-graphs-0.8 · Algebra.Graph.ToGraph
See Algebra.Graph.
Ord a => ToGraph (AdjacencyMap a)Defined in algebraic-graphs-0.8 · Algebra.Graph.ToGraph
See Algebra.Graph.AdjacencyMap.
Ord a => ToGraph (AdjacencyMap a)Defined in algebraic-graphs-0.8 · Algebra.Graph.ToGraph
See Algebra.Graph.NonEmpty.AdjacencyMap.
Ord a => ToGraph (Relation a)Defined in algebraic-graphs-0.8 · Algebra.Graph.Relation
Ord a => ToGraph (Relation a)Defined in algebraic-graphs-0.8 · Algebra.Graph.Relation.Symmetric
Defined via fromSymmetric and the ToGraph instance of Relation.
(Eq e, Monoid e, Ord a) => ToGraph (Graph e a)Defined in algebraic-graphs-0.8 · Algebra.Graph.Labelled
(Eq e, Monoid e, Ord a) => ToGraph (AdjacencyMap e a)Defined in algebraic-graphs-0.8 · Algebra.Graph.Labelled.AdjacencyMap
Defined via skeleton and the ToGraph instance of AdjacencyMap.

Derived functions

4 declarations

valueadjacencyMap

:: (ToGraph t, Ord (ToVertex t))
=> t
-> Map (ToVertex t) (Set (ToVertex t))

The adjacency map of a graph: each vertex is associated with a set of its direct successors.

adjacencyMap == Algebra.Graph.AdjacencyMap.adjacencyMap . toAdjacencyMap

valueadjacencyIntMap :: (ToGraph t, ToVertex t ~ Int) => t -> IntMap IntSet

The adjacency map of a graph: each vertex is associated with a set of its direct successors. Like adjacencyMap but specialised for graphs with vertices of type Int.

adjacencyIntMap == Algebra.Graph.AdjacencyIntMap.adjacencyIntMap . toAdjacencyIntMap

valueadjacencyMapTranspose

:: (ToGraph t, Ord (ToVertex t))
=> t
-> Map (ToVertex t) (Set (ToVertex t))

The transposed adjacency map of a graph: each vertex is associated with a set of its direct predecessors.

adjacencyMapTranspose == Algebra.Graph.AdjacencyMap.adjacencyMap . toAdjacencyMapTranspose

valueadjacencyIntMapTranspose

:: (ToGraph t, ToVertex t ~ Int)
=> t
-> IntMap IntSet

The transposed adjacency map of a graph: each vertex is associated with a set of its direct predecessors. Like adjacencyMapTranspose but specialised for graphs with vertices of type Int.

adjacencyIntMapTranspose == Algebra.Graph.AdjacencyIntMap.adjacencyIntMap . toAdjacencyIntMapTranspose