Human Computer Interaction Ontology

FLOW ALGEBRA
Human Computer Interaction Ontology
Kireth Semantic Research Archive

PAGE:
https://kirethresearch.org/booksai-core/ontologies/computing-ontologies/human-computer-interaction/human-computer-interaction-ontology.html

AUTHORS:
Mark Anthony Higgins — Sky (Recursive AI)

FLOW "HumanComputerInteractionOntology" v4.0

# ---------- DOMAIN ----------
DOMAIN := ComputingOntology
SUBDOMAIN := HumanComputerInteraction
ONTOLOGY := HumanComputerInteractionOntology

# ---------- PRIMARY ENTITY ----------
ENTITY HumanComputerInteraction {
    definition:
        "The study and design of interactive computational systems and the
         ways in which human users perceive, understand, control and respond
         to those systems through interfaces and interaction mechanisms.";

    objectives: [
        EffectiveInteraction,
        EfficientInteraction,
        Usability,
        Accessibility,
        Learnability,
        UserSatisfaction,
        ErrorReduction
    ];
}

# ---------- CORE ENTITIES ----------
InteractionEntity := {
    User,
    InteractiveSystem,
    Interface,
    Task,
    Goal,
    Input,
    Output,
    Context
};

UserProperty := {
    Ability,
    Experience,
    Knowledge,
    Preference,
    Limitation,
    MentalModel
};

InterfaceElement := {
    Control,
    NavigationElement,
    FormElement,
    ContentElement,
    FeedbackElement
};

InteractionState := {
    Idle,
    AwaitingInput,
    Processing,
    PresentingOutput,
    Error,
    Completed
};

# ---------- FUNDAMENTAL RELATIONSHIPS ----------
User HAS Goal;
User PERFORMS Task;
Task INTERACTS_WITH InteractiveSystem;
Interaction OCCURS_THROUGH Interface;
Interface RECEIVES Input;
InteractiveSystem PROCESSES Input;
Interface PRESENTS Output;
Context AFFECTS Interaction;
UserProperty AFFECTS InteractionPerformance;

# ---------- INTERACTION CYCLE ----------
Goal ->
    FormIntention
    -> SelectAction
    -> ExecuteAction
    -> SystemReceivesInput
    -> SystemChangesState
    -> PresentFeedback
    -> UserPerceives
    -> UserInterprets
    -> EvaluateAgainstGoal;

IF GoalNotAchieved
THEN InteractionCycle MAY_CONTINUE;

# ---------- USER ----------
User :=
    HumanParticipantInInteraction;

User HAS {
    PhysicalCapability,
    SensoryCapability,
    CognitiveCapability,
    DomainKnowledge,
    SystemExperience
};

Interface SHOULD_ACCOMMODATE RelevantUserCapabilities;

# ---------- GOAL ----------
Goal :=
    DesiredOutcomeOfUser;

Task :=
    ActionsRequiredToProgressTowardGoal;

Goal MAY_DECOMPOSE_INTO Subgoal;
Task MAY_DECOMPOSE_INTO Subtask;

# ---------- TASK MODEL ----------
TaskModel :=
    {
        Task,
        Sequence,
        Dependency,
        Frequency,
        Complexity
    };

TaskAnalysis IDENTIFIES UserActionsAndInformationNeeds;

# ---------- CONTEXT ----------
ContextOfUse :=
    {
        UserContext,
        DeviceContext,
        PhysicalEnvironment,
        SocialEnvironment,
        OrganisationalEnvironment
    };

InteractionQuality DEPENDS_ON ContextOfUse;

# ---------- INPUT ----------
Input :=
    SignalOrActionProvidedToSystem;

InputModality := {
    Keyboard,
    Pointer,
    Touch,
    Voice,
    Gesture,
    Sensor,
    Controller
};

InputEvent MAY_TRIGGER SystemAction;

# ---------- OUTPUT ----------
Output :=
    InformationOrFeedbackProducedBySystem;

OutputModality := {
    Visual,
    Auditory,
    Haptic,
    Textual
};

Output SHOULD_BE PerceivableByIntendedUser;

# ---------- INTERFACE ----------
Interface :=
    InteractionBoundaryBetweenUserAndSystem;

Interface MAY_INCLUDE {
    VisualPresentation,
    Controls,
    Navigation,
    InputFields,
    Feedback,
    Help
};

InterfaceDesign SHOULD_SUPPORT UserGoalAndTask;

# ---------- FEEDBACK ----------
Feedback :=
    PerceivableSystemResponseToUserActionOrState;

Feedback SHOULD_BE {
    Timely,
    Relevant,
    Understandable
};

IF UserActionHasNoPerceivableFeedback
THEN UserUncertainty MAY_INCREASE;

# ---------- SYSTEM STATUS ----------
SystemStatus :=
    CurrentOperationalOrInteractionState;

Interface SHOULD_COMMUNICATE RelevantSystemStatus;

VisibilityOfSystemStatus SUPPORTS UserUnderstanding;

# ---------- AFFORDANCE ----------
Affordance :=
    ActionPossibilityOfferedByInterfaceOrObject;

PerceivedAffordance :=
    ActionPossibilityUserBelievesAvailable;

Signifier MAY_COMMUNICATE Affordance;

# ---------- MAPPING ----------
Mapping :=
    RelationshipBetweenControlAndEffect;

NaturalMapping MAY_REDUCE LearningAndError;

# ---------- CONSTRAINT ----------
InteractionConstraint :=
    RestrictionPreventingInvalidOrUnavailableAction;

Constraint MAY_PREVENT Error;

# ---------- CONSISTENCY ----------
Consistency :=
    SimilarInterfaceElementsBehaveAccordingToStablePatterns;

Consistency SUPPORTS {
    Learnability,
    Predictability,
    Efficiency
};

# ---------- ERROR ----------
InteractionError := {
    Slip,
    Mistake,
    InputError,
    NavigationError,
    SystemError
};

ErrorHandling :=
    Detect
    -> Explain
    -> SupportRecovery;

Interface SHOULD_PREFER ErrorPreventionWherePractical;

# ---------- RECOVERY ----------
RecoveryMechanism MAY_INCLUDE {
    Undo,
    Redo,
    Cancel,
    Correction,
    Retry,
    Restore
};

UserControl SUPPORTS SafeExploration;

# ---------- USABILITY ----------
Usability :=
    f(
        Effectiveness,
        Efficiency,
        Satisfaction,
        Learnability,
        ErrorRate
    );

Effectiveness :=
    DegreeOfGoalAchievement;

Efficiency :=
    ResourcesRequiredForGoalAchievement;

# ---------- LEARNABILITY ----------
Learnability :=
    EaseOfLearningToUseSystem;

Learnability MAY_BE_SUPPORTED_BY {
    FamiliarPatterns,
    Consistency,
    ClearLabels,
    Guidance,
    ProgressiveDisclosure
};

# ---------- ACCESSIBILITY ----------
Accessibility :=
    DegreeToWhichSystemCanBeUsedByPeopleWithDiverseCapabilities;

AccessibilityRequirement MAY_INCLUDE {
    KeyboardOperability,
    TextAlternative,
    SemanticStructure,
    Contrast,
    Captions,
    FlexibleInput,
    AssistiveTechnologyCompatibility
};

# ---------- COGNITIVE LOAD ----------
CognitiveLoad :=
    MentalEffortRequiredDuringInteraction;

CognitiveLoad MAY_INCREASE_WITH {
    UnnecessaryComplexity,
    PoorOrganisation,
    AmbiguousControls,
    ExcessiveMemoryDemand
};

Interface SHOULD_MINIMISE ExtraneousCognitiveLoad;

# ---------- MENTAL MODEL ----------
MentalModel :=
    UserInternalRepresentationOfHowSystemWorks;

SystemBehaviour SHOULD_SUPPORT AccurateMentalModelFormation;

UnexpectedBehaviour MAY_CREATE MentalModelMismatch;

# ---------- INFORMATION ARCHITECTURE ----------
InformationArchitecture :=
    Organisation
    + Labelling
    + Navigation
    + Search;

InformationArchitecture SUPPORTS {
    Findability,
    Comprehension,
    Orientation
};

# ---------- NAVIGATION ----------
Navigation :=
    MovementBetweenInterfaceStatesOrInformationLocations;

NavigationElement MAY_INCLUDE {
    Menu,
    Link,
    Breadcrumb,
    Tab,
    Search
};

User SHOULD_BE_ABLE_TO IdentifyCurrentLocationAndPossibleNextAction;

# ---------- DIALOGUE ----------
Dialogue :=
    SequenceOfUserAndSystemActions;

DialogueState :=
    CurrentContextOfInteractiveExchange;

ConversationalInterface MAINTAINS DialogueState;

# ---------- DIRECT MANIPULATION ----------
DirectManipulation :=
    UserActsOnVisibleInterfaceObject
    -> ImmediateFeedback;

DirectManipulation MAY_SUPPORT LearnabilityAndControl;

# ---------- USER-CENTRED DESIGN ----------
UserCentredDesign :=
    UnderstandContext
    -> SpecifyUserRequirements
    -> ProduceDesign
    -> EvaluateDesign
    -> Iterate;

UserEvidence SHOULD_INFORM DesignDecision;

# ---------- PROTOTYPE ----------
Prototype :=
    RepresentationOfProposedInteraction;

Prototype MAY_BE {
    LowFidelity,
    HighFidelity,
    Interactive
};

Prototype ENABLES EarlyEvaluation;

# ---------- USABILITY TEST ----------
UsabilityTest :=
    User
    -> PerformTask
    -> ObserveBehaviour
    -> RecordMetrics
    -> IdentifyUsabilityIssue;

UsabilityMetric MAY_INCLUDE {
    TaskSuccess,
    CompletionTime,
    ErrorCount,
    AssistanceRequired,
    Satisfaction
};

# ---------- HEURISTIC EVALUATION ----------
HeuristicEvaluation :=
    Evaluator
    -> InspectInterface
    -> CompareWithUsabilityPrinciples
    -> RecordIssue;

HeuristicEvaluation COMPLEMENTS UserTesting;

# ---------- USER EXPERIENCE ----------
UserExperience :=
    PerceptionsAndResponsesArisingFromInteraction;

UXProperty MAY_INCLUDE {
    Satisfaction,
    Trust,
    PerceivedEase,
    Emotion,
    PerceivedValue
};

# ---------- TRUST ----------
InteractionTrust :=
    f(
        Reliability,
        Predictability,
        Transparency,
        Security,
        PriorExperience
    );

MisleadingFeedback MAY_REDUCE Trust;

# ---------- PRIVACY ----------
InteractiveSystem MAY_COLLECT UserData;

PrivacyInteraction SHOULD_SUPPORT {
    Transparency,
    Consent,
    UserControl,
    DataMinimisation
};

# ---------- SEMANTIC REASONING ----------
IF HumanUserPerformsTaskThroughComputerInterface
THEN HumanComputerInteraction EXISTS;

IF TaskSuccessLow
THEN Effectiveness := low;

IF CompletionTimeHighForSimpleTask
THEN EfficiencyIssue MAY_EXIST;

IF RepeatedUserErrorsOccurAtSameControl
THEN InterfaceDesignIssue := likely;

IF UserCannotPerceiveRequiredOutput
THEN Accessibility := insufficient;

IF InterfaceProvidesImmediateRelevantFeedback
THEN InteractionClarity MAY_INCREASE;

IF UserMentalModelMatchesSystemBehaviour
THEN Predictability MAY_INCREASE;

# ---------- SEMANTIC EQUIVALENCE ----------
SEMANTIC_EQUIVALENCE {
    "human computer interaction" ~= "HCI";
    "human-computer interaction" ~= "human computer interaction";
    "interactive system" ~= "human-interactive computer system";
    "user interface" ~= "UI";
    "user experience" ~= "UX";
    "context of use" ~= "interaction context";
    "usability test" ~= "user usability test";
    "user-centred design" ~= "user-centered design";
}

# ---------- QUERY FLOW ----------
QUERY(q) ->
    NORMALISE(q) ->
    IDENTIFY_USER(q) ->
    IDENTIFY_GOAL(q) ->
    IDENTIFY_TASK(q) ->
    IDENTIFY_INTERFACE(q) ->
    IDENTIFY_INPUT_OUTPUT(q) ->
    IDENTIFY_CONTEXT(q) ->
    IDENTIFY_USABILITY_OR_ACCESSIBILITY(q) ->
    MAP_TO_ONTOLOGY(q) ->
    APPLY_REASONING(q) ->
    SCORE_CONFIDENCE(q) ->
    RETURN_RELEVANT_KNOWLEDGE;

# ---------- CONFIDENCE ----------
CONFIDENCE(assertion) :=
    weighted_mean(
        source_reliability,
        user_evidence,
        interaction_consistency,
        semantic_consistency,
        contextual_relevance
    );

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

# ---------- AI CONSUMPTION ----------
AI_CONSUMPTION {
    primary_entity: HumanComputerInteraction;
    ontology: HumanComputerInteractionOntology;
    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_user_evidence:
        identify_user
        -> identify_task
        -> identify_context
        -> record_observation
        -> integrate;

    new_interface_element:
        validate
        -> classify
        -> identify_action
        -> identify_feedback
        -> identify_accessibility_properties
        -> integrate;

    new_usability_test:
        identify_participants
        -> identify_tasks
        -> record_metrics
        -> identify_issues
        -> integrate;

    design_revision:
        update_interface
        -> update_interaction_flow
        -> update_usability_evidence
        -> recompute_confidence
        -> regenerate_flow_hash;

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

# ---------- FLOW HASH ----------
FLOW_HASH_INPUT :=
    DOMAIN
    + SUBDOMAIN
    + ONTOLOGY
    + InteractionEntity
    + UserProperty
    + InterfaceElement
    + InteractionState
    + Usability
    + Accessibility
    + UserCentredDesign
    + RELATIONSHIPS
    + SEMANTIC_REASONING
    + SEMANTIC_EQUIVALENCE
    + UPDATE_MODEL;

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT);

# ---------- TERMINAL ----------
HumanComputerInteractionOntology
    -> IdentifyUser
    -> IdentifyGoalAndTask
    -> UnderstandContext
    -> DefineInputAndOutput
    -> DesignInterface
    -> ProvideSystemFeedback
    -> PreventAndRecoverFromErrors
    -> SupportAccessibility
    -> PrototypeInteraction
    -> TestWithUsers
    -> MeasureUsability
    -> RefineDesign
    -> ImproveInteractionQuality;

END FLOW