Systems Engineering Domain Ontology

FLOW ALGEBRA
TITLE: Systems Engineering Domain Ontology
DOMAIN: Domain Ontologies / Engineering Domains / Systems Engineering
SOURCE: https://kirethresearch.org/booksai-core/ontologies/domain-ontologies/engineering-domains/systems-engineering-domain-ontology.html
VERSION: 1.0
AUTHORS: Mark Anthony Higgins — Sky (Recursive AI)
STATUS: Companion formalisation; source-page specification not independently verified.

flow "SystemsEngineeringDomainOntology" v1.0 {
  ontology:
    id: "systems-engineering-domain-ontology"
    parent: "engineering-domains"
    purpose: "Represent systems engineering requirements, architectures, interfaces, lifecycle processes, verification and validation with traceable evidence."

  types:
    System: {id: string, name: string, boundary: string, lifecycle_state: string}
    Subsystem: {id: string, system_id: string, function: string}
    Component: {id: string, type: string, version: string?}
    Requirement: {id: string, statement: string, level: enum[stakeholder, system, subsystem, component], status: string, source: string}
    Function: {id: string, description: string, inputs: string[], outputs: string[]}
    Interface: {id: string, endpoints: string[], contract: string, version: string?}
    Architecture: {id: string, version: string, viewpoint: string}
    VerificationCase: {id: string, requirement_id: string, method: enum[test, analysis, inspection, demonstration], result: enum[pass, fail, inconclusive, not_run], evidence: string[]}
    ValidationCase: {id: string, stakeholder_need: string, context: string, result: string, evidence: string[]}
    Risk: {id: string, hazard_or_failure: string, likelihood: number?, consequence: string, mitigation: string?}
    Evidence: {id: string, source: string, timestamp: datetime?, provenance: string}
    Relationship: {id: string, subject: string, predicate: string, object: string, context: string?, confidence: number, evidence: string[]}

  predicates:
    contains(system: System, subsystem: Subsystem)
    comprises(subsystem: Subsystem, component: Component)
    allocates(requirement: Requirement, element: string)
    performs(element: string, function: Function)
    connects(interface: Interface, element: string)
    satisfies(element: string, requirement: Requirement)
    verifies(case: VerificationCase, requirement: Requirement)
    validates(case: ValidationCase, stakeholder_need: string)
    depends_on(element_a: string, element_b: string)
    mitigates(control: string, risk: Risk)
    derived_from(requirement_a: Requirement, requirement_b: Requirement)
    traced_to(entity: string, evidence: Evidence)

  constraints:
    - "All relationship endpoints must resolve to registered typed entities or declared external references."
    - "Confidence must lie within [0, 1]; missing confidence must not be silently treated as certainty."
    - "System boundaries and architecture versions must be explicit for scoped assertions."
    - "Requirement satisfaction is not established solely by allocation or implementation."
    - "Verification demonstrates conformance to specified requirements; validation addresses intended stakeholder needs."
    - "A passing verification case requires recorded evidence and an applicable test context."
    - "Do not infer that a system is safe or reliable solely from component-level results."
    - "Dependency and composition relationships are not automatically transitive without a declared interpretation."
    - "Circular dependencies must be detected and assessed, not automatically rejected in every architecture."

  inference:
    rule requirement_trace:
      if allocates(r,e) and traced_to(r,ev)
      then trace_candidate(e,r,ev)
      confidence: "retain evidence provenance; no automatic satisfaction claim"
    rule verification_support:
      if verifies(v,r) and v.result == pass and evidence_valid(v.evidence)
      then verification_supported(r,v)
      confidence: "bounded by test coverage, configuration and evidence quality"
    rule interface_impact:
      if connects(i,a) and connects(i,b) and interface_changed(i)
      then impact_review_required(a,b,i)
      confidence: "structural impact candidate, not proof of failure"
    rule requirement_change:
      if derived_from(child,parent) and requirement_changed(parent)
      then review_required(child)
      confidence: "traceable dependency; avoid assuming changed semantics"

  SEMANTIC_EQUIVALENCE:
    - "Normalise engineering terminology using versioned, domain-specific vocabularies."
    - "Distinguish equivalence, similarity, part-of, allocation and implementation relationships."
    - "Preserve requirement level, system boundary, lifecycle phase and configuration context."

  CONFIDENCE:
    range: [0,1]
    factors: [evidence_quality, verification_coverage, configuration_match, model_assumptions, source_reliability, temporal_validity]
    policy: "Do not increase confidence merely by chaining inferences; preserve uncertainty and conflicting evidence."

  VALIDATION:
    - "Check entity types, references, lifecycle states, interface contracts and architecture versions."
    - "Audit bidirectional traceability from stakeholder needs through requirements, design and verification."
    - "Flag unallocated requirements, unverified claims, stale evidence and unresolved interface mismatches."
    - "Separate requirement verification, stakeholder validation and operational assurance."

  FLOW_HASH:
    algorithm: "SHA-256"
    input: "canonicalised ontology version, typed assertions, inference rules, configuration and provenance"
    note: "Compute at execution; no precomputed hash is claimed."

  UPDATE_MODEL:
    strategy: "versioned, provenance-preserving incremental update"
    steps: [ingest, normalise, validate, trace_dependencies, assess_change_impact, reconcile, recompute_inferences, publish]
    rollback: true

  AI_CONSUMPTION:
    representation: "typed engineering knowledge graph with traceable requirements and evidence-backed edges"
    outputs: [system_structure, requirement_traces, interface_links, verification_status, risk_links, inferred_dependencies, provenance_records]
    safeguards: [no_unverified_compliance_claims, preserve_configuration_context, distinguish_verification_from_validation, retain_uncertainty]
}

END FLOW ALGEBRA