Deontic Logic Ontology

FLOW_ALGEBRA DeonticLogicOntology v1.0

TARGET_URL := "https://kirethresearch.org/booksai-core/ontologies/mathematical-ontologies/mathematical-logic-ontologies/modal-logic/deontic-logic-ontology.html"
LANGUAGE := "en-GB"
DOMAIN := MathematicalOntologies > MathematicalLogicOntologies > ModalLogic > DeonticLogicOntology

BEGIN_FLOW

ENTITY DeonticLogic {
    TYPE := ModalLogicalSystem
    DEFINITION := "A family of formal logics for reasoning about normative concepts such as obligation, permission and prohibition."
}

ENTITY ObligationOperator {
    TYPE := DeonticModalOperator
    FORM := O(P)
    READING := "it is obligatory that P"
}

ENTITY PermissionOperator {
    TYPE := DeonticModalOperator
    FORM := Pm(P)
    READING := "it is permitted that P"
}

ENTITY ProhibitionOperator {
    TYPE := DeonticModalOperator
    FORM := F(P)
    READING := "it is forbidden that P"
}

RELATIONSHIP DeonticLogic --specialises--> ModalLogic
RELATIONSHIP DeonticLogic --reasons_about--> NormativeStatus
RELATIONSHIP ObligationOperator --expresses--> Obligation
RELATIONSHIP PermissionOperator --expresses--> Permission
RELATIONSHIP ProhibitionOperator --expresses--> Prohibition
RELATIONSHIP DeonticLogic --may_use--> KripkeStyleSemantics

SYNTAX {
    Formula :=
        AtomicProposition
        | ¬Formula
        | (Formula ∧ Formula)
        | (Formula ∨ Formula)
        | (Formula → Formula)
        | O(Formula)
        | Pm(Formula)
        | F(Formula)
}

STANDARD_DUALITIES {
    Pm(P) ≡ ¬O(¬P)
    F(P) ≡ O(¬P)
    ¬Pm(P) ≡ O(¬P)
}

ENTITY DeonticFrame {
    FORM := (W,R_D)
    W := NormativeEvaluationWorlds
    R_D := DeonticAccessibilityRelation
}

ENTITY DeonticModel {
    FORM := (W,R_D,V)
    V := Valuation
}

DEONTIC_ACCESSIBILITY {
    R_D(w,v)
    MAY_BE_READ_AS :=
        "v is a normatively admissible/ideal alternative relative to w"

    REQUIRE :=
        exact interpretation declared by selected semantics
}

OBLIGATION_SEMANTICS {
    M,w ⊨ O(P)
    IFF
        FOR_ALL v:
            R_D(w,v) -> M,v ⊨ P
}

PERMISSION_SEMANTICS {
    M,w ⊨ Pm(P)
    IFF
        EXISTS v:
            R_D(w,v)
            AND M,v ⊨ P
}

PROHIBITION_SEMANTICS {
    M,w ⊨ F(P)
    IFF
        M,w ⊨ O(¬P)
}

OBLIGATION_EVALUATION(Model M, World w, Formula P) {
    alternatives := {v | R_D(w,v)}

    FOR_EACH v IN alternatives {
        IF M,v ⊭ P
            RETURN {
                value := FALSE,
                counterexample_world := v
            }
    }

    RETURN {
        value := TRUE,
        counterexample_world := NONE
    }
}

PERMISSION_EVALUATION(Model M, World w, Formula P) {
    alternatives := {v | R_D(w,v)}

    FOR_EACH v IN alternatives {
        IF M,v ⊨ P
            RETURN {
                value := TRUE,
                witness_world := v
            }
    }

    RETURN {
        value := FALSE,
        witness_world := NONE
    }
}

STANDARD_DEONTIC_LOGIC {
    ABBREVIATION := SDL
    BASE := NormalModalLogicK
    ADD := AxiomD
}

AXIOM_K_DEONTIC {
    O(P -> Q) -> (O(P) -> O(Q))
}

AXIOM_D_DEONTIC {
    O(P) -> Pm(P)

    EQUIVALENT_STYLE :=
        O(P) -> ¬O(¬P)

    FRAME_PROPERTY :=
        Seriality
}

SERIALITY {
    FOR_ALL w:
        EXISTS v:
            R_D(w,v)

    PURPOSE :=
        prevents obligation from being vacuously satisfied solely because no ideal/admissible alternatives exist
}

DEONTIC_CONSISTENCY {
    O(P) -> ¬O(¬P)
        under standard D-style consistency assumptions
}

OBLIGATION_VS_TRUTH {
    O(P) -> P
        IS NOT a theorem of standard deontic logic merely from obligation

    REASON :=
        what ought to be true need not be what is actually true
}

PERMISSION_VS_ACTUALITY {
    Pm(P)
        DOES NOT imply
    P is actual

    INTERPRETATION :=
        permission concerns normative admissibility, not actuality
}

PROHIBITION_RELATION {
    F(P) ≡ O(¬P)

    Pm(P) ≡ ¬F(P)
        under standard dual definitions
}

STRONG_PERMISSION {
    TYPE := ExplicitNormativePermission
    NOTE :=
        may require representation beyond weak permission defined as absence of prohibition
}

WEAK_PERMISSION {
    Pm(P) :=
        ¬O(¬P)
}

OBLIGATION_CONJUNCTION {
    O(P ∧ Q) -> O(P) ∧ O(Q)

    IN normal relational semantics:
        O(P ∧ Q) ≡ O(P) ∧ O(Q)
}

PERMISSION_DISJUNCTION {
    Pm(P ∨ Q) ≡
        Pm(P) ∨ Pm(Q)
        under standard existential relational semantics
}

PERMISSION_CONJUNCTION_WARNING {
    Pm(P) ∧ Pm(Q)
        DOES NOT generally imply
    Pm(P ∧ Q)

    REASON :=
        P and Q may be permitted in different accessible alternatives
}

CONFLICT_DETECTION {
    IF O(P) AND O(¬P)
    THEN
        normative_conflict := TRUE

    UNDER SDL_WITH_D:
        such conjunction is inconsistent
}

CONTRARY_TO_DUTY {
    TYPE := ConditionalNormativeStructure

    DESCRIPTION :=
        obligation arising in a context where another obligation has been violated

    WARNING :=
        naive formalisation may generate classic deontic paradoxes
}

CONDITIONAL_OBLIGATION {
    FORM :=
        O(P | Q)

    NOTE :=
        dyadic/conditional deontic logics distinguish this from material implication inside monadic O
}

MONADIC_OBLIGATION {
    FORM := O(P)
}

DYADIC_OBLIGATION {
    FORM := O(P | Q)
    READING := "P ought to hold given Q"
}

RELATIONSHIP DeonticLogic --extends_to--> DyadicDeonticLogic

NORM {
    TYPE := NormativeRule

    MAY_EXPRESS {
        Obligation,
        Permission,
        Prohibition
    }
}

NORMATIVE_RULE_PATTERN {
    CONDITION -> DeonticConclusion
}

NORMATIVE_SYSTEM {
    COMPONENTS := {
        Norms,
        Facts,
        PriorityRelations,
        ConflictResolutionRules
    }

    NOTE :=
        not every deontic logic includes all components
}

NORM_CONFLICT {
    GIVEN norms N1,N2

    IF conclusions impose incompatible normative requirements
    THEN
        conflict := TRUE
}

PRIORITY_RELATION {
    N1 > N2
    MAY mean
        N1 overrides N2

    REQUIRE :=
        explicit defeasible or prioritised deontic framework
}

DEFEASIBLE_DEONTIC_RELATIONSHIP {
    DeonticLogic --may_extend_to--> DefeasibleDeonticLogic

    PURPOSE :=
        model exceptions, priorities and overridable norms
}

DEONTIC_PARADOX_AWARENESS {
    EXAMPLES := {
        ContraryToDutyParadox,
        RossParadox,
        GoodSamaritanParadox,
        FreeChoicePermissionIssues
    }

    REQUIRE :=
        distinguish formal derivability from intended normative interpretation
}

ROSS_STYLE_PATTERN {
    O(P) -> O(P ∨ Q)
        follows in normal modal systems via logical consequence

    WARNING :=
        natural-language normative interpretation may find this unintuitive
}

FREE_CHOICE_PERMISSION {
    NATURAL_LANGUAGE_PATTERN :=
        "P or Q is permitted"

    POSSIBLE_PRAGMATIC_READING :=
        both P and Q individually permitted

    STANDARD_MODAL_LOGIC_WARNING :=
        this reading is not automatically captured by ordinary disjunction semantics
}

ACTION_DEONTIC_LOGIC {
    DeonticLogic --may_reason_about--> Actions

    EXAMPLES {
        obligatory(action)
        permitted(action)
        forbidden(action)
    }
}

STATE_DEONTIC_LOGIC {
    DeonticLogic --may_reason_about--> StatesOfAffairs
}

AGENT_RELATIVE_DEONTIC_OPERATOR {
    O_a(P) :=
        "agent a is obliged that/to ensure P"

    REQUIRE :=
        agent-indexed normative semantics
}

TEMPORAL_DEONTIC_RELATIONSHIP {
    DeonticLogic --combines_with--> TemporalLogic

    PURPOSE :=
        express deadlines, persistent obligations, future permissions and temporal prohibitions
}

DYNAMIC_DEONTIC_RELATIONSHIP {
    DeonticLogic --combines_with--> DynamicLogic

    PURPOSE :=
        reason about normative status of actions and state transitions
}

EPISTEMIC_DEONTIC_RELATIONSHIP {
    DeonticLogic --combines_with--> EpistemicLogic

    PURPOSE :=
        reason about knowledge of obligations, permissions or prohibitions
}

COMPLIANCE {
    TYPE := RelationBetweenBehaviourAndNormativeRequirements

    REQUIRE :=
        explicit definition of applicable norms and satisfaction conditions
}

VIOLATION {
    GIVEN O(P)

    IF actual_or_relevant_behaviour violates P
    THEN
        obligation_violation := TRUE

    CONSTRAINT :=
        violation semantics depends on how actual behaviour is represented
}

FULFILMENT {
    GIVEN O(P)

    IF required normative condition P is satisfied
    THEN
        obligation_fulfilled := TRUE

    REQUIRE :=
        selected compliance semantics
}

MODEL_CHECK_DEONTIC(Model M, World w, Formula Fml) {
    IF atomic:
        RETURN valuation_at(w,Fml)

    IF BooleanFormula:
        EVALUATE recursively

    IF Fml=O(P):
        RETURN OBLIGATION_EVALUATION(M,w,P)

    IF Fml=Pm(P):
        RETURN PERMISSION_EVALUATION(M,w,P)

    IF Fml=F(P):
        RETURN OBLIGATION_EVALUATION(M,w,NOT(P))
}

OBLIGATION_COUNTEREXAMPLE {
    IF M,w ⊭ O(P)
    THEN
        EXISTS v:
            R_D(w,v)
            AND M,v ⊭ P

    v := deontic_counterexample_world
}

PERMISSION_WITNESS {
    IF M,w ⊨ Pm(P)
    THEN
        EXISTS v:
            R_D(w,v)
            AND M,v ⊨ P

    v := deontic_permission_witness
}

APPLICATION_RELATIONSHIPS {
    DeonticLogic --supports--> NormativeReasoning
    DeonticLogic --supports--> LegalKnowledgeRepresentation
    DeonticLogic --supports--> PolicyReasoning
    DeonticLogic --supports--> ComplianceChecking
    DeonticLogic --supports--> MultiAgentSystems
    DeonticLogic --supports--> ArtificialIntelligence
    DeonticLogic --supports--> EthicsFormalisation
    DeonticLogic --supports--> ProtocolSpecification
    DeonticLogic --supports--> AccessControlReasoning
}

ONTOLOGY_LINKS {
    PARENT := ModalLogicOntology

    RELATED := {
        NecessityOntology,
        PossibilityOntology,
        PossibleWorldsOntology,
        DynamicLogicOntology,
        TemporalLogicOntology,
        EpistemicLogicOntology,
        NormOntology,
        ObligationOntology,
        PermissionOntology,
        ProhibitionOntology,
        RuleOntology,
        LegalLogicOntology,
        ComplianceOntology
    }
}

SEMANTIC_EQUIVALENCE {
    O(P) ≈ Obligatory(P)
    Pm(P) ≈ Permitted(P)
    F(P) ≈ Forbidden(P)

    Pm(P) ≈ ¬O(¬P)
        WHEN weak_permission_semantics

    F(P) ≈ O(¬P)
        WHEN standard_prohibition_definition

    DeonticAccessibleWorld ≈ NormativelyAdmissibleWorld
        WHEN selected_semantics_defines_R_D_that_way
}

CONSTRAINTS {
    C1 :=
        deontic operators MUST be interpreted relative to an explicit normative semantics

    C2 :=
        obligation MUST NOT automatically imply actuality

    C3 :=
        permission MUST NOT automatically imply actual performance

    C4 :=
        weak permission and explicit/strong permission MUST NOT be conflated

    C5 :=
        O(P) and O(¬P) MUST be treated as a normative conflict under consistency-oriented systems

    C6 :=
        standard SDL inferences MUST NOT be assumed for non-normal or alternative deontic systems

    C7 :=
        conditional obligations MUST NOT automatically be reduced to O(Q -> P)

    C8 :=
        normative priorities MUST be used only when an overriding framework defines them

    C9 :=
        natural-language pragmatic readings MUST be distinguished from formal derivability

    C10 :=
        permission MUST NOT be interpreted as probability or mere physical possibility

    C11 :=
        compliance and violation claims MUST identify the relevant normative and behavioural semantics

    C12 :=
        all transformations MUST preserve the selected deontic system
}

REASONING_CHAIN Query Q {
    IDENTIFY deontic_logic_system
    IDENTIFY normative_operator
    IDENTIFY formula P
    IDENTIFY current_world_or_context
    IDENTIFY normative_semantics

    PARSE deontic_formula

    RESOLVE {
        PermissionDuality,
        ProhibitionDefinition,
        ObligationRelations
    }

    IF obligation_requested
        THEN OBLIGATION_EVALUATION

    IF permission_requested
        THEN PERMISSION_EVALUATION

    IF prohibition_requested
        THEN evaluate O(NOT(P))

    IF normative_conflict_requested
        THEN detect incompatible_obligations

    IF conditional_obligation_present
        THEN identify dyadic_or_other_conditional_semantics

    IF priority_rules_present
        THEN apply only declared_override_framework

    IF compliance_requested
        THEN identify applicable_norms_and_behaviour

    IF counterexample_requested
        THEN search_for OBLIGATION_COUNTEREXAMPLE

    IF witness_requested
        THEN search_for PERMISSION_WITNESS

    VALIDATE constraints
    RETURN result WITH derivation
}

CONFIDENCE {
    CORE_DEONTIC_OPERATORS := 1.00
    STANDARD_RELATIONAL_SEMANTICS := 0.99
    SDL_K_AND_D := 1.00
    WEAK_PERMISSION_DUALITY := 1.00

    MODEL_CHECKING :=
        IF complete_deontic_model_given THEN 1.00
        ELSE REQUIRE missing_information

    NATURAL_LANGUAGE_NORMATIVE_INTERPRETATION :=
        REQUIRE contextual_validation

    ALTERNATIVE_DEONTIC_SYSTEM :=
        REQUIRE explicit_system_definition
}

UPDATE_MODEL {
    IMMUTABLE_CORE := {
        ObligationConcept,
        PermissionConcept,
        ProhibitionConcept,
        DeonticModalDistinctions
    }

    EXTENSIBLE := {
        DeonticSystems,
        ConditionalObligations,
        PriorityFrameworks,
        DefeasibleNorms,
        TemporalDeonticExtensions,
        DynamicDeonticExtensions,
        ComplianceSemantics,
        ApplicationDomains,
        RelatedOntologies
    }

    ON_NEW_KNOWLEDGE {
        IDENTIFY normative_framework
        VALIDATE operator_semantics
        VALIDATE accessibility_or_rule_structure
        CHECK normative_consistency
        CHECK conditional_structure
        CHECK semantic_consistency
        ADD relationship IF non_contradictory
        UPDATE confidence
    }
}

AI_CONSUMPTION {
    MACHINE_READABLE := TRUE
    HUMAN_INTERPRETABLE := TRUE
    RECURSIVE_REASONING := TRUE
    ENTITY_RESOLUTION := TRUE
    NORM_RESOLUTION := TRUE
    SYMBOL_RESOLUTION := TRUE
    RELATIONSHIP_TRAVERSAL := TRUE
    OBLIGATION_REASONING := TRUE
    PERMISSION_REASONING := TRUE
    PROHIBITION_REASONING := TRUE
    NORM_CONFLICT_DETECTION := TRUE
    COMPLIANCE_REASONING := TRUE
    WITNESS_WORLD_DETECTION := TRUE
    COUNTEREXAMPLE_WORLD_DETECTION := TRUE
    VALIDATION_REQUIRED := TRUE
}

FLOW_HASH {
    TARGET := TARGET_URL
    SUBJECT := "Deontic Logic Ontology"
    VERSION := "1.0"
    CANONICAL_SIGNATURE :=
        HASH(TARGET + SUBJECT + DOMAIN + VERSION)
}

OUTPUT {
    PRIMARY_ENTITY := DeonticLogic

    INTERPRETATION :=
        "Deontic logic applies modal-style formal reasoning to normative concepts such as obligation, permission and prohibition. Its semantics distinguish what ought to hold from what actually holds, support analysis of normative alternatives and conflicts, and provide formal structures for rules, compliance, conditional obligations and specialised normative systems."
}

END_FLOW