Deontology

by Posted on

Deontology is the ethical paradigm that judges the morality of an action based on the action’s adherence to a set of rules and principles.

Deontology is the branch of ethics concerned with the nature of duty and obligation.

Oxford Reference

Discussion

The deontological paradigm aligns very well with logic because any ethical statement in SUMO will technically be in the form of a rule, the adherence to which can be judged. Definitionally, ‘duty’ is roughly synonymous with ‘obligation’. The granularity of judgments can be significant: adherence to a rule could be good yet optional. The standard deontic operators of obligation, prohibition, and permission do not bother with this level of granularity. Non-obligatory good is simply permissible.

In SUMO, I decided to split deontology into two types of theories: Imperative Theories and Value Judgment Theories. The imperative theories are simply those that concern themselves with the standard deontic operators. The value judgment theories are those that assign value judgments, such as good and bad. There is a philosophically strong trivial mapping between them: consider X as good if and only if X is obligatory and X as bad if and only if X is prohibited. I’ve added the notion of moral permissibility to the value judgment language to simplify the correspondence1To my surprise, there is a paper by Gustafsson arguing that Permissibility Is the Only Feasible Deontic Primitive.. If there are varying degrees of goodness, these can correlate with the varying degrees of obligation. This simple correspondence justifies considering value judgment theories to be deontological of nature.

SUMO

(documentation Deontology EnglishLanguage "Deontology is the ethical paradigm that judges the morality of an action based on the action's adherence to a set of rules and principles.")
(subclass Deontology Ethics)

(documentation DeontologicalTheory EnglishLanguage "A set of sentences assigning moral or deontic attributes.")
(subclass DeontologicalTheory EthicalTheory)

(theoryFieldPairSubclass Deontology DeontologicalTheory)

(documentation DeontologicalSentence EnglishLanguage "A sentence of a deontological language/theory.")      
(subclass DeontologicalSentence EthicalSentence)

Deontology is defined as a proposition and a deontological theory is defined as a set of sentences. They are paired together in the sense that for every deontological philosophy, there is a theory that contains its information. Thus we can discuss the syntactic theories.

(documentation ValueJudgmentTheory EnglishLanguage "A set of sentences assigning moral attributes.")
(subclass ValueJudgmentTheory EthicalTheory)

(documentation ValueJudgmentSentence EnglishLanguage "A sentence that describes the attribution of a moral value judgment.")      
(subclass ValueJudgmentSentence EthicalSentence)

(documentation SimpleValueJudgmentSentence EnglishLanguage "A sentence that describes the attribution of a moral value judgment.")      
(subclass SimpleValueJudgmentSentence ValueJudgmentSentence)

(documentation MoralValueAttribute EnglishLanguage "Moral Value Attributes are a subclass of Moral Attributes dealing with the attribution of value: whether something is good, bad, or netural.")
(subclass MoralValueAttribute MoralAttribute)

(instance MorallyGood MoralValueAttribute)
(instance MorallyBad MoralValueAttribute)
(instance MorallyPermissible MoralValueAttribute)

(<=>
  (instance ?SENTENCE SimpleValueJudgmentSentence)
  (exists (?F ?MORALATTRIBUTE)
    (and
      (equal (modalAttribute ?F ?MORALATTRIBUTE) ?SENTENCE)
      (instance ?F Formula)
      (instance ?MORALATTRIBUTE MoralValueAttribute))))

(<=>
  (instance ?SENTENCE ValueJudgmentSentence)
  (exists (?VJS)
    (and
      (instance ?VJS SimpleValueJudgmentSentence)
      (part ?VJS ?SENTENCE))))

(=>
  (instance ?D ValueJudgmentTheory)
  (forall (?S)
    (=>
      (element ?S ?D)
      (or
        (instance ?S ValueJudgmentSentence)
        (exists (?VJS)
          (and
            (instance ?VJS ValueJudgmentSentence)
            (hasPurposeInArgumentFor ?S ?VJS))))))

Value judgment theories are a subclass of ethical theories and their sentences are ethical sentences. The moral value attributes are good, bad, and permissible. Simple value judgment sentences take the form, “so-and-so formula is such-and-such moral value attribute”, e.g., “it is bad that foxes are red”. Generic value judgment sentences are those that contain a simple value judgment sentence as a part. The SUMO knowledge base doesn’t have an adequate way to define a precise formal language for ethical theories, and this may be a good thing on the ontological level where this meaning postulate should hold whether the sentences are in HOL or English.

One can add lemmas to require that formulas describe an action directly. One can also define lemmas stating that “if a type of situation is bad, then it is bad to cause such a situation.” These will be generic value judgment sentences of a theory.

(documentation DeontologicalImperativeTheory EnglishLanguage "A set of sentences containing deontic attributes.")
(subclass DeontologicalImperativeTheory DeontologicalTheory)

(documentation ImperativeSentence EnglishLanguage "A sentence that describes an imperative deontic operator.")      
(subclass ImperativeSentence DeontologicalSentence)    

(documentation SimpleImperativeSentence EnglishLanguage "A sentence that describes an imperative deontic operator.")      
(subclass SimpleImperativeSentence ImperativeSentence)

(documentation DeonticAttribute EnglishLanguage "A Class containing all of the Attributes relating to the notions of permission, obligation, and prohibition.")	
(subclass DeonticAttribute ObjectiveNorm)

(instance Obligation DeonticAttribute)
(instance Permission DeonticAttribute)
(instance Prohibition DeonticAttribute)

(<=>
  (instance ?SENTENCE SimpleImperativeSentence)
  (exists (?F ?DEONTICATTRIBUTE)
        (and
          (equal (modalAttribute ?F ?DEONTICATTRIBUTE) ?SENTENCE)
          (instance ?F Formula)
          (instance ?DEONTICATTRIBUTE DeonticAttribute))))

(<=>
  (instance ?SENTENCE ImperativeSentence)
  (exists (?IT)
    (and
      (instance ?IT SimpleImperativeSentence)
      (part ?IT ?SENTENCE))))

(<=>
  (instance ?DIT DeontologicalImperativeTheory)
  (forall (?S)
    (=>
      (element ?S ?DIT)
      (or
        (instance ?S ImperativeSentence)
        (exists (?IS)
          (and
            (instance ?IS ImperativeSentence)
            (hasPurposeInArgumentFor ?S ?IS)))))))

Imperative theories are deontological theories whose sentences are deontological sentences or have the purpose of being used in an argument for an imperative sentence.. The deontic attributes are obligation, permission, and prohibition. A simple imperative sentence is of the form, “F is D”, where F is a formula and D is a deontic attribute. A generic imperative sentence is one that contains a simple imperative sentence.

The trivial way to translate between the value judgment sentences and imperative sentences is presented below.

(documentation SimpleValueJudgmentToImperativeSentenceFn EnglishLanguage "A UnaryFunction that maps simple value judgment sentences into imperative sentences.")
(domain SimpleValueJudgmentToImperativeSentenceFn 1 SimpleValueJudgmentSentence)
(range SimpleValueJudgmentToImperativeSentenceFn SimpleImperativeSentence)
(instance SimpleValueJudgmentToImperativeSentenceFn TotalValuedRelation)
(instance SimpleValueJudgmentToImperativeSentenceFn UnaryFunction)

(=> 
  (and 
    (equal (SimpleValueJudgmentToImperativeSentenceFn ?VJS) ?ITS)
    (equal ?VJS (modalAttribute ?SITUATION ?MORALATTRIBUTE))
    (instance ?SITUATION Formula)
    (instance ?MORALATTRIBUTE MoralAttribute))
  (and
    (=>
      (equal ?MORALATTRIBUTE MorallyGood)
      (equal ?ITS 
        (modalAttribute ?SITUATION Obligation)))
    (=>
      (equal ?MORALATTRIBUTE MorallyBad)
      (equal ?ITS
        (modalAttribute ?SITUATION Prohibition)))
    (=>
      (equal ?MORALATTRIBUTE MorallyPermissible)
      (equal ?ITS
        (modalAttribute ?SITUATION Permission)))))
(documentation SimpleImperativeToValueJudgmentSentenceFn EnglishLanguage "A UnaryFunction that maps simple imperative sentences into value judgment sentences in a very generic manner.")
(domain SimpleImperativeToValueJudgmentSentenceFn 1 SimpleImperativeSentence)
(range SimpleImperativeToValueJudgmentSentenceFn SimpleValueJudgmentSentence)
(instance SimpleImperativeToValueJudgmentSentenceFn TotalValuedRelation)
(instance SimpleImperativeToValueJudgmentSentenceFn UnaryFunction)

(=> 
  (and 
    (equal (SimpleImperativeToValueJudgmentSentenceFn ?ITS) ?VJS)
    (equal ?ITS (modalAttribute ?RULE ?DEONTIC))
    (instance ?RULE Formula)
    (instance ?DEONTIC DeonticAttribute))
  (and
    (=>
      (equal ?DEONTIC Obligation)
      (equal ?VJS
        (modalAttribute ?RULE MorallyGood)))
    (=>
      (equal ?DEONTIC Prohibition)
      (equal ?VJS
        (modalAttribute ?RULE MorallyBad)))
    (=>
      (equal ?DEONTIC Permission)
      (equal ?VJS 
        (modalAttribute ?RULE MorallyPermissible)))))

One can define inverse mappings from simple value judgments to imperatives and vice versa.

(=> 
  (instance ?S SimpleValueJudgmentSentence)
  (equal ?S 
    (SimpleImperativeToValueJudgmentSentenceFn (SimpleValueJudgmentToImperativeSentenceFn ?S))))

(=> 
  (instance ?S SimpleImperativeSentence)
  (equal ?S
    (SimpleValueJudgmentToImperativeSentenceFn (SimpleImperativeToValueJudgmentSentenceFn ?S))))