Algebra.Graph.Relation.Internal

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

Binary relation implementation

data Relation a

The Relation data type represents a graph as a binary relation. 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     :: Relation Int) == "empty"
show (1         :: Relation Int) == "vertex 1"
show (1 + 2     :: Relation Int) == "vertices [1,2]"
show (1 * 2     :: Relation Int) == "edge 1 2"
show (1 * 2 * 3 :: Relation Int) == "edges [(1,2),(1,3),(2,3)]"
show (1 * 2 + 3 :: Relation 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

Relation

Fields

• domain :: Set a

  The domain of the relation.

• relation :: Set (a, a)

  The set of pairs of elements that are related. It is guaranteed that each element belongs to the domain.

Instances

Eq a => Eq (Relation a)

Defined in Algebra.Graph.Relation.Internal

Methods

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

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

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

Defined in Algebra.Graph.Relation.Internal

Methods

(+) :: Relation a -> Relation a -> Relation a

(-) :: Relation a -> Relation a -> Relation a

(*) :: Relation a -> Relation a -> Relation a

negate :: Relation a -> Relation a

abs :: Relation a -> Relation a

signum :: Relation a -> Relation a

fromInteger :: Integer -> Relation a

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

Defined in Algebra.Graph.Relation.Internal

Methods

showsPrec :: Int -> Relation a -> ShowS

show :: Relation a -> String

showList :: [Relation a] -> ShowS

NFData a => NFData (Relation a)

Defined in Algebra.Graph.Relation.Internal

Methods

rnf :: Relation a -> ()

Ord a => ToGraph (Relation a)

Defined in Algebra.Graph.ToGraph

Associated Types

type ToVertex (Relation a) :: *

Methods

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

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

isEmpty :: Relation a -> Bool

size :: Relation a -> Int

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

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

vertexCount :: Relation a -> Int

edgeCount :: Relation a -> Int

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

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

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

vertexIntSet :: Relation a -> IntSet

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

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

preIntSet :: Int -> Relation a -> IntSet

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

postIntSet :: Int -> Relation a -> IntSet

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

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

adjacencyIntMap :: Relation a -> IntMap IntSet

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

adjacencyIntMapTranspose :: Relation a -> IntMap IntSet

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

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

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

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

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

isAcyclic :: Relation a -> Bool

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

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

toAdjacencyIntMap :: Relation a -> AdjacencyIntMap

toAdjacencyIntMapTranspose :: Relation a -> AdjacencyIntMap

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

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

Ord a => Graph (Relation a)

Defined in Algebra.Graph.Class

Associated Types

type Vertex (Relation a) :: *

Methods

empty :: Relation a

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

overlay :: Relation a -> Relation a -> Relation a

connect :: Relation a -> Relation a -> Relation a

type ToVertex (Relation a)

Defined in Algebra.Graph.ToGraph

type ToVertex (Relation a) = a

type Vertex (Relation a)

Defined in Algebra.Graph.Class

type Vertex (Relation a) = a

empty :: Relation a

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

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

vertex :: a -> Relation a

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

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   && 'iAlgebra.Graph.Relation.sEmpty'   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 :: Ord a => Relation a -> Relation a -> Relation a

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

setProduct :: Set a -> Set b -> Set (a, b)

Compute the Cartesian product of two sets. Note: this function is for internal use only.

consistent :: Ord a => Relation a -> Bool

Check if the internal representation of a relation is consistent, i.e. if all pairs of elements in the relation refer to existing elements in the domain. It should be impossible to create an inconsistent Relation, 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

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

The set of elements that appear in a given set of pairs. Note: this function is for internal use only.