Home /Modules/artificial-intelligence/rrs.c

rrs.c

artificial-intelligence/rrs/rrs.c · 163 line(s) · c

#include "rrs.h"
#include <string.h>
#include <stdio.h>

const char *sllmrrs_status_string(sllmrrs_status s){
 switch(s){
  case SLLMRRS_OK: return "ok";
  case SLLMRRS_INVALID_ARGUMENT: return "invalid argument";
  case SLLMRRS_FAITH_PREMISE: return "faith/trial premise eliminated (subtracted from RRS)";
  case SLLMRRS_NOT_SOLID: return "argument did not stand: solidity/firmament broken";
  case SLLMRRS_RESPONSIBILITY_UNMET: return "reasonable-responsibility prelude unmet";
  case SLLMRRS_CAPACITY: return "capacity exceeded";
 }
 return "unknown";
}
const char *sllmrrs_signal_name(sllmrrs_signal s){
 switch(s){ case SLLMRRS_ELIMINATE: return "0:eliminate"; case SLLMRRS_AFFIRM: return "1:affirm";
  case SLLMRRS_POWER_ADD: return "2:power-add"; } return "signal";
}
const char *sllmrrs_stage_name(sllmrrs_stage s){
 switch(s){ case SLLMRRS_STAGE_CONJUNCTIVE: return "conjunctive";
  case SLLMRRS_STAGE_RESPONSIBILITY: return "responsibility";
  case SLLMRRS_STAGE_SOLIDITY: return "solidity-firmament"; default: return "stage"; }
}
const char *sllmrrs_potestas_name(sllmrrs_potestas p){
 switch(p){ case SLLMRRS_POTESTAS_NONE: return "none";
  case SLLMRRS_POTESTAS_PROVISIONAL: return "provisional";
  case SLLMRRS_POTESTAS_WARRANTED: return "warranted"; } return "unknown";
}

/* The congruent stage kernel — the SAME fold for all three stages.
   Signal semantics:
     ELIMINATE(0) -> hard zero: strict-AND conjunction becomes false for the stage.
     AFFIRM(1)    -> survives, +1 power.
     POWER_ADD(2) -> survives, +2 power (binary-simple power addition).
   Subtractions that force ELIMINATE regardless of the proposed signal:
     - a faith/trial premise (RRS subtracts faith);
     - at the RESPONSIBILITY stage, a premise whose responsibility is unmet. */
sllmrrs_status sllmrrs_fold_stage(sllmrrs_stage stage,
                                  const sllmrrs_premise *premises, size_t count,
                                  sllmrrs_accumulator *acc){
 if(!acc) return SLLMRRS_INVALID_ARGUMENT;
 acc->power=0; acc->affirmed=0; acc->eliminated=0; acc->conjunction=1;
 if(count && !premises) return SLLMRRS_INVALID_ARGUMENT;

 for(size_t i=0;i<count;i++){
  const sllmrrs_premise *pr=&premises[i];
  sllmrrs_signal sig=pr->signal;

  /* RRS subtracts faith: a faith/trial premise is always eliminated. */
  if(pr->faith_or_trial) sig=SLLMRRS_ELIMINATE;
  /* Responsibility prelude: unmet responsibility eliminates (prelude to continue). */
  if(stage==SLLMRRS_STAGE_RESPONSIBILITY && !pr->responsibility_met) sig=SLLMRRS_ELIMINATE;

  if(sig==SLLMRRS_ELIMINATE){
   acc->eliminated++;
   acc->conjunction=0;   /* strict AND: one elimination breaks the stage conjunction */
   continue;
  }
  /* AFFIRM or POWER_ADD: survives and contributes to the accumulated power. */
  acc->affirmed++;
  acc->power += (sig==SLLMRRS_POWER_ADD)? 2u : 1u;
 }
 return SLLMRRS_OK;
}

/* Count faith/trial premises across the stage inputs (for the report). */
static uint32_t count_faith(const sllmrrs_premise *p, size_t n){
 uint32_t c=0; for(size_t i=0;i<n;i++) if(p && p[i].faith_or_trial) c++; return c;
}

sllmrrs_status sllmrrs_feed_forward(
 const sllmrrs_premise *s1, size_t n1,
 const sllmrrs_premise *s2, size_t n2,
 const sllmrrs_premise *s3, size_t n3,
 sllmrrs_result *out){
 if(!out) return SLLMRRS_INVALID_ARGUMENT;
 memset(out,0,sizeof(*out));
 out->potestas=SLLMRRS_POTESTAS_NONE;

 const sllmrrs_premise *ins[SLLMRRS_STAGE_COUNT]={s1,s2,s3};
 size_t counts[SLLMRRS_STAGE_COUNT]={n1,n2,n3};

 out->faith_eliminated = count_faith(s1,n1)+count_faith(s2,n2)+count_faith(s3,n3);

 int all_conjoined=1;
 uint32_t power=0;
 for(int st=0; st<SLLMRRS_STAGE_COUNT; st++){
  sllmrrs_status rc=sllmrrs_fold_stage((sllmrrs_stage)st, ins[st], counts[st], &out->stage[st]);
  if(rc!=SLLMRRS_OK) return rc;
  power += out->stage[st].power;

  /* Feed-forward, fail closed: a broken conjunction stops the forward pass.
     Stage 3 (solidity) with zero premises inherits the prior conjunction and
     reads the accumulated power, so an empty stage 3 does not break solidity. */
  if(counts[st]==0 && st==SLLMRRS_STAGE_SOLIDITY){
   out->stage[st].conjunction = all_conjoined;  /* culmination reads forward */
  } else if(!out->stage[st].conjunction){
   all_conjoined=0;
   /* record power so far, then stop the feed-forward */
   out->total_power=power;
   out->solid=0;
   if(st==SLLMRRS_STAGE_RESPONSIBILITY) return SLLMRRS_OK; /* responsibility unmet is a valid, honest NONE */
   return SLLMRRS_OK;
  }
 }

 out->total_power=power;
 out->solid = all_conjoined ? 1 : 0;

 /* Culmination: potestas as power issuing from a completed responsible process.
    Warranted requires solidity AND responsibility-stage power; provisional if
    solid but thin; none otherwise. */
 if(out->solid && out->stage[SLLMRRS_STAGE_RESPONSIBILITY].affirmed>0 && power>=4){
  out->potestas=SLLMRRS_POTESTAS_WARRANTED;
 } else if(out->solid && power>=2){
  out->potestas=SLLMRRS_POTESTAS_PROVISIONAL;
 } else {
  out->potestas=SLLMRRS_POTESTAS_NONE;
 }
 return SLLMRRS_OK;
}

/* ---- reasoning-engine verifier adapter ----
   Classify a candidate reasoning step as an RRS signal from light cues in its
   text, then map to a verdict. This lets RRS gate a chain-of-thought: a step
   that rests on faith/trial, or that eliminates, is REFUTED (backtrack); a step
   that affirms/conjoins is SUPPORTED; otherwise UNKNOWN. */
static int contains(const char *h,const char *n){ return h&&n&&strstr(h,n)!=NULL; }

static sllmr_verdict rrs_check(void *ud, sllmr_subject subject, const char *question,
                               const sllmr_step *prior, size_t pn,
                               const sllmr_step *cand, char *note, size_t ncap){
 (void)ud;(void)subject;(void)question;(void)prior;(void)pn;
 const char *t = cand->text? cand->text : "";
 /* Faith/trial is subtracted: such a step is refuted out of RRS. */
 if(contains(t,"faith")||contains(t,"trial of faith")||contains(t,"on faith")){
  if(note&&ncap) snprintf(note,ncap,"RRS subtracts faith: premise rests on faith/trial -> eliminated");
  return SLLMR_VERDICT_REFUTED;
 }
 /* Explicit elimination cue. */
 if(contains(t,"eliminate")||contains(t,"does not hold")||contains(t,"unmet responsibility")){
  if(note&&ncap) snprintf(note,ncap,"RRS: premise reclaimed by prelude -> eliminated (0)");
  return SLLMR_VERDICT_REFUTED;
 }
 /* Affirmation / conjunction cue. */
 if(contains(t,"affirm")||contains(t,"conjoin")||contains(t,"responsibility met")||
    contains(t,"stands")||contains(t,"solid")||contains(t,"firmament")){
  if(note&&ncap) snprintf(note,ncap,"RRS: premise affirms and conjoins -> power added (1/2)");
  return SLLMR_VERDICT_SUPPORTED;
 }
 return SLLMR_VERDICT_UNKNOWN;
}

sllmr_verifier sllmrrs_as_reasoning_verifier(void){
 sllmr_verifier v;
 v.abi_version=SLLMR_ABI_VERSION;
 v.name="rrs-conjunctive-verifier";
 v.user_data=NULL;
 v.check=rrs_check;
 return v;
}