Contradiction Detection Ontology

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

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

BEGIN_FLOW

ContradictionDetection :=
    Identify(LogicalConflict)
    ∧ Detect(UnsatisfiableConstraintSets)
    ∧ Trace(ConflictingStatements)
    ∧ Produce(ContradictionEvidence)

Contradiction :=
    φ ∧ ¬φ

ExplicitContradiction :=
    TheoryContainsOrDerives(φ)
    ∧ TheoryContainsOrDerives(¬φ)

ImplicitContradiction :=
    FormulaSet
    ∧ no_explicit_pair_required
    ∧ jointly_unsatisfiable

Theory :=
    SetOfFormulae

KnowledgeBase :=
    Facts
    ∧ Rules
    ∧ Constraints
    ∧ OntologyAxioms

Consistency :=
    ¬Derivable(⊥)
    ∧ Satisfiable(Theory)

Inconsistency :=
    Derivable(⊥)
    ∨ Unsatisfiable(Theory)

Bottom :=
    ⊥

ContradictionPattern :=
    Assertion(A)
    ∧ NegatedAssertion(¬A)

DirectConflict :=
    A
    ∧ ¬A

DerivedConflict :=
    Premises
    → A
    ∧
    Premises
    → ¬A

ConstraintConflict :=
    C1 ∧ C2 ∧ ... ∧ Cn
    ⇒ ⊥

SemanticConflict :=
    ¬∃Model M :
        M ⊨ Constraints

SyntacticConflict :=
    Theory ⊢ ⊥

ContradictionDetectionFlow :=
    InputTheory
    → ParseStatements
    → NormaliseFormulae
    → ResolveEntities
    → ResolveNegation
    → BuildDependencies
    → DetectDirectConflicts
    → DeriveConsequences
    → TestSatisfiability
    → ExtractConflictSet
    → ProduceEvidence

NegationNormalForm :=
    NNF(Formula)

CNF :=
    ConjunctiveNormalForm

Normalisation :=
    Formula
    → EliminateImplications
    → PushNegations
    → StandardiseVariables
    → OptionalSkolemisation
    → ClauseForm

Literal :=
    Atom
    ∨ NegatedAtom

ComplementaryLiterals :=
    L
    ∧ ¬L

Clause :=
    Disjunction(Literals)

Resolution :=
    (L ∨ A)
    ∧ (¬L ∨ B)
    ⇒ (A ∨ B)

ResolutionRefutation :=
    Clauses
    → RepeatedResolution
    → EmptyClause

EmptyClause :=
    □
    := Contradiction

RefutationFound :=
    EmptyClauseDerived
    ⇒ Inconsistent

SATDetection :=
    PropositionalConstraints
    → SATSolver

SATResult :=
    SAT
    ⇒ NoContradictionWithinEncodedConstraints

UNSATResult :=
    UNSAT
    ⇒ ContradictionDetected

SMTDetection :=
    Formulae
    ∧ BackgroundTheories
    → SMTSolver

BackgroundTheories := {
    Equality,
    Arithmetic,
    Arrays,
    BitVectors,
    UninterpretedFunctions,
    Datatypes,
    Sets,
    Strings
}

ModelFinding :=
    Theory
    → SearchForModel

ModelFound :=
    ∃M : M ⊨ Theory
    ⇒ NoGlobalSemanticContradiction

CountermodelSearch :=
    EntailmentClaim(Γ ⊨ φ)
    → Search(M ⊨ Γ ∧ ¬φ)

UnsatCore :=
    U ⊆ Theory
    ∧ Unsatisfiable(U)

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

ConflictSet :=
    SetOfStatements
    ∧ jointly_inconsistent

MinimalConflictSet :=
    ConflictSet
    ∧ noProperSubsetIsConflictSet

ContradictionWitness :=
    {
        FormulaNegationPair,
        RefutationProof,
        EmptyClause,
        UnsatCore,
        ConstraintCycle,
        TypeConflict,
        CardinalityConflict
    }

TypeContradiction :=
    EntityType(A)
    ∧ EntityType(B)
    ∧ Disjoint(A,B)

ClassConflict :=
    Instance(x,A)
    ∧ Instance(x,B)
    ∧ DisjointClasses(A,B)

EqualityContradiction :=
    a = b
    ∧ a ≠ b

CardinalityContradiction :=
    MinimumCardinality(n)
    ∧ MaximumCardinality(m)
    ∧ n > m

NumericContradiction :=
    x > a
    ∧ x ≤ a

IntervalContradiction :=
    LowerBound > UpperBound

OrderingContradiction :=
    a < b
    ∧ b ≤ a

CycleContradiction :=
    StrictOrderCycle(
        a1 < a2 < ... < an < a1
    )

TemporalContradiction :=
    Before(A,B)
    ∧ Before(B,A)
    under strict temporal ordering

SpatialContradiction :=
    Disjoint(A,B)
    ∧ OverlapRequired(A,B)

IdentityContradiction :=
    SameAs(A,B)
    ∧ DifferentFrom(A,B)

FunctionalPropertyConflict :=
    FunctionalProperty(P)
    ∧ P(x,a)
    ∧ P(x,b)
    ∧ a ≠ b

InverseFunctionalConflict :=
    InverseFunctionalProperty(P)
    ∧ P(a,x)
    ∧ P(b,x)
    ∧ a ≠ b

DomainRangeConflict :=
    PropertyAssertion
    → RequiredType
    ∧ ExplicitDisjointType

RuleContradiction :=
    SameAntecedent
    → Conclusion
    ∧ NegatedConclusion

RequirementContradiction :=
    RequirementA
    requires(P)
    ∧ RequirementB
    forbids(P)

SpecificationContradiction :=
    Preconditions
    ∧ Postconditions
    ∧ Invariants
    ∧ Constraints
    are_unsatisfiable

AssumptionContradiction :=
    AssumptionA
    ∧ AssumptionB
    ⇒ ⊥

OntologyContradiction :=
    OntologyAxioms
    ∧ Assertions
    have_no_model

DatabaseContradiction :=
    Data
    violates
    IntegrityConstraints

IntegrityConstraintConflict :=
    RecordOrRelation
    ∧ violates(Key ∨ Type ∨ Cardinality ∨ ReferentialConstraint)

ProofContradiction :=
    Theory ⊢ φ
    ∧ Theory ⊢ ¬φ

ParaconsistentContext :=
    ContradictionsMayExist
    ∧ ExplosionBlocked

ClassicalExplosion :=
    φ ∧ ¬φ
    ⊢ ψ

ContradictionSeverity :=
    {
        Local,
        Derived,
        Global,
        Structural,
        Semantic
    }

LocalContradiction :=
    ConflictLimitedTo(Subtheory)

GlobalContradiction :=
    EntireTheoryUnsatisfiable

ContradictionScope :=
    smallest_dependency_region
    containing
    ConflictEvidence

DependencyGraph :=
    G = (Statements, DerivationEdges)

DerivationEdge :=
    Premise --supports--> Conclusion

ConflictGraph :=
    Gc = (Assertions, ConflictRelations)

ContradictionPath :=
    SourceAssertions
    → Derivations
    → ConflictingConclusions

Provenance :=
    Statement
    → Source
    ∧ Author
    ∧ Timestamp
    ∧ TransformationHistory

ContradictionProvenance :=
    Conflict
    → SupportingSources
    → DerivationPaths

ConflictExplanation :=
    IdentifyConflictingClaims
    ∧ ShowDependencies
    ∧ ShowFormalReason
    ∧ PreserveProvenance

ContradictionResolution :=
    Detect
    → Diagnose
    → RankOrAssessEvidence
    → ModifyOrAnnotate
    → RecheckConsistency

ResolutionStrategies := {
    RemoveStatement,
    WeakenConstraint,
    ReviseAssumption,
    CorrectEntityResolution,
    SeparateContexts,
    IntroduceTemporalScope,
    PreserveAsUnresolvedConflict
}

ContextualContradiction :=
    StatementsAppearConflicting
    but
    ContextsDiffer

ContextDimensions := {
    Time,
    Location,
    Model,
    Assumptions,
    Definitions,
    Scope,
    Version
}

FalsePositiveConflict :=
    ApparentContradiction
    resolved_by
    ContextDisambiguation

TemporalVersionConflict :=
    ClaimAt(t1)
    ≠ ClaimAt(t2)
    without necessarily implying contradiction

SemanticDisambiguation :=
    ResolveMeaning(A)
    ∧ ResolveMeaning(B)
    → ReevaluateConflict

EntityDisambiguation :=
    ResolveEntityReferences
    → PreventFalseContradiction

QuantifierConflict :=
    UniversalClaim
    ∧ ExistentialCounterexample

UniversalExistentialPattern :=
    ∀x P(x)
    ∧ ∃x ¬P(x)
    ⇒ Contradiction

ExistentialImpossibility :=
    ∃x P(x)
    ∧ ∀x ¬P(x)
    ⇒ Contradiction

ImplicationConflict :=
    P
    ∧ (P → Q)
    ∧ ¬Q
    ⇒ Contradiction

EquivalenceConflict :=
    P ↔ Q
    ∧ P
    ∧ ¬Q
    ⇒ Contradiction

InvariantConflict :=
    ReachableState(s)
    ∧ Invariant(P)
    ∧ ¬P(s)
    ⇒ Violation

AutomatedContradictionDetection :=
    Normalisation
    ∧ Inference
    ∧ SATorSMT
    ∧ ModelFinding
    ∧ ConflictExtraction

IncrementalDetection :=
    NewStatement
    → IdentifyAffectedDependencies
    → CheckDirectNegation
    → PropagateConsequences
    → RecheckAffectedConstraints

StreamingDetection :=
    IncomingClaim
    → Normalise
    → CompareAgainstActiveKnowledge
    → DetectConflict
    → UpdateGraph

ContradictionCache :=
    FLOW_HASH(ConstraintSet)
    → PreviousDetectionResult

DetectionStatus := {
    ContradictionFound,
    NoContradictionFound,
    PotentialConflict,
    Unknown,
    SolverTimeout
}

EvidenceStrength :=
    function(
        Directness,
        FormalDerivation,
        SolverCertificate,
        SourceReliability,
        ContextResolution
    )

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

CoreClasses := {
    Contradiction,
    Assertion,
    NegatedAssertion,
    Theory,
    Constraint,
    Conflict,
    ConflictSet,
    UnsatCore,
    Model,
    Refutation,
    Proof,
    Rule,
    Assumption,
    Requirement,
    OntologyAxiom,
    Provenance,
    DetectionResult
}

CoreRelations := {
    contradicts,
    negates,
    entails,
    derives,
    conflictsWith,
    dependsOn,
    violates,
    satisfies,
    supports,
    refutes,
    causedBy,
    resolvedBy,
    tracesTo
}

TypedRelations :=
    Assertion --contradicts--> Assertion
    Negation --negates--> Formula
    Theory --contains--> Assertion
    Rule --derives--> Conclusion
    Constraint --conflictsWith--> Constraint
    UnsatCore --supports--> InconsistencyClaim
    Refutation --refutes--> ConsistencyClaim
    Conflict --causedBy--> Assertion
    Conflict --tracesTo--> Provenance
    Resolution --resolvedBy--> ResolutionStrategy

InferenceRules := {
    A
        ∧ ¬A
        ⇒ Contradiction,

    Theory ⊢ A
        ∧ Theory ⊢ ¬A
        ⇒ Inconsistent(Theory),

    UNSAT(Theory)
        ⇒ SemanticContradiction(Theory),

    EmptyClauseDerived
        ⇒ RefutationComplete,

    UnsatCore(U)
        ∧ U ⊆ Theory
        ⇒ Inconsistent(Theory),

    Disjoint(A,B)
        ∧ Instance(x,A)
        ∧ Instance(x,B)
        ⇒ TypeContradiction,

    a = b
        ∧ a ≠ b
        ⇒ IdentityContradiction,

    ∀x P(x)
        ∧ ∃x ¬P(x)
        ⇒ QuantifierContradiction,

    DifferentContexts(A,B)
        ⇒ do_not_mark_direct_contradiction_without_context_alignment
}

SEMANTIC_EQUIVALENCE(ConflictA, ConflictB) :=
    same(MinimalConflictingConstraints)
    ∧ same(LogicalIncompatibility)

ContradictionSubsumption :=
    ConflictSetA ⊆ ConflictSetB
    ∧ Unsatisfiable(ConflictSetA)
    ⇒ Unsatisfiable(ConflictSetB)

CanonicalContradictionRepresentation :=
    NormaliseStatements
    → ResolveEntities
    → ResolveContexts
    → ExtractConstraints
    → BuildDependencyGraph
    → ComputeMinimalConflictEvidence
    → CanonicalConflictGraph

CONFIDENCE(ContradictionDetection) :=
    weighted_mean(
        EntityResolution,
        ContextResolution,
        LogicalNormalisation,
        InferenceCoverage,
        SolverEvidence,
        ConflictMinimality,
        ProvenanceQuality
    )

AI_QUERY_INTERPRETATION :=
    Query
    → DetectContradictionIntent
    → ResolveStatements
    → ResolveEntities
    → ResolveContexts
    → IdentifyLogic
    → IdentifyPotentialConflictPatterns

AI_REASONING_FLOW :=
    Query
    → ParseClaims
    → CanonicaliseClaims
    → ResolveEntities
    → ResolveTemporalAndContextScope
    → DetectExplicitNegations
    → BuildConstraintSet
    → ApplyInferenceRules
    → DetectDerivedConflicts
    → TestSatisfiability
    → SearchForModel
    → ExtractUnsatCoreIfNeeded
    → BuildContradictionPath
    → DetermineDetectionStatus
    → AssignConfidence
    → PreserveProvenance
    → GenerateExplanation

AI_CONSUMPTION := {
    ParseContradictionEntities,
    ParseTypedRelations,
    ResolveNegation,
    ResolveEntityIdentity,
    ResolveContext,
    DetectDirectConflicts,
    DeriveLogicalConsequences,
    TestSatisfiability,
    ConstructModels,
    ExtractUnsatCores,
    TraceConflictDependencies,
    CompareConflictEquivalence,
    PreserveProvenance,
    GenerateFormalExplanation
}

UPDATE_MODEL :=
    NewClaimOrEvidence
    → ValidateInput
    → ResolveAffectedEntities
    → ResolveAffectedContexts
    → UpdateDependencyGraph
    → RecomputeDerivedClaims
    → RecheckContradictions
    → UpdateConflictGraph
    → RecomputeDetectionStatus
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

ClaimUpdate :=
    AddedOrRemovedClaim
    ⇒ recheck(
        DirectConflicts,
        DerivedConflicts,
        UnsatCores
    )

ContextUpdate :=
    ChangedTimeOrScope
    ⇒ reevaluate(
        ApparentContradictions,
        ConflictStatus
    )

RuleUpdate :=
    ChangedInferenceRule
    ⇒ recompute(
        DependentDerivations,
        ConflictPaths
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        ContradictionDetectionFlow,
        ContradictionPattern,
        CanonicalContradictionRepresentation,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL := {
    ContradictionEntityResolution,
    NormalisedClaims,
    ContextResolution,
    ConstraintSet,
    DirectConflictStatus,
    DerivedConflictStatus,
    SatisfiabilityStatus,
    ModelStatus,
    UnsatCore,
    ContradictionPath,
    DetectionStatus,
    Confidence,
    Provenance,
    Explanation
}

END_FLOW

END OF AI SEARCH FLOW ALGEBRA