public static void induceInferenceRules(Symbol relationName, Symbol className) {
    relationName = ((Symbol)(relationName.permanentify()));
    Logic.clearCases();
    Logic.clearTrainingExamples();
    Logic.$INDUCED_DECISION_RULES$ = List.newList();
    className = ((Symbol)(className.permanentify()));
    { Surrogate renamed_Class = Logic.getDescription(className).surrogateValueInverse;
      Surrogate relation = Logic.getDescription(relationName).surrogateValueInverse;
      List ilist = Logic.allClassInstances(renamed_Class).listify();
      int num = ilist.length();
      Vector instances = Vector.newVector(num);

      { Stella_Object instance = null;
        Cons iter000 = ilist.theConsList;
        int i = Stella.NULL_INTEGER;
        int iter001 = 0;

        for (;!(iter000 == Stella.NIL); iter000 = iter000.rest, iter001 = iter001 + 1) {
          instance = iter000.value;
          i = iter001;
          (instances.theArray)[i] = (((LogicObject)(instance)));
        }
      }
      if (Logic.$RULE_INDUCTION_STRATEGY$ == Logic.KWD_TOP_DOWN) {
        Logic.$ENABLE_USER_THING$ = true;
        if (!Logic.$ALLOW_RECURSIVE_DECISION_NODES$) {
          Logic.$TABOO_OPERATORS$.insertNew(relation);
        }
        Logic.generateClassificationRule(instances, relationName, className, true);
        { List clauses = ((List)(Logic.$CASE_ANTECEDENT_TABLE$.lookup(className.symbolName + "-match")));

          Logic.$CANDIDATE_CLAUSES$ = Vector.newVector(clauses.length());
          { Cons clause = null;
            Cons iter002 = clauses.theConsList;
            int i = Stella.NULL_INTEGER;
            int iter003 = 0;

            for (;!(iter002 == Stella.NIL); iter002 = iter002.rest, iter003 = iter003 + 1) {
              clause = ((Cons)(iter002.value));
              i = iter003;
              (Logic.$CANDIDATE_CLAUSES$.theArray)[i] = clause;
            }
          }
        }
        System.out.println("Generating Training Examples");
        Logic.generateClassificationTrainingExamples(instances, relation, Logic.$INDUCE_RULES_FROM_SIGNATURES$);
        Logic.$OPTIMIZE_INDUCED_QUERIES$ = true;
        System.out.println("Generating Decision Rules");
        Logic.topDownRuleInduction(Logic.$TRAINING_EXAMPLES$);
      }
      else if (Logic.$RULE_INDUCTION_STRATEGY$ == Logic.KWD_BOTTOM_UP) {
        Logic.$ENABLE_USER_THING$ = false;
        Logic.generateTrainingExamples(instances, relation);
        Logic.$OPTIMIZE_INDUCED_QUERIES$ = true;
        Logic.bottomUpRuleInduction(Logic.$TRAINING_EXAMPLES$, Logic.$SIMPLIFY_RULE_ANTECEDENTp$);
      }
      else {
        { OutputStringStream stream000 = OutputStringStream.newOutputStringStream();

          stream000.nativeStream.print("`" + Logic.$RULE_INDUCTION_STRATEGY$ + "' is not a valid case option");
          throw ((StellaException)(StellaException.newStellaException(stream000.theStringReader()).fillInStackTrace()));
        }
      }
    }
  }