anchor.diff:    | IntroducesConflict of List<SearchStrategyError>
   
     type ResolutionRequest =
  -  | GetSnapshot of AsyncReplyChannel<Map<PackageConstraint, Set<Set<PackageConstraint>>>>
  +  | MarkBadPath of List<ResolutionPath> * PackageConstraint * PackageConstraint * AsyncReplyChannel<Unit>
     | GetCandidates of Constraints * PackageConstraint * PackageSources * AsyncReplyChannel<AsyncSeq<Result<(PackageIdentifier * LocatedVersionSet), SearchStrategyError>>>
   
   
  
positive.code:           else
              yield Result.Error (IntroducesConflict conflicts)
          ()
        ()
      }
  
  
negative.code:       | GetCandidates (constraints, dep, locations, channel) ->
          trackLocal locations dep
          |> trackGlobal constraints
          |> AsyncSeq.takeWhile (fun _ -> testIfBad dep |> Option.isNone)
          |> AsyncSeq.takeWhile (fun _ -> testIfSelectionGood constraints)
          |> AsyncSeq.takeWhile (fun _ -> testIfHasBadCore constraints |> not)
          |> channel.Reply
        | MarkBadPath (path, failedDep, (p, bs), channel) ->
          //System.Console.WriteLine ("Marking " + string failedDep + " because " + string (p, bs) )
  
          let groups =
            world.[failedDep]
            |> Set.map(fun xs ->
              xs
              |> Set.filter(fun (q, _) -> p = q )
              |> Set.map(fun (_, cs) -> cs )
              |> Set.unionMany)
  
          for contribution in groups do
  
            let core =
              path
              |> Seq.choose(fun x ->
                match x with
                | Root m -> Some m.Dependencies
                | Node (q, rv) ->
                  if q <> fst failedDep && p <> q
                  then
                    Some rv.Manifest.Dependencies
                  else None)
              |> Seq.map (fun deps ->
                deps
                |> Seq.map (fun x -> (x.Package, x.Constraint |> constraintToSet |> (fun c -> Set.difference c contribution)))
                |> Seq.filter (fun (q, cs) -> cs.IsEmpty |> not)
                |> Seq.filter (fun (q, cs) -> p = q && Set.isProperSubset cs bs) // should be an intersection
                |> Set
  
              )
              |> Set.unionMany
              |> Set.add failedDep
  
            badCores <- badCores |> Set.add core
           // System.Console.WriteLine "bad core: "
            //System.Console.WriteLine core
           // System.Console.WriteLine "-------"
  
          channel.Reply ()
  
    })
  
  
  