Algebra.Graph.AdjacencyIntMap.Internal

This module exposes the implementation of adjacency maps. The API is unstable and unsafe, and is exposed only for documentation. You should use the non-internal module Algebra.Graph.AdjacencyIntMap instead.

Adjacency map implementation

newtype AdjacencyIntMap

The AdjacencyIntMap data type represents a graph by a map of vertices to their adjacency sets. We define a Num instance as a convenient notation for working with graphs:

0           == vertex 0
1 + 2       == overlay (vertex 1) (vertex 2)
1 * 2       == connect (vertex 1) (vertex 2)
1 + 2 * 3   == overlay (vertex 1) (connect (vertex 2) (vertex 3))
1 * (2 + 3) == connect (vertex 1) (overlay (vertex 2) (vertex 3))

The Show instance is defined using basic graph construction primitives:

show (empty     :: AdjacencyIntMap Int) == "empty"
show (1         :: AdjacencyIntMap Int) == "vertex 1"
show (1 + 2     :: AdjacencyIntMap Int) == "vertices [1,2]"
show (1 * 2     :: AdjacencyIntMap Int) == "edge 1 2"
show (1 * 2 * 3 :: AdjacencyIntMap Int) == "edges [(1,2),(1,3),(2,3)]"
show (1 * 2 + 3 :: AdjacencyIntMap Int) == "overlay (vertex 3) (edge 1 2)"

The Eq instance satisfies all axioms of algebraic graphs:

• overlay is commutative and associative:

        x + y == y + x
  x + (y + z) == (x + y) + z

• connect is associative and has empty as the identity:

    x * empty == x
    empty * x == x
  x * (y * z) == (x * y) * z

• connect distributes over overlay:

  x * (y + z) == x * y + x * z
  (x + y) * z == x * z + y * z

• connect can be decomposed:

  x * y * z == x * y + x * z + y * z

The following useful theorems can be proved from the above set of axioms.

• overlay has empty as the identity and is idempotent:

    x + empty == x
    empty + x == x
        x + x == x

• Absorption and saturation of connect:

  x * y + x + y == x * y
      x * x * x == x * x

When specifying the time and memory complexity of graph algorithms, n and m will denote the number of vertices and edges in the graph, respectively.

Constructors

AM

Fields

• adjacencyIntMap :: IntMap IntSet

  The adjacency map of the graph: each vertex is associated with a set of its direct successors. Complexity: O(1) time and memory.

  adjacencyIntMap empty      == IntMap.empty
  adjacencyIntMap (vertex x) == IntMap.singleton x IntSet.empty
  adjacencyIntMap (edge 1 1) == IntMap.singleton 1 (IntSet.singleton 1)
  adjacencyIntMap (edge 1 2) == IntMap.fromList [(1,IntSet.singleton 2), (2,IntSet.empty)]
  

Instances

Eq AdjacencyIntMap

Defined in Algebra.Graph.AdjacencyIntMap.Internal

Methods

(==) :: AdjacencyIntMap -> AdjacencyIntMap -> Bool

(/=) :: AdjacencyIntMap -> AdjacencyIntMap -> Bool

Num AdjacencyIntMap

Defined in Algebra.Graph.AdjacencyIntMap.Internal

Methods

(+) :: AdjacencyIntMap -> AdjacencyIntMap -> AdjacencyIntMap

(-) :: AdjacencyIntMap -> AdjacencyIntMap -> AdjacencyIntMap

(*) :: AdjacencyIntMap -> AdjacencyIntMap -> AdjacencyIntMap

negate :: AdjacencyIntMap -> AdjacencyIntMap

abs :: AdjacencyIntMap -> AdjacencyIntMap

signum :: AdjacencyIntMap -> AdjacencyIntMap

fromInteger :: Integer -> AdjacencyIntMap

Show AdjacencyIntMap

Defined in Algebra.Graph.AdjacencyIntMap.Internal

Methods

showsPrec :: Int -> AdjacencyIntMap -> ShowS

show :: AdjacencyIntMap -> String

showList :: [AdjacencyIntMap] -> ShowS

NFData AdjacencyIntMap

Defined in Algebra.Graph.AdjacencyIntMap.Internal

Methods

rnf :: AdjacencyIntMap -> ()

ToGraph AdjacencyIntMap

Defined in Algebra.Graph.ToGraph

Associated Types

type ToVertex AdjacencyIntMap :: *

Methods

toGraph :: AdjacencyIntMap -> Graph (ToVertex AdjacencyIntMap)

foldg :: r -> (ToVertex AdjacencyIntMap -> r) -> (r -> r -> r) -> (r -> r -> r) -> AdjacencyIntMap -> r

isEmpty :: AdjacencyIntMap -> Bool

size :: AdjacencyIntMap -> Int

hasVertex :: ToVertex AdjacencyIntMap -> AdjacencyIntMap -> Bool

hasEdge :: ToVertex AdjacencyIntMap -> ToVertex AdjacencyIntMap -> AdjacencyIntMap -> Bool

vertexCount :: AdjacencyIntMap -> Int

edgeCount :: AdjacencyIntMap -> Int

vertexList :: AdjacencyIntMap -> [ToVertex AdjacencyIntMap]

edgeList :: AdjacencyIntMap -> [(ToVertex AdjacencyIntMap, ToVertex AdjacencyIntMap)]

vertexSet :: AdjacencyIntMap -> Set (ToVertex AdjacencyIntMap)

vertexIntSet :: AdjacencyIntMap -> IntSet

edgeSet :: AdjacencyIntMap -> Set (ToVertex AdjacencyIntMap, ToVertex AdjacencyIntMap)

preSet :: ToVertex AdjacencyIntMap -> AdjacencyIntMap -> Set (ToVertex AdjacencyIntMap)

preIntSet :: Int -> AdjacencyIntMap -> IntSet

postSet :: ToVertex AdjacencyIntMap -> AdjacencyIntMap -> Set (ToVertex AdjacencyIntMap)

postIntSet :: Int -> AdjacencyIntMap -> IntSet

adjacencyList :: AdjacencyIntMap -> [(ToVertex AdjacencyIntMap, [ToVertex AdjacencyIntMap])]

adjacencyMap :: AdjacencyIntMap -> Map (ToVertex AdjacencyIntMap) (Set (ToVertex AdjacencyIntMap))

adjacencyIntMap :: AdjacencyIntMap -> IntMap IntSet

adjacencyMapTranspose :: AdjacencyIntMap -> Map (ToVertex AdjacencyIntMap) (Set (ToVertex AdjacencyIntMap))

adjacencyIntMapTranspose :: AdjacencyIntMap -> IntMap IntSet

dfsForest :: AdjacencyIntMap -> Forest (ToVertex AdjacencyIntMap)

dfsForestFrom :: [ToVertex AdjacencyIntMap] -> AdjacencyIntMap -> Forest (ToVertex AdjacencyIntMap)

dfs :: [ToVertex AdjacencyIntMap] -> AdjacencyIntMap -> [ToVertex AdjacencyIntMap]

reachable :: ToVertex AdjacencyIntMap -> AdjacencyIntMap -> [ToVertex AdjacencyIntMap]

topSort :: AdjacencyIntMap -> Maybe [ToVertex AdjacencyIntMap]

isAcyclic :: AdjacencyIntMap -> Bool

toAdjacencyMap :: AdjacencyIntMap -> AdjacencyMap (ToVertex AdjacencyIntMap)

toAdjacencyMapTranspose :: AdjacencyIntMap -> AdjacencyMap (ToVertex AdjacencyIntMap)

toAdjacencyIntMap :: AdjacencyIntMap -> AdjacencyIntMap

toAdjacencyIntMapTranspose :: AdjacencyIntMap -> AdjacencyIntMap

isDfsForestOf :: Forest (ToVertex AdjacencyIntMap) -> AdjacencyIntMap -> Bool

isTopSortOf :: [ToVertex AdjacencyIntMap] -> AdjacencyIntMap -> Bool

Graph AdjacencyIntMap

Defined in Algebra.Graph.Class

Associated Types

type Vertex AdjacencyIntMap :: *

Methods

empty :: AdjacencyIntMap

vertex :: Vertex AdjacencyIntMap -> AdjacencyIntMap

overlay :: AdjacencyIntMap -> AdjacencyIntMap -> AdjacencyIntMap

connect :: AdjacencyIntMap -> AdjacencyIntMap -> AdjacencyIntMap

type ToVertex AdjacencyIntMap

Defined in Algebra.Graph.ToGraph

type ToVertex AdjacencyIntMap = Int

type Vertex AdjacencyIntMap

Defined in Algebra.Graph.Class

type Vertex AdjacencyIntMap = Int

empty :: AdjacencyIntMap

Construct the empty graph. Complexity: O(1) time and memory.

isEmpty     empty == True
hasVertex x empty == False
vertexCount empty == 0
edgeCount   empty == 0

vertex :: Int -> AdjacencyIntMap

Construct the graph comprising a single isolated vertex. Complexity: O(1) time and memory.

isEmpty     (vertex x) == False
hasVertex x (vertex x) == True
vertexCount (vertex x) == 1
edgeCount   (vertex x) == 0

overlay :: AdjacencyIntMap -> AdjacencyIntMap -> AdjacencyIntMap

Overlay two graphs. This is a commutative, associative and idempotent operation with the identity empty. Complexity: O((n + m) * log(n)) time and O(n + m) memory.

isEmpty     (overlay x y) == isEmpty   x   && isEmpty   y
hasVertex z (overlay x y) == hasVertex z x || hasVertex z y
vertexCount (overlay x y) >= vertexCount x
vertexCount (overlay x y) <= vertexCount x + vertexCount y
edgeCount   (overlay x y) >= edgeCount x
edgeCount   (overlay x y) <= edgeCount x   + edgeCount y
vertexCount (overlay 1 2) == 2
edgeCount   (overlay 1 2) == 0

connect :: AdjacencyIntMap -> AdjacencyIntMap -> AdjacencyIntMap

Connect two graphs. This is an associative operation with the identity empty, which distributes over overlay and obeys the decomposition axiom. Complexity: O((n + m) * log(n)) time and O(n + m) memory. Note that the number of edges in the resulting graph is quadratic with respect to the number of vertices of the arguments: m = O(m1 + m2 + n1 * n2).

isEmpty     (connect x y) == isEmpty   x   && isEmpty   y
hasVertex z (connect x y) == hasVertex z x || hasVertex z y
vertexCount (connect x y) >= vertexCount x
vertexCount (connect x y) <= vertexCount x + vertexCount y
edgeCount   (connect x y) >= edgeCount x
edgeCount   (connect x y) >= edgeCount y
edgeCount   (connect x y) >= vertexCount x * vertexCount y
edgeCount   (connect x y) <= vertexCount x * vertexCount y + edgeCount x + edgeCount y
vertexCount (connect 1 2) == 2
edgeCount   (connect 1 2) == 1

fromAdjacencyIntSets :: [(Int, IntSet)] -> AdjacencyIntMap

Construct a graph from a list of adjacency sets. Complexity: O((n + m) * log(n)) time and O(n + m) memory.

fromAdjacencyIntSets []                                           == empty
fromAdjacencyIntSets [(x, IntSet.empty)]                          == vertex x
fromAdjacencyIntSets [(x, IntSet.singleton y)]                    == edge x y
fromAdjacencyIntSets . map (fmap IntSet.fromList) . adjacencyList == id
overlay (fromAdjacencyIntSets xs) (fromAdjacencyIntSets ys)       == fromAdjacencyIntSets (xs ++ ys)

consistent :: AdjacencyIntMap -> Bool

Check if the internal graph representation is consistent, i.e. that all edges refer to existing vertices. It should be impossible to create an inconsistent adjacency map, and we use this function in testing. Note: this function is for internal use only.

consistent empty         == True
consistent (vertex x)    == True
consistent (overlay x y) == True
consistent (connect x y) == True
consistent (edge x y)    == True
consistent (edges xs)    == True
consistent (stars xs)    == True