Quelle prop.xml Sprache: XML

#############################################################################
##
#W prop.xml
#Y Copyright (C) 2014-21 James D. Mitchell
##
## Licensing information can be found in the README file of this package.
##
#############################################################################
##

<#GAPDoc Label="IsMultiDigraph">
<ManSection>
 <Prop Name="IsMultiDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 A <E>multidigraph</E> is one that has at least two
 edges with equal source and range.

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph(["a", "b", "c"], ["a", "b", "b"], ["b", "c", "a"]);
<immutable digraph with 3 vertices, 3 edges>
gap> IsMultiDigraph(D);
false
gap> D := DigraphFromDigraph6String("&Bug");
<immutable digraph with 3 vertices, 6 edges>
gap> IsDuplicateFree(DigraphEdges(D));
true
gap> IsMultiDigraph(D);
false
gap> D := Digraph([[1, 2, 3, 2], [2, 1], [3]]);
<immutable multidigraph with 3 vertices, 7 edges>
gap> IsDuplicateFree(DigraphEdges(D));
false
gap> IsMultiDigraph(D);
true
gap> D := DigraphMutableCopy(D);
<mutable multidigraph with 3 vertices, 7 edges>
gap> IsMultiDigraph(D);
true]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="DigraphHasLoops">
<ManSection>
 <Prop Name="DigraphHasLoops" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 Returns <K>true</K> if the digraph <A>digraph</A> has loops, and
 <K>false</K> if it does not. A loop is an edge with equal source and range.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[1, 2], [2]]);
<immutable digraph with 2 vertices, 3 edges>
gap> DigraphEdges(D);
[ [ 1, 1 ], [ 1, 2 ], [ 2, 2 ] ]
gap> DigraphHasLoops(D);
true
gap> D := Digraph([[2, 3], [1], [2]]);
<immutable digraph with 3 vertices, 4 edges>
gap> DigraphEdges(D);
[ [ 1, 2 ], [ 1, 3 ], [ 2, 1 ], [ 3, 2 ] ]
gap> DigraphHasLoops(D);
false
gap> D := CompleteDigraph(IsMutableDigraph, 4);
<mutable digraph with 4 vertices, 12 edges>
gap> DigraphHasLoops(D);
false]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsAcyclicDigraph">
<ManSection>
 <Prop Name="IsAcyclicDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if the digraph <A>digraph</A> is acyclic, and
 <K>false</K> if it is not. A digraph is <E>acyclic</E> if every directed
 cycle on the digraph is trivial. See Section <Ref Subsect="Definitions"
 Style="Number" /> for the definition of a directed cycle, and of a trivial
 directed cycle.

 The method used in this operation has complexity <M>O(m+n)</M> where
 <M>m</M> is the number of edges (counting multiple edges as one) and
 <M>n</M> is the number of vertices in the digraph. 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> Petersen := Graph(SymmetricGroup(5), [[1, 2]], OnSets,
> function(x, y)
> return IsEmpty(Intersection(x, y));
> end);;
gap> D := Digraph(Petersen);
<immutable digraph with 10 vertices, 30 edges>
gap> IsAcyclicDigraph(D);
false
gap> D := DigraphFromDiSparse6String(
> ".b_OGCIDBaPGkULEbQHCeRIdrHcuZMfRyDAbPhTi|zF");
<immutable digraph with 35 vertices, 34 edges>
gap> IsAcyclicDigraph(D);
true
gap> IsAcyclicDigraph(ChainDigraph(10));
true
gap> D := CompleteDigraph(IsMutableDigraph, 4);
<mutable digraph with 4 vertices, 12 edges>
gap> IsAcyclicDigraph(D);
false
gap> IsAcyclicDigraph(CycleDigraph(10));
false]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsAperiodicDigraph">
<ManSection>
 <Prop Name="IsAperiodicDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if the digraph <A>digraph</A>
 is aperiodic, i.e. if its <Ref Attr = "DigraphPeriod"/> is equal to 1.
 Otherwise, the property is <K>false</K>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[6], [1], [2], [3], [4, 4], [5]]);
<immutable multidigraph with 6 vertices, 7 edges>
gap> IsAperiodicDigraph(D);
false
gap> D := Digraph([[2], [3, 5], [4], [5], [1, 2]]);
<immutable digraph with 5 vertices, 7 edges>
gap> IsAperiodicDigraph(D);
true
gap> D := Digraph(IsMutableDigraph, [[2], [3, 5], [4], [5], [1, 2]]);
<mutable digraph with 5 vertices, 7 edges>
gap> IsAperiodicDigraph(D);
true]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsStronglyConnectedDigraph">
<ManSection>
 <Prop Name="IsStronglyConnectedDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if the digraph <A>digraph</A> is strongly
 connected and <K>false</K> if it is not. 

 A digraph <A>digraph</A> is <E>strongly connected</E> if there is a directed
 path from every vertex to every other vertex. See Section <Ref
 Subsect="Definitions" Style="Number" /> for the definition of a directed
 path. 

 The method used in this operation is based on Gabow's Algorithm
 Key="Gab00"/> and has complexity <M>O(m+n)</M>, where <M>m</M> is
 the number of edges (counting multiple edges as one) and <M>n</M> is the
 number of vertices in the digraph.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := CycleDigraph(250000);
<immutable cycle digraph with 250000 vertices>
gap> IsStronglyConnectedDigraph(D);
true
gap> D := DigraphRemoveEdges(D, [[250000, 1]]);
<immutable digraph with 250000 vertices, 249999 edges>
gap> IsStronglyConnectedDigraph(D);
false
gap> D := CycleDigraph(IsMutableDigraph, 250000);
<mutable digraph with 250000 vertices, 250000 edges>
gap> IsStronglyConnectedDigraph(D);
true
gap> DigraphRemoveEdge(D, [250000, 1]);
<mutable digraph with 250000 vertices, 249999 edges>
gap> IsStronglyConnectedDigraph(D);
false
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsConnectedDigraph">
<ManSection>
 <Prop Name="IsConnectedDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if the digraph <A>digraph</A>
 is weakly connected and <K>false</K> if it is not. A digraph
 <A>digraph</A> is <E>weakly connected</E> if it is possible to travel
 from any vertex to any other vertex by traversing edges in either
 direction (possibly against the orientation of some of them). 

 The method used in this function has complexity <M>O(m)</M> if the
 digraph's attribute is set, otherwise it has
 complexity <M>O(m+n)</M> (where
 <M>m</M> is the number of edges and
 <M>n</M> is the number of vertices of the digraph).
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[2], [3], []]);;
gap> IsConnectedDigraph(D);
true
gap> D := Digraph([[1, 3], [4], [3], []]);;
gap> IsConnectedDigraph(D);
false
gap> D := Digraph(IsMutableDigraph, [[2], [3], []]);;
gap> IsConnectedDigraph(D);
true
gap> D := Digraph(IsMutableDigraph, [[1, 3], [4], [3], []]);;
gap> IsConnectedDigraph(D);
false]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsBiconnectedDigraph">
<ManSection>
 <Prop Name="IsBiconnectedDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 A connected digraph is <E>biconnected</E> if it is still connected (in the
 sense of <Ref Prop="IsConnectedDigraph"/>) when any vertex is removed.
 If <A>D</A> has at least 3 vertices, then <C>IsBiconnectedDigraph</C>
 implies <Ref Prop="IsBridgelessDigraph"/>;
 see <Ref Attr="ArticulationPoints"/> or <Ref Attr="Bridges"/> for a more
 detailed explanation.
 

 <C>IsBiconnectedDigraph</C> returns <K>true</K> if the digraph
 <A>digraph</A> is biconnected, and <K>false</K> if it is not. In
 particular, <C>IsBiconnectedDigraph</C> returns <K>false</K> if
 <A>digraph</A> is not connected. 

 Multiple edges are ignored by this method. 

 The method used in this operation has complexity <M>O(m+n)</M> where
 <M>m</M> is the number of edges and <M>n</M> is the number of vertices in
 the digraph.
 

 See also <Ref Attr="Bridges"/>, <Ref Attr="ArticulationPoints"/>, and
 <Ref Prop="IsBridgelessDigraph"/>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> IsBiconnectedDigraph(Digraph([[1, 3], [2, 3], [3]]));
false
gap> IsBiconnectedDigraph(CycleDigraph(5));
true
gap> D := Digraph([[1, 1], [1, 1, 2], [3], [3, 3, 4, 4]]);;
gap> IsBiconnectedDigraph(D);
false
gap> D := CompleteBipartiteDigraph(IsMutableDigraph, 5, 4);
<mutable digraph with 9 vertices, 40 edges>
gap> IsBiconnectedDigraph(D);
true]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsBipartiteDigraph">
<ManSection>
 <Prop Name="IsBipartiteDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if the digraph <A>digraph</A> is bipartite, and
 <K>false</K> if it is not. A digraph is bipartite if and only if the
 vertices of <A>digraph</A> can be partitioned into two non-empty sets such
 that the source and range of any edge of <A>digraph</A> lie in distinct sets.
 Equivalently, a digraph is bipartite if and only if it is 2-colorable; see
 <Ref Attr="DigraphGreedyColouring" Label="for a digraph"/>. 

 See also <Ref Attr="DigraphBicomponents"/>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := ChainDigraph(4);
<immutable chain digraph with 4 vertices>
gap> IsBipartiteDigraph(D);
true
gap> D := CycleDigraph(3);
<immutable cycle digraph with 3 vertices>
gap> IsBipartiteDigraph(D);
false
gap> D := CompleteBipartiteDigraph(IsMutableDigraph, 5, 4);
<mutable digraph with 9 vertices, 40 edges>
gap> IsBipartiteDigraph(D);
true]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsCompleteBipartiteDigraph">
<ManSection>
 <Prop Name="IsCompleteBipartiteDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 Returns <K>true</K> if the digraph <A>digraph</A> is a complete bipartite
 digraph, and <K>false</K> if it is not. 

 A digraph is a <E>complete bipartite digraph</E> if it is bipartite, see
 <Ref Prop="IsBipartiteDigraph"/>, and there exists a unique edge with
 source <C>i</C> and range <C>j</C> if and only if <C>i</C> and <C>j</C> lie
 in different bicomponents of <A>digraph</A>, see <Ref
 Attr="DigraphBicomponents"/>. 

 Equivalently, a bipartite digraph with bicomponents of size <M>m</M> and
 <M>n</M> is complete precisely when it has <M>2mn</M> edges, none of which
 are multiple edges. 

 See also <Ref Oper="CompleteBipartiteDigraph"/>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := CycleDigraph(2);
<immutable cycle digraph with 2 vertices>
gap> IsCompleteBipartiteDigraph(D);
true
gap> D := CycleDigraph(4);
<immutable cycle digraph with 4 vertices>
gap> IsBipartiteDigraph(D);
true
gap> IsCompleteBipartiteDigraph(D);
false
gap> D := CompleteBipartiteDigraph(IsMutableDigraph, 5, 4);
<mutable digraph with 9 vertices, 40 edges>
gap> IsCompleteBipartiteDigraph(D);
true]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsCompleteMultipartiteDigraph">
<ManSection>
 <Prop Name="IsCompleteMultipartiteDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property returns <K>true</K> if <A>digraph</A> is a complete
 multipartite digraph, and <K>false</K> if not. 

 A digraph is a <E>complete multipartite digraph</E> if and only if
 its vertices can be partitioned into at least two maximal independent sets,
 where every possible edge between these independent sets occurs in the
 digraph exactly once.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := CompleteMultipartiteDigraph([2, 4, 6]);
<immutable complete multipartite digraph with 12 vertices, 88 edges>
gap> IsCompleteMultipartiteDigraph(D);
true
gap> D := CompleteBipartiteDigraph(IsMutableDigraph, 5, 4);
<mutable digraph with 9 vertices, 40 edges>
gap> IsCompleteMultipartiteDigraph(D);
true]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsCompleteDigraph">
<ManSection>
 <Prop Name="IsCompleteDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 Returns <K>true</K> if the digraph <A>digraph</A> is complete, and
 <K>false</K> if it is not. 

 A digraph is <E>complete</E> if it has no loops, and for all
 <E>distinct</E> vertices <C>i</C> and <C>j</C>,
 there is exactly one edge with source <C>i</C> and range <C>j</C>.

 Equivalently, a digraph with <M>n</M> vertices is complete precisely when
 it has <M>n(n - 1)</M> edges, no loops, and no multiple edges.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[2, 3], [1, 3], [1, 2]]);
<immutable digraph with 3 vertices, 6 edges>
gap> IsCompleteDigraph(D);
true
gap> D := Digraph([[2, 2], [1]]);
<immutable multidigraph with 2 vertices, 3 edges>
gap> IsCompleteDigraph(D);
false
gap> D := CompleteBipartiteDigraph(IsMutableDigraph, 5, 4);
<mutable digraph with 9 vertices, 40 edges>
gap> IsCompleteDigraph(D);
false]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsTournament">
<ManSection>
 <Prop Name="IsTournament" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if the digraph <A>digraph</A> is a tournament,
 and <K>false</K> if it is not. 

 A tournament is an orientation of a complete (undirected) graph.
 Specifically, a tournament is a digraph which has a unique directed edge
 (of some orientation) between any pair of distinct vertices, and no loops.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[2, 3, 4], [3, 4], [4], []]);
<immutable digraph with 4 vertices, 6 edges>
gap> IsTournament(D);
true
gap> D := Digraph([[2], [1], [3]]);
<immutable digraph with 3 vertices, 3 edges>
gap> IsTournament(D);
false
gap> D := CycleDigraph(IsMutableDigraph, 3);
<mutable digraph with 3 vertices, 3 edges>
gap> IsTournament(D);
true
gap> DigraphRemoveEdge(D, 1, 2);
<mutable digraph with 3 vertices, 2 edges>
gap> IsTournament(D);
false
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsChainDigraph">
<ManSection>
 <Prop Name="IsChainDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 <C>IsChainDigraph</C> returns <K>true</K> if the digraph <A>digraph</A> is
 isomorphic to the chain digraph with the same number of vertices as
 <A>digraph</A>, and <K>false</K> if it is not; see <Ref
 Oper="ChainDigraph"/>.

 A digraph is a <E>chain</E> if and only if it is a directed tree, in which
 every vertex has out degree at most one; see <Ref Prop="IsDirectedTree"/>
 and <Ref Attr="OutDegrees"/>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[1, 3], [2, 3], [3]]);
<immutable digraph with 3 vertices, 5 edges>
gap> IsChainDigraph(D);
false
gap> D := ChainDigraph(5);
<immutable chain digraph with 5 vertices>
gap> IsChainDigraph(D);
true
gap> D := DigraphReverse(D);
<immutable digraph with 5 vertices, 4 edges>
gap> IsChainDigraph(D);
true
gap> D := ChainDigraph(IsMutableDigraph, 5);
<mutable digraph with 5 vertices, 4 edges>
gap> IsChainDigraph(D);
true
gap> DigraphReverse(D);
<mutable digraph with 5 vertices, 4 edges>
gap> IsChainDigraph(D);
true]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsCycleDigraph">
<ManSection>
 <Prop Name="IsCycleDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 <C>IsCycleDigraph</C> returns <K>true</K> if the digraph <A>digraph</A> is
 isomorphic to the cycle digraph with the same number of vertices as
 <A>digraph</A>, and <K>false</K> if it is not; see <Ref
 Oper="CycleDigraph"/>.

 A digraph is a <E>cycle</E> if and only if it is strongly connected and has
 the same number of edges as vertices.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[1, 3], [2, 3], [3]]);
<immutable digraph with 3 vertices, 5 edges>
gap> IsCycleDigraph(D);
false
gap> D := CycleDigraph(5);
<immutable cycle digraph with 5 vertices>
gap> IsCycleDigraph(D);
true
gap> D := OnDigraphs(D, (1, 2, 3));
<immutable digraph with 5 vertices, 5 edges>
gap> D = CycleDigraph(5);
false
gap> IsCycleDigraph(D);
true]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsDigraphCore">
<ManSection>
 <Prop Name="IsDigraphCore" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property returns <K>true</K> if <A>digraph</A> is a core,
 and <K>false</K> if it is not.

 A digraph <C>D</C> is a <E>core</E> if and only if it has no proper
 subdigraphs <C>A</C> such that there exists a homomorphism from <C>D</C>
 to <C>A</C>. In other words, a digraph <C>D</C> is a core if and only if
 every endomorphism on <C>D</C> is an automorphism on <C>D</C>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := CompleteDigraph(6);
<immutable complete digraph with 6 vertices>
gap> IsDigraphCore(D);
true
gap> D := DigraphSymmetricClosure(CycleDigraph(6));
<immutable symmetric digraph with 6 vertices, 12 edges>
gap> DigraphHomomorphism(D, CompleteDigraph(2));
Transformation( [ 1, 2, 1, 2, 1, 2 ] )
gap> IsDigraphCore(D);
false
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsDirectedTree">
<ManSection>
 <Prop Name="IsDirectedTree" Arg="digraph"/>
 <Prop Name="IsDirectedForest" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 The property <Ref Prop="IsDirectedTree"/> returns <K>true</K> if the
 digraph <A>digraph</A> is a directed tree, and the property
 <Ref Prop="IsDirectedForest"/> returns <K>true</K> if <A>digraph</A> is
 a directed forest; otherwise these properties return <K>false</K>. 

 A <E>directed tree</E> is an acyclic digraph with precisely one source,
 without multiple edges, and such that no two vertices share an
 out-neighbour. See and <Ref Attr="IsAcyclicDigraph"/> and
 <Ref Attr="DigraphSources"/> for more information about these terms. 

 A <E>directed forest</E> is a digraph with at least one vertex,
 each of whose connected components is a directed tree.
 In other words, a directed forest is isomorphic to a disjoint union of
 directed trees.
 In particular, every directed tree is a directed forest.
 See <Ref Attr="DigraphConnectedComponents" /> and
 <Ref Func="DigraphDisjointUnion" Label="for a list of digraphs" />. 

 Please note that the empty digraph with zero vertices is not considered
 to be a directed tree or directed forest, because it has no source. 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[3], [3], []]);
<immutable digraph with 3 vertices, 2 edges>
gap> IsDirectedTree(D);
false
gap> D := Digraph([[2], [3], []]);
<immutable digraph with 3 vertices, 2 edges>
gap> IsDirectedTree(D);
true
gap> IsDirectedForest(DigraphDisjointUnion(D, D));
true
gap> D := Digraph([[2, 3], [6], [4, 5], [], [], []]);
<immutable digraph with 6 vertices, 5 edges>
gap> IsDirectedTree(D);
true
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsUndirectedTree">
<ManSection>
 <Prop Name="IsUndirectedTree" Arg="digraph"/>
 <Prop Name="IsUndirectedForest" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 The property <Ref Prop="IsUndirectedTree"/> returns <K>true</K> if the
 digraph <A>digraph</A> is an undirected tree, and the property
 <Ref Prop="IsUndirectedForest"/> returns <K>true</K> if <A>digraph</A> is
 an undirected forest; otherwise, these properties return <K>false</K>. 

 An <E>undirected tree</E> is a symmetric digraph without loops, in which for
 any pair of distinct vertices <C>u</C> and <C>v</C>, there is exactly one
 directed path from <C>u</C> to <C>v</C>. See <Ref
 Prop="IsSymmetricDigraph"/> and <Ref Prop="DigraphHasLoops"/>, and see
 Section <Ref Subsect="Definitions" Style="Number" /> for the definition of
 directed path. This definition implies that an undirected tree has
 no multiple edges. 

 An <E>undirected forest</E> is a digraph, each of whose connected components
 is an undirected tree. In other words, an undirected forest is isomorphic to
 a disjoint union of undirected trees. See <Ref
 Attr="DigraphConnectedComponents" /> and <Ref Func="DigraphDisjointUnion"
 Label="for a list of digraphs" />. In particular, every
 undirected tree is an undirected forest. 

 Please note that the digraph with zero vertices is considered to be neither
 an undirected tree nor an undirected forest.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[3], [3], [1, 2]]);
<immutable digraph with 3 vertices, 4 edges>
gap> IsUndirectedTree(D);
true
gap> IsSymmetricDigraph(D) and not DigraphHasLoops(D);
true
gap> D := Digraph([[3], [5], [1, 4], [3], [2]]);
<immutable digraph with 5 vertices, 6 edges>
gap> IsConnectedDigraph(D);
false
gap> IsUndirectedTree(D);
false
gap> IsUndirectedForest(D);
true
gap> D := Digraph([[1, 2], [1], [2]]);
<immutable digraph with 3 vertices, 4 edges>
gap> IsUndirectedTree(D) or IsUndirectedForest(D);
false
gap> IsSymmetricDigraph(D) or not DigraphHasLoops(D);
false]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsEdgeTransitive">
<ManSection>
 <Prop Name="IsEdgeTransitive" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 If <A>digraph</A> is a digraph without multiple edges, then
 <C>IsEdgeTransitive</C> returns <K>true</K> if <A>digraph</A>
 is edge transitive, and <K>false</K> otherwise. A digraph is
 <E>edge transitive</E> if its automorphism group acts
 transitively on its edges (via the action
 <Ref Func="OnPairs" BookName="ref"/>).
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> IsEdgeTransitive(CompleteDigraph(2));
true
gap> IsEdgeTransitive(ChainDigraph(3));
false
gap> IsEdgeTransitive(Digraph([[2], [3, 3, 3], []]));
Error, the argument <D> must be a digraph with no multiple edges,
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsVertexTransitive">
<ManSection>
 <Prop Name="IsVertexTransitive" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 If <A>digraph</A> is a digraph, then <C>IsVertexTransitive</C> returns
 <K>true</K> if <A>digraph</A> is vertex transitive, and <K>false</K>
 otherwise. A digraph is <E>vertex transitive</E> if its automorphism group
 acts transitively on its vertices.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> IsVertexTransitive(CompleteDigraph(2));
true
gap> IsVertexTransitive(ChainDigraph(3));
false
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsEmptyDigraph">
<ManSection>
 <Prop Name="IsEmptyDigraph" Arg="digraph"/>
 <Prop Name="IsNullDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 Returns <K>true</K> if the digraph <A>digraph</A> is empty, and
 <K>false</K> if it is not. A digraph is <E>empty</E> if it has no
 edges.

 <Ref Prop="IsNullDigraph"/> is a synonym for <Ref Prop="IsEmptyDigraph"/>.
 See also <Ref Prop="IsNonemptyDigraph"/>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[], []]);
<immutable empty digraph with 2 vertices>
gap> IsEmptyDigraph(D);
true
gap> IsNullDigraph(D);
true
gap> D := Digraph([[], [1]]);
<immutable digraph with 2 vertices, 1 edge>
gap> IsEmptyDigraph(D);
false
gap> IsNullDigraph(D);
false]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsNonemptyDigraph">
<ManSection>
 <Prop Name="IsNonemptyDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 Returns <K>true</K> if the digraph <A>digraph</A> is nonempty, and
 <K>false</K> if it is not. A digraph is <E>nonempty</E> if it has at
 least one edge.

 See also <Ref Prop="IsEmptyDigraph"/>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[], []]);
<immutable empty digraph with 2 vertices>
gap> IsNonemptyDigraph(D);
false
gap> D := Digraph([[], [1]]);
<immutable digraph with 2 vertices, 1 edge>
gap> IsNonemptyDigraph(D);
true]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="DigraphHasAVertex">
<ManSection>
 <Prop Name="DigraphHasAVertex" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 Returns <K>true</K> if the digraph <A>digraph</A> has at least one vertex,
 and <K>false</K> if it does not.

 See also <Ref Prop="DigraphHasNoVertices"/>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([]);
<immutable empty digraph with 0 vertices>
gap> DigraphHasAVertex(D);
false
gap> D := Digraph([[]]);
<immutable empty digraph with 1 vertex>
gap> DigraphHasAVertex(D);
true
gap> D := Digraph([[], [1]]);
<immutable digraph with 2 vertices, 1 edge>
gap> DigraphHasAVertex(D);
true]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="DigraphHasNoVertices">
<ManSection>
 <Prop Name="DigraphHasNoVertices" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 Returns <K>true</K> if the digraph <A>digraph</A> is the unique digraph
 with zero vertices, and <K>false</K> otherwise.

 See also <Ref Prop="DigraphHasAVertex"/>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([]);
<immutable empty digraph with 0 vertices>
gap> DigraphHasNoVertices(D);
true
gap> D := Digraph([[]]);
<immutable empty digraph with 1 vertex>
gap> DigraphHasNoVertices(D);
false
gap> D := Digraph([[], [1]]);
<immutable digraph with 2 vertices, 1 edge>
gap> DigraphHasNoVertices(D);
false]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsEulerianDigraph">
<ManSection>
 <Prop Name="IsEulerianDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property returns true if the digraph <A>digraph</A> is Eulerian.
 

 A connected digraph is called <E>Eulerian</E> if there exists a directed
 circuit on the digraph which includes every edge exactly once. See
 Section <Ref Subsect="Definitions" Style="Number" /> for the definition of
 a directed circuit. Note that the empty digraph with at most one vertex is
 considered to be Eulerian.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[]]);
<immutable empty digraph with 1 vertex>
gap> IsEulerianDigraph(D);
true
gap> D := Digraph([[2], []]);
<immutable digraph with 2 vertices, 1 edge>
gap> IsEulerianDigraph(D);
false
gap> D := Digraph([[3], [], [2]]);
<immutable digraph with 3 vertices, 2 edges>
gap> IsEulerianDigraph(D);
false
gap> D := Digraph([[2], [3], [1]]);
<immutable digraph with 3 vertices, 3 edges>
gap> IsEulerianDigraph(D);
true
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsFunctionalDigraph">
<ManSection>
 <Prop Name="IsFunctionalDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if the digraph <A>digraph</A> is
 functional. 

 A digraph is <E>functional</E> if every vertex is the source of a
 unique edge.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> gr1 := Digraph([[3], [2], [2], [1], [6], [5]]);
<immutable digraph with 6 vertices, 6 edges>
gap> IsFunctionalDigraph(gr1);
true
gap> gr2 := Digraph([[1, 2], [1]]);
<immutable digraph with 2 vertices, 3 edges>
gap> IsFunctionalDigraph(gr2);
false
gap> gr3 := Digraph(3, [1, 2, 3], [2, 3, 1]);
<immutable digraph with 3 vertices, 3 edges>
gap> IsFunctionalDigraph(gr3);
true
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsPermutationDigraph">
<ManSection>
 <Prop Name="IsPermutationDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if the digraph <A>digraph</A> is
 functional and each node has only one in-neighbour. 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> gr1 := Digraph([[3], [2], [2], [1], [6], [5]]);
<immutable digraph with 6 vertices, 6 edges>
gap> IsPermutationDigraph(gr1);
false
gap> gr2 := Digraph([[1, 2], [1]]);
<immutable digraph with 2 vertices, 3 edges>
gap> IsPermutationDigraph(gr2);
false
gap> gr3 := Digraph(3, [1, 2, 3], [2, 3, 1]);
<immutable digraph with 3 vertices, 3 edges>
gap> IsPermutationDigraph(gr3);
true
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsHamiltonianDigraph">
<ManSection>
 <Prop Name="IsHamiltonianDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 If <A>digraph</A> is Hamiltonian, then this property returns
 <K>true</K>, and <K>false</K> if it is not. 

 A digraph with <C>n</C> vertices is <E>Hamiltonian</E> if it has a
 directed cycle of length <C>n</C>. See Section <Ref Subsect="Definitions"
 Style="Number" /> for the definition of a directed cycle.
 Note the empty digraphs on 0 and 1 vertices are considered to be
 Hamiltonian.

 The method used in this operation has the worst case complexity as
 <Ref Oper="DigraphMonomorphism"/>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> g := Digraph([[]]);
<immutable empty digraph with 1 vertex>
gap> IsHamiltonianDigraph(g);
true
gap> g := Digraph([[2], [1]]);
<immutable digraph with 2 vertices, 2 edges>
gap> IsHamiltonianDigraph(g);
true
gap> g := Digraph([[3], [], [2]]);
<immutable digraph with 3 vertices, 2 edges>
gap> IsHamiltonianDigraph(g);
false
gap> g := Digraph([[2], [3], [1]]);
<immutable digraph with 3 vertices, 3 edges>
gap> IsHamiltonianDigraph(g);
true
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsRegularDigraph">
<ManSection>
 <Prop Name="IsRegularDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if there is an integer <C>n</C> such that
 for every vertex <C>v</C> of digraph <A>digraph</A> there are exactly
 <C>n</C> edges starting and terminating at <C>v</C>. In other words,
 the property is <K>true</K> if <A>digraph</A> is both in-regular and
 and out-regular.

 See also <Ref Prop="IsInRegularDigraph"/> and
 <Ref Prop="IsOutRegularDigraph"/>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> IsRegularDigraph(CompleteDigraph(4));
true
gap> IsRegularDigraph(ChainDigraph(4));
false
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsInRegularDigraph">
<ManSection>
 <Prop Name="IsInRegularDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if there is an integer <C>n</C> such that
 for every vertex <C>v</C> of digraph <A>digraph</A> there are exactly
 <C>n</C> edges terminating in <C>v</C>.

 See also <Ref Prop="IsOutRegularDigraph"/> and
 <Ref Prop="IsRegularDigraph"/>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> IsInRegularDigraph(CompleteDigraph(4));
true
gap> IsInRegularDigraph(ChainDigraph(4));
false
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsOutRegularDigraph">
<ManSection>
 <Prop Name="IsOutRegularDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if there is an integer <C>n</C> such that
 for every vertex <C>v</C> of digraph <A>digraph</A> there are exactly
 <C>n</C> edges starting at <C>v</C>.
 

 See also <Ref Prop="IsInRegularDigraph"/> and
 <Ref Prop="IsRegularDigraph"/>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> IsOutRegularDigraph(CompleteDigraph(4));
true
gap> IsOutRegularDigraph(ChainDigraph(4));
false
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsDistanceRegularDigraph">
<ManSection>
 <Prop Name="IsDistanceRegularDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 If <A>digraph</A> is a connected symmetric graph, this property returns
 <K>true</K> if for any two vertices <C>u</C> and <C>v</C> of <A>digraph</A>
 and any two integers <C>i</C> and <C>j</C> between <C>0</C> and the
 diameter of <A>digraph</A>, the number of vertices at distance <C>i</C>
 from <C>u</C> and distance <C>j</C> from <C>v</C> depends only on
 <C>i</C>, <C>j</C>, and the distance between vertices <C>u</C> and
 <C>v</C>.

 Alternatively, a distance regular graph is a graph for which there exist
 integers <C>b_i</C>, <C>c_i</C>, and <C>i</C> such that for any two
 vertices <C>u</C>, <C>v</C> in <A>digraph</A> which are distance <C>i</C>
 apart, there are exactly <C>b_i</C> neighbors of <C>v</C> which are at
 distance <C>i - 1</C> away from <C>u</C>, and <C>c_i</C> neighbors of
 <C>v</C> which are at distance <C>i + 1</C> away from <C>u</C>. This
 definition is used to check whether <A>digraph</A> is distance regular.

 In the case where <A>digraph</A> is not symmetric or not connected, the
 property is <K>false</K>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := DigraphSymmetricClosure(ChainDigraph(5));;
gap> IsDistanceRegularDigraph(D);
false
gap> D := Digraph([[2, 3, 4], [1, 3, 4], [1, 2, 4], [1, 2, 3]]);
<immutable digraph with 4 vertices, 12 edges>
gap> IsDistanceRegularDigraph(D);
true
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsReflexiveDigraph">
<ManSection>
 <Prop Name="IsReflexiveDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if the digraph <A>digraph</A> is
 reflexive, and <K>false</K> if it is not.
 A digraph is <E>reflexive</E> if it has a loop at every vertex. 
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[1, 2], [2]]);
<immutable digraph with 2 vertices, 3 edges>
gap> IsReflexiveDigraph(D);
true
gap> D := Digraph([[3, 1], [4, 2], [3], [2, 1]]);
<immutable digraph with 4 vertices, 7 edges>
gap> IsReflexiveDigraph(D);
false
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsSymmetricDigraph">
<ManSection>
 <Prop Name="IsSymmetricDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if the digraph <A>digraph</A>
 is symmetric, and <K>false</K> if it is not.

 A <E>symmetric digraph</E> is one where for each non-loop edge, having
 source <C>u</C> and range <C>v</C>, there is a corresponding edge with
 source <C>v</C> and range <C>u</C>. If there are <C>n</C> edges with
 source <C>u</C> and range <C>v</C>, then there must be precisely <C>n</C>
 edges with source <C>v</C> and range <C>u</C>. In other words, a symmetric
 digraph has a symmetric adjacency matrix <Ref Attr="AdjacencyMatrix"/>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> gr1 := Digraph([[2], [1, 3], [2, 3]]);
<immutable digraph with 3 vertices, 5 edges>
gap> IsSymmetricDigraph(gr1);
true
gap> adj1 := AdjacencyMatrix(gr1);;
gap> Display(adj1);
[ [ 0, 1, 0 ],
 [ 1, 0, 1 ],
 [ 0, 1, 1 ] ]
gap> adj1 = TransposedMat(adj1);
true
gap> gr1 = DigraphReverse(gr1);
true
gap> gr2 := Digraph([[2, 3], [1, 3], [2, 3]]);
<immutable digraph with 3 vertices, 6 edges>
gap> IsSymmetricDigraph(gr2);
false
gap> adj2 := AdjacencyMatrix(gr2);;
gap> Display(adj2);
[ [ 0, 1, 1 ],
 [ 1, 0, 1 ],
 [ 0, 1, 1 ] ]
gap> adj2 = TransposedMat(adj2);
false
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsAntisymmetricDigraph">
<ManSection>
 <Prop Name="IsAntiSymmetricDigraph" Arg="digraph"/>
 <Prop Name="IsAntisymmetricDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if the digraph <A>digraph</A>
 is antisymmetric, and <K>false</K> if it is not.
 

 A digraph is <E>antisymmetric</E> if whenever there is an edge with source
 <C>u</C> and range <C>v</C>, and an edge with source <C>v</C> and range
 <C>u</C>, then the vertices <C>u</C> and <C>v</C> are equal.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> gr1 := Digraph([[2], [1, 3], [2, 3]]);
<immutable digraph with 3 vertices, 5 edges>
gap> IsAntisymmetricDigraph(gr1);
false
gap> DigraphEdges(gr1){[1, 2]};
[ [ 1, 2 ], [ 2, 1 ] ]
gap> gr2 := Digraph([[1, 2], [3, 3], [1]]);
<immutable multidigraph with 3 vertices, 5 edges>
gap> IsAntisymmetricDigraph(gr2);
true
gap> DigraphEdges(gr2);
[ [ 1, 1 ], [ 1, 2 ], [ 2, 3 ], [ 2, 3 ], [ 3, 1 ] ]
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsTransitiveDigraph">
<ManSection>
 <Prop Name="IsTransitiveDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 This property is <K>true</K> if the digraph <A>digraph</A>
 is transitive, and <K>false</K> if it is not.

 A digraph is <E>transitive</E> if whenever <C>[ i, j ]</C> and
 <C>[ j, k ]</C> are edges of the digraph, then <C>[ i, k ]</C> is also an
 edge of the digraph. 

 Let <M>n</M> be the number of vertices of an arbitrary digraph, and let
 <M>m</M> be the number of edges.
 For general digraphs, the methods used for this property use a version
 of the Floyd-Warshall algorithm, and have complexity <M>O(n^3)</M>.

 However for digraphs which are topologically sortable
 [<Ref Attr="DigraphTopologicalSort"/>], then methods with
 complexity <M>O(m + n + m \cdot n)</M> will be used when appropriate.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[1, 2], [3], [3]]);
<immutable digraph with 3 vertices, 4 edges>
gap> IsTransitiveDigraph(D);
false
gap> gr2 := Digraph([[1, 2, 3], [3], [3]]);
<immutable digraph with 3 vertices, 5 edges>
gap> IsTransitiveDigraph(gr2);
true
gap> gr2 = DigraphTransitiveClosure(D);
true
gap> gr3 := Digraph([[1, 2, 2, 3], [3, 3], [3]]);
<immutable multidigraph with 3 vertices, 7 edges>
gap> IsTransitiveDigraph(gr3);
true
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsMeetSemilatticeDigraph">
<ManSection>
 <Prop Name="IsMeetSemilatticeDigraph" Arg="digraph"/>
 <Prop Name="IsJoinSemilatticeDigraph" Arg="digraph"/>
 <Prop Name="IsLatticeDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 <C>IsMeetSemilatticeDigraph</C> returns <K>true</K> if the digraph
 <A>digraph</A> is a meet semilattice; <C>IsJoinSemilatticeDigraph</C>
 returns <K>true</K> if the digraph <A>digraph</A> is a join semilattice;
 and <C>IsLatticeDigraph</C> returns <K>true</K> if the digraph
 <A>digraph</A> is both a meet and a join semilattice.
 

 For a partial order digraph <Ref Prop="IsPartialOrderDigraph"/> the
 corresponding partial order is the relation <M>\leq</M>, defined by
 <M>x \leq y</M> if and only if <C>[x, y]</C> is an edge.
 A digraph is a <E>meet semilattice</E> if it is a partial order and every
 pair of vertices has a greatest lower bound (meet) with respect to the
 aforementioned relation. A <E>join semilattice</E> is a partial order where
 every pair of vertices has a least upper bound (join) with respect to
 the relation.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[1, 3], [2, 3], [3]]);
<immutable digraph with 3 vertices, 5 edges>
gap> IsMeetSemilatticeDigraph(D);
false
gap> IsJoinSemilatticeDigraph(D);
true
gap> IsLatticeDigraph(D);
false
gap> D := Digraph([[1], [2], [1 .. 3]]);
<immutable digraph with 3 vertices, 5 edges>
gap> IsJoinSemilatticeDigraph(D);
false
gap> IsMeetSemilatticeDigraph(D);
true
gap> IsLatticeDigraph(D);
false
gap> D := Digraph([[1 .. 4], [2, 4], [3, 4], [4]]);
<immutable digraph with 4 vertices, 9 edges>
gap> IsMeetSemilatticeDigraph(D);
true
gap> IsJoinSemilatticeDigraph(D);
true
gap> IsLatticeDigraph(D);
true
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsDistributiveLatticeDigraph">
<ManSection>
 <Prop Name="IsDistributiveLatticeDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 <C>IsDistributiveLatticeDigraph</C> returns <K>true</K> if the digraph
 <A>digraph</A> is a distributive lattice digraph.

 A <E>distributive lattice digraph</E> is a lattice digraph (<Ref
 Prop="IsLatticeDigraph"/>) which is distributive. That is to say, the
 functions <Ref Oper="PartialOrderDigraphMeetOfVertices"/> and <Ref
 Oper="PartialOrderDigraphJoinOfVertices"/> distribute over each other.

 Equivalently, a distributive lattice digraph is a lattice digraph in which
 the <E>lattice digraphs</E> representing <M>M3</M> and <M>N5</M> are not
 embeddable as lattices
 (see <URL>https://en.wikipedia.org/wiki/Distributive_lattice</URL> and
 <Ref Prop="IsLatticeEmbedding"
 Label="for digraphs and a permutation or transformation"/>).

 <Alt Only="HTML">
 <![CDATA[
 <figure>
 <img height="200" src="m3.png"/>

 <img height="200" src="n5.png"/>
 <figcaption>The lattices <e>M3</e> and <e>N5</e>.</figcaption>
 </figure>
 ]]>
 </Alt>
 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[2, 3], [4], [4], []]);
<immutable digraph with 4 vertices, 4 edges>
gap> D := DigraphReflexiveTransitiveClosure(D);
<immutable preorder digraph with 4 vertices, 9 edges>
gap> IsDistributiveLatticeDigraph(D);
true
gap> N5 := Digraph([[2, 4], [3], [5], [5], []]);
<immutable digraph with 5 vertices, 5 edges>
gap> N5 := DigraphReflexiveTransitiveClosure(N5);
<immutable preorder digraph with 5 vertices, 13 edges>
gap> IsDistributiveLatticeDigraph(N5);
false]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsModularLatticeDigraph">
<ManSection>
 <Prop Name="IsModularLatticeDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 <C>IsModularLatticeDigraph</C> returns <K>true</K> if the digraph
 <A>digraph</A> is a modular lattice digraph.

 A <E>modular lattice digraph</E> is a lattice digraph (<Ref
 Prop="IsLatticeDigraph"/>) which is modular. That is to say, the lattice
 digraph representing <M>N5</M> is not embeddable as a lattice (see
 <URL>https://en.wikipedia.org/wiki/Modular_lattice</URL> and <Ref
 Prop="IsLatticeEmbedding"
 Label="for digraphs and a permutation or transformation"/>).

 <Alt Only="HTML">
 <![CDATA[
 <figure>
 <img height="200" src="n5.png"/>
 <figcaption>The lattice <e>N5</e>.</figcaption>
 </figure>
 ]]>
 </Alt>

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := ChainDigraph(5);
<immutable chain digraph with 5 vertices>
gap> D := DigraphReflexiveTransitiveClosure(D);
<immutable preorder digraph with 5 vertices, 15 edges>
gap> IsModularLatticeDigraph(D);
true
gap> N5 := Digraph([[2, 3], [4], [4], []]);
<immutable digraph with 4 vertices, 4 edges>
gap> DigraphReflexiveTransitiveClosure(N5);
<immutable preorder digraph with 4 vertices, 9 edges>
gap> IsModularLatticeDigraph(N5);
false
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsPreorderDigraph">
<ManSection>
 <Prop Name="IsPreorderDigraph" Arg="digraph"/>
 <Prop Name="IsQuasiorderDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 A digraph is a preorder digraph if and only if the digraph satisfies both
 <Ref Prop="IsReflexiveDigraph"/> and <Ref Prop="IsTransitiveDigraph"/>.
 A preorder digraph (or quasiorder digraph) <A>digraph</A> corresponds to
 the preorder relation <M>\leq</M> defined by <M>x \leq y</M> if and only
 if <C>[x, y]</C> is an edge of <A>digraph</A>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[1], [2, 3], [2, 3]]);
<immutable digraph with 3 vertices, 5 edges>
gap> IsPreorderDigraph(D);
true
gap> D := Digraph([[1 .. 4], [1 .. 4], [1 .. 4], [1 .. 4]]);
<immutable digraph with 4 vertices, 16 edges>
gap> IsPreorderDigraph(D);
true
gap> D := Digraph([[2], [3], [4], [5], [1]]);
<immutable digraph with 5 vertices, 5 edges>
gap> IsPreorderDigraph(D);
false
gap> D := Digraph([[1], [1, 2], [2, 3]]);
<immutable digraph with 3 vertices, 5 edges>
gap> IsQuasiorderDigraph(D);
false
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsPartialOrderDigraph">
<ManSection>
 <Prop Name="IsPartialOrderDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 A digraph is a partial order digraph if and only if the digraph satisfies
 all of <Ref Prop="IsReflexiveDigraph"/>,
 <Ref Prop="IsAntisymmetricDigraph"/> and <Ref Prop="IsTransitiveDigraph"/>.
 A partial order <A>digraph</A> corresponds
 to the partial order relation <M>\leq</M> defined by <M>x \leq y</M> if and
 only if <C>[x, y]</C> is an edge of <A>digraph</A>.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[1, 3], [2, 3], [3]]);
<immutable digraph with 3 vertices, 5 edges>
gap> IsPartialOrderDigraph(D);
true
gap> D := CycleDigraph(5);
<immutable cycle digraph with 5 vertices>
gap> IsPartialOrderDigraph(D);
false
gap> D := Digraph([[1, 1], [1, 1, 2], [3], [3, 3, 4, 4]]);
<immutable multidigraph with 4 vertices, 10 edges>
gap> IsPartialOrderDigraph(D);
true
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsEquivalenceDigraph">
<ManSection>
 <Prop Name="IsEquivalenceDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 A digraph is an equivalence digraph if and only if the digraph satisfies
 all of <Ref Prop="IsReflexiveDigraph"/>,
 <Ref Prop="IsSymmetricDigraph"/> and <Ref Prop="IsTransitiveDigraph"/>.
 A partial order <A>digraph</A> corresponds to an equivalence relation.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := Digraph([[1, 3], [2], [1, 3]]);
<immutable digraph with 3 vertices, 5 edges>
gap> IsEquivalenceDigraph(D);
true
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsBridgelessDigraph">
<ManSection>
 <Prop Name="IsBridgelessDigraph" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 A connected digraph is <E>bridgeless</E> if it is still connected (in the
 sense of <Ref Prop="IsConnectedDigraph"/>) when any edge is removed.
 If <A>digraph</A> has at least 3 vertices, then <Ref
 Prop="IsBiconnectedDigraph"/> implies <C>IsBridgelessDigraph</C>;
 see <Ref Attr="ArticulationPoints"/> or <Ref Attr="Bridges"/> for a more
 detailed explanation.
 

 <C>IsBridgelessDigraph</C> returns <K>true</K> if the digraph
 <A>digraph</A> is bridgeless, and <K>false</K> if it is not. In
 particular, <C>IsBridgelessDigraph</C> returns <K>false</K> if
 <A>digraph</A> is not connected. 

 Multiple edges are ignored by this method. 

 The method used in this operation has complexity <M>O(m+n)</M> where
 <M>m</M> is the number of edges and <M>n</M> is the number of vertices in
 the digraph.
 

 See also <Ref Attr="Bridges"/>, <Ref Attr="ArticulationPoints"/>, and
 <Ref Prop="IsBiconnectedDigraph"/>. 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> IsBridgelessDigraph(Digraph([[1, 3], [2, 3], [3]]));
false
gap> IsBridgelessDigraph(CycleDigraph(5));
true
gap> D := Digraph([[1, 1], [1, 1, 2], [3], [3, 3, 4, 4]]);;
gap> IsBridgelessDigraph(D);
false
gap> D := CompleteBipartiteDigraph(IsMutableDigraph, 5, 4);
<mutable digraph with 9 vertices, 40 edges>
gap> IsBridgelessDigraph(D);
true
gap> D := Digraph([[2, 5], [1, 3, 4, 5], [2, 4], [2, 3], [1, 2]]);
<immutable digraph with 5 vertices, 12 edges>
gap> IsBridgelessDigraph(D);
true
gap> IsBiconnectedDigraph(D);
false
gap> D := Digraph([[2], [3], [4], [2]]);
<immutable digraph with 4 vertices, 4 edges>
gap> IsBridgelessDigraph(D);
false
gap> IsBiconnectedDigraph(D);
false
gap> IsBridgelessDigraph(ChainDigraph(2));
false
gap> IsBiconnectedDigraph(ChainDigraph(2));
true
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="IsUpperSemimodularDigraph">
<ManSection>
 <Prop Name="IsUpperSemimodularDigraph" Arg="D"/>
 <Prop Name="IsLowerSemimodularDigraph" Arg="D"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 <C>IsUpperSemimodularDigraph</C> returns <K>true</K> if the digraph
 <A>D</A> represents an upper semimodular lattice and <K>false</K> if it
 does not. Similarly, <C>IsLowerSemimodularDigraph</C> returns <K>true</K>
 if <A>D</A> represents a lower semimodular lattice and <K>false</K> if
 it does not. 

 In a lattice we say that a vertex <C>a</C> <E>covers</E> a vertex <C>b</C>
 if <C>a</C> is greater than <C>b</C>, and there are no further vertices
 between <C>a</C> and <C>b</C>. A lattice is <E>upper semimodular</E> if
 whenever the meet of <C>a</C> and <C>b</C> is covered by <C>a</C>, the join
 of <C>a</C> and <C>b</C> covers <C>b</C>. <E>Lower semimodularity</E> is
 defined analogously. 

 See also <Ref Prop="IsLatticeDigraph"/>, <Ref Oper="NonUpperSemimodularPair"/>,
 and <Ref Oper="NonLowerSemimodularPair"/>.

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> D := DigraphFromDigraph6String(
> "&M~~sc`lYUZO__KIBboC_@h?U_?_GL?A_?c");
<immutable digraph with 14 vertices, 66 edges>
gap> IsUpperSemimodularDigraph(D);
true
gap> IsLowerSemimodularDigraph(D);
false]]></Example>
</Description>
</ManSection>
<#/GAPDoc>

<#GAPDoc Label="Is2EdgeTransitive">
<ManSection>
 <Prop Name="Is2EdgeTransitive" Arg="digraph"/>
 <Returns><K>true</K> or <K>false</K>.</Returns>
 <Description>
 If <A>digraph</A> is a digraph without multiple edges, then <C>Is2EdgeTransitive</C>
 returns <K>true</K> if <A>digraph</A> is 2-edge transitive, and <K>false</K>
 otherwise. If <A>digraph</A> has multiple edges, then <C>Is2EdgeTransitive</C> returns an error.

 A digraph is <E>2-edge transitive</E> if its automorphism group
 acts transitively on 2-edges via the action
 <Ref Func="OnTuples" BookName="ref"/>. A <E>2-edge</E> in a digraph is a triple (u, v, w) of distinct vertices
 such that (u, v) and (v, w) are edges.
 

 &MUTABLE_RECOMPUTED_PROP;

 <Example><![CDATA[
gap> Is2EdgeTransitive(CompleteDigraph(4));
true
gap> Is2EdgeTransitive(DigraphByEdges([[1, 2], [2, 3], [3, 4]]));
false
gap> Is2EdgeTransitive(CycleDigraph(5));
true
gap> Is2EdgeTransitive(Digraph([[2], [3, 3, 3], []]));
Error, the argument <D> must be a digraph with no multiple edges,
]]></Example>
 </Description>
</ManSection>
<#/GAPDoc>

quality94%

¤ Dauer der Verarbeitung: 0.54 Sekunden (vorverarbeitet) ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.