!7

sbool killDB = false;

static int defaultMax = 1000; // steps to run

sS facts = [[

  We want to find out what is more correct than what.

  "not correct" is a candidate.

  "maybe quite correct" is a candidate.

  "really really correct" is a candidate.

  "buggy" is a candidate.

  "total garbage" is a candidate.

  "incorrect" is a candidate.

  "almost correct" is a candidate.

  "absolutely correct" is a candidate.

  "very correct" is a candidate.

  [nfhwfngqkgoqtngs] (no question) and (X is a candidate.) and (Y is a candidate.) and (X <> Y) and (There is no answer to (Is X # more correct than Y?).) => (Ask (Is X # more correct than Y?))

  // Note: The # is just a filler for parsing, we'll get rid of that in time. Also, you will be able to write stuff without brackets of course.

  Always apply rule nfhwfngqkgoqtngs.

  // Interpret answers

  [iprphzfmwithvdfb] (The answer to (Is X # Y than Z?) is yes.) => (X is Y than Z.)

  Always apply rule iprphzfmwithvdfb.

  [udsmtmbiedmxtxci] (The answer to (Is X # Y than Z?) is no.) => (Z is Y than X.)

  Always apply rule udsmtmbiedmxtxci.

  // Transitivity!

  [pglcuchrtxdmlfvh] (X is AA than Y.) and (Y is AA than Z.) => (X is AA than Z.)

  Always apply rule pglcuchrtxdmlfvh.

  [ijziyiplzanfwvqx] (Ask (X)) and (The answer to X is Y.) => (Remove (Ask (X)))

  Always apply rule ijziyiplzanfwvqx.

  no question :- There is no statement with operator fxxathfdlfzgmaov.

  // Just a pretty-printing statement

  omrvwjslbkffaxoj hszwyiyetuuhcfwz acwmbrxqrlaplyqu

]];

sS concepts = [[

  ufzlismnlhvbjqoj - (X) and (Y) and (Z) and (AA) and (AB) => (AC)

  phkdhqkhzytkwdpb - (X) and (Y) and (Z) and (AA) => (AB)

  txsysipmstxmjhmi - (X) and (Y) => (Z)

  wziyypnyayfphdxs - (X) => (Y)

  xikyminwmeahxiws - There is no answer to (X).

  tlwrjpzuteopednt - The answer to X is Y.

  cdzttdbxadjreorm - We want to find out what is X than what.

  ogqdgzepqbunuuht - X is a candidate.

  hszwyiyetuuhcfwz - Is X # Y than Z?

  acwmbrxqrlaplyqu - Is "X" Y than "Z"?

  qgxjwufpfzkqvmxb - X is Y than Z.

  ylvaoplzguvhegka - X is not Y than Z.

  zxucpbfzmexohoiv - It is not true that (X).

  buahjsodljsaxvaq - X <> Y

  fxxathfdlfzgmaov - Ask (X)

  chjllkocfhtwcgoj - Remove (X)

  mzdvauejerzefagk - I don't know if (X)

  omrvwjslbkffaxoj - Format operator X as template Y.

  houyieutcmfdvgmz - Execute (X)

  hzmtabxcmkrtffgh - Apply X

  zvknqzxlrmuobnzx - Always apply rule X.

  plprefzezbluijrw - no question

  jexyjrtbtilmsmfw - setQuestion(X)

  cuutddpitkuswthu - While (X) => (Y)

  sicrogpdrtkiptun - X :- Y

  zhoulgsatpswstfa - There is no statement with operator X.

  ltyqczktgtjxrtlf - more correct

  zveeggveflecjwvr - total garbage

  wolealpbqkkqkvqq - not correct

  tomkbzlqlpeiekvu - maybe quite correct

  dnxyynujqydgcxcd - really really correct

  trajdgvqepyhsumb - buggy

  lwikikhkydtewtjc - incorrect

  muxjpepnjiyjghwj - almost correct

  wtnpjovqqiswlyay - absolutely correct

  bmliokweerblfxco - very correct

]];

concept MyTruth {

  S globalID;

  Lisp term;

  S madeByRule;

  *() {}

  *(S *globalID, Lisp *term, S *madeByRule) { change(); }

}

static Map<S, F1<Lisp, Bool>> evaluators = new HashMap;

static Lisp currentQuestion;

p-tt {

  centerHigherConsole();

  substance();

  // customize parsing and printing

  set englishToConceptLanguage_unquote;

  set englishToConceptLanguage_simple_noXYZ;

  set formatXYZ_quotedVars;

  // load predefined & learned statements

  useConceptsAndStatements(concepts, facts);

  if (killDB) deleteDB();

  db();

  for (MyTruth t)

    lispAddLocalTruth(t.globalID, t.term);

  printLispStatements();

  // create evaluators

  // X <> Y

  evaluators.put("buahjsodljsaxvaq", new F1<Lisp,Bool>() {

    Bool get(Lisp l) {

      ret l.size() == 2 && neq(l.get(0), l.get(1));

    }

  });

  // I don't know if (X)

  evaluators.put("mzdvauejerzefagk", new F1<Lisp,Bool>() {

    Bool get(Lisp l) {

      ret l.size() == 1 && notKnownIf(l.get(0));

    }

  });

  // There is no statement with operator X.

  evaluators.put("zhoulgsatpswstfa", new F1<Lisp,Bool>() {

    Bool get(Lisp l) {

      ret l.size() == 1 && !hasTruthWithHead(l.raw(0));

    }

  });

  // There is no answer to (X).

  evaluators.put("xikyminwmeahxiws", new F1<Lisp,Bool>() {

    Bool get(Lisp l) {

      bool ok = l.size() == 1 && null == lispForward("tlwrjpzuteopednt", l.get(0));

      print("Checking for answer to " + l.get(0) + " => " + ok);

      ret ok;

    }

  });

  // :- rules

  for (final Lisp rule : lispTruth2("sicrogpdrtkiptun"))

    evaluators.put(rule.raw(0), new F1<Lisp,Bool>() {

    Bool get(Lisp l) {

      ret l.isLeaf() && matchCondition(rule.get(1));

    }

  });

  bot();

  //applyRule("nfhwfngqkgoqtngs");

  //applyAlwaysRules();

  //runInstruction("yrgkrfrcwubpevzu");

}

answer {

  if "lisp" { printLispStatements(); ret "ok"; }

  if "print" { printPrettyFacts(); ret "ok"; }

  if "rule *" { applyRule($1); ret "ok"; }

  if "step" { applyAlwaysRules_step(); ret "ok"; }

  if "run" { applyAlwaysRules(defaultMax); ret "ok"; }

  if "force" { force(defaultMax); ret "ok"; }

}

svoid showQuestion() {

  L<Lisp> l = lispTruth1("fxxathfdlfzgmaov");

  if (l(l) > 1) warn("Multiple open questions");

  if (nempty(l)) {

    final Lisp q = first(l).get(0);

    if (eq(currentQuestion, q)) ret;

    currentQuestion = q;

    print("Question: " + q);

    swing {

      showControls2(

        centerAndSouth(

          withBottomMargin(jcenteredBoldLabel(lispToEnglish_prettier(q))),

          jcenteredline(answerButton("Yes"), answerButton("No"), answerButton("I don't know")));

    }

  }

}

svoid runInstruction(S instructionID) {

  Lisp rule = getLispTruth(instructionID);

  if (rule == null) { print("Instruction not found: " + instructionID); ret; }

  runInstruction(rule);

}

svoid runInstruction(Lisp rule) {

  print("runInstruction: " + rule);

  if (rule.is("hzmtabxcmkrtffgh", 1)) // Apply X

    applyRule(rule.raw(0));

  else if (rule.is("cuutddpitkuswthu", 2)) { // While (X) => (Y)

    while (ping() && matchCondition(rule.get(0)))

      runInstruction(rule.get(1));

  } /*else if (rule.is("houyieutcmfdvgmz", 1))

    execute(rule.get(0));

  /*else if (rule.is("jexyjrtbtilmsmfw", 1)) // setQuestion(X)

    setQuestion(rule.get(0));*/

  else print("Unknown instruction type: " + rule);

}

svoid applyRule(S ruleID) {

  // process the rule

  Lisp rule = getLispTruth(ruleID);

  if (rule == null) { print("Rule not found: " + ruleID); ret; }

  //print("Applying rule " + ruleID);

  print_setPrefixForThread(ruleID + "> ");

  try {

    L<Lisp> conditions = dropLast(rule.args);

    Lisp out = last(rule.args);

    //for (Lisp cond : conditions) print("Condition: " + cond);

    new Map<S, Lisp> matches;

    int n = matchConditions_random(conditions, matches);

    if (n == -1) {

      print("Yo! " + struct(matches));

      out = lispReplaceVars(out, matches);

      if (lispTrue(out))

        print("Already had: " + out);

      else {

        print("Defining: " + lispToEnglish_prettier(out));

        emit(out, ruleID);

      }

    } else

      print("Only " + n + " of " + n(conditions, "condition") + " met");

  } finally {

    print_setPrefixForThread("");

  }

}

// if match: returns -1

// if no match: returns how many conditions were met

static int matchConditions_random(L<Lisp> conditions, Map<S, Lisp> m) {

  if (empty(conditions)) ret -1;

  Lisp condition = first(conditions);

  Map<S, Lisp> m2 = cloneMap(m);

  if (!matchCondition_random(condition, m2)) {

    print("Condition failed: " + condition);

    ret 0;

  }

  print("Condition matched, " + struct(m2));

  int n = matchConditions_random(dropFirst(conditions), m2);

  if (n == -1) {

    m.putAll(m2);

    ret -1;

  }

  ret n+1; // failure

}

sbool matchCondition(Lisp condition) {

  print("matchCondition " + condition);

  O evaluator = evaluators.get(condition.head);

  if (evaluator != null)

    ret isTrue(callF(evaluator, condition));

  ret lispTrue(condition);

}

static bool matchCondition_random(Lisp condition, Map<S, Lisp> m) {

  L<Lisp> facts = lispTruth();

  O evaluator = evaluators.get(condition.head);

  if (evaluator != null)

    ret isTrue(callF(evaluator, lispReplaceVars(condition, m)));

  L<Map<S, Lisp>> candidates = new L;

  for (Lisp fact : facts) {

    Map<S, Lisp> m2 = cloneMap(m);

    if (lispMatchIC_xyzVars_sub(condition, fact, m2))

      candidates.add(m2);

  }

  //print("Have " + n(candidates, "candidate"));

  if (empty(candidates)) false;

  m.putAll(random(candidates));

  true;

}

svoid force(long steps) {

  for (long step = 0; step < steps; step++)

    applyAlwaysRules_step();

}

svoid applyAlwaysRules(long maxSteps) {

  long count = 0, step = 0;

  do {

    count = lispChangeCount();

    applyAlwaysRules_step();

  } while (++step < maxSteps && lispChangeCount() != count);

}

svoid applyAlwaysRules_step() {

  for (Lisp l : lispTruth1("zvknqzxlrmuobnzx"))

    applyRule(l.raw(0)); // TODO: not only random application

  for (Lisp l : lispTruth1("chjllkocfhtwcgoj")) { // Remove (X)

    unemit(l);

    unemit(l.get(0));

  }

  for (Lisp l : lispTruth1("hzmtabxcmkrtffgh")) { // Apply X

    unemit(l);

    applyRule(l.raw(0));

  }

  showQuestion();

}

svoid emit(Lisp l, S madeByRule) {

  LispStatement s = lispAddLocalTruth(l);

  if (s != null)

    new MyTruth(s.globalID, l, madeByRule);

}

svoid unemit(Lisp l) {

  LispStatement s = findLispStatement(l);

  if (s == null) ret;

  removeLispStatement(s);

  deleteConcepts(MyTruth, globalID := s.globalID);

}

static JButton answerButton(fS text) {

  ret jbutton(text, r {

    emit(lisp("tlwrjpzuteopednt", currentQuestion, englishToLisp(text)), "button");

    applyAlwaysRules(defaultMax);

  });

}