Software Engineering Domain Ontology

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

flow "SoftwareEngineeringDomainOntology" v1.0 {
  ontology:
    id: "software-engineering-domain-ontology"
    parent: "engineering-domains"
    purpose: "Represent software engineering artefacts, requirements, architectures, implementations, tests, deployments and their traceable relationships."

  types:
    SoftwareSystem: {id: string, name: string, version: string, lifecycle_state: string}
    Requirement: {id: string, statement: string, kind: enum[functional, nonfunctional, constraint], priority: string?, status: string}
    Component: {id: string, system_id: string, interface_ids: string[], version: string}
    Interface: {id: string, contract: string, version: string, protocol: string?}
    SourceArtefact: {id: string, kind: enum[source_file, library, configuration, documentation, build], revision: string, repository: string?}
    Change: {id: string, revision: string, author: string?, timestamp: datetime, rationale: string?}
    TestCase: {id: string, requirement_ids: string[], expected_result: string, test_kind: string}
    TestRun: {id: string, test_id: string, build_id: string, result: enum[pass, fail, skip, error], timestamp: datetime, evidence: string[]}
    Deployment: {id: string, build_id: string, environment: string, timestamp: datetime, status: string}
    Defect: {id: string, severity: string, status: string, affected_versions: string[]}
    Evidence: {id: string, source: string, timestamp: datetime?, provenance: string}
    Relationship: {id: string, subject: string, predicate: string, object: string, confidence: number, evidence: string[], context: string?}

  predicates:
    decomposes_into(system: SoftwareSystem, component: Component)
    implements(component: Component, requirement: Requirement)
    exposes(component: Component, interface: Interface)
    depends_on(a: Component, b: Component)
    modifies(change: Change, artefact: SourceArtefact)
    verifies(test: TestCase, requirement: Requirement)
    executed_as(test: TestCase, run: TestRun)
    deployed_as(system: SoftwareSystem, deployment: Deployment)
    affects(defect: Defect, component: Component)
    supported_by(relationship: Relationship, evidence: Evidence)

  constraints:
    - "All relationship endpoints must resolve to declared, typed entities."
    - "Confidence values must lie in [0,1]."
    - "A test case linked to a requirement does not by itself establish that the requirement is satisfied."
    - "A passing test run is evidence only for the tested build, environment, configuration and assertions."
    - "Dependency and implementation relations are not automatically symmetric or transitive."
    - "Changes, builds, tests and deployments must retain version and provenance context."
    - "Do not equate deployment success with operational correctness or security."
    - "Do not merge software artefacts solely because names match."

  inference:
    rule requirement_trace:
      if implements(c,r) and verifies(t,r)
      then traceability_link(c,t,r)
      confidence: "evidence-dependent; not proof of compliance"
    rule change_impact_candidate:
      if modifies(change,a) and belongs_to(a,c) and depends_on(other,c)
      then potential_impact(change,other)
      confidence: "requires dependency and runtime validation"
    rule verification_evidence:
      if executed_as(t,run) and run.result == pass and verifies(t,r)
      then supporting_test_evidence(r,run)
      confidence: "limited to test scope and build context"

  SEMANTIC_EQUIVALENCE:
    - "Normalise canonical component, requirement and artefact identifiers within versioned namespaces."
    - "Distinguish equivalent implementations from identical artefacts and compatible interfaces."
    - "Retain version, environment, configuration and interface-contract context."

  CONFIDENCE:
    range: [0,1]
    factors: [test_coverage, evidence_quality, provenance_reliability, version_match, environment_match, independent_replication]
    policy: "Do not manufacture certainty through inference chaining or duplicated evidence."

  VALIDATION:
    - "Check identifier resolution, type compatibility and referential integrity."
    - "Check requirement-to-implementation-to-test traceability for missing links."
    - "Flag incompatible interface versions, stale evidence and unresolved defects."
    - "Detect dependency cycles where forbidden by architecture policy."
    - "Keep failed and conflicting test evidence rather than overwriting it."

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

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

  AI_CONSUMPTION:
    representation: "typed software engineering knowledge graph with evidence-backed edges"
    outputs: [requirement_traces, component_dependencies, impact_candidates, verification_records, provenance_records, uncertainty_annotations]
    safeguards: [no_unverified_compliance_claims, no_unsupported_causal_claims, preserve_version_context, retain_failed_tests]
}

END FLOW ALGEBRA