The Policy Enabled Next geNeration Internet (PENNI) project aims to lay the technical foundations for a policy, trust and transparency enabled decentralised Next Generation Internet (NGI), that can support intelligent agents that act on behalf of humans.
Our hypothesis being that decentralized applications that are able to understand constraints, in the form of goals, preferences, norms and usage restrictions, together with trust and transparency mechanisms will give humans more control over how their data is utilised and will foster trustworthiness in NGI applications, such as intelligent agents and devices.
In this document, we propose representations that are suitable for recording service and thing policies, agent preferences, and organisational norms.
This work builds upon the 'Governance of Autonomous Agents on the Web: Challenges and Opportunities' paper [[TOIT-Governance]], which was co-authored by Timotheus Kampik, Adnane Mansour, Olivier Boissier, Julian Padget, Terry R. Payne, Munindar P. Singh, Valentina Tamma, Antoine Zimmermann. We sincerely thank Karen Sollins for her feedback on the initial draft of this document.
This document describes an OWL based language that are used to encode service and thing policies, agent preferences, and normative organisation norms.
We start by providing a high level overview of the 'Conceptual Framework for Governing Agents on the Web' [[TOIT-Governance]], which describes the role of policies, preferences, and norms when it comes to agent based systems. Following on from this we provide generic OWL based encodings for policies, preferences, and norms, as well as concrete examples. Finally, we use the motivating use case scenario detailed in 'Intelligent Software Web Agents: A Gap Analysis' [[JWS-Agent-Architecture]] to demonstrate the potential of the proposed language from a practicality perspective.
The overarching aim of this specification is to provide an OWL based language that are used by agents to reason with respect to policies, preferences, and norms. The language is inspired by the SPECIAL Policy language [[SPECIAL-Policies]] that are used to express policies that are used to verify compliance with General Data Protection Regulation (GDPR) obligations, especially those relating to consent for personal data processing.
The examples throughout the document are serialized using the [[OWL Functional Syntax]] and use the following prefixes:
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
PREFIX xsd: <http://www.w3.org/2001/XMLSchema#> .
PREFIX ppn: <http://www.penni.wu.ac.at/langs/policies-preferences-norms#> .
PREFIX ppnv: <http://www.penni.wu.ac.at/langs/policies-preferences-norms-vocab#> .
The primary objective of this section is to provide the necessary background in relation to the 'Conceptual framework for Governing Agents on the Web' [[TOIT-Governance]], which describes the role of policies, preferences and norms in a multi-agent system. The proposed conceptual framework serves as the theoretical foundation for the work presented here in.
The reactive things and services layer encapulates non-autonomous entities, in the form of things
and services
, which are connected to the internet.
Agents use their sensors and actuators in order to interact with such entities. Things and servies are governed by policies
that are used to specify both access and
usage restrictions.
The autonomous agents layer encapulates entities, namely agents
, which are capable of performing actions autonomously, such as interacting with other agents, things,
and services. Agent actions are guided by various preferences
(e.g., goals, agent preferences, service preferences). However these preferences
cannot be considered in isolation, as agents also need to consider policies that govern service and thing usage and legal and social norms that govern organisations.
The normative organisations layer encapulates (virtual) organisations
that enable agents to interact and collaboration and serve as the basis for developing complex
software agent systems. Organisations are logical groupings of agents that serve a particular business or social purpose. Organisations are governed by legal, regulatory and social norms
that can span multiple organisations.
In this section we present the foundational vocabulary elements that are core to the policies, preferences, and norms (PPN) language.
The following classes are core to all policies: The following properties are core to all policies: Domain and range constraints are used to ensure that ppn:hasRule (and its children) associate a ppn:Rule with a ppn:AgentRules: The following properties are functional (that is, for each x, there can be at most one distinct y such that x is connected with y via the given role):Classes
Declaration( Class( ppn:AgentRules ) )
Declaration( Class( ppn:Rule ) )
Declaration( Class( ppn:Subject ) )
Declaration( Class( ppn:Predicate ) )
Declaration( Class( ppn:Object ) )
Declaration( Class( ppn:Intent ) )
Properties
Declaration( ObjectProperty( ppn:hasRule ) )
Declaration( ObjectProperty( ppn:hasSubject ) )
Declaration( ObjectProperty( ppn:hasPredicate ) )
Declaration( ObjectProperty( ppn:hasObject ) )
Declaration( ObjectProperty( ppn:hasIntent ) )
Constraints
ObjectPropertyDomain( ppn:hasRule ppn:AgentRules )
ObjectPropertyRange( ppn:hasRule ppn:Rule )
FunctionalObjectProperty( ppn:hasSubject )
FunctionalObjectProperty( ppn:hasPredicate )
FunctionalObjectProperty( ppn:hasObject )
FunctionalObjectProperty( ppn:hasIntent )
Both access and usage policies are associated with reactive things and services. The former are used to specify who is permitted / prohibited from using services and/or things, whereas the latter are used to specify usage restrictions that apply after access has been granted.
The following subclasses are core to both access and usage policies:
SubClassOf( ppn:Action ppn:Predicate )
SubClassOf( ppn:AccessIntent ppnIntent )
SubClassOf( ppn:Permission ppn:AccessIntent )
SubClassOf( ppn:Prohibition ppn:AccessIntent )
The following subproperties are core to the access and usage policies:
SubObjectPropertyOf( ppn:hasAction ppn:hasPredicate )
We model access policies as one or more access rules that are used to state that a given subject (e.g., a user, role, group) is permitted to perform an action (e.g., read, write, share)
on a certain object (e.g., dataset, file, graph). Policies can contain both permissions
(positive authorisations) and prohibitions
(negative authorisations).
The following subclasses are core to access policies:
SubClassOf( ppn:AccessPolicy ppn:AgentRules )
SubClassOf( ppn:AccessRule ppn:Rule )
The following subproperties are core to access policies:
SubObjectPropertyOf( ppn:hasAccessRule ppn:hasRule )
Domain and range constraints for access policies:
ObjectPropertyDomain( ppn:hasAccessRule ppn:AccessPolicy )
ObjectPropertyRange( ppn:hasAccessRule ppn:AccessRule )
Conflicts that arise between rules can be handled via default conflict resolution strategies, for instance permissions override prohibitions or prohibitions override permissions. Additionally, meta policies can be used to define more elaborate conflict resolution strategies, for instance explicit authorisations override inferred authorisations.
Specific access policies are defined as follows:
ClassAssertion( ppn:AccessPolicy SomeAccessPolicy )
Specific access rules are defined as follows:
ClassAssertion( ppn:AccessRule SomeAccessRule )
Access rules are associated with policies using the ppn:hasAccessRule property:
ObjectPropertyAssertion( ppn:hasAccessRule
SomeAccessPolicy SomeAccessRule)
Access policies are modelled using an OWL 2 expression of the following form:
EquivalentClasses(
SomeAccessRule
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject SomeSubject )
ObjectSomeValuesFrom( ppn:hasObject SomeObject )
ObjectSomeValuesFrom( ppn:hasAction SomeAction )
ObjectSomeValuesFrom( ppn:hasIntent SomeAccessIntent )
)
)
For instance, an Access Policy could be used to specify that Lucy and Pete's agents are permitted to obtain a copy of Alice's medical data.
Ontology(
ClassAssertion( ppn:AccessPolicy ppn:DoctorsMedicalDataPolicy )
ClassAssertion( ppn:AccessRule ppn:AccessAlicesMedicalDataPermission )
ObjectPropertyAssertion( ppn:hasAccessRule
ppnv:DoctorsMedicalDataPolicy ppnv:AccessAlicesMedicalDataPermission )
EquivalentClasses(
ppnv:AccessAlicesMedicalDataPermission
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject ppnv:AlicesAgent )
ObjectSomeValuesFrom( ppn:hasObject ppnv:AlicesMedicalData )
ObjectSomeValuesFrom( ppn:hasAction ppnv:Access )
ObjectSomeValuesFrom( ppn:hasAccessIntent ppnv:Permission )
)
)
)
We model usage policies by extending basic access control policies (i.e. permissions
and prohibitions
) with obligations
and
dispensations
, aswell as providing support for purpose
specification. Thus usage policies are used to specify permitted, prohibited, obligued,
dispensated actions by subjects on target objects, possibly connected to specifc purposes.
The following classes and subclasses are core to usage policies:
Declaration( Class( ppn:Purpose ) )
SubClassOf( ppn:UsagePolicy ppn:AgentRules )
SubClassOf( ppn:UsageRule ppn:Rule )
SubClassOf( ppn:UsageIntent ppn:Intent )
SubClassOf( ppn:Obligation ppn:UsageIntent )
SubClassOf( ppn:Dispensation ppn:UsageIntent )
The following properties and subproperties are core to usage policies:
Declaration( ObjectProperty( ppn:hasPurpose ) )
SubObjectPropertyOf( ppn:hasUsageRule ppn:hasRule )
Domain and range constraints for usage policies:
ObjectPropertyDomain( ppn:hasUsageRule ppn:UsagePolicy )
ObjectPropertyRange( ppn:hasUsageRule ppn:UsageRule )
The following properties are functional (that is, for each x, there can be at most one distinct y such that x is connected with y via the given role):
FunctionalObjectProperty( ppn:hasPurpose )
Here again meta policies are needed in order to resolve conflicts.
Specific usage policies are defined as follows:
ClassAssertion( ppn:UsagePolicy SomeUsagePolicy )
Specific usage rules are defined as follows:
ClassAssertion( ppn:UsageRule SomeUsageRule )
Usage rules are associated with policies using the ppn:hasUsageRule property:
ObjectPropertyAssertion( ppn:hasUsageRule
SomeUsagePolicy SomeUsageRule )
Usage classes are modelled using an OWL 2 expression of the following form:
EquivalentClasses(
SomeUsageRule
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject SomeSubject )
ObjectSomeValuesFrom( ppn:hasObject SomeObject )
ObjectSomeValuesFrom( ppn:hasAction SomeAction )
ObjectSomeValuesFrom( ppn:hasPurpose SomePurpose )
ObjectSomeValuesFrom( ppn:hasIntent
ObjectUnionOf( SomeAccessIntent SomeUsageIntent ) )
)
)
For instance, a Usage Policy could be used to specify that Lucy and Pete's Agents are permitted to process Alice's medical data for medical appointment scheduling purposes, however the permission is only valid if the agents have obtained delegation of authority for medical appointment scheduling purposes.
Ontology(
ClassAssertion( ppn:UsagePolicy ppnv:DoctorsMedicalDataPolicy )
ClassAssertion( ppn:UsageRule ppnv:ProcessAlicesMedicalDataPermission )
ClassAssertion( ppn:UsageRule ppnv:DOAAlicesMedicalDataObligation )
ObjectPropertyAssertion( ppn:hasUsageIntentRule
ppnv:DoctorsMedicalDataPolicy ppnv:ProcessAlicesMedicalDataPermission )
ObjectPropertyAssertion( ppn:hasUsageIntentRule
ppnv:DoctorsMedicalDataPolicy ppnv:DOAAlicesMedicalDataObligation )
EquivalentClasses(
ppnv:ProcessAlicesMedicalDataPermission
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject
ObjectUnionOf( ppnv:LucysAgent ppnv:PetesAgent ) )
ObjectSomeValuesFrom( ppn:hasObject ppnv:AlicesMedicalData )
ObjectSomeValuesFrom( ppn:hasAction ppnv:Process )
ObjectSomeValuesFrom( ppn:hasPurpose ppnv:MedicalAppointmentScheduling )
ObjectSomeValuesFrom( ppn:hasIntent ppnv:Permission )
)
)
EquivalentClasses(
ppnv:DOAAlicesMedicalDataObligation
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject
ObjectUnionOf( ppnv:LucysAgent ppnv:PetesAgent ) )
ObjectSomeValuesFrom( ppn:hasObject ppnv:AlicesMedicalData )
ObjectSomeValuesFrom( ppn:hasAction ppnv:ObtainDelegationOfAuthority )
ObjectSomeValuesFrom( ppn:hasPurpose ppnv:DOAAlicesMedicalDataObligation )
ObjectSomeValuesFrom( ppn:hasIntent ppnv:Obligation )
)
)
)
In order to enable intelligent devices and agents of the future to interact autonomously via the Internet in a human-centric manner, there is a need to specify not only goals, but also the preferences of the humans utilising these devices in a machine-readable format.
We model preferences as a set of weak or strong rules that can either be used to: (i) specify service thing selection preferences (in order to help the agent to select the most suitable service/thing); or (ii) specify actions that should be performed by the agent (in order to guide agent behaviour). Strong rules indicate that the preference must be satisfied, while weak rules indicate that the preference may be relaxed in favor of other preferences.
The following subclasses are core to preference policies:
SubClassOf( ppn:Preferences ppn:AgentRules )
SubClassOf( ppn:PreferenceRule ppn:Rule )
SubClassOf( ppn:Preference ppn:Intent )
SubClassOf( ppn:StrongPreference ppn:Preference )
SubClassOf( ppn:WeakPreference ppn:Preference )
The following subproperties are core to preference policies:
SubObjectPropertyOf( ppn:hasPreferenceRule ppn:hasRule )
SubObjectPropertyOf( ppn:hasPreference ppn:hasIntent )
Domain and range constraints for preference policies:
ObjectPropertyDomain( ppn:hasPreferenceRule ppn:Preferences )
ObjectPropertyRange( ppn:hasPreferenceRule ppn:PreferenceRule )
Source Preferences are used to specify that a given subject (i.e., thing, service, agent) must meet specific requirements in terms of thing/service/agent traits that are specified via object relationships.
Specific preference policies are defined as follows:
ClassAssertion( ppn:Preferences SomePreferences )
Specific preferences rules are defined as follows:
ClassAssertion( ppn:PreferenceRule SomePreferenceRule )
Preference rules are associated with preference policies as follows:
ObjectPropertyAssertion( ppn:hasPreferenceRule
SomePreferences SomePreferenceRule)
Preferences are modelled using an OWL 2 expression of the following form:
EquivalentClasses(
SomePreferenceRule
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject SomeSubject )
ObjectSomeValuesFrom( ppn:hasPredicate SomePredicate )
ObjectSomeValuesFrom( ppn:hasObject SomeObject )
ObjectSomeValuesFrom( ppn:hasIntent SomePreference )
)
)
For instance, a Preference could be used to specify that a strong prefernce for the selected physiotherapy provider being covered by Alice's insurance.
Ontology(
ClassAssertion( ppn:Preferences ppnv:MedicalProviderCoveredByInsurancePolicy )
ClassAssertion( ppn:PreferenceRule ppnv:MedicalProviderCoveredByInsurancePreference )
ObjectPropertyAssertion( ppn:hasPreferenceRule
ppnv:MedicalProviderCoveredByInsurancePolicy
ppnv:MedicalProviderCoveredByInsurancePreference )
EquivalentClasses(
ppnv:MedicalProviderCoveredByInsurancePreference
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject ppnv:PhysiotherapyProvider )
ObjectSomeValuesFrom( ppn:hasPredicate ppnv:hasContractWith )
ObjectSomeValuesFrom( ppn:hasObject ppnv:AlicesInsuranceProvider )
ObjectSomeValuesFrom( ppn:hasIntent ppnv:StrongPreference )
)
)
)
Organisations are useful abstractions to structure norms and make them accessible to agents. Although agents have the choice of joining such structures, they may be subject to conditions that regulate their admission (and exit), as well as there being an expectation to comply with the organisation's norms.
We model legal, regulatory, and social norms as a set of (possibly nested) rules that encode permissions, prohibitions, obligations, or dispensations that relate to actions, subjects (i.e., parties), and objects (i.e., resources).
The following classes, subclasses, properties, and subproperties have already been defined under policies:
Declaration( Class( ppn:Purpose ) )
SubClassOf( ppn:Action ppn:Predicate )
SubClassOf( ppn:AccessIntent ppn:Intent )
SubClassOf( ppn:UsageIntent ppn:Intent )
SubClassOf( ppn:Permission ppn:AccessIntent )
SubClassOf( ppn:Prohibition ppn:AccessIntent )
SubClassOf( ppn:Obligation ppn:UsageIntent )
SubClassOf( ppn:Dispensation ppn:UsageIntent )
Declaration( ObjectProperty( ppn:hasPurpose ) )
SubObjectPropertyOf( ppn:hasAction ppn:hasPredicate )
The following classes and subclasses are core to norm policies:
SubClassOf( ppn:Norms ppn:AgentRules )
SubClassOf( ppn:NormRule ppn:Rule )
The following properties and subproperties are core to norm policies:
SubObjectPropertyOf( ppn:hasNormRule ppn:hasRule )
Domain and range constraints for norm policies:
ObjectPropertyDomain( ppn:hasNormRule ppn:Norms )
ObjectPropertyRange( ppn:hasNormRule ppn:NormRule )
Here again meta policies are needed in order to resolve conflicts.
Norms are represented as follows:
ClassAssertion( ppn:Norms SomeNorms )
Specific norm rules are defined as follows:
ClassAssertion( ppn:NormRule SomeNormRule )
Norms are composed of one or more deontic usage rules as follows:
ObjectPropertyAssertion( ppn:hasNormRule
SomeNorms SomeNormRule )
Regulatory, legal, and social norms are modelled using an OWL 2 expression of the following form:
EquivalentClasses(
SomeNormRule
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject SomeSubject )
ObjectSomeValuesFrom( ppn:hasObject SomeObject )
ObjectSomeValuesFrom( ppn:hasAction SomeAction )
ObjectSomeValuesFrom( ppn:hasPurpose SomePurpose )
ObjectSomeValuesFrom( ppn:hasIntent
ObjectUnionOf( SomeAccessIntent SomeUsageIntent ) )
)
)
For instance, a Legal Norm could be used to specify that an autonomous agent must have a legal basis in order to process personal data.
Ontology(
ClassAssertion( ppn:Norms ppnv:ProcessPersonalDataNorms )
ClassAssertion( ppn:NormRule ppnv:ProcessPersonalDataNormPermission )
ClassAssertion( ppn:NormRule ppnv:VerifyLegalBasisObligation )
ObjectPropertyAssertion( ppn:hasNormRule
ppnv:ProcessPersonalDataNorms ppnv:ProcessPersonalDataNormPermission )
ObjectPropertyAssertion( ppn:hasUsageIntentRule
ppnv:ProcessPersonalDataNorms ppnv:VerifyLegalBasisObligation )
EquivalentClasses(
ppnv:ProcessPersonalDataNormPermission
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject ppnv:AutonomousAgent )
ObjectSomeValuesFrom( ppn:hasObject ppnv:PersonalData )
ObjectSomeValuesFrom( ppn:hasAction ppnv:Process )
ObjectSomeValuesFrom( ppn:hasPurpose ppn:MedicalResearch )
ObjectSomeValuesFrom( ppn:hasIntent ppnv:Permission)
)
)
EquivalentClasses(
ppnv:VerifyLegalBasisObligation
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject ppnv:AutonomousAgent )
ObjectSomeValuesFrom( ppn:hasObject ppnv:LegalBasis )
ObjectSomeValuesFrom( ppn:hasAction ppnv:Verify )
ObjectSomeValuesFrom( ppn:hasPurpose ppn:MedicalResearch )
ObjectSomeValuesFrom( ppn:hasIntent ppnv:Obligation )
)
)
)
The complete syntax of the proposed policy, norm, and preference language is specified using the following Backus–Naur form (BNF) grammar:
AccessPolicy :=’ObjectUnionOf’ ’(’ AccessRule { AccessRule }* ’)’ | AccessRule
UsagePolicy :=’ObjectUnionOf’ ’(’ UsageRule { UsageRule }* ’)’ | UsageRule
Norms :=’ObjectUnionOf’ ’(’ NormRule { NormRule }* ’)’ | NormRule
Preferences :=’ObjectUnionOf’ ’(’ PreferenceRule { PreferenceRule }* ’)’ | PreferenceRule
AccessRule :=’ObjectIntersectionOf’ ’(’ Subject Object Action AccessIntent)’
UsageRule :=’ObjectIntersectionOf’ ’(’ Subject Object Action Purpose UsageIntent)’
NormRule :=’ObjectIntersectionOf’ ’(’ Subject Object Action Purpose NormIntent)’
PreferenceRule :=’ObjectIntersectionOf’ ’(’ Subject Predicate Object Purpose PreferenceIntent)’
Subject :=’ObjectSomeValueFrom’ ’(’ ’nnp:hasSubject’ SubjectExpression ’)’
Object :=’ObjectSomeValueFrom’ ’(’ ’nnp:hasObject’ ObjectExpression ’)’
Action :=’ObjectSomeValueFrom’ ’(’ ’nnp:hasAction’ ActionExpression ’)’
Purpose :=’ObjectSomeValueFrom’ ’(’ ’nnp:hasPurpose’ PurposeExpression ’)’
Predicate :=’ObjectSomeValueFrom’ ’(’ ’nnp:hasPredicate’ PredicateExpression ’)’
AccessIntent :=’ObjectSomeValueFrom’ ’(’ ’rdf:type’ ObjectUnionOf ’(’ ’nnp:Permission’ ’nnp:Prohibition’ ’)’ ’)’
UsageIntent :=’ObjectSomeValueFrom’ ’(’ ’rdf:type’ ObjectUnionOf ’(’ ’nnp:Permission’ ’nnp:Prohibition’ ’nnp:Obligation’ ’nnp:Dispensation’ ’)’ ’)’
NormIntent :=’ObjectSomeValueFrom’ ’(’ ’rdf:type’ ObjectUnionOf ’(’ ’nnp:Permission’ ’nnp:Prohibition’ ’nnp:Obligation’ ’nnp:Dispensation’ ’)’ ’)’
PreferenceIntent :=’ObjectSomeValueFrom’ ’(’ ’rdf:type’ ObjectUnionOf ’(’ ’nnp:WeakPreference ’nnp:StrongPreference’ ’)’ ’)’
SubjectExpression :=’nnp:Subject’ | SubjectVocabExpression
ObjectExpression :=’nnp:Object’ | ObjectVocabExpression
ActionExpression :=’nnp:Action’ | ActionVocabExpression
PurposeExpression :=’nnp:Purpose' | PurposeVocabExpression
PredicateExpression :=’nnp:Predicate' | PredicateVocabExpression
SubjectVocabExpression := as specified in ppnv
ObjectVocabExpression := as specified in ppnv
ActionVocabExpression := as specified in ppnv
PurposeVocabExpression := as specified in ppnv
PredicateVocabExpression := as specified in ppnv
The original semantic web vision was presented with the help of a motivating use case scenario, revolving around Pete and Lucy and their mother (Alice) who has just found out that she needs to attend regular physiotherapy sessions. Lucy asks her personal agent to prepare a physiotherapy appointment schedule such that they are able to share the chauffeuring duties. Lucy's agent is tasked with finding a physiotherapist who: (i) is covered by their mothers insurance; (ii) has a trusted service rating of very good or excellent; (iii) is located within a 20 mile radius of their mother's home; and (iv) has appointments that work with Lucy and Pete's busy schedules.
Unfortunately the original proposal is not satisfactory, given that the physiotherapist is quite far from Pete's work and the appointment times coincide with the lunch time rush hour, thus Pete instructs his agent to redo the task with stricter constraints on location and time.
Although the original motivating scenario didn't mention policies, preferences, and norms specifically it is possible to infer this Information from an analysis of the textual description.
The following policies have been derived from the use case scenario outlined in the previous section.
The Patient Data Access Policy states that a patient or their representative can obtain patient medical data. As this is a general policy that relates to all patients, the enforcement engine needs to infer that Alice is a patient and AlicesAgent is Alices representative and thus is permitted to obtain Alice's medical data.
Ontology(
ClassAssertion( ppn:AccessPolicy ppnv:PatientMedicalDataPolicy )
ClassAssertion( ppn:AccessRule ppnv:ObtainPatientMedicalDataPermission )
ObjectPropertyAssertion( ppn:hasAccessRule ppnv:PatientMedicalDataPolicy
ppnv:AccessPatientMedicalDataPermission )
EquivalentClasses(
ppnv:ObtainPatientMedicalDataPermission
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject
ObjectUnionOf( ppnv:Patient ppnv:PatientRepresentative ) )
ObjectSomeValuesFrom( ppn:hasObject ppnv:PatientMedicalData )
ObjectSomeValuesFrom( ppn:hasAction ppnv:Obtain )
ObjectSomeValuesFrom( ppn:hasIntent ppnv:Permission )
)
)
)
The Patient Credentials Access Policy states that a patients representative can obtain the patients credential. As per the previous example, the enforcement engine needs to infer that Alice is a patient and AlicesAgent is AlicesRepresentative and thus is permitted to obtain Alice's delegated credentials.
Ontology(
ClassAssertion( ppn:AccessPolicy ppnv:PatientCredentialDelegationPolicy )
ClassAssertion( ppn:AccessRule ppnv:ObtainCredentialsPermission )
ObjectPropertyAssertion( ppn:hasAccessRule ppnv:PatientMedicalDataPolicy
ppnv:AccessPatientMedicalDataPermission )
EquivalentClasses(
ppnv:AccessPatientMedicalDataPermission
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject ppnv:PatientRepresentative )
ObjectSomeValuesFrom( ppn:hasObject ppnv:PatientDelegatedCredentials )
ObjectSomeValuesFrom( ppn:hasAction ppnv:Obtain )
ObjectSomeValuesFrom( ppn:hasIntent ppnv:Permission )
)
)
)
The Patient Delegated Authority Usage Policy states that Alices delegated doctor credentials may only be used to request information about the treatment recommended on date X. Contrary to the above examples this policy does not apply to all patients, but rather to Alice specifically.
Ontology(
ClassAssertion( ppn:UsagePolicy ppnv:AlicesDelegatedCredentialsPolicy )
ClassAssertion( ppn:UsageRule ppnv:AlicesDCUseAppointmentSchedulingPermission )
ClassAssertion( ppn:UsageRule ppnv:AlicesDCObtainObligation )
ObjectPropertyAssertion( ppn:hasUsageRule
ppnv:AlicesDelegatedCredentialsPolicy
ppnv:AlicesDCUseAppointmentSchedulingPermission )
ObjectPropertyAssertion( ppn:hasUsageRule
ppnv:AlicesDelegatedCredentialsPolicy
ppnv:AlicesDCObtainObligation )
EquivalentClasses(
ppnv:AlicesDCUseAppointmentSchedulingPermission
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject ppnv:AlicesRepresentative )
ObjectSomeValuesFrom( ppn:hasObject ppnv:AlicesDelegatedCredentials )
ObjectSomeValuesFrom( ppn:hasAction ppnv:Use )
ObjectSomeValuesFrom( ppn:hasPurpose ppnv:AppointmentScheduling )
ObjectSomeValuesFrom( ppn:hasIntent ppnv:Permission )
)
)
EquivalentClasses(
ppnv:AlicesDCObtainObligation
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject ppnv:AlicesRepresentative )
ObjectSomeValuesFrom( ppn:hasObject ppnv:AlicesDelegatedCredentials )
ObjectSomeValuesFrom( ppn:hasAction ppnv:Obtain )
ObjectSomeValuesFrom( ppn:hasPurpose ppnv:AppointmentScheduling )
ObjectSomeValuesFrom( ppn:hasIntent ppnv:Obligation )
)
)
)
The following preferences have been derived from the use case scenario outlined in the previous section.
The Physiotherapist has contract with Insurance states the physiotherapy provider should have a contract with Alice's insurance provider.
Ontology(
ClassAssertion( ppn:Preferences ppnv:PhysiotherapistPreference )
ClassAssertion( ppn:PreferenceRule
ppnv:PhysiotherapistInsuranceCoverageStrongPreference )
ObjectPropertyAssertion( ppn:hasPreferenceRule
ppnv:PhysiotherapistPreference
ppnv:PhysiotherapistInsuranceCoverageStrongPreference )
EquivalentClasses(
ppnv:PhysiotherapistInsuranceCoverageStrongPreference
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject ppnv:Physiotherapist )
ObjectSomeValuesFrom( ppn:hasPredicate ppnv:hasContractWith )
ObjectSomeValuesFrom( ppn:hasObject ppnv:AlicesInsuranceProvider )
ObjectSomeValuesFrom( ppn:hasIntent ppnv:StrongPreference )
)
)
)
The Physiotherapist Trusted Service Rating states that the physiotherapy provider should have a trusted service rating of very good or excellent.
Ontology(
ClassAssertion( ppn:Preferences ppnv:PhysiotherapistPreference )
ClassAssertion( ppn:PreferenceRule
ppnv:PhysiotherapistTrustedServiceRatingStrongPreference )
ObjectPropertyAssertion( ppn:hasPreferenceRule
ppnv:PhysiotherapistPreference
ppnv:PhysiotherapistTrustedServiceRatingStrongPreference )
EquivalentClasses(
ppnv:PhysiotherapistTrustedServiceRatingStrongPreference
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject ppnv:Physiotherapist )
ObjectSomeValuesFrom( ppn:hasPredicate ppnv:hasTrustedServiceRating )
ObjectSomeValuesFrom( ppn:hasObject
ObjectUnionOf( ppnv:Good ppnv:Excellent ) )
)
ObjectSomeValuesFrom( ppn:hasIntent ppnv:StrongPreference )
)
)
The Physiotherapist Location states that the physiotherapy provider must be located within a 20 mile radius of Alice's home and near Pete and Lucy's workplaces. Here we assume that near means within 5 miles.
Ontology(
ClassAssertion( ppn:Preferences ppnv:PhysiotherapistPreference )
ClassAssertion( ppn:PreferenceRule
ppnv:Within20MileRadiusOfAlicesLocationPreference )
ClassAssertion( ppn:PreferenceRule
ppnv:Within5MileRadiusOfPeteAndLucysLocationPreference )
ObjectPropertyAssertion( ppn:hasPreferenceRule
ppnv:PhysiotherapistPreference
ppnv:Within20MileRadiusOfAlicesLocationPreference )
ObjectPropertyAssertion( ppn:hasPreferenceRule
ppnv:PhysiotherapistPreference
ppnv:Within5MileRadiusOfPeteAndLucysLocationPreference )
EquivalentClasses(
ppnv:Within20MileRadiusOfAlicesLocationPreference
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject ppnv:PhysiotherapistLocation )
ObjectSomeValuesFrom( ppn:hasPredicate ppnv:within20MileRadius )
ObjectSomeValuesFrom( ppn:hasObject ppnv:AlicesLocation )
ObjectSomeValuesFrom( ppn:hasIntent ppnv:StrongPreference )
)
)
EquivalentClasses(
ppnv:Within5MileRadiusOfPeteAndLucysLocationPreference
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject ppnv:PhysiotherapistLocation )
ObjectSomeValuesFrom( ppn:hasPredicate ppnv:within5MileRadius )
ObjectSomeValuesFrom( ppn:hasObject
ObjectUnionOf( ppnv:PetesWorkLocation ppnv:LucysWorkLocation ) )
)
ObjectSomeValuesFrom( ppn:hasIntent ppnv:StrongPreference )
)
)
The Physiotherapy Appointment Scheduling states that the appointments fit with Lucy or Pete's sechedules and the appointments should not be during morning or evening rush hours or at lunchtime.
Ontology(
ClassAssertion( ppn:Preferences ppnv:PhysiotherapyAppointmentScheduling )
ClassAssertion( ppn:PreferenceRule
ppnv:PeteAndLucysAvailabilitySlotsPreference )
ClassAssertion( ppn:PreferenceRule
ppnv:OffPeakSlotsPreference )
ObjectPropertyAssertion( ppn:hasPreferenceRule
ppnv:PhysiotherapyAppointmentScheduling
ppnv:PeteAndLucysAvailabilitySlotsPreference )
ObjectPropertyAssertion( ppn:hasPreferenceRule
ppnv:PhysiotherapyAppointmentScheduling
ppnv:OffPeakSlotsPreference )
EquivalentClasses(
ppnv:PeteAndLucysAvailabilitySlotsPreference
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject
ObjectUnionOf( ppnv:PetesSchedule ppnv:LucySchedule ))
ObjectSomeValuesFrom( ppn:hasPredicate ppnv:hasAvailability )
ObjectSomeValuesFrom( ppn:hasObject ppnv:Timeslot )
ObjectSomeValuesFrom( ppn:hasIntent ppnv:StrongPreference )
)
)
EquivalentClasses(
ppnv:OffPeakSlotsPreference
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject ppnv:OffPeakSchedule )
ObjectSomeValuesFrom( ppn:hasPredicate ppnv:hasAvailability )
ObjectSomeValuesFrom( ppn:hasObject
ObjectUnionOf( ppnv:MidToLateMorning ppnv:EarlyToMidAfternoon ))
)
ObjectSomeValuesFrom( ppn:hasIntent ppnv:StrongPreference )
)
)
The following norms have been derived from the use case scenario outlined in the previous section.
The Personal Data Processing Consent Norm states that data processors must have consent for personal data processing. As this is a general policy that relates to all data processors, the enforcement engine needs to infer that Alice's agent is a data processor and thus needs to have Alice's consent for personal data processing.
Ontology(
ClassAssertion( ppn:Norms ppnv:PersonalDataProcessingConsentNorm )
ClassAssertion( ppn:NormRule ppnv:ProcessPersonalDataPermission )
ClassAssertion( ppn:NormRule ppnv:ObtainConsentPersonalDataObligation )
ObjectPropertyAssertion( ppn:hasAccessIntentRule ppnv:PersonalDataProcessingConsentNorm
ppnv:ProcessPersonalDataPermission )
ObjectPropertyAssertion( ppn:hasAccessIntentRule ppnv:PersonalDataProcessingConsentNorm
ppnv:ObtainConsentPersonalDataObligation )
EquivalentClasses(
ppnv:ProcessPersonalDataPermission
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject ppnv:DataProcessor )
ObjectSomeValuesFrom( ppn:hasObject ppnv:PersonalData )
ObjectSomeValuesFrom( ppn:hasAction ppnv:Process )
ObjectSomeValuesFrom( ppn:hasIntent ppnv:Permission)
)
)
EquivalentClasses(
ppnv:ObtainConsentPersonalDataObligation
ObjectIntersectionOf(
ObjectSomeValuesFrom( ppn:hasSubject ppnv:DataProcessor )
ObjectSomeValuesFrom( ppn:hasObject ppnv:PersonalData )
ObjectSomeValuesFrom( ppn:hasAction ppnv:ObtainConsent )
ObjectSomeValuesFrom( ppn:hasIntent ppnv:Obligation )
)
)
)