Compactness Ontology

KIRETH RESEARCH - SEMANTIC LIBRARY
AI CORE -> ONTOLOGIES -> MATHEMATICAL ONTOLOGIES -> MATHEMATICAL LOGIC ONTOLOGIES
MODEL THEORY -> COMPACTNESS ONTOLOGY

Canonical URL:
https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/model-theory/compactness-ontology-2.html

FLOW_ALGEBRA CompactnessOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN CompactnessOntology := {
    Compactness,
    CompactnessTheorem,
    ModelTheory,
    MathematicalLogic,
    FirstOrderLogic,
    FormalLanguage,
    Theory,
    Sentence,
    Formula,
    FiniteSubset,
    Model,
    Structure,
    Interpretation,
    Satisfaction,
    Satisfiability,
    Unsatisfiability,
    SemanticConsequence,
    FiniteSatisfiability,
    Completeness,
    Consistency,
    Proof,
    Derivation,
    ModelExistence,
    InfiniteModel,
    NonstandardModel,
    ElementaryClass
}

DEFINE ENTITY_TYPES := {
    COMPACTNESS_PROPERTY,
    META_THEOREM,
    FORMAL_LANGUAGE,
    THEORY,
    SENTENCE,
    FORMULA,
    FINITE_SUBTHEORY,
    MODEL,
    STRUCTURE,
    SEMANTIC_RELATION,
    PROOF_OBJECT,
    META_PROPERTY,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    HAS_FINITE_SUBSET,
    SATISFIES,
    IS_MODEL_OF,
    HAS_MODEL,
    IS_SATISFIABLE,
    ENTAILS,
    DERIVES,
    IMPLIES,
    DEPENDS_ON,
    WITNESSES,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF
}

SET Compactness.type = COMPACTNESS_PROPERTY
SET Compactness.context = ModelTheory
SET Compactness.role =
    "express that a first-order theory has a model whenever every finite subset of that theory has a model"

RULE finite_satisfiability:
    Theory(T)
    AND FOR_EVERY finite T0 SUBSET_OF T [
        THERE_EXISTS Model(M0) [
            IS_MODEL_OF(M0,T0)
        ]
    ]
    -> FinitelySatisfiable(T)

RULE compactness_theorem:
    FirstOrderTheory(T)
    AND FinitelySatisfiable(T)
    -> THERE_EXISTS Model(M) [
        IS_MODEL_OF(M,T)
    ]
    -> Satisfiable(T)

RULE contrapositive_unsatisfiability:
    FirstOrderTheory(T)
    AND Unsatisfiable(T)
    -> THERE_EXISTS finite T0 SUBSET_OF T [
        Unsatisfiable(T0)
    ]

RULE semantic_consequence_finite_witness:
    FirstOrderTheory(T)
    AND Sentence(phi)
    AND ENTAILS(T,phi)
    -> THERE_EXISTS finite T0 SUBSET_OF T [
        ENTAILS(T0,phi)
    ]

RULE consequence_via_unsatisfiability:
    ENTAILS(T,phi)
    IFF
    Unsatisfiable(T UNION {NOT(phi)})

RULE compactness_consequence_derivation:
    ENTAILS(T,phi)
    -> Unsatisfiable(T UNION {NOT(phi)})
    -> THERE_EXISTS finite Delta SUBSET_OF (T UNION {NOT(phi)}) [
        Unsatisfiable(Delta)
    ]
    -> THERE_EXISTS finite T0 SUBSET_OF T [
        ENTAILS(T0,phi)
    ]

RULE finite_model_nonuniformity:
    FinitelySatisfiable(T)
    -> DO_NOT_REQUIRE same_model_for_every_finite_subset

RULE compactness_model_unification:
    FOR_EVERY finite T0 SUBSET_OF T [
        EXISTS some_model M_T0 satisfying T0
    ]
    -> Compactness guarantees existence_of_model_for_entire_T
       WHEN first_order_conditions_hold

RULE infinite_model_application:
    Theory(T)
    AND FOR_EVERY natural_number n [
        T UNION {AtLeastNElements(n)} is finitely satisfiable
    ]
    -> T has_infinite_model

RULE nonstandard_model_application:
    FirstOrderTheory(T)
    AND add_constant_c
    AND add_sentences {
        c greater_than numeral_n
        FOR every standard natural_number n
    }
    AND every_finite_subset_satisfiable
    -> compactness_produces_model_with_nonstandard_element
       WHEN language_and_theory_conditions_support_construction

DEFINE COMPACTNESS_MODEL := {
    canonical_form:
        "if every finite subset T0 of T is satisfiable, then T is satisfiable",
    contrapositive_form:
        "if T is unsatisfiable, some finite subset of T is unsatisfiable",
    domain:
        "classical first-order logic under standard semantics"
}

DEFINE FINITE_CONSEQUENCE_MODEL := {
    statement:
        "if T semantically entails phi, then some finite subset T0 of T semantically entails phi",
    basis:
        CompactnessTheorem
}

DEFINE FINITE_SATISFIABILITY_MODEL := {
    theory: T,
    condition:
        "every finite subset of T has at least one model",
    important_note:
        "different finite subsets may be satisfied by different models"
}

DEFINE COMPLETENESS_CONNECTION := {
    proof_theoretic_route:
        "compactness can be derived from a sound and complete finitary first-order proof system",
    semantic_route:
        "compactness may also be established by other model-theoretic methods",
    distinction:
        "compactness and completeness are related but are different metatheoretic properties"
}

DEFINE CRITICAL_DISTINCTIONS := {
    compactness_vs_finiteness: {
        compactness:
            "a local-to-global satisfiability property",
        finiteness:
            "a cardinality property",
        equivalence: FALSE
    },
    compactness_vs_topological_compactness: {
        model_theoretic_compactness:
            "finite satisfiability implies global satisfiability",
        topological_compactness:
            "every open cover has a finite subcover under a standard definition",
        equivalence: FALSE_BY_DEFAULT
    },
    finite_subtheory_models_vs_global_model: {
        finite_stage:
            "each finite subset may have its own model",
        global_stage:
            "compactness establishes one model satisfying all sentences simultaneously"
    },
    compactness_vs_completeness: {
        compactness:
            "finite satisfiability to satisfiability",
        completeness:
            "semantic consequence to syntactic derivability"
    }
}

DEFINE EXAMPLE_1 := {
    theory:
        "T = {there are at least n distinct objects | n is a positive integer}",
    finite_subset:
        "mentions only finitely many lower-bound requirements",
    finite_model:
        "choose a sufficiently large finite domain",
    compactness_result:
        "T has a model",
    consequence:
        "that model must be infinite"
}

DEFINE EXAMPLE_2 := {
    assumption:
        "T ENTAILS phi",
    transformed_theory:
        "T UNION {NOT(phi)}",
    property:
        "unsatisfiable",
    compactness_result:
        "some finite T0 SUBSET_OF T already entails phi"
}

DEFINE EXAMPLE_3 := {
    theory:
        "a first-order theory extended by infinitely many constraints on a new constant",
    condition:
        "every finite subset can be satisfied",
    conclusion:
        "the whole extended theory has a model"
}

DEFINE COMPACTNESS_CHECK_PIPELINE :=
    Theory(T)
    -> IdentifyLogicAndSemantics
    -> ConfirmFirstOrderCompactnessApplies
    -> GenerateFiniteSubsetCondition
    -> VerifyOrAssumeEveryFiniteSubsetSatisfiable
    -> ApplyCompactnessTheorem
    -> InferGlobalSatisfiability
    -> RecordModelExistence

DEFINE UNSATISFIABILITY_PIPELINE :=
    Theory(T)
    -> EstablishUnsatisfiability
    -> ApplyContrapositiveCompactness
    -> SearchForFiniteUnsatisfiableSubset
    -> ReturnFiniteUnsatisfiableCore
    -> PreserveProofOrModelEvidence

DEFINE FINITE_CONSEQUENCE_PIPELINE :=
    Theory(T)
    -> Sentence(phi)
    -> EstablishSemanticEntailment
    -> Form T UNION {NOT(phi)}
    -> EstablishUnsatisfiability
    -> ApplyFiniteUnsatisfiableSubsetResult
    -> ExtractFiniteT0
    -> Conclude ENTAILS(T0,phi)

DEFINE MODEL_CONSTRUCTION_REASONING_PIPELINE :=
    InfiniteConstraintSet
    -> AnalyseFiniteSubsets
    -> ConstructFiniteStageModels
    -> VerifyEveryFiniteStageSatisfiable
    -> InvokeCompactness
    -> InferGlobalModel
    -> AnalysePropertiesForcedByAllConstraints

DEFINE COMPACTNESS_GRAPH := {
    nodes: {
        TheoryNode,
        FiniteSubsetNode,
        ModelNode,
        SatisfiabilityNode,
        CompactnessNode
    },
    edges: {
        HAS_FINITE_SUBSET,
        IS_MODEL_OF,
        IS_SATISFIABLE,
        IMPLIES
    },
    local_to_global_bridge:
        "all finite subsets satisfiable -> whole theory satisfiable"
}

DEFINE ONTOLOGY_RELATIONS := {
    Compactness IS_COMPONENT_OF ModelTheory,
    CompactnessTheorem IS_META_THEOREM_OF FirstOrderLogic,
    Theory HAS_FINITE_SUBSET FiniteSubset,
    FiniteSatisfiability DEPENDS_ON ModelsOfFiniteSubsets,
    Compactness CONNECTS FiniteSatisfiability TO Satisfiability,
    Unsatisfiability HAS_FINITE_WITNESS UNDER Compactness,
    SemanticConsequence HAS_FINITE_SUBTHEORY_WITNESS UNDER Compactness,
    InfiniteModel MAY_BE_ESTABLISHED_BY Compactness,
    NonstandardModel MAY_BE_CONSTRUCTED_USING Compactness,
    Compactness IS_RELATED_TO Completeness
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "compactness" <=> Compactness WHEN model_theory_context=TRUE,
    "compactness theorem" <=> CompactnessTheorem,
    "first-order compactness theorem" <=> CompactnessTheorem,
    "finitely satisfiable" <=> FiniteSatisfiability,
    "every finite subset has a model" <=> FiniteSatisfiability,
    "finite unsatisfiable subset" <=> FiniteUnsatisfiableCore WHEN contradiction_context=TRUE
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation of the first-order compactness theorem and its local-to-global reasoning pattern",
    preserve_theory_identity: TRUE,
    preserve_logic_identity: TRUE,
    preserve_finite_subset_identity: TRUE,
    distinguish_finite_satisfiability_from_global_satisfiability: TRUE,
    do_not_require_shared_model_for_finite_subsets: TRUE,
    apply_compactness_only_when_logical_framework_supports_it: TRUE,
    support_contrapositive_unsatisfiability_reasoning: TRUE,
    support_finite_consequence_extraction: TRUE,
    support_infinite_model_arguments: TRUE,
    support_nonstandard_model_arguments: TRUE,
    distinguish_model_theoretic_from_topological_compactness: TRUE,
    reasoning_mode: "symbolic + semantic + local-to-global + meta-logical"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    compactness_statement_mapping: 1.00,
    finite_satisfiability_mapping: 0.99,
    contrapositive_mapping: 0.99,
    finite_consequence_mapping: 0.99,
    infinite_model_application: 0.99,
    nonstandard_model_application: context_dependent,
    arbitrary_logic_compactness: logical_system_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        finite_subset_satisfiability,
        global_satisfiability,
        contrapositive_finite_unsatisfiability,
        first_order_scope,
        local_to_global_model_existence
    },
    extensible_layers: {
        compactness_via_completeness,
        ultraproduct_proofs,
        nonstandard_models,
        infinite_model_constructions,
        finite_consequence_property,
        compactness_failures_in_stronger_logics,
        computational_unsatisfiable_cores
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + COMPACTNESS_MODEL
    + FINITE_CONSEQUENCE_MODEL
    + FINITE_SATISFIABILITY_MODEL
    + COMPLETENESS_CONNECTION
    + CRITICAL_DISTINCTIONS
    + COMPACTNESS_CHECK_PIPELINE
    + UNSATISFIABILITY_PIPELINE
    + FINITE_CONSEQUENCE_PIPELINE
    + MODEL_CONSTRUCTION_REASONING_PIPELINE
    + COMPACTNESS_GRAPH
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: CompactnessOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/model-theory/compactness-ontology-2.html",
    parent_domain: ModelTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: Compactness,
    finite_satisfiability_reasoning_enabled: TRUE,
    local_to_global_reasoning_enabled: TRUE,
    finite_unsatisfiable_core_reasoning_enabled: TRUE,
    infinite_model_reasoning_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    database_safe_unicode: TRUE,
    flow_complete: TRUE
}

END_FLOW