DEMO.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# households demo: modelling and household lifecycles #\n",
    "\n",
    "**Andrew Cabaniss**\n",
    "*Interdepartmental Program in Classical Art and Archaeology, University of Michigan, Ann Arbor, MI*\n",
    "\n",
    "ahfc@umich.edu\n",
    "\n",
    "[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/acabaniss/house-inheritance/classes?filepath=DEMO.ipynb)\n",
    "\n",
    "**I can guarantee this code doesn't run properly right now. Please wait for this to be updated with the latest release.**\n",
    "\n",
    "Model construction has a long history in archaeology, but most models are still applied without explicit definition. In the realm of household archaeology, namely the study of the physical remains of houses and the attempts to reconstruct the social lives of their inhabitants, assumptions about the timescale of household growth and house renovation regularly rely on the temporality of events in the lifecycle. These assumptions are sometimes rooted in ethnographic observations of Mediterranean or world villages, while other times they are based on the author's intuition or personal experiences. Regardless of the justification, such models can be more profitably explored by explicit definition and construction. \n",
    "\n",
    "An explicit computational model of household lifecycles and house renovation can be constructed using the households Python package. I am writing this package to provide a consistent simulation toolbox for modelling ancient households as well as better understand the intersection between demographic processes and sociocultural transformations of daily life. The package is designed with comparability and easy parametrization in mind, making it possible to perform complex simulations which contrast individual and household lifecycle behaviors such as marriage, inheritance, fragmentation, and fusion.\n",
    "\n",
    "At present, the simulation framework is set up to model homogeneous communities which collectively enact social structures such as neolocality, patrilineal inheritance, or fraternal rivalry. A forthcoming modification to this package will enable multiple communities to coexist as well as allow individuals who enter the simulation (via immigration or birth) to adopt, adapt, learn, or improvise new behaviors as well. At present, it is best suited for answering questions about the relationship between individual settled communities or villages and the temporality of architectural modifications, including renovation, construction, and abandonment.\n",
    "\n",
    "This Jupyter Notebook is organized in two main sections. The first is a demonstration section that covers the main objects of the simulation as well as the yearly lifecourse of individuals and households. This uses toy data typical of the agent-based computational demography literature in which idealized lifecourses are used to represent the more complex demographics of empirically studied populations. The second part is a qualitative coherence assessment between empirically grounded demography of traditional Mediterranean populations and the architectural renovations, additions, and abandonments visible in the domestic architecture of the Early Iron Age (1200-700 BCE) Ierapetra Isthmus of Eastern Crete, Greece.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Importing the households package\n",
      "Importing identity\n",
      "importing kinship\n",
      "importing residency\n",
      "importing behavior\n",
      "loading narrative\n",
      "Importing main.py\n",
      "importing inheritance\n",
      "importing locality\n",
      "importing fragmentation\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "os.chdir('./code')\n",
    "from households import *\n",
    "import pandas\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## An Introduction to households: Sweetwater##\n",
    "\n",
    "I center our exploration of the households package on the town of Sweetwater in the world of WestWorld (1). Sweetwater is a `Community`, meaning that it contains a collection of both Persons and Houses as well as a combination of demographic and behavioral rules. Almost all Persons live in Houses (`Person.has_house`), and almost all Houses that are lived in have an owner (`House.has_owner`). Further, all Persons can potentially have a spouse (`Person.has_spouse`) and may also have a further family of children and other relatives who can be accessed through the `kinship` module, while their household can be accessed and assessed through the `residency` module. This enables the articulation of different types of relationships between `Persons`, giving a \"linked-lives\" component to the model that would provide a suitable social network for analyses beyond household demography.\n",
    "\n",
    "Beyond maintaining `Persons` and `Houses`, `Communities` define context- or event-specific rules (e.g. rules for where a newly married couple should live), time-specific rules (e.g. the probability an individual Person will give birth in a given year), and collections of objects (e.g. people). The community determines the birth and death rates of all Persons (`Community.birthtab`, `Community.mortab`) as well as the ages at which individuals become eligible for marriage (`Community.marrtab`). When individuals marry, the Community they live in defines in which house they will live (`Community.locality`); when individuals die, it determines how their property is divided (`Community.inheritance`); and when households grow in size or property changes hands, it determines whether the household splits (`Community.fragmentation`). At present, it is the Community of residence which determines the profile of an individual's lifecourse.\n",
    "\n",
    "In the case of Sweetwater, life is short because of a very high mortality rate caused by violence. We can define this through the `AgeTable` class, which flexibly defines the probability of events occuring based on an individual's age and sex (2). In the case of Sweetwater, we can simplify this by defining male mortality to be low until age 20, at which point it is about a constant rate of 7.5% a year because of the bloodthirsty visitors. Female mortality is similarly dismal, but doesn't pick up until age 25. \n",
    "\n",
    "```\n",
    "mortality = AgeTable(ages=[0,20,25,100],sex1 = male, rates1 = [0,.075,.075], sex2 = female, rates2 = [0,0,.075])\n",
    "```\n",
    "\n",
    "Eligibility for marriage is similarly defined. Here we assume that all Persons can become eligible for marriage at age 18, and have a 1/3 chance of become eligible in any given year. Spousal search is random across the entire community of eligible individuals of the other sex. (3)\n",
    "\n",
    "```\n",
    "eligibility = AgeTable(ages = [0,18,100], sex1 = female, rates1 = [0,.33], sex2 = male, rates2 = [0,.33])\n",
    "```\n",
    "\n",
    "The same data structure is also used for modelling birth rates, assuming that individuals are married and coresident (4). Birth rates are very low in Sweetwater, and here we assume a 10% yearly fertility rate, although women will rarely live to have the average expected number of children because of the high mortality rate.\n",
    "\n",
    "```\n",
    "fertility = AgeTable(ages = [0,15,44,100], sex1 = female, rates1 = [0,.1,0], sex2 = male, rates2 = [0,0,0])\n",
    "```\n",
    "\n",
    "Together, these AgeTables define the events that frame lifecourse of individuals. What AgeTables do not define is the resultant behaviors triggered by these lifecourse events.  These are defined by a subpackage, `behavior`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "mortality = AgeTable(ages=[0,20,25,100],sex1 = male, rates1 = [0,.075,.1], sex2 = female, rates2 = [0,0,.075])\n",
    "eligibility = AgeTable(ages = [0,18,100], sex1 = female, rates1 = [0,.33], sex2 = male, rates2 = [0,.33])\n",
    "fertility = AgeTable(ages = [0,15,44,100], sex1 = female, rates1 = [0,.1,0], sex2 = male, rates2 = [0,0,0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`behavior` articulates the rules Persons access when they live in a community and undergo a major life event, such as marriage, inheriting property, or dying. These include the location couples move to (`behavior.locality`), how property is distributed by inheritance (`behavior.inheritance`), and household fragmentation caused by internal conflicts or perception of external pressures (`behavior.fragmentation`). Inheritance is currently the most developed module, and the other modules will be brought in line with the new standards inheritance sets.\n",
    "\n",
    "### Inheritance ###\n",
    "When an agent dies, they follow the `Community.inheritance` rule. These rules must be a `behavior.inheritance.InheritanceRule`, which is a class defined to ensure that such rules are well-formatted. The most basic type of `InheritanceRule` constructs a rule in three steps:\n",
    "\n",
    "1. Check property qualifications (`InheritanceRule.has_property()`)\n",
    "\n",
    "   - This is to ensure that this individual even has property that can be inherited. Currently, inheritance only occurs for houses. `inheritance.has_property_houses` checks whether an individual owns at least one house; other forms of inheritance could involve multiple houses being inherited.\n",
    "\n",
    "\n",
    "2. If they have property, attempt to find an heir and assign the property to them. (`InheritanceRule.rule()`)\n",
    "\n",
    "   - This may fail if the individual who died has no heirs who are eligible to inherit. Otherwise, the property is transferred to an heir.\n",
    "\n",
    "\n",
    "3. If inheritance fails, then another option must be used. (`InheritanceRule.failure()`)\n",
    "\n",
    "   - This can include defaulting to collective ownership, no ownership, or random assignment. \n",
    "\n",
    "\n",
    "Together, these steps of a simple `InheritanceRule` provide a structure for the distribution of property after death. More complex inheritance behaviors can be articulated through the `InheritanceRuleComplex` subclass, which defines a modification that breaks apart the `rule()` into three substeps while retaining `.has_property()` and `.failure()` as the first and last steps:\n",
    "\n",
    "2. If they have property, attempt to find an heir and assign the property to them. (`InheritanceRule.rule()`)\n",
    "\n",
    "   a. Find heirs and return them in a ranked and grouped order (`InheritanceRuleComplex.find_heirs()`)\n",
    "\n",
    "      - This returns the full subset of potential heirs in ranked order, allowing some individuals to be given equal claims or  allowing partible inheritance.\n",
    "\n",
    "   b. Among the ranked and grouped heirs, exclude those who don't qualify. (`InheritanceRuleComplex.limit_heirs()`)\n",
    "    \n",
    "     - Heirs could be limited because of their marital status, property ownership, age, sex, or number of children, as well as more complex factors such as adoption.\n",
    "    \n",
    "   c. Distribute the propery among the heir or heirs. (`InheritanceRuleComplex.distribute_property()`)\n",
    "    \n",
    "     - One or more heirs are selected and the property or properties are distributed according to some pattern. This is also a place to enforce residency requirements, i.e. if inheritance depends on residigin in the inherited property.\n",
    "      \n",
    "Inheritance strategies can be fine tuned within this structure, allowing a wide range of flexible behaviors to be described and implemented by the household package. This flexible class structure can enable a researcher to define novel property transmission patterns, or even a new family of related inheritance behaviors by creating a new subclass similar to `InheritanceRuleComplex`. \n",
    "\n",
    "For the community of Sweetwater, we have no attested property transmission except for the vague implication that children of all sexes can inherit homesteads. A proposed `InheritanceRule` for Sweetwater could thus be defined as follows:\n",
    "\n",
    "```\n",
    "inherit_homestead = InheritanceRuleComplex(has_property = has_property_houses,\n",
    "                                           find_heirs = find_heirs_children_oldest_to_youngest,\n",
    "                                           limit_heirs = limit_heirs_none,\n",
    "                                           distribute_property = distribute_property_to_first_heir_and_move_household,\n",
    "                                           failure = failed_inheritance_no_owner)\n",
    "```\n",
    "\n",
    "This would define the property to be inherited as houses, order the deceased's children oldest to youngest, and give the property to the oldest living child. If there were no living children, the house defaults to having no owner. \n",
    "\n",
    "While such a class system is not yet implemented for locality and fragmentation, this is the current expansion of households that is under development (5). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "inherit_homestead = behavior.inheritance.InheritanceRuleComplex(has_property = behavior.inheritance.has_property_houses,\n",
    "                                                                    find_heirs = behavior.inheritance.find_heirs_children_oldest_to_youngest,\n",
    "                                                                    limit_heirs = behavior.inheritance.limit_heirs_none,\n",
    "                                                                    distribute_property = behavior.inheritance.distribute_property_to_first_heir_and_move_household,\n",
    "                                                                    failure = behavior.inheritance.failed_inheritance_no_owner)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Locality ###\n",
    "\n",
    "Locality is the only type of behavior explicitly modeled at present when a couple is married. The `Community.locality` rule determines which of the `behavior.locality` functions the couple will follow, such as patrilocality, matrilocality, or neolocality (6). These functions are predefined and are simply selected, with the exception of neolocality, which at present requires determing a sole owner of the new house.\n",
    "\n",
    "```\n",
    "locality = lambda husband, wife: neolocality(husband,wife,primary = female)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "locality = lambda husband, wife: behavior.locality.neolocality(husband,wife,primary = female)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Fragmentation ###\n",
    "\n",
    "Fragmentation is a more complex situational behavior which arises when a household as a coresidential group splits, normally due to social or economic conflict. An example would be the split between two coresidential brothers, one of whom inherits the homestead when a patriarch dies and the other is left without inheritance. This may encourage the disinherited brother to move himself and his family into a new, smaller house, potentially creating a new lineage as well as a new transmissible homestead for his own children.\n",
    "\n",
    "Fragmentation at present has only two options, `no_fragmentation` and `brother_loses_out`. The latter assumes that if the oldest of a set of brothers inherits the parents' house, the younger brothers above the age of majority feel the pressure to move out. This can be easily parametrized, assuming an age of majority of 18:\n",
    "\n",
    "```\n",
    "fragmentation = lambda house: brother_loses_out(house,age=18)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "fragmentation = lambda house: behavior.fragmentation.brother_loses_out(house,age=18)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Collectively the functions in the `behavior` subpackage provide the agents of the community with responses to major life events. While currently their behavior is uniform and only depending upon their having experienced these events, the current goal is to make the agents more agentive rather than simply part of a microsimulation as the package is developed. At present, the package provides sufficient flexibility to start modeling the dynamics of particular small-scale, homogeneous communities.\n",
    "\n",
    "The only parameters we have yet to specify is the characteristics of our starting population in the community of Sweetwater. This includes the number of `Houses`, the number of `Persons`, and the starting age of the population. The initial configuration of a new community is a floating population who lacks residency, and as such new houses are occupied as the population becomes eligible for marriage. To encourage this, the starting population is kept at a single age, defined to be around the period marriages would begin in the lifecourse. \n",
    "\n",
    "At present, houses only exist and cannot be built to or modified, so the best option is to provide more houses than are likely to be needed during the simulation.\n",
    "\n",
    "A potential starting population then may be 100 people and 200 houses, with a starting age of 17 (since our age of majority for  marriage is 18, as defined above). \n",
    "\n",
    "```\n",
    "start_pop = 100\n",
    "start_area = 200\n",
    "start_age = 17\n",
    "```\n",
    "\n",
    "All that is required to define the simulation is to combine these parameters into a single `Community` object, as well as provide it with a name.\n",
    "\n",
    "```\n",
    "sweetwater = Community(name = 'Sweetwater',\n",
    "                       pop = start_pop,\n",
    "                       area = start_area,\n",
    "                       startage = start_age,\n",
    "                       mortab = mortality,\n",
    "                       marrtab = eligibility,\n",
    "                       birthtab = fertility,\n",
    "                       locality = locality,\n",
    "                       inheritancerule = inherit_homestead,\n",
    "                       fragmentation = fragmentation)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "start_pop = 100\n",
    "start_area = 200\n",
    "start_age = 17\n",
    "\n",
    "rd.seed(1237) #Used here to standardize the example code across runs.\n",
    "sweetwater = Community(name = 'Sweetwater',\n",
    "                       pop = start_pop,\n",
    "                       area = start_area,\n",
    "                       startage = start_age,\n",
    "                       mortab = mortality,\n",
    "                       marrtab = eligibility,\n",
    "                       birthtab = fertility,\n",
    "                       locality = locality,\n",
    "                       inheritancerule = inherit_homestead,\n",
    "                       fragmentation = fragmentation)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### The Year ###\n",
    "\n",
    "The simulation of a `Community` is defined to progress on an annual timescale. During each year, the following events occur:\n",
    "\n",
    "1. The order of `Persons` in the `Community` is randomized.\n",
    "2. Consulting the `Community.mortab` `AgeTable`, some people die; these deaths trigger the defined `InheritanceRule`.\n",
    "3. Households may fragment, depending on these inheritances.\n",
    "4. Individuals who are eligible for marriage may marry each other; other individuals will become eligible.\n",
    "5. Women who are married may give birth.\n",
    "6. Statistics are calculated about the events of the year, and the year is progressed by one.\n",
    "\n",
    "We can now progress (`Community.progress`) our simulation five years to see what happens during the initial configuration and setup of Sweetwater."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "while sweetwater.year < 5:\n",
    "    sweetwater.progress()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using the `narrative` module, we can make individual households and people a bit easier to read than the abstract class objects of their underlying representation. Let's take a look at one of the recently married couples who now has a child:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This house contains a nuclear household with 3 people residing owned by Clementine:\n",
      "William is a living man, 22 years old, married with one child\n",
      "Clementine is a living woman, 22 years old, married with one child\n",
      "Maeve is a living woman, 2 years old, ineligible\n",
      " \n"
     ]
    }
   ],
   "source": [
    "h = [x for x in sweetwater.houses if len(x.people) >2][1] #2 at year 5 start\n",
    "print('This house contains ' + narrative.census(h)+':')\n",
    "for x in h.people:\n",
    "    print(narrative.biography(x)) \n",
    "print(' ')\n",
    "william, clementine, maeve = h.people"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this family, William and Clementine married, with Clementine giving birth to a baby girl Maeve two years prior. At present, they seem a model nuclear family. Let's progress a decade and check in on this household again."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This house contains a solitary household with 1 person residing owned by Maeve:\n",
      "Maeve is a living woman, 12 years old, ineligible\n",
      "Everyone else:\n",
      "William is a dead man, 24 years old, married with one child\n",
      "Clementine is a dead woman, 26 years old, widowed with one child\n",
      " \n"
     ]
    }
   ],
   "source": [
    "while sweetwater.year < 15:\n",
    "    sweetwater.progress()\n",
    "print('This house contains ' + narrative.census(h)+':')\n",
    "for x in h.people:\n",
    "    print(narrative.biography(x)) \n",
    "print('Everyone else:')\n",
    "for x in [william, clementine]:\n",
    "    print(narrative.biography(x)) \n",
    "print(' ')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As Sweetwater is effectively a more violent version of Oregon Trail, both parents have died of either gunshots or dysentery. William died first at age 24, followed shortly thereafter by Clementine at age 26. The minimal infant and child mortality rate means that Maeve will live until at least 25, and will likely marry between now and then. She will spend most of her childhood on her own, as no form of adoption was implemented for this community. Notably, however, she already owns the house, as there is also no age of majority requirement to inherit property. \n",
    "\n",
    "Let's now progress into the future when Maeve is 15 years older."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "This house contains a empty household with 0 people residing owned by Maeve:\n",
      "Maeve still owns this house, but lives elsewhere (neolocality after marriage!)\n",
      " \n",
      "This house contains a nuclear household with 3 people residing owned by Maeve:\n",
      "Robert is a living man, 26 years old, married with one child\n",
      "Maeve is a living woman, 27 years old, married with one child\n",
      "Emily is a living woman, 3 years old, ineligible\n",
      " \n",
      "Robert has 1 house(s)\n",
      "Maeve has 2 house(s)\n"
     ]
    }
   ],
   "source": [
    "while sweetwater.year < 30:\n",
    "    sweetwater.progress()\n",
    "print('This house contains ' + narrative.census(h)+':')\n",
    "print('Maeve still owns this house, but lives elsewhere (neolocality after marriage!)')\n",
    "print(' ')\n",
    "h = maeve.has_house\n",
    "robert = maeve.has_spouse\n",
    "print('This house contains ' + narrative.census(h)+':')\n",
    "for x in h.people:\n",
    "    print(narrative.biography(x)) \n",
    "print(' ')\n",
    "for x in [robert, maeve]:\n",
    "    print(x.name + ' has ' + str(sum([g.owner==x for g in sweetwater.houses])) + ' house(s)')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Maeve still owns her childhood home, but no longer lives in it. Following the community practice of neolocality, she now lives in a new home which she owns, along with her husband Robert and daughter Emily. Notably, Robert also inherited his childhood home before moving out when he married Maeve, and as such the family collectively controls 3 houses.\n",
    "\n",
    "From observing individual families in this manner, we may arrive at some larger truths. The current pattern of 1) neolocality followed by 2) single inheritance makes it impossible for property to be distributed, only to concentrate, leading to substantial inequalities in the number of houses each household controls. This can be seen clearly in aggregate by anbalyzing all households currently present in the simulation:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "number_owned = []\n",
    "for g in sweetwater.houses:\n",
    "    if g.people != []:\n",
    "        owned = 0\n",
    "        for x in g.people:\n",
    "            owned += sum([i.owner==x for i in sweetwater.houses])\n",
    "        number_owned.append(owned)\n",
    "plt.hist(number_owned,bins = [0,1,2,3,4,5,6])\n",
    "plt.xlabel('Houses owned')\n",
    "plt.ylabel('Number of households who own that many')\n",
    "plt.title('Concentration of property over the first 30 years')\n",
    "print('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Property is slowly concentrating into the hands of those who didn't die young. In the grand scheme of problems Sweetwater is facing, however, the larger looming threat is the population collapse occuring because of mismatched death and birth rates, as there are only 24 households left from a starting population of 100 individuals."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.plot(range(sweetwater.year+1),sweetwater.poplist,'k-')\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('Living population')\n",
    "plt.title('Where are we going to find more people to live in Sweetwater?')\n",
    "print('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The household package provides a micro-simulation or micro-history view of individual households as well as macroviews of larger phenomena within particular communities. To better demonstrate this, I now turn from the fictional world of WestWorld to the real wilderness of Eastern Crete at the end of the Aegean Bronze Age, around 1200 BCE."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Author's note: everything after this is in draft form and incomplete; some of the data analysis requires features not yet implemented in the published code. I strongly recommend NOT executing anything below until this note is removed. -AHFC, April 27th, 2020"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## East Crete and Iron Age Villages ##\n",
    "\n",
    "Following a catastrophic reconfiguration of society that arose from multiple simutaneous natural and social causes, the late Bronze Aegean was transformed from a networked world of palaces and cities to a string of globally isolated yet locally connected villages. These villages were founded by the survivors of those collapsed cities and have several uniform properties that make them interesting to study socially. \n",
    "\n",
    "Most of these villages appear to be founded at the end of the Late Minoan III B period (XXXX-XXXX BCE, traditional chronology). aerly small foundation, quicker than growth (or too fragmentary?) they expand.\n",
    "\n",
    "Agglomerative architecture with phases of rebuilding, appear to be related to the growth of nuclear families into extended household housing complexes, but also some evidence for later abandonment and shrinking\n",
    "\n",
    "social structure often thought to involve clans or lineages, reflected in religious beliefs, ties to the past, and the preservation of architecture rahter than expanding into new houses\n",
    "\n",
    "these communities move, agglomerate, and become new communities which take on urban characteristics (public space, formalized government/conflict resoluition.\n",
    "\n",
    "characteristics of these communities would then be described as: lineage structure (patrilocal/matrilocal), housing expands to accomodate nuclear family units within the lineage, fragmentation appears to be rare, inheritance appears to encourage collective occupancy\n",
    "\n",
    "### Architectural phasing ###\n",
    "\n",
    "Many of the generalizations highlighted above are based on the detailed phasing of wall construction in houses.\n",
    "\n",
    "how we detect these phases: architecture, features, stratigraphy, sometimes but rarely pottery\n",
    "\n",
    "number of phases per period something we can extract, plus rooms added or housing units added\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x432 with 4 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "phases = pandas.read_excel('../data/housephases.xlsx')\n",
    "lmiiic = phases.Period == 'LMIIIC'\n",
    "\n",
    "fig, ((a,b),(c,d)) = plt.subplots(2,2)\n",
    "fig.set_figheight(6)\n",
    "fig.set_figwidth(8)\n",
    "\n",
    "a.hist(phases.loc[lmiiic].PhasesCount,bins=range(8))\n",
    "a.set_title('Architectural phases in LMIIIC')\n",
    "\n",
    "b.hist(phases.loc[lmiiic].HousesEnd-phases.loc[lmiiic].HousesStart,bins=range(5))\n",
    "b.set_title('Housing units added in LMIIIC')\n",
    "\n",
    "c.hist(phases.loc[lmiiic].RoomsEnd-phases.loc[lmiiic].RoomsStart,bins=range(10))\n",
    "c.set_title('Rooms added in LMIIIC')\n",
    "\n",
    "d.axis('off')\n",
    "print('')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "like to run some community simulations that compare archaeological inferences with outcomes of the simulation as it stands\n",
    "\n",
    "* matrilocal vs neolocal\n",
    "* no fragmentation (it just seems improbable)\n",
    "* matrilineal inheritance vs ungendered \n",
    "\n",
    "some questions:\n",
    "temporalities of interest: # marriages, # births, # births of sons/daughters, #changes in ownership, # married couples per house, # people per house\n",
    "do phases correspond with # marriages? # births? # births of sons/daughters? do phases correspond with changes in ownership/inheritance? housing units with married couples? rooms with people?\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Define relevant inheritance rules for matrilineal vs ungendered primogeniture inheritance.\n",
    "\n",
    "\n",
    "#matrilineal_inheritance\n",
    "#indifferent_inheritance\n",
    "\n",
    "inheritances = []\n",
    "localities = [behavior.locality.matrilocality,lambda husband, wife: behavior.locality.neolocality(husband,wife,female)]\n",
    "fragmentation = behavior.fragmentation.no_fragmentation\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Footnotes ##\n",
    "\n",
    "(1) Following the practice that most Python packages have some underlying theme (going back to Monty Python in the tutorials), the naming conventions for many classes and functions in households are based on the HBO series of WestWorld. This example is no exception.\n",
    "\n",
    "This package tries to use \"has_\" nomenclature wherever possible, so that links from one object to another (e.g. from a Person to their spouse) uses the variable name \"has_spouse\", following from conventions in ontology creation.\n",
    "\n",
    "Following Python nomenclature, classes are reffered to capitalized, such that a reference to a Person refers to the class that defines how individual people are represented and behave, while a reference to a person refers to an individual human being. \n",
    "\n",
    "(2) Future extensions will include alternative definitions of AgeTables. Sex is currently modeled as a binary variable, which is inaccurate and could be profitably changed in the future depending on the goal of the simulation.\n",
    "\n",
    "(3) This will become a parameter (spousal_search) in the future, similar to the other modules of the behavior package.\n",
    "\n",
    "(4) Future extensions will include the possibility of birth out of wedlock, as well as alternative household and family structures such as polyandry, polygamy, and non-co-residential spouses.\n",
    "\n",
    "(5) The other expansion is more behavior modules, including behaviors triggered by marriage beyond locality, birth of first and subsequent children, and events triggered by the loss of children or spouses. Eventually, the goal is for the behavior subpackage to provide flexible ways of exploring different cultural norms and behavioral strategies that occur at the major moments of an individual's lifecourse.\n",
    "\n",
    "(6) A next step is to enable a class system that will allow these to be prioritized, selected among stochastically, or variants such as settling in the wife's community but occupying a new house."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3602\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\cabaniss\\Anaconda3\\lib\\site-packages\\IPython\\nbformat.py:13: ShimWarning: The `IPython.nbformat` package has been deprecated since IPython 4.0. You should import from nbformat instead.\n",
      "  \"You should import from nbformat instead.\", ShimWarning)\n",
      "C:\\Users\\cabaniss\\Anaconda3\\lib\\site-packages\\nbformat\\current.py:19: UserWarning: nbformat.current is deprecated.\n",
      "\n",
      "- use nbformat for read/write/validate public API\n",
      "- use nbformat.vX directly to composing notebooks of a particular version\n",
      "\n",
      "  \"\"\")\n"
     ]
    }
   ],
   "source": [
    "#Word count for personal tracking/page equivalents\n",
    "## imported from https://gist.github.com/agounaris/5da16c233ce480e75ab95980831f459e\n",
    "## credit to [agounaris](https://gist.github.com/agounaris)\n",
    "import io\n",
    "from IPython.nbformat import current\n",
    "\n",
    "with io.open('../DEMO.ipynb', 'r', encoding='utf-8') as f:\n",
    "    nb = current.read(f, 'json')\n",
    "\n",
    "word_count = 0\n",
    "for cell in nb.worksheets[0].cells:\n",
    "    if cell.cell_type == \"markdown\":\n",
    "        word_count += len(cell['source'].replace('#', '').lstrip().split(' '))\n",
    "print(word_count)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Debugging inheritance classes\n",
    "#behavior.inheritance.has_property_houses(clementine)\n",
    "#behavior.inheritance.find_heirs_children_oldest_to_youngest(clementine) == [maeve]\n",
    "#behavior.inheritance.limit_heirs_none([maeve]) == [maeve]\n",
    "#behavior.inheritance.distribute_property_to_first_heir_and_move_household(clementine, [maeve])\n",
    "#failure = behavior.inheritance.failed_inheritance_no_owner)\n",
    "#clementine.has_community.inheritance._InheritanceRuleComplex__distribute_property(clementine,[maeve]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "#More testing for inheritance\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}