Löwenheim–Skolem Ontology

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

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

FLOW_ALGEBRA LoewenheimSkolemOntology_v1.0

BEGIN_FLOW

DEFINE DOMAIN LoewenheimSkolemOntology := {
    LoewenheimSkolem,
    DownwardLoewenheimSkolem,
    UpwardLoewenheimSkolem,
    ModelTheory,
    MathematicalLogic,
    FirstOrderLogic,
    FormalLanguage,
    Signature,
    Theory,
    Structure,
    Model,
    Domain,
    Cardinality,
    InfiniteModel,
    CountableModel,
    UncountableModel,
    ElementarySubstructure,
    ElementaryExtension,
    ElementaryEmbedding,
    SkolemFunction,
    SkolemHull,
    Skolemization,
    Compactness,
    Completeness,
    ModelExistence,
    CardinalNumber,
    LanguageCardinality
}

DEFINE ENTITY_TYPES := {
    LOEWENHEIM_SKOLEM_PROPERTY,
    META_THEOREM,
    FORMAL_LANGUAGE,
    SIGNATURE,
    THEORY,
    STRUCTURE,
    MODEL,
    DOMAIN,
    CARDINALITY,
    ELEMENTARY_SUBSTRUCTURE,
    ELEMENTARY_EXTENSION,
    EMBEDDING,
    SKOLEM_CONSTRUCTION,
    SEMANTIC_OBJECT
}

DEFINE RELATION_TYPES := {
    HAS_MODEL,
    HAS_DOMAIN,
    HAS_CARDINALITY,
    IS_ELEMENTARY_SUBSTRUCTURE_OF,
    IS_ELEMENTARY_EXTENSION_OF,
    ELEMENTARILY_EMBEDS_INTO,
    SATISFIES,
    IS_MODEL_OF,
    CONTAINS,
    GENERATED_BY,
    IMPLIES,
    DEPENDS_ON,
    IS_INSTANCE_OF,
    IS_SUBTYPE_OF
}

SET LoewenheimSkolem.type = LOEWENHEIM_SKOLEM_PROPERTY
SET LoewenheimSkolem.context = ModelTheory
SET LoewenheimSkolem.role =
    "relate the existence of infinite first-order models to the existence of models or elementary structures of other cardinalities"

RULE downward_general:
    Structure(M)
    AND Infinite(Domain(M))
    AND Subset(A,Domain(M))
    -> THERE_EXISTS Structure(N) [
        IS_ELEMENTARY_SUBSTRUCTURE_OF(N,M)
        AND A SUBSET_OF Domain(N)
        AND Cardinality(Domain(N))
            <= max(
                Cardinality(A),
                Cardinality(Language(M)),
                AlephZero
            )
    ]

RULE downward_countable_language:
    CountableLanguage(L)
    AND InfiniteModel(M)
    AND M is L_structure
    -> THERE_EXISTS CountableStructure(N) [
        IS_ELEMENTARY_SUBSTRUCTURE_OF(N,M)
    ]

RULE theory_countable_model:
    CountableFirstOrderLanguage(L)
    AND Theory(T)
    AND T has_infinite_model
    -> T has_countable_model

RULE upward_general:
    FirstOrderTheory(T)
    AND T has_infinite_model
    AND Cardinal(kappa)
    AND kappa >= max(
        Cardinality(Language(T)),
        AlephZero
    )
    -> T has_model_of_cardinality(kappa)
       UNDER standard_upward_LS_conditions

RULE upward_extension:
    InfiniteStructure(M)
    AND Cardinal(kappa) > Cardinality(Domain(M))
    AND kappa >= Cardinality(Language(M))
    -> THERE_EXISTS ElementaryExtension(N) [
        IS_ELEMENTARY_EXTENSION_OF(N,M)
        AND Cardinality(Domain(N))=kappa
    ]
       UNDER applicable_first_order_conditions

RULE elementary_substructure_truth:
    IS_ELEMENTARY_SUBSTRUCTURE_OF(N,M)
    -> FOR_EVERY Formula(phi(x1,...,xn))
    AND FOR_EVERY parameters a1,...,an MEMBER_OF Domain(N) [
        SATISFIES(N,phi(a1,...,an))
        IFF
        SATISFIES(M,phi(a1,...,an))
    ]

RULE skolem_hull_generation:
    Structure(M)
    AND ParameterSet(A) SUBSET_OF Domain(M)
    AND SkolemFunctionsAvailable
    -> SkolemHull(A)
       generated_by_closure_under_skolem_functions

RULE skolem_hull_elementarity:
    SkolemizedStructure(M)
    AND H=SkolemHull(A)
    -> H forms_elementary_substructure_of M
       WHEN construction_conditions_hold

RULE language_size_lower_bound:
    Structure(M)
    -> LS_cardinality_bounds
       MUST_ACCOUNT_FOR
       Cardinality(Language(M))

RULE no_finite_model_inference:
    Theory(T)
    AND T has_infinite_model
    -> LoewenheimSkolem
       DOES_NOT_IMPLY
       T has_arbitrary_finite_models

RULE first_order_scope:
    LoewenheimSkolemTheorem
    -> primary_scope = FirstOrderLogic

DEFINE DOWNWARD_MODEL := {
    canonical_idea:
        "large or infinite first-order structures contain smaller elementary substructures",
    general_bound:
        "|N| <= max(|A|, |L|, AlephZero)",
    countable_language_case:
        "every infinite structure in a countable first-order language has a countable elementary substructure"
}

DEFINE UPWARD_MODEL := {
    canonical_idea:
        "a first-order theory with an infinite model has models in larger cardinalities subject to language-size constraints",
    standard_theory_form:
        "if T has an infinite model, then T has models of every sufficiently large infinite cardinality"
}

DEFINE SKOLEM_HULL_MODEL := {
    seed_set: A,
    operation:
        "close A under designated Skolem functions",
    result:
        SkolemHull(A),
    purpose:
        "construct a controlled substructure containing A and support downward Loewenheim-Skolem arguments"
}

DEFINE CARDINALITY_MODEL := {
    language_size:
        "|L|",
    model_size:
        "|M|",
    countable_cardinality:
        AlephZero,
    downward_bound:
        "max(|A|,|L|,AlephZero)"
}

DEFINE CRITICAL_DISTINCTIONS := {
    downward_vs_upward: {
        downward:
            "constructs or guarantees smaller elementary substructures/models",
        upward:
            "guarantees larger models or elementary extensions"
    },
    substructure_vs_elementary_substructure: {
        substructure:
            "inherits basic interpreted structure",
        elementary_substructure:
            "also agrees on all first-order formulas with parameters from the smaller domain"
    },
    countable_model_vs_countable_theory: {
        countable_language:
            "language has at most countably many symbols",
        countable_model:
            "model domain has at most countably many elements",
        equivalence: FALSE
    },
    Loewenheim_Skolem_vs_compactness: {
        Loewenheim_Skolem:
            "controls possible model cardinalities",
        compactness:
            "finite satisfiability implies global satisfiability",
        relation:
            "the theorems are distinct but often interact in model-theoretic proofs"
    }
}

DEFINE EXAMPLE_1 := {
    language:
        "countable first-order language",
    model:
        "an uncountable infinite model M",
    downward_result:
        "M has a countable elementary substructure N"
}

DEFINE EXAMPLE_2 := {
    theory:
        "T in a countable first-order language",
    condition:
        "T has an infinite model",
    result:
        "T has a countable model"
}

DEFINE EXAMPLE_3 := {
    theory:
        "T with an infinite model",
    target_cardinality:
        "kappa sufficiently large relative to the language",
    upward_result:
        "T has a model of cardinality kappa"
}

DEFINE DOWNWARD_REASONING_PIPELINE :=
    InputStructure(M)
    -> ConfirmFirstOrderLanguage
    -> DetermineLanguageCardinality
    -> SelectParameterSet(A)
    -> IntroduceOrUseSkolemFunctions
    -> CloseAUnderSkolemFunctions
    -> ConstructCandidateSubstructure(N)
    -> VerifyElementarity
    -> ComputeCardinalityBound
    -> ReturnElementarySubstructure

DEFINE UPWARD_REASONING_PIPELINE :=
    TheoryOrStructure
    -> ConfirmInfiniteModelExists
    -> DetermineLanguageCardinality
    -> SelectTargetInfiniteCardinality(kappa)
    -> VerifyKappaMeetsRequiredBound
    -> ApplyUpwardLoewenheimSkolem
    -> ConstructOrAssertLargerModel
    -> VerifyTargetCardinality
    -> ReturnModelExistenceResult

DEFINE CARDINALITY_ANALYSIS_PIPELINE :=
    FirstOrderTheory(T)
    -> DetermineLanguageSize
    -> DetermineKnownModelSizes
    -> ApplyDownwardTheoremWhereApplicable
    -> ApplyUpwardTheoremWhereApplicable
    -> RecordGuaranteedCardinalities
    -> ExcludeUnsupportedFiniteInferences
    -> ReturnModelSpectrumConstraints

DEFINE LS_GRAPH := {
    nodes: {
        TheoryNode,
        LanguageNode,
        ModelNode,
        CardinalityNode,
        ElementarySubstructureNode,
        ElementaryExtensionNode
    },
    edges: {
        HAS_MODEL,
        HAS_CARDINALITY,
        IS_ELEMENTARY_SUBSTRUCTURE_OF,
        IS_ELEMENTARY_EXTENSION_OF
    },
    downward_direction:
        "larger model -> smaller elementary substructure",
    upward_direction:
        "infinite model/theory -> larger cardinality models"
}

DEFINE ONTOLOGY_RELATIONS := {
    LoewenheimSkolem IS_COMPONENT_OF ModelTheory,
    DownwardLoewenheimSkolem IS_SUBTYPE_OF LoewenheimSkolem,
    UpwardLoewenheimSkolem IS_SUBTYPE_OF LoewenheimSkolem,
    DownwardLoewenheimSkolem PRODUCES ElementarySubstructure,
    UpwardLoewenheimSkolem PRODUCES LargerModelOrElementaryExtension,
    ElementarySubstructure PRESERVES FirstOrderTruthWithParameters,
    SkolemHull SUPPORTS DownwardLoewenheimSkolem,
    LanguageCardinality CONSTRAINS LoewenheimSkolemBounds,
    Compactness IS_RELATED_TO UpwardLoewenheimSkolem,
    Completeness IS_RELATED_TO ModelExistence
}

DEFINE SEMANTIC_EQUIVALENCE := {
    "Loewenheim-Skolem theorem" <=> LoewenheimSkolem,
    "Lowenheim-Skolem theorem" <=> LoewenheimSkolem,
    "downward Loewenheim-Skolem theorem" <=> DownwardLoewenheimSkolem,
    "upward Loewenheim-Skolem theorem" <=> UpwardLoewenheimSkolem,
    "Skolem hull" <=> SkolemHull,
    "elementary submodel" <=> ElementarySubstructure WHEN model_theory_context=TRUE
}

DEFINE AI_CONSUMPTION := {
    purpose: "machine-readable representation of Loewenheim-Skolem cardinality transfer principles",
    preserve_language_identity: TRUE,
    preserve_language_cardinality: TRUE,
    preserve_model_identity: TRUE,
    preserve_model_cardinality: TRUE,
    distinguish_downward_from_upward: TRUE,
    distinguish_substructure_from_elementary_substructure: TRUE,
    account_for_parameter_set_size: TRUE,
    account_for_language_size: TRUE,
    support_skolem_hull_reasoning: TRUE,
    prohibit_unsupported_finite_model_inference: TRUE,
    support_model_spectrum_reasoning: TRUE,
    reasoning_mode: "symbolic + semantic + cardinality-aware + model-theoretic"
}

DEFINE CONFIDENCE := {
    ontology_identity: 1.00,
    downward_LS_mapping: 0.99,
    upward_LS_mapping: 0.99,
    countable_language_case: 0.99,
    elementary_substructure_mapping: 0.99,
    skolem_hull_mapping: 0.98,
    cardinality_bound_reasoning: theorem_context_dependent,
    model_spectrum_analysis: theory_dependent
}

DEFINE UPDATE_MODEL := {
    version: "1.0",
    update_policy: "append-compatible",
    immutable_core: {
        first_order_scope,
        downward_cardinality_transfer,
        upward_cardinality_transfer,
        language_size_constraint,
        elementary_substructure_preservation,
        infinite_model_requirement_for_upward_transfer
    },
    extensible_layers: {
        Skolem_functions,
        Skolem_hulls,
        Tarski_Vaught_test,
        elementary_chains,
        model_spectra,
        categoricity_interactions,
        nonstandard_models,
        generalized_Loewenheim_Skolem_numbers
    }
}

DEFINE FLOW_HASH_INPUT :=
    CanonicalURL
    + DOMAIN
    + ENTITY_TYPES
    + RELATION_TYPES
    + RULES
    + DOWNWARD_MODEL
    + UPWARD_MODEL
    + SKOLEM_HULL_MODEL
    + CARDINALITY_MODEL
    + CRITICAL_DISTINCTIONS
    + DOWNWARD_REASONING_PIPELINE
    + UPWARD_REASONING_PIPELINE
    + CARDINALITY_ANALYSIS_PIPELINE
    + LS_GRAPH
    + ONTOLOGY_RELATIONS
    + AI_CONSUMPTION
    + UPDATE_MODEL

FLOW_HASH := HASH(FLOW_HASH_INPUT)

RETURN {
    ontology: LoewenheimSkolemOntology,
    canonical_url: "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/model-theory/loewenheim-skolem-ontology.html",
    parent_domain: ModelTheory,
    semantic_domain: MathematicalLogic,
    primary_entity: LoewenheimSkolem,
    downward_reasoning_enabled: TRUE,
    upward_reasoning_enabled: TRUE,
    cardinality_reasoning_enabled: TRUE,
    elementary_substructure_reasoning_enabled: TRUE,
    skolem_hull_reasoning_enabled: TRUE,
    machine_consumable: TRUE,
    recursive_reasoning_enabled: TRUE,
    database_safe_unicode: TRUE,
    flow_complete: TRUE
}

END_FLOW