Home /Modules/large-language-models/SLLlmReasoning.sleela

SLLlmReasoning.sleela

lib/large-language-models/SLLlmReasoning.sleela · 165 line(s) · sleela

<< lib/large-language-models/SLLlmReasoning.sleela
   SLeeLa Standard Library Definition.
   Definition: SLeeLa mirror of the Reasoning Language Model layer (sllmr_ in
   large_language_models_reasoning.h). A neuro-symbolic chain-of-thought
   controller over a plain LLM engine plus an optional verifier. It decomposes a
   question, proposes steps, reflects, verifies each step, backtracks on refuted
   paths, and commits an answer only when the require-verified policy is met.
   UNKNOWN is never promoted to verified. It bundles no model. >>
#sleela 3.0
material;
class SLLlmReasoning {
  < ---- Descriptive metadata (version 1.11 nested-friendly accessors) ---- >
  << Eleven catalogued attributes with getter/setter pairs, so a GUI, loader,
     or catalog can read and (where appropriate) override this record.
     Values are faithful to the subject's real origin where publicly known. >>
  String metaVersion = "1.0.0";
  int metaId = 8206;
  String metaAuthor = "Max Rupplin";
  String metaDate = "2026-11-06";
  String metaCopyright = "MEARVK LLC";
  String metaTrademark = "none";
  String metaCorporation = "MEARVK LLC";
  String metaOrigin = "International";
  String metaBirthDate = "2026-11-06";
  int metaScienceRating = 6;
  String metaNationalSchedule = "none";

  String getMetaVersion() { return metaVersion; }
  void setMetaVersion(String v) { metaVersion = v; }
  int getMetaId() { return metaId; }
  void setMetaId(int v) { metaId = v; }
  String getAuthor() { return metaAuthor; }
  void setAuthor(String v) { metaAuthor = v; }
  String getDate() { return metaDate; }
  void setDate(String v) { metaDate = v; }
  String getCopyright() { return metaCopyright; }
  void setCopyright(String v) { metaCopyright = v; }
  String getTrademark() { return metaTrademark; }
  void setTrademark(String v) { metaTrademark = v; }
  String getCorporation() { return metaCorporation; }
  void setCorporation(String v) { metaCorporation = v; }
  String getOrigin() { return metaOrigin; }
  void setOrigin(String v) { metaOrigin = v; }
  String getBirthDate() { return metaBirthDate; }
  void setBirthDate(String v) { metaBirthDate = v; }
  int getScienceRating() { return metaScienceRating; }
  void setScienceRating(int v) { metaScienceRating = v; }
  String getNationalSchedule() { return metaNationalSchedule; }
  void setNationalSchedule(String v) { metaNationalSchedule = v; }

  < sllmr_status mirror. >
  static final int STATUS_OK = 0;
  static final int STATUS_INVALID_ARGUMENT = 1;
  static final int STATUS_OUT_OF_MEMORY = 2;
  static final int STATUS_BACKEND_ERROR = 3;
  static final int STATUS_NOT_LOADED = 4;
  static final int STATUS_CANCELLED = 5;
  static final int STATUS_NO_SOUND_PATH = 6;
  static final int STATUS_UNSUPPORTED = 7;

  < sllmr_subject mirror: controller policies, not separate models. >
  static final int SUBJECT_GENERAL = 0;
  static final int SUBJECT_MATH = 1;
  static final int SUBJECT_PHILOSOPHY = 2;
  static final int SUBJECT_RELIGION = 3;
  static final int SUBJECT_CODE = 4;

  < sllmr_step_kind mirror. >
  static final int STEP_DECOMPOSE = 0;
  static final int STEP_ASSUMPTION = 1;
  static final int STEP_DEDUCTION = 2;
  static final int STEP_INDUCTION = 3;
  static final int STEP_OBJECTION = 4;
  static final int STEP_REFLECTION = 5;
  static final int STEP_REVISION = 6;
  static final int STEP_CONCLUSION = 7;

  < sllmr_verdict mirror. >
  static final int VERDICT_UNKNOWN = 0;
  static final int VERDICT_SUPPORTED = 1;
  static final int VERDICT_REFUTED = 2;

  < sllmr_options fields. >
  int subject;
  int maxSteps;
  int maxBacktracks;
  int reflectionEvery;
  double minConfidence;
  boolean requireVerified;
  long seed;

  String verifierName;
  boolean hasVerifier;

  < sllmr_options_init: neutral reasoning defaults. >
  void initOptions() {
    subject = SUBJECT_GENERAL;
    maxSteps = 16;
    maxBacktracks = 4;
    reflectionEvery = 3;
    minConfidence = 0.5;
    requireVerified = false;
    seed = 0;
  }

  < sllmr_engine_create: bind an optional symbolic verifier by name. >
  void configure(String verifier) {
    verifierName = verifier;
    hasVerifier = verifier != null;
  }

  String engineVerifierName() { return verifierName; }

  String subjectName(int s) {
    if (s == SUBJECT_GENERAL) { return "general"; }
    if (s == SUBJECT_MATH) { return "math"; }
    if (s == SUBJECT_PHILOSOPHY) { return "philosophy"; }
    if (s == SUBJECT_RELIGION) { return "religion"; }
    if (s == SUBJECT_CODE) { return "code"; }
    return "unknown";
  }

  String stepKindName(int k) {
    if (k == STEP_DECOMPOSE) { return "decompose"; }
    if (k == STEP_ASSUMPTION) { return "assumption"; }
    if (k == STEP_DEDUCTION) { return "deduction"; }
    if (k == STEP_INDUCTION) { return "induction"; }
    if (k == STEP_OBJECTION) { return "objection"; }
    if (k == STEP_REFLECTION) { return "reflection"; }
    if (k == STEP_REVISION) { return "revision"; }
    if (k == STEP_CONCLUSION) { return "conclusion"; }
    return "unknown";
  }

  String verdictName(int v) {
    if (v == VERDICT_UNKNOWN) { return "unknown"; }
    if (v == VERDICT_SUPPORTED) { return "supported"; }
    if (v == VERDICT_REFUTED) { return "refuted"; }
    return "unknown";
  }

  < Policy gate mirroring the C commit rule: a step is committable only if its >
  < verdict is not REFUTED, and when require-verified holds it must be SUPPORTED. >
  < UNKNOWN is never promoted to verified. >
  boolean stepCommittable(int verdict) {
    if (verdict == VERDICT_REFUTED) { return false; }
    if (requireVerified) { return verdict == VERDICT_SUPPORTED; }
    return true;
  }

  String statusString(int status) {
    if (status == STATUS_OK) { return "ok"; }
    if (status == STATUS_INVALID_ARGUMENT) { return "invalid argument"; }
    if (status == STATUS_OUT_OF_MEMORY) { return "out of memory"; }
    if (status == STATUS_BACKEND_ERROR) { return "backend error"; }
    if (status == STATUS_NOT_LOADED) { return "not loaded"; }
    if (status == STATUS_CANCELLED) { return "cancelled"; }
    if (status == STATUS_NO_SOUND_PATH) { return "no sound path"; }
    if (status == STATUS_UNSUPPORTED) { return "unsupported"; }
    return "unknown";
  }

  boolean available() { return maxSteps > 0; }
}