# FormalSemanticsCR

(Redirected from FormalSemanticsED)
Jump to: navigation, search

# Overview

See also FormalSemantics.

The idea of this document is to sketch what aspects of the provenance model can be formalized and how they can be formalized, as a first step towards establishing a consensus on the (intended) meaning of the components of the model and the consistency constraints or inferences that can be applied to the model to distinguish valid from invalid provenance records.

The PROV-CONSTRAINTS document contains formal content specifying a notion of validity (approximately, logical consistency) for PROV documents. The formal semantics, PROV-SEM, is planned for release as a W3C Note that will complement the procedural specification in PROV-CONSTRAINTS with a declarative specification formulated in terms of first-order logic. The formal semantics is work in progress. The drafts below are intermediate stages and some of them are out of date.

## Status

This is work in progress. The semantics is being updated to be consistent with the Candidate Recommendation of PROV. The plan is to release the semantics as a Note over the next few months. The wiki version of the semantics is in the process of being converted to HTML. The current version can be found here: PROV-SEM.

## Idea of the semantics

As a starting point, I will assume that we intend the assertions made in a PROV-DM instance to be intended to describe one, consistent state of the world, much like a logical formula is said to be satisfied in a mathematical model. That is, I propose an approach similar to that taken in model theory, where the PROV-DM instance corresponds to a formula or theory of a logic, and the semantics corresponds to what logicians call a model.

For example, the formula $\forall x. P(x) \Rightarrow Q(x)$ is satisfied in a mathematical model where the relation $P$ denotes a set of elements that is contained in that denoted by $Q$. Here, the goal is to come up with a plausible "intended model" for interpreting PROV-DM instances, where the formulas are assertions in PROV-DM and the individuals are things and agents. This is complicated by the fact that many statements about provenance involve talking about objects that change over time.

The word "world" is used in PROV-DM to talk about the actual state of affairs that the PROV-DM instance describes, which is what I would usually call a "model". The word "model" is used in PROV-DM mainly in the sense of "data model", that is, to talk about what I would otherwise call the syntax of PROV-DM. To avoid confusion with the uses of terms in PROV-DM, I will use "world model" to describe the mathematical structure that corresponds to actual state of affairs, and will try to avoid ambiguous, unqualified uses of the word "model".

## Axiomatization and relationship to PROV-CONSTRAINTS

One goal of the semantics is to link the procedural specification of validity and equivalence with traditional notions of logical consistency and equivalence of theories, for example in first-order logic. A first-order axiomatization that corresponds to the formal constraints and is sound for reasoning about the models described below is in progress at the end of the document.

# Basics

I will use syntax for PROV-DM records (which I will usually call formulas) as described in the Candidate Recommendation of PROV-DM (PROV-DM CR).

A PROV-DM instance, or set of atomic formulas $\phi_1$...$\phi_n$, is interpreted as a conjunction, that is, the overall instance is considered to hold in a given structure if each atomic formula in it holds.

The rest of the document will discuss the structures and define when an atomic assertion holds in a given world.

## Identifiers

A lowercase symbol $x,y,...$ on its own denotes an identifier. Identifiers may or may not be URIs. I view identifiers as being like variables in logic (or blank nodes in RDF): just because we have two different identifiers $x$ and $y$ doesn't tell us that they denote different things, since we could discover that they are actually the same later. We write $Identifiers$ for the set of identifiers of interest in a given situation (typically, the set of identifiers present in the PROV instance of interest).

## Times and Intervals

We assume a linearly ordered set $(Times,\leq)$ of time instants. For convenience we assume the order is total or linear order, corresponding to a linear timeline; however, PROV does not assume that time is linear and events could be partially ordered and not necessarily reconciled to a single global clock.

We also consider a set $Intervals$ of closed intervals of the form $\{t \mid t_1 \leq t \leq t_2\}$.

## Attributes and Values

We assume a set $Attributes$ of attribute labels and a set $Values$ of possible values of attributes.

# Formulas

The following atomic formulas correspond to the statements of PROV-DM. We assume that definitions 1-4 of PROV-CONSTRAINTS have been applied in order to expand all optional parameters; thus, we use uniform notation $r(id,a_1,\ldots,a_n)$ instead of the semicolon notation $r(id;a_1,\ldots,a_n)$.

Each parameter is either an identifier, a constant (e.g. a time or other literal value in an attribute list), or a null symbol "-". Null symbols can only appear in the specified arguments in $wasAssociatedWith$ and $wasDerivedFrom$, as shown in the grammar below.

$\begin{array}{rcl}  formula &::=& element\_formula\\ & | & relation\_formula\\ element\_formula &::= &entity(id,attrs) \\ & |& activity(id,st,et,attrs)\\ & |& agent(id,attrs)\\ relation\_formula &::=& wasGeneratedBy(id,e,a,t,attrs)\\ & |& used(id,e,a,t,attrs)\\ & |& wasInvalidatedBy(id,e,a,t,attrs)\\ & |& wasAssociatedWith(id,ag,act,pl,attrs)\\ & |& wasAssociatedWith(id,ag,act,-,attrs)\\ & |& wasStartedBy(id,a_2,e,a_1,attrs)\\ & |& wasEndedBy(id,a_2,e,a_1,attrs)\\ & |& wasAttributedTo(id,e,ag,attrs)\\ & |& actedOnBehalfOf(if,ag_2,ag_1,act,attrs)\\ & |& wasDerivedFrom(id,e_2,e_1,act,g,u,attrs)\\ & |& wasDerivedFrom(id,e_2,e_1,-,-,-,attrs)\\ & |& alternateOf(e_1,e_2)\\ & |& specializationOf(e_1,e_2)  \end{array}$

# World Models

## Things

Things are things in the world. Each thing has a lifetime during which it exists and attributes whose values can change over time.

To model this, a world model $W$ includes

• a set $Things$ of things
• a function $lifetime : Things \to Intervals$ from objects to time intervals
• a function $value : Things \times Attributes \times Times \to Values_\bot$

Note that this description does not say what the structure of an object is, only how it may be described in terms of its time interval and attribute values. An object could just be a record of fixed attribute values; it could be a bear; it could be the Royal Society; it could be a transcendental number like $\pi$. All that matters from our point of view is that we know how to map the object to its time interval and attribute mapping.

The range of the $value$ function us $Values_\bot$, that is, $Values \uplus \{\bot\}$, the set of values with an additional element $\bot \notin Values$. When $value(x,a,t) = \bot$, we say that attribute $a$ is undefined for $x$ at time $t$.

It is possible for two Things to be indistinguishable by their attribute values and lifetime, but have different identity.

## Objects

A Object is described by a time interval and attributes with unchanging values. Objects encompass entities, interactions, and activities.

To model this, a world includes

• a set $Objects$
• a function $lifetime : Objects \to Intervals$ from objects to time intervals
• a function $value : Objects \times Attributes \to Values_\bot$

Intuitively, $lifetime(e)$ is the time interval during which object $e$ exists. The value $value(e,a)$ is the value of attribute $a$ during the object's lifetime.

As with Things, the range of $value$ includes the special undefined value $\bot$, making $value$ effectively a partial function. It is also possible to have two different objects that are indistinguishable by their attributes and time intervals. Objects are not things, and the sets of $Objects$ and $Things$ are disjoint; however, certain objects, namely entities, are linked to things.

### Entities

An entity is a kind of object that describes a time-slice of a thing, during which some of the thing's attributes are fixed. We assume:

• a set $Entities \subseteq Objects$ of entities, disjoint from $Activities$ and $Events$ below.
• a function $thingOf : Entities \to Things$ that associates each Entity with a Thing, such that for each $t \in lifetime(obj)$, and for each attribute $a$ such that $value(obj,a) \neq \bot$, we have $value(obj,a) = value(thingOf(obj),a,t)$.
• $lifetime(e) \subseteq lifetime(t)$.

Remark: Although both entities and things can have undefined attribute values, their meaning is slightly different: for a thing, $value(x,a,t) = \bot$ means that the attribute $a$ has no value at time $t$, whereas for an entity, $value(x,a) = \bot$ only means that the entity does not record a fixed value for $a$. This does not imply that $value(thingOf(e),a,t) = \bot$ when $t \in lifetime(e)$. In particular, if the $value(x,a,t)$ has multiple values during the lifetime of $e$, then $value(e,a)$ must be $\bot$, since assigning a value to $value(e,a)$ would violate condition (3) above.

#### Plans

We identify a specific subset of the entities called plans, $Plans \subseteq Entities$.

### Agents

An agent is an entity that can act, by controlling, starting, ending, or participating in activities. Agents can act on behalf of other agents. We introduce:

• a set $Agents \subseteq Objects$ of agents.

### Actvities

An activity is an object that encompasses a set of events. We introduce

• a set $Activities \subseteq Objects$ of activities, disjoint from $Entities$ and $Events$

### Interactions

We consider a $Interactions \subseteq Objects$ which are split into Events between entities and activities, Associations between agents and activities, and Derivations that describe chains of generation and usage steps. (The first two sets may overlap.) Interactions are disjoint from entities, activities and agents.

• $Interactions = (Events \cup Associations) \cup Derivations \subseteq Objects$
• $(Events \cup Associations) \cap Derivations = \emptyset$
• $Interactions \cap (Entities \cup Activities \cup Agents) = \emptyset$

#### Events

An Event is an interaction whose lifetime is a single time instant, and relates an activity to an entity (which could be an agent). Events have types including usage, generation, starting and ending (possibly more may be added such as destruction/invalidation of an entity). Events are instantaneous. We introduce:

• A set $Events \subseteq Interactions$ of events.
• A function $time : Events \to Times$ giving the time of each event; i.e. $lifetime(evt) = \{time(t)\}$.
• The derived ordering on events given by $evt_1 \leq evt_2 \iff time(evt_1) \leq time(evt_2)$
• A function $type: Events \to \{start,end,use,generate\}$ such that Events have types in $\{start,end,use,generate\}$.

#### Associations

An Association is an interaction relating an agent to an activity. Associations can overlap with events; for example, a start event is also an association. To model associations, we introduce:

• A set $Associations \subseteq Interactions$, such that every event $evt \in Events$ that is a start or end event is also an association. That is, $type(evt) \in \{start,end\}$ implies $evt \in Associations$

Associations are used below in the $ActsFor$ and $AssociatedWith$ relations. Add types for association or delegation?

#### Derivations

A Derivation is an interaction chaining one or more generation and use steps. Derivations can also carry attributes, so we introduce an explicit kind of interaction for them that can carry attributes.

• A set $Derivations \subseteq Interactions$, disjoint from $Events \cup Associations$.

See below for the associated derivation path and DerivedFrom relation.

## Relations

### Simple relations

The entities, interactions, and activities in a world model are related in the following ways:

• A relation $Used \subseteq Events \times Entities$ saying when an event used an entity. An event can use at most one entity, and if $(evt,e)\in Used$ then $time(evt) \in lifetime(e)$ and $type(g) = use$ must hold.
• A relation $Generated \subseteq Events \times Entities$ saying when an event generated an entity. An event can generate at most one entity, and if $(evt,e)\in Generated$ then $min(lifetime(e)) = time(evt)$ and $type(g) = generation$ must hold.
• A relation $Invalidated \subseteq Events \times Entities$ saying when an event invalidated an entity. An event can invalidate at most one entity, and if $(evt,e)\in Invalidated$ then $min(lifetime(e)) = time(evt)$ and $type(g) = invalidation$ must hold.
• A relation $EventActivity \subseteq Events \times Activities$ associating activities with events, such that $(act,evt) \in EventActivity$ implies $time(evt) \in lifetime(act)$.
• A relation $AssociatedWith \subseteq Association \times Agents \times Activities \times Plans^?$ indicating when an agent is associated with an activity, and giving the identity of the association relationship, and an optional plan.
• A relation $ActsFor \subseteq Agents \times Agents \times Activities$ indicating when one agent acts on behalf of another with respect to a given activity.

### Derivation paths and DerivedFrom

Recall that above we introduced a subset of interactions called Derivations. These identify paths of the form

$ent_n\cdot g_n\cdot act_n\cdot u_n\cdot ent_{n-1}\cdot ...\cdot ent_1\cdot g_1\cdot act_1\cdot u_1\cdot ent_0$ where the $ent_i$ are entities, $act_i$ are activities, $g_i$ are generations, and $u_i$ are usages.

Formally, we consider the (regular) language:

• $DerivationPaths = Entities \cdot (Events \cdot Activities \cdot Events \cdot Entities)^+$ with the constraints that for each derivation path:
1. for each substring $ent\cdot g \cdot act$ we have $(g,ent) \in Generated$ and $(g,act) \in EventActivities$, and
2. for each substring $act \cdot u \cdot ent$ we have $(u,ent) \in Used$ and $(u,act) \in EventActivities$.

and we use this language to give meaning to derivations:

• A function $derivedFrom : Derivations \to DerivationPaths$

Note: The reason why we need paths and not just individual derivation steps is that imprecise wasDerivedFrom formulas can represent multiple derivation steps.

## Putting it all together

A world model W is a structure containing all of the above described data. If we need to talk about the objects or relations of more than one world model then we may write $W_1.Objects$; otherwise, to decrease notational clutter, when we consider a fixed world model then the names of the sets, relations and functions above refer to the components of that model.

TODO: List the components.

# Semantics

In what follows, let $W$ be a fixed world model with the associated sets and relations discussed in the previous section, and let $I$ be an interpretation of identifiers as objects in $W$.

The annotations [WF] refer to well-formedness constraints that correspond to typing constraints.

## Interpretations

We need to link identifiers to the objects they denote. We do this using a function which we shall call an interpretation.

The mapping from identifiers to objects may not change over time. Thus, we consider interpretations as follows:

• An interpretation function $I : Identifiers \to Objects$ describing which object is the target of each identifier.

## Satisfaction

Consider an atomic formula $\phi$, a world $W$ and an interpretation $I$. We define notation $W,I \models \phi$ which means that $\phi$ is satisfied in $W,I$. For basic assertions, the definition of the satisfaction relation is given in the next few subsections. For a conjunction of assertions $\phi_1,\ldots,\phi_n$ we write $W,I \models \phi_1,\ldots,\phi_n$ to indicate that $W,I \models \phi_1$ and ... and $W,I \models \phi_n$ hold.

TODO: Satisfiability of additional formulas to explain constraints/inferences

## Attribute matching

We say that an object $obj$ matches attributes $[attr_1=val_1,...]$ in world $W$ provided:

• for each attribute $attr_i$, we have $W.value(obj,attr_i) = val_i$.

This is sometimes abbreviated as: $match(W,obj,attrs)$

## Semantics of Element Records

### Entity Records

An entity formula is of the form $entity(id,attrs)$ where $id$ denotes an entity.

Entity assertions $entity(id,attrs)$ can be interpreted as follows:

• $W,I \models entity(id,attrs)$ if and only if:
1. [WF] $id$ denotes an entity $ent = I(id) \in Entities$
2. the attributes match: $match(W,ent, attrs)$.

For example, the following formulas both hold if $x$ denotes an entity $e$ such that $value(e,a) = 4, value(e,b) = 5, value(e,c) = 6$ hold:

entity(x,[a=4,b=5])
entity(x,[a=4,b=5,c=6])


### Activity Records

An activity record is of the form $activity(id,st,et,attrs)$ where $id$ is a identifier referring to the activity, $st$ is a start time and $et$ is an end time.

• We say that $W,I \models activity(id,st,et,attrs)$ if and only if:
1. [WF] The identifier $id$ maps to an activity $act = I(id) \in Activities$
2. If $st$ is specified then it is equal to the start time of the activity, that is: $min(lifetime(id)) = st$
3. If $et$ is specified then it is equal to the end time of the activity, that is: $max(lifetime(id)) = et$
4. The attributes match: $match(W,act,attrs)$.

### Agent Records

An agent formula is of the form $agent(id,attrs)$ where $id$ denotes the agent and $attrs$ describes additional attributes.

Agent assertions $agent(id,attrs)$ can be interpreted as follows:

• $W,I \models agent(id,attrs)$ if and only if:
1. [WF] $id$ denotes an agent $ag = I(id) \in Agents$
2. The attributes match: $match(W,ag,attrs)$.

## Semantics of Relations

### Entity-Activity

#### Generation

The generation assertion is of the form $wasGeneratedBy(id,e,a,t,attrs)$ where $id$ is an event identifier, $e$ is an entity identifier, $a$ is an activity identifier, $attrs$ is a set of attribute-value pairs, and $t$ is an optional time.

• $W,I \models wasGeneratedBy(id,e,a,t,attrs)$ if and only if:
1. [WF] The identifier $id$ denotes an event $evt = I(id) \in Events$
2. [WF] The identifier $e$ denotes an entity $ent = I(e) \in Entities$
3. [WF] The identifier $a$ denotes an activity $act = I(a) \in Activities$.
4. The event $evt$ is involved in $act$, that is, such that $(evt,act) \in EventActivities$.
5. The type of $evt$ is $generation$, i.e. $type(evt) = generation$
6. The event $evt$ occurred at time $t$, i.e. $time(evt) = t$
7. The event $evt$ generated $ent$, i.e. $(evt,ent) \in Generated$.
8. The attribute values match: $match(W,evt,attrs)$

#### Use

The use assertion is of the form $used(id,a,e,t,attrs)$ where $id$ denotes an event, $a$ is an activity identifier, $e$ is an object identifier, $attrs$ is a set of attribute-value pairs, and $t$ is an optional time.

• $W,I \models used(id,a,e,t,attrs)$ if and only if:
1. [WF] The identifier $id$ denotes an event $evt = I(id) \in Events$
2. [WF] The identifier $a$ denotes an activity $act = I(id) \in Activities$
3. [WF] The identifier $e$ denotes an entity $ent = I(e) \in Entities$
4. The event $evt$ is part of $act$, i.e. $(evt,act) \in EventActivities$.
5. The type of $evt$ is $use$, i.e., $type(evt) = use$.
6. The event $evt$ occurred at time $t$, i.e. $time(evt) = t$
7. The event $evt$ used $obj$, i.e. $(evt,ent) \in Used$.
8. The attribute values match: $match(W,evt,attrs)$

#### Invalidation

The invalidation assertion is of the form $wasInvalidatedBy(id,e,a,t,attrs)$ where $id$ is an event identifier, $e$ is an entity identifier, $a$ is an activity identifier, $attrs$ is a set of attribute-value pairs, and $t$ is an optional time.

• $W,I \models wasInvalidatedBy(id,e,a,t,attrs)$ if and only if:
1. [WF] The identifier $id$ denotes an event $evt = I(id) \in Events$
2. [WF] The identifier $e$ denotes an entity $ent = I(e) \in Entities$
3. [WF] The identifier $a$ denotes an activity $act = I(a) \in Activities$.
4. The event $evt$ is involved in $act$, that is, such that $(evt,act) \in EventActivities$.
5. The type of $evt$ is $invalidation$, i.e. $type(evt) = invalidation$
6. The event $evt$ occurred at time $t$, i.e. $time(evt) = t$
7. The event $evt$ invalidated $ent$, i.e. $(evt,ent) \in Invalidated$.
8. The attribute values match: $match(W,evt,attrs)$

### Agent-Activity

#### Association Records

An association record has the form $wasAssociatedWith(id,a,ag,pl,attrs)$.

• $W,I \models wasAssociatedWith(id,a,ag,pl,attrs)$ holds if and only if:
1. [WF] $assoc$ denotes an association $assoc = I(id) \in Associations$.
2. [WF] $a$ denotes an activity $act = I(a) \in Activities$.
3. [WF] $ag$ denotes an agent $agent = I(ag) \in Agents$.
4. [WF] $pl$ is either the placeholder $-$ or denotes a plan $plan=I(pl) \in Plans$.
5. The association associates the agent with the activity and plan, i.e. $(assoc,agent,act,plan) \in AssociatedWith$.
6. The attributes match: $match(W,assoc,attrs)$.

#### Start Records

A start record $wasStartedBy(id,a2,e,a1,attrs)$ is interpreted as follows:

• $W,I \models wasStartedBy(id,a2,e,a1,attrs)$ holds if and only if:
1. [WF] $id$ denotes an event $evt = I(id) \in Events$
2. [WF] $a2$ denotes an activity $act2 = I(a2)$
3. [WF] $e$ denotes an entity $ent = I(e)$
4. [WF] $a1$ denotes an activity $act1 = I(a1)$
5. The event $evt$ has type $start$, i.e. $type(evt) = start$.
6. The event happened at the start of $act2$, that is, $(act2,evt) \in ActivitiesEvents$, and $min(lifetime(act2)) = time(evt)$.
7. The event happened during $act1$, that is, $(act1,evt) \in ActivitiesEvents$.
8. The attributes match: $match(W,evt,attrs)$.

#### End Records

An activity end record $wasEndedBy(id,a2,e,a1,attrs)$ is interpreted as follows:

• $W,I \models wasEndedBy(id,a2,e,a1,attrs)$ holds if and only if:
1. [WF] $id$ denotes an event $evt = I(id) \in Events$
2. [WF] $a2$ denotes an activity $act2 = I(a2)$
3. [WF] $e$ denotes an entity $ent = I(e)$
4. [WF] $a1$ denotes an activity $act1 = I(a1)$
5. The event $evt$ has type $end$, i.e. $type(evt) = end$.
6. The event happened at the end of $act2$, that is, $(act2,evt) \in ActivitiesEvents$, and $max(lifetime(act2)) = time(evt)$.
7. The event happened during $act1$, that is, $(act1,evt) \in ActivitiesEvents$.
8. The attributes match: $match(W,evt,attrs)$.

### Agent-Entity

#### Attribution Records

An attribution record $wasAttributedTo(id,e,ag,attrs)$ is interpreted as follows:

• $W,I \models wasAttributedTo(id,e,ag,attrs)$ holds if and only if:
1. [WF] $id$ denotes an event $evt = I(id)$ that is also an association $evt \in Associations$
2. [WF] $e$ denotes an entity $ent = I(e)$
3. [WF] $ag$ denotes an agent $agent = I(ag)$
4. The event $evt$ has type $attribution$, i.e. $type(evt) = attribution$.
5. The entity was attributed to the agent, i.e. $(id,ent,ag) \in AttributedTo$
6. The attributes match: $match(W,evt,attrs)$.

### Agent-Agent

#### Responsibility

The $actedOnBehalfOf(id,ag2,ag1,act,attrs)$ relation is interpreted using the $ActsFor$ relation as follows:

• $W,I \models actedOnBehalfOf(id,ag2,ag1,act,attrs)$ holds if and only if:
1. [WF] $id$ denotes an association $assoc=I(id) \in Associations$ that is an association interaction, and $type(id) = responsibility$.
2. [WF] $a$ denotes an activity $act=I(a) \in Activities$ is an activity.
3. [WF] $ag1,ag2$ denote agents $agent1=I(ag1), agent2=I(ag2) \in Agents$ are agents.
4. The agent $agent2$ acts for the agent $agent1$ with respect to the activity $act$, i.e. $(agent2,agent1,act) \in ActsFor$.
5. [Redundant?] The association $id$ associates both agents with the activity, i.e. $(assoc,agent1,act),(assoc,agent2,act) \in AssociatedWith$.
6. The attributes match: $match(W,assoc,attrs)$.

### Entity-Entity

#### Derivation

##### Precise

A precise derivation record has the form $wasDerivedFrom(id,e2,e1,a,g,u,attrs)$.

• $W,I \models wasDerivedFrom(id,e2,e1,act,g,u,attrs)$ if and only if:
1. [WF] $id$ denotes a derivation $deriv = I(id) \in Derivations$
2. [WF] $e1,e2$ denote entities $ent1 = I(e1), ent2=I(e2) \in Entities$
3. [WF] $a$ denotes an activity $act = I(a) \in Activities$
4. [WF] $g$ denotes a generation event $gen = I(g) \in Events$ and $type(I(g)) = generation$
5. [WF] $u$ denotes a use event $I(u) \in Events$ and $type(I(u)) = use$
6. The derivation denotes a valid one-step derivation $derivedFrom(deriv) = I(e2) \cdot I(g) \cdot I(act) \cdot I(u) \cdot I(e1)$
7. The attribute values match: $match(W,deriv,attrs)$.

##### Imprecise

An imprecise derivation record has the form $wasDerivedFrom(id,e2,e1,-,-,-,attrs)$.

• $W,I \models wasDerivedFrom(id,e2,e1,-,-,-,attrs)$ if and only if there exists $path \in DerivationPaths$ such that:
1. [WF] $id$ denotes a derivation $deriv = I(id) \in Derivations$
2. [WF] $e1,e2$ denote entities $ent1 = I(e1), ent2=I(e2) \in Entities$
3. $derivedFrom(deriv)= ent2 \cdot w \cdot ent1$ for some $w$
4. The attribute values match: $match(W,deriv,attrs)$.

#### Specialization

The $specializationOf(e1,e2)$ relation indicates when one entity record presents more specific aspects of another.

• $W,I \models specializationOf(e1,e2)$ if and only if:
1. [WF] Both $e1$ and $e2$ are entity identifiers, denoting $ent_1 = I(e1) \in Entities$ and $ent_2 = I(e2) \in Entities$.
2. The two Entities refer to the same Thing, that is, $thingOf(ent_1) = thingOf(ent_2)$.
3. The lifetime of $obj_1$ is contained in that of $ent_2$,i.e. $lifetime(ent_1) \subseteq lifetime(ent_2)$.
4. For each attribute such that $value(obj_2,a) \neq \bot$ we have $value(obj_1,attr) = value(obj_2,attr)$.

The second criterion says that the two Entities present aspects of the same Thing. Note that the third criterion allows $obj_1$ and $obj_2$ to have the same lifetime (or that of $obj_2$ can be larger). The last criterion allows $obj_1$ to have more defined attributes than $obj_2$, but they must agree on the attributes defined by $obj_2$.

Remark: There has been discussion whether $specializationOf$ is transitive and/oranti-symmetric:

• Transitivity: If $specializationOf(a,b)$ and $specializationOf(b,c)$ hold then $specializationOf(a,c)$ hold. This holds for the above definition.
• Antisymmetry: If $specializationOf(a,b)$ and $specializationOf(b,a)$ hold then $a=b$. This doesn't follow from the current definition (but it would if we stipulated that two entities that have the same interval, attribute and thing are equal).

#### Alternate

The $alternateOf$ relation indicates when two entity records present (possibly different) aspects of the same thing. The two entities may or may not overlap in time.

• $W,I \models alternateOf(e1,e2)$ if and only if:
1. [WF] Both $e1$ and $e2$ are entity identifiers, denoting $ent_1 = I(e1)$ and $ent_2 = I(e2)$.
2. The two objects refer to the same underlying Thing: $thingOf(ent_1) = thingOf(ent_2)$

Remark: There has been discussion whether $alternateOf$ is symmetric and transitive:

• Symmetry: If $alternateOf(a,b)$ holds then $alternateOf(b,a)$ holds.
• Transitivity: If $alternateOf(a,b)$ and $alternateOf(b,c)$ hold then $alternateOf(a,c)$ hold. This holds of the above definition.

We also consider the following properties which have been suggested:

• $specializationOf(e_1,e_2)$ implies $alternateOf(e_1,e_2)$? (This holds at the moment.)
• $alternateOf(a, b)$ if and only if there exists c such that $specializationOf(a,c)$ and $specializationOf(b,c)$? This does not necessarily hold without further assumptions about the Entities.

# Axiomatization

## Definitional Rules

The definitions are essentially used to map the compact notation and implicit placeholder notation used n PROV-N with the abstract syntax of PROV-DM used in the rest of this semantics. We can formalize the definitional expansion rules as follows:

### Definition 1 (optional-identifiers)

For each $r \in \{ used, wasGeneratedBy, wasInvalidatedBy, wasInfluencedBy, wasStartedBy, wasEndedBy, wasInformedBy, wasDerivedFrom, wasAttributedTo, wasAssociatedWith, actedOnBehalfOf\}$ the following axioms hold:

1. $r(a_1,...,a_n) \iff \exists id.~ r(id; a_1,...,a_n)$

1. $r(-; a_1,...,a_n) \iff \exists id.~ r(id; a_1,...,a_n)$

### Definition 2 (optional-attributes)

1. For each p in {entity, activity, agent}, if $a_n$ is not an attribute list parameter then the following definitional rule holds: $p(a_1,...,a_n) \iff p(a_1,...,a_n,[])$
2. For each $r \in \{ used, wasGeneratedBy, wasInvalidated, wasInfluencedBy, wasStartedBy, wasEndedBy, wasInformedBy, wasDerivedFrom, wasAttributedTo, wasAssociatedWith, actedOnBehalfOf\}$, if $a_n$ is not an attribute list parameter then the following definition holds:

$r(id; a_1,...,a_n) \iff r(id; a_1,...,a_n,[])$

### Definition 3 (definition-short-forms)

1. $\forall id,attrs. ~ activity(id,attrs) \iff activity(id,-,-,attrs)$

1. $\forall id, e, attrs. ~ wasGeneratedBy(id; e,attrs) \iff wasGeneratedBy(id; e,-,-,attrs)$

1. $\forall id,a,attrs. ~ used(id; a,attrs) \iff used(id; a,-,-,attrs)$

1. $\forall id,a,attrs. ~ wasStartedBy(id; a,attrs) \iff wasStartedBy(id; a,-,-,-,attrs)$

1. $\forall id,a,attrs. ~ wasEndedBy(id; a,attrs) \iff wasEndedBy(id; a,-,-,-,attrs)$

1. $\forall id,e,attrs. ~ wasInvalidatedBy(id; e,attrs) \iff wasInvalidatedBy(id; e,-,-,attrs)$

1. $\forall id,e1,e2,attrs. ~ wasDerivedFrom(id; e2,e1,attrs) \iff wasDerivedFrom(id; e2,e1,-,-,-,attrs)$

1. $\forall id,e,attrs. ~ wasAssociatedWith(id; e,attrs) \iff wasAssociatedWith(id; e,-,-,attrs)$

1. $\forall id,a1,a2,attrs. ~ actedOnBehalfOf(id; a2,a1,attrs) \iff actedOnBehalfOf(id; a2,a1,-,attrs)$

### Definition 4 (optional-placeholders)

1. $activity(id,-,t2,attrs) \iff \exists t1.~ activity(id,t1,t2,attrs)$. Here, t2 may be a placeholder.
2. $activity(id,t1,-,attrs) \iff \exists t2.~activity(id,t1,t2,attrs)$. Here, t1 must not be a placeholder.
3. For each $r \in \{ used, wasGeneratedBy, wasStartedBy, wasEndedBy, wasInvalidatedBy, wasAssociatedWith, actedOnBehalfOf \}$, if the $i$th parameter of $r$ is an expandable parameter of $r$ as specified in Table 3 of PROV-CONSTRAINTS then the following definition holds:

$r(a_0;...,a_{i-1}, -, a_{i+1}, ...,a_n) \iff \exists a'.~ r(a_0;...,a_{i-1},a',a_{i+1},...,a_n)$.

1. $a \neq - \Rightarrow (wasDerivedFrom(id;e2,e1,a,-,u,attrs) \iff \exists g.~ wasDerivedFrom(id; e2,e1,a,g,u,attrs))$
2. $a \neq - \Rightarrow (wasDerivedFrom(id;e2,e1,a,g,-,attrs) \iff \exists u.~ wasDerivedFrom(id; e2,e1,a,g,u,attrs))$.

## Inference Rules

### Inference 5 (communication-generation-use-inference)

$\forall id, a_2,a_1,attrs. wasInformedBy(id; a_2,a_1,attrs) \Longrightarrow  \exists e, gen, t_1, use, t_2. wasGeneratedBy(gen; e,a_1,t_1,[]) \wedge used(use; a_2,e,t_2,[]) $

### Inference 6 (generation-use-communication-inference)

$\forall gen, a_1, t_1, attrs_1,id_2,a_2,t_2,attrs_2.~wasGeneratedBy(gen; e,a_1,t_1,attrs_1) \wedge used(id_2; a_2,e,t_2,attrs_2) \Longrightarrow \exists id.~wasInformedBy(id; a_2,a_1,[])$

### Inference 7 (entity-generation-invalidation-inference)

$\forall e,attrs.~entity(e,attrs) \Longrightarrow \exists gen,a_1,t_1,inv,a_2,t_2.~wasGeneratedBy(gen,e,a_1,t_1,[]) \wedge wasInvalidatedBy(inv,e,a_2,t_2,[])$

### Inference 8 (activity-start-end-inference)

$\forall a, t_1, t_2, attrs.~ activity(a,t_1,t_2,attrs) \Longrightarrow \exists start, e_1, a_1, end, a_2, e_2.~ wasStartedBy(start; a,e_1,a_1,t_1,[]) \wedge wasEndedBy(end; a,e_2,a_2,t_2,[])$

### Inference 9 (wasStartedBy-inference)

$\forall id, a, e_1, a_1, t, attrs.~ wasStartedBy(id; a,e_1,a_1,t,attrs), \Longrightarrow \exists gen, t_1.~ wasGeneratedBy(gen; e_1,a_1,t_1,[])$

### Inference 10 (wasEndedBy-inference)

$\forall id, a, e_1, a_1, t, attrs.~ wasEndedBy(id; a,e_1,a_1,t,attrs), \Longrightarrow \exists gen, t_1 .~ wasGeneratedBy(gen; e_1,a_1,t_1,[])$

### Inference 11 (derivation-generation-use-inference)

In this inference, none of a, gen2 or use1 can be placeholders -.

$\forall id, e_2, e_1, a, gen_2, use_1, attrs.~ wasDerivedFrom(id; e_2,e_1,a,gen_2,use_1,attrs) \Longrightarrow \exists t_1,t_2 .~ used(use_1; a,e_1,t_1,[]) \wedge wasGeneratedBy(gen_2; e_2,a,t_2,[])$

### Inference 12 (revision-is-alternate-inference)

In this inference, any of a, g or u may be placeholders.

$\forall id, e_1, e_2, a, g,u.~ wasDerivedFrom(id; e_2,e_1,a,g,u,[prov:type='prov:Revision']) \Longrightarrow alternateOf(e_2,e_1)$

### Inference 13 (attribution-inference)

$\forall att, e, ag, attrs.~ wasAttributedTo(att; e,ag,attrs) \Longrightarrow \exists a, t, gen, assoc, pl .~ wasGeneratedBy(gen; e,a,t,[]) \wedge wasAssociatedWith(assoc; a,ag,pl,[])$

### Inference 14 (delegation-inference)

$\forall id, ag_1, ag_2, a, attrs.~ actedOnBehalfOf(id; ag_1, ag_2, a, attrs) \Longrightarrow \exists id_1, pl_1, id_2, pl_2 .~ wasAssociatedWith(id_1; a, ag_1, pl_1, []) \wedge wasAssociatedWith(id_2; a, ag_2, pl_2, [])$

### Inference 15 (influence-inference)

1. $\forall id, e, a, t, attrs.~ wasGeneratedBy(id; e,a,t,attrs) \Longrightarrow wasInfluencedBy(id; e, a, attrs)$
2. $\forall id, a, e, t, attrs.~ used(id; a,e,t,attrs) \Longrightarrow wasInfluencedBy(id; a, e, attrs)$
3. $\forall id, a_2, a_1, attrs.~ wasInformedBy(id; a_2,a_1,attrs) \Longrightarrow wasInfluencedBy(id; a_2, a_1, attrs)$
4. $\forall id, a_2, e, a_1, t, attrs.~ wasStartedBy(id; a_2,e,a_1,t,attrs) \Longrightarrow wasInfluencedBy(id; a_2, e, attrs)$
5. $\forall id, a_2, e, a_1, t, attrs.~ wasEndedBy(id; a_2,e,a_1,t,attrs) \Longrightarrow wasInfluencedBy(id; a_2, e, attrs)$
6. $\forall id, e, a, t, attrs.~ wasInvalidatedBy(id; e,a,t,attrs) \Longrightarrow wasInfluencedBy(id; e, a, attrs)$
7. $\forall id, e_2, e_1, a, g, u, attrs.~ wasDerivedFrom(id; e_2, e_1, a, g, u, attrs) \Longrightarrow wasInfluencedBy(id; e_2, e_1, attrs).$ Here, a, g, u may be placeholders -.
8. $\forall id, e, ag, attrs.~ wasAttributedTo(id; e,ag,attrs) \Longrightarrow wasInfluencedBy(id; e, ag, attrs)$
9. $\forall id, a, ag, pl, attrs.~ wasAssociatedWith(id; a,ag,pl,attrs) \Longrightarrow wasInfluencedBy(id; a, ag, attrs)$ Here, pl may be a placeholder -.
10. $\forall id, ag_2, ag_1, a, attrs.~ actedOnBehalfOf(id; ag_2,ag_1,a,attrs) \Longrightarrow wasInfluencedBy(id; ag_2, ag_1, attrs)$

TODO: In 4 and 5, should e be a1? Otherwise these two rules are redundant since the influence of e on a2 can also be derived using other inferences.

### Inference 16 (alternate-reflexive)

$\forall e.~ entity(e) \Longrightarrow alternateOf(e,e)$

### Inference 17 (alternate-transitive)

$\forall e_1, e_2, e_3.~ alternateOf(e_1,e_2) \wedge alternateOf(e_2,e_3) \Longrightarrow alternateOf(e_1,e_3)$

### Inference 18 (alternate-symmetric)

$\forall e_1, e_2.~ alternateOf(e_1,e_2) \Longrightarrow alternateOf(e_2,e_1)$

### Inference 19 (specialization-transitive)

$\forall e_1, e_2, e_3 .~ specializationOf(e_1,e_2) \wedge specializationOf(e_2,e_3) \Longrightarrow specializationOf(e_1,e_3)$

### Inference 20 (specialization-alternate-inference)

$\forall e_1, e_2.~ specializationOf(e_1,e_2) \Longrightarrow alternateOf(e_1,e_2)$

### Inference 21 (specialization-attributes-inference)

$\forall e_1, attrs, e_2.~ entity(e_1, attrs) \wedge specializationOf(e_2,e_1), \Longrightarrow entity(e_2, attrs)$

## Constraints

### Constraint 22 (key-object)

1. The identifier field id is a KEY for the $entity(id,attrs)$ statement.
2. The identifier field id is a KEY for the $activity(id,t_1,t_2,attrs)$ statement.
3. The identifier field id is a KEY for the $agent(id,attrs)$ statement.

### Constraint 23 (key-properties)

1. The identifier field id is a KEY for the $wasGeneratedBy(id; e,a,t,attrs)$ statement.
2. The identifier field id is a KEY for the $used(id; a,e,t,attrs)$ statement.
3. The identifier field id is a KEY for the $wasInformedBy(id; a_2,a_1,attrs)$ statement.
4. The identifier field id is a KEY for the $wasStartedBy(id; a_2,e,a_1,t,attrs)$ statement.
5. The identifier field id is a KEY for the $wasEndedBy(id; a_2,e,a_1,t,attrs)$ statement.
6. The identifier field id is a KEY for the $wasInvalidatedBy(id; e,a,t,attrs)$ statement.
7. The identifier field id is a KEY for the $wasDerivedFrom(id; e_2, e_1, a, g2, u1, attrs)$ statement.
8. The identifier field id is a KEY for the $wasAttributedTo(id; e,ag,attr)$ statement.
9. The identifier field id is a KEY for the $wasAssociatedWith(id; a,ag,pl,attrs)$ statement.
1. The identifier field id is a KEY for the $actedOnBehalfOf(id; ag_2,ag_1,a,attrs)$ statement.
2. The identifier field id is a KEY for the $wasInfluencedBy(id; o2,o1,attrs)$ statement.

### Constraint 24 (unique-generation)

$\forall gen_1,gen_2,e,a,t_1,t_2,attrs_1,attrs_2.~wasGeneratedBy(gen_1,e,a,t_1,attrs_1) \wedge wasGeneratedBy(gen_2,e,a,t_2,attrs_2) \Longrightarrow gen_1 = gen_2$

### Constraint 25 (unique-invalidation)

$\forall inv_1,inv_2,e,a,t_1,t_2,attrs_1,attrs_2 .~ wasInvalidatedBy(inv_1; e,a,t_1,attrs_1) \wedge wasInvalidatedBy(inv_2; e,a,t_2,attrs_2), \Longrightarrow inv_1 = inv_2.$

### Constraint 26 (unique-wasStartedBy)

$\forall start_1,start_2,a,e_1,e_2,a_0,t_1,t_2,attrs_1,attrs_2 .~ wasStartedBy(start_1; a,e_1,a_0,t_1,attrs_1) \wedge wasStartedBy(start_2; a,e_2,a_0,t_2,attrs_2), \Longrightarrow start_1 = start_2.$

### Constraint 27 (unique-wasEndedBy)

$\forall end_1,end_2,a,e_1,e_2,a_0,t_1,t_2,attrs_1,attrs_2 .~ wasEndedBy(end_1; a,e_1,a0,t_1,attrs_1) \wedge wasEndedBy(end_2; a,e_2,a0,t_2,attrs_2), \Longrightarrow end_1 = end_2.$

### Constraint 28 (unique-startTime)

$\forall start,a_1,a_2,t,t_1,t_2,e,attrs,attrs_1 .~ activity(a_2,t_1,t_2,attrs) \wedge wasStartedBy(start; a_2,e,a_1,t,attrs_1) \Longrightarrow t_1=t.$

### Constraint 29 (unique-endTime)

$\forall end,a_1,a_2,t,t_1,t_2,e,attrs,attrs_1.~ activity(a_2,t_1,t_2,attrs) \wedge wasEndedBy(end; a_2,e,a_1,t,attrs_1) \Longrightarrow t_2 = t.$

### Constraint 30 (start-precedes-end)

$\forall start,end,a,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ wasStartedBy(start; a,e_1,a_1,t_1,attrs_1) \wedge wasEndedBy(end; a,e_2,a_2,t_2,attrs_2) \Longrightarrow start \preceq end.$

### Constraint 31 (start-start-ordering)

$\forall start_1,start_2,a,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ wasStartedBy(start_1; a,e_1,a_1,t_1,attrs_1) \wedge wasStartedBy(start_2; a,e_2,a_2,t_2,attrs_2) \Longrightarrow start_1 \preceq start_2.$

### Constraint 32 (end-end-ordering)

$\forall end_1,end_2,a,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ wasEndedBy(end_1; a,e_1,a_1,t_1,attrs_1) \wedge wasEndedBy(end_2; a,e_2,a_2,t_2,attrs_2) \Longrightarrow end_1 \preceq end2.$

### Constraint 33 (usage-within-activity)

1. $\forall start,use,a,e_1,e_2,a_1,t_1,t_2,attrs_1,attrs_2 .~ wasStartedBy(start; a,e_1,a_1,t_1,attrs_1) \wedge used(use; a,e_2,t_2,attrs_2) \Longrightarrow start \preceq use.$

1. $\forall use,end,a,e_1,e_2,a_2,t_1,t_2,attrs_1,attrs_2 .~ used(use; a,e_1,t_1,attrs_1) \wedge wasEndedBy(end; a,e_2,a_2,t_2,attrs_2) \Longrightarrow use \preceq end.$

### Constraint 34 (generation-within-activity)

1. $\forall start,gen,e_1,e_2,a,a_1,t_1,t_2,attrs_1,attrs_2 .~ wasStartedBy(start; a,e_1,a_1,t_1,attrs_1) \wedge wasGeneratedBy(gen; e_2,a,t_2,attrs_2) \Longrightarrow start \preceq gen.$

1. $\forall gen,end,e,e_1,a,a_1,t,t_1,attrs,attrs_1 .~ wasGeneratedBy(gen; e,a,t,attrs) \wedge wasEndedBy(end; a,e_1,a_1,t_1,attrs_1) \Longrightarrow gen \preceq end.$

### Constraint 35 (wasInformedBy-ordering)

$\forall id,start,end,a_1,a_1',a_2,a_2',e_1,e_2,t_1,t_2,attrs,attrs_1,attrs_2 .~ wasInformedBy(id; a_2,a_1,attrs) \wedge wasStartedBy(start; a_1,e_1,a_1',t_1,attrs_1) \wedge wasEndedBy(end; a_2,e_2,a_2',t_2,attrs_2) \Longrightarrow start \preceq end.$

### Constraint 36 (generation-precedes-invalidation)

$\forall gen,inv,e,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ wasGeneratedBy(gen; e,a_1,t_1,attrs_1) \wedge wasInvalidatedBy(inv; e,a_2,t_2,attrs_2) \Longrightarrow gen \preceq inv.$

### Constraint 37 (generation-precedes-usage)

$\forall gen,use,e,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ wasGeneratedBy(gen; e,a_1,t_1,attrs_1) \wedge used(use; a_2,e,t_2,attrs_2) \Longrightarrow gen \preceq use.$

### Constraint 38 (usage-precedes-invalidation)

$\forall use,inv,a_1,a_2,e,t_1,t_2,attrs_1,attrs_2 .~ used(use; a_1,e,t_1,attrs_1) \wedge wasInvalidatedBy(inv; e,a_2,t_2,attrs_2) \Longrightarrow use \preceq inv.$

### Constraint 39 (generation-generation-ordering)

$\forall gen_1,gen_2,e,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ wasGeneratedBy(gen_1; e,a_1,t_1,attrs_1) \wedge wasGeneratedBy(gen_2; e,a_2,t_2,attrs_2) \Longrightarrow gen_1 \preceq gen_2.$

### Constraint 40 (invalidation-invalidation-ordering)

$\forall inv_1,inv_2,e,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ wasInvalidatedBy(inv_1; e,a_1,t_1,attrs_1) \wedge wasInvalidatedBy(inv_2; e,a_2,t_2,attrs_2) \Longrightarrow inv_1 \preceq inv_2.$

### Constraint 41 (derivation-usage-generation-ordering)

In this constraint, $a$, $gen_2$, $use_1$ must not be placeholders.

$\forall d,e_1,e_2,a,gen_2,use_1,attrs .~ notNull(a) \wedge notNull(gen_2) \wedge notNull(use_1) \wedge wasDerivedFrom(d; e_2,e_1,a,gen_2,use_1,attrs) \Longrightarrow use_1 \preceq gen_2.$

### Constraint 42 (derivation-generation-generation-ordering)

In this constraint, any of $a$, $g$, $u$ may be placeholders.

$\forall d,gen_1,gen_2,e_1,e_2,a,a_1,a_2,g,u,t_1,t_2,attrs,attrs_1,attrs_2 .~ wasDerivedFrom(d; e_2,e_1,a,g,u,attrs) \wedge wasGeneratedBy(gen_1; e_1,a_1,t_1,attrs_1) \wedge wasGeneratedBy(gen_2; e_2,a_2,t_2,attrs_2) \Longrightarrow gen_1 \prec gen_2.$

### Constraint 43 (wasStartedBy-ordering)

1. $\forall gen,start,e,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ wasGeneratedBy(gen; e,a_1,t_1,attrs_1) \wedge wasStartedBy(start; a,e,a_2,t_2,attrs_2) \Longrightarrow gen \preceq start.$

1. $\forall start,inv,e,a,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ wasStartedBy(start; a,e,a_1,t_1,attrs_1) \wedge wasInvalidatedBy(inv; e,a_2,t_2,attrs_2) \Longrightarrow start \preceq inv.$

### Constraint 44 (wasEndedBy-ordering)

1. $\forall gen,end,e,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ wasGeneratedBy(gen; e,a_1,t_1,attrs_1) \wedge wasEndedBy(end; a,e,a_2,t_2,attrs_2) \Longrightarrow gen \preceq end.$

1. $\forall end,inv,e,a,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ wasEndedBy(end; a,e,a_1,t_1,attrs_1) \wedge wasInvalidatedBy(inv; e,a_2,t_2,attrs_2) \Longrightarrow end \preceq inv.$

### Constraint 45 (specialization-generation-ordering)

$\forall gen_1,gen_2,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ specializationOf(e_2,e_1) \wedge wasGeneratedBy(gen_1; e_1,a_1,t_1,attrs_1) \wedge wasGeneratedBy(gen_2; e_2,a_2,t_2,attrs_2) \Longrightarrow gen_1 \preceq gen_2. $

### Constraint 46 (specialization-invalidation-ordering)

$\forall inv_1,inv_2,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ specializationOf(e_1,e_2) \wedge wasInvalidatedBy(inv_1; e_1,a_1,t_1,attrs_1) \wedge wasInvalidatedBy(inv_2; e_2,a_2,t_2,attrs_2) \Longrightarrow inv_1 \preceq inv_2.$

### Constraint 47 (wasAssociatedWith-ordering)

In the following inferences, pl may be a placeholder -.

1. $\forall assoc,start_1,inv_2,ag,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ wasAssociatedWith(assoc; a,ag,pl,attrs) \wedge wasStartedBy(start_1; a,e_1,a_1,t_1,attrs_1) \wedge wasInvalidatedBy(inv_2; ag,a_2,t_2,attrs_2) \Longrightarrow start_1 \preceq inv_2.$

1. $\forall assoc,gen_1,end_2,ag,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ wasAssociatedWith(assoc; a,ag,pl,attrs) \wedge wasGeneratedBy(gen_1; ag,a_1,t_1,attrs_1) \wedge wasEndedBy(end_2; a,e_2,a_2,t_2,attrs_2) \Longrightarrow gen_1 \preceq end_2.$

1. $\forall assoc,start_1,end_2,ag,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~ wasAssociatedWith(assoc; a,ag,pl,attrs) \wedge wasStartedBy(start_1; a,e_1,a_1,t_1,attrs_1) \wedge wasEndedBy(end_2; ag,e_2,a_2,t_2,attrs_2) \Longrightarrow start_1 \preceq end_2.$

1. $\forall assoc,start_1,end_2,ag,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2 .~ wasAssociatedWith(assoc; a,ag,pl,attrs) \wedge wasStartedBy(start_1; ag,e_1,a_1,t_1,attrs_1) \wedge wasEndedBy(end_2; a,e_2,a_2,t_2,attrs_2) \Longrightarrow start_1 \preceq end_2.$

### Constraint 48 (wasAttributedTo-ordering)

1. $\forall att,gen_1,gen_2,e,a_1,a_2,t_1,t_2,ag,attrs,attrs_1,attrs_2 .~ wasAttributedTo(att; e,ag,attrs) \wedge wasGeneratedBy(gen_1; ag,a_1,t_1,attrs_1) \wedge wasGeneratedBy(gen_2; e,a_2,t_2,attrs_2) \Longrightarrow gen_1 \preceq gen_2.$

1. $\forall att,start_1,gen_2,e,e_1,a,a_2,ag,t_1,t_2,attrs,attrs_1,attrs_2 .~ wasAttributedTo(att; e,ag,attrs) \wedge wasStartedBy(start_1; ag,e_1,a_1,t_1,attrs_1) \wedge wasGeneratedBy(gen_2; e,a_2,t_2,attrs_2) \Longrightarrow start_1 \preceq gen_2.$

### Constraint 49 (actedOnBehalfOf-ordering)

1. $\forall del,gen_1,inv_2,ag_1,ag_2,a,a_1,a_2,t_1,t_2,attrs,attrs_1,attrs_2 .~ actedOnBehalfOf(del; ag_2,ag_1,a,attrs) \wedge wasGeneratedBy(gen_1; ag_1,a_1,t_1,attrs_1) \wedge wasInvalidatedBy(inv_2; ag_2,a_2,t_2,attrs_2) \Longrightarrow gen_1 \preceq inv_2.$

1. $\forall del,start_1,end_2, ag_1,ag_2,a,a_1,a_2,e_1,e_2,t_1,t_2,attrs,attrs_1,attrs_2 .~ actedOnBehalfOf(del; ag_2,ag_1,a,attrs) \wedge wasStartedBy(start_1; ag_1,e_1,a_1,t_1,attrs_1) \wedge wasEndedBy(end2; ag_2,e_2,a_2,t_2,attrs_2) \Longrightarrow start_1 \preceq end2.$

### Constraint 50 (typing)

1. $\forall e,attrs .~ entity(e,attrs) \Longrightarrow entity \in typeOf(e).$

1. $\forall ag,attrs .~ agent(ag,attrs) \Longrightarrow agent \in typeOf(ag).$

1. $\forall a,t_1,t_2,attrs .~ activity(a,t_1,t_2,attrs) \Longrightarrow activity \in typeOf(a).$

1. $\forall u,a,e,t,attrs .~ used(u; a,e,t,attrs) \Longrightarrow activity \in typeOf(a) \wedge entity \in typeOf(e).$

1. $\forall gen,e,a,t,attrs .~ wasGeneratedBy(gen; e,a,t,attrs) \Longrightarrow entity \in typeOf(e) \wedge activity \in typeOf(a).$

1. $\forall id,a_1,a_2,attrs .~ wasInformedBy(id; a_2,a_1,attrs) \Longrightarrow activity \in typeOf(a_2) \wedge activity \in typeOf(a_1).$

1. $\forall id,a_1,a_2,e,t,attrs .~ wasStartedBy(id; a_2,e,a_1,t,attrs) \Longrightarrow activity \in typeOf(a_2) \wedge entity \in typeOf(e) \wedge activity \in typeOf(a_1).$

1. $\forall id,a_1,a_2,e,t,attrs .~ wasEndedBy(id; a_2,e,a_1,t,attrs) \Longrightarrow activity \in typeOf(a_2) \wedge entity \in typeOf(e) \wedge activity \in typeOf(a_1).$

1. $\forall id, e,a,t,attrs .~ wasInvalidatedBy(id; e,a,t,attrs) \Longrightarrow entity \in typeOf(e) \wedge activity \in typeOf(a).$

1. In this constraint, $a$, $g_2$, and $u_1$ must not be placeholders.$\forall id, e_2, e_1, a, g2, u1, attrs .~ notNull(a) \wedge notNull(g_2) \wedge notNull(u_1) \wedge wasDerivedFrom(id; e_2, e_1, a, g2, u1, attrs) \Longrightarrow entity \in typeOf(e_2) \wedge entity \in typeOf(e_1) \wedge activity \in typeOf(a).$

1. $\forall id,e_1,e_2,attrs .~ wasDerivedFrom(id; e_2, e_1, -, -, -, attrs) \Longrightarrow entity \in typeOf(e_2) \wedge entity \in typeOf(e_1).$

1. $\forall id, e,ag,attr .~ wasAttributedTo(id; e,ag,attr) \Longrightarrow entity \in typeOf(e) \wedge agent \in typeOf(ag).$

1. In this constraint, $pl$ must not be a placeholder.$\forall id, a,ag,pl,attrs .~ notNull(pl) \wedge wasAssociatedWith(id; a,ag,pl,attrs) \Longrightarrow activity \in typeOf(a) \wedge agent \in typeOf(ag) \wedge entity \in typeOf(pl).$

1. $\forall id, a,ag,attrs .~ wasAssociatedWith(id; a,ag,-,attrs) \Longrightarrow activity \in typeOf(a) \wedge agent \in typeOf(ag).$

1. $\forall id, ag_2,ag_1,a,attrs .~ actedOnBehalfOf(id; ag_2,ag_1,a,attrs) \Longrightarrow agent \in typeOf(ag_2) \wedge agent \in typeOf(ag_1) \wedge activity \in typeOf(a).$

1. $\forall e_2, e_1 .~ alternateOf(e_2, e_1) \Longrightarrow entity \in typeOf(e_2) \wedge entity \in typeOf(e_1).$

1. $\forall e_2, e_1 .~ specializationOf(e_2, e_1) \Longrightarrow entity \in typeOf(e_2) \wedge entity \in typeOf(e_1).$

1. $\forall c,e .~ hadMember(c,e) \Longrightarrow prov:Collection \in typeOf(c) \wedge entity \in typeOf(c) \wedge entity \in typeOf(e).$

1. $\forall c .~ entity(c,[prov:type=prov:EmptyCollection]) \Longrightarrow entity \in typeOf(c) \wedge prov:Collection \in typeOf(c) \wedge prov:EmptyCollection \in typeOf(c).$

### Constraint 51 (impossible-unspecified-derivation-generation-use)

In the following rules, g and u must not be -.

1. $\forall id,e_1,e_2,g,attrs .~ notNull(g) \wedge wasDerivedFrom(id;e_2,e_1,-,g,-,attrs) \Longrightarrow False$

1. $\forall id,e_1,e_2,u,attrs .~ notNull(u) \wedge wasDerivedFrom(id;e_2,e_1,-,-,u,attrs) \Longrightarrow False$

1. $\forall id,e_1,e_2,g,u,attrs .~ notNull(g) \wedge notNull(u) \wedge wasDerivedFrom(id;e_2,e_1,-,g,u,attrs) \Longrightarrow False$

### Constraint 52 (impossible-specialization-reflexive)

$\forall e .~ specializationOf(e,e) \Longrightarrow False$

### Constraint 53 (impossible-property-overlap)

For each $r$ and $s \in \{ used, wasGeneratedBy, wasInvalidatedBy, wasStartedBy, wasEndedBy, wasInformedBy, wasAttributedTo, wasAssociatedWith, actedOnBehalfOf\}$ such that $r$ and $s$ are different relation names, the following constraint holds:

$\forall id,a_1,\ldots,a_m,b_1,\ldots,b_n .~ r(id; a_1,...,a_m) \wedge s(id; b_1,...,b_n) \Longrightarrow False$

### Constraint 54 (impossible-object-property-overlap)

For each $p \in \{entity, activity, agent\}$ and for each $r \in \{ used, wasGeneratedBy, wasInvalidatedBy, wasInfluencedBy, wasStartedBy, wasEndedBy, wasInformedBy, wasDerivedFrom, wasAttributedTo, wasAssociatedWith, actedOnBehalfOf\}$, the following impossibility constraint holds:

$\forall id,a_1,\ldots,a_m,b_1,\ldots,b_n.~ p(id,a_1,\ldots,a_m) \wedge r(id; b_1,\ldots,b_n) \Longrightarrow False$

### Constraint 55 (entity-activity-disjoint)

$\forall id .~ entity \in typeOf(id) \wedge activity \in typeOf(id) \Longrightarrow False$

### Constraint 56 (membership-empty-collection)

$\forall c,e.~hasMember(c,e) \wedge prov:EmptyCollection \in typeOf(c) \Longrightarrow False$

## Automatically generated inferences

### Inference 5 (communication-generation-use-inference)

$\forall id,a_2,a_1,attrs.~wasInformedBy(id,a_2,a_1,attrs) \Longrightarrow \exists e,gen,t_1,use,t_2.~wasGeneratedBy(gen,e,a_1,t_1,[]) \wedge used(use,a_2,e,t_2,[])$

### Inference 6 (generation-use-communication-inference)

$\forall gen,e,a_1,t_1,attrs_1,id_2,a_2,t_2,attrs_2.~wasGeneratedBy(gen,e,a_1,t_1,attrs_1) \wedge used(id_2,a_2,e,t_2,attrs_2) \Longrightarrow \exists id.~wasInformedBy(id,a_2,a_1,[])$

### Inference 7 (entity-generation-invalidation-inference)

$\forall e,attrs.~entity(e,attrs) \Longrightarrow \exists gen,a_1,t_1,inv,a_2,t_2.~wasGeneratedBy(gen,e,a_1,t_1,[]) \wedge wasInvalidatedBy(inv,e,a_2,t_2,[])$

### Inference 8 (activity-start-end-inference)

$\forall a,t_1,t_2,attrs.~activity(a,t_1,t_2,attrs) \Longrightarrow \exists start,e_1,a_1,end,a_2,e_2.~wasStartedBy(start,a,e_1,a_1,t_1,[]) \wedge wasEndedBy(end,a,e_2,a_2,t_2,[])$

### Inference 9 (wasStartedBy-inference)

$\forall id,a,e_1,a_1,t,attrs.~wasStartedBy(id,a,e_1,a_1,t,attrs) \Longrightarrow \exists gen,t_1.~wasGeneratedBy(gen,e_1,a_1,t_1,[])$

### Inference 10 (wasEndedBy-inference)

$\forall id,a,e_1,a_1,t,attrs.~wasEndedBy(id,a,e_1,a_1,t,attrs) \Longrightarrow \exists gen,t_1.~wasGeneratedBy(gen,e_1,a_1,t_1,[])$

### Inference 11 (derivation-generation-use-inference)

In this inference, none of a, gen2 or use_1 can be placeholders -.$\forall id,e_2,e_1,a,gen_2,use_1,attrs.~notNull(a) \wedge notNull(gen_2) \wedge notNull(use_1) \wedge wasDerivedFrom(id,e_2,e_1,a,gen_2,use_1,attrs) \Longrightarrow \exists t_1,t_2.~used(use_1,a,e_1,t_1,[]) \wedge wasGeneratedBy(gen_2,e_2,a,t_2,[])$

### Inference 12 (revision-is-alternate-inference)

In this inference, any of a, g or u may be placeholders.$\forall id,e_1,e_2,a,g,u.~wasDerivedFrom(id,e_2,e_1,a,g,u,.(prov:type = prov:Revision,[])) \Longrightarrow alternateOf(e_2,e_1)$

### Inference 13 (attribution-inference)

$\forall att,e,ag,attrs.~wasAttributedTo(att,e,ag,attrs) \Longrightarrow \exists a,t,gen,assoc,pl.~wasGeneratedBy(gen,e,a,t,[]) \wedge wasAssociatedWith(assoc,a,ag,pl,[])$

### Inference 14 (delegation-inference)

$\forall id,ag_1,ag_2,a,attrs.~actedOnBehalfOf(id,ag_1,ag_2,a,attrs) \Longrightarrow \exists id_1,pl_1,id_2,pl_2.~wasAssociatedWith(id_1,a,ag_1,pl_1,[]) \wedge wasAssociatedWith(id_2,a,ag_2,pl_2,[])$

### Inference 15 (influence-inference)

1. $\forall id,e,a,t,attrs.~wasGeneratedBy(id,e,a,t,attrs) \Longrightarrow wasInfluencedBy(id,e,a,attrs)$

1. $\forall id,a,e,t,attrs.~used(id,a,e,t,attrs) \Longrightarrow wasInfluencedBy(id,a,e,attrs)$

1. $\forall id,a_2,a_1,attrs.~wasInformedBy(id,a_2,a_1,attrs) \Longrightarrow wasInfluencedBy(id,a_2,a_1,attrs)$

1. $\forall id,a_2,e,a_1,t,attrs.~wasStartedBy(id,a_2,e,a_1,t,attrs) \Longrightarrow wasInfluencedBy(id,a_2,e,attrs)$

1. $\forall id,a_2,e,a_1,t,attrs.~wasEndedBy(id,a_2,e,a_1,t,attrs) \Longrightarrow wasInfluencedBy(id,a_2,e,attrs)$

1. $\forall id,e,a,t,attrs.~wasInvalidatedBy(id,e,a,t,attrs) \Longrightarrow wasInfluencedBy(id,e,a,attrs)$

1. $\forall id,e_2,e_1,a,g,u,attrs.~wasDerivedFrom(id,e_2,e_1,a,g,u,attrs) \Longrightarrow wasInfluencedBy(id,e_2,e_1,attrs)$

1. In this rule, a, g, u may be placeholders -.$\forall id,e,ag,attrs.~wasAttributedTo(id,e,ag,attrs) \Longrightarrow wasInfluencedBy(id,e,ag,attrs)$

1. In this rule, pl may be a placeholder -.$\forall id,a,ag,pl,attrs.~wasAssociatedWith(id,a,ag,pl,attrs) \Longrightarrow wasInfluencedBy(id,a,ag,attrs)$

1. $\forall id,ag_2,ag_1,a,attrs.~actedOnBehalfOf(id,ag_2,ag_1,a,attrs) \Longrightarrow wasInfluencedBy(id,ag_2,ag_1,attrs)$

### Inference 16 (alternate-reflexive)

$\forall e.~entity(e) \Longrightarrow alternateOf(e,e)$

### Inference 17 (alternate-transitive)

$\forall e_1,e_2,e_3.~alternateOf(e_1,e_2) \wedge alternateOf(e_2,e_3) \Longrightarrow alternateOf(e_1,e_3)$

### Inference 18 (alternate-symmetric)

$\forall e_1,e_2.~alternateOf(e_1,e_2) \Longrightarrow alternateOf(e_2,e_1)$

### Inference 19 (specialization-transitive)

$\forall e_1,e_2,e_3.~specializationOf(e_1,e_2) \wedge specializationOf(e_2,e_3) \Longrightarrow specializationOf(e_1,e_3)$

### Inference 20 (specialization-alternate-inference)

$\forall e_1,e_2.~specializationOf(e_1,e_2) \Longrightarrow alternateOf(e_1,e_2)$

### Inference 21 (specialization-attributes-inference)

$\forall e_1,attrs,e_2.~entity(e_1,attrs) \wedge specializationOf(e_2,e_1) \Longrightarrow entity(e_2,attrs)$

### Constraint 24 (unique-generation)

$\forall gen_1,gen_2,e,a,t_1,t_2,attrs_1,attrs_2.~wasGeneratedBy(gen_1,e,a,t_1,attrs_1) \wedge wasGeneratedBy(gen_2,e,a,t_2,attrs_2) \Longrightarrow gen_1 = gen_2$

### Constraint 25 (unique-invalidation)

$\forall inv_1,inv_2,e,a,t_1,t_2,attrs_1,attrs_2.~wasInvalidatedBy(inv_1,e,a,t_1,attrs_1) \wedge wasInvalidatedBy(inv_2,e,a,t_2,attrs_2) \Longrightarrow inv_1 = inv_2$

### Constraint 26 (unique-wasStartedBy)

$\forall start_1,start_2,a,e_1,e_2,a_0,t_1,t_2,attrs_1,attrs_2.~wasStartedBy(start_1,a,e_1,a_0,t_1,attrs_1) \wedge wasStartedBy(start_2,a,e_2,a_0,t_2,attrs_2) \Longrightarrow start_1 = start_2$

### Constraint 27 (unique-wasEndedBy)

$\forall end_1,end_2,a,e_1,e_2,a_0,t_1,t_2,attrs_1,attrs_2.~wasEndedBy(end_1,a,e_1,a_0,t_1,attrs_1) \wedge wasEndedBy(end_2,a,e_2,a_0,t_2,attrs_2) \Longrightarrow end_1 = end_2$

### Constraint 28 (unique-startTime)

$\forall start,a_1,a_2,t,t_1,t_2,e,attrs,attrs_1.~activity(a_2,t_1,t_2,attrs) \wedge wasStartedBy(start,a_2,e,a_1,t,attrs_1) \Longrightarrow t_1 = t$

### Constraint 29 (unique-endTime)

$\forall end,a_1,a_2,t,t_1,t_2,e,attrs,attrs_1.~activity(a_2,t_1,t_2,attrs) \wedge wasEndedBy(end,a_2,e,a_1,t,attrs_1) \Longrightarrow t_2 = t$

### Constraint 30 (start-precedes-end)

$\forall start,end,a,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasStartedBy(start,a,e_1,a_1,t_1,attrs_1) \wedge wasEndedBy(end,a,e_2,a_2,t_2,attrs_2) \Longrightarrow start \preceq end$

### Constraint 31 (start-start-ordering)

$\forall start_1,start_2,a,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasStartedBy(start_1,a,e_1,a_1,t_1,attrs_1) \wedge wasStartedBy(start_2,a,e_2,a_2,t_2,attrs_2) \Longrightarrow start_1 \preceq start_2$

### Constraint 32 (end-end-ordering)

$\forall end_1,end_2,a,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasEndedBy(end_1,a,e_1,a_1,t_1,attrs_1) \wedge wasEndedBy(end_2,a,e_2,a_2,t_2,attrs_2) \Longrightarrow end_1 \preceq end2$

### Constraint 33 (usage-within-activity)

1. $\forall start,use,a,e_1,e_2,a_1,t_1,t_2,attrs_1,attrs_2.~wasStartedBy(start,a,e_1,a_1,t_1,attrs_1) \wedge used(use,a,e_2,t_2,attrs_2) \Longrightarrow start \preceq use$

1. $\forall use,end,a,e_1,e_2,a_2,t_1,t_2,attrs_1,attrs_2.~used(use,a,e_1,t_1,attrs_1) \wedge wasEndedBy(end,a,e_2,a_2,t_2,attrs_2) \Longrightarrow use \preceq end$

### Constraint 34 (generation-within-activity)

1. $\forall start,gen,e_1,e_2,a,a_1,t_1,t_2,attrs_1,attrs_2.~wasStartedBy(start,a,e_1,a_1,t_1,attrs_1) \wedge wasGeneratedBy(gen,e_2,a,t_2,attrs_2) \Longrightarrow start \preceq gen$

1. $\forall gen,end,e,e_1,a,a_1,t,t_1,attrs,attrs_1.~wasGeneratedBy(gen,e,a,t,attrs) \wedge wasEndedBy(end,a,e_1,a_1,t_1,attrs_1) \Longrightarrow gen \preceq end$

### Constraint 35 (wasInformedBy-ordering)

$\forall id,start,end,a_1,a_1',a_2,a_2',e_1,e_2,t_1,t_2,attrs,attrs_1,attrs_2.~wasInformedBy(id,a_2,a_1,attrs) \wedge wasStartedBy(start,a_1,e_1,a_1',t_1,attrs_1) \wedge wasEndedBy(end,a_2,e_2,a_2',t_2,attrs_2) \Longrightarrow start \preceq end$

### Constraint 36 (generation-precedes-invalidation)

$\forall gen,inv,e,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasGeneratedBy(gen,e,a_1,t_1,attrs_1) \wedge wasInvalidatedBy(inv,e,a_2,t_2,attrs_2) \Longrightarrow gen \preceq inv$

### Constraint 37 (generation-precedes-usage)

$\forall gen,use,e,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasGeneratedBy(gen,e,a_1,t_1,attrs_1) \wedge used(use,a_2,e,t_2,attrs_2) \Longrightarrow gen \preceq use$

### Constraint 38 (usage-precedes-invalidation)

$\forall use,inv,a_1,a_2,e,t_1,t_2,attrs_1,attrs_2.~used(use,a_1,e,t_1,attrs_1) \wedge wasInvalidatedBy(inv,e,a_2,t_2,attrs_2) \Longrightarrow use \preceq inv$

### Constraint 39 (generation-generation-ordering)

$\forall gen_1,gen_2,e,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasGeneratedBy(gen_1,e,a_1,t_1,attrs_1) \wedge wasGeneratedBy(gen_2,e,a_2,t_2,attrs_2) \Longrightarrow gen_1 \preceq gen_2$

### Constraint 40 (invalidation-invalidation-ordering)

$\forall inv_1,inv_2,e,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasInvalidatedBy(inv_1,e,a_1,t_1,attrs_1) \wedge wasInvalidatedBy(inv_2,e,a_2,t_2,attrs_2) \Longrightarrow inv_1 \preceq inv_2$

### Constraint 41 (derivation-usage-generation-ordering)

In this constraint, $a$, $gen_2$, $use_1$ must not be placeholders.$\forall d,e_1,e_2,a,gen_2,use_1,attrs.~notNull(a) \wedge notNull(gen_2) \wedge notNull(use_1) \wedge wasDerivedFrom(d,e_2,e_1,a,gen_2,use_1,attrs) \Longrightarrow use_1 \preceq gen_2$

### Constraint 42 (derivation-generation-generation-ordering)

In this constraint, any of $a$, $g$, $u$ may be placeholders.$\forall d,gen_1,gen_2,e_1,e_2,a,a_1,a_2,g,u,t_1,t_2,attrs,attrs_1,attrs_2.~wasDerivedFrom(d,e_2,e_1,a,g,u,attrs) \wedge wasGeneratedBy(gen_1,e_1,a_1,t_1,attrs_1) \wedge wasGeneratedBy(gen_2,e_2,a_2,t_2,attrs_2) \Longrightarrow gen_1 \prec gen_2$

### Constraint 43 (wasStartedBy-ordering)

1. $\forall gen,start,e,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasGeneratedBy(gen,e,a_1,t_1,attrs_1) \wedge wasStartedBy(start,a,e,a_2,t_2,attrs_2) \Longrightarrow gen \preceq start$

1. $\forall start,inv,e,a,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasStartedBy(start,a,e,a_1,t_1,attrs_1) \wedge wasInvalidatedBy(inv,e,a_2,t_2,attrs_2) \Longrightarrow start \preceq inv$

### Constraint 44 (wasEndedBy-ordering)

1. $\forall gen,end,e,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasGeneratedBy(gen,e,a_1,t_1,attrs_1) \wedge wasEndedBy(end,a,e,a_2,t_2,attrs_2) \Longrightarrow gen \preceq end$

1. $\forall end,inv,e,a,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasEndedBy(end,a,e,a_1,t_1,attrs_1) \wedge wasInvalidatedBy(inv,e,a_2,t_2,attrs_2) \Longrightarrow end \preceq inv$

### Constraint 45 (specialization-generation-ordering)

$\forall gen_1,gen_2,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~specializationOf(e_2,e_1) \wedge wasGeneratedBy(gen_1,e_1,a_1,t_1,attrs_1) \wedge wasGeneratedBy(gen_2,e_2,a_2,t_2,attrs_2) \Longrightarrow gen_1 \preceq gen_2$

### Constraint 46 (specialization-invalidation-ordering)

$\forall inv_1,inv_2,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~specializationOf(e_1,e_2) \wedge wasInvalidatedBy(inv_1,e_1,a_1,t_1,attrs_1) \wedge wasInvalidatedBy(inv_2,e_2,a_2,t_2,attrs_2) \Longrightarrow inv_1 \preceq inv_2$

### Constraint 47 (wasAssociatedWith-ordering)

In the following inferences, pl may be a placeholder -.

1. $\forall assoc,start_1,inv_2,ag,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasAssociatedWith(assoc,a,ag,pl,attrs) \wedge wasStartedBy(start_1,a,e_1,a_1,t_1,attrs_1) \wedge wasInvalidatedBy(inv_2,ag,a_2,t_2,attrs_2) \Longrightarrow start_1 \preceq inv_2$

1. $\forall assoc,gen_1,end_2,ag,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasAssociatedWith(assoc,a,ag,pl,attrs) \wedge wasGeneratedBy(gen_1,ag,a_1,t_1,attrs_1) \wedge wasEndedBy(end_2,a,e_2,a_2,t_2,attrs_2) \Longrightarrow gen_1 \preceq end_2$

1. $\forall assoc,start_1,end_2,ag,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasAssociatedWith(assoc,a,ag,pl,attrs) \wedge wasStartedBy(start_1,a,e_1,a_1,t_1,attrs_1) \wedge wasEndedBy(end_2,ag,e_2,a_2,t_2,attrs_2) \Longrightarrow start_1 \preceq end_2$

1. $\forall assoc,start_1,end_2,ag,e_1,e_2,a_1,a_2,t_1,t_2,attrs_1,attrs_2.~wasAssociatedWith(assoc,a,ag,pl,attrs) \wedge wasStartedBy(start_1,ag,e_1,a_1,t_1,attrs_1) \wedge wasEndedBy(end_2,a,e_2,a_2,t_2,attrs_2) \Longrightarrow start_1 \preceq end_2$

### Constraint 48 (wasAttributedTo-ordering)

1. $\forall att,gen_1,gen_2,e,a_1,a_2,t_1,t_2,ag,attrs,attrs_1,attrs_2.~wasAttributedTo(att,e,ag,attrs) \wedge wasGeneratedBy(gen_1,ag,a_1,t_1,attrs_1) \wedge wasGeneratedBy(gen_2,e,a_2,t_2,attrs_2) \Longrightarrow gen_1 \preceq gen_2$

1. $\forall att,start_1,gen_2,e,e_1,a,a_2,ag,t_1,t_2,attrs,attrs_1,attrs_2.~wasAttributedTo(att,e,ag,attrs) \wedge wasStartedBy(start_1,ag,e_1,a_1,t_1,attrs_1) \wedge wasGeneratedBy(gen_2,e,a_2,t_2,attrs_2) \Longrightarrow start_1 \preceq gen_2$

### Constraint 49 (actedOnBehalfOf-ordering)

1. $\forall del,gen_1,inv_2,ag_1,ag_2,a,a_1,a_2,t_1,t_2,attrs,attrs_1,attrs_2.~actedOnBehalfOf(del,ag_2,ag_1,a,attrs) \wedge wasGeneratedBy(gen_1,ag_1,a_1,t_1,attrs_1) \wedge wasInvalidatedBy(inv_2,ag_2,a_2,t_2,attrs_2) \Longrightarrow gen_1 \preceq inv_2$

1. $\forall del,start_1,end_2,ag_1,ag_2,a,a_1,a_2,e_1,e_2,t_1,t_2,attrs,attrs_1,attrs_2.~actedOnBehalfOf(del,ag_2,ag_1,a,attrs) \wedge wasStartedBy(start_1,ag_1,e_1,a_1,t_1,attrs_1) \wedge wasEndedBy(end2,ag_2,e_2,a_2,t_2,attrs_2) \Longrightarrow start_1 \preceq end2$

### Constraint 51 (impossible-unspecified-derivation-generation-use)

1. $\forall id,e_1,e_2,g,attrs.~notNull(g) \wedge wasDerivedFrom(id,e_2,e_1,-,g,-,attrs) \Longrightarrow False$

1. $\forall id,e_1,e_2,u,attrs.~notNull(u) \wedge wasDerivedFrom(id,e_2,e_1,-,-,u,attrs) \Longrightarrow False$

1. $\forall id,e_1,e_2,g,u,attrs.~notNull(g) \wedge notNull(u) \wedge wasDerivedFrom(id,e_2,e_1,-,g,u,attrs) \Longrightarrow False$

### Constraint 52 (impossible-specialization-reflexive)

$\forall e.~specializationOf(e,e) \Longrightarrow False$

### Constraint 55 (entity-activity-disjoint)

$\forall id.~entity \in typeOf(id) \wedge activity \in typeOf(id) \Longrightarrow False$

### Constraint 56 (membership-empty-collection)

$\forall c,e.~hasMember(c,e) \wedge prov:EmptyCollection \in typeOf(c) \Longrightarrow False$