Decidability Ontology

KIRETH RESEARCH - SEMANTIC LIBRARY
AI CORE -> ONTOLOGIES -> MATHEMATICAL ONTOLOGIES -> MATHEMATICAL LOGIC ONTOLOGIES
COMPUTABILITY THEORY -> DECIDABILITY ONTOLOGY

Canonical URL:
https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/computability-theory/decidability-ontology.html

FLOW_ALGEBRA DecidabilityOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN DecidabilityOntology := {
    Decidability,
    ComputabilityTheory,
    DecisionProblem,
    DecidableProblem,
    UndecidableProblem,
    SemiDecidableProblem,
    Language,
    DecidableLanguage,
    RecognisableLanguage,
    RecursivelyEnumerableLanguage,
    RecursiveLanguage,
    ComputableSet,
    CharacteristicFunction,
    Algorithm,
    Decider,
    Recogniser,
    TuringMachine,
    Input,
    YesInstance,
    NoInstance,
    Acceptance,
    Rejection,
    Halting,
    Divergence,
    Complement,
    Reduction,
    ManyOneReduction,
    TuringReduction,
    HaltingProblem,
    UndecidabilityProof,
    ChurchTuringThesis
}

DEFINE ENTITY_TYPES := {
    DECIDABILITY_PROPERTY,
    DECISION_PROBLEM,
    LANGUAGE,
    SET,
    ALGORITHM,
    DECIDER,
    RECOGNISER,
    MACHINE,
    INPUT,
    COMPUTABLE_FUNCTION,
    REDUCTION,
    THEOREM,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    DECIDES,
    RECOGNISES,
    ACCEPTS,
    REJECTS,
    HALTS_ON,
    DIVERGES_ON,
    HAS_INPUT,
    HAS_COMPLEMENT,
    COMPUTES,
    REDUCES_TO,
    MANY_ONE_REDUCES_TO,
    TURING_REDUCES_TO,
    IS_DECIDABLE_BY,
    IS_RECOGNISABLE_BY,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON
}

SET Decidability.type = DECIDABILITY_PROPERTY
SET Decidability.context = ComputabilityTheory
SET Decidability.role =
    "classify whether a decision problem has an effective procedure that halts on every valid input and returns the correct yes-or-no answer"

RULE decision_problem:
    SetOfInstances(X)
    AND Predicate(P:X->Boolean)
    -> DecisionProblem(P)

RULE decider:
    DecisionProblem(P)
    AND Algorithm(A)
    AND FOR_EVERY input x MEMBER_OF InstanceDomain(P) [
        HALTS_ON(A,x)
        AND output(A,x)=P(x)
    ]
    -> Decider(A,P)

RULE decidable_problem:
    DecisionProblem(P)
    AND EXISTS Decider(A,P)
    -> DecidableProblem(P)

RULE undecidable_problem:
    DecisionProblem(P)
    AND NOT EXISTS Algorithm(A) [
        A halts_on_every_valid_input
        AND A correctly_decides P
    ]
    -> UndecidableProblem(P)

RULE language_decider:
    Language(L)
    AND TuringMachine(M)
    AND FOR_EVERY input w [
        HALTS_ON(M,w)
        AND (
            w MEMBER_OF L -> ACCEPTS(M,w)
        )
        AND (
            w NOT_MEMBER_OF L -> REJECTS(M,w)
        )
    ]
    -> DecidableLanguage(L)
    AND DECIDES(M,L)

RULE recognisable_language:
    Language(L)
    AND TuringMachine(M)
    AND FOR_EVERY input w [
        w MEMBER_OF L -> ACCEPTS(M,w)
    ]
    -> RecognisableLanguage(L)
    AND RECOGNISES(M,L)

RULE decidable_implies_recognisable:
    DecidableLanguage(L)
    -> RecognisableLanguage(L)

RULE decidable_complement:
    DecidableLanguage(L)
    -> DecidableLanguage(Complement(L))

RULE recognisable_and_corecognisable:
    RecognisableLanguage(L)
    AND RecognisableLanguage(Complement(L))
    -> DecidableLanguage(L)

RULE characteristic_function:
    Set(A)
    -> CharacteristicFunction(chi_A)
       where {
           chi_A(x)=1 IF x MEMBER_OF A,
           chi_A(x)=0 IF x NOT_MEMBER_OF A
       }

RULE computable_characteristic_equivalence:
    Set(A)
    AND TotalComputableFunction(chi_A)
    -> DecidableSet(A)

RULE many_one_reduction:
    DecisionProblem(A)
    AND DecisionProblem(B)
    AND EXISTS TotalComputableFunction(f) [
        FOR_EVERY x [
            A(x)=TRUE
            IFF
            B(f(x))=TRUE
        ]
    ]
    -> MANY_ONE_REDUCES_TO(A,B)

RULE reduction_decidability_backward:
    MANY_ONE_REDUCES_TO(A,B)
    AND DecidableProblem(B)
    -> DecidableProblem(A)

RULE reduction_undecidability_forward:
    MANY_ONE_REDUCES_TO(A,B)
    AND UndecidableProblem(A)
    -> UndecidableProblem(B)

RULE halting_problem:
    HaltingProblem(HALT)
    -> HALT = {
        encode(M,w)
        | HALTS_ON(M,w)
    }

RULE halting_problem_undecidable:
    -> UndecidableProblem(HaltingProblem)

RULE semi_decidability:
    DecisionProblem(P)
    AND EXISTS Recogniser(R) [
        FOR_EVERY yes_instance x [
            ACCEPTS(R,x)
        ]
        AND no_instances_may_reject_or_diverge
    ]
    -> SemiDecidableProblem(P)

DEFINE DECIDABILITY_MODEL := {
    input:
        DecisionProblem,
    requirement: {
        correctness:
            "every answer is correct",
        totality:
            "procedure halts on every valid input"
    },
    output:
        BooleanDecision
}

DEFINE DECIDER_MODEL := {
    yes_instance:
        "halts and accepts",
    no_instance:
        "halts and rejects",
    divergence_allowed:
        FALSE
}

DEFINE RECOGNISER_MODEL := {
    yes_instance:
        "halts and accepts",
    no_instance:
        "may reject or diverge",
    divergence_allowed:
        TRUE_ON_NEGATIVE_INSTANCES
}

DEFINE CHARACTERISTIC_FUNCTION_MODEL := {
    set: A,
    function:
        "chi_A(x) in {0,1}",
    decidability_condition:
        "A is decidable when chi_A is total computable"
}

DEFINE CRITICAL_DISTINCTIONS := {
    decidable_vs_recognisable: {
        decidable:
            "halts on all yes and no instances",
        recognisable:
            "guaranteed to halt and accept yes instances; may diverge on no instances"
    },
    undecidable_vs_unrecognisable: {
        undecidable:
            "no total correct decider exists",
        unrecognisable:
            "no recogniser exists",
        implication:
            "unrecognisable implies undecidable, but undecidable does not imply unrecognisable"
    },
    decidability_vs_complexity: {
        decidability:
            "asks whether a terminating algorithm exists",
        complexity:
            "asks how much time or space an algorithm requires"
    },
    decision_problem_vs_function_problem: {
        decision_problem:
            "yes/no output",
        function_problem:
            "general output value"
    }
}

DEFINE EXAMPLE_1 := {
    problem:
        "is integer n even?",
    algorithm:
        "compute n modulo 2",
    termination:
        "always",
    classification:
        DecidableProblem
}

DEFINE EXAMPLE_2 := {
    problem:
        HaltingProblem,
    input:
        "encoding of machine M and input w",
    question:
        "does M halt on w?",
    classification:
        UndecidableProblem
}

DEFINE EXAMPLE_3 := {
    language:
        "encodings of Turing machines that halt on blank input",
    recognisable:
        TRUE,
    decidable:
        FALSE
}

DEFINE DECIDABILITY_ANALYSIS_PIPELINE :=
    ProblemSpecification
    -> ConfirmBooleanDecisionForm
    -> IdentifyInstanceDomain
    -> SearchForCandidateAlgorithm
    -> VerifyCorrectnessOnYesInstances
    -> VerifyCorrectnessOnNoInstances
    -> VerifyHaltingOnAllInputs
    -> IF all_conditions_hold
       THEN Decidable
    -> ELSE ContinueWithUndecidabilityAnalysis

DEFINE RECOGNISABILITY_PIPELINE :=
    DecisionProblem
    -> SearchForRecogniser
    -> VerifyAllPositiveInstancesAccepted
    -> AnalyseNegativeInstanceBehaviour
    -> ClassifyRecognisableStatus
    -> CheckComplementRecognisability
    -> IF both_language_and_complement_recognisable
       THEN InferDecidability

DEFINE UNDECIDABILITY_PIPELINE :=
    TargetProblem(B)
    -> SelectKnownUndecidableProblem(A)
    -> ConstructReduction(A,B)
    -> VerifyReductionIsComputable
    -> VerifyYesNoPreservation
    -> ApplyUndecidabilityTransfer
    -> OR ConstructDiagonalArgument
    -> ReturnUndecidableResult

DEFINE DECISION_GRAPH := {
    node_types: {
        ProblemNode,
        InputNode,
        AlgorithmNode,
        MachineNode,
        LanguageNode,
        ComplementNode,
        ReductionNode
    },
    edge_types: {
        DECIDES,
        RECOGNISES,
        ACCEPTS,
        REJECTS,
        HALTS_ON,
        DIVERGES_ON,
        HAS_COMPLEMENT,
        REDUCES_TO
    },
    halting_requirement_for_decider: TRUE
}

DEFINE ONTOLOGY_RELATIONS := {
    Decidability IS_COMPONENT_OF ComputabilityTheory,
    DecidableProblem IS_SUBTYPE_OF DecisionProblem,
    UndecidableProblem IS_SUBTYPE_OF DecisionProblem,
    SemiDecidableProblem IS_SUBTYPE_OF DecisionProblem,
    Decider DECIDES DecidableProblem,
    Recogniser RECOGNISES RecognisableLanguage,
    DecidableLanguage IS_SUBTYPE_OF RecognisableLanguage,
    DecidableSet HAS_COMPUTABLE CharacteristicFunction,
    Complement PRESERVES Decidability,
    ManyOneReduction TRANSFERS DecidabilityBackward,
    ManyOneReduction TRANSFERS UndecidabilityForward,
    HaltingProblem IS_INSTANCE_OF UndecidableProblem
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "decidability" <=> Decidability,
    "decidable" <=> DecidableProblem WHEN decision_problem_context=TRUE,
    "recursive language" <=> DecidableLanguage,
    "Turing-decidable" <=> DecidableLanguage,
    "recognisable" <=> RecognisableLanguage,
    "recursively enumerable" <=> RecognisableLanguage,
    "semi-decidable" <=> SemiDecidableProblem,
    "undecidable" <=> UndecidableProblem
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation and reasoning for decidability, recognisability and undecidability",
    preserve_problem_identity: TRUE,
    preserve_instance_domain: TRUE,
    preserve_yes_no_semantics: TRUE,
    preserve_algorithm_identity: TRUE,
    preserve_halting_requirement: TRUE,
    distinguish_decider_from_recogniser: TRUE,
    distinguish_undecidable_from_unrecognisable: TRUE,
    distinguish_decidability_from_complexity: TRUE,
    preserve_reduction_direction: TRUE,
    validate_reduction_correctness: TRUE,
    support_complement_reasoning: TRUE,
    support_undecidability_proofs: TRUE,
    reasoning_mode: "symbolic + algorithmic + halting-aware + reduction-based"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    decidability_definition: 1.00,
    recogniser_decider_distinction: 1.00,
    complement_rule: 0.99,
    characteristic_function_mapping: 0.99,
    reduction_transfer: 1.00,
    halting_problem_mapping: 1.00,
    arbitrary_problem_decidability: problem_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        total_halting_requirement,
        correct_yes_no_classification,
        decidable_recognisable_distinction,
        complement_decidability,
        recognisable_corecognisable_equivalence,
        reduction_direction,
        halting_problem_undecidability
    },
    extensible_layers: {
        decidable_sets,
        semi_decidable_sets,
        co_recognisable_languages,
        mapping_reducibility,
        Turing_reducibility,
        Rice_theorem,
        Post_correspondence_problem,
        logical_decision_problems,
        automated_decidability_analysis
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + DECIDABILITY_MODEL
    + DECIDER_MODEL
    + RECOGNISER_MODEL
    + CHARACTERISTIC_FUNCTION_MODEL
    + CRITICAL_DISTINCTIONS
    + DECIDABILITY_ANALYSIS_PIPELINE
    + RECOGNISABILITY_PIPELINE
    + UNDECIDABILITY_PIPELINE
    + DECISION_GRAPH
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: DecidabilityOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/computability-theory/decidability-ontology.html",
    parent_domain: ComputabilityTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: Decidability,
    decidability_analysis_enabled: TRUE,
    recognisability_reasoning_enabled: TRUE,
    complement_reasoning_enabled: TRUE,
    reduction_reasoning_enabled: TRUE,
    undecidability_reasoning_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    database_safe_unicode: TRUE,
    flow_complete: TRUE
}

END_FLOW