anchor.diff:              let ``F'(x)`` = Map.find x F'
               Map.add x ``F'(x)`` F
   
  -        // Find the 'y' values related to 'x' and compute xRy
  -        // by recursively traversing them.
  +        // 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 ->
  
positive.code: /// A binary relation over a set of elements.
  // For each 'x', contains the 'y' values such that xRy (given a relation 'R').
  type internal Relation<'T when 'T : comparison> =
      Map<'T, Set<'T>>
  
  /// The traversal status of an element.
  type private TraversalStatus =
      /// The element has not yet been traversed.
      | NotStarted
      /// Traversal of the element is in-progress.
      | InProgress of int // depth
      /// Traversal of the element has been completed.
      | Completed
  
  //
  [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module internal Relation =
      //
      let empty : Relation<'T> = Map.empty
  
      //
      let add source target (relation : Relation<'T>) : Relation<'T> =
          let targets =
              match Map.tryFind source relation with
  
negative.code:     and 'U : comparison> =
      Map<'T, Set<'U>>
  
  /// Functions for working with PartialFunction instances.
  [<RequireQualifiedAccess; CompilationRepresentation(CompilationRepresentationFlags.ModuleSuffix)>]
  module internal PartialFunction =
      /// Returns an empty partial function.
      let empty : PartialFunction<'T, 'U> = Map.empty
  
      /// Returns a new partial function with the binding added to the given partial function.
      let add source target (func : PartialFunction<'T,' U>) : PartialFunction<'T,' U> =
          let targets =
              match Map.tryFind source func with
  