Deontology

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, bad, or neutral. 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. The relation between neutrality and permission is a bit more complicated because one ought to be permitted to do that which is obliged. That which is neither obliged nor prohibited is ‘purely’ permitted; that which is neither good nor bad is morally neutral. 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 MorallyNeutral 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 neutral. 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.

(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 MorallyNeutral)
      (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 MorallyNeutral)))))

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))))

As mentioned above, nuances in the relation between permission and moral neutrality can be expressed via the interpretation functions between value judgment and imperative theories. However, if SUMO contains a rule that obligation implies permission, then one doesn’t need to build this into the interpretation directly.

(=>
      (equal ?DEONTIC Permission)
      (equal ?VJS 
        (or
          (modalAttribute ?RULE MorallyGood)
          (modalAttribute ?RULE MorallyNeutral))))

The interpretation that a permitted rule only be translated to moral neutrality if it is not also obliged cannot be done without including the full theory as an argument. This could be necessary because neutrality and good might be contrary attributes whereas permission and obligation can overlap. Perhaps one lesson is that my personal addition of the concept of “moral neutrality” is weak and should be dropped. Instead, the conversion could be to translate permission into “not morally bad”.

(=>
  (equal ?DEONTIC Permission)
  (equal ?VJS 
    (not
      (modalAttribute ?RULE MorallyBad))))

In working with logic, it is common to translate theories into normal forms that are easier to algorithmically process. Transforming all permission statements into terms of prohibition could ease the translation into the value judgment language.