diff --git a/pymathics/graph/base.py b/pymathics/graph/base.py
index f154221..8cca6ba 100644
--- a/pymathics/graph/base.py
+++ b/pymathics/graph/base.py
@@ -817,13 +817,13 @@ class _PatternList(_NetworkXBuiltin):
     def eval(
         self, graph, expression: Expression, evaluation: Evaluation, options: dict
     ):
-        "%(name)s[graph_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             return ListExpression(*(from_python(q) for q in self._items(graph)))
 
     def eval_patt(self, graph, patt, expression, evaluation, options):
-        "%(name)s[graph_, patt_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, patt_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             return Expression(SymbolCases, ListExpression(*self._items(graph)), patt)
@@ -875,7 +875,7 @@ def _retrieve(self, graph, what, neighbors, expression, evaluation):
             self._not_a_vertex(expression, 2, evaluation)
 
     def eval(self, graph, what, expression, evaluation, options):
-        "%(name)s[graph_, what_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, what_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             G = graph.G.to_undirected()  # FIXME inefficient
@@ -884,7 +884,7 @@ def eval(self, graph, what, expression, evaluation, options):
             )
 
     def eval_d(self, graph, what, d, expression, evaluation, options):
-        "%(name)s[graph_, what_, d_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, what_, d_, OptionsPattern[%(name)s]]"
         py_d = d.to_mpmath()
         if py_d is None:
             return
@@ -967,13 +967,13 @@ class EdgeConnectivity(_NetworkXBuiltin):
     summary_text = "edge connectivity of a graph"
 
     def eval(self, graph, expression, evaluation, options):
-        "%(name)s[graph_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph and not graph.empty():
             return Integer(nx.edge_connectivity(graph.G))
 
     def eval_st(self, graph, s, t, expression, evaluation, options):
-        "%(name)s[graph_, s_, t_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, s_, t_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph and not graph.empty():
             return Integer(nx.edge_connectivity(graph.G, s, t))
@@ -995,7 +995,7 @@ class EdgeIndex(_NetworkXBuiltin):
     summary_text = "find the position of an edge"
 
     def eval(self, graph, v, expression, evaluation, options):
-        "%(name)s[graph_, v_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, v_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             # FIXME: check if directionality must be considered or not.
@@ -1040,7 +1040,7 @@ class EdgeRules(_NetworkXBuiltin):
     summary_text = "list the edge as rules"
 
     def eval(self, graph, expression, evaluation, options):
-        "%(name)s[graph_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
 
@@ -1096,7 +1096,7 @@ class FindShortestPath(_NetworkXBuiltin):
     def eval_s_t(
         self, graph, s, t, expression: Expression, evaluation: Evaluation, options: dict
     ):
-        "FindShortestPath[graph_, s_, t_, OptionsPattern[FindShortestPath]]"
+        "expression: FindShortestPath[graph_, s_, t_, OptionsPattern[FindShortestPath]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if not graph:
             return
@@ -1153,7 +1153,7 @@ class FindVertexCut(_NetworkXBuiltin):
     summary_text = "find the vertex cuts"
 
     def eval(self, graph, expression, evaluation, options):
-        "FindVertexCut[graph_, OptionsPattern[%(name)s]]"
+        "expression: FindVertexCut[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             if graph.empty() or not is_connected(graph.G):
@@ -1164,7 +1164,7 @@ def eval(self, graph, expression, evaluation, options):
                 )
 
     def eval_st(self, graph, s, t, expression, evaluation, options):
-        "FindVertexCut[graph_, s_, t_, OptionsPattern[%(name)s]]"
+        "expression: FindVertexCut[graph_, s_, t_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if not graph:
             return
@@ -1248,7 +1248,7 @@ class HighlightGraph(_NetworkXBuiltin):
     summary_text = "highlight elements in a graph"
 
     def eval(self, graph, what, expression, evaluation, options):
-        "HighlightGraph[graph_, what_List, OptionsPattern[%(name)s]]"
+        "expression: HighlightGraph[graph_, what_List, OptionsPattern[%(name)s]]"
         default_highlight = [Expression(SymbolRGBColor, Integer1, Integer0, Integer0)]
 
         def parse(item):
@@ -1355,7 +1355,7 @@ class VertexAdd(_NetworkXBuiltin):
     summary_text = "add a vertex"
 
     def eval(self, graph: Expression, what, expression, evaluation, options):
-        "VertexAdd[graph_, what_, OptionsPattern[VertexAdd]]"
+        "expression: VertexAdd[graph_, what_, OptionsPattern[VertexAdd]]"
         mathics_graph = self._build_graph(graph, evaluation, options, expression)
         if mathics_graph:
             if what.get_head_name() == "System`List":
@@ -1399,7 +1399,7 @@ class VertexConnectivity(_NetworkXBuiltin):
     summary_text = "vertex connectivity"
 
     def eval(self, graph, expression, evaluation, options):
-        "%(name)s[graph_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph and not graph.empty():
             if not is_connected(graph.G):
@@ -1408,7 +1408,7 @@ def eval(self, graph, expression, evaluation, options):
                 return Integer(nx.node_connectivity(graph.G))
 
     def eval_st(self, graph, s, t, expression, evaluation, options):
-        "%(name)s[graph_, s_, t_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, s_, t_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph and not graph.empty():
             if not is_connected(graph.G):
@@ -1440,7 +1440,7 @@ class VertexDelete(_NetworkXBuiltin):
     summary_text = "remove a vertex"
 
     def eval(self, graph, what, expression, evaluation, options) -> Optional[Graph]:
-        "VertexDelete[graph_, what_, OptionsPattern[VertexDelete]]"
+        "expression: VertexDelete[graph_, what_, OptionsPattern[VertexDelete]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             head_name = what.get_head_name()
@@ -1475,7 +1475,7 @@ class VertexIndex(_NetworkXBuiltin):
     summary_text = "find the position of a vertex"
 
     def eval(self, graph, v, expression, evaluation, options):
-        "%(name)s[graph_, v_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, v_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             try:
@@ -1579,7 +1579,7 @@ class EdgeDelete(_NetworkXBuiltin):
     summary_text = "remove an edge"
 
     def eval(self, graph, what, expression, evaluation, options) -> Optional[Graph]:
-        "EdgeDelete[graph_, what_, OptionsPattern[EdgeDelete]]"
+        "expression: EdgeDelete[graph_, what_, OptionsPattern[EdgeDelete]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             head_name = what.get_head_name()
diff --git a/pymathics/graph/centralities.py b/pymathics/graph/centralities.py
index cbe9310..169b10d 100644
--- a/pymathics/graph/centralities.py
+++ b/pymathics/graph/centralities.py
@@ -96,7 +96,7 @@ class BetweennessCentrality(_Centrality):
     summary_text = "get Betweenness centrality"
 
     def eval(self, graph, expression, evaluation, options):
-        "%(name)s[graph_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             weight = graph.update_weights(evaluation)
@@ -143,7 +143,7 @@ class ClosenessCentrality(_Centrality):
     summary_text = "get the closeness centrality"
 
     def eval(self, graph, expression, evaluation, options):
-        "%(name)s[graph_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             weight = graph.update_weights(evaluation)
@@ -196,19 +196,19 @@ def _from_dict(self, graph, centrality):
         )
 
     def eval(self, graph, expression, evaluation, options):
-        "Pymathics`DegreeCentrality[graph_, OptionsPattern[]]"
+        "expression: Pymathics`DegreeCentrality[graph_, OptionsPattern[]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             return self._from_dict(graph, nx.degree_centrality(graph.G))
 
     def eval_in(self, graph, expression, evaluation, options):
-        '%(name)s[graph_, "In", OptionsPattern[]]'
+        'expression: %(name)s[graph_, "In", OptionsPattern[]]'
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             return self._from_dict(graph, nx.in_degree_centrality(graph.G))
 
     def eval_out(self, graph, expression, evaluation, options):
-        '%(name)s[graph_, "Out", OptionsPattern[]]'
+        'expression: %(name)s[graph_, "Out", OptionsPattern[]]'
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             return self._from_dict(graph, nx.out_degree_centrality(graph.G))
@@ -263,13 +263,13 @@ def _centrality(self, g, weight):
         return nx.eigenvector_centrality(g, max_iter=10000, tol=1.0e-7, weight=weight)
 
     def eval(self, graph, expression, evaluation, options):
-        "%(name)s[graph_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             return self._compute(graph, evaluation)
 
     def eval_in_out(self, graph, dir, expression, evaluation, options):
-        "%(name)s[graph_, dir_String, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, dir_String, OptionsPattern[%(name)s]]"
         py_dir = dir.get_string_value()
         if py_dir not in ("In", "Out"):
             return
@@ -299,7 +299,7 @@ class HITSCentrality(_Centrality):
     summary_text = "get HITS centrality"
 
     def eval(self, graph, expression, evaluation, options):
-        "%(name)s[graph_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             G, _ = graph.coalesced_graph(evaluation)  # FIXME warn if weight > 1
@@ -364,7 +364,7 @@ def _centrality(self, g, weight, alpha, beta):
         )
 
     def eval(self, graph, alpha, beta, expression, evaluation, options):
-        "Pymathics`KatzCentrality[Pymathics`graph_, alpha_, beta_, OptionsPattern[%(name)s]]"
+        "expression: Pymathics`KatzCentrality[Pymathics`graph_, alpha_, beta_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             try:
@@ -407,7 +407,7 @@ class PageRankCentrality(_Centrality):
     summary_text = "get the page rank centralities"
 
     def eval_alpha_beta(self, graph, alpha, expression, evaluation, options):
-        "%(name)s[graph_, alpha_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, alpha_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             py_alpha = float(alpha.to_mpmath())
diff --git a/pymathics/graph/components.py b/pymathics/graph/components.py
index 2850528..a4a8c65 100644
--- a/pymathics/graph/components.py
+++ b/pymathics/graph/components.py
@@ -52,7 +52,7 @@ class ConnectedComponents(_NetworkXBuiltin):
     def eval(
         self, graph, expression, evaluation: Evaluation, options: dict
     ) -> Optional[ListExpression]:
-        "ConnectedComponents[graph_, OptionsPattern[%(name)s]]"
+        "expression: ConnectedComponents[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             connect_fn = (
@@ -123,7 +123,7 @@ class WeaklyConnectedComponents(_NetworkXBuiltin):
     summary_text = "list the weakly connected components"
 
     def eval(self, graph, expression, evaluation: Evaluation, options):
-        "WeaklyConnectedComponents[graph_, OptionsPattern[WeaklyConnectedComponents]]"
+        "expression: WeaklyConnectedComponents[graph_, OptionsPattern[WeaklyConnectedComponents]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             components = nx.connected_components(graph.G.to_undirected())
diff --git a/pymathics/graph/curated.py b/pymathics/graph/curated.py
index b7effcc..3a44c44 100644
--- a/pymathics/graph/curated.py
+++ b/pymathics/graph/curated.py
@@ -28,7 +28,7 @@ class GraphData(_NetworkXBuiltin):
     def eval(
         self, name, expression, evaluation: Evaluation, options: dict
     ) -> Optional[Graph]:
-        "GraphData[name_String, OptionsPattern[GraphData]]"
+        "expression: GraphData[name_String, OptionsPattern[GraphData]]"
         py_name = name.get_string_value()
         fn, layout = WL_TO_NETWORKX_FN.get(py_name, (None, None))
         if not fn:
diff --git a/pymathics/graph/measures_and_metrics.py b/pymathics/graph/measures_and_metrics.py
index 2ae7351..0ceed55 100644
--- a/pymathics/graph/measures_and_metrics.py
+++ b/pymathics/graph/measures_and_metrics.py
@@ -31,7 +31,7 @@ class _PatternCount(_NetworkXBuiltin):
     no_doc = True
 
     def eval(self, graph, expression, evaluation, options) -> Optional[Integer]:
-        "%(name)s[graph_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             return Integer(len(self._items(graph)))
@@ -39,7 +39,7 @@ def eval(self, graph, expression, evaluation, options) -> Optional[Integer]:
     def eval_patt(
         self, graph, patt, expression, evaluation, options
     ) -> Optional[Expression]:
-        "%(name)s[graph_, patt_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, patt_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             return Expression(
@@ -132,7 +132,7 @@ class GraphDistance(_NetworkXBuiltin):
     def eval_s(
         self, graph, s, expression, evaluation: Evaluation, options: dict
     ) -> Optional[ListExpression]:
-        "GraphDistance[graph_, s_, OptionsPattern[GraphDistance]]"
+        "expression: GraphDistance[graph_, s_, OptionsPattern[GraphDistance]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             weight = graph.update_weights(evaluation)
@@ -141,7 +141,7 @@ def eval_s(
             return to_mathics_list(*[d.get(v, inf) for v in graph.vertices])
 
     def eval_s_t(self, graph, s, t, expression, evaluation: Evaluation, options: dict):
-        "GraphDistance[graph_, s_, t_, OptionsPattern[GraphDistance]]"
+        "expression: GraphDistance[graph_, s_, t_, OptionsPattern[GraphDistance]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if not graph:
             return
diff --git a/pymathics/graph/operations.py b/pymathics/graph/operations.py
index 4d344f3..71ce330 100644
--- a/pymathics/graph/operations.py
+++ b/pymathics/graph/operations.py
@@ -40,7 +40,7 @@ class FindSpanningTree(_NetworkXBuiltin):
     summary_text = "find a spanning tree"
 
     def eval(self, graph, expression, evaluation: Evaluation, options: dict):
-        "%(name)s[graph_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if graph:
             graph.update_weights(evaluation)
diff --git a/pymathics/graph/parametric.py b/pymathics/graph/parametric.py
index b28b6dd..7462e98 100644
--- a/pymathics/graph/parametric.py
+++ b/pymathics/graph/parametric.py
@@ -59,7 +59,7 @@ class BalancedTree(_NetworkXBuiltin):
     def eval(
         self, r: Integer, h: Integer, expression, evaluation: Evaluation, options: dict
     ) -> Optional[Graph]:
-        "%(name)s[r_Integer, h_Integer, OptionsPattern[%(name)s]]"
+        "expression:%(name)s[r_Integer, h_Integer, OptionsPattern[%(name)s]]"
         py_r = r.value
 
         if py_r < 0:
@@ -113,7 +113,7 @@ def eval(
         evaluation: Evaluation,
         options: dict,
     ) -> Optional[Graph]:
-        "BarbellGraph[m1_Integer, m2_Integer, OptionsPattern[BarbellGraph]]"
+        "expression: BarbellGraph[m1_Integer, m2_Integer, OptionsPattern[BarbellGraph]]"
         py_m1 = m1.value
 
         if py_m1 < 0:
@@ -179,7 +179,7 @@ class BinomialTree(_NetworkXBuiltin):
     def eval(
         self, n: Integer, expression, evaluation: Evaluation, options: dict
     ) -> Optional[Graph]:
-        "%(name)s[n_Integer, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[n_Integer, OptionsPattern[%(name)s]]"
         py_n = n.value
 
         if py_n < 0:
@@ -221,7 +221,7 @@ class CompleteGraph(_NetworkXBuiltin):
     summary_text = "build a completely-connected graph"
 
     def eval(self, n: Integer, expression, evaluation: Evaluation, options: dict):
-        "CompleteGraph[n_Integer, OptionsPattern[CompleteGraph]]"
+        "expression: CompleteGraph[n_Integer, OptionsPattern[CompleteGraph]]"
         return eval_complete_graph(self, n, expression, evaluation, options)
 
     def eval_multipartite(
@@ -265,7 +265,7 @@ class CompleteKaryTree(_NetworkXBuiltin):
     def eval(
         self, k: Integer, n: Integer, expression, evaluation: Evaluation, options: dict
     ):
-        "CompleteKaryTree[n_Integer, k_Integer, OptionsPattern[CompleteKaryTree]]"
+        "expression: CompleteKaryTree[n_Integer, k_Integer, OptionsPattern[CompleteKaryTree]]"
 
         n_int = n.value
         k_int = k.value
@@ -277,7 +277,7 @@ def eval(
 
     # FIXME: can be done with rules?
     def eval_2(self, n: Integer, expression, evaluation: Evaluation, options: dict):
-        "CompleteKaryTree[n_Integer, OptionsPattern[CompleteKaryTree]]"
+        "expression: CompleteKaryTree[n_Integer, OptionsPattern[CompleteKaryTree]]"
 
         n_int = n.value
 
@@ -308,7 +308,7 @@ class CycleGraph(_NetworkXBuiltin):
     def eval(
         self, n: Integer, expression, evaluation: Evaluation, options: dict
     ) -> Optional[Graph]:
-        "CycleGraph[n_Integer, OptionsPattern[CycleGraph]]"
+        "expression: CycleGraph[n_Integer, OptionsPattern[CycleGraph]]"
         n_int = n.value
         if n_int < 3:
             return eval_complete_graph(self, n, expression, evaluation, options)
@@ -342,7 +342,7 @@ class GraphAtlas(_NetworkXBuiltin):
     def eval(
         self, n: Integer, expression, evaluation: Evaluation, options: dict
     ) -> Optional[Graph]:
-        "GraphAtlas[n_Integer, OptionsPattern[GraphAtlas]]"
+        "expression: GraphAtlas[n_Integer, OptionsPattern[GraphAtlas]]"
         py_n = n.value
 
         if py_n < 1:
@@ -391,7 +391,7 @@ class HknHararyGraph(_NetworkXBuiltin):
     summary_text = "build a Hkn Harary graph"
 
     def eval(self, k, n, expression, evaluation: Evaluation, options: dict):
-        "%(name)s[k_Integer, n_Integer, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[k_Integer, n_Integer, OptionsPattern[%(name)s]]"
         return eval_hkn_harary(self, k, n, expression, evaluation, options)
 
 
@@ -430,7 +430,7 @@ class HmnHararyGraph(_NetworkXBuiltin):
     def eval(
         self, n: Integer, m: Integer, expression, evaluation: Evaluation, options: dict
     ) -> Optional[Graph]:
-        "%(name)s[n_Integer, m_Integer, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[n_Integer, m_Integer, OptionsPattern[%(name)s]]"
         py_n = n.value
 
         if py_n < 0:
@@ -490,13 +490,13 @@ class KaryTree(_NetworkXBuiltin):
     def eval(
         self, n: Integer, expression, evaluation: Evaluation, options: dict
     ) -> Optional[Graph]:
-        "KaryTree[n_Integer, OptionsPattern[KaryTree]]"
+        "expression: KaryTree[n_Integer, OptionsPattern[KaryTree]]"
         return eval_full_rary_tree(self, Integer2, n, expression, evaluation, options)
 
     def eval_with_k(
         self, n: Integer, k: Integer, expression, evaluation: Evaluation, options: dict
     ) -> Optional[Graph]:
-        "KaryTree[n_Integer, k_Integer, OptionsPattern[KaryTree]]"
+        "expression: KaryTree[n_Integer, k_Integer, OptionsPattern[KaryTree]]"
         return eval_full_rary_tree(self, k, n, expression, evaluation, options)
 
 
@@ -525,7 +525,7 @@ class LadderGraph(_NetworkXBuiltin):
     def eval(
         self, n: Integer, expression, evaluation: Evaluation, options: dict
     ) -> Optional[Graph]:
-        "LadderGraph[n_Integer, OptionsPattern[LadderGraph]]"
+        "expression: LadderGraph[n_Integer, OptionsPattern[LadderGraph]]"
         py_n = n.value
 
         if py_n < 1:
@@ -602,7 +602,7 @@ class RandomTree(_NetworkXBuiltin):
     def eval(
         self, n: Integer, expression, evaluation: Evaluation, options: dict
     ) -> Optional[Graph]:
-        "RandomTree[n_Integer, OptionsPattern[RandomTree]]"
+        "expression: RandomTree[n_Integer, OptionsPattern[RandomTree]]"
         py_n = n.value
 
         if py_n < 0:
@@ -646,7 +646,7 @@ class StarGraph(_NetworkXBuiltin):
     def eval(
         self, n: Integer, expression, evaluation: Evaluation, options: dict
     ) -> Optional[Graph]:
-        "StarGraph[n_Integer, OptionsPattern[StarGraph]]"
+        "expression: StarGraph[n_Integer, OptionsPattern[StarGraph]]"
         py_n = n.value
 
         if py_n < 1:
diff --git a/pymathics/graph/properties.py b/pymathics/graph/properties.py
index 7d85b19..82e14f4 100644
--- a/pymathics/graph/properties.py
+++ b/pymathics/graph/properties.py
@@ -53,7 +53,7 @@ class AcyclicGraphQ(_NetworkXBuiltin):
     summary_text = "test if is a graph is acyclic"
 
     def eval(self, graph, expression, evaluation: Evaluation, options: dict):
-        "AcyclicGraphQ[graph_, OptionsPattern[AcyclicGraphQ]]"
+        "expression: AcyclicGraphQ[graph_, OptionsPattern[AcyclicGraphQ]]"
         graph = self._build_graph(graph, evaluation, options, expression, quiet=False)
         if not graph or graph.empty():
             return SymbolFalse
@@ -112,7 +112,7 @@ class ConnectedGraphQ(_NetworkXBuiltin):
     summary_text = "test if a graph is a connected"
 
     def eval(self, graph, expression, evaluation: Evaluation, options: dict):
-        "%(name)s[graph_, OptionsPattern[%(name)s]]"
+        "expression: %(name)s[graph_, OptionsPattern[%(name)s]]"
         graph = self._build_graph(graph, evaluation, options, expression, quiet=True)
         if graph:
             return from_python(is_connected(graph.G))
@@ -154,7 +154,7 @@ class DirectedGraphQ(_NetworkXBuiltin):
     summary_text = "test if a graph is directed"
 
     def eval(self, graph, expression, evaluation: Evaluation, options: dict):
-        "DirectedGraphQ[graph_, OptionsPattern[DirectedGraphQ]]"
+        "expression: DirectedGraphQ[graph_, OptionsPattern[DirectedGraphQ]]"
         graph = self._build_graph(graph, evaluation, options, expression, quiet=True)
         if graph:
             return from_python(graph.is_directed())
@@ -182,7 +182,7 @@ class GraphQ(_NetworkXBuiltin):
     summary_text = "test object is a graph"
 
     def eval(self, graph, expression, evaluation: Evaluation, options: dict):
-        "GraphQ[graph_, OptionsPattern[GraphQ]]"
+        "expression: GraphQ[graph_, OptionsPattern[GraphQ]]"
         graph = self._build_graph(graph, evaluation, options, expression, quiet=True)
         return SymbolTrue if graph else SymbolFalse
 
@@ -221,7 +221,7 @@ class LoopFreeGraphQ(_NetworkXBuiltin):
     summary_text = "test if a graph is loop free"
 
     def eval(self, graph, expression, evaluation: Evaluation, options: dict):
-        "LoopFreeGraphQ[graph_, OptionsPattern[LoopFreeGraphQ]]"
+        "expression: LoopFreeGraphQ[graph_, OptionsPattern[LoopFreeGraphQ]]"
         graph = self._build_graph(graph, evaluation, options, expression, quiet=True)
         if not graph or graph.empty():
             return SymbolFalse
@@ -266,7 +266,7 @@ class MixedGraphQ(_NetworkXBuiltin):
     summary_text = "test if a graph has directed and undirected edges"
 
     def eval(self, graph, expression, evaluation: Evaluation, options: dict):
-        "MixedGraphQ[graph_, OptionsPattern[MixedGraphQ]]"
+        "expression: MixedGraphQ[graph_, OptionsPattern[MixedGraphQ]]"
         graph = self._build_graph(graph, evaluation, options, expression, quiet=True)
         if graph:
             return from_python(graph.is_mixed_graph())
@@ -307,7 +307,7 @@ class MultigraphQ(_NetworkXBuiltin):
     summary_text = "test if a graph is a multi graph"
 
     def eval(self, graph, expression, evaluation: Evaluation, options: dict):
-        "MultigraphQ[graph_, OptionsPattern[MultigraphQ]]"
+        "expression: MultigraphQ[graph_, OptionsPattern[MultigraphQ]]"
         graph = self._build_graph(graph, evaluation, options, expression, quiet=True)
         if graph:
             return from_python(graph.is_multigraph())
@@ -365,7 +365,7 @@ class PathGraphQ(_NetworkXBuiltin):
     summary_text = "test if a graph is a path-like graph"
 
     def eval(self, graph, expression, evaluation: Evaluation, options: dict):
-        "PathGraphQ[graph_, OptionsPattern[PathGraphQ]]"
+        "expression: PathGraphQ[graph_, OptionsPattern[PathGraphQ]]"
         if not isinstance(graph, Graph) or graph.empty():
             return SymbolFalse
 
@@ -420,7 +420,7 @@ class PlanarGraphQ(_NetworkXBuiltin):
     summary_text = "test if a graph is planar"
 
     def eval(self, graph, expression, evaluation: Evaluation, options: dict):
-        "Pymathics`PlanarGraphQ[graph_, OptionsPattern[PlanarGraphQ]]"
+        "expression: Pymathics`PlanarGraphQ[graph_, OptionsPattern[PlanarGraphQ]]"
         graph = self._build_graph(graph, evaluation, options, expression)
         if not graph or graph.empty():
             return SymbolFalse
@@ -462,7 +462,7 @@ class SimpleGraphQ(_NetworkXBuiltin):
     summary_text = "test if a graph is simple (not multigraph)"
 
     def eval(self, graph, expression, evaluation: Evaluation, options: dict):
-        "SimpleGraphQ[graph_, OptionsPattern[LoopFreeGraphQ]]"
+        "expression: SimpleGraphQ[graph_, OptionsPattern[LoopFreeGraphQ]]"
         graph = self._build_graph(graph, evaluation, options, expression, quiet=True)
         if graph:
             if graph.empty():
diff --git a/pymathics/graph/tree.py b/pymathics/graph/tree.py
index 863a33f..0318330 100644
--- a/pymathics/graph/tree.py
+++ b/pymathics/graph/tree.py
@@ -104,5 +104,5 @@ class TreeGraphQ(_NetworkXBuiltin):
     def eval(
         self, g, expression, evaluation: Evaluation, options: dict
     ) -> SymbolConstant:
-        "TreeGraphQ[g_, OptionsPattern[%(name)s]]"
+        "expression: TreeGraphQ[g_, OptionsPattern[%(name)s]]"
         return eval_TreeGraphQ(g)