anchor.diff:                          |> Seq.filter (fun l -> l <> literal)
                           |> Seq.exists (fun otherLiteral ->
                               otherLiteral.RawFormular.IsSubsetOf literal.RawFormular)
  -                        |> not) }
  +                        |> not)
  +                if newLiterals.Length <> literals.Length
  +                then true, {Literals = newLiterals}
  +                else false, andClause
                   //andClause
  -            { OrFormulas = fr.OrFormulas |> List.map simplifyAndClause }
  +            let wasChanged, newOrList =
  +                fr.OrFormulas
  +                |> List.fold (fun (oldWasChanged, newList) andList ->
  +                    let wasChanged, newAndList = simplifyAndClause andList
  +                    oldWasChanged || wasChanged, newAndList :: newList) (false, [])
  +            if wasChanged then
  +                FrameworkRestriction.WithOrListInternal newOrList fr
  +            else fr
           
           /// (>= net40-full) || (< net46) || (>= net20) can be simplified to (< net46) || (>= net20) because (>= net40-full) is a subset of (>= net20)
           // NOTE: This optimization is kind of dangerous as future frameworks might make it invalid
  
positive.code:                         normalizeLiterals
                          |> Seq.exists (fun l ->
                              normalizeLiterals |> Seq.contains { l with IsNegated = not l.IsNegated})
                      not foundLiteralAndNegation) }
  
          /// When we optmized a clause away completely we can replace the hole formula with "NoRestriction"
          /// This happens for example with ( <net45 || >=net45) and the removeNegatedLiteralsWhichOccurSinglePositive
  
negative.code:                     item.Literals
                      |> Seq.forall (fun lit -> andList.Literals |> Seq.contains lit)
  
              let newOrList =
                  fr.OrFormulas
                  |> List.filter (fun orClause ->
                      orClauses |> Seq.exists (isContained orClause) |> not)
  
              if newOrList.Length < fr.OrFormulas.Length then
                  FrameworkRestriction.WithOrListInternal newOrList fr
              else fr
  
          /// clauses with ((>= net20) && (< net20) && ...) can be removed because they contains a literal and its negation.
          let removeUneccessaryAndClauses (fr:FrameworkRestriction) =
              let newOrList =
                  fr.OrFormulas
                  |> List.filter (fun andList ->
                      let normalizeLiterals =
  