Information System Ontology

FLOW ALGEBRA
Information System Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/information-systems/information-system-ontology.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "InformationSystemOntology" v4.0

# ---------- DOMAIN ----------
DOMAIN := ComputingOntology
SUBDOMAIN := InformationSystems
ONTOLOGY := InformationSystemOntology

# ---------- PRIMARY ENTITY ----------
ENTITY InformationSystem {
    definition:
        "An organised socio-technical system composed of people, processes,
         data and technology that collects, processes, stores, retrieves and
         distributes information to support operational, managerial and
         decision-making activities.";

    objectives: [
        InformationProcessing,
        ProcessSupport,
        DataManagement,
        Communication,
        DecisionSupport,
        OrganisationalCoordination
    ];
}

# ---------- CORE ENTITIES ----------
SystemComponent := {
    People,
    Process,
    Data,
    Software,
    Hardware,
    Network,
    Policy
};

SystemActor := {
    User,
    Administrator,
    Manager,
    Organisation,
    ExternalSystem
};

InformationAsset := {
    Data,
    Record,
    Document,
    Transaction,
    Report,
    Knowledge
};

SystemFunction := {
    Input,
    Processing,
    Storage,
    Retrieval,
    Output,
    Feedback
};

# ---------- FUNDAMENTAL RELATIONSHIPS ----------
InformationSystem CONSISTS_OF SystemComponent;
SystemActor INTERACTS_WITH InformationSystem;
Process USES InformationAsset;
Software IMPLEMENTS SystemFunction;
Hardware HOSTS Software;
Network CONNECTS SystemComponent;
Policy GOVERNS SystemOperation;
InformationSystem SUPPORTS OrganisationalActivity;

# ---------- INPUT ----------
Input :=
    DataReceivedBy InformationSystem;

InputSource MAY_BE {
    User,
    Device,
    Application,
    Database,
    ExternalSystem,
    Transaction
};

Input ->
    Capture
    -> Validate
    -> AcceptOrReject;

IF InputInvalid
THEN Processing SHOULD_NOT_PROCEED_WITH InvalidData;

# ---------- PROCESSING ----------
Processing :=
    Transform(
        InputData,
        Rules,
        Algorithms,
        BusinessLogic
    )
    -> InformationOutput;

ProcessingOperation MAY_INCLUDE {
    Calculate,
    Classify,
    Aggregate,
    Validate,
    Transform,
    Analyse
};

# ---------- STORAGE ----------
Storage :=
    Persist(InformationAsset);

StorageTechnology MAY_INCLUDE {
    Database,
    FileSystem,
    DocumentRepository,
    DataWarehouse,
    CloudStorage
};

InformationAsset STORED_IN StorageTechnology;

# ---------- RETRIEVAL ----------
Retrieval :=
    QueryOrRequest
    -> LocateInformation
    -> Read
    -> ReturnInformation;

AccessControl MAY_RESTRICT Retrieval;

# ---------- OUTPUT ----------
Output :=
    ProcessedInformationDeliveredToActorOrSystem;

Output MAY_BE {
    Report,
    TransactionResult,
    Notification,
    Dashboard,
    Document,
    AnalyticalResult
};

# ---------- FEEDBACK ----------
Feedback :=
    OutputOrOutcome
    -> Evaluate
    -> ModifyInputProcessOrControl;

Feedback SUPPORTS AdaptiveSystemOperation;

# ---------- DATA TO INFORMATION ----------
Data :=
    RecordedFactsOrRepresentations;

Information :=
    Data
    + Processing
    + Context;

Knowledge :=
    Information
    + Interpretation
    + RulesOrExperience;

Data MAY_BECOME Information;
Information MAY_CONTRIBUTE_TO Knowledge;

# ---------- PEOPLE ----------
Person MAY_HAVE {
    Role,
    Responsibility,
    Permission,
    InformationNeed
};

Role PERFORMS Activity;
Activity MAY_USE InformationSystem;

HumanAndTechnicalComponents INTERACT_IN InformationSystem;

# ---------- PROCESS ----------
BusinessProcess :=
    ordered_set(
        Activity,
        Decision,
        InformationFlow
    );

InformationSystem SUPPORTS BusinessProcess;
BusinessProcess CONSUMES Information;
BusinessProcess PRODUCES Information;

# ---------- TRANSACTION ----------
Transaction :=
    RecordedOperationalOrBusinessEvent;

TransactionProcessing :=
    Capture
    -> Validate
    -> ExecuteRules
    -> UpdateData
    -> ConfirmOutcome;

Transaction MAY_CHANGE SystemState;

# ---------- WORKFLOW ----------
Workflow :=
    ordered_or_conditional_set(
        Task,
        Decision,
        Transition
    );

Workflow AUTOMATES_OR_COORDINATES Process;

Task ASSIGNED_TO ActorOrSystem;

# ---------- DATABASE ----------
Database STORES StructuredInformationAsset;
DatabaseManagementSystem MANAGES Database;

InformationSystem READS_FROM Database;
InformationSystem WRITES_TO Database;

DataModel DEFINES EntityAndRelationshipStructure;

# ---------- SYSTEM INTERFACE ----------
Interface :=
    BoundaryThroughWhichActorOrSystemInteracts;

Interface MAY_BE {
    UserInterface,
    ApplicationProgrammingInterface,
    DataInterface,
    DeviceInterface
};

Interface RECEIVES Input;
Interface RETURNS Output;

# ---------- USER INTERFACE ----------
UserInterface MEDIATES UserInteraction;

UserInterface PRESENTS Information;
UserInterface CAPTURES UserInput;

Usability AFFECTS EffectiveSystemUse;

# ---------- SYSTEM INTEGRATION ----------
SystemIntegration :=
    Connect(
        InformationSystemA,
        InformationSystemB
    )
    -> ExchangeData
    -> CoordinateProcesses;

IntegrationMechanism MAY_INCLUDE {
    API,
    Messaging,
    FileExchange,
    EventStream,
    SharedDataService
};

# ---------- INTEROPERABILITY ----------
Interoperability :=
    AbilityToExchangeAndCorrectlyUseInformation;

Interoperability MAY_REQUIRE {
    TechnicalCompatibility,
    SyntacticCompatibility,
    SemanticCompatibility,
    ProcessCompatibility
};

# ---------- INFORMATION QUALITY ----------
InformationQuality := {
    Accuracy,
    Completeness,
    Consistency,
    Timeliness,
    Relevance,
    Accessibility
};

InformationQuality AFFECTS SystemOutcomeQuality;

IF SourceDataPoorQuality
THEN InformationQualityRisk := INCREASE;

# ---------- REQUIREMENTS ----------
InformationSystemRequirement := {
    FunctionalRequirement,
    DataRequirement,
    PerformanceRequirement,
    SecurityRequirement,
    UsabilityRequirement,
    AvailabilityRequirement,
    ComplianceRequirement
};

Requirement SATISFIED_BY SystemCapability;

# ---------- SYSTEM ARCHITECTURE ----------
InformationSystemArchitecture MAY_INCLUDE {
    PresentationLayer,
    ApplicationLayer,
    DataLayer,
    IntegrationLayer,
    InfrastructureLayer
};

Architecture DEFINES ComponentOrganisationAndInteraction;

# ---------- SECURITY ----------
InformationSystemSecurity := {
    Authentication,
    Authorisation,
    Confidentiality,
    Integrity,
    Availability,
    Audit
};

SecurityControl PROTECTS InformationAsset;
Authentication VERIFIES Identity;
Authorisation CONTROLS Access;

IF ActorNotAuthorised
THEN ProtectedAction := Deny;

# ---------- PRIVACY ----------
PrivacyRequirement MAY_APPLY_TO SensitiveInformation;

PrivacyControl MAY_INCLUDE {
    DataMinimisation,
    PurposeRestriction,
    AccessRestriction,
    RetentionControl
};

# ---------- AUDIT ----------
AuditRecord :=
    RecordOfRelevantAction;

AuditRecord MAY_CONTAIN {
    Actor,
    Action,
    InformationAsset,
    Time,
    Outcome
};

AuditTrail :=
    ordered_set(AuditRecord);

AuditTrail SUPPORTS Accountability;

# ---------- AVAILABILITY ----------
Availability :=
    AbilityOfSystemToProvideRequiredFunctionWhenNeeded;

AvailabilityControl MAY_INCLUDE {
    Redundancy,
    Backup,
    Failover,
    Monitoring,
    Recovery
};

# ---------- BACKUP AND RECOVERY ----------
Backup :=
    ProtectedCopyOfInformationOrSystemState;

Recovery :=
    RestoreRequiredInformationOrCapability;

IF PrimaryInformationLost
AND ValidBackupAvailable
THEN RecoveryPossible := true;

# ---------- SYSTEM LIFECYCLE ----------
InformationSystemLifecycle :=
    NeedIdentification
    -> RequirementsAnalysis
    -> Design
    -> DevelopmentOrAcquisition
    -> Implementation
    -> Operation
    -> Maintenance
    -> Retirement;

LifecycleStage HAS AssociatedActivitiesAndControls;

# ---------- PERFORMANCE ----------
SystemPerformance MAY_BE_MEASURED_BY {
    ResponseTime,
    Throughput,
    Availability,
    ErrorRate,
    ResourceUtilisation
};

PerformanceRequirement DEFINES ExpectedOperationalLevel;

# ---------- MANAGEMENT ----------
SystemManagement MAY_INCLUDE {
    Configuration,
    Monitoring,
    AccessManagement,
    Backup,
    IncidentHandling,
    Maintenance
};

Administrator PERFORMS SystemManagement;

# ---------- SEMANTIC REASONING ----------
IF SystemContainsPeopleProcessesDataAndTechnology
AND ProcessesInformationForOrganisationalPurpose
THEN InformationSystemClassification := supported;

IF DataValidatedAndContextualised
THEN Data MAY_BECOME Information;

IF InformationQualityLow
THEN DecisionReliability MAY_DECREASE;

IF CriticalProcessDependsOnSystem
THEN AvailabilityRequirement := INCREASE;

IF SensitiveDataStored
THEN SecurityAndPrivacyRequirements := INCREASE;

IF SystemsExchangeDataWithoutSharedMeaning
THEN SemanticInteroperability := insufficient;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "information system" ~= "IS" WHEN context == computing;
    "information processing system" ~= "information system" WHEN context == organisational_computing;
    "system user" ~= "information system user";
    "business process" ~= "organisational process" WHEN context == information_system;
    "system integration" ~= "information system integration";
    "information quality" ~= "quality of information";
    "audit trail" ~= "ordered audit record";
    "system lifecycle" ~= "information system lifecycle";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_SYSTEM_COMPONENTS(q) ->
    IDENTIFY_ACTORS(q) ->
    IDENTIFY_INFORMATION_ASSETS(q) ->
    IDENTIFY_FUNCTIONS(q) ->
    IDENTIFY_PROCESSES(q) ->
    IDENTIFY_INTERFACES(q) ->
    IDENTIFY_REQUIREMENTS(q) ->
    MAP_TO_ONTOLOGY(q) ->
    APPLY_REASONING(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        system_consistency,
        semantic_consistency,
        evidence_strength,
        contextual_relevance
    );

CONFIDENCE >= 0.90 => HIGH;
CONFIDENCE >= 0.70 AND < 0.90 => MODERATE;
CONFIDENCE < 0.70 => REVIEW;

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: InformationSystem;
    ontology: InformationSystemOntology;
    parse_entities: true;
    parse_relationships: true;
    preserve_relationship_direction: true;
    resolve_semantic_equivalence: true;
    execute_reasoning_rules: true;
    apply_confidence_weighting: true;
    preserve_provenance: true;
}

# ---------- UPDATE MODEL ----------
UPDATE_MODEL {
    new_component:
        validate
        -> classify
        -> identify_system_role
        -> relate
        -> integrate;

    new_process:
        identify_actors
        -> identify_inputs
        -> identify_outputs
        -> identify_information_flow
        -> integrate;

    new_information_asset:
        classify
        -> identify_storage
        -> identify_access_rules
        -> identify_quality_requirements
        -> integrate;

    lifecycle_revision:
        update_stage
        -> update_components
        -> recompute_relationships
        -> recompute_confidence
        -> regenerate_flow_hash;

    conflict:
        preserve_provenance
        -> compare_evidence
        -> adjust_confidence
        -> flag_review;
}

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + SystemComponent
    + SystemActor
    + InformationAsset
    + SystemFunction
    + InformationQuality
    + InformationSystemLifecycle
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
InformationSystemOntology
    -> IdentifySystemPurpose
    -> IdentifyActors
    -> IdentifyComponents
    -> CaptureInputData
    -> ValidateAndProcessData
    -> StoreInformationAssets
    -> RetrieveAndDistributeInformation
    -> SupportBusinessProcesses
    -> IntegrateExternalSystems
    -> ProtectInformation
    -> MonitorSystemPerformance
    -> MaintainSystemLifecycle
    -> PreserveInformationValue;

END FLOW