anchor.diff:                  | None -> ()
                   | Some v -> raise (UncontrollablePeerPreferenceException p1.Node.Loc)
               // preferences for different peers must be implementable from internal preferences
  -            // TODO: use inferred preferences rather than exact
  -            if not (bestCasePrefs.[p1] > worstCasePrefs.[p2]) then 
  +            let p1Worse = bestCasePrefs.[p1] > worstCasePrefs.[p2]
  +            let p1Worse = 
  +              (loc p1 = loc p2 && inferredBestPrefs.[p1] > inferredWorstPrefs.[p2]) || p1Worse
  +            if not p1Worse then 
                 if p1.Node.Loc <> p2.Node.Loc then 
                   raise (UncontrollablePeerPreferenceException p1.Node.Loc)
           let mutable actions = []
  
positive.code:       |> Seq.map (fun (x, y) -> (x, Seq.map snd y))
        |> Seq.sortBy fst
      
      // Collect worst case pref for each peer
      let mutable worstCasePrefs = Map.empty
      let mutable bestCasePrefs = Map.empty
      for p in info.Peers do
        worstCasePrefs <- Map.add p (getMostPreference Seq.max cg p) worstCasePrefs
        bestCasePrefs <- Map.add p (getMostPreference Seq.min cg p) bestCasePrefs
      // Run through each preference level and check for safe preference
      let exportMap = ref Map.empty
      let mutable i = 0
  
negative.code:   
    let getUnique peers = Set.ofSeq (Seq.map (fun p -> p.Node.Loc) peers)
    
    let getMostPreference f g (cg : CGraph.T) (x : CgState) = 
      x
      |> CGraph.neighborsIn cg
      |> Seq.filter CGraph.isInside
      |> Seq.map g
      |> f
    
    let getSeen cg (peers : seq<CgState>) = 
  