Agent Policies, Preferences, and Norms

Abstract

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.

Introduction

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.

Aims of the Specification

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#> .
      

Conceptual framework for Governing Agents on the Web

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.

Conceptual framework for Governing Agents on the Web
Conceptual framework for Governing Agents on the Web adapted from [[TOIT-Governance]]

Reactive Things and Services Layer

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.

Autonomous Agents Layer

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.

Normative Organisations Layer

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.

PPN Foundations

In this section we present the foundational vocabulary elements that are core to the policies, preferences, and norms (PPN) language.

Classes

The following classes are core to all policies:


      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

The following properties are core to all policies:


      Declaration( ObjectProperty( ppn:hasRule ) )
      Declaration( ObjectProperty( ppn:hasSubject ) )
      Declaration( ObjectProperty( ppn:hasPredicate ) )
      Declaration( ObjectProperty( ppn:hasObject ) )
      Declaration( ObjectProperty( ppn:hasIntent ) )
      

Constraints

Domain and range constraints are used to ensure that ppn:hasRule (and its children) associate a ppn:Rule with a ppn:AgentRules:


        ObjectPropertyDomain( ppn:hasRule ppn:AgentRules )
        ObjectPropertyRange( ppn:hasRule ppn:Rule )
      

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:hasSubject )
        FunctionalObjectProperty( ppn:hasPredicate )
        FunctionalObjectProperty( ppn:hasObject )
        FunctionalObjectProperty( ppn:hasIntent )
      

Reactive Thing and Service Policies

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 )
    

Access Policies

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

Usage Policies

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

Autonomous Agent Preferences

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

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

Normative Organisation norms

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.

Legal, Regulatory, and Social 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 )
             )
           )
          )
        
      

PPN Grammar

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

    

Appointment Scheduling Usecase Scenario

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.

Policies

The following policies have been derived from the use case scenario outlined in the previous section.

Patient Data Access

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

Patient Credentials Access

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

Patient Delegated Authority Usage

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

Preferences

The following preferences have been derived from the use case scenario outlined in the previous section.

Physiotherapist Insurance Coverage

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

Physiotherapist Trusted Service Rating

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

Physiotherapist Location

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

Physiotherapy Appointment Scheduling

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

Norms

The following norms have been derived from the use case scenario outlined in the previous section.

Autonomous Agents Information Sharing

The Collaborating Agents Information Sharing Norm states that autonomous agents must not share sensitive information. As this is a general policy that relates to all autonomous agents, the enforcement engine needs to infer that generally speaking agents must not share sensitive information, unless that sensitive information needs to be shared in order to complete a delegated task.

          
          Ontology(
           ClassAssertion( ppn:SocialNorm ppnv:ShareInformationNorm )
           ClassAssertion( ppn:Prohibition ppnv:ShareInformationProhibition )
           ClassAssertion( ppn:Dispensation ppnv:CompleteDelegatedTaskDispensation )

           ObjectPropertyAssertion( ppn:hasAccessIntentRule ppnv:ShareInformationNorm
            ppnv:ShareInformationProhibition )

            ObjectPropertyAssertion( ppn:hasAccessIntentRule ppnv:ShareInformationNorm
             ppnv:CompleteDelegatedTaskDispensation )

           EquivalentClasses(
            ppnv:ShareInformationProhibition
            ObjectIntersectionOf(
             ObjectSomeValuesFrom( ppn:hasSubject ppnv:AutonomousAgents )
             ObjectSomeValuesFrom( ppn:hasObject ppnv:SensitiveInformation )
             ObjectSomeValuesFrom( ppn:hasAction ppnv:Share )
             ObjectSomeValuesFrom( ppn:hasPurpose nnp:Purpose )
             ObjectSomeValuesFrom( ppn:hasIntent ppnv:Obligation )
            )
           )

           EquivalentClasses(
            ppnv:CompleteDelegatedTaskDispensation
            ObjectIntersectionOf(
             ObjectSomeValuesFrom( ppn:hasSubject ppnv:AutonomousAgents )
             ObjectSomeValuesFrom( ppn:hasObject ppnv:SensitiveInformation )
             ObjectSomeValuesFrom( ppn:hasAction ppnv:Complete )
             ObjectSomeValuesFrom( ppn:hasPurpose ppnv:DelegatedTask )
             ObjectSomeValuesFrom( ppn:hasIntent ppnv:Dispensation )
            )
           )
          )
        
        

Collaborating Agents Information Sharing

The Collaborating Agents Information Sharing Norm states that collaboratng autonomous agents must partake in information sharing. As this is a general policy that relates to all autonomous agents, the enforcement engine needs to infer that Lucy's agent needs to share information with Pete's agent.

          
          Ontology(
           ClassAssertion( ppn:Norms ppnv:ShareInformationAgentCollaborationNorm )
           ClassAssertion( ppn:Obligation ppnv:ShareInformationAgentCollaborationObligation )

           ObjectPropertyAssertion( ppn:hasAccessIntentRule ppnv:ShareInformationAgentCollaborationNorm
            ppnv:ShareInformationAgentCollaborationObligation )

           EquivalentClasses(
            ppnv:ShareInformationAgentCollaborationObligation
            ObjectIntersectionOf(
             ObjectSomeValuesFrom( ppn:hasSubject ppnv:AutonomousAgents )
             ObjectSomeValuesFrom( ppn:hasObject ppnv:Information )
             ObjectSomeValuesFrom( ppn:hasAction ppnv:Share )
             ObjectSomeValuesFrom( ppn:hasPurpose ppnv:AgentCollaboration )
             ObjectSomeValuesFrom( ppn:hasIntent ppnv:Obligation )
            )
           )
          )