TestNoLoop.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "93f97c91",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pm4py\n",
    "from pm4py.objects.process_tree import semantics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4f9830b7",
   "metadata": {},
   "source": [
    "## Generate PT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "c4b460eb",
   "metadata": {},
   "outputs": [],
   "source": [
    "'''\n",
    "    This file is part of PM4Py (More Info: https://pm4py.fit.fraunhofer.de).\n",
    "\n",
    "    PM4Py is free software: you can redistribute it and/or modify\n",
    "    it under the terms of the GNU General Public License as published by\n",
    "    the Free Software Foundation, either version 3 of the License, or\n",
    "    (at your option) any later version.\n",
    "\n",
    "    PM4Py is distributed in the hope that it will be useful,\n",
    "    but WITHOUT ANY WARRANTY; without even the implied warranty of\n",
    "    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\n",
    "    GNU General Public License for more details.\n",
    "\n",
    "    You should have received a copy of the GNU General Public License\n",
    "    along with PM4Py.  If not, see <https://www.gnu.org/licenses/>.\n",
    "'''\n",
    "from pm4py.objects.process_tree import obj\n",
    "from pm4py.objects.process_tree import obj as pt_operator\n",
    "from scipy.stats import triang as triangular\n",
    "import string\n",
    "import math\n",
    "import itertools\n",
    "from enum import Enum\n",
    "from itertools import accumulate as _accumulate, repeat as _repeat\n",
    "from bisect import bisect as _bisect\n",
    "import random\n",
    "\n",
    "\n",
    "def choices(population, weights=None, *, cum_weights=None, k=1):\n",
    "    \"\"\"Return a k sized list of population elements chosen with replacement.\n",
    "    If the relative weights or cumulative weights are not specified,\n",
    "    the selections are made with equal probability.\n",
    "    \"\"\"\n",
    "    n = len(population)\n",
    "    if cum_weights is None:\n",
    "        if weights is None:\n",
    "            _int = int\n",
    "            n += 0.0    # convert to float for a small speed improvement\n",
    "            return [population[_int(random.random() * n)] for i in _repeat(None, k)]\n",
    "        cum_weights = list(_accumulate(weights))\n",
    "    elif weights is not None:\n",
    "        raise TypeError('Cannot specify both weights and cumulative weights')\n",
    "    if len(cum_weights) != n:\n",
    "        raise ValueError('The number of weights does not match the population')\n",
    "    bisect = _bisect\n",
    "    total = cum_weights[-1] + 0.0   # convert to float\n",
    "    hi = n - 1\n",
    "    return [population[bisect(cum_weights, random.random() * total, 0, hi)]\n",
    "            for i in _repeat(None, k)]\n",
    "\n",
    "\n",
    "\n",
    "class Parameters(Enum):\n",
    "    SEQUENCE = \"sequence\"\n",
    "    CHOICE = \"choice\"\n",
    "    PARALLEL = \"parallel\"\n",
    "    OR = \"or\"\n",
    "    MODE = \"mode\"\n",
    "    MIN = \"min\"\n",
    "    MAX = \"max\"\n",
    "    SILENT = \"silent\"\n",
    "    DUPLICATE = \"duplicate\"\n",
    "    LT_DEPENDENCY = \"lt_dependency\"\n",
    "    INFREQUENT = \"infrequent\"\n",
    "    NO_MODELS = \"no_models\"\n",
    "    UNFOLD = \"unfold\"\n",
    "    MAX_REPEAT = \"max_repeat\"\n",
    "\n",
    "\n",
    "\n",
    "def apply(parameters=None):\n",
    "    \"\"\"\n",
    "    Generate a process tree using the PTAndLogGenerator approach\n",
    "    (see the paper PTandLogGenerator: A Generator for Artificial Event Data)\n",
    "\n",
    "    Parameters\n",
    "    --------------\n",
    "    parameters\n",
    "        Parameters of the algorithm, according to the paper:\n",
    "        - Parameters.MODE: most frequent number of visible activities\n",
    "        - Parameters.MIN: minimum number of visible activities\n",
    "        - Parameters.MAX: maximum number of visible activities\n",
    "        - Parameters.SEQUENCE: probability to add a sequence operator to tree\n",
    "        - Parameters.CHOICE: probability to add a choice operator to tree\n",
    "        - Parameters.PARALLEL: probability to add a parallel operator to tree\n",
    "        - Parameters.LOOP: probability to add a loop operator to tree\n",
    "        - Parameters.OR: probability to add an or operator to tree\n",
    "        - Parameters.SILENT: probability to add silent activity to a choice or loop operator\n",
    "        - Parameters.DUPLICATE: probability to duplicate an activity label\n",
    "        - Parameters.LT_DEPENDENCY: probability to add a random dependency to the tree\n",
    "        - Parameters.INFREQUENT: probability to make a choice have infrequent paths\n",
    "        - Parameters.NO_MODELS: number of trees to generate from model population\n",
    "        - Parameters.UNFOLD: whether or not to unfold loops in order to include choices underneath in dependencies: 0=False, 1=True\n",
    "            if lt_dependency <= 0: this should always be 0 (False)\n",
    "            if lt_dependency > 0: this can be 1 or 0 (True or False)\n",
    "        - Parameters.MAX_REPEAT: maximum number of repetitions of a loop (only used when unfolding is True)\n",
    "    \"\"\"\n",
    "    if parameters is None:\n",
    "        parameters = {}\n",
    "\n",
    "    if not \"mode\" in parameters:\n",
    "        parameters[\"mode\"] = 30\n",
    "    if not \"min\" in parameters:\n",
    "        parameters[\"min\"] = 30\n",
    "    if not \"max\" in parameters:\n",
    "        parameters[\"max\"] = 50\n",
    "    if not \"sequence\" in parameters:\n",
    "        parameters[\"sequence\"] = 0.25\n",
    "    if not \"choice\" in parameters:\n",
    "        parameters[\"choice\"] = 0.25\n",
    "    if not \"parallel\" in parameters:\n",
    "        parameters[\"parallel\"] = 0.25\n",
    "    if not \"or\" in parameters:\n",
    "        parameters[\"or\"] = 0.25\n",
    "    if not \"silent\" in parameters:\n",
    "        parameters[\"silent\"] = 0\n",
    "    if not \"duplicate\" in parameters:\n",
    "        parameters[\"duplicate\"] = 0\n",
    "    if not \"lt_depencency\" in parameters:\n",
    "        parameters[\"lt_depencency\"] = 0.0\n",
    "    if not \"infrequent\" in parameters:\n",
    "        parameters[\"infrequent\"] = 0.5\n",
    "    if not \"no_models\" in parameters:\n",
    "        parameters[\"no_models\"] = 10\n",
    "    if not \"unfold\" in parameters:\n",
    "        parameters[\"unfold\"] = 10\n",
    "    if not \"max_repeat\" in parameters:\n",
    "        parameters[\"max_repeat\"] = 10\n",
    "\n",
    "    return GeneratedTree(parameters).generate()\n",
    "\n",
    "def assign_operator(operator):\n",
    "    if operator == \"choice\":\n",
    "        return pt_operator.Operator.XOR\n",
    "    elif operator == \"sequence\":\n",
    "        return pt_operator.Operator.SEQUENCE\n",
    "    elif operator == \"parallel\":\n",
    "        return pt_operator.Operator.PARALLEL\n",
    "    elif operator == \"or\":\n",
    "        return pt_operator.Operator.OR\n",
    "    else:\n",
    "        return None\n",
    "\n",
    "\n",
    "\n",
    "class GeneratedTree(object):\n",
    "    # are later used as labels\n",
    "    alphabet = string.ascii_lowercase\n",
    "\n",
    "    def calculate_activity_distribution(self, mode, min, max):\n",
    "        \"\"\"\n",
    "        Here, the triangular function is used, since the parameters for this function are given in the paramterfile.\n",
    "        However, this approach can be applied on other distribution functions as well.\n",
    "        :param mode: Mode of the distribution\n",
    "        :param min: Smallest number\n",
    "        :param max: Highest number\n",
    "        :return: Distribution object\n",
    "        \"\"\"\n",
    "        c = (mode - min) / (max - min)\n",
    "        return triangular(c, loc=min, scale=max - min)\n",
    "\n",
    "\n",
    "    def draw_random_number_from_distribution(self):\n",
    "        return self.activity_distribution.rvs(1)[0]\n",
    "\n",
    "\n",
    "    def select_operator(self):\n",
    "        # add root operator, if probabilities are high enough\n",
    "        # ordering of operator computation is sequence, choice, parallel, loop, or\n",
    "        operator = choices([\"sequence\", \"choice\", \"parallel\",\"or\"],\n",
    "                                  [self.parameters[\"sequence\"], self.parameters[\"choice\"], self.parameters[\"parallel\"],\n",
    "                                   self.parameters[\"or\"]])\n",
    "        return operator[0]\n",
    "\n",
    "\n",
    "    def get_next_activity(self, activity):\n",
    "        result = self.set_activity_labels[self.set_activity_labels.index(activity) + 1]\n",
    "        return result\n",
    "\n",
    "\n",
    "    def assign_root_opeartor(self):\n",
    "        activity = \"a\"\n",
    "        # is a silent activity chosen\n",
    "        silent_activity = False\n",
    "        if random.random() < self.parameters[\"silent\"]:\n",
    "            silent_activity = True\n",
    "        root = self.tree._get_root()\n",
    "        operator = self.select_operator()\n",
    "        root.operator = assign_operator(operator)\n",
    "        # if operator is loop, we use a special structure, otherwise 2\n",
    "        if operator == \"loop\":\n",
    "            print('POPO')\n",
    "        else:\n",
    "            if silent_activity and operator == \"choice\":\n",
    "                number = random.choice([0, 1])\n",
    "                if number == 0:\n",
    "                    new_node = obj.ProcessTree(label=None)\n",
    "                    new_node.parent = root\n",
    "                    root._children.append(new_node)\n",
    "                    new_node = obj.ProcessTree(label=activity)\n",
    "                    new_node.parent = root\n",
    "                    root._children.append(new_node)\n",
    "                else:\n",
    "                    new_node = obj.ProcessTree(label=activity)\n",
    "                    new_node.parent = root\n",
    "                    root._children.append(new_node)\n",
    "                    new_node = obj.ProcessTree(label=None)\n",
    "                    new_node.parent = root\n",
    "                    root._children.append(new_node)\n",
    "            else:\n",
    "                new_node = obj.ProcessTree(label=activity)\n",
    "                new_node.parent = root\n",
    "                root._children.append(new_node)\n",
    "                activity = self.get_next_activity(activity)\n",
    "                new_node = obj.ProcessTree(label=activity)\n",
    "                new_node.parent = root\n",
    "                root._children.append(new_node)\n",
    "        # always two children are added\n",
    "        self.total_activities -= 2\n",
    "        return self.get_next_activity(activity)\n",
    "\n",
    "\n",
    "    def add_node(self, next_activity):\n",
    "        \"\"\"\n",
    "        Add nodes to current tree. The general procedure is as follows:\n",
    "        Select a random leaf (leaves have label). Next step, and opertor is chosen.\n",
    "        The chosen operator then replaces the leaf, whereby the old label is then add as a leaf to the manipulated node.\n",
    "        Then, next activity is added as a second leaf to the new operator node or a silent acticity (tau) is added.\n",
    "        :return: Next activity\n",
    "        \"\"\"\n",
    "        # Need to select random node that is not a silent activity\n",
    "        leaf_silent = True\n",
    "        while (leaf_silent):\n",
    "            leaf = random.choice(self.tree._get_leaves())\n",
    "            if leaf.label is not None:\n",
    "                leaf_silent = False\n",
    "        operator_nok = True\n",
    "        while (operator_nok):\n",
    "            operator = self.select_operator()\n",
    "            if self.total_activities > 1:\n",
    "                operator_nok = False\n",
    "            else:\n",
    "                if operator != \"loop\":\n",
    "                    operator_nok = False\n",
    "        activity = leaf._get_label()\n",
    "        leaf._set_label(None)\n",
    "        leaf._set_operator(assign_operator(operator))\n",
    "        # Will be an tau added?\n",
    "        silent_activity = False\n",
    "        if random.random() < self.parameters[\"silent\"]:\n",
    "            silent_activity = True\n",
    "        # add two children\n",
    "        if operator == \"loop\":\n",
    "            print('popo')\n",
    "        else:\n",
    "            if silent_activity and operator == \"choice\":\n",
    "                number = random.choice([0, 1])\n",
    "                if number == 0:\n",
    "                    new_node = obj.ProcessTree(label=None)\n",
    "                    new_node.parent = leaf\n",
    "                    leaf._children.append(new_node)\n",
    "                    new_node = obj.ProcessTree(label=activity)\n",
    "                    new_node.parent = leaf\n",
    "                    leaf._children.append(new_node)\n",
    "                else:\n",
    "                    new_node = obj.ProcessTree(label=activity)\n",
    "                    new_node.parent = leaf\n",
    "                    leaf._children.append(new_node)\n",
    "                    new_node = obj.ProcessTree(label=None)\n",
    "                    new_node.parent = leaf\n",
    "                    leaf._children.append(new_node)\n",
    "            else:\n",
    "                new_node = obj.ProcessTree(label=activity)\n",
    "                new_node.parent = leaf\n",
    "                leaf._children.append(new_node)\n",
    "                activity = next_activity\n",
    "                new_node = obj.ProcessTree(label=activity)\n",
    "                new_node.parent = leaf\n",
    "                leaf._children.append(new_node)\n",
    "\n",
    "        self.total_activities -= 2\n",
    "        if silent_activity and operator == \"choice\":\n",
    "            return next_activity\n",
    "        else:\n",
    "            return self.get_next_activity(activity)\n",
    "\n",
    "\n",
    "    def add_duplicates(self):\n",
    "        \"\"\"\n",
    "        Replaces some leaves  to add duplicated labels. Depends on parameter.\n",
    "        :return:\n",
    "        \"\"\"\n",
    "        duplication_allowed = False\n",
    "        leaves = self.tree._get_leaves()\n",
    "        for leaf in leaves:\n",
    "            if leaf._parent != self.tree._get_root():\n",
    "                duplication_allowed = True\n",
    "                break\n",
    "        # if there is at least a depth of two\n",
    "        if duplication_allowed:\n",
    "            # list that contains the leaves with a label unequal to tau\n",
    "            leaves_with_label = []\n",
    "            for leaf in leaves:\n",
    "                if leaf.label is not None:\n",
    "                    leaves_with_label.append(leaf)\n",
    "            # generate random list of duplicates\n",
    "            duplicates = []\n",
    "            for leaf in leaves:\n",
    "                if random.random() < self.parameters[\"duplicate\"]:\n",
    "                    duplicates.append(leaf)\n",
    "            if len(duplicates) > 0:\n",
    "                # select potential leaves to replace them by duplicates\n",
    "                possible_replacements = []\n",
    "                for leaf in leaves:\n",
    "                    if leaf not in duplicates:\n",
    "                        possible_replacements.append(leaf)\n",
    "            for leaf in duplicates:\n",
    "                i = 0\n",
    "                siblings = []\n",
    "                # determine sibling nodes (same parent)\n",
    "                p = leaf._parent\n",
    "                for child in p._children:\n",
    "                    if child != leaf:\n",
    "                        siblings.append(child)\n",
    "                # TODO Skaling? Original: 30times, my idea : percentage of duplicates * len(leaves)\n",
    "                while i < self.parameters[\"duplicate\"] * len(leaves):\n",
    "                    replacement = random.choice(possible_replacements)\n",
    "                    if replacement not in siblings:\n",
    "                        replacement._label = leaf._label\n",
    "                        break\n",
    "\n",
    "\n",
    "    def create_process_tree(self):\n",
    "        self.tree = obj.ProcessTree()\n",
    "        self.set_activity_labels = []\n",
    "        p = 1\n",
    "        # create labels\n",
    "        while (self.total_activities > len(self.set_activity_labels)):\n",
    "            # pairwise product\n",
    "            l = itertools.product(self.alphabet, repeat=p)\n",
    "            for item in l:\n",
    "                label = \"\"\n",
    "                for element in item:\n",
    "                    label += str(element)\n",
    "                self.set_activity_labels.append(label)\n",
    "            p += 1\n",
    "        step = 1\n",
    "        activity = self.assign_root_opeartor()\n",
    "        step += 1\n",
    "\n",
    "        while (self.total_activities > 0):\n",
    "            activity = self.add_node(activity)\n",
    "            step += 1\n",
    "\n",
    "\n",
    "    def __init__(self, parameters):\n",
    "        self.parameters = {}\n",
    "        for param in parameters:\n",
    "            p = param if type(param) is str else param.value\n",
    "            self.parameters[p] = parameters[param]\n",
    "        # rescale probabilities of operators if the sum is not equal to one\n",
    "        if self.parameters[\"sequence\"] + self.parameters[\"choice\"] + self.parameters[\"parallel\"] + self.parameters[\"or\"] != 1:\n",
    "            sum_of_operators = self.parameters[\"sequence\"] + self.parameters[\"choice\"] + self.parameters[\"parallel\"] + \\\n",
    "                               self.parameters[\"or\"]\n",
    "            self.parameters[\"sequence\"] = self.parameters[\"sequence\"] / sum_of_operators\n",
    "            self.parameters[\"choice\"] = self.parameters[\"choice\"] / sum_of_operators\n",
    "            self.parameters[\"parallel\"] = self.parameters[\"parallel\"] / sum_of_operators\n",
    "            self.parameters[\"or\"] = self.parameters[\"or\"] / sum_of_operators\n",
    "        # First step: Compute acivity distribution\n",
    "        # Since mode, min and max are given, the triangle distribution is chosen\n",
    "        self.activity_distribution = self.calculate_activity_distribution(self.parameters[\"mode\"],\n",
    "                                                                          self.parameters[\"min\"],\n",
    "                                                                          self.parameters[\"max\"])\n",
    "        # Number of total activities represented in the tree. Also, tau is counted as an activity.\n",
    "        self.total_activities = int(math.ceil(self.draw_random_number_from_distribution()))\n",
    "\n",
    "\n",
    "    def generate(self):\n",
    "        # Create a process tree based on the given probabilities\n",
    "        self.create_process_tree()\n",
    "        # add duplicates\n",
    "        self.add_duplicates()\n",
    "\n",
    "        return self.tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9a6df825",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "O( +( O( ->( 'a', 'm' ), O( 'f', ->( 'h', 'i' ) ) ), 'c' ), ->( 'b', X( X( X( O( X( O( 'd', 'q' ), 'o' ), 'l' ), O( O( 'k', ->( 'p', 'r' ) ), 'n' ) ), 'g' ), +( 'e', 'j' ) ) ) )\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<IPython.core.display.Image object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "70f9b51ffb504baf99c06f53f4662788",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "exporting log, completed traces ::   0%|          | 0/1000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "nl = apply()\n",
    "print(nl)\n",
    "pm4py.view_process_tree(nl,\"png\")\n",
    "pm4py.objects.process_tree.exporter.exporter.apply(nl, \"ptree3.xml\")\n",
    "\n",
    "net, im, fm = pm4py.convert_to_petri_net(nl)\n",
    "log = pm4py.play_out(net, im, fm)\n",
    "#log = pm4py.play_out(thept)\n",
    "#log = semantics.generate_log(nl, no_traces=5)\n",
    "pm4py.write_xes(log, 'processtraces.xes')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "be8b2670",
   "metadata": {},
   "source": [
    "## Translate PT into AT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6699c447",
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "import graphviz\n",
    "import uuid\n",
    "import Node as nd\n",
    "import xml.etree.cElementTree as ET\n",
    "from IPython import display\n",
    "import pm4py\n",
    "import sys\n",
    "\n",
    "\n",
    "count = 0\n",
    "# Translate the Process Tree into an Attack Tree\n",
    "def P2T(node):\n",
    "\tglobal count\n",
    "    # If our current node is an operator\n",
    "\tif not node.operator == None:\n",
    "\t\tprint(node.operator)\n",
    "\t\t#Create the new node\n",
    "\t\tparent = nd.Node('tau' + str(count), 'non-observable')\n",
    "\t\t#DFS on all children\n",
    "\t\tfor child in node.children:\n",
    "\t\t\t\tcount = count + 1\n",
    "\t\t\t\tnew = P2T(child)\n",
    "\t\t\t\tif new == None:\n",
    "\t\t\t\t\tcontinue\n",
    "\n",
    "\t\t\t    #Set the relationship(SAND, AND, OR, XOR)\n",
    "\t\t\t    #SEQUENCE -> SAND\n",
    "\t\t\t    #PARALLEL -> AND\n",
    "\t\t\t    #OR       -> OR\n",
    "\t\t\t    #XOR      -> XOR\n",
    "\t\t\t    #LOOP     -> ?\n",
    "\t\t\t\tnew.setParentRelationship(node.operator.name)\n",
    "\t\t\t\tif new.getName() != None:\n",
    "\t\t\t\t\tattckTreebranch = copy.deepcopy(new)\n",
    "\t\t\t\t\tattckTreebranch.setID(uuid.uuid4().hex)\n",
    "\t\t\t\t\tparent.setChildren(attckTreebranch)\n",
    "\n",
    "\t\t#newp = copy.deepcopy(parent)\n",
    "\t\t#newp.setID(uuid.uuid4().hex)\n",
    "\t\treturn copy.deepcopy(parent)\n",
    "\n",
    "    #If our current node is not an operator\n",
    "\telif node.label != '0':\n",
    "\t\tprint(node.label)\n",
    "\t\treturn nd.Node(node.label, 'observable')\n",
    "\n",
    "# Convert to xml\n",
    "# Save the attack tree (bfs access)\n",
    "def AT2xml(node, filepath):\n",
    "\ttree = ET.Element(\"tree\")\n",
    "\tif node is None:\n",
    "\t\treturn\n",
    "\tqueue = [node]\n",
    "\twhile len(queue) > 0:\n",
    "\t\tcur_node = queue.pop(0)\n",
    "\t\tET.SubElement(tree, \"root\", name =cur_node.getName(), state =  \"observable\", id = cur_node.getID())\n",
    "\t\tfor child in cur_node.getChildren():\n",
    "\t\t\tET.SubElement(tree, \"child\", name = child.getName(), state =  \"observable\", parentRelationship = child.getParentRelationship(), parent = cur_node.getID(), id=child.getID())\n",
    "\t\t\tqueue.append(child)\n",
    "\tET.ElementTree(tree).write(filepath+\".xml\")\n",
    "\n",
    "def Tree2RisQFLan(root, file):\n",
    "\twith open(file, 'w') as file:\n",
    "\t\tfile.write('begin model Empty \\n// This is an empty RisQFLan file \\n// Fill all the blocks to model your scenario name \\n//Here we specify variables and their initial values. This is convenient to express constraints and to ease the analysis\\nbegin variables \\nend variables \\n// Here we specify all the things that can go wrong\\n// In particular successful actions of attacker\\nbegin attack nodes\\n')\n",
    "\t\tqueue = [root]\n",
    "\t\twhile len(queue) > 0:\n",
    "\t\t\tcur_node = queue.pop(0)\n",
    "\t\t\tfile.write(cur_node.getName() + '\\n')\n",
    "\t\t\tfor child in cur_node.getChildren():\n",
    "\t\t\t\tqueue.append(child)\n",
    "\t\tfile.write('end attack nodes\\n')\n",
    "\t\tfile.write('// Reactive defensive actions\\nbegin defense nodes\\nend defense nodes\\n// Permanent defensive actions\\nbegin countermeasure nodes\\nend countermeasure nodes\\n// The diagram specifies how defensive actions and attacker actions relate to each other\\nbegin attack diagram\\n')\n",
    "\t\tqueue = [root]\n",
    "\t\twhile len(queue) > 0:\n",
    "\t\t\tcur_node = queue.pop(0)\n",
    "\t\t\tif len(cur_node.getChildren()) == 0:\n",
    "\t\t\t\tcontinue\n",
    "\t\t\tfile.write(cur_node.getName())\n",
    "\t\t\tflag = False\n",
    "\t\t\tfor child in cur_node.getChildren():\n",
    "\t\t\t\tif(not flag):\n",
    "\t\t\t\t\toperator = child.getParentRelationship()\n",
    "\t\t\t\t\tif operator == 'SeqAnd':\n",
    "\t\t\t\t\t\tfile.write(' -OAND-> [')\n",
    "\t\t\t\t\telif operator == 'And':\n",
    "\t\t\t\t\t\tfile.write(' -AND-> {')\n",
    "\t\t\t\t\telif operator == 'Or':\n",
    "\t\t\t\t\t\tfile.write(' -> {')\n",
    "\t\t\t\t\telif operator == 'Xor':\n",
    "\t\t\t\t\t\tfile.write(' -K1-> {')\n",
    "\t\t\t\t\telse:\n",
    "\t\t\t\t\t\tprint('no operator')\n",
    "\n",
    "\t\t\t\t\tflag = True\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tfile.write(', ')\n",
    "\t\t\t\tfile.write(child.getName())\n",
    "\t\t\t\tqueue.append(child)\n",
    "\t\t\tif(flag):\n",
    "\t\t\t\tif operator == 'SeqAnd':\n",
    "\t\t\t\t\tfile.write(']\\n')\n",
    "\t\t\t\telif operator == 'And':\n",
    "\t\t\t\t\tfile.write('}\\n')\n",
    "\t\t\t\telif operator == 'Or':\n",
    "\t\t\t\t\tfile.write('}\\n')\n",
    "\t\t\t\telif operator == 'Xor':\n",
    "\t\t\t\t\tfile.write('}\\n')\n",
    "\t\t\t\telse:\n",
    "\t\t\t\t\tcontinue\n",
    "\t\tfile.write('end attack diagram\\n')\n",
    "\t\tfile.write('// Here we can specify classes of attackers with probabilistic behavior\\nbegin attackers\\n attacker1\\nend attackers\\n// The effectiveness of a defence depends on the class of attacker and the attack action\\nbegin defense effectiveness\\nend defense effectiveness\\n// Attacks may not be detected \\nbegin attack detection rates\\nend attack detection rates\\n// Attributes of attacks are specified here\\nbegin attributes\\nend attributes\\n// One can here impose additional constraints on the attacker, e.g. based on his budget\\nbegin quantitative constraints\\nend quantitative constraints\\n//Domain-specific actions executed by the attacker\\nbegin actions\\nend actions\\n//Constraints on the execution of actions\\nbegin action constraints\\nend action constraints\\n//The probabilistic behaviour of each attacker\\nbegin attacker behaviour\\nbegin attack attacker\\n= attacker1\\nstates = state1\\ntransitions = \\n\tstate1 - (succ(' + root.getName() +'),1.0) -> state1\\nend attack \\nend attacker behaviour\\n// Here we specify the attacker we want to consider\\nbegin init\\nattacker1\\nend init\\n//Finally, you can specify 3 types of analysis\\n//analysis: statistical analysis of quantitative properties\\n//exportDTMC: export the state space of the model (if finite) in a discrete time Markov chain in the format supported by the model checkers PRISM and STORM\\n//simulate: perform a simulation to debug your model\\n\\n// In this particular case we are just interested in the likelihood of success of each attack\\nbegin analysis\\n   query = eval from 1 to 100 by 20 :\\n    {'     + root.getName() +    '\\n}\\n    // Statistical confidence\\n    default delta = 0.1\\n    alpha = 0.1\\n    // Parallelism to be exploited in the machine \\n    parallelism = 1\\nend analysis\\nend model')\n",
    "\n",
    "\n",
    "#def main(filei, fileo):\n",
    "# import the process tree\n",
    "# ProcessTree = pm4py.objects.process_tree.importer.importer.apply(\"ptree3.xml\")\n",
    "\n",
    "#Translate to Attack Tree\n",
    "AttackTree = P2T(nl)\n",
    "print(\"Attack tree translated!\")\n",
    "\n",
    "#Write Attck Tree to xml\n",
    "AT2xml(AttackTree, \"atree\")\n",
    "\n",
    "#Convert to RISQFlan code\n",
    "Tree2RisQFLan(AttackTree, \"atree\" + \".bbt\")\n",
    "print(\"Attack tree converted to RISQFlan code!\")\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3ee7c96",
   "metadata": {},
   "source": [
    "## Replay PT traces in AT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb14345a",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pm4py.objects.log.importer.xes import importer as xes_importer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3312d024",
   "metadata": {},
   "outputs": [],
   "source": [
    "#update the values in nodes\n",
    "def dfs(element, node):\n",
    "    if node == None:\n",
    "        return\n",
    "    \n",
    "    if node.getName() == element:\n",
    "        node.updateValue(1)\n",
    "        return\n",
    "    \n",
    "    for child in node.getChildren():\n",
    "        dfs(element, child)\n",
    "        \n",
    "    return\n",
    "\n",
    "#clear the values in nodes\n",
    "def clear(node):\n",
    "    if node == None:\n",
    "        return\n",
    "    \n",
    "    for child in node.getChildren():\n",
    "        clear(child)\n",
    "    \n",
    "    node.updateValue(0)\n",
    "\n",
    "    return\n",
    "\n",
    "#Check the value of the node\n",
    "def check(node):\n",
    "    \n",
    "    if len(node.getChildren()) == 0:\n",
    "        return \n",
    "    \n",
    "    relation = node.getChildren()[0].getParentRelationship()\n",
    "    \n",
    "    value = 0\n",
    "    \n",
    "    check_xor = 0\n",
    "    \n",
    "    check_seq = 0\n",
    "\n",
    "    for child in node.getChildren():\n",
    "        check(child)\n",
    "        value = value + child.getValue()\n",
    "\n",
    "    if relation == 'Or':\n",
    "        if value > 0:\n",
    "            node.updateValue(1)\n",
    "            \n",
    "    if relation == 'Xor':\n",
    "        for child in node.getChildren():\n",
    "            check_xor = check_xor + child.getValue()\n",
    "        if(check_xor == 1):\n",
    "            node.updateValue(1)\n",
    "        check_xor = 0\n",
    "    \n",
    "    if relation == 'And':\n",
    "        if value == len(node.getChildren()):\n",
    "            node.updateValue(1)\n",
    "            \n",
    "    if relation == 'SeqAnd':\n",
    "        for i in range(0,len(node.getChildren())):\n",
    "            if i==0:\n",
    "                if node.getChildren()[0].getValue() == 1:\n",
    "                    check_seq = check_seq + 1\n",
    "            else:\n",
    "                if(i == check_seq):\n",
    "                    check_seq = check_seq + 1\n",
    "                    \n",
    "        if(check_seq == len(node.getChildren())):\n",
    "            node.updateValue(1)\n",
    "        #print('check seq', check_seq)\n",
    "        \n",
    "        check_seq = 0\n",
    "            \n",
    "        \n",
    "    return\n",
    "\n",
    "# Replay the traces on the Attack Tree\n",
    "def replay(trace):\n",
    "    #print(trace)\n",
    "    for element in trace:\n",
    "        dfs(element, AttackTree)\n",
    "    check(AttackTree)\n",
    "    return AttackTree.getValue()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f4a2c626",
   "metadata": {},
   "outputs": [],
   "source": [
    "log = xes_importer.apply(\"processtraces.xes\")\n",
    "x = 0\n",
    "for trace in log:\n",
    "    tracetocheck = []\n",
    "    for event in trace:\n",
    "        tracetocheck.append(event.get(\"concept:name\"))\n",
    "    #print(tracetocheck)\n",
    "    #print(trace.attributes, replay(tracetocheck))\n",
    "    x =  x + replay(tracetocheck)\n",
    "    clear(AttackTree)\n",
    "x = int(x)\n",
    "print(x)\n",
    "print(x/len(log))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c16d5fcd",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.10.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}