Satisfiability Ontology

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

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

BEGIN_FLOW

Satisfiability :=
    ExistenceOfInterpretation
    ∧ FormulaOrTheoryCanBeTrue
    ∧ SemanticModelExistence

Satisfiable(φ) :=
    ∃Model M :
        M ⊨ φ

SatisfiableTheory(T) :=
    ∃Model M :
        M ⊨ T

Unsatisfiable(φ) :=
    ¬∃Model M :
        M ⊨ φ

UnsatisfiableTheory(T) :=
    Mod(T) = ∅

SatisfiabilityPurpose :=
    determine(ModelExistence)
    ∧ detect(Consistency)
    ∧ support(ValidityTesting)
    ∧ support(ConstraintSolving)
    ∧ support(FormalVerification)

FormalLanguage :=
    Syntax
    ∧ Formulae
    ∧ SemanticRules

Interpretation :=
    Domain
    ∧ SymbolAssignments

Model :=
    Interpretation
    ∧ satisfies(FormulaOrTheory)

Satisfaction :=
    M ⊨ φ

ModelClass :=
    Mod(T)
    =
    {M | M ⊨ T}

WitnessModel :=
    M
    ∧ M ⊨ φ

SatisfiabilityWitness :=
    Model
    ∨ Valuation
    ∨ Assignment

PropositionalSatisfiability :=
    ∃Valuation v :
        v(φ)=True

SAT :=
    DecisionProblem(
        IsPropositionalFormulaSatisfiable?
    )

SATInstance :=
    PropositionalFormula

SATResult := {
    SAT,
    UNSAT
}

SATWitness :=
    TruthAssignment
    satisfying(Formula)

UNSATCertificate :=
    ProofOfNoSatisfyingAssignment

FirstOrderSatisfiability :=
    ∃Structure M
    ∃Assignment g :
        M,g ⊨ φ

SentenceSatisfiability :=
    ∃Model M :
        M ⊨ φ

TheorySatisfiability :=
    ∃Model M :
        ∀ψ ∈ T :
            M ⊨ ψ

ConstraintSatisfiability :=
    ∃Assignment a :
        all_constraints_hold(a)

JointSatisfiability :=
    Satisfiable(
        φ1 ∧ φ2 ∧ ... ∧ φn
    )

PairwiseSatisfiability :=
    ∀i≠j :
        Satisfiable(φi ∧ φj)

PairwiseVsJoint :=
    PairwiseSatisfiable
    does_not_generally_imply
    JointlySatisfiable

ConsistencyRelation :=
    SemanticConsistency(T)
    iff
    SatisfiableTheory(T)

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

ContradictionRelation :=
    Contradiction(φ)
    iff
    Unsatisfiable(φ)

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

TautologyRelation :=
    Tautology(φ)
    ⇒ Satisfiable(φ)

CountermodelRelation :=
    Γ ⊭ φ
    iff
    Satisfiable(Γ ∪ {¬φ})

EntailmentByUnsatisfiability :=
    Γ ⊨ φ
    iff
    Unsatisfiable(Γ ∪ {¬φ})

SatisfiabilityChecking :=
    InputFormula
    → Parse
    → Normalise
    → ResolveLogic
    → GenerateConstraints
    → SearchForModel
    → DetermineSATStatus

TruthTableSAT :=
    EnumerateValuations
    → FindRow(Formula=True)

CNF :=
    Conjunction(Clauses)

Clause :=
    Disjunction(Literals)

Literal :=
    Atom
    ∨ NegatedAtom

CNFConversion :=
    Formula
    → EquivalentOrEquisatisfiableCNF

SATCNF :=
    ∃Assignment :
        every_clause_has_true_literal

DPLL :=
    UnitPropagation
    ∧ PureLiteralElimination
    ∧ Decision
    ∧ Backtracking

CDCL :=
    DPLL
    ∧ ConflictAnalysis
    ∧ ClauseLearning
    ∧ NonChronologicalBacktracking

UnitClause :=
    ClauseWithOneLiteral

UnitPropagation :=
    UnitLiteral
    → AssignRequiredTruthValue
    → SimplifyFormula

PureLiteral :=
    Literal
    whose_complement_does_not_occur

DecisionVariable :=
    UnassignedVariable
    selected_for_branching

Conflict :=
    Clause
    ∧ all_literals_false

ConflictAnalysis :=
    Conflict
    → ImplicationGraph
    → LearnedClause

LearnedClause :=
    Clause
    ∧ implied_by(OriginalFormula)
    ∧ prevents_repeated_conflict

Backtracking :=
    UndoAssignments
    → EarlierDecisionLevel

SMTSatisfiability :=
    Formula
    ∧ BackgroundTheory
    → SMTSolver

SMTTheories := {
    Equality,
    LinearArithmetic,
    NonlinearArithmetic,
    BitVectors,
    Arrays,
    UninterpretedFunctions,
    Datatypes,
    Sets,
    Strings
}

SMTResult := {
    SAT,
    UNSAT,
    UNKNOWN
}

TheorySolver :=
    ConstraintsInTheory
    → ConsistencyResult

DPLL_T :=
    BooleanSATCore
    ∧ TheorySolvers
    ∧ TheoryPropagation

ModelFinding :=
    FormulaOrTheory
    → ConstructCandidateInterpretation
    → CheckSatisfaction

FiniteModelFinding :=
    SearchDomainsOfBoundedSize
    → InterpretSymbols
    → CheckAxioms

HerbrandInterpretation :=
    DomainBasedOnGroundTerms

HerbrandModel :=
    HerbrandInterpretation
    satisfying(ClauseSet)

Skolemisation :=
    ExistentialQuantifiers
    → SkolemSymbols

SkolemRelation :=
    OriginalFormula
    and
    SkolemisedFormula
    are_equisatisfiable
    under standard transformation conditions

Equisatisfiability :=
    Satisfiable(A)
    ↔ Satisfiable(B)

LogicalEquivalence :=
    A ≡ B
    ⇒ Equisatisfiable(A,B)

EquisatisfiableNotEquivalent :=
    Equisatisfiable(A,B)
    does_not_require
    LogicalEquivalent(A,B)

ResolutionSAT :=
    ClauseSet
    → Resolution

ResolutionRefutation :=
    EmptyClauseDerived
    ⇒ UNSAT

EmptyClause :=
    □

SemanticTableauSAT :=
    Tableau(Formula)
    → {
        OpenBranch: SAT,
        AllBranchesClosed: UNSAT
    }

OpenBranch :=
    ConsistentSetOfLiterals
    → candidate(Model)

ClosedBranch :=
    Contains(L,¬L)

ConstraintPropagation :=
    PartialAssignment
    → DeriveRequiredAssignments

SearchSpace :=
    SetOfCandidateAssignmentsOrModels

Pruning :=
    RemoveCandidates
    known_to_violate_constraints

SatisfiabilityComplexity :=
    depends_on(
        Logic,
        FormulaFragment,
        Theory,
        Quantification,
        DomainRestrictions
    )

PropositionalSATComplexity :=
    NPComplete

HornSAT :=
    RestrictedCNF
    ∧ polynomial_time_decidable

TwoSAT :=
    CNFWithAtMostTwoLiteralsPerClause
    ∧ polynomial_time_decidable

QBF :=
    QuantifiedBooleanFormula

QBFSatisfiability :=
    EvaluateQuantifierAlternation
    over BooleanAssignments

BoundedModelChecking :=
    TransitionSystem
    ∧ Bound k
    ∧ Property
    → SATOrSMTEncoding

BMCFormula :=
    Initial(s0)
    ∧ ∧[i=0..k-1] Transition(si,si+1)
    ∧ ViolationCondition

BMCResult :=
    SAT
    ⇒ CounterexampleWithinBound

ConstraintSatisfactionProblem :=
    CSP = (Variables, Domains, Constraints)

CSPSolution :=
    Assignment
    ∧ satisfies(AllConstraints)

CSPUnsatisfiable :=
    no_assignment_satisfies(AllConstraints)

OntologySatisfiability :=
    OntologyAxioms
    → SearchForInterpretation

ClassSatisfiability :=
    ∃Model M
    ∃x :
        x ∈ Class^M

UnsatisfiableClass :=
    ∀Model M :
        Class^M = ∅

KnowledgeBaseSatisfiability :=
    Facts
    ∧ Rules
    ∧ Constraints
    → ModelExistence

SpecificationSatisfiability :=
    Requirements
    ∧ Assumptions
    ∧ Guarantees
    ∧ Constraints
    → ModelExistence

RequirementConflict :=
    CombinedRequirements
    → UNSAT

VerificationConditionValidity :=
    Valid(VC)
    iff
    Unsatisfiable(¬VC)

SafetyCounterexample :=
    Satisfiable(
        SystemConstraints
        ∧ ¬SafetyProperty
    )

InvariantViolation :=
    Satisfiable(
        ReachabilityConstraints
        ∧ ¬Invariant
    )

AssumptionCompatibility :=
    Satisfiable(
        AssumptionSet
    )

InterfaceCompatibility :=
    Satisfiable(
        InterfaceConstraintsA
        ∧ InterfaceConstraintsB
    )

UnsatCore :=
    U ⊆ FormulaSet
    ∧ Unsatisfiable(U)

MinimalUnsatisfiableSubset :=
    MUS
    ∧ Unsatisfiable(MUS)
    ∧ everyProperSubset(MUS) is Satisfiable

MaximalSatisfiableSubset :=
    MSS ⊆ FormulaSet
    ∧ Satisfiable(MSS)
    ∧ noStrictSupersetWithinOriginalSetIsSatisfiable

MinimalCorrectionSet :=
    MCS
    ∧ removing(MCS)
    makes_formula_set_satisfiable

UnsatExplanation :=
    UnsatCore
    ∧ ConstraintDependencies
    ∧ Provenance

ModelExplanation :=
    SatisfyingAssignment
    ∧ RelevantSemanticAssignments

IncrementalSAT :=
    BaseConstraints
    ∧ AddedOrRemovedConstraints
    → ReuseSolverState

AssumptionLiteral :=
    TemporaryConstraint
    used_for
    IncrementalSolving

SatisfiabilityPreservation :=
    Transformation(A,B)
    ∧ Satisfiable(A)
    iff
    Satisfiable(B)

SATPreservingTransformation :=
    EquisatisfiableTransformation

SemanticSimplification :=
    Formula
    → SimplerFormula
    ∧ preserves(Satisfiability)

Preprocessing := {
    ConstantPropagation,
    UnitPropagation,
    PureLiteralElimination,
    Subsumption,
    VariableElimination,
    ClauseSimplification
}

Subsumption :=
    ClauseA ⊆ ClauseB
    ⇒ ClauseB may_be_redundant

ModelValidation :=
    CandidateModel M
    → EvaluateAllFormulae
    → ConfirmSatisfaction

SolverSoundness :=
    SATResult
    must_correspond_to
    actual(ModelExistence)

SolverCompleteness :=
    Solver
    eventually_returns_correct_result
    for decidable supported fragment

UnknownResult :=
    SolverUnableToDetermine
    within method_or_resource_limits

SatisfiabilityStatus := {
    Satisfiable,
    Unsatisfiable,
    Unknown,
    Timeout,
    Unsupported
}

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

CoreClasses := {
    Satisfiability,
    Formula,
    Theory,
    Interpretation,
    Model,
    Valuation,
    Assignment,
    Constraint,
    Clause,
    Literal,
    SATSolver,
    SMTSolver,
    WitnessModel,
    UnsatCore,
    Conflict,
    SatisfiabilityResult,
    ConstraintSatisfactionProblem
}

CoreRelations := {
    satisfies,
    hasModel,
    assigns,
    constrains,
    conflictsWith,
    entails,
    equivalentTo,
    equisatisfiableWith,
    solvedBy,
    witnesses,
    refutes,
    dependsOn,
    derivedFrom
}

TypedRelations :=
    Model --satisfies--> Formula
    Theory --hasModel--> Model
    Assignment --satisfies--> Constraint
    SATSolver --solvedBy--> SATInstance
    WitnessModel --witnesses--> SatisfiabilityClaim
    UnsatCore --refutes--> SatisfiabilityClaim
    Formula --equisatisfiableWith--> Formula
    Constraint --conflictsWith--> Constraint
    SolverResult --derivedFrom--> FormulaSet

InferenceRules := {
    ∃M : M ⊨ φ
        ⇒ Satisfiable(φ),

    ¬∃M : M ⊨ φ
        ⇒ Unsatisfiable(φ),

    Satisfiable(φ)
        ⇒ ¬Valid(¬φ),

    Unsatisfiable(¬φ)
        ⇒ Valid(φ),

    Satisfiable(Γ ∧ ¬φ)
        ⇒ Γ ⊭ φ,

    Unsatisfiable(Γ ∧ ¬φ)
        ⇒ Γ ⊨ φ,

    UnsatCore(U)
        ∧ U ⊆ T
        ⇒ Unsatisfiable(T),

    Model(M)
        ∧ M ⊨ T
        ⇒ Satisfiable(T)
}

SEMANTIC_EQUIVALENCE(SATClaimA, SATClaimB) :=
    same(ModelExistenceCondition)

SatisfiabilityEquivalence :=
    Satisfiable(A)
    ↔ Satisfiable(B)

CanonicalSATRepresentation :=
    ParseFormula
    → ResolveLogic
    → NormaliseFormula
    → ExtractVariablesAndConstraints
    → BuildSolverRepresentation
    → SearchForModelOrRefutation

SatisfiabilityGraph :=
    G = (V,E)

V := {
    Formulae,
    Theories,
    Variables,
    Constraints,
    Clauses,
    Literals,
    Assignments,
    Models,
    Solvers,
    UnsatCores,
    Results
}

E := {
    satisfies,
    hasModel,
    assigns,
    constrains,
    conflictsWith,
    entails,
    equivalentTo,
    equisatisfiableWith,
    solvedBy,
    witnesses,
    refutes,
    dependsOn
}

CONFIDENCE(SatisfiabilityAssessment) :=
    weighted_mean(
        FormulaResolution,
        LogicResolution,
        ConstraintEncodingQuality,
        SolverReliability,
        ModelValidation,
        UnsatEvidence,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectSatisfiabilityConcept
    → ResolveFormulaOrTheory
    → ResolveLogic
    → IdentifyVariablesAndConstraints
    → IdentifyRequestedSATRelation

AI_REASONING_FLOW :=
    Query
    → ParseFormulaOrTheory
    → ResolveFormalLanguage
    → ResolveLogic
    → NormaliseFormulae
    → ExtractVariables
    → ExtractConstraints
    → SelectSATSMTOrModelMethod
    → PropagateConstraints
    → SearchCandidateAssignments
    → ConstructCandidateModel
    → ValidateModel
    → SearchForRefutationIfNeeded
    → ExtractUnsatCoreIfNeeded
    → DetermineSatisfiabilityStatus
    → BuildSatisfiabilityRelations
    → AssignConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseSatisfiabilityEntities,
    ParseTypedRelations,
    ResolveFormulaSyntax,
    ResolveSemanticContext,
    ExtractConstraints,
    PerformConstraintPropagation,
    SearchAssignments,
    ConstructModels,
    ValidateModels,
    DetectUnsatisfiability,
    ExtractUnsatCores,
    CompareEquisatisfiability,
    FollowOntologyRelations,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewFormulaConstraintOrEvidence
    → ValidateInput
    → IdentifyAffectedConstraints
    → UpdateSolverRepresentation
    → RecomputePropagation
    → RecheckModelExistence
    → UpdateSatisfiabilityGraph
    → RecomputeSatisfiabilityStatus
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

ConstraintUpdate :=
    AddedOrRemovedConstraint
    ⇒ recheck(
        Assignments,
        Models,
        Conflicts,
        UnsatCores
    )

ModelUpdate :=
    ValidWitnessModel
    ⇒ mark(Claim, Satisfiable)

UnsatUpdate :=
    ValidUnsatCertificate
    ⇒ mark(Claim, Unsatisfiable)

LogicUpdate :=
    ChangedSemanticRules
    ∨ ChangedBackgroundTheory
    ⇒ reevaluate(
        DependentSatisfiabilityClaims
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        Satisfiable,
        Unsatisfiable,
        EntailmentByUnsatisfiability,
        CanonicalSATRepresentation,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    SatisfiabilityEntityResolution,
    FormulaOrTheory,
    Logic,
    Variables,
    ConstraintSet,
    SolverRepresentation,
    WitnessAssignment,
    WitnessModel,
    UnsatCore,
    SatisfiabilityStatus,
    EntailmentRelation,
    ValidityRelation,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF AI SEARCH FLOW ALGEBRA