anchor.diff:                  let negated =
                       match operand with
                       | { OrFormulas = [ {Literals = [ lit] } ] } -> 
  -                        { OrFormulas = [ {Literals = [ { lit with IsNegated = not lit.IsNegated } ] } ] }
  +                        [ {Literals = [ { lit with IsNegated = not lit.IsNegated } ] } ]
  +                        |> FrameworkRestriction.FromOrList
                       |  _ -> failwithf "a general NOT is not implemted jet (and shouldn't be emitted for now)"
                   negated, next
               else
  
positive.code:                     else
                          workDone, andFormula :: reworkedOrFormulas
                      ) (false, [])
              if workDone then removeNegatedLiteralsWhichOccurSinglePositive { OrFormulas = reworked }
              else fr
          /// (>= net40-full) && (< net46) && (>= net20) can be simplified to (< net46) && (>= net40-full) because (>= net40-full) is a subset of (>= net20)
          // NOTE: This optimization is kind of dangerous as future frameworks might make it invalid
  
negative.code:             if containsEmptyAnd then NoRestriction else fr
          
          let sortClauses (fr:FrameworkRestriction) =
              fr.OrFormulas
              |> List.map (fun andFormula -> { Literals = andFormula.Literals |> List.distinct |> List.sort })
              |> List.distinct
              |> List.sort 
              |> fun newOrList -> FrameworkRestriction.WithOrListInternal newOrList fr
          let optimize fr =
              fr
              |> removeNegatedLiteralsWhichOccurSinglePositive
  