This R code implements ideas in Joseph Halpern’s Actual Causality.

Library setup

library(conflicted)
library(tidyverse)
## ── Attaching core tidyverse packages ──────────────────────── tidyverse 2.0.0 ──
## ✔ dplyr     1.1.3     ✔ readr     2.1.4
## ✔ forcats   1.0.0     ✔ stringr   1.5.0
## ✔ ggplot2   3.4.3     ✔ tibble    3.2.1
## ✔ lubridate 1.9.2     ✔ tidyr     1.3.0
## ✔ purrr     1.0.2
library(R6)
conflicts_prefer(dplyr::filter)
## [conflicted] Will prefer dplyr::filter over any other package.

The R6 class that does all the magic

Comments coming on this one. {R6} is a lovely package; however, I’m not sure how best to use it in Markdown.

CausalMod <- R6Class("CausalMod",
  public = list(
    
    initialize = function(funs = NA, ranges = NA) {
      self$setFuns(funs)
      self$setRanges(ranges)
    },
    
    setFuns = function(funs) {
      private$funs <- funs
    },
    
    setRanges = function(ranges) {
      private$ranges <- ranges
    },
    
    update = function(var, newVal) {
      if (!var %in% self$getVars())
        stop(paste(var, "is not a variable"))
      if (!newVal %in% self$getRanges()[[var]])
        stop(paste(newVal, "is not in range",
                   paste(self$getRanges()[[var]], collapse = ", " )))
      
      private$funs[[var]] <- \() newVal
    },
    
    updateList = function(valList) {
      vars <- names(valList)
      
      for (v in vars) {
        self$update(v, valList[[v]])
      }
    },
    
    getFuns = function() {
      private$funs
    },
    
    getRanges = function() {
      private$ranges
    },
    
    getVars = function() {
      names(private$funs)
    },
    
    getState = function() {
      res <- as.list(rep(NA, length(private$funs)))
      names(res) <- names(private$funs)
  
      for (v in names(res)) {
        theArgs <- formalArgs(private$funs[[v]])
        theParams <- list()
        if (!is.null(theArgs)) {
          theParams <- res[theArgs]
        }
        res[[v]] <- do.call(private$funs[[v]], theParams)
      }

      res      
    },
    
    testProp = function(prop) {
      state <- self$getState()[(formalArgs(prop))]
      do.call(prop, state)
    },
    
    AC1 = function(XsProp, phiProp) {
      self$testProp(XsProp) && self$testProp(phiProp)
    },
    
    AC2 = function(XsProp, phiProp) {
      Xs <- formalArgs(XsProp)
      partitions <- private$listZWs(Xs, names(private$funs))
      res <- data.frame()
      
      for (Ws in partitions$Ws) {
        possibilities <- expand.grid(private$ranges[c(Xs, Ws)])
        Zs <- setdiff(names(private$funs), c(Xs, Ws))
        
        cat("\nTrying partition:\n")
        private$printPartition(Xs, Ws, Zs)

        for (r in seq_len(nrow(possibilities))) {
          cloned <- self$clone()
          thisWorld <- possibilities[r,,drop = FALSE]
          cloned$updateList(thisWorld |> as.list())
          if (!cloned$testProp(XsProp) && !cloned$testProp(phiProp)) {
            cat("AC2u(a) PASSED on: \n")
            cat("  ")
            private$printFlatList(thisWorld |> as.list())
            cat("\n")
            
            X_setting <- self$getState()[Xs]
            Z_setting <- self$getState()[Zs]
            W_setting <- cloned$getState()[Ws]
            ZW_setting <- c(Z_setting, W_setting)
            
            test_subs <- private$allSubsets(ZW_setting)
            test_subs <- lapply(test_subs, \(x) c(X_setting, x))

            cat("Testing AC2u(b) on subsets:\n")
            
            AC2b_res <- c()
            for (x in seq_len(length(test_subs))) {
              cat("  ")
              private$printFlatList(test_subs[[x]])
              
              testWorld <- self$clone()
              testWorld$updateList(test_subs[[x]])
              testResult <- testWorld$testProp(phiProp)
              
              if (testResult)
                cat("✓\n")
              else
                cat("✗\n") 
              
              AC2b_res <- c(AC2b_res, testResult)
            }

            if (all(AC2b_res)) {
              res <- bind_rows(res, thisWorld)
              cat("✓✓ AC2(a) and AC2u(b)!\n")
            }
            else {
              cat("AC2u(b) failed!\n")              
            }
          }
        }
      }
      cat("\n")
      res
    },
    
    AC = function(XsProp, phiProp) {
      c(AC1 = self$AC1(XsProp, phiProp),
        AC2u = (nrow(self$AC2(XsProp, phiProp)) > 0)
      )
    }
    
  ),
  
  private = list(
    funs   = list(),
    ranges = list(),
    
    allZWs = function(Xs, vars) {
      varsList <- as.list(rep(NA, length(vars)))
      names(varsList) <- vars
  
      for (v in vars) {
        if (v %in% Xs)
          varsList[[v]] <- c("Z")
        else
          varsList[[v]] <- c("Z", "W")
      }
  
      expand.grid(varsList, stringsAsFactors = FALSE)
    },
    
    listZWs = function(Xs, vars) {
      dat <- private$allZWs(Xs, vars)
      Zs <- list(rep(NA, nrow(dat)))
      Ws <- list(rep(NA, nrow(dat)))
  
      for (i in seq_len(nrow(dat))) {
        Zs[[i]] <- names(dat)[dat[i,,drop = FALSE] == "Z"]
        Ws[[i]] <- names(dat)[dat[i,,drop = FALSE] == "W"]
      }
    
      list(Ws = Ws, Zs = Zs)
    },
    
    allSubsets = function(theList) {
      vars <- names(theList)
      varsList <- as.list(rep(NA, length(vars)))
      names(varsList) <- vars
      
      for (v in vars) {
          varsList[[v]] <- c(TRUE, FALSE)
      }
      
      truthtab <- expand.grid(varsList, stringsAsFactors = FALSE)
      
      res <- list()
      for (r in seq_len(nrow(truthtab))) {
        vec <- truthtab[r,,drop = FALSE] |> t() |> as.vector()
        res <- c(res, list(theList[vec]))
      }
      
      res
    },
    
    printFlatList = function(flat) {
      if (length(flat) > 0)
        stopifnot(!is.null(names(flat)))
      
      cat("[ ")
      for (v in names(flat)) {
        cat(v)
        cat("←")
        cat(flat[[v]])
        cat(" ")
      }
      cat("]")
    },
    
    printListofLists = function(lists) {
      for (e in lists) {
        cat("  ")
        private$printFlatList(e)
        cat("\n")
      }
    },
    
    printPartition = function(Xs, Ws, Zs) {
      cat("  X = {")
      cat(paste(Xs, collapse = ", "))
      cat("}\n")
      cat("  W = {")
      cat(paste(Ws, collapse = ", "))
      cat("}\n")
      cat("  Z-X = {")
      cat(paste(Zs, collapse = ", "))
      cat("}\n")
    }
  )
)

Easy example: one person lobbing stone at bottle

Here’s an easy simplfication of an example given by Halpert. Suzy throws (ST), bottle smashes (BS).

simpBottle <- CausalMod$new(
  funs = list(
    ST = \() 1,
    BS = \(ST) ST
  ), 
  ranges = list(
    ST = c(0, 1),
    BS = c(0, 1)    
  )
)

simpBottle$AC(\(ST) ST == 1, \(BS) BS == 1)
## 
## Trying partition:
##   X = {ST}
##   W = {}
##   Z-X = {BS}
## AC2u(a) PASSED on: 
##   [ ST←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BS←1 ]✓
##   [ ST←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {ST}
##   W = {BS}
##   Z-X = {}
## AC2u(a) PASSED on: 
##   [ ST←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BS←0 ]✗
##   [ ST←1 ]✓
## AC2u(b) failed!
##  AC1 AC2u 
## TRUE TRUE

Both AC1 and AC2u (for updated) hold.

simpBottle$AC(\(BS) BS == 1, \(ST) ST == 1)
## 
## Trying partition:
##   X = {BS}
##   W = {}
##   Z-X = {ST}
## 
## Trying partition:
##   X = {BS}
##   W = {ST}
##   Z-X = {}
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 ST←0 ]✗
##   [ BS←1 ]✓
## AC2u(b) failed!
##   AC1  AC2u 
##  TRUE FALSE

The reverse doesn’t for AC2u.

Complicated example from Fig 2.3 in the book

Now a more complicated example from the book (Fig 2.3).

bottle <- CausalMod$new(
  funs = list(
    ST = \() 1,
    BT = \() 1,
    SH = \(ST) ST,
    BH = \(BT, SH) BT * (1 - SH),
    BS = \(SH, BH) max(SH, BH)
  ), 
  ranges = list(
    ST = c(0, 1),
    BT = c(0, 1),
    SH = c(0, 1),
    BH = c(0, 1),
    BS = c(0, 1)    
  )
)

ST causes BT:

bottle$AC(\(ST) ST == 1, \(BS) BS == 1)
## 
## Trying partition:
##   X = {ST}
##   W = {}
##   Z-X = {BT, SH, BH, BS}
## 
## Trying partition:
##   X = {ST}
##   W = {BT}
##   Z-X = {SH, BH, BS}
## AC2u(a) PASSED on: 
##   [ ST←0 BT←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 SH←1 BH←0 BS←1 BT←0 ]✓
##   [ ST←1 BH←0 BS←1 BT←0 ]✓
##   [ ST←1 SH←1 BS←1 BT←0 ]✓
##   [ ST←1 BS←1 BT←0 ]✓
##   [ ST←1 SH←1 BH←0 BT←0 ]✓
##   [ ST←1 BH←0 BT←0 ]✓
##   [ ST←1 SH←1 BT←0 ]✓
##   [ ST←1 BT←0 ]✓
##   [ ST←1 SH←1 BH←0 BS←1 ]✓
##   [ ST←1 BH←0 BS←1 ]✓
##   [ ST←1 SH←1 BS←1 ]✓
##   [ ST←1 BS←1 ]✓
##   [ ST←1 SH←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {ST}
##   W = {SH}
##   Z-X = {BT, BH, BS}
## 
## Trying partition:
##   X = {ST}
##   W = {BT, SH}
##   Z-X = {BH, BS}
## AC2u(a) PASSED on: 
##   [ ST←0 BT←0 SH←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BH←0 BS←1 BT←0 SH←0 ]✓
##   [ ST←1 BS←1 BT←0 SH←0 ]✓
##   [ ST←1 BH←0 BT←0 SH←0 ]✗
##   [ ST←1 BT←0 SH←0 ]✗
##   [ ST←1 BH←0 BS←1 SH←0 ]✓
##   [ ST←1 BS←1 SH←0 ]✓
##   [ ST←1 BH←0 SH←0 ]✗
##   [ ST←1 SH←0 ]✓
##   [ ST←1 BH←0 BS←1 BT←0 ]✓
##   [ ST←1 BS←1 BT←0 ]✓
##   [ ST←1 BH←0 BT←0 ]✓
##   [ ST←1 BT←0 ]✓
##   [ ST←1 BH←0 BS←1 ]✓
##   [ ST←1 BS←1 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {ST}
##   W = {BH}
##   Z-X = {BT, SH, BS}
## AC2u(a) PASSED on: 
##   [ ST←0 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 SH←1 BS←1 BH←0 ]✓
##   [ ST←1 SH←1 BS←1 BH←0 ]✓
##   [ ST←1 BT←1 BS←1 BH←0 ]✓
##   [ ST←1 BS←1 BH←0 ]✓
##   [ ST←1 BT←1 SH←1 BH←0 ]✓
##   [ ST←1 SH←1 BH←0 ]✓
##   [ ST←1 BT←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 BT←1 SH←1 BS←1 ]✓
##   [ ST←1 SH←1 BS←1 ]✓
##   [ ST←1 BT←1 BS←1 ]✓
##   [ ST←1 BS←1 ]✓
##   [ ST←1 BT←1 SH←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {ST}
##   W = {BT, BH}
##   Z-X = {SH, BS}
## AC2u(a) PASSED on: 
##   [ ST←0 BT←0 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 SH←1 BS←1 BT←0 BH←0 ]✓
##   [ ST←1 BS←1 BT←0 BH←0 ]✓
##   [ ST←1 SH←1 BT←0 BH←0 ]✓
##   [ ST←1 BT←0 BH←0 ]✓
##   [ ST←1 SH←1 BS←1 BH←0 ]✓
##   [ ST←1 BS←1 BH←0 ]✓
##   [ ST←1 SH←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 SH←1 BS←1 BT←0 ]✓
##   [ ST←1 BS←1 BT←0 ]✓
##   [ ST←1 SH←1 BT←0 ]✓
##   [ ST←1 BT←0 ]✓
##   [ ST←1 SH←1 BS←1 ]✓
##   [ ST←1 BS←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←1 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 SH←1 BS←1 BT←1 BH←0 ]✓
##   [ ST←1 BS←1 BT←1 BH←0 ]✓
##   [ ST←1 SH←1 BT←1 BH←0 ]✓
##   [ ST←1 BT←1 BH←0 ]✓
##   [ ST←1 SH←1 BS←1 BH←0 ]✓
##   [ ST←1 BS←1 BH←0 ]✓
##   [ ST←1 SH←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 SH←1 BS←1 BT←1 ]✓
##   [ ST←1 BS←1 BT←1 ]✓
##   [ ST←1 SH←1 BT←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 SH←1 BS←1 ]✓
##   [ ST←1 BS←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {ST}
##   W = {SH, BH}
##   Z-X = {BT, BS}
## AC2u(a) PASSED on: 
##   [ ST←0 SH←0 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 BS←1 SH←0 BH←0 ]✓
##   [ ST←1 BS←1 SH←0 BH←0 ]✓
##   [ ST←1 BT←1 SH←0 BH←0 ]✗
##   [ ST←1 SH←0 BH←0 ]✗
##   [ ST←1 BT←1 BS←1 BH←0 ]✓
##   [ ST←1 BS←1 BH←0 ]✓
##   [ ST←1 BT←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 BT←1 BS←1 SH←0 ]✓
##   [ ST←1 BS←1 SH←0 ]✓
##   [ ST←1 BT←1 SH←0 ]✓
##   [ ST←1 SH←0 ]✓
##   [ ST←1 BT←1 BS←1 ]✓
##   [ ST←1 BS←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {ST}
##   W = {BT, SH, BH}
##   Z-X = {BS}
## AC2u(a) PASSED on: 
##   [ ST←0 BT←0 SH←0 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BS←1 BT←0 SH←0 BH←0 ]✓
##   [ ST←1 BT←0 SH←0 BH←0 ]✗
##   [ ST←1 BS←1 SH←0 BH←0 ]✓
##   [ ST←1 SH←0 BH←0 ]✗
##   [ ST←1 BS←1 BT←0 BH←0 ]✓
##   [ ST←1 BT←0 BH←0 ]✓
##   [ ST←1 BS←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 BS←1 BT←0 SH←0 ]✓
##   [ ST←1 BT←0 SH←0 ]✗
##   [ ST←1 BS←1 SH←0 ]✓
##   [ ST←1 SH←0 ]✓
##   [ ST←1 BS←1 BT←0 ]✓
##   [ ST←1 BT←0 ]✓
##   [ ST←1 BS←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←1 SH←0 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BS←1 BT←1 SH←0 BH←0 ]✓
##   [ ST←1 BT←1 SH←0 BH←0 ]✗
##   [ ST←1 BS←1 SH←0 BH←0 ]✓
##   [ ST←1 SH←0 BH←0 ]✗
##   [ ST←1 BS←1 BT←1 BH←0 ]✓
##   [ ST←1 BT←1 BH←0 ]✓
##   [ ST←1 BS←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 BS←1 BT←1 SH←0 ]✓
##   [ ST←1 BT←1 SH←0 ]✓
##   [ ST←1 BS←1 SH←0 ]✓
##   [ ST←1 SH←0 ]✓
##   [ ST←1 BS←1 BT←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 BS←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {ST}
##   W = {BS}
##   Z-X = {BT, SH, BH}
## AC2u(a) PASSED on: 
##   [ ST←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 SH←1 BH←0 BS←0 ]✗
##   [ ST←1 SH←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 BH←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BH←0 ]✓
##   [ ST←1 SH←1 BH←0 ]✓
##   [ ST←1 BT←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 BT←1 SH←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {ST}
##   W = {BT, BS}
##   Z-X = {SH, BH}
## AC2u(a) PASSED on: 
##   [ ST←0 BT←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 SH←1 BH←0 BT←0 BS←0 ]✗
##   [ ST←1 BH←0 BT←0 BS←0 ]✗
##   [ ST←1 SH←1 BT←0 BS←0 ]✗
##   [ ST←1 BT←0 BS←0 ]✗
##   [ ST←1 SH←1 BH←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 SH←1 BH←0 BT←0 ]✓
##   [ ST←1 BH←0 BT←0 ]✓
##   [ ST←1 SH←1 BT←0 ]✓
##   [ ST←1 BT←0 ]✓
##   [ ST←1 SH←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←1 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 SH←1 BH←0 BT←1 BS←0 ]✗
##   [ ST←1 BH←0 BT←1 BS←0 ]✗
##   [ ST←1 SH←1 BT←1 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 SH←1 BH←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 SH←1 BH←0 BT←1 ]✓
##   [ ST←1 BH←0 BT←1 ]✓
##   [ ST←1 SH←1 BT←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 SH←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {ST}
##   W = {SH, BS}
##   Z-X = {BT, BH}
## AC2u(a) PASSED on: 
##   [ ST←0 SH←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 BH←0 SH←0 BS←0 ]✗
##   [ ST←1 BH←0 SH←0 BS←0 ]✗
##   [ ST←1 BT←1 SH←0 BS←0 ]✗
##   [ ST←1 SH←0 BS←0 ]✗
##   [ ST←1 BT←1 BH←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←1 BH←0 SH←0 ]✗
##   [ ST←1 BH←0 SH←0 ]✗
##   [ ST←1 BT←1 SH←0 ]✓
##   [ ST←1 SH←0 ]✓
##   [ ST←1 BT←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 SH←1 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 BH←0 SH←1 BS←0 ]✗
##   [ ST←1 BH←0 SH←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BT←1 BH←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←1 BH←0 SH←1 ]✓
##   [ ST←1 BH←0 SH←1 ]✓
##   [ ST←1 BT←1 SH←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 BT←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {ST}
##   W = {BT, SH, BS}
##   Z-X = {BH}
## AC2u(a) PASSED on: 
##   [ ST←0 BT←0 SH←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BH←0 BT←0 SH←0 BS←0 ]✗
##   [ ST←1 BT←0 SH←0 BS←0 ]✗
##   [ ST←1 BH←0 SH←0 BS←0 ]✗
##   [ ST←1 SH←0 BS←0 ]✗
##   [ ST←1 BH←0 BT←0 BS←0 ]✗
##   [ ST←1 BT←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BH←0 BT←0 SH←0 ]✗
##   [ ST←1 BT←0 SH←0 ]✗
##   [ ST←1 BH←0 SH←0 ]✗
##   [ ST←1 SH←0 ]✓
##   [ ST←1 BH←0 BT←0 ]✓
##   [ ST←1 BT←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←1 SH←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BH←0 BT←1 SH←0 BS←0 ]✗
##   [ ST←1 BT←1 SH←0 BS←0 ]✗
##   [ ST←1 BH←0 SH←0 BS←0 ]✗
##   [ ST←1 SH←0 BS←0 ]✗
##   [ ST←1 BH←0 BT←1 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BH←0 BT←1 SH←0 ]✗
##   [ ST←1 BT←1 SH←0 ]✓
##   [ ST←1 BH←0 SH←0 ]✗
##   [ ST←1 SH←0 ]✓
##   [ ST←1 BH←0 BT←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←0 SH←1 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BH←0 BT←0 SH←1 BS←0 ]✗
##   [ ST←1 BT←0 SH←1 BS←0 ]✗
##   [ ST←1 BH←0 SH←1 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BH←0 BT←0 BS←0 ]✗
##   [ ST←1 BT←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BH←0 BT←0 SH←1 ]✓
##   [ ST←1 BT←0 SH←1 ]✓
##   [ ST←1 BH←0 SH←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 BH←0 BT←0 ]✓
##   [ ST←1 BT←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←1 SH←1 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BH←0 BT←1 SH←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BS←0 ]✗
##   [ ST←1 BH←0 SH←1 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BH←0 BT←1 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BH←0 BT←1 SH←1 ]✓
##   [ ST←1 BT←1 SH←1 ]✓
##   [ ST←1 BH←0 SH←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 BH←0 BT←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {ST}
##   W = {BH, BS}
##   Z-X = {BT, SH}
## AC2u(a) PASSED on: 
##   [ ST←0 BH←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 SH←1 BH←0 BS←0 ]✗
##   [ ST←1 SH←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 BH←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BH←0 ]✓
##   [ ST←1 SH←1 BH←0 ]✓
##   [ ST←1 BT←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 BT←1 SH←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BH←1 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 SH←1 BH←1 BS←0 ]✗
##   [ ST←1 SH←1 BH←1 BS←0 ]✗
##   [ ST←1 BT←1 BH←1 BS←0 ]✗
##   [ ST←1 BH←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BH←1 ]✓
##   [ ST←1 SH←1 BH←1 ]✓
##   [ ST←1 BT←1 BH←1 ]✓
##   [ ST←1 BH←1 ]✓
##   [ ST←1 BT←1 SH←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {ST}
##   W = {BT, BH, BS}
##   Z-X = {SH}
## AC2u(a) PASSED on: 
##   [ ST←0 BT←0 BH←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 SH←1 BT←0 BH←0 BS←0 ]✗
##   [ ST←1 BT←0 BH←0 BS←0 ]✗
##   [ ST←1 SH←1 BH←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 SH←1 BT←0 BS←0 ]✗
##   [ ST←1 BT←0 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 SH←1 BT←0 BH←0 ]✓
##   [ ST←1 BT←0 BH←0 ]✓
##   [ ST←1 SH←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 SH←1 BT←0 ]✓
##   [ ST←1 BT←0 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←1 BH←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 SH←1 BT←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 BH←0 BS←0 ]✗
##   [ ST←1 SH←1 BH←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 SH←1 BT←1 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 SH←1 BT←1 BH←0 ]✓
##   [ ST←1 BT←1 BH←0 ]✓
##   [ ST←1 SH←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 SH←1 BT←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←0 BH←1 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 SH←1 BT←0 BH←1 BS←0 ]✗
##   [ ST←1 BT←0 BH←1 BS←0 ]✗
##   [ ST←1 SH←1 BH←1 BS←0 ]✗
##   [ ST←1 BH←1 BS←0 ]✗
##   [ ST←1 SH←1 BT←0 BS←0 ]✗
##   [ ST←1 BT←0 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 SH←1 BT←0 BH←1 ]✓
##   [ ST←1 BT←0 BH←1 ]✓
##   [ ST←1 SH←1 BH←1 ]✓
##   [ ST←1 BH←1 ]✓
##   [ ST←1 SH←1 BT←0 ]✓
##   [ ST←1 BT←0 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←1 BH←1 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 SH←1 BT←1 BH←1 BS←0 ]✗
##   [ ST←1 BT←1 BH←1 BS←0 ]✗
##   [ ST←1 SH←1 BH←1 BS←0 ]✗
##   [ ST←1 BH←1 BS←0 ]✗
##   [ ST←1 SH←1 BT←1 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 SH←1 BT←1 BH←1 ]✓
##   [ ST←1 BT←1 BH←1 ]✓
##   [ ST←1 SH←1 BH←1 ]✓
##   [ ST←1 BH←1 ]✓
##   [ ST←1 SH←1 BT←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {ST}
##   W = {SH, BH, BS}
##   Z-X = {BT}
## AC2u(a) PASSED on: 
##   [ ST←0 SH←0 BH←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 SH←0 BH←0 BS←0 ]✗
##   [ ST←1 SH←0 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 BH←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 SH←0 BS←0 ]✗
##   [ ST←1 SH←0 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←0 BH←0 ]✗
##   [ ST←1 SH←0 BH←0 ]✗
##   [ ST←1 BT←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 BT←1 SH←0 ]✓
##   [ ST←1 SH←0 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 SH←1 BH←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 SH←1 BH←0 BS←0 ]✗
##   [ ST←1 SH←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 BH←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BH←0 ]✓
##   [ ST←1 SH←1 BH←0 ]✓
##   [ ST←1 BT←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 BT←1 SH←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 SH←0 BH←1 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 SH←0 BH←1 BS←0 ]✗
##   [ ST←1 SH←0 BH←1 BS←0 ]✗
##   [ ST←1 BT←1 BH←1 BS←0 ]✗
##   [ ST←1 BH←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←0 BS←0 ]✗
##   [ ST←1 SH←0 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←0 BH←1 ]✓
##   [ ST←1 SH←0 BH←1 ]✓
##   [ ST←1 BT←1 BH←1 ]✓
##   [ ST←1 BH←1 ]✓
##   [ ST←1 BT←1 SH←0 ]✓
##   [ ST←1 SH←0 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 SH←1 BH←1 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 SH←1 BH←1 BS←0 ]✗
##   [ ST←1 SH←1 BH←1 BS←0 ]✗
##   [ ST←1 BT←1 BH←1 BS←0 ]✗
##   [ ST←1 BH←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BH←1 ]✓
##   [ ST←1 SH←1 BH←1 ]✓
##   [ ST←1 BT←1 BH←1 ]✓
##   [ ST←1 BH←1 ]✓
##   [ ST←1 BT←1 SH←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {ST}
##   W = {BT, SH, BH, BS}
##   Z-X = {}
## AC2u(a) PASSED on: 
##   [ ST←0 BT←0 SH←0 BH←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←0 SH←0 BH←0 BS←0 ]✗
##   [ ST←1 SH←0 BH←0 BS←0 ]✗
##   [ ST←1 BT←0 BH←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←0 SH←0 BS←0 ]✗
##   [ ST←1 SH←0 BS←0 ]✗
##   [ ST←1 BT←0 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←0 SH←0 BH←0 ]✗
##   [ ST←1 SH←0 BH←0 ]✗
##   [ ST←1 BT←0 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 BT←0 SH←0 ]✗
##   [ ST←1 SH←0 ]✓
##   [ ST←1 BT←0 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←1 SH←0 BH←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 SH←0 BH←0 BS←0 ]✗
##   [ ST←1 SH←0 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 BH←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 SH←0 BS←0 ]✗
##   [ ST←1 SH←0 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←0 BH←0 ]✗
##   [ ST←1 SH←0 BH←0 ]✗
##   [ ST←1 BT←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 BT←1 SH←0 ]✓
##   [ ST←1 SH←0 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←0 SH←1 BH←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←0 SH←1 BH←0 BS←0 ]✗
##   [ ST←1 SH←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←0 BH←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←0 SH←1 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BT←0 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←0 SH←1 BH←0 ]✓
##   [ ST←1 SH←1 BH←0 ]✓
##   [ ST←1 BT←0 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 BT←0 SH←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 BT←0 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←1 SH←1 BH←0 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 SH←1 BH←0 BS←0 ]✗
##   [ ST←1 SH←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 BH←0 BS←0 ]✗
##   [ ST←1 BH←0 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BH←0 ]✓
##   [ ST←1 SH←1 BH←0 ]✓
##   [ ST←1 BT←1 BH←0 ]✓
##   [ ST←1 BH←0 ]✓
##   [ ST←1 BT←1 SH←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←0 SH←0 BH←1 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←0 SH←0 BH←1 BS←0 ]✗
##   [ ST←1 SH←0 BH←1 BS←0 ]✗
##   [ ST←1 BT←0 BH←1 BS←0 ]✗
##   [ ST←1 BH←1 BS←0 ]✗
##   [ ST←1 BT←0 SH←0 BS←0 ]✗
##   [ ST←1 SH←0 BS←0 ]✗
##   [ ST←1 BT←0 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←0 SH←0 BH←1 ]✓
##   [ ST←1 SH←0 BH←1 ]✓
##   [ ST←1 BT←0 BH←1 ]✓
##   [ ST←1 BH←1 ]✓
##   [ ST←1 BT←0 SH←0 ]✗
##   [ ST←1 SH←0 ]✓
##   [ ST←1 BT←0 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←1 SH←0 BH←1 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 SH←0 BH←1 BS←0 ]✗
##   [ ST←1 SH←0 BH←1 BS←0 ]✗
##   [ ST←1 BT←1 BH←1 BS←0 ]✗
##   [ ST←1 BH←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←0 BS←0 ]✗
##   [ ST←1 SH←0 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←0 BH←1 ]✓
##   [ ST←1 SH←0 BH←1 ]✓
##   [ ST←1 BT←1 BH←1 ]✓
##   [ ST←1 BH←1 ]✓
##   [ ST←1 BT←1 SH←0 ]✓
##   [ ST←1 SH←0 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←0 SH←1 BH←1 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←0 SH←1 BH←1 BS←0 ]✗
##   [ ST←1 SH←1 BH←1 BS←0 ]✗
##   [ ST←1 BT←0 BH←1 BS←0 ]✗
##   [ ST←1 BH←1 BS←0 ]✗
##   [ ST←1 BT←0 SH←1 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BT←0 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←0 SH←1 BH←1 ]✓
##   [ ST←1 SH←1 BH←1 ]✓
##   [ ST←1 BT←0 BH←1 ]✓
##   [ ST←1 BH←1 ]✓
##   [ ST←1 BT←0 SH←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 BT←0 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ ST←0 BT←1 SH←1 BH←1 BS←0 ]
## Testing AC2u(b) on subsets:
##   [ ST←1 BT←1 SH←1 BH←1 BS←0 ]✗
##   [ ST←1 SH←1 BH←1 BS←0 ]✗
##   [ ST←1 BT←1 BH←1 BS←0 ]✗
##   [ ST←1 BH←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BS←0 ]✗
##   [ ST←1 SH←1 BS←0 ]✗
##   [ ST←1 BT←1 BS←0 ]✗
##   [ ST←1 BS←0 ]✗
##   [ ST←1 BT←1 SH←1 BH←1 ]✓
##   [ ST←1 SH←1 BH←1 ]✓
##   [ ST←1 BT←1 BH←1 ]✓
##   [ ST←1 BH←1 ]✓
##   [ ST←1 BT←1 SH←1 ]✓
##   [ ST←1 SH←1 ]✓
##   [ ST←1 BT←1 ]✓
##   [ ST←1 ]✓
## AC2u(b) failed!
##  AC1 AC2u 
## TRUE TRUE

Blimey. Imagine doing that by hand (though we didn’t actually need to try all partitions and settings).

Reverse:

bottle$AC(\(BS) BS == 1, \(ST) ST == 1)
## 
## Trying partition:
##   X = {BS}
##   W = {}
##   Z-X = {ST, BT, SH, BH}
## 
## Trying partition:
##   X = {BS}
##   W = {ST}
##   Z-X = {BT, SH, BH}
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 BT←1 SH←1 BH←0 ST←0 ]✗
##   [ BS←1 SH←1 BH←0 ST←0 ]✗
##   [ BS←1 BT←1 BH←0 ST←0 ]✗
##   [ BS←1 BH←0 ST←0 ]✗
##   [ BS←1 BT←1 SH←1 ST←0 ]✗
##   [ BS←1 SH←1 ST←0 ]✗
##   [ BS←1 BT←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 BT←1 SH←1 BH←0 ]✓
##   [ BS←1 SH←1 BH←0 ]✓
##   [ BS←1 BT←1 BH←0 ]✓
##   [ BS←1 BH←0 ]✓
##   [ BS←1 BT←1 SH←1 ]✓
##   [ BS←1 SH←1 ]✓
##   [ BS←1 BT←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {BS}
##   W = {BT}
##   Z-X = {ST, SH, BH}
## 
## Trying partition:
##   X = {BS}
##   W = {ST, BT}
##   Z-X = {SH, BH}
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 SH←1 BH←0 ST←0 BT←0 ]✗
##   [ BS←1 BH←0 ST←0 BT←0 ]✗
##   [ BS←1 SH←1 ST←0 BT←0 ]✗
##   [ BS←1 ST←0 BT←0 ]✗
##   [ BS←1 SH←1 BH←0 BT←0 ]✓
##   [ BS←1 BH←0 BT←0 ]✓
##   [ BS←1 SH←1 BT←0 ]✓
##   [ BS←1 BT←0 ]✓
##   [ BS←1 SH←1 BH←0 ST←0 ]✗
##   [ BS←1 BH←0 ST←0 ]✗
##   [ BS←1 SH←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 SH←1 BH←0 ]✓
##   [ BS←1 BH←0 ]✓
##   [ BS←1 SH←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←1 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 SH←1 BH←0 ST←0 BT←1 ]✗
##   [ BS←1 BH←0 ST←0 BT←1 ]✗
##   [ BS←1 SH←1 ST←0 BT←1 ]✗
##   [ BS←1 ST←0 BT←1 ]✗
##   [ BS←1 SH←1 BH←0 BT←1 ]✓
##   [ BS←1 BH←0 BT←1 ]✓
##   [ BS←1 SH←1 BT←1 ]✓
##   [ BS←1 BT←1 ]✓
##   [ BS←1 SH←1 BH←0 ST←0 ]✗
##   [ BS←1 BH←0 ST←0 ]✗
##   [ BS←1 SH←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 SH←1 BH←0 ]✓
##   [ BS←1 BH←0 ]✓
##   [ BS←1 SH←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {BS}
##   W = {SH}
##   Z-X = {ST, BT, BH}
## 
## Trying partition:
##   X = {BS}
##   W = {ST, SH}
##   Z-X = {BT, BH}
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 SH←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 BT←1 BH←0 ST←0 SH←0 ]✗
##   [ BS←1 BH←0 ST←0 SH←0 ]✗
##   [ BS←1 BT←1 ST←0 SH←0 ]✗
##   [ BS←1 ST←0 SH←0 ]✗
##   [ BS←1 BT←1 BH←0 SH←0 ]✓
##   [ BS←1 BH←0 SH←0 ]✓
##   [ BS←1 BT←1 SH←0 ]✓
##   [ BS←1 SH←0 ]✓
##   [ BS←1 BT←1 BH←0 ST←0 ]✗
##   [ BS←1 BH←0 ST←0 ]✗
##   [ BS←1 BT←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 BT←1 BH←0 ]✓
##   [ BS←1 BH←0 ]✓
##   [ BS←1 BT←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 SH←1 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 BT←1 BH←0 ST←0 SH←1 ]✗
##   [ BS←1 BH←0 ST←0 SH←1 ]✗
##   [ BS←1 BT←1 ST←0 SH←1 ]✗
##   [ BS←1 ST←0 SH←1 ]✗
##   [ BS←1 BT←1 BH←0 SH←1 ]✓
##   [ BS←1 BH←0 SH←1 ]✓
##   [ BS←1 BT←1 SH←1 ]✓
##   [ BS←1 SH←1 ]✓
##   [ BS←1 BT←1 BH←0 ST←0 ]✗
##   [ BS←1 BH←0 ST←0 ]✗
##   [ BS←1 BT←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 BT←1 BH←0 ]✓
##   [ BS←1 BH←0 ]✓
##   [ BS←1 BT←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {BS}
##   W = {BT, SH}
##   Z-X = {ST, BH}
## 
## Trying partition:
##   X = {BS}
##   W = {ST, BT, SH}
##   Z-X = {BH}
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←0 SH←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 BH←0 ST←0 BT←0 SH←0 ]✗
##   [ BS←1 ST←0 BT←0 SH←0 ]✗
##   [ BS←1 BH←0 BT←0 SH←0 ]✓
##   [ BS←1 BT←0 SH←0 ]✓
##   [ BS←1 BH←0 ST←0 SH←0 ]✗
##   [ BS←1 ST←0 SH←0 ]✗
##   [ BS←1 BH←0 SH←0 ]✓
##   [ BS←1 SH←0 ]✓
##   [ BS←1 BH←0 ST←0 BT←0 ]✗
##   [ BS←1 ST←0 BT←0 ]✗
##   [ BS←1 BH←0 BT←0 ]✓
##   [ BS←1 BT←0 ]✓
##   [ BS←1 BH←0 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 BH←0 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←1 SH←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 BH←0 ST←0 BT←1 SH←0 ]✗
##   [ BS←1 ST←0 BT←1 SH←0 ]✗
##   [ BS←1 BH←0 BT←1 SH←0 ]✓
##   [ BS←1 BT←1 SH←0 ]✓
##   [ BS←1 BH←0 ST←0 SH←0 ]✗
##   [ BS←1 ST←0 SH←0 ]✗
##   [ BS←1 BH←0 SH←0 ]✓
##   [ BS←1 SH←0 ]✓
##   [ BS←1 BH←0 ST←0 BT←1 ]✗
##   [ BS←1 ST←0 BT←1 ]✗
##   [ BS←1 BH←0 BT←1 ]✓
##   [ BS←1 BT←1 ]✓
##   [ BS←1 BH←0 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 BH←0 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←0 SH←1 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 BH←0 ST←0 BT←0 SH←1 ]✗
##   [ BS←1 ST←0 BT←0 SH←1 ]✗
##   [ BS←1 BH←0 BT←0 SH←1 ]✓
##   [ BS←1 BT←0 SH←1 ]✓
##   [ BS←1 BH←0 ST←0 SH←1 ]✗
##   [ BS←1 ST←0 SH←1 ]✗
##   [ BS←1 BH←0 SH←1 ]✓
##   [ BS←1 SH←1 ]✓
##   [ BS←1 BH←0 ST←0 BT←0 ]✗
##   [ BS←1 ST←0 BT←0 ]✗
##   [ BS←1 BH←0 BT←0 ]✓
##   [ BS←1 BT←0 ]✓
##   [ BS←1 BH←0 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 BH←0 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←1 SH←1 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 BH←0 ST←0 BT←1 SH←1 ]✗
##   [ BS←1 ST←0 BT←1 SH←1 ]✗
##   [ BS←1 BH←0 BT←1 SH←1 ]✓
##   [ BS←1 BT←1 SH←1 ]✓
##   [ BS←1 BH←0 ST←0 SH←1 ]✗
##   [ BS←1 ST←0 SH←1 ]✗
##   [ BS←1 BH←0 SH←1 ]✓
##   [ BS←1 SH←1 ]✓
##   [ BS←1 BH←0 ST←0 BT←1 ]✗
##   [ BS←1 ST←0 BT←1 ]✗
##   [ BS←1 BH←0 BT←1 ]✓
##   [ BS←1 BT←1 ]✓
##   [ BS←1 BH←0 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 BH←0 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {BS}
##   W = {BH}
##   Z-X = {ST, BT, SH}
## 
## Trying partition:
##   X = {BS}
##   W = {ST, BH}
##   Z-X = {BT, SH}
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 BT←1 SH←1 ST←0 BH←0 ]✗
##   [ BS←1 SH←1 ST←0 BH←0 ]✗
##   [ BS←1 BT←1 ST←0 BH←0 ]✗
##   [ BS←1 ST←0 BH←0 ]✗
##   [ BS←1 BT←1 SH←1 BH←0 ]✓
##   [ BS←1 SH←1 BH←0 ]✓
##   [ BS←1 BT←1 BH←0 ]✓
##   [ BS←1 BH←0 ]✓
##   [ BS←1 BT←1 SH←1 ST←0 ]✗
##   [ BS←1 SH←1 ST←0 ]✗
##   [ BS←1 BT←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 BT←1 SH←1 ]✓
##   [ BS←1 SH←1 ]✓
##   [ BS←1 BT←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BH←1 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 BT←1 SH←1 ST←0 BH←1 ]✗
##   [ BS←1 SH←1 ST←0 BH←1 ]✗
##   [ BS←1 BT←1 ST←0 BH←1 ]✗
##   [ BS←1 ST←0 BH←1 ]✗
##   [ BS←1 BT←1 SH←1 BH←1 ]✓
##   [ BS←1 SH←1 BH←1 ]✓
##   [ BS←1 BT←1 BH←1 ]✓
##   [ BS←1 BH←1 ]✓
##   [ BS←1 BT←1 SH←1 ST←0 ]✗
##   [ BS←1 SH←1 ST←0 ]✗
##   [ BS←1 BT←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 BT←1 SH←1 ]✓
##   [ BS←1 SH←1 ]✓
##   [ BS←1 BT←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {BS}
##   W = {BT, BH}
##   Z-X = {ST, SH}
## 
## Trying partition:
##   X = {BS}
##   W = {ST, BT, BH}
##   Z-X = {SH}
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←0 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 SH←1 ST←0 BT←0 BH←0 ]✗
##   [ BS←1 ST←0 BT←0 BH←0 ]✗
##   [ BS←1 SH←1 BT←0 BH←0 ]✓
##   [ BS←1 BT←0 BH←0 ]✓
##   [ BS←1 SH←1 ST←0 BH←0 ]✗
##   [ BS←1 ST←0 BH←0 ]✗
##   [ BS←1 SH←1 BH←0 ]✓
##   [ BS←1 BH←0 ]✓
##   [ BS←1 SH←1 ST←0 BT←0 ]✗
##   [ BS←1 ST←0 BT←0 ]✗
##   [ BS←1 SH←1 BT←0 ]✓
##   [ BS←1 BT←0 ]✓
##   [ BS←1 SH←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 SH←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←1 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 SH←1 ST←0 BT←1 BH←0 ]✗
##   [ BS←1 ST←0 BT←1 BH←0 ]✗
##   [ BS←1 SH←1 BT←1 BH←0 ]✓
##   [ BS←1 BT←1 BH←0 ]✓
##   [ BS←1 SH←1 ST←0 BH←0 ]✗
##   [ BS←1 ST←0 BH←0 ]✗
##   [ BS←1 SH←1 BH←0 ]✓
##   [ BS←1 BH←0 ]✓
##   [ BS←1 SH←1 ST←0 BT←1 ]✗
##   [ BS←1 ST←0 BT←1 ]✗
##   [ BS←1 SH←1 BT←1 ]✓
##   [ BS←1 BT←1 ]✓
##   [ BS←1 SH←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 SH←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←0 BH←1 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 SH←1 ST←0 BT←0 BH←1 ]✗
##   [ BS←1 ST←0 BT←0 BH←1 ]✗
##   [ BS←1 SH←1 BT←0 BH←1 ]✓
##   [ BS←1 BT←0 BH←1 ]✓
##   [ BS←1 SH←1 ST←0 BH←1 ]✗
##   [ BS←1 ST←0 BH←1 ]✗
##   [ BS←1 SH←1 BH←1 ]✓
##   [ BS←1 BH←1 ]✓
##   [ BS←1 SH←1 ST←0 BT←0 ]✗
##   [ BS←1 ST←0 BT←0 ]✗
##   [ BS←1 SH←1 BT←0 ]✓
##   [ BS←1 BT←0 ]✓
##   [ BS←1 SH←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 SH←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←1 BH←1 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 SH←1 ST←0 BT←1 BH←1 ]✗
##   [ BS←1 ST←0 BT←1 BH←1 ]✗
##   [ BS←1 SH←1 BT←1 BH←1 ]✓
##   [ BS←1 BT←1 BH←1 ]✓
##   [ BS←1 SH←1 ST←0 BH←1 ]✗
##   [ BS←1 ST←0 BH←1 ]✗
##   [ BS←1 SH←1 BH←1 ]✓
##   [ BS←1 BH←1 ]✓
##   [ BS←1 SH←1 ST←0 BT←1 ]✗
##   [ BS←1 ST←0 BT←1 ]✗
##   [ BS←1 SH←1 BT←1 ]✓
##   [ BS←1 BT←1 ]✓
##   [ BS←1 SH←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 SH←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {BS}
##   W = {SH, BH}
##   Z-X = {ST, BT}
## 
## Trying partition:
##   X = {BS}
##   W = {ST, SH, BH}
##   Z-X = {BT}
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 SH←0 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 BT←1 ST←0 SH←0 BH←0 ]✗
##   [ BS←1 ST←0 SH←0 BH←0 ]✗
##   [ BS←1 BT←1 SH←0 BH←0 ]✓
##   [ BS←1 SH←0 BH←0 ]✓
##   [ BS←1 BT←1 ST←0 BH←0 ]✗
##   [ BS←1 ST←0 BH←0 ]✗
##   [ BS←1 BT←1 BH←0 ]✓
##   [ BS←1 BH←0 ]✓
##   [ BS←1 BT←1 ST←0 SH←0 ]✗
##   [ BS←1 ST←0 SH←0 ]✗
##   [ BS←1 BT←1 SH←0 ]✓
##   [ BS←1 SH←0 ]✓
##   [ BS←1 BT←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 BT←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 SH←1 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 BT←1 ST←0 SH←1 BH←0 ]✗
##   [ BS←1 ST←0 SH←1 BH←0 ]✗
##   [ BS←1 BT←1 SH←1 BH←0 ]✓
##   [ BS←1 SH←1 BH←0 ]✓
##   [ BS←1 BT←1 ST←0 BH←0 ]✗
##   [ BS←1 ST←0 BH←0 ]✗
##   [ BS←1 BT←1 BH←0 ]✓
##   [ BS←1 BH←0 ]✓
##   [ BS←1 BT←1 ST←0 SH←1 ]✗
##   [ BS←1 ST←0 SH←1 ]✗
##   [ BS←1 BT←1 SH←1 ]✓
##   [ BS←1 SH←1 ]✓
##   [ BS←1 BT←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 BT←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 SH←0 BH←1 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 BT←1 ST←0 SH←0 BH←1 ]✗
##   [ BS←1 ST←0 SH←0 BH←1 ]✗
##   [ BS←1 BT←1 SH←0 BH←1 ]✓
##   [ BS←1 SH←0 BH←1 ]✓
##   [ BS←1 BT←1 ST←0 BH←1 ]✗
##   [ BS←1 ST←0 BH←1 ]✗
##   [ BS←1 BT←1 BH←1 ]✓
##   [ BS←1 BH←1 ]✓
##   [ BS←1 BT←1 ST←0 SH←0 ]✗
##   [ BS←1 ST←0 SH←0 ]✗
##   [ BS←1 BT←1 SH←0 ]✓
##   [ BS←1 SH←0 ]✓
##   [ BS←1 BT←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 BT←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 SH←1 BH←1 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 BT←1 ST←0 SH←1 BH←1 ]✗
##   [ BS←1 ST←0 SH←1 BH←1 ]✗
##   [ BS←1 BT←1 SH←1 BH←1 ]✓
##   [ BS←1 SH←1 BH←1 ]✓
##   [ BS←1 BT←1 ST←0 BH←1 ]✗
##   [ BS←1 ST←0 BH←1 ]✗
##   [ BS←1 BT←1 BH←1 ]✓
##   [ BS←1 BH←1 ]✓
##   [ BS←1 BT←1 ST←0 SH←1 ]✗
##   [ BS←1 ST←0 SH←1 ]✗
##   [ BS←1 BT←1 SH←1 ]✓
##   [ BS←1 SH←1 ]✓
##   [ BS←1 BT←1 ST←0 ]✗
##   [ BS←1 ST←0 ]✗
##   [ BS←1 BT←1 ]✓
##   [ BS←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {BS}
##   W = {BT, SH, BH}
##   Z-X = {ST}
## 
## Trying partition:
##   X = {BS}
##   W = {ST, BT, SH, BH}
##   Z-X = {}
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←0 SH←0 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 ST←0 BT←0 SH←0 BH←0 ]✗
##   [ BS←1 BT←0 SH←0 BH←0 ]✓
##   [ BS←1 ST←0 SH←0 BH←0 ]✗
##   [ BS←1 SH←0 BH←0 ]✓
##   [ BS←1 ST←0 BT←0 BH←0 ]✗
##   [ BS←1 BT←0 BH←0 ]✓
##   [ BS←1 ST←0 BH←0 ]✗
##   [ BS←1 BH←0 ]✓
##   [ BS←1 ST←0 BT←0 SH←0 ]✗
##   [ BS←1 BT←0 SH←0 ]✓
##   [ BS←1 ST←0 SH←0 ]✗
##   [ BS←1 SH←0 ]✓
##   [ BS←1 ST←0 BT←0 ]✗
##   [ BS←1 BT←0 ]✓
##   [ BS←1 ST←0 ]✗
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←1 SH←0 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 ST←0 BT←1 SH←0 BH←0 ]✗
##   [ BS←1 BT←1 SH←0 BH←0 ]✓
##   [ BS←1 ST←0 SH←0 BH←0 ]✗
##   [ BS←1 SH←0 BH←0 ]✓
##   [ BS←1 ST←0 BT←1 BH←0 ]✗
##   [ BS←1 BT←1 BH←0 ]✓
##   [ BS←1 ST←0 BH←0 ]✗
##   [ BS←1 BH←0 ]✓
##   [ BS←1 ST←0 BT←1 SH←0 ]✗
##   [ BS←1 BT←1 SH←0 ]✓
##   [ BS←1 ST←0 SH←0 ]✗
##   [ BS←1 SH←0 ]✓
##   [ BS←1 ST←0 BT←1 ]✗
##   [ BS←1 BT←1 ]✓
##   [ BS←1 ST←0 ]✗
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←0 SH←1 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 ST←0 BT←0 SH←1 BH←0 ]✗
##   [ BS←1 BT←0 SH←1 BH←0 ]✓
##   [ BS←1 ST←0 SH←1 BH←0 ]✗
##   [ BS←1 SH←1 BH←0 ]✓
##   [ BS←1 ST←0 BT←0 BH←0 ]✗
##   [ BS←1 BT←0 BH←0 ]✓
##   [ BS←1 ST←0 BH←0 ]✗
##   [ BS←1 BH←0 ]✓
##   [ BS←1 ST←0 BT←0 SH←1 ]✗
##   [ BS←1 BT←0 SH←1 ]✓
##   [ BS←1 ST←0 SH←1 ]✗
##   [ BS←1 SH←1 ]✓
##   [ BS←1 ST←0 BT←0 ]✗
##   [ BS←1 BT←0 ]✓
##   [ BS←1 ST←0 ]✗
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←1 SH←1 BH←0 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 ST←0 BT←1 SH←1 BH←0 ]✗
##   [ BS←1 BT←1 SH←1 BH←0 ]✓
##   [ BS←1 ST←0 SH←1 BH←0 ]✗
##   [ BS←1 SH←1 BH←0 ]✓
##   [ BS←1 ST←0 BT←1 BH←0 ]✗
##   [ BS←1 BT←1 BH←0 ]✓
##   [ BS←1 ST←0 BH←0 ]✗
##   [ BS←1 BH←0 ]✓
##   [ BS←1 ST←0 BT←1 SH←1 ]✗
##   [ BS←1 BT←1 SH←1 ]✓
##   [ BS←1 ST←0 SH←1 ]✗
##   [ BS←1 SH←1 ]✓
##   [ BS←1 ST←0 BT←1 ]✗
##   [ BS←1 BT←1 ]✓
##   [ BS←1 ST←0 ]✗
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←0 SH←0 BH←1 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 ST←0 BT←0 SH←0 BH←1 ]✗
##   [ BS←1 BT←0 SH←0 BH←1 ]✓
##   [ BS←1 ST←0 SH←0 BH←1 ]✗
##   [ BS←1 SH←0 BH←1 ]✓
##   [ BS←1 ST←0 BT←0 BH←1 ]✗
##   [ BS←1 BT←0 BH←1 ]✓
##   [ BS←1 ST←0 BH←1 ]✗
##   [ BS←1 BH←1 ]✓
##   [ BS←1 ST←0 BT←0 SH←0 ]✗
##   [ BS←1 BT←0 SH←0 ]✓
##   [ BS←1 ST←0 SH←0 ]✗
##   [ BS←1 SH←0 ]✓
##   [ BS←1 ST←0 BT←0 ]✗
##   [ BS←1 BT←0 ]✓
##   [ BS←1 ST←0 ]✗
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←1 SH←0 BH←1 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 ST←0 BT←1 SH←0 BH←1 ]✗
##   [ BS←1 BT←1 SH←0 BH←1 ]✓
##   [ BS←1 ST←0 SH←0 BH←1 ]✗
##   [ BS←1 SH←0 BH←1 ]✓
##   [ BS←1 ST←0 BT←1 BH←1 ]✗
##   [ BS←1 BT←1 BH←1 ]✓
##   [ BS←1 ST←0 BH←1 ]✗
##   [ BS←1 BH←1 ]✓
##   [ BS←1 ST←0 BT←1 SH←0 ]✗
##   [ BS←1 BT←1 SH←0 ]✓
##   [ BS←1 ST←0 SH←0 ]✗
##   [ BS←1 SH←0 ]✓
##   [ BS←1 ST←0 BT←1 ]✗
##   [ BS←1 BT←1 ]✓
##   [ BS←1 ST←0 ]✗
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←0 SH←1 BH←1 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 ST←0 BT←0 SH←1 BH←1 ]✗
##   [ BS←1 BT←0 SH←1 BH←1 ]✓
##   [ BS←1 ST←0 SH←1 BH←1 ]✗
##   [ BS←1 SH←1 BH←1 ]✓
##   [ BS←1 ST←0 BT←0 BH←1 ]✗
##   [ BS←1 BT←0 BH←1 ]✓
##   [ BS←1 ST←0 BH←1 ]✗
##   [ BS←1 BH←1 ]✓
##   [ BS←1 ST←0 BT←0 SH←1 ]✗
##   [ BS←1 BT←0 SH←1 ]✓
##   [ BS←1 ST←0 SH←1 ]✗
##   [ BS←1 SH←1 ]✓
##   [ BS←1 ST←0 BT←0 ]✗
##   [ BS←1 BT←0 ]✓
##   [ BS←1 ST←0 ]✗
##   [ BS←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ BS←0 ST←0 BT←1 SH←1 BH←1 ]
## Testing AC2u(b) on subsets:
##   [ BS←1 ST←0 BT←1 SH←1 BH←1 ]✗
##   [ BS←1 BT←1 SH←1 BH←1 ]✓
##   [ BS←1 ST←0 SH←1 BH←1 ]✗
##   [ BS←1 SH←1 BH←1 ]✓
##   [ BS←1 ST←0 BT←1 BH←1 ]✗
##   [ BS←1 BT←1 BH←1 ]✓
##   [ BS←1 ST←0 BH←1 ]✗
##   [ BS←1 BH←1 ]✓
##   [ BS←1 ST←0 BT←1 SH←1 ]✗
##   [ BS←1 BT←1 SH←1 ]✓
##   [ BS←1 ST←0 SH←1 ]✗
##   [ BS←1 SH←1 ]✓
##   [ BS←1 ST←0 BT←1 ]✗
##   [ BS←1 BT←1 ]✓
##   [ BS←1 ST←0 ]✗
##   [ BS←1 ]✓
## AC2u(b) failed!
##   AC1  AC2u 
##  TRUE FALSE

It works!

Two people throwing bricks at a glasshouse

Now a moderately hard one (not quite as bad as above) which I use in the blog post.

mod_hard <- CausalMod$new(
  funs = list(
    AliceThrow  = \() 1,
    BobThrow    = \() 1,
    GlassBreaks = \(AliceThrow, BobThrow) max(AliceThrow, BobThrow)
  ), 
  ranges = list(
    AliceThrow  = c(0, 1),
    BobThrow    = c(0, 1),
    GlassBreaks = c(0, 1)
  )
)
mod_hard$AC(\(AliceThrow) AliceThrow == 1, \(GlassBreaks) GlassBreaks == 1)
## 
## Trying partition:
##   X = {AliceThrow}
##   W = {}
##   Z-X = {BobThrow, GlassBreaks}
## 
## Trying partition:
##   X = {AliceThrow}
##   W = {BobThrow}
##   Z-X = {GlassBreaks}
## AC2u(a) PASSED on: 
##   [ AliceThrow←0 BobThrow←0 ]
## Testing AC2u(b) on subsets:
##   [ AliceThrow←1 GlassBreaks←1 BobThrow←0 ]✓
##   [ AliceThrow←1 BobThrow←0 ]✓
##   [ AliceThrow←1 GlassBreaks←1 ]✓
##   [ AliceThrow←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {AliceThrow}
##   W = {GlassBreaks}
##   Z-X = {BobThrow}
## AC2u(a) PASSED on: 
##   [ AliceThrow←0 GlassBreaks←0 ]
## Testing AC2u(b) on subsets:
##   [ AliceThrow←1 BobThrow←1 GlassBreaks←0 ]✗
##   [ AliceThrow←1 GlassBreaks←0 ]✗
##   [ AliceThrow←1 BobThrow←1 ]✓
##   [ AliceThrow←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {AliceThrow}
##   W = {BobThrow, GlassBreaks}
##   Z-X = {}
## AC2u(a) PASSED on: 
##   [ AliceThrow←0 BobThrow←0 GlassBreaks←0 ]
## Testing AC2u(b) on subsets:
##   [ AliceThrow←1 BobThrow←0 GlassBreaks←0 ]✗
##   [ AliceThrow←1 GlassBreaks←0 ]✗
##   [ AliceThrow←1 BobThrow←0 ]✓
##   [ AliceThrow←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ AliceThrow←0 BobThrow←1 GlassBreaks←0 ]
## Testing AC2u(b) on subsets:
##   [ AliceThrow←1 BobThrow←1 GlassBreaks←0 ]✗
##   [ AliceThrow←1 GlassBreaks←0 ]✗
##   [ AliceThrow←1 BobThrow←1 ]✓
##   [ AliceThrow←1 ]✓
## AC2u(b) failed!
##  AC1 AC2u 
## TRUE TRUE
mod_hard$AC(\(GlassBreaks) GlassBreaks == 1,
            \(AliceThrow) AliceThrow == 1)
## 
## Trying partition:
##   X = {GlassBreaks}
##   W = {}
##   Z-X = {AliceThrow, BobThrow}
## 
## Trying partition:
##   X = {GlassBreaks}
##   W = {AliceThrow}
##   Z-X = {BobThrow}
## AC2u(a) PASSED on: 
##   [ GlassBreaks←0 AliceThrow←0 ]
## Testing AC2u(b) on subsets:
##   [ GlassBreaks←1 BobThrow←1 AliceThrow←0 ]✗
##   [ GlassBreaks←1 AliceThrow←0 ]✗
##   [ GlassBreaks←1 BobThrow←1 ]✓
##   [ GlassBreaks←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {GlassBreaks}
##   W = {BobThrow}
##   Z-X = {AliceThrow}
## 
## Trying partition:
##   X = {GlassBreaks}
##   W = {AliceThrow, BobThrow}
##   Z-X = {}
## AC2u(a) PASSED on: 
##   [ GlassBreaks←0 AliceThrow←0 BobThrow←0 ]
## Testing AC2u(b) on subsets:
##   [ GlassBreaks←1 AliceThrow←0 BobThrow←0 ]✗
##   [ GlassBreaks←1 BobThrow←0 ]✓
##   [ GlassBreaks←1 AliceThrow←0 ]✗
##   [ GlassBreaks←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ GlassBreaks←0 AliceThrow←0 BobThrow←1 ]
## Testing AC2u(b) on subsets:
##   [ GlassBreaks←1 AliceThrow←0 BobThrow←1 ]✗
##   [ GlassBreaks←1 BobThrow←1 ]✓
##   [ GlassBreaks←1 AliceThrow←0 ]✗
##   [ GlassBreaks←1 ]✓
## AC2u(b) failed!
##   AC1  AC2u 
##  TRUE FALSE

Scriven example

scriven_ex <- CausalMod$new(
  funs = list(
    jumped_t0       = \() 1,
    shot_mid_flight = \() 1,
    dead_t1         = \(jumped_t0, shot_mid_flight)
                                min(jumped_t0, shot_mid_flight),
    dead_t2         = \(jumped_t0) jumped_t0
  ), 
  ranges = list(
    jumped_t0       = c(0, 1),
    shot_mid_flight = c(0, 1),
    dead_t1         = c(0, 1),
    dead_t2         = c(0, 1)
  )
)

Does jumping at t0 lead to death at t2?

scriven_ex$AC(\(jumped_t0) jumped_t0 == 1,
              \(dead_t2)   dead_t2 == 1)
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {}
##   Z-X = {shot_mid_flight, dead_t1, dead_t2}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t1←1 dead_t2←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {shot_mid_flight}
##   Z-X = {dead_t1, dead_t2}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t1←1 dead_t2←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 dead_t1←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←1 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t1←1 dead_t2←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 dead_t1←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {dead_t1}
##   Z-X = {shot_mid_flight, dead_t2}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 dead_t1←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←1 dead_t1←0 ]✓
##   [ jumped_t0←1 dead_t2←1 dead_t1←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 ]✓
##   [ jumped_t0←1 dead_t1←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 dead_t1←1 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←1 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t2←1 dead_t1←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {shot_mid_flight, dead_t1}
##   Z-X = {dead_t2}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←0 dead_t1←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←0 dead_t1←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 dead_t1←0 ]✓
##   [ jumped_t0←1 dead_t2←1 dead_t1←0 ]✓
##   [ jumped_t0←1 dead_t1←0 ]✓
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←1 dead_t1←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←1 dead_t1←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 ]✓
##   [ jumped_t0←1 dead_t2←1 dead_t1←0 ]✓
##   [ jumped_t0←1 dead_t1←0 ]✓
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←0 dead_t1←1 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←0 dead_t1←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t2←1 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←1 dead_t1←1 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←1 dead_t1←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t2←1 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {dead_t2}
##   Z-X = {shot_mid_flight, dead_t1}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←1 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {shot_mid_flight, dead_t2}
##   Z-X = {dead_t1}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←0 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←0 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←1 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←1 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←1 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←1 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {dead_t1, dead_t2}
##   Z-X = {shot_mid_flight}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 dead_t1←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←0 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 ]✓
##   [ jumped_t0←1 dead_t1←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 dead_t1←1 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←1 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {shot_mid_flight, dead_t1, dead_t2}
##   Z-X = {}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←0 dead_t1←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←0 dead_t1←0 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←0 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←0 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←0 dead_t1←0 ]✓
##   [ jumped_t0←1 dead_t1←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←1 dead_t1←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←0 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 ]✓
##   [ jumped_t0←1 dead_t1←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←0 dead_t1←1 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←0 dead_t1←1 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←1 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←0 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←0 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←1 dead_t1←1 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←1 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
##  AC1 AC2u 
## TRUE TRUE

Does jumping at t0 cause death at t1?

scriven_ex$AC(\(jumped_t0) jumped_t0 == 1,
              \(dead_t1)   dead_t1 == 1)
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {}
##   Z-X = {shot_mid_flight, dead_t1, dead_t2}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t1←1 dead_t2←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {shot_mid_flight}
##   Z-X = {dead_t1, dead_t2}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t1←1 dead_t2←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←0 ]✗
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 ]✗
##   [ jumped_t0←1 dead_t1←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←1 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t1←1 dead_t2←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 dead_t1←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {dead_t1}
##   Z-X = {shot_mid_flight, dead_t2}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 dead_t1←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←1 dead_t1←0 ]✗
##   [ jumped_t0←1 dead_t2←1 dead_t1←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 ]✗
##   [ jumped_t0←1 dead_t1←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {shot_mid_flight, dead_t1}
##   Z-X = {dead_t2}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←0 dead_t1←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←0 dead_t1←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←0 dead_t1←0 ]✗
##   [ jumped_t0←1 dead_t2←1 dead_t1←0 ]✗
##   [ jumped_t0←1 dead_t1←0 ]✗
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←0 ]✗
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←1 dead_t1←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←1 dead_t1←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 ]✗
##   [ jumped_t0←1 dead_t2←1 dead_t1←0 ]✗
##   [ jumped_t0←1 dead_t1←0 ]✗
##   [ jumped_t0←1 dead_t2←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {dead_t2}
##   Z-X = {shot_mid_flight, dead_t1}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 dead_t2←0 ]✓
##   [ jumped_t0←1 dead_t1←1 dead_t2←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←0 ]✓
##   [ jumped_t0←1 dead_t2←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 dead_t2←1 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t1←1 dead_t2←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {shot_mid_flight, dead_t2}
##   Z-X = {dead_t1}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←0 dead_t2←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←1 dead_t2←0 ]✓
##   [ jumped_t0←1 dead_t2←0 ]✓
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 ]✗
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←1 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←1 dead_t2←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←0 ]✓
##   [ jumped_t0←1 dead_t1←1 dead_t2←0 ]✓
##   [ jumped_t0←1 dead_t2←0 ]✓
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←0 dead_t2←1 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←0 dead_t2←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 dead_t2←1 ]✗
##   [ jumped_t0←1 dead_t1←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 ]✗
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←1 dead_t2←1 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←1 dead_t2←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t1←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t1←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 dead_t1←1 ]✓
##   [ jumped_t0←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {dead_t1, dead_t2}
##   Z-X = {shot_mid_flight}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 dead_t1←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←0 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←0 ]✓
##   [ jumped_t0←1 dead_t2←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 ]✗
##   [ jumped_t0←1 dead_t1←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 dead_t1←0 dead_t2←1 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 dead_t2←1 ]✗
##   [ jumped_t0←1 dead_t1←0 dead_t2←1 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 ]✗
##   [ jumped_t0←1 dead_t1←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {jumped_t0}
##   W = {shot_mid_flight, dead_t1, dead_t2}
##   Z-X = {}
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←0 dead_t1←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←0 dead_t1←0 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←0 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←0 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t2←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 dead_t1←0 ]✗
##   [ jumped_t0←1 dead_t1←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←0 ]✗
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←1 dead_t1←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 dead_t2←0 ]✗
##   [ jumped_t0←1 dead_t1←0 dead_t2←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←0 ]✓
##   [ jumped_t0←1 dead_t2←0 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 ]✗
##   [ jumped_t0←1 dead_t1←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←0 dead_t1←0 dead_t2←1 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←0 dead_t1←0 dead_t2←1 ]✗
##   [ jumped_t0←1 dead_t1←0 dead_t2←1 ]✗
##   [ jumped_t0←1 shot_mid_flight←0 dead_t2←1 ]✗
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←0 dead_t1←0 ]✗
##   [ jumped_t0←1 dead_t1←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←0 ]✗
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ jumped_t0←0 shot_mid_flight←1 dead_t1←0 dead_t2←1 ]
## Testing AC2u(b) on subsets:
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 dead_t2←1 ]✗
##   [ jumped_t0←1 dead_t1←0 dead_t2←1 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 dead_t2←1 ]✓
##   [ jumped_t0←1 dead_t2←1 ]✓
##   [ jumped_t0←1 shot_mid_flight←1 dead_t1←0 ]✗
##   [ jumped_t0←1 dead_t1←0 ]✗
##   [ jumped_t0←1 shot_mid_flight←1 ]✓
##   [ jumped_t0←1 ]✓
## AC2u(b) failed!
##  AC1 AC2u 
## TRUE TRUE
scriven_ex$AC(\(shot_mid_flight) shot_mid_flight == 1,
              \(dead_t1) dead_t1 == 1)
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {}
##   Z-X = {jumped_t0, dead_t1, dead_t2}
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {jumped_t0}
##   Z-X = {dead_t1, dead_t2}
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←1 jumped_t0←0 ]✓
##   [ shot_mid_flight←1 dead_t2←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←1 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 dead_t2←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {dead_t1}
##   Z-X = {jumped_t0, dead_t2}
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 dead_t1←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t2←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {jumped_t0, dead_t1}
##   Z-X = {dead_t2}
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←0 dead_t1←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 dead_t2←1 jumped_t0←0 dead_t1←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←0 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t2←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t2←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←1 dead_t1←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 dead_t2←1 jumped_t0←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t2←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t2←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {dead_t2}
##   Z-X = {jumped_t0, dead_t1}
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 dead_t2←1 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {jumped_t0, dead_t2}
##   Z-X = {dead_t1}
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←0 dead_t2←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←1 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←0 dead_t2←1 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←0 dead_t2←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←0 dead_t2←1 ]✗
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←1 dead_t2←1 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 ]✓
## ✓✓ AC2(a) and AC2u(b)!
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {dead_t1, dead_t2}
##   Z-X = {jumped_t0}
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 dead_t1←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 dead_t1←0 dead_t2←1 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←0 dead_t2←1 ]✗
##   [ shot_mid_flight←1 dead_t1←0 dead_t2←1 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {jumped_t0, dead_t1, dead_t2}
##   Z-X = {}
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←0 dead_t1←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←0 dead_t1←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←0 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←1 dead_t1←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 dead_t2←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←0 dead_t1←0 dead_t2←1 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←0 dead_t1←0 dead_t2←1 ]✗
##   [ shot_mid_flight←1 dead_t1←0 dead_t2←1 ]✗
##   [ shot_mid_flight←1 jumped_t0←0 dead_t2←1 ]✗
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←0 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←1 dead_t1←0 dead_t2←1 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←0 dead_t2←1 ]✗
##   [ shot_mid_flight←1 dead_t1←0 dead_t2←1 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
##  AC1 AC2u 
## TRUE TRUE
scriven_ex$AC(\(shot_mid_flight) shot_mid_flight == 1,
              \(dead_t2) dead_t2 == 1)
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {}
##   Z-X = {jumped_t0, dead_t1, dead_t2}
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {jumped_t0}
##   Z-X = {dead_t1, dead_t2}
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←1 jumped_t0←0 ]✓
##   [ shot_mid_flight←1 dead_t2←1 jumped_t0←0 ]✓
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {dead_t1}
##   Z-X = {jumped_t0, dead_t2}
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {jumped_t0, dead_t1}
##   Z-X = {dead_t2}
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←0 dead_t1←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 dead_t2←1 jumped_t0←0 dead_t1←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←0 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t2←1 dead_t1←0 ]✓
##   [ shot_mid_flight←1 dead_t1←0 ]✓
##   [ shot_mid_flight←1 dead_t2←1 jumped_t0←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←0 dead_t1←1 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 dead_t2←1 jumped_t0←0 dead_t1←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←0 dead_t1←1 ]✗
##   [ shot_mid_flight←1 dead_t2←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 dead_t2←1 jumped_t0←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 dead_t2←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {dead_t2}
##   Z-X = {jumped_t0, dead_t1}
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {jumped_t0, dead_t2}
##   Z-X = {dead_t1}
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←1 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {dead_t1, dead_t2}
##   Z-X = {jumped_t0}
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 dead_t1←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←0 ]✓
##   [ shot_mid_flight←1 dead_t1←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 dead_t1←1 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## 
## Trying partition:
##   X = {shot_mid_flight}
##   W = {jumped_t0, dead_t1, dead_t2}
##   Z-X = {}
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←0 dead_t1←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←0 dead_t1←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←0 dead_t1←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←1 dead_t1←0 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←0 ]✓
##   [ shot_mid_flight←1 dead_t1←0 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←0 dead_t1←1 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←0 dead_t1←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←0 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←0 dead_t1←1 ]✗
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←0 ]✗
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
## AC2u(a) PASSED on: 
##   [ shot_mid_flight←0 jumped_t0←1 dead_t1←1 dead_t2←0 ]
## Testing AC2u(b) on subsets:
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t1←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 dead_t2←0 ]✗
##   [ shot_mid_flight←1 jumped_t0←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 dead_t1←1 ]✓
##   [ shot_mid_flight←1 jumped_t0←1 ]✓
##   [ shot_mid_flight←1 ]✓
## AC2u(b) failed!
##   AC1  AC2u 
##  TRUE FALSE