Verification Condition Ontology

AI SEARCH FLOW ALGEBRA — VERIFICATION CONDITION ONTOLOGY
Kireth Research — Semantic Library
URL: https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/formal-verification/verification-condition-ontology.html

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

BEGIN_FLOW

VerificationCondition :=
    LogicalFormula
    ∧ DerivedFrom(Program, Specification)
    ∧ ProofObligation
    ∧ RequiredFor(Correctness)

VerificationConditionPurpose :=
    ReduceProgramCorrectness
    → LogicalValidityProblems
    → AutomatedOrInteractiveProof

Program :=
    {
        Statement,
        Expression,
        Procedure,
        Function,
        Module,
        TransitionSystem,
        Algorithm,
        SoftwareComponent
    }

Specification :=
    Preconditions
    ∧ Postconditions
    ∧ Invariants
    ∧ Assertions
    ∧ Contracts
    ∧ SafetyProperties

ProgramState :=
    Mapping(Variables, Values)

Assertion :=
    Predicate(ProgramState)

Precondition :=
    Predicate(StateBeforeExecution)

Postcondition :=
    Predicate(StateAfterExecution)

Invariant :=
    Predicate
    ∧ preserved_by(Execution)

HoareTriple :=
    {P} C {Q}

HoareMeaning :=
    P holds before C
    ∧ C executes
    ⇒ Q holds after C

PartialCorrectness :=
    terminates(C)
    ∧ P
    ⇒ Q

TotalCorrectness :=
    PartialCorrectness
    ∧ Termination

WeakestPrecondition :=
    wp(C,Q)

WeakestPreconditionMeaning :=
    weakest(P)
    such_that
    {P} C {Q}

VerificationConditionBasic :=
    P ⇒ wp(C,Q)

StrongestPostcondition :=
    sp(P,C)

VerificationConditionGeneration :=
    Program
    ∧ Specification
    →
    Set{
        VC1,
        VC2,
        ...,
        VCn
    }

VCGenerator :=
    SyntaxDirectedTransformation
    ∧ SemanticRules
    ∧ ContractInformation

VCGenerationFlow :=
    ParseProgram
    → BuildControlFlow
    → AttachSpecifications
    → PropagateAssertions
    → GenerateLogicalObligations
    → Simplify
    → SubmitToProver

AssignmentRule :=
    wp(x := E, Q)
    =
    Q[x ← E]

SequenceRule :=
    wp(C1 ; C2, Q)
    =
    wp(C1, wp(C2,Q))

ConditionalRule :=
    wp(
        if B then C1 else C2,
        Q
    )
    =
    (B ⇒ wp(C1,Q))
    ∧
    (¬B ⇒ wp(C2,Q))

AssertionRule :=
    wp(assert P, Q)
    =
    P ∧ Q

AssumptionRule :=
    wp(assume P, Q)
    =
    P ⇒ Q

SkipRule :=
    wp(skip,Q)
    =
    Q

Loop :=
    while B do C

LoopInvariant :=
    I

LoopVerificationConditions :=
    {
        InitialisationVC,
        PreservationVC,
        ExitVC
    }

InitialisationVC :=
    P ⇒ I

PreservationVC :=
    I
    ∧ B
    ⇒ wp(C,I)

ExitVC :=
    I
    ∧ ¬B
    ⇒ Q

TerminationVariant :=
    V : State → WellFoundedSet

TerminationVC :=
    I
    ∧ B
    ⇒
    V ≥ 0
    ∧ V_after < V_before

ProcedureContract :=
    Requires
    ∧ Ensures
    ∧ Modifies

CallRule :=
    CallerState
    ⇒ CalleePrecondition

ReturnRule :=
    CalleePostcondition
    ⇒ CallerContinuationCondition

FrameCondition :=
    VariablesNotModified
    retain
    PreviousValues

FunctionCorrectness :=
    FunctionPrecondition
    ⇒ FunctionPostcondition

ModularVerification :=
    VerifyEachComponent
    using
    ComponentContract
    rather_than
    FullImplementationOfDependencies

ProofObligation :=
    Formula
    ∧ must_be_valid

VCValidity :=
    ⊨ VerificationCondition

VCSatisfiabilityRelation :=
    VC valid
    iff
    ¬VC unsatisfiable

InvalidVC :=
    ∃Interpretation I :
        I ⊭ VC

Countermodel :=
    Model
    ∧ satisfies(¬VC)

Counterexample :=
    Countermodel
    → candidate(ProgramExecutionViolatingSpecification)

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

AutomatedDischarge :=
    VerificationCondition
    → SMTProver
    ∨ SATSolver
    ∨ AutomatedTheoremProver
    ∨ DecisionProcedure

InteractiveDischarge :=
    VerificationCondition
    → InteractiveTheoremProver
    → HumanGuidedProof

SMTEncoding :=
    LogicalFormula
    ∧ BackgroundTheories

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

SMTDischarge :=
    check_sat(¬VC)

SMTResult :=
    {
        UNSAT ⇒ VCValid,
        SAT ⇒ VCInvalidOrCountermodelFound,
        UNKNOWN ⇒ VCUndetermined
    }

SATEncoding :=
    Booleanise(VerificationCondition)
    → PropositionalFormula

TheoremProving :=
    Axioms
    ∧ Assumptions
    ⊢ VerificationCondition

LogicalContext :=
    Γ

ProofGoal :=
    Γ ⊢ VC

ContextAssumption :=
    Formula ∈ Γ

VCNormalisation :=
    Parse
    → TypeCheck
    → ExpandDefinitions
    → Simplify
    → NormalForm

NormalForms :=
    {
        CNF,
        DNF,
        PrenexNormalForm,
        SSAForm,
        SolverSpecificForm
    }

StaticSingleAssignment :=
    eachVariableAssignedOncePerVersion

SSAConversion :=
    Program
    → VersionedVariables
    → PhiFunctions
    → ConstraintSystem

PathCondition :=
    Conjunction(BranchConditionsAlongPath)

PathVerificationCondition :=
    PathCondition
    ⇒ RequiredPostcondition

SymbolicExecution :=
    Program
    → SymbolicStates
    → PathConditions
    → VerificationConditions

SymbolicState :=
    SymbolicVariableBindings
    ∧ PathCondition

PathExplosion :=
    NumberOfPaths grows rapidly
    with BranchingStructure

VCOptimisation :=
    {
        Simplification,
        CommonSubexpressionElimination,
        LemmaReuse,
        PathMerging,
        IncrementalSolving,
        ConstraintSlicing
    }

ConstraintSlicing :=
    VC
    → RelevantConstraintsOnly

DependencyAnalysis :=
    GoalVariables
    → DataDependencies
    → RelevantAssertions

SafetyVerificationCondition :=
    ReachableState
    ⇒ SafetyPredicate

InvariantVerificationCondition :=
    Initialisation
    ∧ Preservation

RefinementVerificationCondition :=
    ConcreteBehaviour
    ⇒ AbstractAllowedBehaviour

EquivalenceVerificationCondition :=
    InputsEquivalent
    ⇒ OutputsEquivalent

InformationFlowVC :=
    LowEquivalentInputs
    ⇒ LowEquivalentOutputs

MemorySafetyVC :=
    MemoryAccess
    ⇒ ValidAddress
    ∧ CorrectBounds
    ∧ RequiredPermission

ArrayBoundsVC :=
    ArrayAccess(a,i)
    ⇒ 0 ≤ i < length(a)

NullSafetyVC :=
    Dereference(x)
    ⇒ x ≠ null

ArithmeticSafetyVC :=
    ArithmeticOperation
    ⇒ noForbiddenOverflow
    ∧ noDivisionByZero

ContractVC :=
    Precondition
    ∧ OperationSemantics
    ⇒ Postcondition

AssumeGuaranteeVC :=
    EnvironmentAssumption
    ⇒ ComponentGuarantee

ConcurrencyVC :=
    InterferenceConditions
    ∧ Invariants
    ⇒ RequiredConcurrentProperty

RelyGuaranteeVC :=
    RelyCondition
    ∧ ComponentStep
    ⇒ GuaranteeCondition

InductiveVC :=
    BaseCase
    ∧ InductiveStep

BaseCase :=
    InitialState
    ⇒ Property

InductiveStep :=
    Property(s)
    ∧ Transition(s,s')
    ⇒ Property(s')

ReachabilityVC :=
    Reachable(s)
    ⇒ RequiredProperty(s)

VCComposition :=
    VC1
    ∧ VC2
    ∧ ...
    ∧ VCn

ProgramVerified :=
    ∀VC ∈ GeneratedVCs :
        Valid(VC)

VerificationFailure :=
    ∃VC ∈ GeneratedVCs :
        Invalid(VC)

VerificationIncomplete :=
    ∃VC ∈ GeneratedVCs :
        Status(VC) ∈ {Unknown, Timeout, Unsupported}

SoundVCGeneration :=
    AllGeneratedVCsValid
    ⇒ ProgramSatisfiesSpecification

CompleteVCGeneration :=
    ProgramSatisfiesSpecification
    ⇒ AllRequiredVCsProvable
    under_defined_logic_and_semantics

Soundness :=
    ProofOfVC
    must_imply
    TargetCorrectnessClaim

TrustedComputingBase :=
    {
        Parser,
        TypeChecker,
        VCGenerator,
        LogicalEncoding,
        ProofChecker,
        SolverInterface
    }

ProofCertificate :=
    MachineCheckableEvidence
    supporting
    VCValidity

UnsatCore :=
    SubsetOfConstraints
    sufficient_for(Unsatisfiability)

CounterexampleModel :=
    Assignment
    ∧ satisfies(¬VC)

DiagnosticMapping :=
    Countermodel
    → SourceVariables
    → ProgramLocation
    → FailedSpecification

Traceability :=
    SourceRequirement
    → ProgramAssertion
    → VerificationCondition
    → SolverResult
    → VerificationEvidence

VerificationEvidence :=
    {
        Proof,
        ProofCertificate,
        SolverResult,
        Countermodel,
        DiagnosticTrace
    }

VCProvenance :=
    SourceProgramLocation
    ∧ SourceSpecification
    ∧ GenerationRule
    ∧ TransformationHistory

VCIdentifier :=
    StableID(
        SourceLocation,
        SpecificationElement,
        GenerationContext
    )

VCVersion :=
    ProgramVersion
    ∧ SpecificationVersion
    ∧ GeneratorVersion

IncrementalVerification :=
    ChangedProgramElements
    → IdentifyAffectedVCs
    → RegenerateAffectedVCs
    → ReuseUnaffectedProofs

Caching :=
    FLOW_HASH(VC)
    → PreviousVerificationResult

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

CoreClasses :=
    {
        VerificationCondition,
        Program,
        ProgramState,
        Specification,
        Precondition,
        Postcondition,
        Invariant,
        Assertion,
        Loop,
        Procedure,
        Contract,
        ProofObligation,
        Solver,
        Proof,
        Countermodel,
        VerificationResult,
        VerificationEvidence
    }

CoreRelations :=
    {
        generatedFrom,
        requires,
        ensures,
        preserves,
        implies,
        proves,
        discharges,
        violates,
        dependsOn,
        derivedBy,
        tracesTo,
        verifiedBy
    }

TypedRelations :=
    VerificationCondition --generatedFrom--> Program
    VerificationCondition --generatedFrom--> Specification
    Procedure --requires--> Precondition
    Procedure --ensures--> Postcondition
    Loop --preserves--> Invariant
    Solver --discharges--> VerificationCondition
    Proof --proves--> VerificationCondition
    Countermodel --violates--> VerificationCondition
    VerificationCondition --tracesTo--> SourceRequirement
    VerificationResult --verifiedBy--> Solver

InferenceRules := {
    Valid(P ⇒ wp(C,Q))
        ⇒ HoareTriple({P} C {Q}),

    Valid(InitialisationVC)
        ∧ Valid(PreservationVC)
        ∧ Valid(ExitVC)
        ⇒ LoopPartiallyCorrect,

    LoopPartiallyCorrect
        ∧ Valid(TerminationVC)
        ⇒ LoopTotallyCorrect,

    ∀VC ∈ GeneratedVCs : Valid(VC)
        ∧ SoundVCGeneration
        ⇒ ProgramSatisfiesSpecification,

    SAT(¬VC)
        ⇒ Invalid(VC),

    UNSAT(¬VC)
        ⇒ Valid(VC),

    Countermodel(¬VC)
        ⇒ candidate(Counterexample),

    ProgramOrSpecificationChanged
        ⇒ DependentVCsRequireRevalidation
}

SemanticMeaning :=
    VerificationCondition
    → LogicalConstraintOnProgramBehaviour

SEMANTIC_EQUIVALENCE(VC_A, VC_B) :=
    Models(VC_A)
    =
    Models(VC_B)

LogicalEquivalence :=
    ⊨ (VC_A ↔ VC_B)

VCSubsumption :=
    VC_A ⊨ VC_B

StrongerVC :=
    Models(VC_A)
    ⊆ Models(VC_B)

WeakerVC :=
    Models(VC_A)
    ⊇ Models(VC_B)

VCConflict :=
    Context
    ∧ VerificationCondition
    is_unsatisfiable
    where satisfiability_was_expected

CanonicalVCRepresentation :=
    Parse(VC)
    → TypeNormalise
    → AlphaRename
    → Simplify
    → CanonicalLogicalForm

VerificationConditionGraph :=
    G = (V,E)

V :=
    {
        Programs,
        Specifications,
        Assertions,
        Preconditions,
        Postconditions,
        Invariants,
        VerificationConditions,
        Solvers,
        Proofs,
        Countermodels,
        Evidence
    }

E :=
    {
        generatedFrom,
        requires,
        ensures,
        preserves,
        implies,
        discharges,
        proves,
        violates,
        dependsOn,
        tracesTo
    }

CONFIDENCE(VerificationCondition) :=
    weighted_mean(
        SpecificationPrecision,
        SemanticEncodingQuality,
        VCGeneratorSoundness,
        SolverReliability,
        ProofEvidenceStrength,
        Traceability
    )

ConfidenceFactors :=
    {
        SourceSpecificationQuality,
        TypeCorrectness,
        EncodingSoundness,
        SolverStatus,
        ProofCertificateAvailability,
        DependencyCoverage,
        ProvenanceQuality
    }

AI_QUERY_INTERPRETATION :=
    Query
    → DetectVerificationConditionConcept
    → ResolveProgramContext
    → ResolveSpecificationContext
    → IdentifyRequiredCorrectnessProperty
    → ResolveLogicalObligation

AI_REASONING_FLOW :=
    Query
    → IdentifyProgramOrModel
    → IdentifySpecification
    → ExtractPreconditions
    → ExtractPostconditions
    → ExtractInvariants
    → BuildSemanticRepresentation
    → GenerateVerificationConditions
    → SimplifyLogicalObligations
    → SelectSolverOrProofMethod
    → EvaluateVCs
    → InterpretCountermodels
    → AggregateVerificationStatus
    → ProduceEvidence
    → ExplainResult

AI_CONSUMPTION :=
    {
        ParseVCEntities,
        ParseTypedRelations,
        ResolveProgramSemantics,
        ResolveContracts,
        GenerateProofObligations,
        FollowDependencies,
        CompareVerificationConditions,
        InterpretSolverResults,
        MapCountermodelsToSource,
        FollowTraceability,
        GenerateFormalExplanation
    }

UPDATE_MODEL :=
    NewProgramOrSpecificationEvidence
    → ValidateInput
    → IdentifyAffectedDependencies
    → RegenerateAffectedVCs
    → ReevaluateLogicalStatus
    → UpdateVerificationConditionGraph
    → RecomputeVerificationStatus
    → RecomputeConfidence
    → PreserveProvenance
    → VersionModel

SolverResultUpdate :=
    ValidProof
    ⇒ mark(VC, Valid)

CountermodelUpdate :=
    ValidCountermodel
    ⇒ mark(VC, Invalid)

UnknownResultUpdate :=
    SolverUnknown
    ∨ Timeout
    ⇒ mark(VC, Undetermined)

SourceChange :=
    ProgramChange
    ∨ SpecificationChange
    ∨ SemanticModelChange
    ⇒ invalidate_or_recheck(
        DependentVerificationConditions
    )

FLOW_HASH_INPUT :=
    canonical(
        ONTOLOGY,
        CoreClasses,
        CoreRelations,
        InferenceRules,
        VerificationConditionGeneration,
        WeakestPrecondition,
        VCValidity,
        AI_REASONING_FLOW
    )

FLOW_HASH :=
    HASH(FLOW_HASH_INPUT)

OUTPUT_MODEL :=
    {
        VerificationConditionResolution,
        LogicalMeaning,
        ProgramSpecificationRelations,
        GeneratedProofObligations,
        SolverStatus,
        CountermodelStatus,
        VerificationStatus,
        Evidence,
        Confidence,
        Provenance,
        Explanation
    }

END_FLOW

END OF AI SEARCH FLOW ALGEBRA