<< lib/rrs/SLRrs.sleela SLeeLa Standard Library Definition. Definition: SLeeLa mirror of RRS -- Reasonable Responsibility Solidity (sllmrrs_ in artificial-intelligence/rrs/rrs.h). Three congruent models are chained feed-forward over a ternary signal: 1 = AFFIRM, 0 = ELIMINATE, 2 = POWER_ADD. Stage 1 is conjunctive (strict AND), stage 2 is the reasonable-responsibility prelude, stage 3 is the solidity culmination. RRS subtracts faith: any faith or trial premise is forced to ELIMINATE. It ships no weights; the ternary net is a tiny conjunctive accumulator. >> #sleela 3.0 material; class SLRrs { < ---- 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 = 8221; 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 = 7; 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; } << sllmrrs_signal: values chosen so AFFIRM/POWER_ADD contribute power and ELIMINATE is a hard zero that breaks the stage conjunction. >> static final int SIGNAL_ELIMINATE = 0; static final int SIGNAL_AFFIRM = 1; static final int SIGNAL_POWER_ADD = 2; < sllmrrs_stage. > static final int STAGE_CONJUNCTIVE = 0; static final int STAGE_RESPONSIBILITY = 1; static final int STAGE_SOLIDITY = 2; static final int STAGE_COUNT = 3; < sllmrrs_potestas: graded warranted capacity-to-continue. > static final int POTESTAS_NONE = 0; static final int POTESTAS_PROVISIONAL = 1; static final int POTESTAS_WARRANTED = 2; < sllmrrs_status. > static final int STATUS_OK = 0; static final int STATUS_INVALID_ARGUMENT = 1; static final int STATUS_FAITH_PREMISE = 2; static final int STATUS_NOT_SOLID = 3; static final int STATUS_RESPONSIBILITY_UNMET = 4; static final int STATUS_CAPACITY = 5; < Per-stage accumulator (sllmrrs_accumulator). > int accPower; int accAffirmed; int accEliminated; boolean accConjunction; < Result (sllmrrs_result) across the three stages. > int totalPower; int potestas; boolean solid; int faithEliminated; < Per-stage power snapshot kept parallel to STAGE_COUNT. > int stage0Power; int stage1Affirmed; << The effective signal a premise contributes at a given stage, after faith subtraction and the responsibility prelude. Mirrors the fold kernel rule. >> int effectiveSignal(int stage, int signal, boolean faithOrTrial, boolean responsibilityMet) { if (faithOrTrial) { return SIGNAL_ELIMINATE; } if (stage == STAGE_RESPONSIBILITY && !responsibilityMet) { return SIGNAL_ELIMINATE; } return signal; } << sllmrrs_fold_stage: the single congruent kernel reused by all three stages. Resets the accumulator, then folds each premise. ELIMINATE breaks the strict AND (conjunction = false) and counts an elimination; AFFIRM adds +1 power, POWER_ADD adds +2, both count an affirmation. Parallel arrays describe the premises so this stays portable. >> void foldStage(int stage, int[] signals, boolean[] faith, boolean[] respMet, int n) { accPower = 0; accAffirmed = 0; accEliminated = 0; accConjunction = true; int i = 0; while (i < n) { int eff = effectiveSignal(stage, signals[i], faith[i], respMet[i]); if (faith[i]) { faithEliminated = faithEliminated + 1; } if (eff == SIGNAL_ELIMINATE) { accEliminated = accEliminated + 1; accConjunction = false; } else { if (eff == SIGNAL_AFFIRM) { accPower = accPower + 1; } if (eff == SIGNAL_POWER_ADD) { accPower = accPower + 2; } accAffirmed = accAffirmed + 1; } i = i + 1; } } << sllmrrs_feed_forward: run stage1 -> stage2 -> stage3, accumulating power and counting faith eliminations. Fails closed: a broken conjunction stops the forward pass and yields an honest NONE. An empty stage 3 inherits the prior conjunction and the accumulated power, so it does not break solidity. >> int feedForward(int[] s1, boolean[] f1, boolean[] r1, int n1, int[] s2, boolean[] f2, boolean[] r2, int n2, int[] s3, boolean[] f3, boolean[] r3, int n3) { totalPower = 0; potestas = POTESTAS_NONE; solid = false; faithEliminated = 0; foldStage(STAGE_CONJUNCTIVE, s1, f1, r1, n1); stage0Power = accPower; totalPower = totalPower + accPower; if (!accConjunction) { return STATUS_OK; } foldStage(STAGE_RESPONSIBILITY, s2, f2, r2, n2); stage1Affirmed = accAffirmed; totalPower = totalPower + accPower; if (!accConjunction) { return STATUS_OK; } boolean carriedConjunction = true; if (n3 > 0) { foldStage(STAGE_SOLIDITY, s3, f3, r3, n3); totalPower = totalPower + accPower; carriedConjunction = accConjunction; } if (!carriedConjunction) { return STATUS_OK; } << Culmination: WARRANTED needs solid + responsibility affirmed + power>=4; PROVISIONAL needs solid + power>=2; else NONE. >> solid = true; if (stage1Affirmed > 0 && totalPower >= 4) { potestas = POTESTAS_WARRANTED; } else { if (totalPower >= 2) { potestas = POTESTAS_PROVISIONAL; } else { potestas = POTESTAS_NONE; } } return STATUS_OK; } int getTotalPower() { return totalPower; } int getPotestas() { return potestas; } boolean isSolid() { return solid; } int getFaithEliminated() { return faithEliminated; } String signalName(int signal) { if (signal == SIGNAL_ELIMINATE) { return "eliminate"; } if (signal == SIGNAL_AFFIRM) { return "affirm"; } if (signal == SIGNAL_POWER_ADD) { return "power-add"; } return "unknown"; } String stageName(int stage) { if (stage == STAGE_CONJUNCTIVE) { return "conjunctive"; } if (stage == STAGE_RESPONSIBILITY) { return "responsibility"; } if (stage == STAGE_SOLIDITY) { return "solidity"; } return "unknown"; } String potestasName(int p) { if (p == POTESTAS_NONE) { return "none"; } if (p == POTESTAS_PROVISIONAL) { return "provisional"; } if (p == POTESTAS_WARRANTED) { return "warranted"; } return "unknown"; } String statusString(int status) { if (status == STATUS_OK) { return "ok"; } if (status == STATUS_INVALID_ARGUMENT) { return "invalid argument"; } if (status == STATUS_FAITH_PREMISE) { return "faith premise"; } if (status == STATUS_NOT_SOLID) { return "not solid"; } if (status == STATUS_RESPONSIBILITY_UNMET) { return "responsibility unmet"; } if (status == STATUS_CAPACITY) { return "capacity"; } return "unknown"; } boolean available() { return STAGE_COUNT == 3; } }