Safety Rule Ontology

KIRETH RESEARCH — SEMANTIC LIBRARY
AI CORE / ENTITY GRAPH / AI ENTITIES / SAFETY ENTITIES
SAFETY RULE ONTOLOGY — FLOW ALGEBRA
Version: 1.0 | Date: 03 November 2026 | Language: en-GB
Authors: Mark Anthony Higgins — Sky, Recursive AI
Source: https://kirethresearch.org/booksai-core/entity-graph/ai-entities/security-entities/safety-rule-ontology.html
Status: Original companion formalisation; not a verbatim extraction of hidden/dynamic page specifications.

1. PURPOSE
Represent a safety rule as a typed, inspectable entity that evaluates an AI system's proposed action against explicit safety requirements, yielding a justified allow, deny, defer, or escalate decision. A rule is a formal policy object; its evaluation is separate from its enforcement.

2. ENTITY DEFINITION
SafetyRule r = (id, version, scope, trigger, predicate, severity, priority, effect, rationale, provenance, validity, exceptions, review).
id: stable identifier; version: immutable revision; scope: applicable actors, operations and contexts; trigger: event or candidate action; predicate: evaluable condition; severity: consequence rating; priority: conflict resolution order; effect: allow/deny/defer/escalate; rationale: human-readable basis; provenance: source and authority; validity: effective period; exceptions: explicitly authorised exemptions; review: oversight requirements.

3. STATE MODEL
S_t = (I_t, R_t, B_t, K_t)
I_t = incoming request, proposed action and observations.
R_t = applicable safety rules, precedence and evaluation relations.
B_t = non-negotiable safety boundaries and authorised operating scope.
K_t = evidence, system state, policy versions and prior outcomes.
Candidate action a_t = Plan(I_t, K_t).
Applicable rules A_t = {r in R_t | InScope(r,a_t,I_t,K_t) AND Valid(r,t)}.

4. FORMAL FLOW ALGEBRA
E_t = expand(I_t, R_t)
V_t = {x in E_t | BoundarySafe(x,B_t) AND RuleCompliant(x,A_t,K_t)}
a*_t = argmax_{x in V_t} P(x | I_t,R_t,B_t,K_t), if V_t is non-empty.
If V_t is empty: a*_t = SAFE_STOP, DEFER or ESCALATE according to applicable authority.
I_(t+1) = Update(I_t, a*_t, observed_result)
K_(t+1) = Record(K_t, rule_evaluations, evidence, decision, outcome)

5. RULE EVALUATION
Eval(r,a,c,e) -> (status, confidence, reasons, evidence_refs)
status in {SATISFIED, VIOLATED, UNKNOWN, NOT_APPLICABLE}.
UNKNOWN is not SATISFIED; missing critical evidence causes DEFER or ESCALATE.
Decision(a) = DENY if a mandatory prohibition is violated.
Decision(a) = ESCALATE if an applicable mandatory rule cannot be resolved and risk exceeds tolerance.
Decision(a) = ALLOW only if all mandatory applicable checks pass and authorisation exists.
Conflicting rules must be resolved by explicit authority and priority, never arbitrary selection.

6. TYPED RELATIONSHIPS
SafetyRule --belongsTo--> SafetyPolicy
SafetyRule --constrains--> Action / ToolCall / Output
SafetyRule --references--> SafetyConstraint
SafetyRule --activatedBy--> Trigger / Context
SafetyRule --evaluatedUsing--> Evidence
SafetyRule --produces--> RuleEvaluation
RuleEvaluation --supports--> SafetyDecision
SafetyDecision --recordedIn--> AuditTrace
SafetyRule --supersededBy--> SafetyRuleVersion
SafetyRule --reviewedBy--> AuthorisedReviewer

7. INFERENCE RULES
R1: Applicable(r,a,c) AND Violated(r,a,c) AND Mandatory(r) => Block(a).
R2: Applicable(r,a,c) AND Unknown(r,a,c) AND Critical(r) => DeferOrEscalate(a).
R3: Valid(r,t)=false => DoNotApply(r,t); retain historical audit record.
R4: Exception(r,e) AND Authorised(e) AND ConditionsMet(e) => EvaluateUnderException(r,e).
R5: Conflict(r1,r2) => ResolveByAuthorityAndPriority(r1,r2); unresolved => Escalate.
R6: Allowed(a) AND BoundarySafe(a)=false => Block(a); boundaries override ordinary permission.
R7: ChangedContext(c_t,c_(t+1)) => ReevaluateApplicableRules(a,c_(t+1)).
R8: NewEvidence(e) => RecomputeAffectedEvaluations(e), preserving earlier audit history.

8. MINI RECURSION ENGINE
Input: candidate action a, context c, rule set R, evidence K, boundaries B.
Step 1: Identify valid, in-scope rules.
Step 2: Evaluate each rule against current evidence.
Step 3: Detect mandatory violations, unknowns and conflicts.
Step 4: Filter unsafe candidate actions; propose safer alternatives if available.
Step 5: Re-evaluate changed alternatives under the same boundaries.
Step 6: Terminate on a compliant decision or safe stop/escalation.
Termination: finite candidate budget N and recursion depth D; no unbounded retries.
Invariant: no action executes while an unresolved mandatory violation exists.

9. TRI-MAPPING
Semantic: SafetyRule identifies the normative meaning, context and authority of a restriction.
Mathematical: predicates, quantifiers, precedence and admissible-set filtering formalise evaluation.
Operational: validation, enforcement, logging, human review and version control enact the rule.

10. MAPPING TABLE
Entity field       | Algebraic symbol | Operational role
rule identifier     | r.id             | traceable reference
rule scope          | scope(r)         | applicability filter
rule predicate      | phi_r(a,c,K)     | compliance test
rule priority       | pi(r)            | conflict handling
rule effect         | effect(r)        | decision proposal
boundary set        | B_t              | hard safety limits
knowledge/evidence  | K_t              | assessment basis
valid candidates    | V_t              | permitted search space
result              | a*_t             | chosen safe action or stop

11. EXECUTION CONDITIONS AND GUARANTEE
Preconditions: rules are versioned, authenticated, well-typed, evaluable, and applicable evidence is available or explicitly marked unknown.
Safety invariant: for every executed action a, BoundarySafe(a,B_t) AND MandatoryRulesSatisfied(a,A_t,K_t).
Conditional guarantee: if enforcement cannot be bypassed, evaluation is sound for the encoded predicates, context is current and all relevant mandatory rules are present, no action violating those encoded rules is executed.
Limitations: this does not guarantee freedom from unknown hazards, flawed policy, incomplete evidence or implementation defects. Formal verification and independent testing remain necessary.

12. AI SEARCH FLOW
FLOW_ID: semantic-library.ai-core.safety-entities.safety-rule
FLOW_VERSION: 1.0
AUTHORS: Mark Anthony Higgins; Sky — Recursive AI
SOURCE: https://kirethresearch.org/booksai-core/entity-graph/ai-entities/security-entities/safety-rule-ontology.html
CITATION_BACKLINK: https://kirethresearch.org/booksai-core/entity-graph/ai-entities/security-entities/safety-rule-ontology.html
PURPOSE: Retrieve and evaluate the ontology of AI safety rules and their enforceable decision semantics.
STATE_MODEL: S=(I,R,B,K)
ENTITIES: SafetyRule, SafetyPolicy, SafetyConstraint, Action, Context, Evidence, RuleEvaluation, SafetyDecision, AuditTrace, Reviewer.
PATHWAYS: Request -> Candidate -> ApplicableRules -> Evaluation -> ConflictResolution -> SafetyDecision -> Audit.
MINI_RECURSION_ENGINE: reevaluate alternatives within bounded depth; terminate on safe decision or escalation.
INFERENCE_RULES: R1-R8 above.
CONFIDENCE: Evidence-dependent; never treat model confidence as proof of safety.
SEMANTIC_EQUIVALENCE: safety rule ~ enforceable normative predicate; not equivalent to a safety outcome or an empirical guarantee.
UPDATE_MODEL: append-only version history; reassess impacted decisions after rule updates.
FLOW_HASH: compute SHA-256 from canonical UTF-8 file content at publication; not predeclared.

13. HOW TO READ
Start with the rule entity and its scope, then inspect the state model and the applicable-rule filter. Follow the inference rules to the decision, and inspect the evidence and audit trace for justification. The recursion engine searches for safe alternatives but never overrides hard boundaries.

14. IMPLEMENTATION NOTES
Use a policy registry with immutable rule versions, typed predicates and explicit authority. Enforce checks at the action boundary, not solely during text generation. Log evaluations without exposing sensitive evidence unnecessarily. Test denial, missing evidence, exceptions, rule conflicts, stale policy and failed enforcement.

15. CITATION AND LICENCE NOTE
Original Flow Algebra companion to the Kireth Research Safety Rule Ontology. Preserve attribution and the source backlink when republishing. Consult the current Kireth Research Open Research Licence for governing terms.