diff --git a/README.md b/README.md index e3aa1f9e4..579f63b62 100644 --- a/README.md +++ b/README.md @@ -111,7 +111,7 @@ Here is a table of algorithms, the figure, name of the algorithm in the book and | 10.1 | Air-Cargo-problem | `air_cargo` | [`planning.py`][planning] | Done | Included | | 10.2 | Spare-Tire-Problem | `spare_tire` | [`planning.py`][planning] | Done | Included | | 10.3 | Three-Block-Tower | `three_block_tower` | [`planning.py`][planning] | Done | Included | -| 10.7 | Cake-Problem | `have_cake_and_eat_cake_too` | [`planning.py`][planning] | Done | | +| 10.7 | Cake-Problem | `have_cake_and_eat_cake_too` | [`planning.py`][planning] | Done | Included | | 10.9 | Graphplan | `GraphPlan` | [`planning.py`][planning] | | | | 10.13 | Partial-Order-Planner | | | | | | 11.1 | Job-Shop-Problem-With-Resources | `job_shop_problem` | [`planning.py`][planning] | Done | | @@ -186,4 +186,4 @@ Many thanks for contributions over the years. I got bug reports, corrected code, [rl]:../master/rl.py [search]:../master/search.py [utils]:../master/utils.py -[text]:../master/text.py \ No newline at end of file +[text]:../master/text.py diff --git a/planning.ipynb b/planning.ipynb index 5c26e5b5e..6a79a3100 100644 --- a/planning.ipynb +++ b/planning.ipynb @@ -26,7 +26,8 @@ "metadata": {}, "outputs": [], "source": [ - "from planning import *" + "from planning import *\n", + "from notebook import psource" ] }, { @@ -302,13 +303,185 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Air Cargo problem involves loading and unloading of cargo and flying it from place to place. The problem can be with defined with three actions: Load, Unload and Fly. Let us now define an object of `air_cargo` problem:" + "Air Cargo problem involves loading and unloading of cargo and flying it from place to place. The problem can be defined with three actions: Load, Unload and Fly. Let us look at `air_cargo`. " ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

\n", + "\n", + "
def air_cargo():\n",
+       "    init = [expr('At(C1, SFO)'),\n",
+       "            expr('At(C2, JFK)'),\n",
+       "            expr('At(P1, SFO)'),\n",
+       "            expr('At(P2, JFK)'),\n",
+       "            expr('Cargo(C1)'),\n",
+       "            expr('Cargo(C2)'),\n",
+       "            expr('Plane(P1)'),\n",
+       "            expr('Plane(P2)'),\n",
+       "            expr('Airport(JFK)'),\n",
+       "            expr('Airport(SFO)')]\n",
+       "\n",
+       "    def goal_test(kb):\n",
+       "        required = [expr('At(C1 , JFK)'), expr('At(C2 ,SFO)')]\n",
+       "        return all([kb.ask(q) is not False for q in required])\n",
+       "\n",
+       "    # Actions\n",
+       "\n",
+       "    #  Load\n",
+       "    precond_pos = [expr("At(c, a)"), expr("At(p, a)"), expr("Cargo(c)"), expr("Plane(p)"),\n",
+       "                   expr("Airport(a)")]\n",
+       "    precond_neg = []\n",
+       "    effect_add = [expr("In(c, p)")]\n",
+       "    effect_rem = [expr("At(c, a)")]\n",
+       "    load = Action(expr("Load(c, p, a)"), [precond_pos, precond_neg], [effect_add, effect_rem])\n",
+       "\n",
+       "    #  Unload\n",
+       "    precond_pos = [expr("In(c, p)"), expr("At(p, a)"), expr("Cargo(c)"), expr("Plane(p)"),\n",
+       "                   expr("Airport(a)")]\n",
+       "    precond_neg = []\n",
+       "    effect_add = [expr("At(c, a)")]\n",
+       "    effect_rem = [expr("In(c, p)")]\n",
+       "    unload = Action(expr("Unload(c, p, a)"), [precond_pos, precond_neg], [effect_add, effect_rem])\n",
+       "\n",
+       "    #  Fly\n",
+       "    #  Used 'f' instead of 'from' because 'from' is a python keyword and expr uses eval() function\n",
+       "    precond_pos = [expr("At(p, f)"), expr("Plane(p)"), expr("Airport(f)"), expr("Airport(to)")]\n",
+       "    precond_neg = []\n",
+       "    effect_add = [expr("At(p, to)")]\n",
+       "    effect_rem = [expr("At(p, f)")]\n",
+       "    fly = Action(expr("Fly(p, f, to)"), [precond_pos, precond_neg], [effect_add, effect_rem])\n",
+       "\n",
+       "    return PDDL(init, [load, unload, fly], goal_test)\n",
+       "
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "psource(air_cargo)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**At(x, a):** The cargo or plane **'x'** is at airport **'a'**.\n", + "\n", + "**In(c, p):** Cargo **'c'** is in palne **'p'**.\n", + "\n", + "**Cargo(x):** Declare **'x'** as cargo.\n", + "\n", + "**Plane(x):** Declare **'x'** as plane.\n", + "\n", + "**Airport(x):** Declare **'x'** as airport.\n", + "\n", + "\n", + "\n", + "In the `initial_state`, we have cargo C1, plane P1 at airport SFO and cargo C2, plane P2 at airport JFK. Our goal state is to have cargo C1 at airport JFK and cargo C2 at airport SFO. We will discuss on how to achieve this. Let us now define an object of the `air_cargo` problem:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, "outputs": [], "source": [ "airCargo = air_cargo()" @@ -323,7 +496,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -342,22 +515,29 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "As we can see, it hasn't completed the goal. Now, we define the sequence of actions that it should take in order to achieve\n", - "the goal. Then the `airCargo` acts on each of them." + "It returns False because the goal state is not yet reached. Now, we define the sequence of actions that it should take in order to achieve the goal. Then the `airCargo` acts on each of them.\n", + "\n", + "The actions available to us are the following: Load, Unload, Fly\n", + "\n", + "**Load(c, p, a):** Load cargo **'c'** into plane **'p'** from airport **'a'**.\n", + "\n", + "**Fly(p, f, t):** Fly the plane **'p'** from airport **'f'** to airport **'t'**.\n", + "\n", + "**Unload(c, p, c):** Unload cargo **'c'** from plane **'p'** to airport **'a'**.\n" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "solution = [expr(\"Load(C1 , P1, SFO)\"),\n", - " expr(\"Fly(P1, SFO, JFK)\"),\n", - " expr(\"Unload(C1, P1, JFK)\"),\n", - " expr(\"Load(C2, P2, JFK)\"),\n", - " expr(\"Fly(P2, JFK, SFO)\"),\n", - " expr(\"Unload (C2, P2, SFO)\")] \n", + " expr(\"Fly(P1, SFO, JFK)\"),\n", + " expr(\"Unload(C1, P1, JFK)\"),\n", + " expr(\"Load(C2, P2, JFK)\"),\n", + " expr(\"Fly(P2, JFK, SFO)\"),\n", + " expr(\"Unload (C2, P2, SFO)\")] \n", "\n", "for action in solution:\n", " airCargo.act(action)" @@ -372,22 +552,19 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 15, "metadata": {}, "outputs": [ { - "data": { - "text/plain": [ - "True" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] } ], "source": [ - "airCargo.goal_test()" + "print(airCargo.goal_test())" ] }, { @@ -408,12 +585,169 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Let's consider the problem of changing a flat tire. The goal is to have a good spare tire properly mounted onto the car's axle, where the initial state has a flat tire on the axle and a good spare tire in the trunk. Let us now define an object of `spare_tire` problem:" + "Let's consider the problem of changing a flat tire of a car. The goal is to have a good spare tire properly mounted onto the car's axle, where the initial state has a flat tire on the axle and a good spare tire in the trunk. " ] }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

\n", + "\n", + "
def spare_tire():\n",
+       "    init = [expr('Tire(Flat)'),\n",
+       "            expr('Tire(Spare)'),\n",
+       "            expr('At(Flat, Axle)'),\n",
+       "            expr('At(Spare, Trunk)')]\n",
+       "\n",
+       "    def goal_test(kb):\n",
+       "        required = [expr('At(Spare, Axle)')]\n",
+       "        return all(kb.ask(q) is not False for q in required)\n",
+       "\n",
+       "    # Actions\n",
+       "\n",
+       "    # Remove\n",
+       "    precond_pos = [expr("At(obj, loc)")]\n",
+       "    precond_neg = []\n",
+       "    effect_add = [expr("At(obj, Ground)")]\n",
+       "    effect_rem = [expr("At(obj, loc)")]\n",
+       "    remove = Action(expr("Remove(obj, loc)"), [precond_pos, precond_neg], [effect_add, effect_rem])\n",
+       "\n",
+       "    # PutOn\n",
+       "    precond_pos = [expr("Tire(t)"), expr("At(t, Ground)")]\n",
+       "    precond_neg = [expr("At(Flat, Axle)")]\n",
+       "    effect_add = [expr("At(t, Axle)")]\n",
+       "    effect_rem = [expr("At(t, Ground)")]\n",
+       "    put_on = Action(expr("PutOn(t, Axle)"), [precond_pos, precond_neg], [effect_add, effect_rem])\n",
+       "\n",
+       "    # LeaveOvernight\n",
+       "    precond_pos = []\n",
+       "    precond_neg = []\n",
+       "    effect_add = []\n",
+       "    effect_rem = [expr("At(Spare, Ground)"), expr("At(Spare, Axle)"), expr("At(Spare, Trunk)"),\n",
+       "                  expr("At(Flat, Ground)"), expr("At(Flat, Axle)"), expr("At(Flat, Trunk)")]\n",
+       "    leave_overnight = Action(expr("LeaveOvernight"), [precond_pos, precond_neg],\n",
+       "                             [effect_add, effect_rem])\n",
+       "\n",
+       "    return PDDL(init, [remove, put_on, leave_overnight], goal_test)\n",
+       "
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "psource(spare_tire)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**At(x, l):** object **'x'** is at location **'l'**.\n", + "\n", + "**Tire(x):** Declare a tire of type **'x'**.\n", + "\n", + "Let us now define an object of `spare_tire` problem:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -429,7 +763,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -448,12 +782,19 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "As we can see, it hasn't completed the goal. Now, we define the sequence of actions that it should take in order to have a good spare tire properly mounted onto the car's axle. Then the `spare_tire` acts on each of them." + "As we can see, it hasn't completed the goal. Now, we define the sequence of actions that it should take in order to have a good spare tire properly mounted onto the car's axle. Then the `spare_tire` acts on each of them.\n", + "\n", + "The actions available to us are the following: Remove, PutOn\n", + "\n", + "**Remove(obj, loc):** Remove the tire **'obj'** from the location **'loc'**.\n", + "\n", + "**PutOn(t, Axle):** Attach the tire **'t'** on the Axle.\n", + "\n" ] }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -474,7 +815,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -507,12 +848,175 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This problem's domain consists of a set of cube-shaped blocks sitting on a table. The blocks can be stacked , but only one block can fit directly on top of another. A robot arm can pick up a block and move it to another position, either on the table or on top of another block. The arm can pick up only one block at a time, so it cannot pick up a block that has another one on it. The goal will always be to build one or more stacks of blocks. In our case, we consider only three blocks. Let us now define an object of `three_block_tower` problem:" + "This problem's domain consists of a set of cube-shaped blocks sitting on a table. The blocks can be stacked, but only one block can fit directly on top of another. A robot arm can pick up a block and move it to another position, either on the table or on top of another block. The arm can pick up only one block at a time, so it cannot pick up a block that has another one on it. The goal will always be to build one or more stacks of blocks. In our case, we consider only three blocks." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "let us take a look at the `three_block_tower()` code." ] }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

\n", + "\n", + "
def three_block_tower():\n",
+       "    init = [expr('On(A, Table)'),\n",
+       "            expr('On(B, Table)'),\n",
+       "            expr('On(C, A)'),\n",
+       "            expr('Block(A)'),\n",
+       "            expr('Block(B)'),\n",
+       "            expr('Block(C)'),\n",
+       "            expr('Clear(B)'),\n",
+       "            expr('Clear(C)')]\n",
+       "\n",
+       "    def goal_test(kb):\n",
+       "        required = [expr('On(A, B)'), expr('On(B, C)')]\n",
+       "        return all(kb.ask(q) is not False for q in required)\n",
+       "\n",
+       "    # Actions\n",
+       "\n",
+       "    #  Move\n",
+       "    precond_pos = [expr('On(b, x)'), expr('Clear(b)'), expr('Clear(y)'), expr('Block(b)'),\n",
+       "                   expr('Block(y)')]\n",
+       "    precond_neg = []\n",
+       "    effect_add = [expr('On(b, y)'), expr('Clear(x)')]\n",
+       "    effect_rem = [expr('On(b, x)'), expr('Clear(y)')]\n",
+       "    move = Action(expr('Move(b, x, y)'), [precond_pos, precond_neg], [effect_add, effect_rem])\n",
+       "\n",
+       "    #  MoveToTable\n",
+       "    precond_pos = [expr('On(b, x)'), expr('Clear(b)'), expr('Block(b)')]\n",
+       "    precond_neg = []\n",
+       "    effect_add = [expr('On(b, Table)'), expr('Clear(x)')]\n",
+       "    effect_rem = [expr('On(b, x)')]\n",
+       "    moveToTable = Action(expr('MoveToTable(b, x)'), [precond_pos, precond_neg],\n",
+       "                         [effect_add, effect_rem])\n",
+       "\n",
+       "    return PDDL(init, [move, moveToTable], goal_test)\n",
+       "
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "psource(three_block_tower)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**On(b, x):** The block **'b'** is on **'x'**. **'x'** can be a table or a block.\n", + "\n", + "**Block(x):** Declares **'x'** as a block.\n", + "\n", + "**Clear(x):** To tell that there is nothing on **'x'**.\n", + " \n", + " Let us now define an object of `three_block_tower` problem:" + ] + }, + { + "cell_type": "code", + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -528,7 +1032,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -547,12 +1051,18 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "As we can see, it hasn't completed the goal. Now, we define the sequence of actions that it should take in order to build a stack of three blocks. Then the `three_block_tower` acts on each of them." + "As we can see, it hasn't completed the goal. Now, we define the sequence of actions that it should take in order to build a stack of three blocks. Then the `three_block_tower` acts on each of them.\n", + "\n", + "The actions available to us are the following: MoveToTable, Move\n", + "\n", + "**MoveToTable(b, x):** Move the box **'b'** which is on top of box **'x'** to the table.\n", + "\n", + "**Move(b, x, y):** Move box **'b'** from top of **'x'** to the top of **'y'**.\n" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -573,7 +1083,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 25, "metadata": {}, "outputs": [ { @@ -594,6 +1104,249 @@ "source": [ "It has now successfully achieved its goal i.e, to build a stack of three blocks." ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Have Cake and Eat Cake Too" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This problem involves the task of eating a cake with an initial condition of having a cake. First, let us take a look at `have_cake_and_eat_cake_too`" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + "\n", + "

\n", + "\n", + "
def have_cake_and_eat_cake_too():\n",
+       "    init = [expr('Have(Cake)')]\n",
+       "\n",
+       "    def goal_test(kb):\n",
+       "        required = [expr('Have(Cake)'), expr('Eaten(Cake)')]\n",
+       "        return all(kb.ask(q) is not False for q in required)\n",
+       "\n",
+       "    # Actions\n",
+       "\n",
+       "    # Eat cake\n",
+       "    precond_pos = [expr('Have(Cake)')]\n",
+       "    precond_neg = []\n",
+       "    effect_add = [expr('Eaten(Cake)')]\n",
+       "    effect_rem = [expr('Have(Cake)')]\n",
+       "    eat_cake = Action(expr('Eat(Cake)'), [precond_pos, precond_neg], [effect_add, effect_rem])\n",
+       "\n",
+       "    # Bake Cake\n",
+       "    precond_pos = []\n",
+       "    precond_neg = [expr('Have(Cake)')]\n",
+       "    effect_add = [expr('Have(Cake)')]\n",
+       "    effect_rem = []\n",
+       "    bake_cake = Action(expr('Bake(Cake)'), [precond_pos, precond_neg], [effect_add, effect_rem])\n",
+       "\n",
+       "    return PDDL(init, [eat_cake, bake_cake], goal_test)\n",
+       "
\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "psource(have_cake_and_eat_cake_too)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Have(x):** Declares that we have **' x '**." + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "have_cake_and_eat_cake_too = have_cake_and_eat_cake_too()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First let us check wether the goal state (have cake and eat cake) is reached or not." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n" + ] + } + ], + "source": [ + "print(have_cake_and_eat_cake_too.goal_test())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As the goal state is not reached we will make some actions and we will let `have_cake_and_eat_cake_too` act on them. To eat the cake we need to bake it. Let us look at the actions that we can do.\n", + "\n", + "**Bake(x):** To bake **' x '**.\n", + "\n", + "**Eat(x):** To eat **' x '**." + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "solution = [expr(\"Bake(cake)\"),\n", + " expr(\"Eat(cake)\")]\n", + "\n", + "for action in solution:\n", + " have_cake_and_eat_cake_too.act(action)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we have made actions to bake the cake and eat the cake. The goal state is **having and eating the cake**. Let us check if it is reached or not." + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n" + ] + } + ], + "source": [ + "print(have_cake_and_eat_cake_too.goal_test())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It has now successfully achieved its goal i.e, to have and eat the cake." + ] } ], "metadata": { @@ -612,7 +1365,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.5.2" } }, "nbformat": 4, diff --git a/planning.py b/planning.py index bb54f2027..b7c1c021d 100644 --- a/planning.py +++ b/planning.py @@ -867,15 +867,3 @@ def goal_test(kb): goal_test, [job_group1, job_group2], resources) -def test_three_block_tower(): - p = three_block_tower() - assert p.goal_test() is False - solution = [expr("MoveToTable(C, A)"), - expr("Move(B, Table, C)"), - expr("Move(A, Table, B)")] - - for action in solution: - p.act(action) - - assert p.goal_test() -