www:

www:
DEON’02 SUBMISSION
------------------------------Authors’ Names:
Alan S. Abrahams and Jean M. Bacon
Authors’ Affiliation:
University of Cambridge Computer Laboratory
Authors’ Address:
William Gates Building
15 JJ Thomson Avenue
Cambridge CB3 0FD
UK
Authors’ Email Addresses:
Primary contact:
Secondary contact:
alan.abrahams@cl.cam.ac.uk
jean.bacon@cl.cam.ac.uk
Article Title:
The Life and Times of Identified, Situated, and Conflicting Norms
Abstract:
In this paper we argue for a treatment of obligations, permissions, and prohibitions that differs from the
standard treatment of these notions in deontic logic. Firstly, we propose that instantiated norms be treated as
individual, identified entities - that is, variables that can be quantified over - rather than simply as logical
operators as in Standard Deontic Logic. This allows us to refer to specific instances of obligations,
permissions, and prohibitions. We explain why we believe that norms take, as their arguments, sets of
occurrences, rather than simply propositions as in the standard treatment. Further, we argue that specific,
identified norms themselves are brought about by occurrences. We provide an account of the life-cycle of
norms: we explain how individual identified norm-instances are generated from general norms through
functions of occurrences, and how each such instance’s life may end with its fulfillment, violation, or
nullification. In addition, we suggest that norms are situated: that they must be tagged with the context in
which they were written or spoken. This is necessary for conflict specification, detection, and resolution
purposes. Finally, we tag our conclusions with a time, so that, without contradiction, we may nonmonotonically conclude different results as cases and norms vary over time.
The Life and Times of Identified, Situated, and Conflicting Norms
1
Introduction
In this paper we argue for a treatment of obligations, permissions, and prohibitions that differs from the
standard treatment of these notions in deontic logic. Firstly, in Section 2, we propose that instantiated
norms be treated as individual, identified entities - that is, variables that can be quantified over - rather
than simply as logical operators as in Standard Deontic Logic. This allows us to refer to specific instances
of obligations, permissions, and prohibitions. We explain why we believe that norms take, as their
arguments, sets of occurrences, rather than simply propositions as in the standard treatment. Further, we
argue that specific, identified norms themselves are brought about by occurrences. In Section 3, we
provide an account of the life-cycle of norms: we explain how individual identified norm-instances are
generated from general norms through functions of occurrences, and how each such instance’s life may
end with its fulfillment, violation, or nullification. In addition, we suggest (Section 4) that norms are
situated: that they must be tagged with the context in which they were written or spoken. This is
necessary for conflict specification, detection, and resolution purposes (Section 5). Finally, in Section 6,
we tag our conclusions with a time, so that, without contradiction, we may non-monotonically conclude
different results as cases and norms vary over time.
2
Identity
In this section we describe what we mean by an identified occurrence, as opposed to a proposition or a
logical operator, and how this notion is used for representing and assessing obligations. We then describe
how specific identified obligations may be brought about from general obligations through functions on
occurrences. In the spirit of Jones and Sergot (1993), we will use a library lending scenario throughout,
though we will make use of our own specific set of regulations and circumstances.
2.1
Representing and Assessing Obligations with Occurrences
Standard Deontic Logic presumes that being obliged to do that which is prohibited is a logical
contradiction. Obligation and prohibition are treated as operators, typically with the interdefinability
axiom:
P def ¬O¬
meaning that if a state-of-affairs, , is permitted then it is not obliged that not . In contrast, we take as
our starting point the assumption that permissions and obligations are independent entities - variables that
are quantified over - and that conflicting norms can exist. Our view is that being obliged to do that which
is forbidden is not a logical contradiction, but a choice dilemma. The choice may involve deciding which
identified directive to violate, or deciding which to regard as void in the circumstance (that is, in each case
of application by a norm interpreter).
Before we investigate the representation of an identified norm further, we need to introduce the notion of
an occurrence, as distinct from a proposition. A proposition may be associated with a truth value: letting A
be the proposition ‘John returned the book’, we assess that A is true in the case that there are one or more
occurrences of John having returned the book. In contrast, an occurrence is an identified entity which
occupies a moment or interval of time and takes as its arguments participants in various roles. We might
therefore have returning_1 which takes as its arguments book_copy_1235 in the role returned and John
in the role returner. Assuming John borrowed book_copy_1235 on two separate occasions following are
two separate occurrences of John returning that book:
returning_1 (on 3 June 2001)
returned:
book_copy_1235
returner:
John (user_id = user896)
returning_2 (on 5 July 2001)
returned:
book_copy_1235
returner:
John (user_id = user896)
We use Skolem constants to identify specific occurrences of a given type: returning_1 as an instance of
the type returning. Each occurrence of returning may be associated with a time: the first return may have
been on 3rd June 2001, whilst the second may have been on 5 th July 2001. The proposition A (‘John
returned book_copy_1235’) is strictly true from 3rd June 2001 onwards, since from that moment on it is
true that John has at some stage returned the book. A proposition, then, becomes true as a result of one or
more identified occurrences. Of identified occurrences we can say only that they happened (or did not):
we speak of their existence, rather than of their ‘truth’. Since occurrences occupy (perhaps unspecified)
moments or intervals of time, they are inherently temporal in nature, whereas propositions - in the absence
of extension to cater for time - are atemporal.
The notion of individuating events has its philosophical original in Davidson (1980), and has been
examined and substantiated in various forms by, inter alia, Kowalski and Sergot (1986), Bennett (1988),
Parsons (1990), Kimbrough (1998), and Pianesi and Varzi (2000). Philosophical subtleties abound in the
various uses of the term ‘event’ in the literature. For instance, Bennett (1988) controversially argues that
John’s crossing the Channel and John’s swimming the Channel are the same ‘event’, whereas we treat
them as separate occurrences. Kimbrough (personal communication) argues that an obligation state,
e ought(e), can be the same as a violation state, violating(e); our contention is that each is an
independent entity: an occurrence being_obliged_1, and an occurrence violating_1, where the
participant in the role violated in violating_1 is the obligation identified as being_obliged_1. To
avoid any confusion with the various usages of the word ‘event’ in the literature, we have chosen the term
‘occurrence’ to refer to our entities.
We believe the notion of an occurrence, absent from standard treatments of deontic logic, is useful for the
representation and assessment of obligations. Brown (2000) speaks of the distinction between simply
dischargeable obligations and standing obligations. The latter have been the traditional purvey of deontic
logic. As we will illustrate here, it seems that Standard Deontic Logic (SDL) copes poorly with simply
dischargeable obligations. This is problematic since such obligations form a large portion of the
obligations we wish to reason about in commercial contractual scenarios. Consider the case where John
has borrowed book_copy_1235 for the second time on 1st July 2001 and has an obligation - a specific
obligation - to return it. Taking A as the proposition that John returns the book, in Standard Deontic Logic
we might then say:
OA
meaning ‘John is obliged to return book_copy_1235’. How though, do we distinguish this second
obligation, from John’s previous obligation, which arose when he first borrowed the book? In SDL, the
first obligation is also represented as:
OA
Collapsing the obligations together through logical derivation results in dangerous information loss, since
originally we had two obligations, but standard propositional logic leaves us with one:
OA  OA
 (standard propositional logic)
OA1
SDL fails to distinguish between propositions about norms, and the actual norms themselves. Makinson
(1999) comments that simply describing norms as true or false is insufficient, and that it is a fundamental
problem of deontic logic that norms are simply considered to have truth values. We argue that, since
propositions about norms are derived from the norms themselves, invalid or misleading inferences will
result if we deal merely with the propositions rather than with the identified norms that make those
propositions true or false. Assume, on both occasions, John fulfils his obligation to return the book (that
is, A is true), we have:
OA  A  OA  A
 (standard propositional logic)
OA  A
Similar information loss occurs when we derive such conclusions as OA from O(AB) in SDL. As SDL does not identify the
particular obligation O(AB) we have no way of determining that OA is in fact a partial description of O(AB). Maintaining an
identifier for the obligation (e.g. using subscripts, O1(AB) and O1(A)) would be useful in a database environment to allow us to
look up the full description of the obligation O1 when we have partial information on it.
1
The two different fulfillment occurrences are not distinguished here. Most problematically, it seems that,
had John returned the book only the first time and his dog had eaten it on the second occasion we would
still have:
OA  A
This says that A was obliged and A was done. Using Anderson’s (1958) reduction of obligation to
violation in the case of falsity of the obliged proposition ( OA =def (AViolation)), John’s violation of
his second obligation is not evident since A is true by virtue of fulfillment of the first obligation.
To rectify the above problems, it seems that norms (and occurrences which fulfil or violate those norms)
should be individually identified. A treatment of obligations as entities, rather than as operators on
propositions, has been proposed in Kimbrough (2001). Kimbrough has recommended identifying both
obligation states (instead of the O operator) and violation states (instead of the insufficiently specific
Violation predicate) to correct some existing deficiencies of SDL. We wish to justify Kimbrough’s
suggestion and, using our own notation, illustrate their pertinence to the book-borrowing example.
In our world of identified norms, the particular obligation of, say, John, to return the book he borrowed on
1st June may be written, informally, as:
being_obliged_1 (arising on 1st June 2001)
obliged:
first occurrence, on or after 1st June 2001,
of John returning book_copy_1235
Ignoring return deadlines for the time being, we have an identified obligation, being_obliged_1,
where
what is obliged is the first occurrence of John returning the book he borrowed. The second obligation may
likewise be represented as:
being_obliged_2 (arising on 1st July 2001)
obliged:
first occurrence, on or after 1st July 2001,
of John returning book_copy_1235
Now, returning_1 fulfils the first obligation (being_obliged_1), whilst returning_2 fulfils
(being_obliged_2). This can be assessed computationally. Each occurrence can be stored in
the second
a database.
For instance, one possible schema, a tabular format which has been implemented in Abrahams and Bacon
(2001), might be as follows:
Participant
Occurrence
Role
book_copy_1235
user896 (John)
returning_1
returning_1
returned
returner
Query1
being_obliged_1
obliged
book_copy_1235
user896 (John)
returning_2
returning_2
returned
returner
Query2
being_obliged_2
obliged
where:
Query1 = an identifier for the root node of the
SELECT first occurrence, on or after 1st
John returning book_copy_1235
Query2 = an identifier for the root node of the
SELECT first occurrence, on or after 1st
John returning book_copy_1235
syntax tree for the query:
June 2001, of
syntax tree for the query:
July 2001, of
Using a so-called ‘continuous query’ mechanism for assessing the changing results of a stored query as
new data is added to the database, we can computationally determine that returning_1 is covered by
Query1 and that returning_2 is covered by Query2. Furthermore, as both queries only ever return a
maximum of one occurrence (hence the criterion ‘first’ in each query) we see that returning_1 fills
Query1 and returning_2 fills Query2. We can then conclude that returning_1 fulfills being_obliged_1
and returning_2 fulfills being_obliged_2.
In the case of concurrent obligations, Kimbrough (2001) and Daskalopulu and Sergot (2001) recommend
the use of a sake_of() predicate to allocate fulfillment occurrences to the obligations they are intended to
fulfil. This is necessary since, for instance, a consumer may purchase two similar items in quick
succession, and the supplier may have two separate obligations to deliver the item. Considering the case
of Peter separately purchasing two pizzas on the same night from Susan, the obligations cannot be
represented simply as:
being_obliged_3
obliged:
being_obliged_4
obliged:
first occurrence, tonight, of Sue delivering pizza
first occurrence, tonight, of Sue delivering pizza
This is because a delivery of a single pizza, say, delivery_1, should be allocated to at most one order, and
in the absence of further specification it seems that delivery_1 of a single pizza could fulfil both
being_obliged_3 and being_obliged_4 which is not what is intended. Since different allocations are
possible over time, and depending on which allocation basis is used (e.g. most-recent-first, least-recentfirst, or arbitrarily complex allocation criteria) we might choose to use an occurrence of allocating in
place of Kimbrough’s sake_of() predicate. We might then represent the concurrent obligations as:
being_obliged_3
obliged:
being_obliged_4
obliged:
first occurrence, tonight, of Sue delivering pizza,
and where said occurrence is allocated to being_obliged_3
first occurrence, tonight, of Sue delivering pizza
and where said occurrence is allocated to being_obliged_4
We then require a rule that each delivery of a single pizza must be allocated, using some specified basis, to
a single obligation. Following application of such a rule, we might have the following occurrences of
allocating:
allocating_1
allocated:
allocated_to:
basis_of_allocation:
allocating_2
allocated:
allocated_to:
basis_of_allocation:
delivery_1
being_obliged_3
least_recent_first
delivery_2
being_obliged_4
least_recent_first
We can then ensure that each delivery satisfies only a single obligation.
We do not here deal with assignment of performances to multiple obligations, such as when a single
delivery of two pizzas (or similarly, a single payment of many dollars) fulfills multiple obligations. In the
latter case, each delivered pizza (or similarly, paid dollar) is allocated to an obligation, rather than each
delivery of pizza (similarly, payment of dollars). Neither do we deal with the complexities of
accumulation of debts, such as when multiple purchases-on-account during a month are aggregated at
month end into a single obligation to pay during the following month, and such obligations may
accumulate from month to month. Assignment of payments to purchases, and corresponding conclusions
about transfer of ownership for each item purchased during the period is generally controlled by
sophisticated organization-specific policies which are outside this paper’s scope. In this paper, then, we
make the simplifying assumption that each discrete performance occurrence pertains to a single obligation.
Given our above-specified obligations, and our ability to deduce their fulfillment by determining whether
queries are filled, we can derive the following occurrences when John returns book_copy_1235 on time, on
both occasions:
fulfillment_1
fulfilled:
fulfiller:
fulfillment_2
fulfilled:
fulfiller:
being_obliged_1
returning_1
being_obliged_2
returning_2
It is already evident that the identification of obligations and occurrences brings some benefits over the
operator-based account of Standard Deontic Logic: separate obligations can be uniquely identified, and
we can determine which of these several obligations has been fulfilled, and by which occurrences of
returning, even when the content of the obligation (e.g. ‘returning book_copy_1235’) is similar.
In this section, we have posited the existence of two separate obligations ( being_obliged_1 and
being_obliged_2) upon John to return the book each time, without explanation of their origin. In the next
section, we look at how individual obligation instances may be born from general obligations.
2.2
From General Obligations to Specific Obligations Instances: Functions of Occurrences
Specific obligations instances may be brought about from general obligations through functions on
occurrences. In the case of the book borrowing example, it is likely that we have a general rule of the
form:
Borrowers are obliged to return books borrowed within 14 days.
We need some mechanism for generating specific obligations from general specifications of this nature.
We choose the device of an identified function, function1, which takes as its domain a set of occurrences,
X, and produces as its range a resulting set of obligations, being_obliged_function_1(X). We append the
occurrence type produced by the function to the start of the function name to make the output range more
clear and more easily accessible to the query mechanism.
The domain of the function,
being_obliged_function_1, is the set of occurrences of borrowing from our library: that is, roughly, any
occurrence in the database having an identifier beginning with borrowing, and having as its lender our
library. Assume John borrows the same book on two occasions, giving us:
borrowing_1 (on 1 June 2001)
borrowed:
book_copy_1235
borrower:
John (user_id = user896)
lender:
Free Library of America
borrowing_2 (on 1 July 2001)
borrowed:
book_copy_1235
borrower:
John (user_id = user896)
lender:
Free Library of America
It should be evident that both these borrowings, borrowing_1 and borrowing_2, are in the domain of
being_obliged_function_1. The function then generates two separate obligations, identifiable as
being_obliged_function_1(borrowing_1) and being_obliged_function_1(borrowing_2) respectively.
These identifiers could be thought of as alternative identifiers, usable instead of the identifiers,
being_obliged_1 and being_obliged_2 which we used earlier (§2.1) to identify John’s separate
obligations. Earlier we assumed that being_obliged_1 and being_obliged_2 were freestanding
obligations without provenance in any particular norm or regulation. We can now see, though, how
specific obligations are generated, via functions, from stipulated norms and actual occurrences, and we can
use such functions to identify each specific obligation instance. The function defining our norm is then:
being_obliged_function_1
domain:
X = any occurrence of borrowing from library
range:
being_obliged_function_1(X) where
obliged
first occurrence, on or after date of X,
and within 14 days of X,
of borrower in X returning borrowed in X
(to lender in X)2
2
In the tabular format shown earlier, this function can be represented and stored as:
Participant
----------Query_3
Query_|X|_4
Occurrence
---------being_obliged_function_1
being_obliged_function_1(X)
Role
---domain
obliged
where:
Query_3 = an identifier for the root node of the syntax tree for the query:
SELECT occurrences of borrowing from library
(Notice that domain of being_obliged_function_1 = X = Query3)
Query_|X|_4 = an identifier for the root node of the syntax tree for the
parameterized query which takes |X| as parameter:
SELECT first returning occurrence, on or after |X|.date AND
within 14 days of |X|.date WHERE
returned = |X|.borrowed AND returner = |X|.borrower
(|X| is a bound variable denoting the occurrence that was covered by Query3 and which therefore
generated the occurrence identified as being_obliged_function_1(X).
For |X| merely substitute the
occurrence identifier in the domain of the function.
Therefore, for borrowing_1, Query_|X|_4
becomes
Query_borrowing_1_4, and |X|.date becomes borrowing_1.date.)
Given that our continuous query mechanism can determine that the above-mentioned occurrences of
borrowing (borrowing_1 and borrowing_2) fall within the query…
SELECT any occurrence of borrowing from Free Library of America
… which defines the domain of the function, our two obligations are then the following two identified
occurrences:
being_obliged_function_1(borrowing_1)
obliged:
first occurrence, between 1st and 15th June 2001,
of John returning book_copy_1235
(This query is identified as Query_borrowing_1_4: see footnote 2)
being_obliged_function_1(borrowing_2)
obliged:
first occurrence, between 1st and 15th July 2001,
of John returning book_copy_1235
(This query is identified as Query_borrowing_2_4: see footnote 2)
being_obliged_function_1(borrowing_1) is an obligation instance that arises on 1 st June 2001,
being_obliged_function_1(borrowing_1) is an obligation instance that arises on 1 st July 2001.
whilst
Here we have shown how identified occurrences and identified norms allow us to separately identify the
obligations generated by a norm over time. Derivation of specific identified obligations from general
obligations is not treated in SDL.
3
Life Cycle of Norms
In SDL it is not clear that John’s first obligation to return the book he first borrowed was fulfilled: OA  A
should, intuitively, imply OA since a fulfilled dischargeable obligation no longer stands. Or more
specifically,
we
should
be
able
to
infer
that
the
obligation
(say,
being_obliged_function_1(borrowing_1)) once was in force, but is now fulfilled and no further call to
action results. We therefore must be aware of occurrences of either its fulfillment, violation, or being
voided. For example:
fulfillment_1
fulfilled:
being_obliged_function_1(borrowing_1)
violating_1
violated:
being_obliged_function_1(borrowing_1)
being_void_1
voided:
being_obliged_function_1(borrowing_1)
or
or
Capturing such occurrences allows us to capture the life-cycle of an obligation, and thereby assess whether
it is still active and requires fulfillment. Standard Deontic Logic allows us to make no such inferences.
This is because SDL deals with truth-valued propositions about general standing obligations, rather than
with specific identified obligations.
As we have seen, there is a variety of ways in which an obligation may terminate: each of the above
occurrences (fulfilling, violating, voiding) counts as a cessation of the obligation. We can define a
function to capture this:
ceasing_function_1
domain:
X = any occurrence of fulfilling, violating, or voiding
an obligation
range:
A fulfillment,
occurrence:
ceasing_function_1(X) where
ceased:
|X|.theme3
fulfillment_100, of say being_obliged_1, would
then produce the following cessation
ceasing_function_1(fulfillment_100)
ceased:
being_obliged_1
theme here refers to any of the open set of role names: fulfilled, violated, voided since these domain-specific roles can
be generalized to the semantic role ‘theme’ commonly used in knowledge representation in artificial intelligence (Allen 1995; Sowa
2000).
3
To capture fulfillment and violation of our obligations in our book-borrowing example we make use of the
function device once again. These functions demonstrate how occurrences of fulfilling and violating are
produced in each case.
The function that describes the fulfillment conditions
(being_obliged_function_1(borrowing_1)) is as follows:
for
John’s
1st
obligation
fulfilling_function_1
domain:
X = an occurrence of filling where a query describing
obliged occurrences is filled (completely).
range:
fulfilling_function_1(X) where
fulfilled:
obligation associated with
the query |X|.filled
An on-time return, returning_1, would fill the query identified as Query_borrowing_1_4 (see footnote 2)
which is associated with the obligation instance being_obliged_function_1(borrowing_1). This is
detected by the continuous query mechanism, which fires an occurrence, say filling_1, of the query
being
filled
(completely).
We
then
derive
the
following
fulfillment
occurrence
from
fulfilling_function_1:
fulfilling_function_1(filling_1)
fulfilled:
being_obliged_function_1(borrowing_1)
The obligation to return a book before 15 th June 2001 is violated when 15th June 2001 passes and the
obligation is still in force (has not ceased through fulfillment or being made void). The obligation is also
violated when any occurrence occurs that makes its fulfillment impossible, such as destruction of the
book. Of course, in the case where the occurrence that makes it impossible to fulfill the obligation is as a
result of an ‘Act of G-d’ (as opposed to act of dog), we may view the obligation as voided, rather than
violated, and thereby forgive the non-fulfillment.
The
function
that
describes
how
violations
of
John’s
(being_obliged_function_1(borrowing_1)) are brought about is as follows:
1 st
obligation
violating_function_1
domain:
X = first occurrence, on or before cessation of
being_obliged_function_1(borrowing_1),
of being_impossible for John to return book_copy_1235
before 15th June 2001.
range:
violating_function_1(X) where
violated:
being_obliged_function_1(borrowing_1)
An occurrence of 15th June expiring without the occurrence of John returning the book implies an
occurrence of being_impossible that is in the domain of violating_function_1. Assume that 15th June
2001 expires and that our system counts the occurrences of John returning the book before 15 th June, and
finds a result of zero. The monitoring system then asserts being_impossible_1 which says that
occurrences of John returning the book before 15 th June 2001 are impossible (since 15th June has passed
and none occurred). The occurrence being_impossible_1 then implies the following violation
occurrence:
violating_function_1(being_impossible_1)
violated:
being_obliged_function_1(borrowing_1)
What prohibition is this obligation equivalent to? It might be tempting to think of the obligation to return
a book before 15th June 2001 as equivalent to the prohibition against returning the book after 15 th June
2001. However, we must be careful of our reading and implementation of this prohibition. We do not
want a prohibition against returning the book after 15th June 2001, since this would fire a violation each
time the book is returned after 15 th June 2001, which is not what we intend. ‘Better a late return than no
return’ is not captured by that logic interpretation. Rather, our prohibition is against the single case where
no books are returned before 15th June, and the violation conditions for this have been defined already in
violating_function_1.
4
Situation
As deontic logics generally neither capture the provenance of a norm (e.g. its author, specification time, or
document position), nor a unique identifier for each norm, conflict resolution in formal logic is in many
cases untenable as insufficient information about the policies exist to enable choice amongst them. We
can rectify this by associating each identified norm (function or specific obligation instance) with a clause
that construes that obligation as having come about. This may be achieved by adding an ‘isAccordingTo’
role to each function, obligation, permission, or prohibition, where the participant in this role is a clause
identifier (such as Clause_1) which identifies the utterance that promulgated this clause. Using an
occurrence of being_in, the utterance identifier can then be associated with a document position identifier
(e.g. ‘Section 1.1’), and a document heading (‘Library General Regulations’). Alternatively, the clause
can be associated with an utterer (e.g. ‘Chief Librarian’) or institution which associates itself with the
clause (e.g. ‘Library of Congress’), and an utterance time and place (e.g. ‘Washington’, ‘February 8 th
2002’).
As each obligation is according to a particular clause, these obligations may be considered as a
representation of the notion of prima facie obligations discussed in the deontic logic literature (Prakken
and Sergot 1997). John might have a prima facie obligation, according to Clause 1 (in Library General
Regulation 32B) to return the book within 14 days. But, being a faculty member, John may also have
another prima facie obligation, according to Clause 2 (in Library General Regulation 48C) to return the
book within 30 days. The general norm that brings about the latter prima facie obligation may be
represented by the function being_obliged_function_2:
being_obliged_function_2
domain:
X = any occurrence of borrowing, where borrower is a
faculty member, from library
range:
being_obliged_function_2(X) where
obliged :
first occurrence, on or after date of X,
and within 30 days,
of borrower in X returning borrowed in X
(to lender in X)
isAccordingTo: Clause_2
We can similarly add ‘isAccordingTo: Clause_1’ to the general obligation defined by
being_obliged_function_1. We will see how this information is used for conflict resolution purposes in
Section 5.2. For the moment though, let us compare our intentions when tagging norms with clause
identifiers to Sergot et al’s (1986) work on relativising norms.
A mechanism of labeling conclusions with the section of law from which they were derived was employed
in Sergot et al (1986) in their analysis of the British Nationality Act. That paper recommends that rules
take the form:
[proposition] on [date] by Section [section number] if [conditions]
For example:
x acquires British citizenship on 16 March 1987 by Section 11.1 if …
Sergot et al recommend that the section number be recorded because candidates may qualify by any of
four different section for citizenship, and the way in which the candidate qualified may have implications
for, for instance, the nationality of their children. Their intention in recording section numbers is solely to
record the origin of a conclusion in a conflict-free specification so that the specific type of citizenship can
be derived, where type of citizenship corresponds to section number under which the citizenship is
acquired. Our representation differs in a few important respects. Firstly, our identifiers are systemassigned and the utterances (clauses) are regarded as an immutable part of history once recorded. For us,
multiple clauses may make conflicting construals without logical contradiction, though clearly choice as to
which construal to uphold must be made during application of the rules by the norm interpreter. Such
choice is typically guided by other rules: these are high-level norms or ‘principles’ (selection principles).
In contrast, Sergot et al propose that identified sections be revised to eliminate conflicts. There is no
allowance for subjective clauses to conflict without logical contradiction, and conflicts are in fact
specifically removed by redrafting. For instance, the addition of Section 11.2 which specifies exclusions
to the conditions of Section 11.1, would require the restatement of Section 11.1 as:
x acquires British citizenship on 16 March 1987 by Section 11.1 if …
and not [x is prevented by section 11.2 from acquiring British citizenship]
Such revisions are problematic from a number of perspectives. Firstly, as Sergot et al point out, if conflict
elimination is to be achieved, adding sections requires the adjustment of existing rules (primarily by
human trial and error), which becomes increasingly difficult as the size of the rule-base grows. The
addition of a single new rule may require the revision of many existing rules, violating the principle of
locality of update. Secondly, we believe, adjusting existing rules changes the content of what was
proposed by the legislator. Section 11.1 above is no longer the same section as contained in the original
Act, since it now contains additional conditions from later sections and even interrelated laws. By
repeatedly revising existing rules, a prima facie provision becomes altered to an all-things-considered
provision, and we are no longer concluding
x acquires British citizenship on 16 March 1987 by Section 11.1
but rather, effectively,
x acquires British citizenship on 16 March 1987 by the law as a whole
The provisions of the section are being confused with the provisions of the law as a whole, thereby
diluting the usefulness of the section identifier. Hansson and Makinson (1997) make a very useful
distinction between “contraction-and-revision”, which is what Sergot et al employ, and “restrained
application”. The former involves derogation and amendment: adding, removing, and altering rules. The
latter leaves the rules exactly as stated, but chooses one rule above another when application of the rules
by a norm-interpreter gives contradictory results. Makinson (1998) suggests that, while inconsistency is
never entirely eliminable, legislation should be redrafted so far as possible to remove conflict, since
pervasive inconsistencies complicate application of the norms. Revision of law to eliminate conflict is
useful in many instances, and Sergot et al’s recommendations are pertinent to legislators and policy
makers. However, revision of the clausal text of existing legislation and policy during implementation to
account for newly introduced rules fundamentally alters its meaning and is to be avoided. Restrained
application (choosing from a set of conflicting construals on a case-by-case basis) may be required instead.
This is not to say that we object to document revision altogether. Our objection is against changing the
contents of an utterance once uttered: once a rule has been stated, it is always the case that its particular
contents were stated, and the contents of the utterance are therefore immutable, even though the contents
of a particular document may be subject to change. The intention of document-level labeling (‘Section
11.1’, paragraph headings, document headings such as ‘British Nationality Act’) we see as being useful in
allowing the determination of which portion of text a conclusion was derived from; that is, the
determination of where a particular utterance was included in a named document or section at a given
time. Altering rule text through rule revision makes such determination very difficult indeed, since
multiple texts are being coalesced, thus blurring their distinct specifications: Section 11.1 is no longer the
same Section 11.1 as the law-makers intended since it contains different utterances from their original
statements. We see revision as being the case where a particular utterance is included in, say, ‘Section
1.1’ at some time, and a different, identified utterance is included in Section 1.1 at a later stage. We have
no objection to the revision of law but we do object to the revision of history. The content and positioning
of text in the British Nationality Act of 1981 at the time it was passed is inalterable. Subsequent
amendments do not change what was passed, since that is history, but may change what is to be considered
by the judiciary (or decision-maker) in their application of the law (or policy) to specific cases.
5
Conflict Specification, Detection, and Resolution
In our example above, we saw that obligations are associated with a description of the set of occurrences
that can fulfill that obligation. When the query describing that set is filled, the obligation is fulfilled. We
also saw how a query may be used to define the domain of functions. In the case of obligation functions,
the occurrences produced by the function represent specific, identified obligations arising from
occurrences in the domain of the general obligation function. In the case of prohibitions and permissions,
we can also use queries to describe the prohibited and permitted occurrences. The function device is used
to produce case-specific instances of permissions and prohibitions, from the general permissions and
prohibitions.
Assuming a rule that all borrowings are permitted, we might represent this using the following function:
permitting_function_1
domain:
X = any occurrence of borrowing from library
range:
permitting_function_1(X) where
permitted:
X
isAccordingTo: Clause_3
see that, prima facie, borrowing_1 is permitted, as it falls in the domain of
We can
therefore generates the occurrence:
the function, and
permitting_function_1(borrowing_1)
permitted:
borrowing_1
isAccordingTo: Clause_3
Assuming a rule that borrowings of rare books are prohibited 4, we might represent this using the following
function:
prohibiting_function_1
domain:
X = any occurrence of borrowing a rare book from library
range:
prohibiting_function_1(X) where
prohibited:
X
isAccordingTo: Clause_4
An additional fact may specify that Clause_4 is contained in our Book Preservation Regulations.
Assuming that book_copy_1235 is not a rare book we can see that, prima facie, borrowing_1 is not
prohibited according to Clause 4, as it does not fall in the domain of the function. But what if
book_copy_1235 is a rare book? Then it would be clear that, prima facie (according to Clause 4),
borrowing_1 is prohibited, as it falls in the domain of the function and therefore produces the occurrence
identified as:
prohibiting_function_1(borrowing_1)
prohibited:
borrowing_1
isAccordingTo: Clause_4
Here we notice a conflict: borrowing_1 is both permitted and prohibited. Let us deal firstly with
mechanisms for analytically determining conflicts in advance (§5.1), and then with conflict resolution
mechanisms (§5.2).
5.1
Conflict Detection
Since norms are associated with queries that describe sets of occurrences, conflicts may, in general, be
detected by analytically determining overlap between stored queries. This conflict detection may be
driven by some basic suggestions of deontic logic 5, which propose that conflicts exist when:
1. an occurrence is in a set of permitted occurrences and a set of prohibited occurrences.
2. an occurrence is in a set of obliged occurrences and a set of prohibited occurrences
3. an occurrence is in a set of obligatory occurrences (implying that not performing the action produces a
violation), but a permission to refrain from performing the occurrence exists (implying that no
violation arises from not performing the action) (Lee 1988; Makinson 1988)
4. an occurrence is in the domain of a function but is in a set of forbidden occurrences. This principle
can be derived from the principle that a power may conflict with a prohibition against exercising that
power (Makinson, 1986; Jones and Sergot 1996). This is because, effectively, functions define
powers, because functions define what set of occurrences can bring about, according to a certain
clause, other occurrences.
5. an occurrence is in a set of obliged occurrences but is not in the range of a function. This can be
derived from the principle that an obligation may conflict with the absence of a power to fulfil that
obligation (the latter includes the case where another party has immunity against a certain state of
affairs being brought about).
From point 1 above we can see that, as the domains of permitting_function_1 and
prohibiting_function_1 overlap, there is potential for conflict. Unlike Standard Deontic Logic, we see
Take ‘prohibited’ here to mean ‘a violation results if it occurs’, rather than “no person is legally empowered to bring about the state
of affairs where the library views the book as ‘borrowed’”.
5
The authors cited here do not make use of a notion of occurrences, but reason at the level of propositions and contradiction between
propositions. We restate their suggestions in terms of sets of occurrences.
4
no logical contradiction in the co-existence of conflicting prima facie permissions and prohibitions.
Instead, we argue that, where dilemmas exist, some choice must be made as to which particular permission
or prohibition entity to void or violate in a given case. Conflict resolution is dealt with next.
5.2
Conflict Resolution
A variety of conflict resolution options are available to us:
 revision to eliminate conflict. This approach is taken by Sergot et al. (1986).
 amendment to specify which case-specific instances are void for a particular case
 in the absence of revision or amendment, acceptance that fulfilling one provision may violate others.
In the presence of conflicting provisions, we may wish it to be the case that one or more of the provisions
is voided, or we may wish simply to guide the decision-maker as to which provisions to violate. While we
agree that revisions to the rule-set may be useful in removing conflict, we see revision alone as
insufficient. Supplementation of the rule-set with additional choice principles for case-based reasoning is
a necessary and complementary conflict resolution mechanism: here we specify which case-specific
obligation, permission, or prohibition instances are voided. Supplementation of the rule-set with choice
principles for deciding which norms to violate in cases where violations are unavoidable is also possible.
In the above example, given that a borrowing may fall into both the domain of permitting_function_1
and the domain of prohibiting_function_1 we can define a function, voiding_function_4, that
specifies which generated permission or prohibition instance is void in the circumstance. Let us assume
that our normative system says that the specific permission to borrow a book is voided where prohibitions
defined in our Book Preservation Regulations contradict. voiding_function_4 is a general norm which
specifies which provision’s construal (i.e. instantiation of a norm) is void in the light of conflicting prima
facie instances.
voiding_function_4
domain:
range:
X = occurrences produced by permitting_function_1 from
occurrence Y, where Y is in the role ‘prohibited’
in any occurrence of prohibiting where the
isAccordingTo role is a clause in
Book Preservation Regulations
voiding_function_4(X) where
voided:
X
isAccordingTo: Clause_5
In the presence of borrowing_1, this function produces the following result:
voiding_function_4(permitting_function_1(borrowing_1))
voided:
permitting_function_1(borrowing_1)
isAccordingTo: Clause_5
It
is
then
clear
that,
according
to
Clause_5,
the
permission
identified
as
permitting_function_1(borrowing_1) is void in this circumstance. It should be noted here that it is the
case-specific instantiation (permitting_function_1(borrowing_1)) of the permission that is voided,
rather than the permission in general (permitting_function_1). Hence, the general permission may still
apply to other occurrences of borrowing. The distinction between case-specific permission instances and
the general permission from which they are derived is at the heart of Hansson and Makinson’s (1997)
contrast between restrained application and revision. In restrained application (typically used by judges in
their application of the law), it is the case-specific permission instance that is voided. In revision
(typically used by legislators in their revision of the law), it is the general permission that is voided.
It may be argued at this stage that if we ask the question ‘is borrowing_1 permitted?’ we get the response
‘yes’, since permitting_function_1(borrowing_1) is stored in our database. However, the ‘yes’ is
actually a qualified ‘yes’: what we really mean is ‘prima facie, according to Clause_3, yes’. But looking
further we see that permitting_function_1(borrowing_1) is voided. What we need is an additional
definition of permission that says that a void permission is, in some sense, not a permission at all. We
may define:
permitting_function_2
domain:
X = any occurrence of permitting but not one that
participates, in role ‘voided’ in an occurrence
of voiding
range:
permitting_function_2(X) where
permitted:
|X|.permitted
isAccordingTo: Clause_6
Clearly permitting_function_1(borrowing_1) is not in the domain of permitting_function_2 since it
participates in the role voided in voiding_function_4(permitting_function_1(borrowing_1)). Once
we have this definition of what it means for something to currently be permitted, we can ask the specific
question ‘is borrowing_1 permitted according to Clause_6?’ our answer is an unambiguous ‘No’.
As another example of conflicting prima facie norms, consider the case where John is a faculty member.
Under being_obliged_function_1 and being_obliged_function_2 defined earlier (§2.2 and §4
respectively), we have, arising from borrowing_1, the following two obligations:
 being_obliged_function_1(borrowing_1) saying John is obliged to return the book by 15 June
 being_obliged_function_2(borrowing_1) saying John is obliged to return the book by 31 June
At first glance, it appears that there is no conflict here: John could return the book before 15 th June 2001
and so satisfy both obligations. However, in this case, let us assume that faculty members are exempt
from any obligations produced by being_obliged_function_1. We can proceed as we did for the voiding
of the case-specific prohibition above: by defining a function that specifies which specific instances are
void.
voiding_function_5
domain:
range:
X = occurrences produced by being_obliged_function_1 from
occurrence Y, where Y is a borrowing where the
participant in the role ‘borrower’ is a faculty member
voiding_function_5(X) where
voided:
X
isAccordingTo: Clause_7
In the presence of borrowing_1, this function produces the following result:
voiding_function_5(being_obliged_function_1(borrowing_1))
voided:
being_obliged_function_1(borrowing_1)
isAccordingTo: Clause_7
So, the obligation to return the book by 15 th June is here void.
Voiding obligations produced by conflicting clauses is one possible solution to conflict; another, is to
merely accept that conflict exists. In many environments it may be the case that the stricter obligation is
intended to be enforced even when the more lenient obligation also applies. This is hard to imagine when
the obligations both arise from a single source, but consider the case where library regulations say that
returns by 31st June are required, whereas the principles of general fairness say John should nevertheless
return the book by 15th June. Here we cannot easily argue that one obligation voids the other; rather they
exist in conflict, and John must choose which to violate. If John returns the book on 17th June there is then
one violation: a violation of a principle of general fairness. If John never returns the book, he has violated
both obligations: there is a violation of a principle of general fairness and a violation of a specific library
regulation.
6
Time
In the spirit of Sergot (1986), we tag each conclusion with a time to indicate the moment at which the
conclusion was derived. A conclusion derived at time t1, may no longer be derived at time t2.
Nonmonotonicity (revision of conclusions) is supported, as partial information is supplemented over time.
A continuous query mechanism, which monitors how the results of stored queries change over time still
remains applicable here. Occurrences join and leave the domain of functions over time; consequently, the
range of functions changes over time. Where necessary, we can tag the item produced by the function
with the time of its production.
Let us define a high-level principle that says that something is (currently) obliged if there is an obligation
to do it which has not yet ceased6:
being_obliged_function_42
domain:
X = any occurrence of being_obliged
that does not participate in role ‘ceased’ in an
occurrence of ceasing.
range:
being_obliged_function_42(X) where
obliged:
|X|.obliged
isAccordingTo: Clause_42
have called this principle Clause_42. Now, beginning with an empty database, let us trace our
We
bookborrowing scenario from its start until just after the first return of the book. Below is a commented
transcript: % represents a command prompt with user input, > represents a system response to a query, and
=> represents an output from system derivation. For brevity, role-players in each identified occurrence are
not indicated; the reader may consult the respective occurrence identifiers mentioned earlier in this
document for further details on the participants in each identified occurrence and their roles.
Date
1 Feb 2001
1 June 2001
3 June 2001
Commentary
Borrowers are obliged to return books borrowed
(Clause_1)
Is John obliged to return the book, according to
Clause_42 ?
No, he’s not. (He hasn’t yet borrowed it.)
John borrows the book
Therefore, prima facie, according to Clause_1,
John is obliged to return the book.
Also, prima facie, according to Clause_42,
John is obliged to return the book.
Is John obliged to return the book, according to
Clause_42 ?
Yes, he is.
John returns the book.
Continuous query mechanism detects query
associated with obligation is filled
Therefore, the obligation to return the book has
been fulfilled.
And, the obligation to return the book ceases.
Is John obliged to return the book, according to
Clause_42 ?
No, he is not. (According to Clause_42,
something is no longer obliged if the obligation
to do it has ceased.)
Session Transcript
% INSERT being_obliged_function_1
% SELECT occurrences of being_obliged
WHERE isAccordingTo=Clause_42 AND
obliged >= Query1
> 0 results.
% INSERT borrowing_1
=> being_obliged_function_1(borrowing_1)
=> being_obliged_function_42(
being_obliged_function_1(borrowing_1))
(Same SELECT query as above)
> being_obliged_function_42(
being_obliged_function_1(borrowing_1))
% INSERT returning_1
CQ monitor: INSERT filling_1
=> fulfilling_function_1(filling_1)
=> ceasing_function_1(
fulfilling_function_1(filling_1))
(Same SELECT query as above)
> 0 results.
From the transcript above, we can see that the question ‘is John obliged to return the book, according to
Clause_42 ?’ is answered ‘No’ on 1st Jan 2001, ‘Yes’ after his borrowing on 1 st June 2001, and ‘No’ again
after his book return on 3rd June 2001. Conclusions are defeasible. On 5th June 2001, we could ask
whether it was the case, on 2nd June 2001 at 14h00, that John was obliged to return the book. We could do
this by running the SELECT query from the transcript above, but instructing the inference engine only to use
facts and rules dated on or before 2 nd June 2001 at 14h00. The query, framed on 5 th June but using only
information
known
up
until
2nd
June
2001
at
14h00,
would
return
being_obliged_function_42(being_obliged_function_1(borrowing_1)) meaning that, yes, as at 2nd
June 2001 at 14h00, John was obliged to return the book.
6
We defined what it means for an obligation to ‘cease’ through a ceasing_function in §3.
7
Related Work
We have presented problems raised by: (1) the relationship between obligations and time, and (2) the
origin of obligations and conflicts.
In real problems, many obligation statements refer to time, and obligation validity changes over time. The
relationship between deontic notions and time has previously received some attention. For instance,
Brown (1996, 2000) explains that dynamic, dischargeable obligations (e.g. ‘to return the book’), are more
prevalent in contracts than the static, standing obligations (e.g. ‘to honor your parents’) of SDL. However,
the temporal logic Brown defines does not allow one to date obligations, and the problem of life cycle of
individual, identified obligations over time is not addressed.
In terms of problems raised by the origin of obligations and conflicts, a previous contribution to the
literature on defeasible deontic logic and non-monotonic reasoning with contradictory norms in this regard
is the work by Cholvy and Cuppens. They speak of merging sets of norms originating from conflicting
roles (Cholvy and Cuppens, 1995) or regulations (Cholvy and Cuppens, 1998). In their earlier work, sets
of obligations, permissions, and prohibitions are associated with identified roles – such as
‘Role1=Christian’ or ‘Role2=Ordered_Soldier’. In the latter work, sets of norms are associated with
identified regulations – such as ‘Regulation1=Eating Regulations’ and ‘Regulation2=Asparagus Eating
Regulations’. Cholvy and Cuppens (1998) extend SDL by relativizing norms to regulations, expressing
sentences of the form ‘within regulation R / regulation R says / according to regulation R, it is obligatory /
permitted / forbidden that P’. A precedence ordering relationship is defined between regulations. When
regulations are merged, conflicts in the norm sets are resolved by allowing norms from the regulation with
higher precedence to override. The notion of precedence-based override is seen as a generalization of
Horty’s suggestion of specificity-based override, as specificity ordering is viewed as one means of
preference ordering. Taking the rules “generally, one ought not to eat with one’s fingers” and “when
eating asparagus, one ought to eat with fingers”, specificity-based override takes the second rule over the
first one, since its premise is more specific. Cholvy and Cuppens’ approach is reasonably course-grained
as all norms in regulation R1 are taken to override all norms in regulation R2. The logic does not speak of
dynamic determination of context-specific priorities: it does not explicitly attend to the problem that
precedence relationships are non-static and in some cases regulation R1 overrides R2, whereas in other
circumstances, R2 overrides R1. Cholvy and Cuppens assume that regulations are internally consistent
and conflict free, and their logic therefore does not attend to conflicting obligations brought about by
different events covered by the same norm. For example, Hansson and Makinson (1997) give the case
where the single rule that ‘the doctor must immediately visit heart attack victims’ generates conflicting
obligations when two remote patients suffer heart-attacks: an obligation to visit patient A immediately and
a separate, conflicting one to visit patient B immediately. Cholvy and Cuppens treatment of the source or
origin of obligations (and conflicts) effectively looks at their provenance in documents but not at their
birth in circumstance.
8
Conclusion
We have critically reviewed the traditional operator-based construal of obligation and permission in
deontic logic and illustrated the usefulness of identifying specific obligation, permission, and prohibition
instances which are generated from norms by functions on occurrences. We have shown that the
identification of separate case-specific instantiations of obligations (similarly permissions and
prohibitions) allows us to speak of the life-cycle of those obligations, and to reason about their force over
time as new information becomes available. We explained how the supplementation of deontic
specifications with additional information to capture the situation or provenance of a norm (e.g. author,
document position, place of utterance, etc.) allows us to reason more powerfully about conflicts between
prima facie provisions. Through worked examples, we demonstrated the process of reasoning in the light
of conflicting norms, which may be voided or violated. We believe our exposition enlightens aspects of
the life and times of identified, situated, and conflicting instantiations of norms that are not dealt with in
standard operator-based treatments of norms in deontic logic.
9
Acknowledgements
The authors would like to acknowledge the valuable feedback received from the anonymous referees,
helpful input kindly provided by David Makinson, and the hospitality of the Information and Decision
Technologies Group at the Department of Operations and Information Management, Wharton Business
School, University of Pennsylvania, which hosted one of the authors during the writing up of this work.
This research is supported by grants from the Cambridge Commonwealth Trust, the Overseas Research
Students Scheme (UK), and the University of Cape Town Postgraduate Scholarships Office.
10 References
Abrahams, Alan S., and Jean M. Bacon. (2001). ‘Representing and Enforcing E-Commerce Contracts
Using Occurrences’, Proceedings of the Fourth International Conference on Electronic Commerce
Research, Volume 1, Dallas, TX: ATSMA, IFIP, INFORMS, 59-82.
Allen, James. (1995). Natural Language Understanding, 2nd ed. Menlo Park, CA: Benjamin Cummings,
1-41, 248.
Anderson Alan R. (1958). ‘A reduction of deontic logic to alethic modal logic’, Mind 67. 100-103.
Bennett, Jonathan. (1988). Events and their Names. Oxford, UK: Oxford University Press.
Brown MA. (1996). Doing As We Ought: Towards a Logic of Simply Dischargeable Obligations. In
Brown MA and Carmo J (eds): Deontic Logic, Agency, and Normative Systems: Proceedings of the
Third International Workshop on Deontic Logic In Computer Science (DEON’96). Sesimbra,
Portugal. Springer. January 1996.
Brown MA. (2000). Conditional Obligation and Positive Permission for Agents in Time. Nordic Journal
of Philosophy 5, no. 2, 83-112
Cholvy L and Cuppens F. Solving normative conflicts by merging roles. In Proceedings of the Fifth
International Conference on Artificial Intelligence and Law (ICAIL’95). Washington, USA. pp 201209. 1995.
Cholvy L and Cuppens F. Reasoning about norms provided by conflicting regulations. In Prakken H and
McNamara P (eds): Norms, Logic, and Information Systems: New Studies in Deontic Logic and
Computer Science. IOS Press, Amsterdam. pp. 247-264. 1998.
Daskalopulu, Aspassia and Marek J. Sergot. (2001). ‘Computational Aspects of the FLBC Framework’,
Decision Support Systems. Special Issue on Formal Modeling in E-Commerce.
Davidson, Donald. (1980). Essays on Actions and Events. Oxford, UK: Clarendon Press.
Hansson, Sven O., and David C. Makinson. (1997). ‘Applying Normative Rules with Restraint’, in ML
Dalla Chiara et al (eds.), Logic and Scientific Methods. Dordrecht: Kluwer, 313-332.
Jones, Andrew J.I., and Marek J. Sergot. (1993). ‘On the Characterization of Law and Computer Systems:
The Normative Systems Perspective’, in Meyer John-Jules Ch. and Roel J. Wieringa (eds.), Deontic
Logic in Computer Science: Normative System Specification. Chichester, UK: John Wiley & Sons.
Jones, Andrew J.I. and Marek J. Sergot. (1996). ‘A formal characterisation of institutionalised power’,
Journal of the Interest Group in Pure and Applied Logic 4, no. 3, 427-443.
Kimbrough, Steven O. (1998). ‘On ES Theory and the Logic of the X12 Date/Time Qualifiers’,
Proceedings of the 31st Hawaii International Conference on System Sciences (HICSS98). Kohalo
Coast, Hawaii: IEEE Computer Society Press.
Kimbrough, Steven O. (2001). ‘Reasoning about the Objects of Attitudes and Operators: Towards a
Disquotation Theory for the Representation of Propositional Content’, Eighth International
Conference on Artificial Intelligence and the Law (ICAIL 2001). St Louis, Missouri: ACM Press.
Kowalski Robert and Marek Sergot. (1986). ‘A logic-based calculus of events’, New Generation
Computing 4, 67-95.
Lee, Ronald M. (1988). ‘Bureaucracies as Deontic Systems’, ACM Transactions on Office Information
Systems 6, no. 2 (April), 87-108.
Makinson, David. (1986). ‘On the Formal Representation of Rights Relations’, Journal of Philosophical
Logic 15, 403-425.
Makinson, David. (1988). ‘Rights of Peoples: Point of View of a Logician’, in James Crawford (ed.), The
Rights of Peoples. Oxford, UK: Oxford University Press, 69-92.
Makinson DC. (1999). On a Fundamental Problem of Deontic Logic. In McNamara P and Prakken H
(eds.): Norms, Logic, and Information Systems: New Studies in Deontic Logic and Computer Science.
Amsterdam: IOS Press. 29-53.
Parsons, Terence. (1990). Events in the Semantics of English: A Study in Subatomic Semantics.
Cambridge, MA: MIT Press.
Pianesi, Fabio and Achille C. Varzi. (2000). ‘Events and Event Talk: An Introduction’, in James
Higginbotham, Fabio Pianesi, and Achille C. Varzi (eds.), Speaking of Events. Oxford, UK: Oxford
University Press, 3-49.
Prakken, Henry and Marek Sergot. (1997). ‘Dyadic Deontic Logic and Contrary-to-Duty Obligations’, in
Donald Nute (ed.), Defeasible Deontic Logic: Essays in Nonmonotonic Normative Reasoning,
Synthese Library No. 263, Kluwer Academic Publishers, 223-262.
Sergot, Marek J., et al. (1986). ‘The British Nationality Act as a Logic Program’, Communications of the
ACM 29, no. 5 (May), 370-386.
Sowa, John F. (2000). Knowledge Representation: Logical, Philosophical, and Computational
Foundations. Pacific Grove, CA: Brooks/Cole.
11 Appendix: Supplementary Example
Let us consider an additional example which treats most of the issues discussed in this paper. In Jewish
tradition, a Cohen is forbidden from visiting a cemetery, but may attend the funeral, which necessarily
involves visiting a cemetery, if their parent or child dies. General principles of good faith say a person is
obliged to attend the funeral of family members and close friends. We wish to illustrate in this section two
different treatments of conflicting norms across two different cases:
1. in the first case, a visit for a parent’s funeral, a case-specific instance of a conflicting norm is voided
2. in the second case, a visit for a friend’s funeral, a case-specific instance of a conflicting norm is
violated
The examples demonstrates that, in some cases, it is important to resolve conflicts by designating norms as
void in a circumstance: that is, by designating case-specific instances of those norms as void. However, in
other case, merely detecting violating of conflicting norms is sufficient.
Let us examine the general norms in place, and their case-based instantiations.
We have a general prohibition against visits of Cohens to cemeteries which gives rise, for instance, to a
specific instantiation of the prohibition, being the prima facie prohibition against a visit, say a visit by Jeff
Cohen to West Park Cemetery for his father’s funeral. The specific prohibition is generated from the
general prohibition by a function: the function takes as its domain the set of prohibited occurrences. Take
the case where Jeff Cohen’s father, Jack, has died, and Jeff visited West Park Cemetery on 1 st May 2003
for his father’s funeral. Assume we wish to now assess, retrospectively, whether Jeff’s action was
permissible. Take Jeff’s visit as visiting1. Assuming the general prohibition against Cohen’s visiting
cemeteries was identified as prohibiting_function_6, which takes as its domain any visit by a Cohen,
we have the prima facie prohibition, identified as ‘prohibiting_function_6(visiting1)’ against
visiting1. We derive that, prima facie, visiting1 is prohibited.
We also have a function, call it being_obliged_function_7, which takes as its domain the set of
occurrence of deaths, and for each, creates a specific obligation instance upon persons who are close
family or friends of the deceased to attend the funeral. Taking Jack Cohen’s unfortunate death as dying1,
we then have the specific obligation, being_obliged_function_7(dying1), upon his son Jeff to visit
West Park Cemetery.
Taking visiting1 as the visit that fulfilled this obligation, we then have a conflict: visiting1 was, prima
facie, both obliged and prohibited. Given, though, that the intention of the law is that the obligation,
being_obliged_function_7(dying1), should defeat the prohibition as the visit is for the death of a
parent, we can mark prohibiting_function_6(visiting1) as void, through its participation in role
voided in an occurrence voiding_function_8(visiting1), thereby eliminating the conflict.
We
conclude that visiting1 was not prohibited since prohibiting_function_6(visiting1) is void (i.e. not
regarded as a valid prohibition by a high-level principle of law which says that void prohibitions do not
count as prohibitions).
Now, assume that the unfortunate Jeff Cohen happens to lose his best friend Marvin Goldberg (who is no
relation to Jeff). Take Marvin’s death as dying2. By general principles of good faith, Jeff has the prima
facie obligation, being_obliged_function_7(dying2), to attend Marvin’s funeral. Assume Jeff,
disrespectful of Jewish law, visits the cemetery to attend Marvin’s funeral. Take this visit as visiting2.
visiting2 fulfils being_obliged_function_7(dying2). Now visiting2 is clearly not for the death of a
parent or child, and so prohibiting_function_6(visiting2) is in force. Seeing as the prohibition is in
force, visiting2 brings about a violation, violating_function_8(visiting2) where it is
prohibiting_function_6(visiting2) that is violated. What arises here is a choice as to which
conflicting norm instance to violate in this case: Jeff chose to violate Jewish law, rather than general
principles of good faith. Had he stayed home, he would have violated general principles of good faith, but
obeyed Jewish law. The choice as to which to violate was in this case forced on him, as he could not
physically have honored his obligation and respected the prohibition.
Note that a prohibition that is void in a particular case is not void in general: so voiding a particular casebased instantiation of a prohibition is not the same as voiding the general prohibition. Voiding the
prohibition against Jeff Cohen visiting West Park to attend his father’s funeral on 1 st May does not void
the prohibition against his other visits in other circumstances: that is, he is still prohibited from visiting the
next day, or even from visiting the same day but for a different purpose. The English word ‘prohibition’ is
loosely used to refer to both general prohibitions and particular case-based instantiations of general
prohibitions, but it is important for reasoning purposes to separately identify the notions so that case-based
instantiations can be voided without voiding the general prohibition. Similarly, for obligations, identifying
case-based instantiations is essential.
Note that it is not the general prohibition,
prohibiting_function_6(X), against Cohens visiting cemeteries that is regarded as null, since that
prohibition may still apply to other Cohen’s who were not relatives of the deceased, but the specific casebased instantiation of the prohibition - i.e. the prohibition, prohibiting_function_6(visiting1)
(generated from the general prohibition), against Jeff Cohen visiting West Park Cemetery - that is regarded
as null. Again, we see the distinction between revision and restrained application illuminated by Hansson
and Makinson (1997): revision would have involved the nullification of the general prohibition (and hence
all case-based instances), whereas restrained application involves the nullification of a specific case-based
instance only. As we have argued previously, nullification (voiding) of a case-based instance is only one
means of dealing with conflict though: the alternative is to simply recognize that (in the case of
visiting2) the prohibition is violated.
In SDL, Jeff’s obligation to visit the cemetery for his friend’s funeral, and the prohibition against him
visiting the funeral would yield a contradiction:
O  ¬P  
In contrast, in cases where neither the obligation nor the prohibition is voided, we see it that the following
would be the case:
e1,e2 being_obliged(e1)  obliged(e1,)  prohibiting(e2)  prohibited(e2,) 
(¬(e3 ceasing(e3)  ceased(e3,e1))) 
(e4 violating(e4)  violated(e4,e1)) 
(e5 violating(e5)  violated(e5,e2))
is, if an obligation (e1) to do  exists, and a prohibition (e2) against doing  exists, then it is either
That
the
case that the obligation has not yet ceased, or it is the case that the obligation was violated, or it is the case
that the prohibition was violated.
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertising