Recursive Enumeration Ontology

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

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

FLOW_ALGEBRA RecursiveEnumerationOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN RecursiveEnumerationOntology := {
    RecursiveEnumeration,
    ComputabilityTheory,
    RecursivelyEnumerableSet,
    RecursivelyEnumerableLanguage,
    RecognisableSet,
    RecognisableLanguage,
    ComputablyEnumerableSet,
    EnumerableSet,
    Enumeration,
    Enumerator,
    EffectiveEnumeration,
    TuringMachine,
    Recogniser,
    Decider,
    ComputableFunction,
    PartialComputableFunction,
    DomainOfPartialFunction,
    RangeOfComputableFunction,
    NaturalNumbers,
    Encoding,
    Language,
    Set,
    Membership,
    Acceptance,
    Rejection,
    Halting,
    Divergence,
    Decidability,
    SemiDecidability,
    Complement
}

DEFINE ENTITY_TYPES := {
    RECURSIVE_ENUMERATION,
    ENUMERABLE_SET,
    ENUMERABLE_LANGUAGE,
    ENUMERATOR,
    RECOGNISER,
    DECIDER,
    MACHINE,
    COMPUTABLE_FUNCTION,
    PARTIAL_FUNCTION,
    SET,
    LANGUAGE,
    ENCODING,
    COMPUTABILITY_PROPERTY,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    ENUMERATES,
    RECOGNISES,
    DECIDES,
    ACCEPTS,
    REJECTS,
    HALTS_ON,
    DIVERGES_ON,
    HAS_DOMAIN,
    HAS_RANGE,
    OUTPUTS,
    ENCODES,
    MEMBER_OF,
    IS_COMPLEMENT_OF,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF,
    DEPENDS_ON
}

SET RecursiveEnumeration.type = RECURSIVE_ENUMERATION
SET RecursiveEnumeration.context = ComputabilityTheory
SET RecursiveEnumeration.role =
    "represent sets and languages whose members can be generated or recognised by an effective computational process"

RULE enumerator_definition:
    Algorithm(E)
    AND OutputStream(E)
    -> Enumerator(E)

RULE enumeration_of_set:
    Enumerator(E)
    AND Set(A)
    AND FOR_EVERY x [
        x MEMBER_OF A
        IFF
        E eventually_outputs x
    ]
    -> ENUMERATES(E,A)

RULE recursively_enumerable_set:
    Set(A)
    AND EXISTS Enumerator(E) [
        ENUMERATES(E,A)
    ]
    -> RecursivelyEnumerableSet(A)

RULE recognisable_set:
    Set(A)
    AND EXISTS TuringMachine(M) [
        FOR_EVERY x [
            x MEMBER_OF A
            -> ACCEPTS(M,x)
        ]
        AND FOR_EVERY x [
            x NOT_MEMBER_OF A
            -> M may_reject_or_diverge
        ]
    ]
    -> RecognisableSet(A)

RULE enumeration_recognition_equivalence:
    RecursivelyEnumerableSet(A)
    IFF
    RecognisableSet(A)
       UNDER standard_effective_encodings

RULE language_equivalence:
    RecursivelyEnumerableLanguage(L)
    IFF
    RecognisableLanguage(L)

RULE partial_function_domain:
    PartialComputableFunction(f)
    -> Domain(f)
       is RecursivelyEnumerableSet

RULE r_e_set_as_partial_domain:
    RecursivelyEnumerableSet(A)
    -> EXISTS PartialComputableFunction(f) [
        Domain(f)=A
    ]

RULE computable_range:
    TotalComputableFunction(f)
    -> Range(f)
       is RecursivelyEnumerableSet

RULE nonempty_re_set_range:
    RecursivelyEnumerableSet(A)
    AND A != EMPTY
    -> EXISTS TotalComputableFunction(f:NaturalNumbers->Universe) [
        Range(f)=A
    ]
       allowing_repetitions

RULE decidable_implies_re:
    DecidableSet(A)
    -> RecursivelyEnumerableSet(A)

RULE decidable_complement_characterisation:
    RecursivelyEnumerableSet(A)
    AND RecursivelyEnumerableSet(Complement(A))
    -> DecidableSet(A)

RULE enumeration_repetition:
    Enumerator(E)
    -> outputs MAY_CONTAIN duplicates

RULE enumeration_order:
    Enumerator(E)
    -> output_order NEED_NOT_MATCH
       numeric_or_lexical_order

RULE infinite_wait_guard:
    x not_yet_output_by E after finite_time
    -> DO_NOT_INFER x NOT_MEMBER_OF enumerated_set

RULE recognition_wait_guard:
    Recogniser(M)
    AND M has_not_accepted x after finite_time
    -> DO_NOT_INFER x NOT_MEMBER_OF recognised_set

DEFINE ENUMERATION_MODEL := {
    enumerator:
        "effective procedure producing a sequence of encoded objects",
    set_enumerated:
        "exactly the objects eventually appearing in the output",
    duplicates:
        "permitted unless a stronger enumeration convention is specified",
    order:
        "arbitrary unless otherwise constrained"
}

DEFINE RECOGNITION_MODEL := {
    positive_instance:
        "recogniser eventually halts and accepts",
    negative_instance:
        "recogniser may reject or run forever",
    equivalence:
        "recognisable sets coincide with recursively enumerable sets under standard computability definitions"
}

DEFINE PARTIAL_FUNCTION_MODEL := {
    set_A:
        "domain of a partial computable function",
    membership_witness:
        "x belongs to A when the corresponding partial computation halts",
    nonmembership:
        "computation may diverge"
}

DEFINE TERMINOLOGY_MODEL := {
    recursively_enumerable:
        RecursivelyEnumerableSet,
    computably_enumerable:
        ComputablyEnumerableSet,
    Turing_recognisable:
        RecognisableSet,
    historical_abbreviation:
        "r.e.",
    modern_abbreviation:
        "c.e."
}

DEFINE CRITICAL_DISTINCTIONS := {
    recursively_enumerable_vs_decidable: {
        recursively_enumerable:
            "membership can be positively recognised or members can be effectively listed",
        decidable:
            "membership and nonmembership are both determined in finite time"
    },
    enumeration_vs_decision: {
        enumeration:
            "generates members",
        decision:
            "takes an arbitrary candidate and returns yes or no"
    },
    not_yet_enumerated_vs_nonmember: {
        not_yet_enumerated:
            "finite observation state",
        nonmember:
            "semantic membership claim",
        equivalence: FALSE
    },
    enumerable_vs_finite: {
        enumerable:
            "may be finite or infinite",
        finite:
            "contains finitely many elements",
        equivalence: FALSE
    }
}

DEFINE EXAMPLE_1 := {
    set:
        "even natural numbers",
    enumerator:
        "output 0,2,4,6,...",
    classification:
        RecursivelyEnumerableSet,
    decidable:
        TRUE
}

DEFINE EXAMPLE_2 := {
    set:
        "encodings of Turing machines that halt on their encoded input",
    recognisable:
        TRUE,
    recursively_enumerable:
        TRUE,
    decidable:
        FALSE
}

DEFINE EXAMPLE_3 := {
    partial_function:
        "simulate machine M on input w and return 1 if it halts",
    domain:
        "halting instances",
    domain_classification:
        RecursivelyEnumerableSet
}

DEFINE ENUMERATION_PIPELINE :=
    SetOrLanguage(A)
    -> ChooseEffectiveEncoding
    -> ConstructEnumerator(E)
    -> GenerateCandidateOutputs
    -> VerifyEveryOutputBelongsToA
    -> VerifyEveryMemberEventuallyAppears
    -> AllowDuplicatesUnlessRestricted
    -> ConcludeRecursivelyEnumerable(A)

DEFINE RECOGNISER_TO_ENUMERATOR_PIPELINE :=
    Recogniser(M)
    -> EnumeratePossibleInputs
    -> DovetailSimulationsOfM
    -> WheneverSimulationAccepts(x)
       -> Output(x)
    -> ContinueIndefinitely
    -> ConstructEnumeratorForRecognisedSet

DEFINE ENUMERATOR_TO_RECOGNISER_PIPELINE :=
    Enumerator(E)
    -> Input(x)
    -> SimulateEnumeration
    -> CompareEachOutputWithx
    -> IF x appears
       THEN Accept
    -> ELSE Continue
    -> ConstructRecogniserForEnumeratedSet

DEFINE DECIDABILITY_PIPELINE :=
    RecursivelyEnumerableSet(A)
    -> AnalyseComplement(A)
    -> IF Complement(A) recursively_enumerable
       THEN DovetailRecognisersForAAndComplement
       -> OneMustEventuallyAccept
       -> ConstructDecider
    -> ReturnDecidabilityStatus

DEFINE ENUMERATION_GRAPH := {
    node_types: {
        EnumeratorNode,
        SetNode,
        LanguageNode,
        RecogniserNode,
        FunctionNode,
        OutputNode,
        EncodingNode
    },
    edge_types: {
        ENUMERATES,
        RECOGNISES,
        OUTPUTS,
        HAS_DOMAIN,
        HAS_RANGE,
        ENCODES
    },
    potentially_infinite_process: TRUE
}

DEFINE ONTOLOGY_RELATIONS := {
    RecursiveEnumeration IS_COMPONENT_OF ComputabilityTheory,
    RecursivelyEnumerableSet IS_EQUIVALENT_TO RecognisableSet,
    RecursivelyEnumerableLanguage IS_EQUIVALENT_TO RecognisableLanguage,
    Enumerator ENUMERATES RecursivelyEnumerableSet,
    Recogniser RECOGNISES RecursivelyEnumerableSet,
    PartialComputableFunction HAS_RECURSIVELY_ENUMERABLE Domain,
    TotalComputableFunction HAS_RECURSIVELY_ENUMERABLE Range,
    DecidableSet IS_SUBTYPE_OF RecursivelyEnumerableSet,
    ComplementTogetherWithRecursiveEnumeration CHARACTERISES Decidability
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "recursive enumeration" <=> RecursiveEnumeration,
    "recursively enumerable" <=> RecursivelyEnumerableSet,
    "computably enumerable" <=> RecursivelyEnumerableSet,
    "c.e. set" <=> RecursivelyEnumerableSet,
    "r.e. set" <=> RecursivelyEnumerableSet,
    "Turing-recognisable" <=> RecognisableSet,
    "effectively enumerable" <=> RecursivelyEnumerableSet,
    "enumerator" <=> Enumerator
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation of recursive enumeration, recognisability and effective listing",
    preserve_set_identity: TRUE,
    preserve_encoding: TRUE,
    preserve_enumerator_identity: TRUE,
    preserve_recogniser_identity: TRUE,
    distinguish_enumeration_from_decision: TRUE,
    distinguish_recognisable_from_decidable: TRUE,
    allow_duplicate_outputs: TRUE,
    allow_arbitrary_output_order: TRUE,
    prohibit_nonmembership_inference_from_finite_wait: TRUE,
    support_dovetailing: TRUE,
    support_recogniser_enumerator_conversion: TRUE,
    support_partial_function_domain_reasoning: TRUE,
    support_complement_decidability_reasoning: TRUE,
    reasoning_mode: "symbolic + enumerable + simulation-based + computability-aware"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    enumeration_definition: 1.00,
    recognisable_equivalence: 1.00,
    partial_domain_mapping: 0.99,
    computable_range_mapping: 0.99,
    complement_decidability_characterisation: 1.00,
    dovetailing_conversion: 0.99,
    arbitrary_nonmembership_detection: not_guaranteed
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        effective_enumeration,
        recognisable_equivalence,
        positive_membership_confirmation,
        possible_negative_divergence,
        partial_computable_domain,
        complement_decidability_characterisation
    },
    extensible_layers: {
        computably_enumerable_sets,
        enumeration_operators,
        creative_sets,
        productive_sets,
        simple_sets,
        recursively_inseparable_sets,
        enumeration_reducibility,
        arithmetic_hierarchy
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + ENUMERATION_MODEL
    + RECOGNITION_MODEL
    + PARTIAL_FUNCTION_MODEL
    + TERMINOLOGY_MODEL
    + CRITICAL_DISTINCTIONS
    + ENUMERATION_PIPELINE
    + RECOGNISER_TO_ENUMERATOR_PIPELINE
    + ENUMERATOR_TO_RECOGNISER_PIPELINE
    + DECIDABILITY_PIPELINE
    + ENUMERATION_GRAPH
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: RecursiveEnumerationOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/computability-theory/recursive-enumeration-ontology.html",
    parent_domain: ComputabilityTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: RecursiveEnumeration,
    enumeration_reasoning_enabled: TRUE,
    recognisability_reasoning_enabled: TRUE,
    dovetailing_reasoning_enabled: TRUE,
    complement_decidability_reasoning_enabled: TRUE,
    partial_function_domain_reasoning_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    database_safe_unicode: TRUE,
    flow_complete: TRUE
}

END_FLOW