diff --git a/doc/min_cost_flow.dox b/doc/min_cost_flow.dox
--- a/doc/min_cost_flow.dox
+++ b/doc/min_cost_flow.dox
@@ -78,7 +78,7 @@
    - if \f$lower(uv)<f(uv)<upper(uv)\f$, then \f$cost^\pi(uv)=0\f$;
    - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.
  - For all \f$u\in V\f$ nodes:
-   - \f$\pi(u)<=0\f$;
+   - \f$\pi(u)\leq 0\f$;
    - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
      then \f$\pi(u)=0\f$.
  
@@ -145,7 +145,7 @@
    - if \f$lower(uv)<f(uv)<upper(uv)\f$, then \f$cost^\pi(uv)=0\f$;
    - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.
  - For all \f$u\in V\f$ nodes:
-   - \f$\pi(u)>=0\f$;
+   - \f$\pi(u)\geq 0\f$;
    - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
      then \f$\pi(u)=0\f$.
 
diff --git a/lemon/bellman_ford.h b/lemon/bellman_ford.h
--- a/lemon/bellman_ford.h
+++ b/lemon/bellman_ford.h
@@ -300,7 +300,7 @@
     ///
     /// \ref named-templ-param "Named parameter" for setting
     /// \c OperationTraits type.
-    /// For more information see \ref BellmanFordDefaultOperationTraits.
+    /// For more information, see \ref BellmanFordDefaultOperationTraits.
     template <class T>
     struct SetOperationTraits
       : public BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> > {
@@ -718,7 +718,7 @@
     /// is not reached from the root(s) or if \c v is a root.
     ///
     /// The shortest path tree used here is equal to the shortest path
-    /// tree used in \ref predNode() and \predMap().
+    /// tree used in \ref predNode() and \ref predMap().
     ///
     /// \pre Either \ref run() or \ref init() must be called before
     /// using this function.
@@ -733,7 +733,7 @@
     /// is not reached from the root(s) or if \c v is a root.
     ///
     /// The shortest path tree used here is equal to the shortest path
-    /// tree used in \ref predArc() and \predMap().
+    /// tree used in \ref predArc() and \ref predMap().
     ///
     /// \pre Either \ref run() or \ref init() must be called before
     /// using this function.
diff --git a/lemon/bfs.h b/lemon/bfs.h
--- a/lemon/bfs.h
+++ b/lemon/bfs.h
@@ -63,7 +63,7 @@
 
     ///The type of the map that indicates which nodes are processed.
     ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default it is a NullMap.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
 
@@ -848,7 +848,7 @@
 
     ///The type of the map that indicates which nodes are processed.
     ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default it is a NullMap.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.
 
diff --git a/lemon/circulation.h b/lemon/circulation.h
--- a/lemon/circulation.h
+++ b/lemon/circulation.h
@@ -306,7 +306,7 @@
     /// The Elevator should have standard constructor interface to be
     /// able to automatically created by the algorithm (i.e. the
     /// digraph and the maximum level should be passed to it).
-    /// However an external elevator object could also be passed to the
+    /// However, an external elevator object could also be passed to the
     /// algorithm with the \ref elevator(Elevator&) "elevator()" function
     /// before calling \ref run() or \ref init().
     /// \sa SetElevator
diff --git a/lemon/concepts/digraph.h b/lemon/concepts/digraph.h
--- a/lemon/concepts/digraph.h
+++ b/lemon/concepts/digraph.h
@@ -107,7 +107,7 @@
       /// Iterator class for the nodes.
 
       /// This iterator goes through each node of the digraph.
-      /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of nodes in a digraph \c g of type \c %Digraph like this:
       ///\code
       /// int count=0;
@@ -196,7 +196,7 @@
 
       /// This iterator goes trough the \e outgoing arcs of a certain node
       /// of a digraph.
-      /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of outgoing arcs of a node \c n
       /// in a digraph \c g of type \c %Digraph as follows.
       ///\code
@@ -241,7 +241,7 @@
 
       /// This iterator goes trough the \e incoming arcs of a certain node
       /// of a digraph.
-      /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of incoming arcs of a node \c n
       /// in a digraph \c g of type \c %Digraph as follows.
       ///\code
@@ -285,7 +285,7 @@
       /// Iterator class for the arcs.
 
       /// This iterator goes through each arc of the digraph.
-      /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of arcs in a digraph \c g of type \c %Digraph as follows:
       ///\code
       /// int count=0;
diff --git a/lemon/concepts/graph.h b/lemon/concepts/graph.h
--- a/lemon/concepts/graph.h
+++ b/lemon/concepts/graph.h
@@ -140,7 +140,7 @@
       /// Iterator class for the nodes.
 
       /// This iterator goes through each node of the graph.
-      /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of nodes in a graph \c g of type \c %Graph like this:
       ///\code
       /// int count=0;
@@ -228,7 +228,7 @@
       /// Iterator class for the edges.
 
       /// This iterator goes through each edge of the graph.
-      /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of edges in a graph \c g of type \c %Graph as follows:
       ///\code
       /// int count=0;
@@ -272,7 +272,7 @@
 
       /// This iterator goes trough the incident undirected edges
       /// of a certain node of a graph.
-      /// Its usage is quite simple, for example you can compute the
+      /// Its usage is quite simple, for example, you can compute the
       /// degree (i.e. the number of incident edges) of a node \c n
       /// in a graph \c g of type \c %Graph as follows.
       ///
@@ -369,7 +369,7 @@
       /// Iterator class for the arcs.
 
       /// This iterator goes through each directed arc of the graph.
-      /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of arcs in a graph \c g of type \c %Graph as follows:
       ///\code
       /// int count=0;
@@ -413,7 +413,7 @@
 
       /// This iterator goes trough the \e outgoing directed arcs of a
       /// certain node of a graph.
-      /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of outgoing arcs of a node \c n
       /// in a graph \c g of type \c %Graph as follows.
       ///\code
@@ -461,7 +461,7 @@
 
       /// This iterator goes trough the \e incoming directed arcs of a
       /// certain node of a graph.
-      /// Its usage is quite simple, for example you can count the number
+      /// Its usage is quite simple, for example, you can count the number
       /// of incoming arcs of a node \c n
       /// in a graph \c g of type \c %Graph as follows.
       ///\code
@@ -587,7 +587,7 @@
       ///
       /// Returns the first node of the given edge.
       ///
-      /// Edges don't have source and target nodes, however methods
+      /// Edges don't have source and target nodes, however, methods
       /// u() and v() are used to query the two end-nodes of an edge.
       /// The orientation of an edge that arises this way is called
       /// the inherent direction, it is used to define the default
@@ -600,7 +600,7 @@
       ///
       /// Returns the second node of the given edge.
       ///
-      /// Edges don't have source and target nodes, however methods
+      /// Edges don't have source and target nodes, however, methods
       /// u() and v() are used to query the two end-nodes of an edge.
       /// The orientation of an edge that arises this way is called
       /// the inherent direction, it is used to define the default
diff --git a/lemon/concepts/graph_components.h b/lemon/concepts/graph_components.h
--- a/lemon/concepts/graph_components.h
+++ b/lemon/concepts/graph_components.h
@@ -18,7 +18,7 @@
 
 ///\ingroup graph_concepts
 ///\file
-///\brief The concept of graph components.
+///\brief The concepts of graph components.
 
 #ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
 #define LEMON_CONCEPTS_GRAPH_COMPONENTS_H
diff --git a/lemon/concepts/path.h b/lemon/concepts/path.h
--- a/lemon/concepts/path.h
+++ b/lemon/concepts/path.h
@@ -18,7 +18,7 @@
 
 ///\ingroup concept
 ///\file
-///\brief Classes for representing paths in digraphs.
+///\brief The concept of paths
 ///
 
 #ifndef LEMON_CONCEPTS_PATH_H
@@ -38,13 +38,22 @@
     ///
     /// A skeleton structure for representing directed paths in a
     /// digraph.
+    /// In a sense, a path can be treated as a list of arcs.
+    /// LEMON path types just store this list. As a consequence, they cannot
+    /// enumerate the nodes on the path directly and a zero length path
+    /// cannot store its source node.
+    ///
+    /// The arcs of a path should be stored in the order of their directions,
+    /// i.e. the target node of each arc should be the same as the source
+    /// node of the next arc. This consistency could be checked using
+    /// \ref checkPath().
+    /// The source and target nodes of a (consistent) path can be obtained
+    /// using \ref pathSource() and \ref pathTarget().
+    ///
+    /// A path can be constructed from another path of any type using the
+    /// copy constructor or the assignment operator.
+    ///
     /// \tparam GR The digraph type in which the path is.
-    ///
-    /// In a sense, the path can be treated as a list of arcs. The
-    /// lemon path type stores just this list. As a consequence it
-    /// cannot enumerate the nodes in the path and the zero length
-    /// paths cannot store the source.
-    ///
     template <typename GR>
     class Path {
     public:
@@ -59,18 +68,18 @@
       /// \brief Default constructor
       Path() {}
 
-      /// \brief Template constructor
+      /// \brief Template copy constructor
       template <typename CPath>
       Path(const CPath& cpath) {}
 
-      /// \brief Template assigment
+      /// \brief Template assigment operator
       template <typename CPath>
       Path& operator=(const CPath& cpath) {
         ignore_unused_variable_warning(cpath);
         return *this;
       }
 
-      /// Length of the path ie. the number of arcs in the path.
+      /// Length of the path, i.e. the number of arcs on the path.
       int length() const { return 0;}
 
       /// Returns whether the path is empty.
@@ -79,19 +88,19 @@
       /// Resets the path to an empty path.
       void clear() {}
 
-      /// \brief LEMON style iterator for path arcs
+      /// \brief LEMON style iterator for enumerating the arcs of a path.
       ///
-      /// This class is used to iterate on the arcs of the paths.
+      /// LEMON style iterator class for enumerating the arcs of a path.
       class ArcIt {
       public:
         /// Default constructor
         ArcIt() {}
         /// Invalid constructor
         ArcIt(Invalid) {}
-        /// Constructor for first arc
+        /// Sets the iterator to the first arc of the given path
         ArcIt(const Path &) {}
 
-        /// Conversion to Arc
+        /// Conversion to \c Arc
         operator Arc() const { return INVALID; }
 
         /// Next arc
@@ -192,24 +201,18 @@
     /// \brief A skeleton structure for path dumpers.
     ///
     /// A skeleton structure for path dumpers. The path dumpers are
-    /// the generalization of the paths. The path dumpers can
-    /// enumerate the arcs of the path wheter in forward or in
-    /// backward order.  In most time these classes are not used
-    /// directly rather it used to assign a dumped class to a real
-    /// path type.
+    /// the generalization of the paths, they can enumerate the arcs
+    /// of the path either in forward or in backward order.
+    /// These classes are typically not used directly, they are rather
+    /// used to be assigned to a real path type.
     ///
     /// The main purpose of this concept is that the shortest path
-    /// algorithms can enumerate easily the arcs in reverse order.
-    /// If we would like to give back a real path from these
-    /// algorithms then we should create a temporarly path object. In
-    /// LEMON such algorithms gives back a path dumper what can
-    /// assigned to a real path and the dumpers can be implemented as
+    /// algorithms can enumerate the arcs easily in reverse order.
+    /// In LEMON, such algorithms give back a (reverse) path dumper that
+    /// can be assigned to a real path. The dumpers can be implemented as
     /// an adaptor class to the predecessor map.
     ///
     /// \tparam GR The digraph type in which the path is.
-    ///
-    /// The paths can be constructed from any path type by a
-    /// template constructor or a template assignment operator.
     template <typename GR>
     class PathDumper {
     public:
@@ -219,7 +222,7 @@
       /// Arc type of the underlying digraph.
       typedef typename Digraph::Arc Arc;
 
-      /// Length of the path ie. the number of arcs in the path.
+      /// Length of the path, i.e. the number of arcs on the path.
       int length() const { return 0;}
 
       /// Returns whether the path is empty.
@@ -227,25 +230,24 @@
 
       /// \brief Forward or reverse dumping
       ///
-      /// If the RevPathTag is defined and true then reverse dumping
-      /// is provided in the path dumper. In this case instead of the
-      /// ArcIt the RevArcIt iterator should be implemented in the
-      /// dumper.
+      /// If this tag is defined to be \c True, then reverse dumping
+      /// is provided in the path dumper. In this case, \c RevArcIt
+      /// iterator should be implemented instead of \c ArcIt iterator.
       typedef False RevPathTag;
 
-      /// \brief LEMON style iterator for path arcs
+      /// \brief LEMON style iterator for enumerating the arcs of a path.
       ///
-      /// This class is used to iterate on the arcs of the paths.
+      /// LEMON style iterator class for enumerating the arcs of a path.
       class ArcIt {
       public:
         /// Default constructor
         ArcIt() {}
         /// Invalid constructor
         ArcIt(Invalid) {}
-        /// Constructor for first arc
+        /// Sets the iterator to the first arc of the given path
         ArcIt(const PathDumper&) {}
 
-        /// Conversion to Arc
+        /// Conversion to \c Arc
         operator Arc() const { return INVALID; }
 
         /// Next arc
@@ -260,20 +262,21 @@
 
       };
 
-      /// \brief LEMON style iterator for path arcs
+      /// \brief LEMON style iterator for enumerating the arcs of a path
+      /// in reverse direction.
       ///
-      /// This class is used to iterate on the arcs of the paths in
-      /// reverse direction.
+      /// LEMON style iterator class for enumerating the arcs of a path
+      /// in reverse direction.
       class RevArcIt {
       public:
         /// Default constructor
         RevArcIt() {}
         /// Invalid constructor
         RevArcIt(Invalid) {}
-        /// Constructor for first arc
+        /// Sets the iterator to the last arc of the given path
         RevArcIt(const PathDumper &) {}
 
-        /// Conversion to Arc
+        /// Conversion to \c Arc
         operator Arc() const { return INVALID; }
 
         /// Next arc
diff --git a/lemon/counter.h b/lemon/counter.h
--- a/lemon/counter.h
+++ b/lemon/counter.h
@@ -212,7 +212,7 @@
 
   /// 'Do nothing' version of Counter.
 
-  /// This class can be used in the same way as \ref Counter however it
+  /// This class can be used in the same way as \ref Counter, but it
   /// does not count at all and does not print report on destruction.
   ///
   /// Replacing a \ref Counter with a \ref NoCounter makes it possible
diff --git a/lemon/dfs.h b/lemon/dfs.h
--- a/lemon/dfs.h
+++ b/lemon/dfs.h
@@ -63,7 +63,7 @@
 
     ///The type of the map that indicates which nodes are processed.
     ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default it is a NullMap.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
 
@@ -778,7 +778,7 @@
 
     ///The type of the map that indicates which nodes are processed.
     ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default it is a NullMap.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.
 
diff --git a/lemon/dijkstra.h b/lemon/dijkstra.h
--- a/lemon/dijkstra.h
+++ b/lemon/dijkstra.h
@@ -132,7 +132,7 @@
 
     ///The type of the map that indicates which nodes are processed.
     ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default it is a NullMap.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
 
@@ -426,7 +426,7 @@
     ///automatically created by the algorithm (i.e. the digraph should be
     ///passed to the constructor of the cross reference and the cross
     ///reference should be passed to the constructor of the heap).
-    ///However external heap and cross reference objects could also be
+    ///However, external heap and cross reference objects could also be
     ///passed to the algorithm using the \ref heap() function before
     ///calling \ref run(Node) "run()" or \ref init().
     ///\sa SetHeap
@@ -447,7 +447,7 @@
     ///
     ///\ref named-templ-param "Named parameter" for setting
     ///\c OperationTraits type.
-    /// For more information see \ref DijkstraDefaultOperationTraits.
+    /// For more information, see \ref DijkstraDefaultOperationTraits.
     template <class T>
     struct SetOperationTraits
       : public Dijkstra<Digraph, LengthMap, SetOperationTraitsTraits<T> > {
@@ -996,7 +996,7 @@
 
     ///The type of the map that indicates which nodes are processed.
     ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default it is a NullMap.
+    ///By default, it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.
 
diff --git a/lemon/gomory_hu.h b/lemon/gomory_hu.h
--- a/lemon/gomory_hu.h
+++ b/lemon/gomory_hu.h
@@ -294,11 +294,9 @@
     ///
     /// \pre \ref run() must be called before using this function.
     template <typename CutMap>
-    Value minCutMap(const Node& s, ///< 
+    Value minCutMap(const Node& s,
                     const Node& t,
-                    ///< 
                     CutMap& cutMap
-                    ///< 
                     ) const {
       Node sn = s, tn = t;
       bool s_root=false;
@@ -394,7 +392,7 @@
                    /// MinCutNodeIt(gomory, t, s, false);
                    /// \endcode
                    /// does not necessarily give the same set of nodes.
-                   /// However it is ensured that
+                   /// However, it is ensured that
                    /// \code
                    /// MinCutNodeIt(gomory, s, t, true);
                    /// \endcode
diff --git a/lemon/graph_to_eps.h b/lemon/graph_to_eps.h
--- a/lemon/graph_to_eps.h
+++ b/lemon/graph_to_eps.h
@@ -142,7 +142,7 @@
   ///Constructor
   ///\param gr  Reference to the graph to be printed.
   ///\param ost Reference to the output stream.
-  ///By default it is <tt>std::cout</tt>.
+  ///By default, it is <tt>std::cout</tt>.
   ///\param pros If it is \c true, then the \c ostream referenced by \c os
   ///will be explicitly deallocated by the destructor.
   DefaultGraphToEpsTraits(const GR &gr, std::ostream& ost = std::cout,
@@ -512,7 +512,7 @@
 
   ///Turn on/off pre-scaling
 
-  ///By default graphToEps() rescales the whole image in order to avoid
+  ///By default, graphToEps() rescales the whole image in order to avoid
   ///very big or very small bounding boxes.
   ///
   ///This (p)rescaling can be turned off with this function.
@@ -1114,7 +1114,7 @@
 ///Generates an EPS file from a graph.
 ///\param g Reference to the graph to be printed.
 ///\param os Reference to the output stream.
-///By default it is <tt>std::cout</tt>.
+///By default, it is <tt>std::cout</tt>.
 ///
 ///This function also has a lot of
 ///\ref named-templ-func-param "named parameters",
@@ -1126,7 +1126,7 @@
 ///              .arcWidthScale(.4).run();
 ///\endcode
 ///
-///For more detailed examples see the \ref graph_to_eps_demo.cc demo file.
+///For more detailed examples, see the \ref graph_to_eps_demo.cc demo file.
 ///
 ///\warning Don't forget to put the \ref GraphToEps::run() "run()"
 ///to the end of the parameter list.
diff --git a/lemon/hypercube_graph.h b/lemon/hypercube_graph.h
--- a/lemon/hypercube_graph.h
+++ b/lemon/hypercube_graph.h
@@ -287,7 +287,7 @@
   /// Two nodes are connected in the graph if and only if their indices
   /// differ only on one position in the binary form.
   /// This class is completely static and it needs constant memory space.
-  /// Thus you can neither add nor delete nodes or edges, however 
+  /// Thus you can neither add nor delete nodes or edges, however,
   /// the structure can be resized using resize().
   ///
   /// This type fully conforms to the \ref concepts::Graph "Graph concept".
diff --git a/lemon/lgf_reader.h b/lemon/lgf_reader.h
--- a/lemon/lgf_reader.h
+++ b/lemon/lgf_reader.h
@@ -427,7 +427,7 @@
   ///   run();
   ///\endcode
   ///
-  /// By default the reader uses the first section in the file of the
+  /// By default, the reader uses the first section in the file of the
   /// proper type. If a section has an optional name, then it can be
   /// selected for reading by giving an optional name parameter to the
   /// \c nodes(), \c arcs() or \c attributes() functions.
@@ -2221,7 +2221,7 @@
     /// and the comment lines are filtered out, and the leading
     /// whitespaces are trimmed from each processed string.
     ///
-    /// For example let's see a section, which contain several
+    /// For example, let's see a section, which contain several
     /// integers, which should be inserted into a vector.
     ///\code
     ///  @numbers
diff --git a/lemon/list_graph.h b/lemon/list_graph.h
--- a/lemon/list_graph.h
+++ b/lemon/list_graph.h
@@ -400,7 +400,7 @@
     /// This function changes the target node of the given arc \c a to \c n.
     ///
     ///\note \c ArcIt and \c OutArcIt iterators referencing the changed
-    ///arc remain valid, however \c InArcIt iterators are invalidated.
+    ///arc remain valid, but \c InArcIt iterators are invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
     ///feature.
@@ -412,7 +412,7 @@
     /// This function changes the source node of the given arc \c a to \c n.
     ///
     ///\note \c InArcIt iterators referencing the changed arc remain
-    ///valid, however \c ArcIt and \c OutArcIt iterators are invalidated.
+    ///valid, but \c ArcIt and \c OutArcIt iterators are invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
     ///feature.
@@ -559,7 +559,7 @@
     /// \warning Node and arc deletions and other modifications (e.g.
     /// reversing, contracting, splitting arcs or nodes) cannot be
     /// restored. These events invalidate the snapshot.
-    /// However the arcs and nodes that were added to the digraph after
+    /// However, the arcs and nodes that were added to the digraph after
     /// making the current snapshot can be removed without invalidating it.
     class Snapshot {
     protected:
@@ -1286,7 +1286,7 @@
     /// This function changes the second node of the given edge \c e to \c n.
     ///
     ///\note \c EdgeIt iterators referencing the changed edge remain
-    ///valid, however \c ArcIt iterators referencing the changed edge and
+    ///valid, but \c ArcIt iterators referencing the changed edge and
     ///all other iterators whose base node is the changed node are also
     ///invalidated.
     ///
@@ -1371,7 +1371,7 @@
     /// \warning Node and edge deletions and other modifications
     /// (e.g. changing the end-nodes of edges or contracting nodes)
     /// cannot be restored. These events invalidate the snapshot.
-    /// However the edges and nodes that were added to the graph after
+    /// However, the edges and nodes that were added to the graph after
     /// making the current snapshot can be removed without invalidating it.
     class Snapshot {
     protected:
diff --git a/lemon/lp_base.h b/lemon/lp_base.h
--- a/lemon/lp_base.h
+++ b/lemon/lp_base.h
@@ -146,7 +146,7 @@
 
     ///Iterator for iterate over the columns of an LP problem
 
-    /// Its usage is quite simple, for example you can count the number
+    /// Its usage is quite simple, for example, you can count the number
     /// of columns in an LP \c lp:
     ///\code
     /// int count=0;
@@ -241,7 +241,7 @@
 
     ///Iterator for iterate over the rows of an LP problem
 
-    /// Its usage is quite simple, for example you can count the number
+    /// Its usage is quite simple, for example, you can count the number
     /// of rows in an LP \c lp:
     ///\code
     /// int count=0;
diff --git a/lemon/maps.h b/lemon/maps.h
--- a/lemon/maps.h
+++ b/lemon/maps.h
@@ -230,10 +230,10 @@
   ///
   /// This map is essentially a wrapper for \c std::vector. It assigns
   /// values to integer keys from the range <tt>[0..size-1]</tt>.
-  /// It can be used with some data structures, for example
-  /// \c UnionFind, \c BinHeap, when the used items are small
+  /// It can be used together with some data structures, e.g.
+  /// heap types and \c UnionFind, when the used items are small
   /// integers. This map conforms to the \ref concepts::ReferenceMap
-  /// "ReferenceMap" concept.
+  /// "ReferenceMap" concept. 
   ///
   /// The simplest way of using this map is through the rangeMap()
   /// function.
@@ -348,9 +348,9 @@
   /// keys (i.e. the map is "sparse").
   /// The name of this type also refers to this important usage.
   ///
-  /// Apart form that this map can be used in many other cases since it
+  /// Apart form that, this map can be used in many other cases since it
   /// is based on \c std::map, which is a general associative container.
-  /// However keep in mind that it is usually not as efficient as other
+  /// However, keep in mind that it is usually not as efficient as other
   /// maps.
   ///
   /// The simplest way of using this map is through the sparseMap()
@@ -1785,7 +1785,7 @@
   ///
   /// The most important usage of it is storing certain nodes or arcs
   /// that were marked \c true by an algorithm.
-  /// For example it makes easier to store the nodes in the processing
+  /// For example, it makes easier to store the nodes in the processing
   /// order of Dfs algorithm, as the following examples show.
   /// \code
   ///   std::vector<Node> v;
@@ -1800,7 +1800,7 @@
   /// for the elements or the iterator should be an inserter iterator.
   ///
   /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so
-  /// it cannot be used when a readable map is needed, for example as
+  /// it cannot be used when a readable map is needed, for example, as
   /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.
   ///
   /// \relates LoggerBoolMap
@@ -1922,7 +1922,7 @@
   /// items with the same value.
   /// Otherwise consider to use \c IterableValueMap, which is more 
   /// suitable and more efficient for such cases. It provides iterators
-  /// to traverse the items with the same associated value, however
+  /// to traverse the items with the same associated value, but
   /// it does not have \c InverseMap.
   ///
   /// This type is not reference map, so it cannot be modified with
@@ -3466,7 +3466,7 @@
   /// \warning Besides \c addNode() and \c addArc(), a digraph structure
   /// may provide alternative ways to modify the digraph.
   /// The correct behavior of InDegMap is not guarantied if these additional
-  /// features are used. For example the functions
+  /// features are used. For example, the functions
   /// \ref ListDigraph::changeSource() "changeSource()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
   /// \ref ListDigraph::reverseArc() "reverseArc()"
@@ -3596,7 +3596,7 @@
   /// \warning Besides \c addNode() and \c addArc(), a digraph structure
   /// may provide alternative ways to modify the digraph.
   /// The correct behavior of OutDegMap is not guarantied if these additional
-  /// features are used. For example the functions
+  /// features are used. For example, the functions
   /// \ref ListDigraph::changeSource() "changeSource()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
   /// \ref ListDigraph::reverseArc() "reverseArc()"
diff --git a/lemon/network_simplex.h b/lemon/network_simplex.h
--- a/lemon/network_simplex.h
+++ b/lemon/network_simplex.h
@@ -50,7 +50,7 @@
   /// In general this class is the fastest implementation available
   /// in LEMON for the minimum cost flow problem.
   /// Moreover it supports both directions of the supply/demand inequality
-  /// constraints. For more information see \ref SupplyType.
+  /// constraints. For more information, see \ref SupplyType.
   ///
   /// Most of the parameters of the problem (except for the digraph)
   /// can be given using separate functions, and the algorithm can be
@@ -59,16 +59,16 @@
   ///
   /// \tparam GR The digraph type the algorithm runs on.
   /// \tparam V The value type used for flow amounts, capacity bounds
-  /// and supply values in the algorithm. By default it is \c int.
+  /// and supply values in the algorithm. By default, it is \c int.
   /// \tparam C The value type used for costs and potentials in the
-  /// algorithm. By default it is the same as \c V.
+  /// algorithm. By default, it is the same as \c V.
   ///
   /// \warning Both value types must be signed and all input data must
   /// be integer.
   ///
   /// \note %NetworkSimplex provides five different pivot rule
   /// implementations, from which the most efficient one is used
-  /// by default. For more information see \ref PivotRule.
+  /// by default. For more information, see \ref PivotRule.
   template <typename GR, typename V = int, typename C = V>
   class NetworkSimplex
   {
@@ -124,35 +124,35 @@
     /// \ref NetworkSimplex provides five different pivot rule
     /// implementations that significantly affect the running time
     /// of the algorithm.
-    /// By default \ref BLOCK_SEARCH "Block Search" is used, which
+    /// By default, \ref BLOCK_SEARCH "Block Search" is used, which
     /// proved to be the most efficient and the most robust on various
     /// test inputs according to our benchmark tests.
-    /// However another pivot rule can be selected using the \ref run()
+    /// However, another pivot rule can be selected using the \ref run()
     /// function with the proper parameter.
     enum PivotRule {
 
-      /// The First Eligible pivot rule.
+      /// The \e First \e Eligible pivot rule.
       /// The next eligible arc is selected in a wraparound fashion
       /// in every iteration.
       FIRST_ELIGIBLE,
 
-      /// The Best Eligible pivot rule.
+      /// The \e Best \e Eligible pivot rule.
       /// The best eligible arc is selected in every iteration.
       BEST_ELIGIBLE,
 
-      /// The Block Search pivot rule.
+      /// The \e Block \e Search pivot rule.
       /// A specified number of arcs are examined in every iteration
       /// in a wraparound fashion and the best eligible arc is selected
       /// from this block.
       BLOCK_SEARCH,
 
-      /// The Candidate List pivot rule.
+      /// The \e Candidate \e List pivot rule.
       /// In a major iteration a candidate list is built from eligible arcs
       /// in a wraparound fashion and in the following minor iterations
       /// the best eligible arc is selected from this list.
       CANDIDATE_LIST,
 
-      /// The Altering Candidate List pivot rule.
+      /// The \e Altering \e Candidate \e List pivot rule.
       /// It is a modified version of the Candidate List method.
       /// It keeps only the several best eligible arcs from the former
       /// candidate list and extends this list in every iteration.
@@ -812,7 +812,7 @@
     /// If it is not used before calling \ref run(), the \ref GEQ supply
     /// type will be used.
     ///
-    /// For more information see \ref SupplyType.
+    /// For more information, see \ref SupplyType.
     ///
     /// \return <tt>(*this)</tt>
     NetworkSimplex& supplyType(SupplyType supply_type) {
@@ -844,11 +844,11 @@
     /// that have been given are kept for the next call, unless
     /// \ref reset() is called, thus only the modified parameters
     /// have to be set again. See \ref reset() for examples.
-    /// However the underlying digraph must not be modified after this
+    /// However, the underlying digraph must not be modified after this
     /// class have been constructed, since it copies and extends the graph.
     ///
     /// \param pivot_rule The pivot rule that will be used during the
-    /// algorithm. For more information see \ref PivotRule.
+    /// algorithm. For more information, see \ref PivotRule.
     ///
     /// \return \c INFEASIBLE if no feasible flow exists,
     /// \n \c OPTIMAL if the problem has optimal solution
@@ -873,7 +873,7 @@
     /// It is useful for multiple run() calls. If this function is not
     /// used, all the parameters given before are kept for the next
     /// \ref run() call.
-    /// However the underlying digraph must not be modified after this
+    /// However, the underlying digraph must not be modified after this
     /// class have been constructed, since it copies and extends the graph.
     ///
     /// For example,
diff --git a/lemon/preflow.h b/lemon/preflow.h
--- a/lemon/preflow.h
+++ b/lemon/preflow.h
@@ -265,7 +265,7 @@
     /// The Elevator should have standard constructor interface to be
     /// able to automatically created by the algorithm (i.e. the
     /// digraph and the maximum level should be passed to it).
-    /// However an external elevator object could also be passed to the
+    /// However, an external elevator object could also be passed to the
     /// algorithm with the \ref elevator(Elevator&) "elevator()" function
     /// before calling \ref run() or \ref init().
     /// \sa SetElevator
diff --git a/lemon/time_measure.h b/lemon/time_measure.h
--- a/lemon/time_measure.h
+++ b/lemon/time_measure.h
@@ -375,7 +375,7 @@
 
     ///This function returns the number of stop() exections that is
     ///necessary to really stop the timer.
-    ///For example the timer
+    ///For example, the timer
     ///is running if and only if the return value is \c true
     ///(i.e. greater than
     ///zero).
diff --git a/lemon/unionfind.h b/lemon/unionfind.h
--- a/lemon/unionfind.h
+++ b/lemon/unionfind.h
@@ -43,7 +43,7 @@
   /// the find operation uses path compression.
   /// This is a very simple but efficient implementation, providing
   /// only four methods: join (union), find, insert and size.
-  /// For more features see the \ref UnionFindEnum class.
+  /// For more features, see the \ref UnionFindEnum class.
   ///
   /// It is primarily used in Kruskal algorithm for finding minimal
   /// cost spanning tree in a graph.