Algebra.Graph.AdjacencyMap.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.AdjacencyMap instead.

Adjacency map implementation

newtype AdjacencyMap a

The AdjacencyMap 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))

Note: the Num instance does not satisfy several "customary laws" of Num, which dictate that fromInteger 0 and fromInteger 1 should act as additive and multiplicative identities, and negate as additive inverse. Nevertheless, overloading fromInteger, + and * is very convenient when working with algebraic graphs; we hope that in future Haskell's Prelude will provide a more fine-grained class hierarchy for algebraic structures, which we would be able to utilise without violating any laws.

The Show instance is defined using basic graph construction primitives:

show (empty     :: AdjacencyMap Int) == "empty"
show (1         :: AdjacencyMap Int) == "vertex 1"
show (1 + 2     :: AdjacencyMap Int) == "vertices [1,2]"
show (1 * 2     :: AdjacencyMap Int) == "edge 1 2"
show (1 * 2 * 3 :: AdjacencyMap Int) == "edges [(1,2),(1,3),(2,3)]"
show (1 * 2 + 3 :: AdjacencyMap 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.

The total order on graphs is defined using size-lexicographic comparison:

• Compare the number of vertices. In case of a tie, continue.
• Compare the sets of vertices. In case of a tie, continue.
• Compare the number of edges. In case of a tie, continue.
• Compare the sets of edges.

Here are a few examples:

vertex 1 < vertex 2
vertex 3 < edge 1 2
vertex 1 < edge 1 1
edge 1 1 < edge 1 2
edge 1 2 < edge 1 1 + edge 2 2
edge 1 2 < edge 1 3

Note that the resulting order refines the isSubgraphOf relation and is compatible with overlay and connect operations:

isSubgraphOf x y ==> x <= y

empty <= x
x     <= x + y
x + y <= x * y

Constructors

AM

Fields

• adjacencyMap :: Map a (Set a)

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

  adjacencyMap empty      == Map.empty
  adjacencyMap (vertex x) == Map.singleton x Set.empty
  adjacencyMap (edge 1 1) == Map.singleton 1 (Set.singleton 1)
  adjacencyMap (edge 1 2) == Map.fromList [(1,Set.singleton 2), (2,Set.empty)]
  

Instances

Eq a => Eq (AdjacencyMap a)

Defined in Algebra.Graph.AdjacencyMap.Internal

Methods

(==) :: AdjacencyMap a -> AdjacencyMap a -> Bool

(/=) :: AdjacencyMap a -> AdjacencyMap a -> Bool

(Ord a, Num a) => Num (AdjacencyMap a)

Note: this does not satisfy the usual ring laws; see AdjacencyMap for more details.

Defined in Algebra.Graph.AdjacencyMap.Internal

Methods

(+) :: AdjacencyMap a -> AdjacencyMap a -> AdjacencyMap a

(-) :: AdjacencyMap a -> AdjacencyMap a -> AdjacencyMap a

(*) :: AdjacencyMap a -> AdjacencyMap a -> AdjacencyMap a

negate :: AdjacencyMap a -> AdjacencyMap a

abs :: AdjacencyMap a -> AdjacencyMap a

signum :: AdjacencyMap a -> AdjacencyMap a

fromInteger :: Integer -> AdjacencyMap a

Ord a => Ord (AdjacencyMap a)

Defined in Algebra.Graph.AdjacencyMap.Internal

Methods

compare :: AdjacencyMap a -> AdjacencyMap a -> Ordering

(<) :: AdjacencyMap a -> AdjacencyMap a -> Bool

(<=) :: AdjacencyMap a -> AdjacencyMap a -> Bool

(>) :: AdjacencyMap a -> AdjacencyMap a -> Bool

(>=) :: AdjacencyMap a -> AdjacencyMap a -> Bool

max :: AdjacencyMap a -> AdjacencyMap a -> AdjacencyMap a

min :: AdjacencyMap a -> AdjacencyMap a -> AdjacencyMap a

(Ord a, Show a) => Show (AdjacencyMap a)

Defined in Algebra.Graph.AdjacencyMap.Internal

Methods

showsPrec :: Int -> AdjacencyMap a -> ShowS

show :: AdjacencyMap a -> String

showList :: [AdjacencyMap a] -> ShowS

Generic (AdjacencyMap a)

Defined in Algebra.Graph.AdjacencyMap.Internal

Associated Types

type Rep (AdjacencyMap a) :: Type -> Type

Methods

from :: AdjacencyMap a -> Rep (AdjacencyMap a) x

to :: Rep (AdjacencyMap a) x -> AdjacencyMap a

NFData a => NFData (AdjacencyMap a)

Defined in Algebra.Graph.AdjacencyMap.Internal

Methods

rnf :: AdjacencyMap a -> ()

Ord a => ToGraph (AdjacencyMap a)

See Algebra.Graph.AdjacencyMap.

Defined in Algebra.Graph.ToGraph

Associated Types

type ToVertex (AdjacencyMap a) :: Type

Methods

toGraph :: AdjacencyMap a -> Graph (ToVertex (AdjacencyMap a))

foldg :: r -> (ToVertex (AdjacencyMap a) -> r) -> (r -> r -> r) -> (r -> r -> r) -> AdjacencyMap a -> r

isEmpty :: AdjacencyMap a -> Bool

size :: AdjacencyMap a -> Int

hasVertex :: ToVertex (AdjacencyMap a) -> AdjacencyMap a -> Bool

hasEdge :: ToVertex (AdjacencyMap a) -> ToVertex (AdjacencyMap a) -> AdjacencyMap a -> Bool

vertexCount :: AdjacencyMap a -> Int

edgeCount :: AdjacencyMap a -> Int

vertexList :: AdjacencyMap a -> [ToVertex (AdjacencyMap a)]

edgeList :: AdjacencyMap a -> [(ToVertex (AdjacencyMap a), ToVertex (AdjacencyMap a))]

vertexSet :: AdjacencyMap a -> Set (ToVertex (AdjacencyMap a))

vertexIntSet :: AdjacencyMap a -> IntSet

edgeSet :: AdjacencyMap a -> Set (ToVertex (AdjacencyMap a), ToVertex (AdjacencyMap a))

preSet :: ToVertex (AdjacencyMap a) -> AdjacencyMap a -> Set (ToVertex (AdjacencyMap a))

preIntSet :: Int -> AdjacencyMap a -> IntSet

postSet :: ToVertex (AdjacencyMap a) -> AdjacencyMap a -> Set (ToVertex (AdjacencyMap a))

postIntSet :: Int -> AdjacencyMap a -> IntSet

adjacencyList :: AdjacencyMap a -> [(ToVertex (AdjacencyMap a), [ToVertex (AdjacencyMap a)])]

adjacencyMap :: AdjacencyMap a -> Map (ToVertex (AdjacencyMap a)) (Set (ToVertex (AdjacencyMap a)))

adjacencyIntMap :: AdjacencyMap a -> IntMap IntSet

adjacencyMapTranspose :: AdjacencyMap a -> Map (ToVertex (AdjacencyMap a)) (Set (ToVertex (AdjacencyMap a)))

adjacencyIntMapTranspose :: AdjacencyMap a -> IntMap IntSet

dfsForest :: AdjacencyMap a -> Forest (ToVertex (AdjacencyMap a))

dfsForestFrom :: [ToVertex (AdjacencyMap a)] -> AdjacencyMap a -> Forest (ToVertex (AdjacencyMap a))

dfs :: [ToVertex (AdjacencyMap a)] -> AdjacencyMap a -> [ToVertex (AdjacencyMap a)]

reachable :: ToVertex (AdjacencyMap a) -> AdjacencyMap a -> [ToVertex (AdjacencyMap a)]

topSort :: AdjacencyMap a -> Maybe [ToVertex (AdjacencyMap a)]

isAcyclic :: AdjacencyMap a -> Bool

toAdjacencyMap :: AdjacencyMap a -> AdjacencyMap (ToVertex (AdjacencyMap a))

toAdjacencyMapTranspose :: AdjacencyMap a -> AdjacencyMap (ToVertex (AdjacencyMap a))

toAdjacencyIntMap :: AdjacencyMap a -> AdjacencyIntMap

toAdjacencyIntMapTranspose :: AdjacencyMap a -> AdjacencyIntMap

isDfsForestOf :: Forest (ToVertex (AdjacencyMap a)) -> AdjacencyMap a -> Bool

isTopSortOf :: [ToVertex (AdjacencyMap a)] -> AdjacencyMap a -> Bool

Ord a => Graph (AdjacencyMap a)

Defined in Algebra.Graph.Class

Associated Types

type Vertex (AdjacencyMap a) :: Type

Methods

empty :: AdjacencyMap a

vertex :: Vertex (AdjacencyMap a) -> AdjacencyMap a

overlay :: AdjacencyMap a -> AdjacencyMap a -> AdjacencyMap a

connect :: AdjacencyMap a -> AdjacencyMap a -> AdjacencyMap a

type Rep (AdjacencyMap a)

Defined in Algebra.Graph.AdjacencyMap.Internal

type Rep (AdjacencyMap a) = D1 (MetaData "AdjacencyMap" "Algebra.Graph.AdjacencyMap.Internal" "algebraic-graphs-0.4-1Yo9SHjdEnwDfrW6pcUtYw" True) (C1 (MetaCons "AM" PrefixI True) (S1 (MetaSel (Just "adjacencyMap") NoSourceUnpackedness NoSourceStrictness DecidedLazy) (Rec0 (Map a (Set a)))))

type ToVertex (AdjacencyMap a)

Defined in Algebra.Graph.ToGraph

type ToVertex (AdjacencyMap a) = a

type Vertex (AdjacencyMap a)

Defined in Algebra.Graph.Class

type Vertex (AdjacencyMap a) = a

consistent :: Ord a => AdjacencyMap a -> 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

internalEdgeList :: Map a (Set a) -> [(a, a)]

The list of edges of an adjacency map. Note: this function is for internal use only.

referredToVertexSet :: Ord a => Map a (Set a) -> Set a

The set of vertices that are referred to by the edges of an adjacency map. Note: this function is for internal use only.