Expectations.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": "[![View in Deepnote](https://deepnote.com/static/buttons/view-in-deepnote-white.svg)](https://deepnote.com/viewer/github/katetruman/MultiAgentEC/blob/master/Expectations.ipynb)",
   "metadata": {
    "cell_id": "5e99b889-15f8-498b-868a-0421470c5e2d",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "markdown",
   "source": "# Expectations related to our scenario",
   "metadata": {
    "tags": [],
    "is_collapsed": false,
    "deepnote_app_coordinates": {
     "x": 0,
     "y": null,
     "w": 12,
     "h": 5
    },
    "cell_id": "a8dff274-b9cf-4698-be7c-19fa830d4033",
    "deepnote_cell_height": 82,
    "deepnote_cell_type": "text-cell-h1"
   }
  },
  {
   "cell_type": "markdown",
   "source": "This notebook discusses expectations related to our organ transplant scenario. If you have not yet done so, please refer to **AgentsAndEvents.ipynb** for important events and fluents used in this scenario. For expectation examples, please refer to the **ExpectationExamples** folder.",
   "metadata": {
    "tags": [],
    "deepnote_app_coordinates": {
     "x": 0,
     "y": 174,
     "w": 12,
     "h": 5
    },
    "cell_id": "00001-7530f456-e82a-47c5-9eca-f45d92f7beed",
    "deepnote_cell_height": 74,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "markdown",
   "source": "There are many different categories of expectation that could be held by an agent in an product tracking scenario. Here, we consider the following categories: authorisation, compatibility, timely communication.\n\nEach of these categories is covered by a separate notebook in the **ExpectationExamples** folder. Note that while the notebooks in the **ExpectationExample** folder should be able to function concurrently, these notebooks are run independently from one other to reduce the number of predicates loaded at once and simplify our query output.\n\nThis notebook explains the format of expectation rules and some special features of them that can be utilised.\n",
   "metadata": {
    "tags": [],
    "deepnote_app_coordinates": {
     "x": 0,
     "y": 0,
     "w": 12,
     "h": 5
    },
    "cell_id": "00039-64bb84cf-29ce-40b0-ac6d-db19c46544a2",
    "deepnote_cell_height": 132,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "markdown",
   "source": "### Set up",
   "metadata": {
    "cell_id": "efe88898-6dd4-4644-980e-489ed4c6981a",
    "tags": [],
    "is_collapsed": false,
    "deepnote_app_coordinates": {
     "x": 0,
     "y": 0,
     "w": 12,
     "h": 5
    },
    "deepnote_cell_height": 62,
    "deepnote_cell_type": "text-cell-h3"
   }
  },
  {
   "cell_type": "markdown",
   "source": "We need to set up our environment by loading in our event and fluent declarations from **dec:notation.pl** and **AE.pl**. The latter contains the code from **AgentsAndEvents.ipynb** the last time that notebook was run.\n\n```diff\n- IMPORTANT NOTE: you should run AgentsAndEvents.ipynb prior to running this notebook to ensure that AE.pl contains up to date predicates! You must run the notebook, not just update and save it.\n```",
   "metadata": {
    "cell_id": "8bcf3ea2-94a0-4352-a9d1-7d4391c910e1",
    "tags": [],
    "deepnote_app_coordinates": {
     "x": 0,
     "y": 0,
     "w": 12,
     "h": 5
    },
    "deepnote_cell_height": 152,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "459e59fd-0648-4455-9fea-d80f2a9038de",
    "tags": [],
    "deepnote_app_coordinates": {
     "x": 0,
     "y": 0,
     "w": 12,
     "h": 5
    },
    "deepnote_to_be_reexecuted": false,
    "source_hash": "932f14c0",
    "execution_start": 1645477165309,
    "execution_millis": 330,
    "deepnote_cell_height": 226,
    "deepnote_cell_type": "code"
   },
   "source": "?- cd('~/work'), ['dec:notation'].\n?- initialiseDEC.\n?- retractall(happensAtNarrative(_,_)).\n?- ['AE'].",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.\nfalse.\ntrue.\ntrue.",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "### Expectation rule format",
   "metadata": {
    "cell_id": "7a925c4a-2a47-4a3f-a8bf-3cd47a69db08",
    "tags": [],
    "is_collapsed": false,
    "deepnote_cell_height": 62,
    "deepnote_cell_type": "text-cell-h3"
   }
  },
  {
   "cell_type": "markdown",
   "source": "Expectation rules are declared for a particular agent. They are usually specified in an **initially/1** clause so that the expectation rule is active from time period zero onwards. \n\nWe use an expectation rule with the form **exp_rule(Condition, Outcome, Status, Message))**. **Condition** refers to the triggering condition for the resulting expectation and **Outcome** is the state that needs to be reached for the expectation to be fulfilled. If **Status** is set to `independent`, then expectations resulting from our expectation will remain even if the expectation rule is deleted. **Message** is a more user friendly message describing the expectation rule, which uniquely identifies it, and which can also include a category for the expectation.\n\nIn our example expectation rule, we declare that the starting condition for our expectation is that **monSys** receives a wait list add request from a hospital, the resulting expected outcome is that the hospital is recognised by **monSys**, that the resulting expectations shall be dependent, and use the message \"Authorisation\":\"Wait list requests should come from recognised hospital\" to describe the expectation rule.",
   "metadata": {
    "cell_id": "945d1f3a-de33-43f9-a98b-0d201abd6edb",
    "tags": [],
    "deepnote_app_coordinates": {
     "x": 0,
     "y": 0,
     "w": 12,
     "h": 5
    },
    "deepnote_cell_height": 212,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "ef7138de-6a45-41bd-a139-4809f3eaccdf",
    "tags": [],
    "deepnote_app_coordinates": {
     "x": 0,
     "y": 0,
     "w": 12,
     "h": 5
    },
    "deepnote_to_be_reexecuted": false,
    "source_hash": "d19089da",
    "execution_start": 1645477165354,
    "execution_millis": 287,
    "deepnote_cell_height": 117,
    "deepnote_cell_type": "code"
   },
   "source": "% File: authorisationExample.pl\n% We make our initially/1 predicate dynamic to allow us to retract this expectation rule later\n:- dynamic(initially/1).\ninitially(monSys:exp_rule(happ(receive(Hospital, waitAddReq(_, _, _))), agent(Hospital), dependent, \n\"Authorisation\":\"Wait list requests should come from recognised hospital\")).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "### Expectation rule message categories",
   "metadata": {
    "cell_id": "6963a205-2833-439a-bbc1-083bbf76aeee",
    "tags": [],
    "is_collapsed": false,
    "deepnote_cell_height": 62,
    "deepnote_cell_type": "text-cell-h3"
   }
  },
  {
   "cell_type": "markdown",
   "source": "In order to test the example expectation rule added above, we add a narrative event in which Otago sends **monSys** a waiting list add request at time period 0.",
   "metadata": {
    "cell_id": "54d13805-e156-4a09-a696-5565926e957d",
    "tags": [],
    "deepnote_cell_height": 52,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "c6a85aee-93ba-42c1-b428-626f66c9b196",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "e5df1b6b",
    "execution_start": 1645477165397,
    "execution_millis": 245,
    "deepnote_cell_height": 117,
    "deepnote_cell_type": "code"
   },
   "source": "% File: narrative.pl\nhappensAtNarrative(\"Otago\":send(monSys, waitAddReq(101, [\"liver\", \"kidney\"], [sex:\"F\", \ndob:\"01/01/2000\"])),0).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "At time period 0, the expectation rule holds for **monSys**. At time period 1, **monSys** receives Otago's waiting list add request, which fulfils our expectation that such requests will come from a recognised hospital.",
   "metadata": {
    "cell_id": "b9f7cdc9-8c2e-415e-9cd1-4a64a9522311",
    "tags": [],
    "deepnote_cell_height": 74,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "4f0fa61c-8374-4ffd-b99f-700c286b910e",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "1eb1d783",
    "execution_start": 1645477165398,
    "execution_millis": 245,
    "deepnote_cell_height": 212,
    "deepnote_cell_type": "code"
   },
   "source": "?- run(10).\n?- holdsAt(monSys, exp_rule(Condition, Outcome, Status, \"Authorisation\":MessageSpecifics), 0).\n?- happensAt(monSys, Event, 1).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.\nCondition = happ(receive(_1770, waitAddReq(_1776, _1778, _1780))), Outcome = agent(_1770), Status = dependent, MessageSpecifics = b'Wait list requests should come from recognised hospital' .\nEvent = fulf(happ(receive(b'Otago', waitAddReq(101, [b'liver', b'kidney'], [Functor(188685,2,sex,b'F'), Functor(188685,2,dob,b'01/01/2000')]))), agent(b'Otago'), 1, agent(b'Otago'), dependent, :(b'Authorisation', b'Wait list requests should come from recognised hospital')) ;\nEvent = receive(b'Otago', waitAddReq(101, [b'liver', b'kidney'], [Functor(188685,2,sex,b'F'), Functor(188685,2,dob,b'01/01/2000')])) .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "As our expectation rule messages can be of the form Category:Specifics, we are able to filter expectation rules by their category if we so desire:",
   "metadata": {
    "cell_id": "39fc2ec2-db72-4086-a27a-100aa1ab17d6",
    "tags": [],
    "deepnote_cell_height": 52,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "a8b27a59-b16b-44f9-9b0e-6332b2752561",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "c7ad16c4",
    "execution_start": 1645477165442,
    "execution_millis": 202,
    "deepnote_cell_height": 150,
    "deepnote_cell_type": "code"
   },
   "source": "?- run(10).\n?- happensAt(monSys, fulf(_, _, _, Outcome, _, \"Authorisation\":MessageSpecifics), 1).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.\nOutcome = agent(b'Otago'), MessageSpecifics = b'Wait list requests should come from recognised hospital' .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "# Expectation functionality",
   "metadata": {
    "cell_id": "89d416e4-0e34-45de-9eae-e028a0250149",
    "tags": [],
    "is_collapsed": false,
    "deepnote_cell_height": 82,
    "deepnote_cell_type": "text-cell-h1"
   }
  },
  {
   "cell_type": "markdown",
   "source": "We reset our environment.",
   "metadata": {
    "cell_id": "a82cdb5d-e642-402a-9a28-79133548254c",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "30d3b015-9e85-4c39-b9d1-8e076cc9f784",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "865bf12b",
    "execution_start": 1645477165485,
    "execution_millis": 160,
    "deepnote_cell_type": "code"
   },
   "source": "?- retractall(initially(_)).\n?- cd('~/work'), ['dec:notation'].\n?- initialiseDEC.\n?- retractall(happensAtNarrative(_,_)).\n?- ['AE'].",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.\ntrue.\ntrue.\ntrue.\ntrue.",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "## Current outcome types",
   "metadata": {
    "cell_id": "7206d557-5297-40c1-b25c-c61560a11620",
    "tags": [],
    "is_collapsed": false,
    "deepnote_cell_height": 70,
    "deepnote_cell_type": "text-cell-h2"
   }
  },
  {
   "cell_type": "markdown",
   "source": "As well as having different categories of expectations in terms of their use for agents, we are able to have different types of expectations in terms of what classifies an expectation as fulfilled or violated.\n\nWe can create an expectation that given an event E :\n- Another event will occur or a fluent will hold at the same time period\n- An event will occur / fluent will hold in exactly X time periods after the current time period (`delay` clause)\n- When an event occurs / fluent holds, another event will have occurred / fluent will have held exactly X time periods earlier (`preceded` clause)\n- An event will occur / fluent will hold before X time periods are up (`within` clause)\n- An event will occur / fluent will hold before X time periods are up, and the condition cannot be fulfiled in the triggering time period (`withinStartNext` clause)\n- An event will not occur / fluent will not hold until X time periods are up (`later` clause)\n- An event will eventually occur / a fluent will eventually hold (`eventually` clause)\n- An event will always occur / a fluent will always hold from this time period onwards (`always` clause)\n- Another event will occur / fluent will hold before a third event occurs / fluent holds (`before` clause)\n- Another event will occur / fluent will hold until a third event occurs / fluent holds (`until` clause).\n- **The opposite of any of these situations, and any logical combination of them.**\n\nThis allows us to create expectations such as the following:\n- When a hospital sends a message to the monitoring agent, they will be a registered hospital known to the monitoring agent.\n- A waiting list request will be either accepted or rejected within 1 time period.\n- A transplant outcome notification will be be received by the monitoring agent within 6 time periods of the transplant being approved.\n- A patient on the waiting list will eventually receive a transplant.\n\nMany further expectation set ups could be supported by adding new `eval` predicates to **dec:notation.pl**.",
   "metadata": {
    "cell_id": "49fac541-56dc-4a0c-8d38-e96010dc0551",
    "tags": [],
    "deepnote_cell_height": 479,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "markdown",
   "source": "## Adjustable progress",
   "metadata": {
    "cell_id": "e19896cc-429a-4a5c-9ef5-740054724a04",
    "tags": [],
    "is_collapsed": false,
    "deepnote_cell_height": 70,
    "deepnote_cell_type": "text-cell-h2"
   }
  },
  {
   "cell_type": "markdown",
   "source": "The expectation outcomes listed above rely on being progressed at the end of each time period. Generally, expectations with a countdown time e.g. will occur within 3 time periods, are progressed by 1 unit each time period. (So if we have 4 time periods remaining in our expectation at time period 0, we only have 3 time periods remaining at time period 1, 2 time periods remaining at time period 2, and so on). However, we can also declare expectations which have adjustable countdown progression.\n\n",
   "metadata": {
    "cell_id": "3ed08e68-8119-48a3-a13c-834466b8d5d9",
    "tags": [],
    "deepnote_cell_height": 96,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "markdown",
   "source": "An expectation which seems particularly relevant in an organ donor situation is a `within` rule - which states that following an event, another state will hold **within** a certain period of time. Let us take the example of a rule stating that a waiting list request will be either accepted or rejected with a countdown value of 1. Note that this does not necessarily mean within 1 time periods of the request being received, but that when the request is received, the expectation will hold with a countdown value of 1, and we expect this value to drop over time. The expectation is fulfilled when the request is accepted or rejected before the countdown value drops to or below zero, and is violated if neither of these events occur before the countdown value drops to or below zero.\n\nThis is currently supported for `within` expectations only, but could be easily declared to apply for a wider range of expectations in **dec:notation.pl**.",
   "metadata": {
    "cell_id": "9ad5c659-83b3-424c-9b44-6539c8ad626f",
    "tags": [],
    "deepnote_cell_height": 154,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "markdown",
   "source": "### Declaring the levels",
   "metadata": {
    "cell_id": "5c72a4f0-866e-4015-9fe0-f77e4e954083",
    "tags": [],
    "is_collapsed": false,
    "deepnote_cell_height": 62,
    "deepnote_cell_type": "text-cell-h3"
   }
  },
  {
   "cell_type": "markdown",
   "source": "We use the total number of messages sent and received by **monSys** in the last 10 time periods as a measure of **monSys**' busyness, although other measures such as number of patients waiting for transplants or number of patients currently admitted at hospitals recognised by **monSys** could also be used. The `recentMessageTotal` fluent produces a count of the total number of messages sent and received by the current actor within the last 10 time periods. If less than 10 time periods have taken place since the start of the scenario, the total is taken from time zero to the current time period.",
   "metadata": {
    "cell_id": "001c77ea-44f2-43f7-b5af-aa9bf895cf79",
    "tags": [],
    "deepnote_cell_height": 118,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "c471daee-e042-413e-9f8d-ec0b7e5d2ecd",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "9a83968a",
    "execution_start": 1645477165486,
    "execution_millis": 160,
    "deepnote_cell_height": 135,
    "deepnote_cell_type": "code"
   },
   "source": "% File: recentMessageTotal.pl\nholdsAt(Actor, recentMessageTotal(Total), CurrentTime):- \n    aggregate_all(count, ((happensAt(Actor, receive(Hosp, Message), T) ; \n    happensAt(Actor, send(Hosp, Message), T)), T < CurrentTime, T >= CurrentTime - 10), Total).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "Level information is set using the fluent levels/3, where the first argument is a list of the level names, the second argument is the break points between the levels and the third argument is the weighting assigned to different types of events under the levels. \n\nIn this example, we declare that there are three levels; low, medium and high, with break points at 4 and 6. The break points are set very low for ease of illustration, and mean that if there have been 4 or fewer messages sent and received within the last 10 time periods (inclusive of the current time period), the hospital's busyness is low, if there were between 4 (exclusive) and 6 (inclusive) messages, the hospital's busyness is medium, and if there were more than 6 messages, the hospital's busyness is high. At the current level settings, any match event is likely to lead to a high busyness level due to the large number of subsequent related events. Of course, in practice the break points would be high enough that one match in isolation wasn't sufficient to achieve an increase in busyness level!\n\nWe also declare the relative weightings to be assigned to different types of **within** expectations. Here, `foreignAcceptance` expectations are given a weighting of 1 under all three levels, while `localAcceptance` expectations (representing actor decisions) are given a weighting of 1 under the low level, 0.5 under the medium level and 0.333 under the high level. `foreignAcceptance` expectations will be set to be those in which the current Actor expects that a offer or request they make will be accepted by another agent in a certain time frame. `localAcceptance` expectations will be set to expectations about acceptance made by the current agent. When a given hospital is busy, it may alter its expectations on how quickly it responds to requests, but will not necessarily alter its expectations on how quickly other agents respond to it. The `localAcceptance` and `foreignAcceptance` arguments can be specified as an additional parameter to a `within` clause.",
   "metadata": {
    "cell_id": "0f11fb4f-1ec4-4755-8dfa-c4be42ced1a4",
    "tags": [],
    "deepnote_cell_height": 344,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "7cc610e0-37b3-4a49-86b5-dbf768cad9bb",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "fb67dc55",
    "execution_start": 1645477165487,
    "execution_millis": 159,
    "deepnote_cell_height": 99,
    "deepnote_cell_type": "code"
   },
   "source": "% File: levels.pl\ninitially(monSys:levels([low,medium,high],[4,6],[foreignAcceptance=[1,1,1], localAcceptance=[1, 0.5, 0.333]])).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "We declare our **monSys** expectation that a donation offer should be matched or a declaration of no match found will occur within 1 time period, and give the `within` clause a `localAcceptance` argument. We also declare another **monSys** expectation which states that a match offer should be accepted by the donor's hospital with a countdown value of three, and give its `within` clause a `foreignAcceptance` argument.",
   "metadata": {
    "cell_id": "0802db16-78db-46b0-a32a-ab2395b399ef",
    "tags": [],
    "deepnote_cell_height": 96,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "ad37a40c-c299-4ff6-a748-e096a985c169",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "4e75bca6",
    "execution_start": 1645477165529,
    "execution_millis": 119,
    "deepnote_cell_height": 225,
    "deepnote_cell_type": "code"
   },
   "source": "% File: adjustableExpectations.pl\n% Donation offer to match expectation\ninitially(monSys:exp_rule(happ(receive(Hospital, donorOffer(ID, _, _))), \nwithin(or([happ(noMatch(Hospital, ID)), happ(match(_, Hospital, ID, _, _, _, _, _))]),1, localAcceptance), \ndependent, \"Timely action\":\"A donation offer should be matched or a declaration of no match found will occur with a countdown value of one\")).\n\ninitially(monSys:exp_rule(happ(send(DonorHospital, recipientFound(MatchID, _, _, _, _, _))),\nwithin(happ(receive(DonorHospital, acceptMatch(MatchID))),3, foreignAcceptance), dependent, \n\"Timely response\":\"A match offer should be accepted by the donor's hospital with a countdown value of three\")).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "The event weightings are used to affect how far to progress expectations under a given busyness level. If an expectation contains a *within* rule with the argument `foreignAcceptance`, and has a starting countdown value of 3, we expect the event to take place within the next three time periods, as `foreignAcceptance` `within` expectations (and any `within` expectations without a type specified) have a weighting of 1. Note that the starting countdown value is not necessarily the number of time periods before an expectation will be violated if the expected event does not take place. If an expectation with a *within* rule and `localAcceptance` argument instead stated that an a match event will take place and has a countdown time of 1, we would expect the event to take place within 3 time periods under a high busyness level, as 1 / 0.33 = 3. The weightings control how quickly the specified countdown valuedrops, and allow the rate of decrease in countdown value associated with some types of expectations to be modified by busyness level.",
   "metadata": {
    "cell_id": "e21d16fe-eb96-4d78-b858-baf083dd6af1",
    "tags": [],
    "deepnote_cell_height": 162,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "e0a38950-4679-4e5f-bc8e-0966009aa4ae",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "742ddf38",
    "execution_start": 1645477165530,
    "execution_millis": 119,
    "deepnote_cell_height": 351,
    "deepnote_cell_type": "code"
   },
   "source": "% File: levelRules.pl\n% If the count is greater than the maximum breakpoint, the busyness level is the greatest level.\nholdsAt(Actor, busyness(Level), T):- \n    holdsAt(Actor, recentMessageTotal(Count), T) , holdsAt(Actor, levels(Names,BreakPoints,_), T), \n    last(Names, Level), last(BreakPoints, P), Count > P.\n\n% Else, check which breakpoints the count falls between, using 0 as the minimum breakpoint.\nholdsAt(Actor, busyness(Level),T):-  \n    holdsAt(Actor, recentMessageTotal(Count), T), holdsAt(Actor, levels(Names,BreakPoints,_), T), member(Level,Names), \n    nth0(LIndex,Names,Level), nth0(LIndex, BreakPoints, P),  P >= Count, \n    (LIndex > 0 -> (LIndex2 is LIndex - 1, nth0(LIndex2,BreakPoints,P2), P2 < Count); true).\n\n% Decrease in countdown value should be set by weightings given in the levels/3 predicate.\nprogress(Actor, within(F1,T1,Type), within(F1,T2,Type),T):- \n    holdsAt(Actor, busyness(Level), T), holdsAt(Actor, levels(Levels,_,DecayList), T), member(Type=Decay,DecayList), \n    nth0(Index, Levels, Level), nth0(Index,Decay,D), T2 is T1 - D. ",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "We will use some narrative events to test out our busyness and adjustable expectation predicates. \n\nTo simplify the narrative events listed, we will add have not included all `waitAddReq` messages referenced in `match` events. (To see an example of `waitAddReq` and `match` together, please refer to the [Timely Communication notebook](ExpectationExamples/Timely%20Communication.ipynb)).\n\n- At time period 0, Wellington sends a `donorOffer` message to **monSys**.\n- At time period 2, Otago sends a `waitAddReq` message to **monSys**.\n- At time period 3, **monSys** creates a match.\n- At time period 4, Christchurch sends a `donorOffer` message to **monSys**.\n- At time period 7, **monSys** creates a match.",
   "metadata": {
    "cell_id": "2d5d9f56-4b3b-40d3-bd9c-87c763fa815c",
    "tags": [],
    "deepnote_cell_height": 74,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "77c7c43b-099b-40ff-af96-7a126e5cf91c",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "523513f9",
    "execution_start": 1645477165532,
    "execution_millis": 118,
    "deepnote_cell_height": 171,
    "deepnote_cell_type": "code"
   },
   "source": "% File: narrative.pl\nhappensAtNarrative(\"Wellington\":send(monSys, donorOffer(200, [heart, kidney], [bloodType:\"A\"])),0).\nhappensAtNarrative(\"Otago\":send(monSys, waitAddReq(104, [kidney], [])), 2).\nhappensAtNarrative(monSys:match(701, \"Wellington\", 200, \"Otago\", 103, \"Auckland\", [\"heart\"], []),3).\nhappensAtNarrative(\"Christchurch\":send(monSys, donorOffer(201, [kidney], [bloodType:\"B\"])),4).\n%happensAtNarrative(monSys:match(702, \"Christchurch\", 201, \"Otago\", 104, \"Auckland\", [\"kidney\"], []),7).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "We allow queries for the first 10 time periods.",
   "metadata": {
    "cell_id": "efec94a1-bb6e-4010-bfe0-1e8fdf83c230",
    "tags": [],
    "deepnote_cell_height": 46,
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "cb44ac0e-b93b-48ab-9124-47a98af92a6e",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "6ac0959c",
    "execution_start": 1645477165588,
    "execution_millis": 85,
    "deepnote_cell_height": 112,
    "deepnote_cell_type": "code"
   },
   "source": "?- run(9).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "At time period 1, **monSys** receives a `donorOffer` message from Wellington. This causes the expectation that the donor offer will be matched, or a no match event will occur, with a countdown value of one. No messages had been sent or received by **monSys** before time period one, so the busyness level is set to low.",
   "metadata": {
    "cell_id": "242d0ace-91a5-4c10-a12a-fb649983451c",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "640c056f-a010-43a9-bb55-2d6800c9edec",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "c93ec5c5",
    "execution_start": 1645477165703,
    "execution_millis": 3,
    "deepnote_cell_type": "code"
   },
   "source": "?- happensAt(monSys, Event, 1).\n?- holdsAt(monSys, exp(_, _, _, within(_,TimeRemaining,WithinType), _, Message), 1).\n?- holdsAt(monSys, busyness(Level), 1).\n?- holdsAt(monSys, recentMessageTotal(Total), 1).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "Event = receive(b'Wellington', donorOffer(200, [Atom('687877'), Atom('688005')], [Functor(188685,2,bloodType,b'A')])) .\nTimeRemaining = 1, WithinType = localAcceptance, Message = :(b'Timely action', b'A donation offer should be matched or a declaration of no match found will occur with a countdown value of one') .\nLevel = low .\nTotal = 0 .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "As the busyness level was low at time period one, the `within` expectation countdown value dropped by one when it progressed and reached zero. Thus, a violation occurs, as no `match` or `noMatch` event occurs at time period 2 and the countdown value is less than or equal to zero.",
   "metadata": {
    "cell_id": "ba817d58-ea6c-42dd-82f4-3a615faa6736",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "d6ad2e53-2937-4f25-af39-627d65c37dca",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "814b9113",
    "execution_start": 1645477165704,
    "execution_millis": 2,
    "deepnote_cell_type": "code"
   },
   "source": "?- T = 2, happensAt(monSys, viol(_, _, _, within(_,TimeRemaining,WithinType), _, Message), T).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "T = 2, TimeRemaining = 0, WithinType = localAcceptance, Message = :(b'Timely action', b'A donation offer should be matched or a declaration of no match found will occur with a countdown value of one') .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "At time period 3, a `match` event occurs for **monSys**. This causes a `recipientFound` message (amongst others) to be sent at time period 4. This creates the expectation that the match offer will be accepted by the recipient's hospital with a countdown value of 3. As the busyness level is still low, this countdown value will drop by 1 from 3 to 2 for time period 5.",
   "metadata": {
    "cell_id": "337225a1-8b87-4f73-8e77-a6bd22aa0a1d",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "d664cc34-c8b1-4174-83ad-fb4ae675a4ba",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "764ea72d",
    "execution_start": 1645477165705,
    "execution_millis": 5,
    "deepnote_cell_type": "code"
   },
   "source": "?- happensAt(monSys, Event, 4).\n?- holdsAt(monSys, exp(_, _, _, within(_,TimeRemaining,WithinType), _, Message), 4).\n?- holdsAt(monSys, busyness(Level), 4).\n?- holdsAt(monSys, recentMessageTotal(Total), 4).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "Event = send(b'Wellington', recipientFound(701, 200, b'Otago', b'Auckland', [b'heart'], [])) ;\nEvent = send(b'Otago', donorFound(701, 103, b'Wellington', b'Auckland', [b'heart'], [])) ;\nEvent = send(b'Auckland', locationSelected(701, b'Wellington', b'Otago', [b'heart'], [])) ;\nEvent = send(b'Otago', waitAccept(104)) .\nTimeRemaining = 3, WithinType = foreignAcceptance, Message = :(b'Timely response', b\"A match offer should be accepted by the donor's hospital with a countdown value of three\") .\nLevel = low .\nTotal = 2 .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "At time period 5, **monSys** receives a `donorOffer` message from Christchurch. This creates the expectation that a `match` or `noMatch` event will occur by the next time period. The countdown value for the acceptance message from the recipient's hospital has dropped by 1 to 2 as expected.\nThe busyness level of **monSys** is now medium, as 6 messages have been sent or received by **monSys** in time periods 0-5.",
   "metadata": {
    "cell_id": "473e0077-d7f8-4489-8726-9a969b26b908",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "70fee093-1aab-4625-9555-ae94f99e15a6",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "9ee4e247",
    "execution_start": 1645477165740,
    "execution_millis": 5,
    "deepnote_cell_type": "code"
   },
   "source": "?- happensAt(monSys, Event, 5).\n?- holdsAt(monSys, exp(_, _, _, within(_,TimeRemaining,WithinType), _, Message), 5).\n?- holdsAt(monSys, busyness(Level), 5).\n?- holdsAt(monSys, recentMessageTotal(Total), 5).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "Event = receive(b'Christchurch', donorOffer(201, [Atom('688005')], [Functor(188685,2,bloodType,b'B')])) .\nTimeRemaining = 2, WithinType = foreignAcceptance, Message = :(b'Timely response', b\"A match offer should be accepted by the donor's hospital with a countdown value of three\") ;\nTimeRemaining = 1, WithinType = localAcceptance, Message = :(b'Timely action', b'A donation offer should be matched or a declaration of no match found will occur with a countdown value of one') .\nLevel = medium .\nTotal = 6 .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "As `foreignAcceptance` `within` expectations have a weighting of 1 under the medium busyness level, while `localAcceptance` `within` expectations have a weighting of 0.5 under the same level, the countdown value for our \"Timely response\" expectation decreases by one, while the countdown value for our \"Timely action\" expectation only decreases by 0.5 between time periods 5 and 6. At time period 6, the busyness level reaches high, with 7 messages being sent or received by **monSys** in the earlier time periods.",
   "metadata": {
    "cell_id": "95c2efa1-7b53-474a-b026-01f953b0e85e",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "de1be84b-5846-466d-8c43-f0be2852c5b3",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "a181d3ff",
    "execution_start": 1645477165741,
    "execution_millis": 4,
    "deepnote_cell_type": "code"
   },
   "source": "?- holdsAt(monSys, exp(_, _, _, within(_,TimeRemaining,WithinType), _, Message), 6).\n?- holdsAt(monSys, busyness(Level), 6).\n?- holdsAt(monSys, recentMessageTotal(Total), 6).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "TimeRemaining = 1, WithinType = foreignAcceptance, Message = :(b'Timely response', b\"A match offer should be accepted by the donor's hospital with a countdown value of three\") ;\nTimeRemaining = 0.5, WithinType = localAcceptance, Message = :(b'Timely action', b'A donation offer should be matched or a declaration of no match found will occur with a countdown value of one') .\nLevel = high .\nTotal = 7 .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "At time period 7, the countdown value for our \"Timely response\" expectation has again decreased by one, while the countdown value for our \"Timely action\" expectation has decreased by 0.333 to 0.1667 (with some floating point error). As the countdown value for our \"Timely response\" expectation has reached zero and the expected events have not occurred, a violation occurs.",
   "metadata": {
    "cell_id": "0f153a24-c2d1-4d90-ae26-73bd2f8221ba",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "64e23633-75ee-4e43-8b29-f430e43a6b05",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "26b194f9",
    "execution_start": 1645477165743,
    "execution_millis": 1,
    "deepnote_cell_type": "code"
   },
   "source": "?- holdsAt(monSys, exp(_, _, _, within(_,TimeRemaining,WithinType), _, Message), 7).\n?- happensAt(monSys, Event, 7).\n?- holdsAt(monSys, busyness(Level), 7).\n",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "TimeRemaining = 0, WithinType = foreignAcceptance, Message = :(b'Timely response', b\"A match offer should be accepted by the donor's hospital with a countdown value of three\") ;\nTimeRemaining = 0.16699999999999998, WithinType = localAcceptance, Message = :(b'Timely action', b'A donation offer should be matched or a declaration of no match found will occur with a countdown value of one') .\nEvent = viol(happ(send(b'Wellington', recipientFound(701, 200, b'Otago', b'Auckland', [b'heart'], []))), within(happ(receive(b'Wellington', acceptMatch(701))), 3, foreignAcceptance), 4, within(happ(receive(b'Wellington', acceptMatch(701))), 0, foreignAcceptance), dependent, :(b'Timely response', b\"A match offer should be accepted by the donor's hospital with a countdown value of three\")) .\nLevel = high .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "At time period 8, the countdown value for our \"Timely response\" expectation has dropped below zero, so a violation (finally!) occurs. Note that this expectation was created at time period 5 with a countdown value of 1. Under a low busyness level, a violation would have occurred at time period 6. However, due to the increased busyness levels, the drop in countdown value was diminished and it took an additional 2 time periods for a violation to occur.",
   "metadata": {
    "cell_id": "42798953-fa62-4d53-b397-f20ec359e7aa",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "42adde4a-a46c-4c4d-a256-0d3feb50ad91",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "ed3935f3",
    "execution_start": 1645477165796,
    "execution_millis": 6,
    "deepnote_cell_type": "code"
   },
   "source": "?- holdsAt(monSys, exp(_, _, _, within(_,TimeRemaining,WithinType), _, Message), 8).\n?- happensAt(monSys, Event, 8).\n?- holdsAt(monSys, busyness(Level), 8).\n",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "TimeRemaining = -0.16600000000000004, WithinType = localAcceptance, Message = :(b'Timely action', b'A donation offer should be matched or a declaration of no match found will occur with a countdown value of one') .\nEvent = viol(happ(receive(b'Christchurch', donorOffer(201, [Atom('688005')], [Functor(188685,2,bloodType,b'B')]))), within(or([Functor(14504077,1,noMatch(b'Christchurch', 201)), Functor(14504077,1,match(_1734, b'Christchurch', 201, _1740, _1742, _1744, _1746, _1748))]), 1, localAcceptance), 5, within(or([Functor(14504077,1,noMatch(b'Christchurch', 201)), Functor(14504077,1,match(_1734, b'Christchurch', 201, _1740, _1742, _1744, _1746, _1748))]), -0.16600000000000004, localAcceptance), dependent, :(b'Timely action', b'A donation offer should be matched or a declaration of no match found will occur with a countdown value of one')) .\nLevel = high .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "As illustrated above, we are able to have an event trigger an expectation rule at one busyness level, and  the drop in the associated countdown value will be affected by the busyness level during future time periods, until the expectation is either fulfilled or violated. This allows us to extend the time period specified for **within** expectations under busy scenarios. Adjustable expectations are not currently defined for other types of expectations, but this functionality could be added relatively easily.",
   "metadata": {
    "cell_id": "99688d81-91ef-4589-ad27-e0040d741b3e",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "markdown",
   "source": "## Independent expectations",
   "metadata": {
    "cell_id": "f7fc8e07-3f79-4dd8-911c-f4c427feab1f",
    "tags": [],
    "is_collapsed": false,
    "deepnote_cell_type": "text-cell-h2"
   }
  },
  {
   "cell_type": "markdown",
   "source": "Expectation rules should be subject to change if necessary. Specific events can be used to initiate and terminate expectation rules. As expectation rules lead to expectations holding when their conditions have been fulfilled, we also want to specify how termination of an expectation rule will affect the associated expectations.\n\nFor example, we could have an expectation rule which states that all patients who had admitted to hospital will eventually be discharged. The expectation that a patient would eventually be discharged would be triggered when they were admitted, and fulfilled upon their dischargement. This expectation would not be fulfilled for any patients who pass away in hospital. At a point where multiple patients are currently in hospital and have not yet been discharged, our expectation rule may be terminated by an event. It must then be decided whether the expectation of eventual discharge should continue to be applied to existing patients, or removed from all current patients, in addition to not applying to future admissions.",
   "metadata": {
    "cell_id": "8af185b6-b67f-4cdf-a57f-c5c5a95a29d6",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "5a97b3f5-d231-4d37-95fe-53105c1a6bc3",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "865bf12b",
    "execution_start": 1645477165798,
    "execution_millis": 4,
    "deepnote_cell_type": "code"
   },
   "source": "?- retractall(initially(_)).\n?- cd('~/work'), ['dec:notation'].\n?- initialiseDEC.\n?- retractall(happensAtNarrative(_,_)).\n?- ['AE'].",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.\ntrue.\ntrue.\ntrue.\ntrue.",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "### Example Expectation Rule (dependent)",
   "metadata": {
    "cell_id": "1dbe2e90-1912-4f4b-b7ef-52e007a2d57a",
    "tags": [],
    "is_collapsed": false,
    "deepnote_cell_type": "text-cell-h3"
   }
  },
  {
   "cell_type": "markdown",
   "source": "We use an expectation rule with the form **exp_rule(Condition, Outcome, Status, Message))**. **Condition** refers to the triggering condition for the resulting expectation and **Outcome** is the state that needs to be reached for the expectation to be fulfilled. If **Status** is set to *independent*, then expectations resulting from our expectation will remain even if the expectation rule is deleted. **Message** is a more user friendly message describing the expectation rule. Currently, **Message** is used as a unique identifier to facilitate easier termination of expectation rules.\n\nIn our example expectation rule, which is for Otago hospital, we declare that the starting condition for our expectation is the admission of a patient, that the resulting expected outcome is that the patient will eventually be discharged, that the resulting expectations shall be dependent, and use the message \"Dependency Example\":\"Patients must eventually be discharged\" to describe the expectation rule.",
   "metadata": {
    "cell_id": "8b23e7ed-47ce-4270-aa97-9d2cf2ca9260",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "a7cff2ab-9b7f-430f-86d9-4c5197b13b1f",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "d7501001",
    "execution_start": 1645477165798,
    "execution_millis": 38,
    "deepnote_cell_type": "code"
   },
   "source": "% File: expectationRule.pl\ninitially(\"Otago\":exp_rule(happ(admission(Patient)), eventually(happ(discharge(Patient))), dependent, \n\"Dependency Example\":\"Patients must eventually be discharged\")).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "### Example Rule Termination",
   "metadata": {
    "cell_id": "19c36c7e-aebb-4877-b0ba-1f33e0e25c03",
    "tags": [],
    "is_collapsed": false,
    "deepnote_cell_type": "text-cell-h3"
   }
  },
  {
   "cell_type": "markdown",
   "source": "An **optionalDischarge** event can be used to terminate our expectation rule.",
   "metadata": {
    "cell_id": "22c72a8c-fb2e-402a-9fde-8a1159e67ca8",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "02f0c1b8-fdff-418f-a162-90ed2e8e31e7",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "851e478b",
    "execution_start": 1645477165834,
    "execution_millis": 3,
    "deepnote_cell_type": "code"
   },
   "source": "% File: expRuleTermination.pl\nterminates(\"Otago\":optionalDischarge, exp_rule(_,_,_, \"Dependency Example\":\"Patients must eventually be discharged\"), _).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "### Example Narrative",
   "metadata": {
    "cell_id": "39a248e0-75e2-4446-97cc-eeeeb6772442",
    "tags": [],
    "is_collapsed": false,
    "deepnote_cell_type": "text-cell-h3"
   }
  },
  {
   "cell_type": "markdown",
   "source": "Patient 123 is admitted at time period 1, while patients 124 and 125 are both admitted at time period 2. The **optionalDischarge** event occurs at time period 3. ",
   "metadata": {
    "cell_id": "4c3c32d5-2582-44c2-86f5-71e1a0ff00b1",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "315d40bc-b3c9-4237-91bd-d36ef8edb0d5",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "c95ed88d",
    "execution_start": 1645477165834,
    "execution_millis": 3,
    "deepnote_cell_type": "code"
   },
   "source": "% File: narrative.pl\nhappensAtNarrative(\"Otago\":admission(123),1).\nhappensAtNarrative(\"Otago\":admission(124),2).\nhappensAtNarrative(\"Otago\":admission(125),2).\nhappensAtNarrative(\"Otago\":optionalDischarge, 3).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "At time period zero, we can see that our expectation rule holds.",
   "metadata": {
    "cell_id": "76bca334-9c43-45c5-af27-f5f07916d707",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "611161bd-865f-4f76-91b8-581197ad4d86",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "921e1c1c",
    "execution_start": 1645477165839,
    "execution_millis": 8,
    "deepnote_cell_type": "code"
   },
   "source": "?- tick(0).\n?- holdsAt(\"Otago\", exp_rule(Trigger, Outcome, Status, Message),0).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.\nTrigger = happ(admission(_1722)), Outcome = eventually(happ(discharge(_1722))), Status = dependent, Message = :(b'Dependency Example', b'Patients must eventually be discharged') .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "At time period one, the expectation that Patient 123 will eventually be admitted holds.",
   "metadata": {
    "cell_id": "ebffa259-0bfc-4404-9dc5-7ed59d12d9b1",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "e2f7f975-5eec-4a4f-9bd5-ac670851b257",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "88676ce2",
    "execution_start": 1645477165847,
    "execution_millis": 10,
    "deepnote_cell_type": "code"
   },
   "source": "?- tick(1).\n?- happensAt(\"Otago\", Event, 1).\n?- holdsAt(\"Otago\", exp(Outcome, Status, Message), 1).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.\nEvent = admission(123) .\nOutcome = eventually(happ(discharge(123))), Status = dependent, Message = :(b'Dependency Example', b'Patients must eventually be discharged') .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "At time period two, we expect that all three patients will eventually be discharged. ",
   "metadata": {
    "cell_id": "36cd9c16-1db4-4a78-af3c-067c2cda2ac9",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "944b70cd-2c5e-49d8-9a55-007dd83b7bb0",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "ffce3e36",
    "execution_start": 1645477165861,
    "execution_millis": 11,
    "deepnote_cell_type": "code"
   },
   "source": "?- tick(2).\n?- happensAt(\"Otago\", Event, 2).\n?- holdsAt(\"Otago\", Fluent, 2), Fluent \\= exp(_,_,_,_,_,_), Fluent \\= recentMessageTotal(_).\n",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.\nEvent = admission(124) ;\nEvent = admission(125) .\nFluent = exp_rule(happ(admission(_1744)), eventually(happ(discharge(_1744))), dependent, :(b'Dependency Example', b'Patients must eventually be discharged')) ;\nFluent = exp(eventually(happ(discharge(123))), dependent, :(b'Dependency Example', b'Patients must eventually be discharged')) ;\nFluent = exp(eventually(happ(discharge(124))), dependent, :(b'Dependency Example', b'Patients must eventually be discharged')) ;\nFluent = exp(eventually(happ(discharge(125))), dependent, :(b'Dependency Example', b'Patients must eventually be discharged')) .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "At time period three, the **optionalDischarge** event occurs. At this time period, the expectation rule and resulting expectations still hold.",
   "metadata": {
    "cell_id": "d86457e9-f33f-41c0-b8da-7719cf509498",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "4e836b93-3e3d-4ab4-a78f-55d2a83c8583",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "65d14862",
    "execution_start": 1645477165876,
    "execution_millis": 45,
    "deepnote_cell_type": "code"
   },
   "source": "?- tick(3).\n?- happensAt(\"Otago\", Event, 3).\n?- holdsAt(\"Otago\", Fluent, 3), Fluent \\= exp(_,_,_,_,_,_), Fluent \\= recentMessageTotal(_).\n",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.\nEvent = optionalDischarge .\nFluent = exp_rule(happ(admission(_1724)), eventually(happ(discharge(_1724))), dependent, :(b'Dependency Example', b'Patients must eventually be discharged')) ;\nFluent = exp(eventually(happ(discharge(123))), dependent, :(b'Dependency Example', b'Patients must eventually be discharged')) ;\nFluent = exp(eventually(happ(discharge(124))), dependent, :(b'Dependency Example', b'Patients must eventually be discharged')) ;\nFluent = exp(eventually(happ(discharge(125))), dependent, :(b'Dependency Example', b'Patients must eventually be discharged')) .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "At time period four, the expectation rule no longer holds, as it was terminated by the **optionalDischarge** event. As the status of the expectation rule was set to **dependent**, the expectations that patients 123, 124 and 125 will eventually be discharged also no longer exist.",
   "metadata": {
    "cell_id": "ec0100df-6e67-424d-9ca1-f53fa2335357",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "1f131349-2867-4a47-844a-da0bcd61aded",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "5f329d6d",
    "execution_start": 1645477165918,
    "execution_millis": 5,
    "deepnote_cell_type": "code"
   },
   "source": "?- tick(4).\n?- holdsAt(\"Otago\", Fluent, 4), Fluent \\= recentMessageTotal(_).\n",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.\nfalse.",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "### Independent Expectation Scenario",
   "metadata": {
    "cell_id": "bfb58080-f5fd-4091-9a31-19691c7f74c1",
    "tags": [],
    "is_collapsed": false,
    "deepnote_cell_type": "text-cell-h3"
   }
  },
  {
   "cell_type": "markdown",
   "source": "Let us instead consider a scenario in which the expectation are not dependent on their expectation rule. Note that the third argument of the new expectation rule is **independent** rather than **dependent**. We use the **newExpRule** event at time period five to initiate our new expectation rule. Patient 126 is admitted at time period six, and patients 127 and 128 are admitted at time period seven. Also at time period seven, the **optionalDischarge** event occurs which terminates our expectation rule.  ",
   "metadata": {
    "cell_id": "43cbdd77-f450-453b-a8e4-090b38148414",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "7a0849db-dba5-47c4-8155-422767a28aad",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "19829a26",
    "execution_start": 1645477165919,
    "execution_millis": 4,
    "deepnote_cell_type": "code"
   },
   "source": "% File: dependentScenario.pl\ninitiates(\"Otago\":newExpRule(Condition,Outcome,Status,Message), exp_rule(Condition,Outcome,Status,Message),_).\nhappensAtNarrative(\"Otago\":newExpRule(happ(admission(Patient)), eventually(happ(discharge(Patient))), independent, \n\"Dependency Example\":\"Patients must eventually be discharged\"),5).\nhappensAtNarrative(\"Otago\":admission(126),6).\nhappensAtNarrative(\"Otago\":admission(127),7).\nhappensAtNarrative(\"Otago\":admission(128),7).\nhappensAtNarrative(\"Otago\":optionalDischarge, 7).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "Our expectation rule holds from time period six onwards.",
   "metadata": {
    "cell_id": "771630c9-6a69-46b5-b0ea-d40c7a3541a1",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "8a63ecd3-ba2f-448b-9cec-e6bed956e478",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "732cea59",
    "execution_start": 1645477165920,
    "execution_millis": 35,
    "deepnote_cell_type": "code"
   },
   "source": "?- tick(5).\n?- happensAt(\"Otago\", Event, 5).\n?- holdsAt(\"Otago\", Fluent, 5), Fluent \\= exp(_,_,_,_,_,_), Fluent \\= recentMessageTotal(_).\n",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.\nEvent = newExpRule(happ(admission(_1636)), eventually(happ(discharge(_1636))), independent, :(b'Dependency Example', b'Patients must eventually be discharged')) .\nfalse.",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "The expectation that patient 126 will eventually be discharged has been correctly triggered by the expectation rule.",
   "metadata": {
    "cell_id": "3d3e7457-4662-4dde-9cda-2385a9935a2c",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "8151bfcb-de4f-4906-b33d-1d0f872eba15",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "58526709",
    "execution_start": 1645477165952,
    "execution_millis": 5,
    "deepnote_cell_type": "code"
   },
   "source": "?- tick(6).\n?- happensAt(\"Otago\", Event, 6).\n?- holdsAt(\"Otago\", Fluent, 6), Fluent \\= exp(_,_,_,_,_,_), Fluent \\= recentMessageTotal(_).\n",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.\nEvent = admission(126) .\nFluent = exp_rule(happ(admission(_1724)), eventually(happ(discharge(_1724))), independent, :(b'Dependency Example', b'Patients must eventually be discharged')) ;\nFluent = exp(eventually(happ(discharge(126))), independent, :(b'Dependency Example', b'Patients must eventually be discharged')) .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "Similarly, expectations also hold for patients 127 and 128 at time period seven. Also at this time period, the **optionalDischarge** event takes place.",
   "metadata": {
    "cell_id": "3e76ea95-c2e0-4f4d-8fad-25499d6e3849",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "66078d8d-1922-420c-a581-ff502478fd75",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "34393142",
    "execution_start": 1645477165953,
    "execution_millis": 4,
    "deepnote_cell_type": "code"
   },
   "source": "?- tick(7).\n?- happensAt(\"Otago\", Event, 7).\n?- holdsAt(\"Otago\", Fluent, 7), Fluent \\= exp(_,_,_,_,_,_), Fluent \\= recentMessageTotal(_).\n",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.\nEvent = admission(127) ;\nEvent = admission(128) ;\nEvent = optionalDischarge .\nFluent = exp_rule(happ(admission(_1724)), eventually(happ(discharge(_1724))), independent, :(b'Dependency Example', b'Patients must eventually be discharged')) ;\nFluent = exp(eventually(happ(discharge(126))), independent, :(b'Dependency Example', b'Patients must eventually be discharged')) ;\nFluent = exp(eventually(happ(discharge(127))), independent, :(b'Dependency Example', b'Patients must eventually be discharged')) ;\nFluent = exp(eventually(happ(discharge(128))), independent, :(b'Dependency Example', b'Patients must eventually be discharged')) .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "At time period eight, our expectation rule no longer holds. However, because our expectations are independent of the rule, they continue to hold.",
   "metadata": {
    "cell_id": "406d434c-5f4e-4bf2-bede-cc5bef80b25f",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "code",
   "metadata": {
    "cell_id": "088fa636-6beb-4c92-991b-8c43f059c2b6",
    "tags": [],
    "deepnote_to_be_reexecuted": false,
    "source_hash": "7db9c9",
    "execution_start": 1645477165954,
    "execution_millis": 13,
    "deepnote_cell_type": "code"
   },
   "source": "?- tick(8).\n?- holdsAt(\"Otago\", exp_rule(Condition,Outcome, Status, Message),8).\n?- holdsAt(\"Otago\", Fluent, 8), Fluent \\= exp(_,_,_,_,_,_), Fluent \\= recentMessageTotal(_).",
   "execution_count": null,
   "outputs": [
    {
     "name": "stdout",
     "text": "true.\nfalse.\nFluent = exp(eventually(happ(discharge(126))), independent, :(b'Dependency Example', b'Patients must eventually be discharged')) ;\nFluent = exp(eventually(happ(discharge(127))), independent, :(b'Dependency Example', b'Patients must eventually be discharged')) ;\nFluent = exp(eventually(happ(discharge(128))), independent, :(b'Dependency Example', b'Patients must eventually be discharged')) .",
     "output_type": "stream"
    }
   ]
  },
  {
   "cell_type": "markdown",
   "source": "So, we can set the status of expectation rules to independent or dependent in order to control whether expectations are terminated along with their parent expectation rule. A text message can be used to describe expectation rules in a more user friendly manner, and used to identify expectation rules.",
   "metadata": {
    "cell_id": "4fda7447-51fc-46e7-a6b9-8f5537ee1634",
    "tags": [],
    "deepnote_cell_type": "markdown"
   }
  },
  {
   "cell_type": "markdown",
   "source": "<a style='text-decoration:none;line-height:16px;display:flex;color:#5B5B62;padding:10px;justify-content:end;' href='https://deepnote.com?utm_source=created-in-deepnote-cell&projectId=32f94018-a4da-40ef-8c9f-8983d73811c8' target=\"_blank\">\n<img alt='Created in deepnote.com' style='display:inline;max-height:16px;margin:0px;margin-right:7.5px;' src='data:image/svg+xml;base64,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' > </img>\nCreated in <span style='font-weight:600;margin-left:4px;'>Deepnote</span></a>",
   "metadata": {
    "tags": [],
    "created_in_deepnote_cell": true,
    "deepnote_cell_type": "markdown"
   }
  }
 ],
 "nbformat": 4,
 "nbformat_minor": 2,
 "metadata": {
  "orig_nbformat": 2,
  "deepnote": {
   "is_reactive": false
  },
  "deepnote_notebook_id": "e282702a-315d-43d7-b6cf-4e10a1f33669",
  "deepnote_execution_queue": [],
  "deepnote_app_layout": "article"
 }
}