anchor.diff:  
       /// Used to decide which peptides should be used for quantification of protein groups
       type PeptideUsageForQuantification =
  -        /// Use only the best matchin peptides
  +        /// Use only the best matching peptides
           | Minimal
  -        /// Use all available peptides
  +        /// Use all available peptides which point to a protein group which includes the given protein group
           | Maximal
  +        /// Use all available peptides which point to a part of the protein group
  +        | MaximalInverse
   
   
       let private increaseClass c =
  
positive.code:                     |> Seq.toArray
                      |> Array.distinct
                      |> createInferredProteinClassItem group c
                  )
              )
  
  
negative.code:             |> Seq.map (fun group -> 
                  let prots = Option.get (d.TryGetByValue group)
                  let protSet = Set.ofSeq prots
                  match peptideUsageForQuantification with
                  | PeptideUsageForQuantification.Maximal ->                     
                      let potentialCandidates = 
                          prots
                          |> Seq.collect (fun prot -> 
                              seqDict.[prot]
                              |> Seq.choose (fun protClassItem -> 
                                  let set = Set.ofArray protClassItem.GroupOfProteinIDs
                                  if Set.isSubset protSet set then
                                      Some protClassItem
                                  else 
                                      None
                                  )
                              )                    
                      potentialCandidates
                      |> Seq.map (fun pci -> pci.PeptideSequence)
                      |> Seq.toArray
                      |> Array.distinct
                      |> createInferredProteinClassItem group c 
                  | PeptideUsageForQuantification.Minimal -> 
                      let potentialCandidates = 
                          prots
                          |> Seq.collect (fun prot -> 
                              seqDict.[prot]
                              |> Seq.choose (fun protClassItem -> 
                                  let set = Set.ofArray protClassItem.GroupOfProteinIDs
                                  if Set.isSubset protSet set then
                                      Some protClassItem
                                  else 
                                      None
                                  )
                              )   
                      let withLength = 
                          potentialCandidates
                          |> Seq.map (fun pci -> pci.GroupOfProteinIDs.Length,pci)
  