anchor.diff:            TestCaseData(bEq (bAfter "flag") (BNot (bBefore "flag")))
               .Returns(bEq (BNot (bBefore "flag"))
                            (BNot (bBefore "flag")))
  -            .SetName("Remove Boolean afters in after-before relation; reduce to tautology")
  +            .SetName("Remove Boolean afters in after-before relation")
             TestCaseData(BAnd [bAfter "flag"; bAfter "pole"])
               .Returns(BAnd [ BNot (bBefore "flag")
                               bAfter "pole" ])
  -            .SetName("Remove Boolean afters only if they are in the environment")
  +            .SetName("Remove Boolean afters only if in the environment")
             TestCaseData(BAnd [BGt (aAfter "serving", aAfter "t")
                                BOr [bAfter "flag"; bAfter "pole"]])
  -            .Returns(BAnd [ BGt ((AAdd [aBefore "serving"; AInt 1L]), aAfter "t")
  +            .Returns(BAnd [ BGt ((AAdd [aBefore "serving"
  +                                        AInt 1L]), aAfter "t")
                               BOr [BNot (bBefore "flag"); bAfter "pole" ]])
               .SetName("Remove afters of both types simultaneously")
  -          TestCaseData(BNot (BImplies (bAfter "flag", BGt (aAfter "serving", aAfter "t"))))
  +          TestCaseData(BNot (BImplies (bAfter "flag", BGt (aAfter "serving",
  +                                                           aAfter "t"))))
               .Returns(BNot (BImplies (BNot (bBefore "flag"),
                                        BGt (AAdd [aBefore "serving"; AInt 1L],
                                             aAfter "t"))))
  
positive.code: 
      /// Test discovery of Boolean before-after pairs.
      [<TestCaseSource("BoolAfterDiscoveries")>]
      member x.``Discovery of Boolean before-after pairs should operate correctly`` b =
          b |> findBoolAfters |> Map.ofList
  
      /// Test cases for substituting afters in a func.
      static member AfterFuncs = 
          [ TestCaseData({ Name = "foo"
                           Params = [ AExpr (aAfter "serving")
                                      BExpr (bAfter "flag") ] })
              .Returns({ Name = "foo"
                         Params = [ AExpr (AAdd [aBefore "serving"; AInt 1L])
                                    BExpr (BNot (bBefore "flag")) ] })
              .SetName("Substitute afters in a func with all-after parameters") ]
  
      /// Test substitution of afters in funcs.
      [<TestCaseSource("AfterFuncs")>]
      member x.``Afters in the params of funcs should be substituted correctly`` f =
          let sub = afterSubs OptimiserTests.AfterArithSubs OptimiserTests.AfterBoolSubs
          subExprInVFunc sub f
  
      /// Test cases for simplification.
  
negative.code:     /// Test after-elimination of Booleans.
      [<TestCaseSource("AfterBools")>]
      member x.``After-elimination of Booleans should operate correctly`` b =
          (afterSubs OptimiserTests.AfterArithSubs OptimiserTests.AfterBoolSubs)
              .BSub b
  
      /// Test cases for discovering Boolean after-before pairs.
      static member BoolAfterDiscoveries =
  