FactRules constructor

FactRules(List<String> rules)

Implementation

FactRules(List<String> rules) {
  // --- parse and process rules ---
  final p = Prover();
  for (final rule in rules) {
    final split = rule.split(RegExp(r"\s+"));
    final (aRaw, op, bRaw) = (split[0], split[1], split.sublist(2).join(' '));

    final a = Logic.fromString(aRaw);
    final b = Logic.fromString(bRaw);

    if (op == "->") {
      p.processRule(a, b);
    } else if (op == "==") {
      p.processRule(a, b);
      p.processRule(b, a);
    } else {
      throw ArgumentError("Unknown operator $op");
    }
  }

  // --- build deduction networks ---
  betaRules = [
    for (final (bCond, bImpl) in p.rulesBeta)
      (
        {
          for (final a in bCond.args) _asPair(a),
        },
        _asPair(bImpl),
      ),
  ];

  // deduce alpha implications
  final implA = deduceAlphaImplications(p.rulesAlpha);

  // now:
  // - apply beta rules to alpha chains  (static extension), and
  // - further associate beta rules to alpha chain (for inference
  //    at runtime)
  final implAB = applyBetaToAlphaRoute(implA, p.rulesBeta);

  // extract defined fact names
  definedFacts = {
    for (final k in implAB.keys) _baseFact(k),
  };

  // build rels (forward chains)
  for (final entry in implAB.entries) {
    final k = entry.key;
    final (impl, betaIdxs) = entry.value;
    fullImplications[_asPair(k)] = {
      for (final i in impl) _asPair(i),
    };
    betaTriggers[_asPair(k)] = betaIdxs;
  }

  // build prereq (backward chains)
  final relPrereq = rules2Prereq(fullImplications);
  relPrereq.forEach((k, pItems) {
    if (!prereq.containsKey(k)) {
      prereq[k] = <Logic>{};
    }
    prereq[k].addAll(pItems);
  });
}