Home /Modules/artificial-intelligence/rrs.h

rrs.h

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

#ifndef SLEELA_AI_LLM_RRS_H
#define SLEELA_AI_LLM_RRS_H
/*
 * RRS — Reasonable Responsibility Solidity. A kind of LLM.
 *
 * RRS is a reasoning model built as THREE CONGRUENT MODELS chained FEED-FORWARD,
 * each operating on a simple ternary signal:
 *
 *     1 = AFFIRM   (yes; the premise stands and conjoins)
 *     0 = ELIMINATE(no; the premise is reclaimed out by a prelude)
 *     2 = POWER-ADD(binary-simple power addition: an affirmed premise is
 *                   accumulated into the conjunctive "power" — potestas built
 *                   by addition of what stands together)
 *
 * The three congruent stages (same contract, composable):
 *
 *   STAGE 1  CONJUNCTIVE  — a Conjunctive Neural Net stage. Reasonable
 *            assumptions SURFACE; each is signalled. A prelude may RECLAIM an
 *            assumption as ELIMINATION (0), pruning it. Survivors AFFIRM (1) and
 *            POWER-ADD (2). The stage conjoins: the path continues only if the
 *            surviving premises hold TOGETHER (strict AND).
 *
 *   STAGE 2  RESPONSIBILITY — mounts the survivors onto the question of
 *            Reasonable Responsibility as the PRELUDE TO CONTINUE: you may
 *            proceed only if responsibility is met. Unmet responsibility
 *            ELIMINATES (0); met responsibility AFFIRMS (1) and POWER-ADDs (2).
 *
 *   STAGE 3  SOLIDITY/FIRMAMENT — the culmination: a Reasonable argument about
 *            SOLIDITY (structural firmness) and FIRMAMENT (the fixed ground).
 *            It reads the accumulated power and renders the CULMINATION.
 *
 * Explicitly "less the Faith of Trial of Man of Reason": RRS SUBTRACTS faith.
 * A premise that rests on faith / trial-of-faith is out of scope — it is
 * surfaced and ELIMINATED (0), never affirmed. RRS argues from reason about
 * what stands firm; it makes no faith-claim and no proof-by-faith.
 *
 * The CULMINATION is "Power in the Latin sense" — potestas / potentia: a
 * warranted CAPACITY to continue/act that issues from a completed responsible
 * process, graded (none / provisional / warranted). It is capacity-authority,
 * NOT force.
 *
 * RRS ships no weights: it is a controller + verifier contract over the
 * reasoning engine (SLLMR_*). The ternary net is a real, tiny conjunctive
 * accumulator defined here; a backend LLM (optional) supplies premise text.
 */
#include "../large-language-models/large_language_models_reasoning.h"
#include <stddef.h>
#include <stdint.h>
#ifdef __cplusplus
extern "C" {
#endif
#if defined(_WIN32) && defined(SLEELA_AI_SHARED)
# if defined(SLEELA_AI_BUILD)
#  define SLLMRRS_API __declspec(dllexport)
# else
#  define SLLMRRS_API __declspec(dllimport)
# endif
#elif defined(__GNUC__) && defined(SLEELA_AI_SHARED)
# define SLLMRRS_API __attribute__((visibility("default")))
#else
# define SLLMRRS_API
#endif

#define SLLMRRS_ABI_VERSION 1u

/* The ternary signal. The names are the contract; the values are chosen so the
   conjunctive accumulator can treat AFFIRM/POWER_ADD as contributing and
   ELIMINATE as a hard zero. */
typedef enum sllmrrs_signal {
 SLLMRRS_ELIMINATE = 0,  /* no: reclaimed out by a prelude (hard zero / AND-kill) */
 SLLMRRS_AFFIRM    = 1,  /* yes: stands and conjoins */
 SLLMRRS_POWER_ADD = 2   /* binary-simple power addition into the conjunction */
} sllmrrs_signal;

/* The three congruent stages. */
typedef enum sllmrrs_stage {
 SLLMRRS_STAGE_CONJUNCTIVE   = 0, /* surface assumptions; prelude elimination; strict AND */
 SLLMRRS_STAGE_RESPONSIBILITY = 1,/* reasonable-responsibility prelude to continue */
 SLLMRRS_STAGE_SOLIDITY      = 2, /* solidity/firmament culmination */
 SLLMRRS_STAGE_COUNT         = 3
} sllmrrs_stage;

/* The culmination verdict — potestas, graded. */
typedef enum sllmrrs_potestas {
 SLLMRRS_POTESTAS_NONE        = 0, /* no warranted capacity: the argument did not stand */
 SLLMRRS_POTESTAS_PROVISIONAL = 1, /* capacity conditional on what is still open */
 SLLMRRS_POTESTAS_WARRANTED   = 2  /* full warranted capacity-to-continue (responsible power) */
} sllmrrs_potestas;

typedef enum sllmrrs_status {
 SLLMRRS_OK=0, SLLMRRS_INVALID_ARGUMENT=1, SLLMRRS_FAITH_PREMISE=2,
 SLLMRRS_NOT_SOLID=3, SLLMRRS_RESPONSIBILITY_UNMET=4, SLLMRRS_CAPACITY=5
} sllmrrs_status;

/* One premise entering the feed-forward. 'faith_or_trial' marks a premise that
   rests on faith/trial — RRS eliminates it (subtracted, never affirmed). */
typedef struct sllmrrs_premise {
 const char *text;        /* the premise (borrowed) */
 sllmrrs_signal signal;   /* the caller/handler's proposed ternary signal */
 int faith_or_trial;      /* nonzero => a faith/trial premise (will be eliminated) */
 int responsibility_met;  /* for stage 2: nonzero => responsibility is satisfied */
} sllmrrs_premise;

/* The conjunctive accumulator — the "power addition". Affirmed/power-added
   premises add to 'power'; any ELIMINATE (or a faith premise, or unmet
   responsibility at stage 2) sets the stage's conjunction false. */
typedef struct sllmrrs_accumulator {
 uint32_t power;          /* sum of contributions from AFFIRM(+1)/POWER_ADD(+2) */
 uint32_t affirmed;       /* count of surviving (non-eliminated) premises */
 uint32_t eliminated;     /* count eliminated (incl. faith/trial) */
 int      conjunction;    /* 1 if the strict-AND still holds for this stage */
} sllmrrs_accumulator;

/* The result of running the three-stage feed-forward. */
typedef struct sllmrrs_result {
 sllmrrs_accumulator stage[SLLMRRS_STAGE_COUNT];
 uint32_t total_power;         /* culminated power across the feed-forward */
 sllmrrs_potestas potestas;    /* the graded culmination verdict */
 int solid;                    /* 1 if solidity/firmament holds (all stages conjoined) */
 uint32_t faith_eliminated;    /* how many faith/trial premises were subtracted */
} sllmrrs_result;

SLLMRRS_API const char *sllmrrs_status_string(sllmrrs_status status);
SLLMRRS_API const char *sllmrrs_signal_name(sllmrrs_signal signal);
SLLMRRS_API const char *sllmrrs_stage_name(sllmrrs_stage stage);
SLLMRRS_API const char *sllmrrs_potestas_name(sllmrrs_potestas potestas);

/* The congruent stage kernel, applied identically at every stage: given the
   premises for the stage, fold the ternary signal into the accumulator under
   strict AND. A faith/trial premise is forced to ELIMINATE (subtracted). At the
   RESPONSIBILITY stage, a premise whose responsibility_met is zero is forced to
   ELIMINATE (the prelude to continue is unmet). Returns SLLMRRS_OK and fills
   *acc; the congruence is that the SAME kernel runs for all three stages. */
SLLMRRS_API sllmrrs_status sllmrrs_fold_stage(sllmrrs_stage stage,
                                              const sllmrrs_premise *premises, size_t count,
                                              sllmrrs_accumulator *acc);

/* Run the full three-model feed-forward: STAGE 1 (conjunctive elimination) ->
   STAGE 2 (responsibility prelude) -> STAGE 3 (solidity/firmament culmination).
   The feed-forward is congruent: each stage uses sllmrrs_fold_stage, and a
   stage whose conjunction is broken stops the forward pass (fail closed). On
   SLLMRRS_OK, *out holds the accumulators, total power, solidity, and the
   potestas culmination. 'stageN'/'count' give the premises for stages 1..3
   (stage 3 may be empty: its culmination reads the prior power). */
SLLMRRS_API sllmrrs_status sllmrrs_feed_forward(
 const sllmrrs_premise *stage1, size_t n1,
 const sllmrrs_premise *stage2, size_t n2,
 const sllmrrs_premise *stage3, size_t n3,
 sllmrrs_result *out);

/* Adapt RRS as an sllmr_verifier for the reasoning engine: a candidate step is
   SUPPORTED when it AFFIRMS/POWER-ADDs and conjoins, REFUTED when it ELIMINATES
   (including any faith/trial premise), UNKNOWN when RRS cannot classify it. The
   returned verifier is self-contained (no user_data needed). */
SLLMRRS_API sllmr_verifier sllmrrs_as_reasoning_verifier(void);

#ifdef __cplusplus
}
#endif
#endif