sclass OneColorTheoryChecker {
  replace Cell with URecognizer.Cell.
  
  new ProbabilisticScheduler scheduler;
  
  sclass Theory {
    // values are: withProbability(strengthOfEvidence, probabilityOfTheory)
    new MultiMap<S, WithProbability<Double>> examples;
    double strengthSum, probabilitySum;
    
    double currentProbabilityGuess() {
      ret doubleRatio(probabilitySum, strengthSum);
    }
    
    S renderProbabilityGuess() {
      ret "Current probability guess (evidence count " + n2(l(examples)) + "): " + formatDouble3X(currentProbabilityGuess()) + " with strength " + formatDouble3(strengthSum);
    }
    
    bool hasExampleNamed(S name) { ret examples.containsKey(name); }
    
    void addEvidence(S desc, double probabilityOfTheory, double strengthOfEvidence) {
      examples.add(desc, withProbability(strengthOfEvidence, probabilityOfTheory));
      probabilitySum += probabilityOfTheory*strengthOfEvidence;
      strengthSum += strengthOfEvidence;
    }
    
    S toStringWithEvidence() {
      ret toString() + "\n\n"
        + pnlToString("EVIDENCE", multiMapToPairs(examples));
    }
  }
  
  record OneColorTheory(S text, Cell cell, RGB color) > Theory {
    toString {
      ret renderProbabilityGuess() + ": " + dollarVarsMeanFields(text, this);
    }
    
    selfType branch(O... _) { this; }
  }
  
  // create the theory object and initiate the reasoning
  // you have to step the scheduler afterwards to get results
  OneColorTheory makeTheory(Cell cell) {
    var color = cell.averageColor();

    var theory = new OneColorTheory("Color of every pixel in $cell is $color.", cell, color);
  
    testOneColorTheory(cell, theory);
    ret theory;
  }

  void noteCellColor(Cell cell, OneColorTheory theory) {
    var desc = "Pixel check at " + cell;
    if (theory.hasExampleNamed(desc)) return;
    var strength = doubleRatio(cell.area(), theory.cell.area()); // how much do we have to say about the cell in the theory?
    var p = colorDistanceToProbability(cell.averageColor(), theory.color);
    addExampleToTheory(theory, desc, p, strength);
  }
  
  double colorDistanceToProbability(RGB col1, RGB col2) {
    double sim = colorSimilarity(col1, col2), sqr = sqr(sim);
    printFunctionCall colorDistanceToProbability(+col1, +col2, +sim, +sqr);
    ret sqr;
  }
  
  void testOneColorTheory(Cell cell, OneColorTheory theory) {  
    noteCellColor(cell, theory);
  
    scheduler.atRelative(dontZoomTooFar(cell), r {
      for (var split : usefulSplits(cell))
        scheduler.atRelative(split.probability(), r {
          for (var cell : split!)
            testOneColorTheory(cell, theory.branch(description := "recursion to " + cell));
        });
    });
  }
  
  L<WithProbability<Cell[]>> usefulSplits(Cell cell) {
    ret map withProbability1(llNonNulls(cell.split(0, 2), cell.split(1, 2)));
  }
  
  // probability penalty .25 for zooming in 3 steps
  double dontZoomTooFar(Cell cell) {
    ret 0.75;
  }
  
  void addExampleToTheory(Theory theory, S desc, double probabilityOfTheory, double strengthOfEvidence) {
    theory.addEvidence(desc, probabilityOfTheory, /* scheduler.currentProbability()* */ strengthOfEvidence);
  }
}