gh-36571: Add method to check whether a (di)graph is geodetic
    
A (di)graph is geodetic if there exists only one shortest path between
any pair of its vertices. We add a method to check this property on
unweighted (di)graphs.

### 📝 Checklist

- [x] The title is concise, informative, and self-explanatory.
- [x] The description explains in detail what this PR is about.
- [ ] I have linked a relevant issue or discussion.
- [x] I have created tests covering the changes.
- [x] I have updated the documentation accordingly.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on
- #12345: short description why this is a dependency
- #34567: ...
-->

<!-- If you're unsure about any of these, don't hesitate to ask. We're
here to help! -->
    
URL: #36571
Reported by: David Coudert
Reviewer(s): David Coudert, Kwankyu Lee

Author: Release Manager

src/sage/graphs/convexity_properties.pyx

@@ -13,13 +13,10 @@ the following methods:
     :meth:`ConvexityProperties.hull` | Return the convex hull of a set of vertices
     :meth:`ConvexityProperties.hull_number` | Compute the hull number of a graph and a corresponding generating set
     :meth:`geodetic_closure`| Return the geodetic closure of a set of vertices
+    :meth:`is_geodetic` | Check whether the input (di)graph is geodetic
 
-These methods can be used through the :class:`ConvexityProperties` object
-returned by :meth:`Graph.convexity_properties`.
-
-AUTHORS:
-
-    -  Nathann Cohen
+Some of these methods can be used through the :class:`ConvexityProperties`
+object returned by :meth:`Graph.convexity_properties`.
 
 Methods
 -------
@@ -674,3 +671,156 @@ def geodetic_closure(G, S):
     free_short_digraph(sd)
 
     return ret
+
+
+def is_geodetic(G):
+    r"""
+    Check whether the input (di)graph is geodetic.
+
+    A graph `G` is *geodetic* if there exists only one shortest path between
+    every pair of its vertices. This can be checked in time `O(nm)` in
+    unweighted (di)graphs with `n` nodes and `m` edges. Examples of geodetic
+    graphs are trees, cliques and odd cycles. See the
+    :wikipedia:`Geodetic_graph` for more details.
+
+    (Di)graphs with multiple edges are not considered geodetic.
+
+    INPUT:
+
+    - ``G`` -- a graph or a digraph
+
+    EXAMPLES:
+
+    Trees, cliques and odd cycles are geodetic::
+
+        sage: T = graphs.RandomTree(20)
+        sage: T.is_geodetic()
+        True
+        sage: all(graphs.CompleteGraph(n).is_geodetic() for n in range(8))
+        True
+        sage: all(graphs.CycleGraph(n).is_geodetic() for n in range(3, 16, 2))
+        True
+
+    Even cycles of order at least 4 are not geodetic::
+
+        sage: all(graphs.CycleGraph(n).is_geodetic() for n in range(4, 17, 2))
+        False
+
+    The Petersen graph is geodetic::
+
+        sage: P = graphs.PetersenGraph()
+        sage: P.is_geodetic()
+        True
+
+    Grid graphs are not geodetic::
+
+        sage: G = graphs.Grid2dGraph(2, 3)
+        sage: G.is_geodetic()
+        False
+
+    This method is also valid for digraphs::
+
+        sage: G = DiGraph(graphs.PetersenGraph())
+        sage: G.is_geodetic()
+        True
+        sage: G = digraphs.Path(5)
+        sage: G.add_path([0, 'a', 'b', 'c', 4])
+        sage: G.is_geodetic()
+        False
+
+    TESTS::
+
+        sage: all(g.is_geodetic() for g in graphs(3))
+        True
+        sage: all((2*g).is_geodetic() for g in graphs(3))
+        True
+        sage: G = graphs.CycleGraph(5)
+        sage: G.allow_loops(True)
+        sage: G.add_edges([(u, u) for u in G])
+        sage: G.is_geodetic()
+        True
+        sage: G.allow_multiple_edges(True)
+        sage: G.is_geodetic()
+        True
+        sage: G.add_edge(G.random_edge())
+        sage: G.is_geodetic()
+        False
+    """
+    if G.has_multiple_edges():
+        return False
+
+    if G.order() < 4:
+        return True
+
+    # Copy the graph as a short digraph
+    cdef int n = G.order()
+    cdef short_digraph sd
+    init_short_digraph(sd, G, edge_labelled=False, vertex_list=list(G))
+
+    # Allocate some data structures
+    cdef MemoryAllocator mem = MemoryAllocator()
+    cdef uint32_t * distances = <uint32_t *> mem.malloc(n * sizeof(uint32_t))
+    cdef uint32_t * waiting_list = <uint32_t *> mem.malloc(n * sizeof(uint32_t))
+    if not distances or not waiting_list:
+        free_short_digraph(sd)
+        raise MemoryError()
+    cdef bitset_t seen
+    bitset_init(seen, n)
+
+    # We now explore geodesics between vertices in S, and we avoid visiting
+    # twice the geodesics between u and v
+
+    cdef uint32_t source, u, v
+    cdef uint32_t waiting_beginning
+    cdef uint32_t waiting_end
+    cdef uint32_t * p_tmp
+    cdef uint32_t * end
+    cdef uint32_t ** p_vertices = sd.neighbors
+
+    for source in range(n):
+
+        # Compute distances from source using BFS
+        bitset_clear(seen)
+        bitset_add(seen, source)
+        distances[source] = 0
+        waiting_beginning = 0
+        waiting_end = 0
+        waiting_list[waiting_beginning] = source
+
+        # For as long as there are vertices left to explore
+        while waiting_beginning <= waiting_end:
+
+            # We pick the first one
+            v = waiting_list[waiting_beginning]
+            p_tmp = p_vertices[v]
+            end = p_vertices[v + 1]
+
+            # and we iterate over all the outneighbors u of v
+            while p_tmp < end:
+                u = p_tmp[0]
+
+                # If we notice one of these neighbors is not seen yet, we set
+                # its parameters and add it to the queue to be explored later.
+                # Otherwise, we check whether we have detected a second shortest
+                # path between source and v.
+                if not bitset_in(seen, u):
+                    distances[u] = distances[v] + 1
+                    bitset_add(seen, u)
+                    waiting_end += 1
+                    waiting_list[waiting_end] = u
+                elif distances[u] == distances[v] + 1:
+                    # G is not geodetic
+                    bitset_free(seen)
+                    free_short_digraph(sd)
+                    return False
+
+                p_tmp += 1
+
+            # We go to the next vertex in the queue
+            waiting_beginning += 1
+
+    bitset_free(seen)
+    free_short_digraph(sd)
+
+    # The graph is geodetic
+    return True

src/sage/graphs/generic_graph.py

@@ -185,6 +185,7 @@
     :meth:`~GenericGraph.is_gallai_tree` | Return whether the current graph is a Gallai tree.
     :meth:`~GenericGraph.is_clique` | Check whether a set of vertices is a clique
     :meth:`~GenericGraph.is_cycle` | Check whether ``self`` is a (directed) cycle graph.
+    :meth:`~GenericGraph.is_geodetic` | Check whether the input (di)graph is geodetic.
     :meth:`~GenericGraph.is_independent_set` | Check whether ``vertices`` is an independent set of ``self``
     :meth:`~GenericGraph.is_transitively_reduced` | Test whether the digraph is transitively reduced.
     :meth:`~GenericGraph.is_equitable` | Check whether the given partition is equitable with respect to self.
@@ -24415,6 +24416,7 @@ def is_self_complementary(self):
     from sage.graphs.traversals import lex_UP
     from sage.graphs.traversals import lex_DFS
     from sage.graphs.traversals import lex_DOWN
+    is_geodetic = LazyImport('sage.graphs.convexity_properties', 'is_geodetic')
 
     def katz_matrix(self, alpha, nonedgesonly=False, vertices=None):
         r"""