anchor.diff:  
           ((Map.empty, N, []), X)
           ||> Set.fold (fun (F, N, stack) x ->
  -            if Map.containsKey x N then
  -                F, N, stack
  -            else
  -                traverse (x, N, stack, F, X, R, F'))
  +            match Map.find x N with
  +            | Untraversed ->
  +                traverse (x, N, stack, F, X, R, F')
  +            | _ ->
  +                F, N, stack)
           // Discard the intermediate variables
           |> fun (F, N, _) ->
               // DEBUG : Make sure all set elements have been completely traversed.
  +            #if DEBUG
  +            let untraversed =
  +                X |> Set.filter (fun x ->
  +                    match Map.find x N with Traversed -> false | _ -> true)
               Debug.Assert (
  -                Set.forall (fun x -> match Map.find x N with Traversed -> true | _ -> false) X,
  -                "Some elements of X have not been completely traversed.")
  +                Set.isEmpty untraversed,
  +                sprintf "There are %i elements of X (Count = %i) which have not been completely traversed." (Set.count untraversed) (Set.count X))
  +            #endif
   
               // Return the computed relation.
               F
  
positive.code:         // by inspection of the transition's successor state.
          let directRead = directRead lr0ParserTable
  
          // Add the nonterminal transitions to the graph.
          let reads =
              (Graph.empty, nonterminalTransitions)
              ||> Set.fold (fun reads transition ->
                  Graph.addVertex transition reads)
  
          // C. Compute 'reads'. One set of nonterminal transitions per nonterminal transition,
          // by inspection of the successor state of the later transition.
          (reads, lr0ParserTable.GotoTable)
          ||> Map.fold (fun reads transition succStateId ->
              (reads, lr0ParserTable.GotoTable)
              ||> Map.fold (fun reads ((stateId, nonterminal) as succTransition) _ ->
                  // We only care about successors of the original transition;
                  // also, the nonterminal for this (successor) transition must be nullable.
                  if stateId = succStateId &&
                      Map.find nonterminal nullable then
                      // Add the edge to the 'reads' graph.
                      Graph.addEdge transition succTransition reads
                  else
                      reads))
          //
          |> Graph.reachable
          //
          |> Map.map (fun transition reachableTransitions ->
              /// The direct-read (DR) set for this transition.
              let transitionDirectRead = Map.find transition directRead
  
              // Union the DR set for this transition with the DR sets
              // of any other transitions reachable via the 'reads' relation.
              (transitionDirectRead, reachableTransitions)
              ||> Set.fold (fun read reachableTransition ->
                  Map.find reachableTransition directRead
                  |> Set.union read))
  
      //
      let private lookbackAndIncludes (grammar : AugmentedGrammar<'Nonterminal, 'Terminal>, lr0ParserTable : Lr0ParserTable<'Nonterminal, 'Terminal>, nonterminalTransitions, nullable) =
  
negative.code:         // Find the 'y' values related to 'x' and compute xRy
          // by recursively traversing them.
          let F, N, stack =
              match Map.tryFind x R with
              | None ->
                  F, N, stack
              | Some ``R(x)`` ->
                  ((F, N, stack), ``R(x)``)
                  ||> Set.fold (fun (F, N, stack) y ->
                      let F, N, stack =
                          match Map.find y N with
                          | Untraversed ->
                              traverse (y, N, stack, F, X, R, F')
                          | _ ->
                              F, N, stack
  
                      let N =
                          let ``N(x)`` = Map.find x N
                          let ``N(y)`` = Map.find y N
                          Map.add x (min ``N(x)`` ``N(y)``) N
  
                      let F =
                          match Map.tryFind y F with
                          | None -> F
                          | Some ``F(y)`` ->
                              let ``F(x)`` = Map.find x F
                              Map.add x (Set.union ``F(x)`` ``F(y)``) F
  
                      F, N, stack)
  
          // Walk back up the stack, if necessary.
          match Map.find x N with
  