Example System - Farnsworth Reduced.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Analysis of Reduced System"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\r",
      "Computing concepts:   0%|          | 0/7 [00:00<?, ?it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Network =  NodeLabels(('R', 'C', 'P'))\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PyPhi Value =  0.25\n",
      "\tNumber of Non-unique Constellations = 3\n",
      "\n",
      "Evaluating Cut  Cut [R] ━━/ /━━➤ [C, P]\n",
      "\tNumber of Non-unique Constellations = 1\n",
      "\n",
      "Evaluating Cut  Cut [C] ━━/ /━━➤ [R, P]\n",
      "\tNumber of Non-unique Constellations = 1\n",
      "\n",
      "Evaluating Cut  Cut [R, C] ━━/ /━━➤ [P]\n",
      "\tNumber of Non-unique Constellations = 1\n",
      "\n",
      "Evaluating Cut  Cut [P] ━━/ /━━➤ [R, C]\n",
      "\tNumber of Non-unique Constellations = 1\n",
      "\n",
      "Evaluating Cut  Cut [R, P] ━━/ /━━➤ [C]\n",
      "\tNumber of Non-unique Constellations = 1\n",
      "\n",
      "Evaluating Cut  Cut [C, P] ━━/ /━━➤ [R]\n",
      "\tNumber of Non-unique Constellations = 3\n",
      "\n",
      "Cuts =  [Cut [R] ━━/ /━━➤ [C, P], Cut [C] ━━/ /━━➤ [R, P], Cut [R, C] ━━/ /━━➤ [P], Cut [P] ━━/ /━━➤ [R, C], Cut [R, P] ━━/ /━━➤ [C], Cut [C, P] ━━/ /━━➤ [R]]\n",
      "\n",
      "Phi Spectrum =  [[0.25], [0.75], [0.75], [1.0], [1.0], [0.5]]\n"
     ]
    }
   ],
   "source": [
    "import pyphi\n",
    "import numpy as np\n",
    "from pyphi import phi_spectrum\n",
    "\n",
    "# Transition probability matrix used in Farnsworth\n",
    "## Available as part of supplementary material: \n",
    "## https://www.sciencedirect.com/science/article/pii/S0303264720301969\n",
    "\n",
    "tpm = np.array([\n",
    "    [0.,0.,0.],\n",
    "    [0.,0.,0.],\n",
    "    [1.,0.,0.],\n",
    "    [1.,0.,1.],\n",
    "    [0.,1.,0.],\n",
    "    [0.,1.,0.],\n",
    "    [1.,1.,0.],\n",
    "    [1.,1.,1.]\n",
    "])\n",
    "\n",
    "# Connectivity matrix for nodes (A,B,C)\n",
    "# cm = np.array([\n",
    "#     [0,1,1],\n",
    "#     [1,0,1],\n",
    "#     [1,1,0]\n",
    "# ])\n",
    "\n",
    "# Set up network object\n",
    "network = pyphi.Network(tpm, node_labels=['R','C','P'])\n",
    "print(\"Network = \",network.node_labels)\n",
    "\n",
    "# Put the system into a given state\n",
    "state = (1,1,1)\n",
    "nodes = ['R','C','P']\n",
    "\n",
    "## Get the requisite Subsystem\n",
    "subsystem = pyphi.Subsystem(network, state, nodes)\n",
    "\n",
    "## What does PyPhi Give? Should be 0.125\n",
    "pyphi_val = pyphi.compute.phi(subsystem)\n",
    "print(\"PyPhi Value = \",pyphi_val)\n",
    "\n",
    "## Calculate all Phi values\n",
    "display_CES= False  # if True, output will display constellations\n",
    "Phi_Spectrum = phi_spectrum.get_phi_spectrum(subsystem,display_CES)\n",
    "\n",
    "print(\"\\nCuts = \",Phi_Spectrum[0])\n",
    "print(\"\\nPhi Spectrum = \",Phi_Spectrum[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Phi MIP =  [0.25]\n",
      "1\n",
      "Results Saved\n"
     ]
    }
   ],
   "source": [
    "Phi_MIP = phi_spectrum.get_Phi_MIP(Phi_Spectrum)\n",
    "print(\"Phi MIP = \",Phi_MIP)\n",
    "print(len(Phi_MIP))\n",
    "# np.savetxt(\"KO17/results/phi_spectrum_farnsworth_reduced.csv\", Phi_MIP, delimiter=\",\")\n",
    "# print(\"Results Saved\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Now get all the different cause/effect repetoires"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 0. 0. 0.]\n",
      "Repertoire irreducibility analysis\n",
      "  φ = 1/4\n",
      "  Mechanism: [C]\n",
      "  Purview = [R, P]\n",
      "  Direction: EFFECT\n",
      "  Partition:\n",
      "     ∅     C \n",
      "    ─── ✕ ───\n",
      "     P     R \n",
      "  Repertoire:\n",
      "    ┌──────────────┐\n",
      "    │ S     Pr(S)  │\n",
      "    │ ╴╴╴╴╴╴╴╴╴╴╴╴ │\n",
      "    │ 00    1      │\n",
      "    │ 10    0      │\n",
      "    │ 01    0      │\n",
      "    │ 11    0      │\n",
      "    └──────────────┘\n",
      "  Partitioned repertoire:\n",
      "    ┌──────────────┐\n",
      "    │ S     Pr(S)  │\n",
      "    │ ╴╴╴╴╴╴╴╴╴╴╴╴ │\n",
      "    │ 00    3/4    │\n",
      "    │ 10    0      │\n",
      "    │ 01    1/4    │\n",
      "    │ 11    0      │\n",
      "    └──────────────┘\n"
     ]
    }
   ],
   "source": [
    "# network = pyphi.Network(tpm, cm, node_labels=['R','C','P'])\n",
    "\n",
    "# Put the system into a given state\n",
    "state = (0,0,0)\n",
    "nodes = ['R','C','P']\n",
    "subsystem = pyphi.Subsystem(network, state, nodes)\n",
    "\n",
    "# Get the cause repetoire for the mechanism over the purview\n",
    "R,C,P = subsystem.node_indices\n",
    "# print(subsystem.state)\n",
    "mechanism = (C,)\n",
    "purview = (R,P)\n",
    "cr = subsystem.effect_repertoire(mechanism,purview)\n",
    "flat_cr = pyphi.distribution.flatten(cr)  # returns 1d array in little endian convention\n",
    "print(flat_cr)\n",
    "\n",
    "mip = subsystem.effect_mip(mechanism,purview)\n",
    "print(mip)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Now do the same for the unidirectional cut R -//->CP"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1. 0. 0. 0.]\n",
      "Repertoire irreducibility analysis\n",
      "  φ = 1/4\n",
      "  Mechanism: [C]\n",
      "  Purview = [R, P]\n",
      "  Direction: EFFECT\n",
      "  Partition:\n",
      "     ∅     C \n",
      "    ─── ✕ ───\n",
      "     P     R \n",
      "  Repertoire:\n",
      "    ┌──────────────┐\n",
      "    │ S     Pr(S)  │\n",
      "    │ ╴╴╴╴╴╴╴╴╴╴╴╴ │\n",
      "    │ 00    1      │\n",
      "    │ 10    0      │\n",
      "    │ 01    0      │\n",
      "    │ 11    0      │\n",
      "    └──────────────┘\n",
      "  Partitioned repertoire:\n",
      "    ┌──────────────┐\n",
      "    │ S     Pr(S)  │\n",
      "    │ ╴╴╴╴╴╴╴╴╴╴╴╴ │\n",
      "    │ 00    3/4    │\n",
      "    │ 10    0      │\n",
      "    │ 01    1/4    │\n",
      "    │ 11    0      │\n",
      "    └──────────────┘\n"
     ]
    }
   ],
   "source": [
    "import pyphi\n",
    "import numpy as np\n",
    "\n",
    "# Transition probability matrix. Saying where each state (little-endian binary) goes\n",
    "tpm = np.array([\n",
    "    [1.,0.,0.,0.,0.,0.,0.,0.],\n",
    "    [1.,0.,0.,0.,0.,0.,0.,0.],\n",
    "    [0.,1/2.,0.,0.,0.,1/2.,0.,0.],\n",
    "    [0.,1/2.,0.,0.,0.,1/2.,0.,0.],\n",
    "    [0.,0.,1.,0.,0.,0.,0.,0.],\n",
    "    [0.,0.,1.,0.,0.,0.,0.,0.],\n",
    "    [0.,0,0.,1/2.,0.,0.,0.,1/2.],\n",
    "    [0.,0,0.,1/2.,0.,0.,0.,1/2.],\n",
    "])\n",
    "\n",
    "# Set up network object\n",
    "# network = pyphi.Network(tpm, cm=cm, node_labels=['A','B','C'])\n",
    "network = pyphi.Network(tpm, node_labels=['R','C','P'])\n",
    "\n",
    "# Put the system into a given state\n",
    "state = (0,0,0)\n",
    "nodes = ['R','C','P']\n",
    "subsystem = pyphi.Subsystem(network, state, nodes)\n",
    "\n",
    "# Get the cause repetoire for the mechanism over the purview\n",
    "R,C,P = subsystem.node_indices\n",
    "# print(subsystem.state)\n",
    "mechanism = (C,)\n",
    "purview = (R,P)\n",
    "cr = subsystem.effect_repertoire(mechanism,purview)\n",
    "flat_cr = pyphi.distribution.flatten(cr)  # returns 1d array in little endian convention\n",
    "print(flat_cr)\n",
    "\n",
    "mip = subsystem.effect_mip(mechanism,purview)\n",
    "print(mip)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n",
      "           Concept: Mechanism = [C], φ = 1/2            \n",
      "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n",
      "            MIC                         MIE             \n",
      "┌──────────────────────────┐┌──────────────────────────┐\n",
      "│  φ = 1/2                 ││  φ = 1/2                 │\n",
      "│  Purview = [P]           ││  Purview = [R]           │\n",
      "│  MIP:                    ││  MIP:                    │\n",
      "│     ∅     C              ││     ∅     C              │\n",
      "│    ─── ✕ ───             ││    ─── ✕ ───             │\n",
      "│     P     ∅              ││     R     ∅              │\n",
      "│  Repertoire:             ││  Repertoire:             │\n",
      "│    ┌─────────────┐       ││    ┌─────────────┐       │\n",
      "│    │ S    Pr(S)  │       ││    │ S    Pr(S)  │       │\n",
      "│    │ ╴╴╴╴╴╴╴╴╴╴╴ │       ││    │ ╴╴╴╴╴╴╴╴╴╴╴ │       │\n",
      "│    │ 0    1      │       ││    │ 0    1      │       │\n",
      "│    │ 1    0      │       ││    │ 1    0      │       │\n",
      "│    └─────────────┘       ││    └─────────────┘       │\n",
      "│  Partitioned repertoire: ││  Partitioned repertoire: │\n",
      "│    ┌─────────────┐       ││    ┌─────────────┐       │\n",
      "│    │ S    Pr(S)  │       ││    │ S    Pr(S)  │       │\n",
      "│    │ ╴╴╴╴╴╴╴╴╴╴╴ │       ││    │ ╴╴╴╴╴╴╴╴╴╴╴ │       │\n",
      "│    │ 0    1/2    │       ││    │ 0    1/2    │       │\n",
      "│    │ 1    1/2    │       ││    │ 1    1/2    │       │\n",
      "│    └─────────────┘       ││    └─────────────┘       │\n",
      "└──────────────────────────┘└──────────────────────────┘\n",
      "], [━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n",
      "           Concept: Mechanism = [P], φ = 1/6            \n",
      "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n",
      "            MIC                         MIE             \n",
      "┌──────────────────────────┐┌──────────────────────────┐\n",
      "│  φ = 1/6                 ││  φ = 1/2                 │\n",
      "│  Purview = [C]           ││  Purview = [C]           │\n",
      "│  MIP:                    ││  MIP:                    │\n",
      "│     ∅     P              ││     ∅     P              │\n",
      "│    ─── ✕ ───             ││    ─── ✕ ───             │\n",
      "│     C     ∅              ││     C     ∅              │\n",
      "│  Repertoire:             ││  Repertoire:             │\n",
      "│    ┌─────────────┐       ││    ┌─────────────┐       │\n",
      "│    │ S    Pr(S)  │       ││    │ S    Pr(S)  │       │\n",
      "│    │ ╴╴╴╴╴╴╴╴╴╴╴ │       ││    │ ╴╴╴╴╴╴╴╴╴╴╴ │       │\n",
      "│    │ 0    2/3    │       ││    │ 0    1      │       │\n",
      "│    │ 1    1/3    │       ││    │ 1    0      │       │\n",
      "│    └─────────────┘       ││    └─────────────┘       │\n",
      "│  Partitioned repertoire: ││  Partitioned repertoire: │\n",
      "│    ┌─────────────┐       ││    ┌─────────────┐       │\n",
      "│    │ S    Pr(S)  │       ││    │ S    Pr(S)  │       │\n",
      "│    │ ╴╴╴╴╴╴╴╴╴╴╴ │       ││    │ ╴╴╴╴╴╴╴╴╴╴╴ │       │\n",
      "│    │ 0    1/2    │       ││    │ 0    1/2    │       │\n",
      "│    │ 1    1/2    │       ││    │ 1    1/2    │       │\n",
      "│    └─────────────┘       ││    └─────────────┘       │\n",
      "└──────────────────────────┘└──────────────────────────┘\n",
      "]]\n",
      "Possible CES:\n",
      "════════════════════════════════════════════════════════════\n",
      "            Cause-effect structure (2 concepts)             \n",
      "════════════════════════════════════════════════════════════\n",
      "  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  \n",
      "             Concept: Mechanism = [C], φ = 1/2              \n",
      "  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  \n",
      "              MIC                         MIE               \n",
      "  ┌──────────────────────────┐┌──────────────────────────┐  \n",
      "  │  φ = 1/2                 ││  φ = 1/2                 │  \n",
      "  │  Purview = [P]           ││  Purview = [R]           │  \n",
      "  │  MIP:                    ││  MIP:                    │  \n",
      "  │     ∅     C              ││     ∅     C              │  \n",
      "  │    ─── ✕ ───             ││    ─── ✕ ───             │  \n",
      "  │     P     ∅              ││     R     ∅              │  \n",
      "  │  Repertoire:             ││  Repertoire:             │  \n",
      "  │    ┌─────────────┐       ││    ┌─────────────┐       │  \n",
      "  │    │ S    Pr(S)  │       ││    │ S    Pr(S)  │       │  \n",
      "  │    │ ╴╴╴╴╴╴╴╴╴╴╴ │       ││    │ ╴╴╴╴╴╴╴╴╴╴╴ │       │  \n",
      "  │    │ 0    1      │       ││    │ 0    1      │       │  \n",
      "  │    │ 1    0      │       ││    │ 1    0      │       │  \n",
      "  │    └─────────────┘       ││    └─────────────┘       │  \n",
      "  │  Partitioned repertoire: ││  Partitioned repertoire: │  \n",
      "  │    ┌─────────────┐       ││    ┌─────────────┐       │  \n",
      "  │    │ S    Pr(S)  │       ││    │ S    Pr(S)  │       │  \n",
      "  │    │ ╴╴╴╴╴╴╴╴╴╴╴ │       ││    │ ╴╴╴╴╴╴╴╴╴╴╴ │       │  \n",
      "  │    │ 0    1/2    │       ││    │ 0    1/2    │       │  \n",
      "  │    │ 1    1/2    │       ││    │ 1    1/2    │       │  \n",
      "  │    └─────────────┘       ││    └─────────────┘       │  \n",
      "  └──────────────────────────┘└──────────────────────────┘  \n",
      "    \n",
      "  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  \n",
      "             Concept: Mechanism = [P], φ = 1/6              \n",
      "  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  \n",
      "              MIC                         MIE               \n",
      "  ┌──────────────────────────┐┌──────────────────────────┐  \n",
      "  │  φ = 1/6                 ││  φ = 1/2                 │  \n",
      "  │  Purview = [C]           ││  Purview = [C]           │  \n",
      "  │  MIP:                    ││  MIP:                    │  \n",
      "  │     ∅     P              ││     ∅     P              │  \n",
      "  │    ─── ✕ ───             ││    ─── ✕ ───             │  \n",
      "  │     C     ∅              ││     C     ∅              │  \n",
      "  │  Repertoire:             ││  Repertoire:             │  \n",
      "  │    ┌─────────────┐       ││    ┌─────────────┐       │  \n",
      "  │    │ S    Pr(S)  │       ││    │ S    Pr(S)  │       │  \n",
      "  │    │ ╴╴╴╴╴╴╴╴╴╴╴ │       ││    │ ╴╴╴╴╴╴╴╴╴╴╴ │       │  \n",
      "  │    │ 0    2/3    │       ││    │ 0    1      │       │  \n",
      "  │    │ 1    1/3    │       ││    │ 1    0      │       │  \n",
      "  │    └─────────────┘       ││    └─────────────┘       │  \n",
      "  │  Partitioned repertoire: ││  Partitioned repertoire: │  \n",
      "  │    ┌─────────────┐       ││    ┌─────────────┐       │  \n",
      "  │    │ S    Pr(S)  │       ││    │ S    Pr(S)  │       │  \n",
      "  │    │ ╴╴╴╴╴╴╴╴╴╴╴ │       ││    │ ╴╴╴╴╴╴╴╴╴╴╴ │       │  \n",
      "  │    │ 0    1/2    │       ││    │ 0    1/2    │       │  \n",
      "  │    │ 1    1/2    │       ││    │ 1    1/2    │       │  \n",
      "  │    └─────────────┘       ││    └─────────────┘       │  \n",
      "  └──────────────────────────┘└──────────────────────────┘  \n",
      "    \n",
      "\n"
     ]
    }
   ],
   "source": [
    "import pyphi\n",
    "import numpy as np\n",
    "import itertools\n",
    "from pyphi import Direction\n",
    "from pyphi import utils\n",
    "from pyphi import cache\n",
    "from pyphi import models\n",
    "\n",
    "# Transition probability matrix. Saying where each state (little-endian binary) goes\n",
    "tpm = np.array([\n",
    "    [1.,0.,0.,0.,0.,0.,0.,0.],\n",
    "    [1.,0.,0.,0.,0.,0.,0.,0.],\n",
    "    [0.,1/2.,0.,0.,0.,1/2.,0.,0.],\n",
    "    [0.,1/2.,0.,0.,0.,1/2.,0.,0.],\n",
    "    [0.,0.,1.,0.,0.,0.,0.,0.],\n",
    "    [0.,0.,1.,0.,0.,0.,0.,0.],\n",
    "    [0.,0,0.,1/2.,0.,0.,0.,1/2.],\n",
    "    [0.,0,0.,1/2.,0.,0.,0.,1/2.],\n",
    "])\n",
    "\n",
    "# Set up network object\n",
    "# network = pyphi.Network(tpm, cm=cm, node_labels=['A','B','C'])\n",
    "network = pyphi.Network(tpm, node_labels=['R','C','P'])\n",
    "\n",
    "# Put the system into a given state\n",
    "state = (0,0,0)\n",
    "nodes = ['R','C','P']\n",
    "subsystem = pyphi.Subsystem(network, state, nodes)\n",
    "\n",
    "## Find all concepts for the specified subsystem\n",
    "all_concepts = []\n",
    "mechanisms = utils.powerset(subsystem.node_indices, nonempty=True)\n",
    "for mechanism in mechanisms:\n",
    "#     print(\"MECHANISM = \",mechanism)\n",
    "    mechanism_concepts = []\n",
    "    \n",
    "    # Find the CORE cause(s) for a given mechanism\n",
    "    direction = Direction.CAUSE\n",
    "    past_purviews = subsystem.potential_purviews(direction, mechanism, purviews=False)\n",
    "    all_causes = [subsystem.find_mip(direction, mechanism, purview) for purview in past_purviews]\n",
    "\n",
    "\n",
    "    core_cause = max(all_causes)\n",
    "    \n",
    "#     print(core_cause)\n",
    "    \n",
    "    \n",
    "    if core_cause.phi > 0.:\n",
    "        all_core_causes = [value for index,value in enumerate(subsystem.find_mip(direction, mechanism, purview) for purview in past_purviews) if value.phi == core_cause.phi]\n",
    "    else:\n",
    "        all_core_causes = [core_cause]\n",
    "            \n",
    "#     print(\"Core Cause(s) for Mechanism : \",all_core_causes)\n",
    "    \n",
    "    # Find the CORE effect(s) for a given mechanism\n",
    "    direction = Direction.EFFECT\n",
    "    future_purviews = subsystem.potential_purviews(direction, mechanism, purviews=False)\n",
    "    all_effects = [subsystem.find_mip(direction, mechanism, purview) for purview in future_purviews]\n",
    "\n",
    "\n",
    "    core_effect = max(all_effects)\n",
    "    \n",
    "#     print(core_effect)\n",
    "    \n",
    "    \n",
    "    if core_effect.phi > 0.:\n",
    "        all_core_effects = [value for index,value in enumerate(subsystem.find_mip(direction, mechanism, purview) for purview in past_purviews) if value.phi == core_effect.phi]\n",
    "    else:\n",
    "        all_core_effects = [core_effect]\n",
    "            \n",
    "#     print(\"Core Effects(s) for Mechanism : \",all_core_effects)\n",
    "\n",
    "    ## Now we need to build concepts for all possible core cause and core effect combinations\n",
    "    for each_cause in all_core_causes:\n",
    "        MIC = models.MaximallyIrreducibleCause(each_cause)\n",
    "        for each_effect in all_core_effects:\n",
    "            MIE = models.MaximallyIrreducibleEffect(each_effect)\n",
    "            \n",
    "            concept = models.Concept(mechanism = mechanism, cause = MIC, effect = MIE, subsystem = subsystem)            \n",
    "                            \n",
    "            ## If phi^max > 0 store the concept\n",
    "            if concept.phi > 0.:\n",
    "                mechanism_concepts.append(concept)\n",
    "            \n",
    "    if mechanism_concepts:\n",
    "        all_concepts.append(mechanism_concepts)\n",
    "        \n",
    "print(all_concepts)\n",
    "        \n",
    "\n",
    "# Create all possible CES via the cartesian product of all possible concepts for each mechanism\n",
    "original_CES = []\n",
    "for element in itertools.product(*all_concepts):\n",
    "    original_CES.append(models.CauseEffectStructure(concepts=element))\n",
    "    \n",
    "for CES in original_CES:\n",
    "    print(\"Possible CES:\")\n",
    "    print(CES)"
   ]
  },
  {
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}