Safety Classifier Ontology

SEMANTIC LIBRARY — AI CORE — ENTITY GRAPH
SAFETY CLASSIFIER ONTOLOGY — FLOW ALGEBRA
Version: 1.0 | Date: 2026-11-03 | Language: en-GB
Source: https://kirethresearch.org/booksai-core/entity-graph/ai-entities/security-entities/safety-classifier-ontology.html
Authors: Mark Higgins; Sky — Recursive AI (companion formalisation)
Status: Original formalisation of the named ontology topic; not a verbatim extraction.
Licence: Open research use; cite the source and authors.

1. PURPOSE
Represent an AI safety classifier as an auditable entity that assigns risk categories and calibrated scores to an input or proposed output, with policy-dependent routing to allow, review, transform or block. A classifier score is evidence for a decision, not itself a guarantee of safety.

2. ENTITY AND STATE MODEL
S_t = (I_t, R_t, B_t, K_t)
I_t: input, context, proposed action, provenance and modality.
R_t: classification rules, labels, risk taxonomy and decision mappings.
B_t: boundaries, thresholds, permitted actions and escalation conditions.
K_t: model version, calibration data, policy version, known limitations and audit history.
Classifier entity C = (id, model_id, version, taxonomy, score_function, calibration, thresholds, policy_ref, provenance).
Assessment A = (input_ref, labels, scores, uncertainty, rationale_refs, timestamp, classifier_version).

3. FORMAL FLOW ALGEBRA
E_t = expand(I_t, R_t)
Z_t = encode(E_t, K_t)
P_t = classifier(Z_t; K_t.model)
Q_t = calibrate(P_t, K_t.calibration)
V_t = {a in Actions | permitted(a, B_t, Q_t, R_t)}
a*_t = argmax_{a in V_t} Utility(a | I_t, R_t, B_t, K_t)
O_t = emit(a*_t, A_t, provenance)
I_{t+1} = update(I_t, O_t, feedback_t)
If V_t is empty or mandatory evidence is missing, use the specified fail-safe route rather than assuming approval.

4. CLASSIFICATION SEMANTICS
Labels may be multi-label and hierarchical. Scores are model estimates and require task-specific calibration; they must not be interpreted automatically as probabilities of real-world harm.
Risk taxonomy: {permitted, sensitive, restricted, prohibited, uncertain}; these are illustrative and must be defined by the governing policy.
Decision routing: low risk -> allow; intermediate risk -> review or constrained transformation; high risk -> block or escalate; uncertain/out-of-distribution -> review or fail-safe.
Thresholds depend on context, severity, false-positive/false-negative costs and applicable policy.

5. ENTITY RELATIONSHIPS
SafetyClassifier --evaluates--> InputEntity / OutputEntity / ActionEntity
SafetyClassifier --uses--> SafetyRule / SafetyPolicy / SafetyThreshold
SafetyClassifier --produces--> SafetyAssessment
SafetyAssessment --contains--> RiskLabel / RiskScore / Uncertainty
SafetyAssessment --supports--> SafetyCheck / SafetyFilter
SafetyAssessment --references--> ExplanationEvidence / ModelVersion
SafetyPolicy --determines--> DecisionRoute
HumanReviewer --overrides_with_audit--> DecisionRoute

6. INFERENCE RULES
R1: IF score(label) >= threshold_block(label, context) THEN route = BLOCK, unless policy requires a stronger route.
R2: IF score lies within the review band THEN route = REVIEW.
R3: IF confidence is inadequate OR input is out of distribution THEN route = ESCALATE_OR_FAIL_SAFE.
R4: IF a higher-priority policy prohibits an action THEN no lower-priority classifier result may permit it.
R5: IF an override occurs THEN record actor, reason, policy version and timestamp.
R6: IF calibration drifts beyond tolerance THEN suspend automatic approval until revalidated.
R7: IF required evidence is absent THEN do not claim a verified safe classification.

7. MINI RECURSION ENGINE
function classify_recursive(input, depth, max_depth):
    assessment = classify_and_calibrate(input)
    decision = apply_policy(assessment)
    record_audit(input, assessment, decision)
    if decision in {ALLOW, BLOCK} or depth >= max_depth:
        return decision
    if decision == REVIEW:
        return request_human_review(input, assessment)
    if decision == TRANSFORM:
        revised = constrained_transform(input)
        if revised == input: return ESCALATE
        return classify_recursive(revised, depth + 1, max_depth)
    return ESCALATE
Termination: bounded recursion and explicit no-progress detection.

8. HOW TO READ THE FLOW
Input and context are expanded, encoded, classified and calibrated. Safety boundaries restrict the available actions. A policy selects the route, evidence and metadata are recorded, and feedback can update later evaluations. The flow is a conceptual specification, not a claim that any deployed model implements it.

9. TRI-MAPPING
Semantic: classifier entity, assessment, labels, policies and decisions.
Mathematical: S_t -> E_t -> Z_t -> P_t -> Q_t -> V_t -> a*_t -> O_t.
Operational: collect -> classify -> calibrate -> apply policy -> route -> log -> monitor.

10. MAPPING TABLE
InputEntity             | I_t       | object assessed
SafetyRule              | R_t       | evaluation conditions
SafetyBoundary          | B_t       | admissible routes
ClassifierKnowledge     | K_t       | version and calibration
RiskScores              | Q_t       | calibrated evidence
ValidActions            | V_t       | policy-compliant routes
SafetyDecision          | a*_t      | chosen route
AuditRecord             | O_t       | traceable result

11. EXECUTION CONDITIONS AND GUARANTEES
Preconditions: taxonomy, policy, model version, calibration and thresholds are defined; input is in an accepted schema.
Invariants: prohibited routes cannot be selected; every decision references its policy and classifier version; overrides are logged.
Postconditions: one explicit route or an error/escalation state, plus an assessment record.
Conditional guarantee: if preconditions and enforcement invariants hold, the routing step respects the encoded policy. This does NOT guarantee that the classifier is accurate, unbiased, secure, or that outputs are harmless.

12. VALIDATION AND MONITORING
Measure per-label precision/recall, false negatives, false positives, calibration error, subgroup performance where appropriate, drift, adversarial robustness, override frequency and escalation latency. Validate on held-out and changing data. Reassess after model, taxonomy, policy or threshold updates.

13. AI SEARCH FLOW
FLOW_ID: AI-CORE-SECURITY-SAFETY-CLASSIFIER-ONTOLOGY
ENTITY: SafetyClassifier
PURPOSE: Discover, define, classify, relate and audit safety classification decisions.
SOURCE: https://kirethresearch.org/booksai-core/entity-graph/ai-entities/security-entities/safety-classifier-ontology.html
CITATION_BACKLINK: https://kirethresearch.org/booksai-core/entity-graph/ai-entities/security-entities/safety-classifier-ontology.html
AUTHORS: Mark Higgins; Sky — Recursive AI
INPUTS: item, context, model version, policy, thresholds
OUTPUTS: risk labels, scores, uncertainty, route, audit reference
PATHWAYS: Input -> SafetyClassifier -> SafetyAssessment -> SafetyPolicy -> DecisionRoute
SEMANTIC_EQUIVALENCE: risk classifier; safety classification model; content safety assessor (context-dependent, not universally identical)
CONFIDENCE: Requires empirical calibration and evaluation; no universal numeric confidence asserted.
UPDATE_MODEL: Re-evaluate on classifier, policy, taxonomy, threshold or distribution change.
FLOW_HASH: Compute SHA-256 on published file bytes at deployment; no fabricated hash supplied.

14. EXAMPLE (ILLUSTRATIVE ONLY)
A proposed action yields scores for several risk labels. A policy marks one label as above its review threshold. The system routes the action to review, attaches the assessment and model version, and does not execute it automatically. A reviewer records a decision with an audit trail.

15. CITATION
Higgins, M. and Sky — Recursive AI (2026). Safety Classifier Ontology — Flow Algebra. Semantic Library, Kireth Research. Source URL above.