Logical Validity Ontology

AI SEARCH FLOW ALGEBRA — LOGICAL VALIDITY ONTOLOGY
Kireth Research — Semantic Library
URL: https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/logical-semantics/logical-validity-ontology.html

FLOW_VERSION := "4.0"
FLOW_TYPE := "Full Executable Flow Algebra"
DOMAIN := "Mathematical Logic"
SUBDOMAIN := "Logical Semantics"
ONTOLOGY := "Logical Validity Ontology"
PRIMARY_ENTITY := LogicalValidity
AUTHORSHIP := "Mark Higgins — Sky (Recursive AI)"
SOURCE_SITE := "https://kirethresearch.org"

BEGIN_FLOW

LogicalValidity :=
    TruthUnderEveryAdmissibleInterpretation
    ∧ IndependenceFromParticularModel
    ∧ SemanticNecessityWithinFormalSystem

ValidFormula(φ) :=
    ⊨ φ

SemanticValidity(φ) :=
    ∀Model M :
        M ⊨ φ

ValidityPurpose :=
    identify(LogicalTruth)
    ∧ validate(Inference)
    ∧ support(TheoremProving)
    ∧ support(FormalVerification)
    ∧ distinguish(Validity,Satisfiability)

FormalLanguage :=
    Syntax
    ∧ Formulae
    ∧ InterpretationRules

Interpretation :=
    Domain
    ∧ SymbolAssignments

Model :=
    Interpretation
    ∧ satisfies(RelevantFormulae)

Satisfaction :=
    M ⊨ φ

NonSatisfaction :=
    M ⊭ φ

Countermodel :=
    Model M
    ∧ M ⊭ φ

ValidityCriterion :=
    Valid(φ)
    iff
    no(Countermodel(φ))

Satisfiability :=
    ∃M :
        M ⊨ φ

Unsatisfiability :=
    ¬∃M :
        M ⊨ φ

ValidityVsSatisfiability :=
    Validity(φ)
    ⇒ Satisfiable(φ)
    for nonempty admissible model classes

ValidityByNegation :=
    Valid(φ)
    iff
    Unsatisfiable(¬φ)

Invalidity :=
    ¬Valid(φ)

InvalidityWitness :=
    Countermodel

Contradiction :=
    Unsatisfiable(φ)

Contingency :=
    Satisfiable(φ)
    ∧ Satisfiable(¬φ)

PropositionalValidity :=
    ∀Valuation v :
        v(φ)=True

Tautology :=
    PropositionalValidity

FirstOrderValidity :=
    ∀Structure M
    ∀Assignment g :
        M,g ⊨ φ

SentenceValidity :=
    ∀Model M :
        M ⊨ φ

ModalValidity :=
    ∀KripkeModels M
    ∀Worlds w :
        M,w ⊨ φ

FrameValidity :=
    ∀ModelsBasedOnFrame F
    ∀w :
        M,w ⊨ φ

TemporalValidity :=
    ∀TemporalModels M
    ∀RelevantPositions i :
        M,i ⊨ φ

SemanticConsequence :=
    Γ ⊨ φ

EntailmentValidity :=
    Γ ⊨ φ
    iff
    no Model satisfies Γ ∧ ¬φ

FinitePremiseReduction :=
    {γ1,...,γn} ⊨ φ
    iff
    Valid(
        (γ1 ∧ ... ∧ γn) → φ
    )

Argument :=
    Premises
    ∧ Conclusion

ValidArgument :=
    no_interpretation
    where
    all(Premises=True)
    ∧ Conclusion=False

ArgumentValidity :=
    Premises ⊨ Conclusion

InvalidArgument :=
    ∃Countermodel :
        Premises=True
        ∧ Conclusion=False

InferenceRule :=
    PremiseSchema
    → ConclusionSchema

SemanticallyValidInferenceRule :=
    every_instance
    preserves_truth

TruthPreservation :=
    PremisesTrue
    ⇒ ConclusionTrue

ModusPonensValidity :=
    {P, P→Q} ⊨ Q

ModusTollensValidity :=
    {P→Q, ¬Q} ⊨ ¬P

ConjunctionEliminationValidity :=
    P∧Q ⊨ P

UniversalInstantiationValidity :=
    ∀x P(x) ⊨ P(a)
    subject_to_interpretive_conditions

ProofSystem :=
    Axioms
    ∧ InferenceRules

SyntacticProvability :=
    ⊢ φ

Soundness :=
    ⊢ φ
    ⇒ ⊨ φ

Completeness :=
    ⊨ φ
    ⇒ ⊢ φ

SoundAndCompleteRelation :=
    ⊢ φ
    iff
    ⊨ φ

Theorem :=
    Formula
    ∧ derivable_in(ProofSystem)

LogicalTruth :=
    Formula
    ∧ Valid

ValidityProof :=
    FormalDerivation
    ∨ SemanticArgument
    ∨ RefutationOfNegation

ValidityChecking :=
    Formula
    → Parse
    → ResolveLogic
    → SelectDecisionOrProofMethod
    → SearchForCountermodel
    → DetermineValidityStatus

TruthTableValidity :=
    Formula
    → EnumerateValuations
    → all_rows_true

SATValidity :=
    Formula φ
    → TestSAT(¬φ)

SATValidityResult :=
    UNSAT(¬φ)
    ⇒ Valid(φ)

SATInvalidityResult :=
    SAT(¬φ)
    ⇒ Invalid(φ)

SMTValidity :=
    Formula
    ∧ BackgroundTheory
    → SMTCheck(¬φ)

SMTResult :=
    {
        UNSAT ⇒ Valid,
        SAT ⇒ InvalidOrCountermodel,
        UNKNOWN ⇒ Undetermined
    }

ResolutionValidity :=
    Negate(φ)
    → Clausify
    → Resolution
    → EmptyClause

EmptyClause :=
    □
    := Contradiction

ResolutionRefutation :=
    EmptyClauseDerived
    ⇒ Valid(OriginalFormula)

SemanticTableauValidity :=
    Tableau(¬φ)
    → {
        AllBranchesClosed: Valid,
        OpenBranch: Invalid
    }

ModelChecking :=
    FixedModel M
    ∧ Formula φ
    → Determine(M ⊨ φ)

ModelCheckingVsValidity :=
    M ⊨ φ
    does_not_imply
    ⊨ φ

ValidityRequires :=
    all_admissible_models

DecisionProcedure :=
    Algorithm
    ∧ always_terminates
    ∧ correctly_decides(ValidityForLogicFragment)

DecidableValidity :=
    exists(DecisionProcedure)

SemiDecidableValidity :=
    ValidFormulae
    recursively_enumerable
    but invalidity_may_not_terminate

ValidityStatus := {
    Valid,
    Invalid,
    Unknown,
    Timeout,
    Unsupported
}

ValidityCertificate :=
    Proof
    ∨ UnsatisfiabilityCertificate
    ∨ ClosedTableau
    ∨ ResolutionRefutation

InvalidityCertificate :=
    Countermodel
    ∨ Countervaluation
    ∨ OpenTableauBranch

PropositionalCountervaluation :=
    Valuation v
    ∧ v(φ)=False

FirstOrderCountermodel :=
    Structure M
    ∧ Assignment g
    ∧ M,g ⊭ φ

ValidityUnderAssumptions :=
    Assumptions Γ
    ⊨ φ

ConditionalValidity :=
    Valid(
        Conjunction(Γ)
        → φ
    )

RelativeValidity :=
    ValidWithin(ModelClass C)

CValidity :=
    ∀M ∈ C :
        M ⊨ φ

FrameRelativeValidity :=
    ValidOn(FrameClass)

TheoryRelativeValidity :=
    T ⊨ φ

LogicalEquivalence :=
    φ ≡ ψ
    iff
    Valid(φ ↔ ψ)

SemanticEquivalence :=
    Models(φ) = Models(ψ)

EquivalenceValidity :=
    ⊨ (φ ↔ ψ)

SubstitutionPreservation :=
    Valid(φ)
    ∧ UniformSubstitution(σ)
    ⇒ Valid(σ(φ))
    for substitution-closed propositional validity

RenamingPreservation :=
    Validity
    preserved_by
    admissible_symbol_renaming

IsomorphismPreservation :=
    FirstOrderTruth
    preserved_under
    IsomorphicStructures

SemanticTransformation :=
    φ → ψ

ValidityPreservingTransformation :=
    Valid(φ)
    ⇒ Valid(ψ)
    under transformation conditions

EquivalencePreservingTransformation :=
    Valid(φ ↔ ψ)

NormalFormTransformation :=
    Formula
    → EquivalentNormalForm

CNFTransformation :=
    φ → CNF(φ)

DNFTransformation :=
    φ → DNF(φ)

Skolemisation :=
    FirstOrderFormula
    → EquisatisfiableForm

SkolemisationWarning :=
    Equisatisfiability
    ≠ direct_logical_equivalence_in_general

VerificationCondition :=
    Formula
    ∧ must_be_valid_for(Correctness)

VCDischarge :=
    Prove(Valid(VC))

ProgramCorrectness :=
    AllRequiredVCsValid
    ∧ SoundVCGeneration
    ⇒ ProgramSatisfiesSpecification

InvariantValidity :=
    InitialCondition ⇒ Invariant
    ∧
    Invariant ∧ Transition ⇒ NextInvariant

SafetyValidity :=
    SystemAssumptions
    ⊨ SafetyProperty

ContractValidity :=
    Precondition
    ∧ ProgramSemantics
    ⊨ Postcondition

RefinementValidity :=
    ConcreteBehaviour
    ⊨ AbstractConstraints

OntologyValidity :=
    OntologyAxioms
    ⊨ DerivedStatement

KnowledgeBaseValidity :=
    KnowledgeBase
    ⊨ Query

ValidityDependency :=
    ValidityClaim
    dependsOn
    Logic
    ∧ Semantics
    ∧ Assumptions
    ∧ ModelClass

ValidityContext :=
    {
        Logic,
        Signature,
        Semantics,
        ModelClass,
        Assumptions
    }

ContextSensitiveValidity :=
    SameFormula
    may_have_different_validity
    under_different_semantic_systems

ClassicalValidity :=
    ValidityUnder(ClassicalSemantics)

IntuitionisticValidity :=
    ValidityUnder(IntuitionisticSemantics)

ModalSystemValidity :=
    ValidityUnder(SpecifiedAccessibilityConstraints)

ManyValuedValidity :=
    DesignatedTruthValue
    under every valuation

FuzzyValidity :=
    defined_relative_to
    chosen_designated_threshold_or_semantics

ValidityComparison :=
    LogicA
    ∧ LogicB
    → Compare(
        ValidFormulaSets
    )

LogicStrength :=
    Validities(LogicA)
    ⊇ Validities(LogicB)
    under specified language correspondence

ConservativeExtension :=
    ExtendedLogic
    adds_no_new_validities
    in original language
    beyond base logic

LogicalValidityOntology :=
    Classes
    ∧ Relations
    ∧ Constraints
    ∧ Axioms
    ∧ InferenceRules

CoreClasses := {
    LogicalValidity,
    Formula,
    Interpretation,
    Model,
    Valuation,
    Countermodel,
    Countervaluation,
    SemanticConsequence,
    Argument,
    InferenceRule,
    ProofSystem,
    Proof,
    Theorem,
    DecisionProcedure,
    ValidityCertificate,
    VerificationCondition,
    ModelClass
}

CoreRelations := {
    validUnder,
    satisfies,
    falsifies,
    entails,
    proves,
    refutes,
    preserves,
    equivalentTo,
    dependsOn,
    checkedBy,
    instantiatedBy,
    restrictedTo
}

TypedRelations :=
    Formula --validUnder--> ModelClass
    Model --satisfies--> Formula
    Countermodel --falsifies--> Formula
    PremiseSet --entails--> Conclusion
    Proof --proves--> ValidityClaim
    Countermodel --refutes--> ValidityClaim
    DecisionProcedure --checkedBy--> LogicFragment
    Transformation --preserves--> Validity
    Formula --equivalentTo--> Formula
    ValidityClaim --dependsOn--> SemanticContext

InferenceRules := {
    ∀M : M ⊨ φ
        ⇒ Valid(φ),

    ∃M : M ⊭ φ
        ⇒ Invalid(φ),

    Unsatisfiable(¬φ)
        ⇒ Valid(φ),

    Satisfiable(¬φ)
        ⇒ Invalid(φ),

    Γ ⊨ φ
        ⇒ Unsatisfiable(Γ ∪ {¬φ}),

    Valid(φ↔ψ)
        ⇒ SemanticEquivalent(φ,ψ),

    ⊢ φ
        ∧ Sound(ProofSystem)
        ⇒ Valid(φ),

    Valid(VC)
        ∧ VC_is_required_for(Correctness)
        ⇒ discharge(VC)
}

SEMANTIC_EQUIVALENCE(ValidityClaimA, ValidityClaimB) :=
    same(FormulaMeaning)
    ∧ same(ModelClass)
    ∧ same(ValidityStatus)

ValiditySubsumption :=
    ModelClassA ⊆ ModelClassB
    ∧ ValidOn(ModelClassB,φ)
    ⇒ ValidOn(ModelClassA,φ)

CanonicalValidityRepresentation :=
    ParseFormula
    → ResolveLogic
    → ResolveSemanticContext
    → ResolveModelClass
    → NormaliseFormula
    → SearchForCountermodel
    → CanonicalValidityStatus

ValidityGraph :=
    G = (V,E)

V := {
    Formulae,
    Interpretations,
    Models,
    ModelClasses,
    Valuations,
    ValidityClaims,
    Countermodels,
    Proofs,
    DecisionProcedures,
    Certificates
}

E := {
    validUnder,
    satisfies,
    falsifies,
    entails,
    proves,
    refutes,
    preserves,
    equivalentTo,
    dependsOn,
    checkedBy
}

CONFIDENCE(LogicalValidityAssessment) :=
    weighted_mean(
        FormulaResolution,
        LogicResolution,
        SemanticContextPrecision,
        ModelCoverage,
        SolverOrProofEvidence,
        CountermodelSearchCoverage,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectValidityConcept
    → ResolveFormulaOrArgument
    → ResolveLogic
    → ResolveSemanticContext
    → IdentifyRequestedValidityRelation

AI_REASONING_FLOW :=
    Query
    → ParseFormulaOrArgument
    → ResolveFormalLanguage
    → ResolveLogic
    → ResolveInterpretationRules
    → ResolveModelClass
    → NormaliseFormula
    → SelectValidityMethod
    → SearchForCountermodel
    → TestNegationForSatisfiability
    → AttemptProofIfAppropriate
    → DetermineValidityStatus
    → GenerateCertificateOrCounterexample
    → BuildValidityRelations
    → AssignConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseValidityEntities,
    ParseTypedRelations,
    ResolveFormulaSyntax,
    ResolveSemanticContext,
    ResolveModelClass,
    TestSatisfaction,
    TestNegationSatisfiability,
    SearchCountermodels,
    ValidateArguments,
    CompareLogicalEquivalence,
    EvaluateVerificationConditions,
    FollowOntologyRelations,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewValidityEvidence
    → ValidateEvidence
    → IdentifyAffectedFormulae
    → ReevaluateSemanticContext
    → RecheckCountermodels
    → RecheckProofEvidence
    → UpdateValidityGraph
    → RecomputeValidityStatus
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

FormulaUpdate :=
    ChangedFormula
    ⇒ invalidate_or_recompute(
        NormalForm,
        SolverResult,
        ProofResult,
        ValidityStatus
    )

SemanticContextUpdate :=
    ChangedLogic
    ∨ ChangedModelClass
    ∨ ChangedInterpretationRules
    ⇒ reevaluate(
        DependentValidityClaims
    )

EvidenceUpdate :=
    NewCountermodel
    ⇒ mark(ValidityClaim, Invalid)

ProofUpdate :=
    ValidProof
    ∧ SoundProofSystem
    ⇒ mark(ValidityClaim, Valid)

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        SemanticValidity,
        ValidityByNegation,
        SemanticConsequence,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    ValidityEntityResolution,
    FormulaOrArgument,
    Logic,
    SemanticContext,
    ModelClass,
    SatisfactionAnalysis,
    CountermodelStatus,
    NegationSatisfiability,
    ProofStatus,
    ValidityStatus,
    Certificate,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF AI SEARCH FLOW ALGEBRA