Pickhardt-Payments-Simulation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is an educational simulation to demonstrate how to implement the main concepts of [probabilistic payment delivery with the additional maintainance of the uncertainty network](https://arxiv.org/abs/2103.08576) and [optimal splitting of payments in MPP which is also known as optimally realiable payment flows](https://arxiv.org/abs/2107.05322)\n",
    "\n",
    "This code assumes an oracle with the actual liquidity of channels to exist. In reality the oracle is the lightning network which can be queried by sending out actual onions.\n",
    "\n",
    "## Warning: THIS IS WORK IN PROGRESS: The code has some severe limitations...\n",
    "...which make it impractical for real nodes and implementations. Do not just blindly wrap this into production code but address the following limitations:\n",
    "\n",
    "* channel reserves are ignored\n",
    "* HTLC limits like min_size, max_size, max_accepted_htlc are fully ignored\n",
    "* proper handling of parallel channels needs to be done\n",
    "* strategies to operate with hanging htlc's (some might require protocol updates) may need to be included\n",
    "* concurrent handeling of onions and maintanance of the uncertainty network\n",
    "* proper handling of non zero base fee channels is needed and in particular handeling their cost properly at least as good as it is possible\n",
    "* better piecewise splitting / quantization of the amounts is necessary\n",
    "* learning how to weight various features needs to be conducted or at least configureably be in place\n",
    "* Mechanics of making learnt information persistant over some time\n",
    "* inclusion of other otpimization goals that predict reliability are missing (like latency, distance, ...)\n",
    "* One should Prune the graph before invoking the solver\n",
    "* properly conduct the piecewise linearization of the cost function\n",
    "* don't overwrite memory of the entire uncertainty network all the time but just update the necessary pieces before invoking the solver\n",
    "* potentially write your own stand alone cost scaling min cost flow solver instead of relying on a third party dependency\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## BOLT14 considerations\n",
    "\n",
    "This code also contains a few experiments to investigate the effects of the BOLT14 proposal.\n",
    "Maybe it might make sense to make entropy hints not only as a foaf query but as an n-bit network wide gossip message. Unless we have some prior belief about the channel the 2 bit gossip intervalls are\n",
    "\n",
    "* [0, c/4]\n",
    "* [c/4,c/2]\n",
    "* [c/2,3c/4]\n",
    "* [3c/4,c]\n",
    "\n",
    "nodes would only signal a message if the liquidity switches from one of those intervals to another (of course one could also require 3 bits or so)\n",
    "\n",
    "## TODOS: \n",
    "as hinted in the ldk issue https://github.com/lightningdevkit/rust-lightning/issues/1372 it might make sense to not use a global \\mu but rather learn it for each channel by comparing min uncertainty cost ~ 1/c max uncertainty cost = log(c+1) with the ppm on the edge and make sure we get this in the same order. It is only a test but it might turn out to work really well\n",
    "\n",
    "fix some fixme's most notably the data model that produces poor probability computation in outputs as it ignors the prior knowlege which means all displayed probabilities are too low (though the flow is computed properly)\n",
    "\n",
    "make a useful design for liquidity sharing...\n",
    "\n",
    "# Funding\n",
    "\n",
    "This research result is funded through [NTNU](https://www.ntnu.no) and [BitMEX](https://blog.bitmex.com/bitmex-2021-open-source-developer-grants/) as well as generous donations from the Bitcoin community via https://donate.ln.rene-pickhardt.de and via recurring donations at https://www.patreon.com/renepickhardt. If you want to learn why independent research and development for Bitcoin and the Lightning Network is important I kindly refer you to: https://ln.rene-pickhardt.de/ of course I will be grateful if you consider my work of importance and decide to support it.\n",
    "\n",
    "Special Thanks to Stefan Richter with whom we implemented the first mainnet tests on top of lnd which certainly helped me to clarify many details and get the maintanance of the uncertainty network straight."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Glossary of terms\n",
    "\n",
    "As many similar terms are being used for similar concepts and things and since I have been studying these topics for three years now I will follow the good practice of [BOLT0](https://github.com/lightning/bolts/blob/master/00-introduction.md) and put a glossary of used terms up here with the hope that I finally have some good, useful and precise defintions that will also bee picked up by others.\n",
    "\n",
    "\n",
    "## (Payment) Channel\n",
    "Payment `channel`s are either announced or unnannounced but known to the sender and recpient of a payment. They have meta data like the `capacity` or `routing fees` as well as some other config values which we ignore for simplicity here.\n",
    "\n",
    "##  Arc\n",
    "An `arc` is not to be confused with a payment `channel`. `Arc`s are the data structure that arise from the piece wise linearized `cost function` and are used internally in the min cost flow solver. \n",
    "\n",
    "\n",
    "## (Channel) Capacity\n",
    "The `capacity` of a payment channel is its size as observed in the amount of the output of the funding transaction which is announced via the `short_channel_id` in gossip.\n",
    "\n",
    "**Important**: It seems to be an unavoidable collision that the term capacity is also used for `arcs` in min cost flow solvers. As I introduce the piece wise linearization the `cost function` the arcs in the min cost flow solve will usually have a lower `capacity` than the cannels they represent. I try to distinguish this by talking either about the `channel capacity` or the `arc capacity` if absolutely necessary.\n",
    "\n",
    "## Liquidity\n",
    "The `Liquidity` is the amount of satoshis a peer has available to route on it's channel. This means that unless the (even) `capacity` is split exactly 50/50 between the peers the `liquidity` in a channel will be different for both peers. \n",
    "\n",
    "typical terms in the wild: balance, local balance, outbound capacity\n",
    "\n",
    "## Uncertainty / Entropy \n",
    "assuming a prior probability distribution we can quantify the `uncertainty` about the channels `liquidity` by measureing the `entropy` of the probability function. Notably if a channel as a `capacity` of `c` satoshis the entropy is `log(c+1)`\n",
    "\n",
    "## Unertainty Network\n",
    "\n",
    "The `uncertainty network` is a model than encodes our current belief about the available `liquidity` in the channels of the Lightning network. This is usually achieved by storing three values: \n",
    "\n",
    "1. Minimum `liquidity` which initialy for remote channel is `0`. \n",
    "2. Maximum `liquidity` which initially for remote channels corresponds its `capacity`.\n",
    "3. `inflight` is the number of satoshis that we currently have allocated to this channel in outstanding onions and HTLCs.\n",
    "\n",
    "## inflight\n",
    "We use `inflight` to encode how many satoshis we have currently allocated or plan to allocate to a channel. Note that this is not the same as the number of inflight htlcs that the peer co-owning the channel will observe as some of the onions that we have outstanding may not have been delivered to the channel yet or may have failed but not returend back to us yet.\n",
    "\n",
    "## Cost(function)\n",
    "\n",
    "The `cost` function encodes our optimization goals and consists of several `features`. typical `features` are the `uncertainty cost` and the `routing fees`. Note that the same cost function can be applied to Dijkstra's algorithm as to min cost flow solvers. However in the general case of min cost flows the cost function should be convex or even better linear or piecewise linear so that a reasonable runtime can be achieved. \n",
    "\n",
    "The `cost` is just an internal value that will be minimized in computation of `candidate paths` for the `payment loop`. This cost may or may not translate to `routing fees`.\n",
    "\n",
    "typical terms in the wild: Score, fees, penalty\n",
    "\n",
    "## Unit cost\n",
    "Linear min cost flow solvers need a fixed cost for transporting 1 unit (e.g. 1 satoshi) along an `arc` (e.g. `channel`). Oft\n",
    "\n",
    "## Uncertainty cost\n",
    "This is the `feature` introduced in the [`probablistic payment delivery` paper](https://arxiv.org/abs/2103.08576) it puts a cost on an amount `a` to be send over a (`path`) of `payment channels`.\n",
    "It is comuted by taking the negative logarithm of the `success probability` if we have no prior belief of the channel the `uncertainty cost` will be computed as: `-log((c+1-a)/(c+1))`. Note that the uncertainty cost is a convex gowing function takin the value `0 = -log((c+1-0)/(c+1)) = -log(1)` if no sats are to be allocated on the channel. The maximum possible `uncertainty cost` occurs if `a=c` and takes the value `log(c+1)` which is exactly the `entropy` of the channel which can be seen by the following calculation:\n",
    "`-log((c+1-c)/(c+1)) = -log(1/(c+1)) = log(c+1)`\n",
    "\n",
    "### linearized uncertainty cost\n",
    "The linearized uncertainty cost is the first term of the taylor approximation of `f(a)=-log((c+1-a)/(c+1))` which results in `a/(c+1)`. This (in my opinion surprisingly) corresponds to the failure probability. Note that we should not interpret it as such as it does not make sense to add probabilities while those feature will be added in the global `cost function` of the min cost flow solvers. \n",
    "\n",
    "This results in a `unit` cost of `1/(c+1)`. since integers are preferable we multiply the unit cost with the maximum observed channel `capacity` of all channels and ignoring the decimals. \n",
    "\n",
    "Thus the **final integer linearized uncertainty unit cost** is: `int(c_{max}/(c+1))`\n",
    "\n",
    "## (routing) fees\n",
    "\n",
    "The routing `fee` is a feature that usually corresponds directly to the fees that are being charged to forward a payment of size `a` along a channel. According to the protocol it is currently being computed as: \n",
    "\n",
    "`fee(a) = a*ppm/1000 + base_fee_msat`\n",
    "\n",
    "## linearized fees\n",
    "\n",
    "As discussed in our research and on the mailinglist the fee function of the lightning network is not linear. In the mentioned discussion one can see that `fee(a+b) = fee(a)+fee(b) - base_fee_msat` which is linear if and only if `base_fee_msat = 0`. \n",
    "\n",
    "Thus in computation we currently linearize the `fee` function by ignoring the `base fee` so we use `fee(a) = a*ppm/1000` giving us a `unit cost` of `ppm/1000` \n",
    "\n",
    "As min cost flow solvers prefer integer cost we scale by `1000` and arrive at the **final integer linearized fee unit cost** which is just the: `ppm`. \n",
    "\n",
    "For this to work good enough we might also take channel that charge a very small `base_fee` and later just pay it when we send the onions.\n",
    "\n",
    "\n",
    "## Features\n",
    "\n",
    "The `features` of our cost function encode our optimization goals. Typicalfeatures goals might be to have a cheap price (usually encoded by `fee`) or to have a high reliability (in this work best encoded by the `uncertainty cost`that comes from the estimated `success probability` that the channel has enough `liquidity`. Other features that seam reasonable are things related to `latency` of payments (e.g. [pyhsical geodistance or virtaul IP-distance as indicted in this comment](https://github.com/lightningdevkit/rust-lightning/issues/1170)). Implementations have also experimented with other features like CLTV delta or channel age. \n",
    "\n",
    "Feature engineering is a crucial part for future research \n",
    "\n",
    "## Success Probability\n",
    "\n",
    "The definition of the `success probability` is in our case modelled by estimating the likelihood that a channel with a `capacity` of `c` has `a` sats of `liquidity` available. \n",
    "\n",
    "In the base case where we have not learnt anything about the channel's `liquidity` in the past the `success probability` for making a payment of size `a` stays at `P(X>=a) = (c+1-a)/(c+1)`\n",
    "\n",
    "Let's say a payment delivery algorithm sends an onion via a path of channel and wants to add an HTLC with amount `h` to a channel of capacity `c` there are several cases that we can observe to update our uncertainty about the network for future payments of size `a`\n",
    "\n",
    "1. Payment failed at the channel: This means the channel of capacity `c` has at most `h-1` satoshi in it. In Terms of Probability theory we can ask ourselves what is the success rate for a subsequent payment of size `a` given the event `X<h` (the htlc  `h` has failed) which can be expressed as `P(X>=a | X<h)`. Here we see because of the condition that for `a>=h` the proabbility has to be `0`. Computing the conditional probability for the remainder in the uniform case we can se `P(X>=a | X < h) = (h-a)/h`. Note that this is the same as the success probability for a channel of capacity `h-1`. \n",
    "2. Payment failed at a downstream channel: This means that the channel of capcity `c` was able to route `h` satoshi and has at least a minimum `liquidity` of `h`. This means that `P(X>=a | X>=h) = 1`  for all amounts `a <=h` and in the unform case for all larger values of `a` the conditional probability materializes to: `P(X>=a)/P(X>=h) = ((c+1-a)/(c+1))/((c+1-h)/(c+1)) = (c+1-a)/(c+1-h)` Note that this fraction is always smaller than `1` as `a >=h`\n",
    "3. The case that the payment was successfull or did not return an error: Following the same thoughts and the first bullet point at the end of section 3 in the second paper we know that for a future payment of size `a` we have to look at `P(X>=a + h | X >=h)` which in the uniform case materializes to `( (c-h) + 1 - a)/( (c - h) + 1)`. Note that this is the same as if the channel shrunk from `c` to `c-h` as we now know that the maximum `liquidity` is not `c` but rather `c-h`\n",
    "\n",
    "\n",
    "## optimal payment flow / optimal mpp split\n",
    "\n",
    "We call a payment flow optimal if it minimizes the `cost function` that encodes our optimization goals. Note that the solution of the min cost flow problem also defines a split of the payment across various paths. While simple algorithms for discecting a flow into paths exist the actual disection is not uique and needs further research. Especially when we start taking channel configurations into account.\n",
    "\n",
    "## Payment Loop\n",
    "\n",
    "The payment loop is the trial and error process of delivering a certain amount of satoshis from a sending node to a recipient. This is usually done by generating a set of candidate onions from the solution of an `optimal payment flow`. The onions are concurrently being sent out and error are being used to update our belief about the `liquidity` in the `uncertainty network`.\n",
    "\n",
    "## Probabilistic Payment Delivery\n",
    "\n",
    "The idea of `probabilistic payment delivery` is to send onions that maximize the success proabbility for all (or parts of them) to be successul. This takes the `uncertainty` about the remote `liquidity` into consideration and was first introduced in path finding (Note I did not use the term path findng nore did I put it in the glossary)\n",
    "\n",
    "## Pickhardt Payments\n",
    "As the term is more and more starting to flow around I will try to summarize best what is currently from a technial point of view meant by it: \n",
    "\n",
    "`Using probabilistic payment delivery` in a round based `payment loop` that updeates our belief of the remote `liquidity` in the `uncertainty network` and generates reliable and cheap `payment flows` in every round by solving a `piece wise linearized min integer cost flow problem with a seperable cost function` (I start to see why a shorter term was needed)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ortools.graph import pywrapgraph\n",
    "import time\n",
    "import random\n",
    "import networkx as nx\n",
    "import json\n",
    "from math import log2 as log"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def next_hop(path):\n",
    "    \"\"\"\n",
    "    generator to iterate through edges indext by node id of paths\n",
    "    \n",
    "    The path is a list of node ids. Each call returns a tuple src, dest of an edge in the path    \n",
    "    \"\"\"\n",
    "    for i in range(1,len(path)):\n",
    "        src = path[i-1]\n",
    "        dest = path[i]\n",
    "        yield (src,dest)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Channel:\n",
    "    \"\"\"\n",
    "    The channel class contains basic information of a channel that will be used to create the\n",
    "    Uncertainty network.\n",
    "    \n",
    "    Since we optimize for reliability via a probability estimate for liquidity that is based\n",
    "    on the capacity of the channel the class contains the `capacity` as seen in the funding tx output.\n",
    "    \n",
    "    As we also optimize for fees and want to be able to compute the fees of a flow the classe\n",
    "    contains information for the feerate (`ppm`) and the base_fee (`base`). \n",
    "    \n",
    "    Most importantly the class stores our belief about the liquidity information of a channel.\n",
    "    This is done by reducing the uncertainty interval from [0,`capacity`] to \n",
    "    [`min_liquidity`, `max_liquidity`].\n",
    "    Additionally we need to know how many sats we currently have allocated via outstanding onions\n",
    "    to the channel which is stored in `inflight`.\n",
    "    \n",
    "    the `key` field is necessary to map the channel to its corresponding arcs in the minc cost flow solver\n",
    "    \n",
    "    FIXME: the class does not contain min_htlc_size, channel_reserve or other meta data from gossip yet.\n",
    "    \"\"\"\n",
    "    def __init__(self,size,key,ppm,base):\n",
    "        self.__key=key\n",
    "        self.__ppm=ppm\n",
    "        self.__base=base\n",
    "        self.__capacity=size\n",
    "        self.__minLiquidity=0\n",
    "        self.__maxLiquidity=size\n",
    "        self.__inflight = 0\n",
    "        \n",
    "    def __str__(self):\n",
    "        return \"Size: {} with {:4.2f} bits of Entropy. Uncertainty Interval: [{},{}]\".format(self.__capacity, self.entropy(), self.__minLiquidity, self.__maxLiquidity)\n",
    "\n",
    "    def get_key(self):\n",
    "        return self.__key\n",
    "    \n",
    "    def get_capacity(self):\n",
    "        return self.__capacity\n",
    "    \n",
    "    def get_ppm(self):\n",
    "        return self.__ppm\n",
    "    \n",
    "    def get_base(self):\n",
    "        return self.__base\n",
    "    \n",
    "    def get_max_liquidity(self):\n",
    "        return self.__maxLiquidity\n",
    "\n",
    "    def get_min_liquidity(self):\n",
    "        return self.__minLiquidity\n",
    "    \n",
    "    def forget_information(self):\n",
    "        \"\"\"\n",
    "        resets the information that we belief to have about the channel. \n",
    "        \"\"\"\n",
    "        self.__minLiquidity=0\n",
    "        self.__maxLiquidity=self.__capacity\n",
    "        self.__inflight = 0\n",
    "        \n",
    "    def set_min_liquidity(self,value):\n",
    "        self.__minLiquidity=value\n",
    "    \n",
    "    def set_max_liquidity(self,value):\n",
    "        self.__maxLiquidity=value\n",
    "\n",
    "    def allocate_amount(self,amt):\n",
    "        self.__inflight += amt\n",
    "        return\n",
    "    \n",
    "    def entropy(self):\n",
    "        \"\"\"\n",
    "        returns the uncertainty that we have about the channel\n",
    "        \n",
    "        FIXME: Do we have to respect inflight information? I assume no.\n",
    "        \"\"\"\n",
    "        return log(self.__maxLiquidity - self.__minLiquidity + 1)\n",
    "    \n",
    "    def success_probability(self,amt):\n",
    "        \"\"\"\n",
    "        returns the estimated success probability for a payment based on our belief about the channel using a uniform distribution.\n",
    "\n",
    "        In particular the conditional probability P(X>=a | min_liquidity < X < max_liquidity)\n",
    "        is computed based on our belief also respecting how many satoshis we have currently \n",
    "        outstanding and allocated.\n",
    "        \n",
    "        FIXME: Potentially test other prior distributions like mixedmodels where most funds are on one side of the channel\n",
    "        \"\"\"\n",
    "        tested_liquidity = amt + self.__inflight\n",
    "\n",
    "        if tested_liquidity <= self.__minLiquidity:\n",
    "            return 1.0\n",
    "        elif amt >= self.__maxLiquidity:\n",
    "            return 0\n",
    "        else:            \n",
    "            conditional_amount = tested_liquidity - self.__minLiquidity\n",
    "            conditional_capacity = self.__maxLiquidity - self.__minLiquidity\n",
    "            return float(conditional_capacity + 1 - conditional_amount)/ (conditional_capacity + 1)\n",
    "      \n",
    "        \n",
    "        \"\"\"\n",
    "        This is how it would be computed without respecting in_flight information \n",
    "        \n",
    "        if amt <= self.__minLiquidity:\n",
    "            return 1.0\n",
    "        elif amt >= self.__maxLiquidity:\n",
    "            return 0\n",
    "        else:\n",
    "            \n",
    "            effective_amount = amt - self.__minLiquidity\n",
    "            effective_capacity = self.__maxLiquidity - self.__minLiquidity\n",
    "            return float(effective_capacity+1 - effective_amount)/ (effective_capacity+1)\n",
    "        \"\"\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class OracleChannel(Channel):\n",
    "    \"\"\"\n",
    "    The Oracle channel inherits from the channel and is used for our simulation to act as the Oracle\n",
    "    \n",
    "    The Oracle channel has assigned liquidity information about a payment channel and can be tested \n",
    "    against. Note that on mainnet the actual channels act as oracles as one tests them by sending out\n",
    "    onions. For the simulation we just create ourselves an `known_liquidity_network` as an oracle.\n",
    "    (Note in the optimally reliable payment flows paper we still called this the known balance graph\n",
    "    however we retracted from using the term balance.)\n",
    "    \n",
    "    \n",
    "    \"\"\"\n",
    "    def __init__(self,size,key,ppm,base,actual_liquidity=None):\n",
    "        super().__init__(size,key,ppm,base)\n",
    "        self.__actual_liquidity=actual_liquidity\n",
    "        if actual_liquidity is None or actual_liquidity >= size or actual_liquidity < 0:\n",
    "            self.__actual_liquidity = random.randint(0,size)\n",
    "    def __str__(self):\n",
    "        return super().__str__()+\" actual Liquidity: {}\".format(self.__actual_liquidity)\n",
    "    \n",
    "    def update_knowledge(self,amt):\n",
    "        \"\"\"\n",
    "        updates our knowledge about the channel if we tried to probe it for amount `amt`\n",
    "        \"\"\"\n",
    "        if amt <= self.__actual_liquidity:\n",
    "            self.set_min_liquidity(max(self.get_min_liquidity(),amt))\n",
    "            return True\n",
    "        else:\n",
    "            self.set_max_liquidity(min(self.get_max_liquidity(), amt))\n",
    "            return False\n",
    "    \n",
    "    #needed for BOLT14 test experiment\n",
    "    def learn_n_bits(self,n):\n",
    "        \"\"\"\n",
    "        conducts n probes of channel via binary search starting from our belief\n",
    "        \n",
    "        This of course only learns `n` bits if we use a uniform success probability as a prior\n",
    "        thus this method will not work if a different prior success probability is assumed \n",
    "        \"\"\"\n",
    "        if n <= 0:\n",
    "            return\n",
    "        amt = self.get_min_liquidity() + int((self.get_max_liquidity() - self.get_min_liquidity())/2)\n",
    "        self.update_knowledge(amt)\n",
    "        self.learn_n_bits(n-1)\n",
    "    \n",
    "    def get_actual_liquidity(self):\n",
    "        \"\"\"\n",
    "        Tells us the actual liquidity according to the oracle. \n",
    "        \n",
    "        This is usful for experiments but must of course not be used in routing and is also\n",
    "        not a vailable if mainnet remote channels are being used.\n",
    "        \"\"\"\n",
    "        return self.__actual_liquidity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Oracle:\n",
    "    def __init__(self,):\n",
    "        return \n",
    "    \n",
    "    def get_max_cap(self):\n",
    "        \"\"\"\n",
    "        returns the maximum capacity on the channel graph\n",
    "        \n",
    "        This is necessary to produce integer costs for the linearized uncertainty cost\n",
    "        \"\"\"\n",
    "        return self.__max_cap\n",
    "    \n",
    "    def reset_uncertainty_network(self):\n",
    "        \"\"\"\n",
    "        Forgets all learnt information on the uncertainty network. \n",
    "        \n",
    "        This is usful to resuse the same data from the oracle between various experiments\n",
    "        \"\"\"\n",
    "        for key in self.__arcs.keys():\n",
    "            self.__arcs[key].forget_information()\n",
    "    \n",
    "    def __get_channel_json(self,fp):\n",
    "        #$ lightning-cli listchannels > listchannels20211028.json\n",
    "        f = open(fp)\n",
    "        return json.load(f)[\"channels\"]\n",
    "    \n",
    "    def __prepare_integer_indices_for_nodes(self,channels):\n",
    "        \"\"\"\n",
    "        necessary for the OR-lib by google and the min cost flow solver\n",
    "        \"\"\"\n",
    "        # let's first find all node_ids \n",
    "        # so that we can build the look up table and use integer unit costs\n",
    "\n",
    "        node_ids = set()\n",
    "        for c in channels:\n",
    "            src = c[\"source\"]\n",
    "            dest = c[\"destination\"]\n",
    "            node_ids.add(src)\n",
    "            node_ids.add(dest)        \n",
    "\n",
    "        # let's initialize the look up tables for node_ids to integers from [0,...,#number of nodes]\n",
    "        # this is necessary because of the API of the Google Operations Research min cost flow solver\n",
    "        self.__node_key_to_id = {}\n",
    "        self.__id_to_node_key = {}\n",
    "        for k, node_id in enumerate(node_ids):\n",
    "            self.__node_key_to_id[node_id]=k\n",
    "            self.__id_to_node_key[k]=node_id\n",
    "    \n",
    "    def import_channels(self,fp):\n",
    "        \"\"\"\n",
    "        This function does all the magic! \n",
    "        \n",
    "        It starts by importing the channel_graph from c-lightning listchannels command and then \n",
    "        it goes through the channels to find all node ids and max capacity (to make integer uncertainty cost)\n",
    "        in a second pass it goes over all channels and adds arcs to the modelled linearized network\n",
    "        for each channel N arcs are being added with increasing unit costs to mimic the convex behavior\n",
    "        the piecewise dissection is not optimal nor is the linear approximation of negative log probs exact\n",
    "        however this does not matter for the sake of argument the runtime will not change if the costs\n",
    "        are chosen a bit more optimally. But the code will blow up thus those simplifications\n",
    "        \"\"\"\n",
    "\n",
    "        channels = self.__get_channel_json(fp)\n",
    "        self.__prepare_integer_indices_for_nodes(channels)\n",
    "\n",
    "        self.__max_cap = 0\n",
    "        for c in channels:\n",
    "            cap = c[\"satoshis\"]\n",
    "            if cap > self.__max_cap:\n",
    "                self.__max_cap = cap\n",
    "\n",
    "        self.__arcs = {}\n",
    "        self.__parallel = {}\n",
    "        for c in channels:\n",
    "            cap = c[\"satoshis\"]\n",
    "            sid = c[\"short_channel_id\"]\n",
    "\n",
    "            src = self.__node_key_to_id[c[\"source\"]]\n",
    "            dest = self.__node_key_to_id[c[\"destination\"]]\n",
    "            cap = c[\"satoshis\"]\n",
    "\n",
    "            key = \"{}x{}x{}\".format(src,dest,sid)\n",
    "            base = c[\"base_fee_millisatoshi\"]\n",
    "            ppm = c[\"fee_per_millionth\"]\n",
    "            self.__arcs[key]=OracleChannel(cap,key,ppm,base)\n",
    "            arc = \"{}x{}\".format(src,dest)\n",
    "            if arc in self.__parallel:\n",
    "                self.__parallel[arc].append(key)\n",
    "            else:\n",
    "                self.__parallel[arc] = [key]\n",
    "\n",
    "\n",
    "    def arcs_to_networkx(self,base_threshold = None):\n",
    "        \"\"\"\n",
    "        stores the arcs also in networkx for fee computation and display of probabilities\n",
    "        \n",
    "        FIXME: it should actually be the other way around. First store the channel graph in \n",
    "        networkx and then compute the piece wise linearized arcs from this\n",
    "        \"\"\"\n",
    "        self.__channel_graph = nx.MultiDiGraph()\n",
    "        for channel in self.__arcs.values():\n",
    "            src, dest, height, index, out = channel.get_key().split(\"x\")\n",
    "            if base_threshold is not None:\n",
    "                if channel.get_base() > base_threshold:\n",
    "                    continue\n",
    "            self.__channel_graph.add_edge(int(src),int(dest),capacity=channel.get_capacity(),base=channel.get_base(),ppm=channel.get_ppm())\n",
    "           \n",
    "\n",
    "                \n",
    "    def theoretical_maximum_payable_amount(self, source, destination):\n",
    "        \"\"\"\n",
    "        Uses the information from the oracle to compute the min-cut between source and destination\n",
    "        \n",
    "        This is only useful for experiments and simulations if one wants to know what would be \n",
    "        possible to actually send before starting the payment loop\n",
    "        \"\"\"\n",
    "        self.__channel_graph = nx.MultiDiGraph()\n",
    "        for channel in self.__arcs.values():\n",
    "            src, dest, height, index, out = channel.get_key().split(\"x\")\n",
    "            if base_threshold is not None:\n",
    "                if channel.get_base() > base_threshold:\n",
    "                    continue\n",
    "            self.__channel_graph.add_edge(int(src),int(dest),capacity=channel.get_actual_liquidity(),base=channel.get_base(),ppm=channel.get_ppm())\n",
    "           \n",
    "        self.__G = nx.DiGraph()\n",
    "        for u,v,data in self.__channel_graph.edges(data=True):\n",
    "            if not self.__G.has_edge(u,v):\n",
    "                capacity = sum(d.get('capacity') for d in self.__channel_graph.get_edge_data(u,v).values())\n",
    "                self.__G.add_edge(u, v, capacity=capacity)\n",
    "        \n",
    "        mincut, _ = nx.minimum_cut(self.__G, self.__node_key_to_id[source], self.__node_key_to_id[destination])\n",
    "        return mincut\n",
    "    \n",
    "    def get_probability(self,src,dest,amt):\n",
    "        #FIXME: handle multi edges properly\n",
    "        #if not self.__channel_graph.has_edge(src,dest):\n",
    "        capacity = sum(d.get('capacity') for d in self.__channel_graph.get_edge_data(src,dest).values())\n",
    "        #else:\n",
    "        #    capacity = self.__channel_graph[src][dest][\"capacity\"]\n",
    "        if amt > capacity:\n",
    "            print(src,dest,self.__channel_graph.get_edge_data(src,dest))\n",
    "        return float(capacity+1-amt)/(capacity+1)\n",
    "\n",
    "            \n",
    "    def get_fees_msat(self,src,dest,amt):\n",
    "        #FIXME: handle multi edges properly\n",
    "        ppm = min(d.get('ppm') for d in self.__channel_graph.get_edge_data(src,dest).values())\n",
    "        base = min(d.get('base') for d in self.__channel_graph.get_edge_data(src,dest).values())\n",
    "        return int(base + float(amt * ppm)/1000) \n",
    "        \n",
    "    def test_path(self,path,amt):\n",
    "        probability = 1\n",
    "        fees = 0\n",
    "        success = True\n",
    "        for src,dest in next_hop(path):\n",
    "            fees += self.get_fees_msat(src,dest,amt)\n",
    "            probability *= self.get_probability(src,dest,amt)\n",
    "            key = \"{}x{}\".format(src,dest)\n",
    "            #FIXME: do not just take the first parallel channel\n",
    "            arc_key = self.__parallel[key][0]\n",
    "            if success:\n",
    "                success = self.__arcs[arc_key].update_knowledge(amt)\n",
    "            \n",
    "        return success, fees, probability\n",
    "    \n",
    "    def allocate_path(self,path,amt):\n",
    "        t,_,_ = self.test_path(path,amt)\n",
    "        if t == False:\n",
    "            return False\n",
    "        for src,dest in next_hop(path):\n",
    "            key = \"{}x{}\".format(src,dest)\n",
    "            #FIXME: do not just take the first parallel channel\n",
    "            arc_key = self.__parallel[key][0]\n",
    "            if success:\n",
    "                success = self.__arcs[arc_key].allocate_amount(amt)\n",
    "        \n",
    "        \n",
    "    def get_arcs(self):\n",
    "        return self.__arcs\n",
    "    \n",
    "    def look_up_id(self,node_id):\n",
    "        return self.__node_key_to_id[node_id]\n",
    "    \n",
    "    def get_uncertainty_network(self,start_node,mu,threshold_base =None):\n",
    "        #FIXME: find mu\n",
    "        start_node = self.__node_key_to_id[start_node]\n",
    "\n",
    "        max_cap = oracle.get_max_cap()\n",
    "        used_arcs = []\n",
    "        for key, channel in self.__arcs.items():\n",
    "            base = channel.get_base()\n",
    "            if threshold_base is not None:\n",
    "                if base > threshold_base:\n",
    "                    continue\n",
    "\n",
    "            cap = channel.get_capacity()\n",
    "            src,dest,_,_,_ = channel.get_key().split(\"x\")\n",
    "            src = int(src)\n",
    "            dest = int(dest)\n",
    "\n",
    "            is_own_channel = False\n",
    "            if src == start_node:\n",
    "                is_own_channel=True\n",
    "                \n",
    "            #FIXME: might need a fix if we account for HTLCs in flight but I guess this is just reduced from actual liqudity\n",
    "            if is_own_channel: #we know exactly how much liquidity we have in our channels\n",
    "                channel.set_min_liquidity(channel.get_actual_liquidity())\n",
    "                channel.set_min_liquidity(channel.get_actual_liquidity())\n",
    "\n",
    "            conditional_capacity = channel.get_max_liquidity() - channel.get_min_liquidity()\n",
    "            min_liquidity = channel.get_min_liquidity()\n",
    "            ppm = channel.get_ppm()\n",
    "            \n",
    "            if is_own_channel: #we don't have to pay ppm on our own channels\n",
    "                ppm = 0\n",
    "            \n",
    "            n = N\n",
    "            \n",
    "            #FIXME: prune expensive and unlikeli channels\n",
    "            #FIXME: compute smarter linearization eg: http://www.iaeng.org/publication/WCECS2008/WCECS2008_pp1191-1194.pdf            \n",
    "            #using certainly available liquidity costs us nothing but fees\n",
    "            if int(min_liquidity/QUANTIZATION) > 0:\n",
    "                used_arcs.append((src,dest,int(min_liquidity/QUANTIZATION),0 + mu*ppm))\n",
    "                n-=1\n",
    "\n",
    "            # FIXME: include the \n",
    "            if int(conditional_capacity/QUANTIZATION) > 0:\n",
    "                unit_cost = int(max_cap/conditional_capacity)\n",
    "                for i in range(n):\n",
    "                    #arc format is src, dest, capacity, unit_cost\n",
    "                    # THIS IS THE IMPORTANT LINE OF CODE WHERE THE MAGIC HAPPENS\n",
    "                    used_arcs.append((src,dest,int(conditional_capacity/(N*QUANTIZATION)),(i+1)*unit_cost +mu* ppm))\n",
    "        return used_arcs\n",
    "    \n",
    "    ##############################################################\n",
    "    #\n",
    "    #     needed for FOAF liquidity sharing  (BOLT 14 proposal)  \n",
    "    #\n",
    "    ##############################################################\n",
    "\n",
    "    def entropy(self):\n",
    "        return sum(arc.entropy() for _,arc in self.__arcs.items())\n",
    "    \n",
    "    \n",
    "    def activate_network_wide_uncertainty_reduction(self,n):\n",
    "        for arc in self.__arcs.values():\n",
    "            arc.learn_n_bits(n)\n",
    "            \n",
    "    def activate_foaf_uncertainty_reduction(self,src,dest):\n",
    "        ego_netwok=set()\n",
    "        foaf_network = set()\n",
    "\n",
    "        out_set = set()\n",
    "        edges = self.__channel_graph.out_edges(self.__node_key_to_id[src])\n",
    "        for edge in edges:\n",
    "            ego_netwok.add(\"{}x{}\".format(edge[0],edge[1]))\n",
    "            out_set.add(edge[1])\n",
    "        \n",
    "        for node in out_set:\n",
    "            edges = self.__channel_graph.out_edges(node)\n",
    "            for edge in edges:\n",
    "                foaf_network.add(\"{}x{}\".format(edge[0],edge[1]))\n",
    "\n",
    "        in_set = set()\n",
    "        edges = self.__channel_graph.in_edges(self.__node_key_to_id[dest])\n",
    "        for edge in edges:\n",
    "            ego_netwok.add(\"{}x{}\".format(edge[0],edge[1]))\n",
    "            in_set.add(edge[0])\n",
    "        \n",
    "        for node in in_set:\n",
    "            edges = self.__channel_graph.out_edges(node)\n",
    "            for edge in edges:\n",
    "                foaf_network.add(\"{}x{}\".format(edge[0],edge[1]))\n",
    "                \n",
    "                \n",
    "        #print(len(ego_netwok))\n",
    "        for k,arc in self.__arcs.items():\n",
    "            #print(k)\n",
    "            vals = k.split(\"x\")\n",
    "            key = \"{}x{}\".format(vals[0],vals[1])\n",
    "            if key in ego_netwok:\n",
    "                l = arc.get_actual_liquidity()\n",
    "                arc.update_knowledge(l-1)\n",
    "                arc.update_knowledge(l+1)\n",
    "                #print(key,arc.entropy())\n",
    "            \n",
    "            if key in foaf_network:\n",
    "                arc.learn_n_bits(2)\n",
    "                l = arc.get_actual_liquidity()\n",
    "                arc.update_knowledge(l-1)\n",
    "                arc.update_knowledge(l+1)\n",
    "                #print(key, arc.entropy())\n",
    "        print(\"channels with full knowlege: \", len(ego_netwok))\n",
    "        print(\"channels with 2 Bits of less entropy: \", len(foaf_network))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Define some helper functions to prepare experiments"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_mcf_solver(src, dest,amt, mu=0, base=0):\n",
    "    \"\"\"\n",
    "    computes the uncertainty network given our prior belief and prepares the min cost flow solver\n",
    "    \n",
    "    This function can define a value for \\mu to control how heavily we combine the uncertainty cost and fees\n",
    "    Also the function supports only taking channels into account that don't charge a base_fee higher or equal to `base`\n",
    "\n",
    "    returns the instantiated min_cost_flow object from the google OR-lib that contains the piecewise linearized problem\n",
    "    \"\"\"\n",
    "    used_arcs = oracle.get_uncertainty_network(src,mu,base)\n",
    "    oracle.arcs_to_networkx(base)\n",
    "    min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n",
    "\n",
    "    # Add each of the prepared arcs from import_channels().\n",
    "    node_ids = set()\n",
    "    for arc in used_arcs:\n",
    "        node_ids.add(arc[0])\n",
    "        node_ids.add(arc[1])\n",
    "        min_cost_flow.AddArcWithCapacityAndUnitCost(arc[0], arc[1], arc[2],\n",
    "                                                    arc[3])\n",
    "\n",
    "    # Add node supply to 0 for all nodes\n",
    "    for i in node_ids:\n",
    "        min_cost_flow.SetNodeSupply(i, 0)\n",
    "\n",
    "    #add amount to sending node\n",
    "    min_cost_flow.SetNodeSupply(oracle.look_up_id(src),int(amt/QUANTIZATION))\n",
    "\n",
    "    #add -amount to recipient nods\n",
    "    min_cost_flow.SetNodeSupply(oracle.look_up_id(dest),-int(amt/QUANTIZATION))\n",
    "    return min_cost_flow\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def disect_flow_to_paths(min_cost_flow,s,d):\n",
    "    \"\"\"\n",
    "    A standard algorithm to disect a flow into several paths.\n",
    "    \n",
    "    FIXME: Note that this disection while accurate is probably not optimal in practise. \n",
    "    As noted in our Probabilistic payment delivery paper the payment process is a bernoulli trial \n",
    "    and I assume it makes sense to disect the flow into paths of similar likelihood to make most\n",
    "    progress but this is a mere conjecture at this point. I expect quite a bit of research will be\n",
    "    necessary to resolve this issue.\n",
    "    \"\"\"\n",
    "    total_flow = {}\n",
    "\n",
    "    #first collect all linearized edges which are assigned a non zero flow\n",
    "    for i in range(min_cost_flow.NumArcs()):\n",
    "        if min_cost_flow.Flow(i) == 0:\n",
    "            continue\n",
    "        src = min_cost_flow.Tail(i)\n",
    "        dest = min_cost_flow.Head(i)\n",
    "        flow = min_cost_flow.Flow(i)*QUANTIZATION\n",
    "\n",
    "        key = str(src)+\":\"+str(dest)\n",
    "        if key in total_flow:\n",
    "            total_flow[key]=(src,dest,total_flow[key][2]+flow)\n",
    "        else:\n",
    "            total_flow[key]=(src,dest,flow)\n",
    "    \n",
    "    \n",
    "    G = nx.DiGraph()\n",
    "    for key, val in total_flow.items():\n",
    "        src, dest, flow = val\n",
    "        G.add_edge(src,dest,weight=flow)\n",
    "\n",
    "    m = 1\n",
    "    paths = []\n",
    "    while m>0:\n",
    "        try: \n",
    "            path = nx.shortest_path(G,s,d)\n",
    "            m = min(G[src][dest][\"weight\"] for src, dest in next_hop(path))\n",
    "            #t+=m\n",
    "            #print(\"{} sats along {}\".format(m*10000,path_str(path)))\n",
    "            paths.append((path,m))\n",
    "            for src,dest in next_hop(path):\n",
    "                G[src][dest][\"weight\"]-=m\n",
    "                if G[src][dest][\"weight\"]==0:\n",
    "                    G.remove_edge(src,dest)\n",
    "        except: \n",
    "            break\n",
    "    return paths\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "def make_attempt(src, dest, amt,mu,base):\n",
    "    \"\"\"\n",
    "    computes the optimal payment split to deliver `amt` from `src` to `dest` and updates our belief about the liquidity\n",
    "    \n",
    "    This is one step within the payment loop.\n",
    "    \n",
    "    Retuns the residual amount of the `amt` that could ne be delivered and the paid fees\n",
    "    (on a per channel base not including fees for downstream fees) for the delivered amount\n",
    "    \n",
    "    the function also prints some results an statistics about the paths of the flow to stdout.\n",
    "    \"\"\"\n",
    "    start = time.time()\n",
    "\n",
    "    mcf = prepare_mcf_solver(src,dest,amt,mu,base)   \n",
    "\n",
    "    status = mcf.Solve()\n",
    "\n",
    "\n",
    "    if status != mcf.OPTIMAL:\n",
    "        print('There was an issue with the min cost flow input.')\n",
    "        print(f'Status: {status}')\n",
    "        exit(1)\n",
    "\n",
    "    paths = disect_flow_to_paths(mcf,oracle.look_up_id(src),oracle.look_up_id(dest))\n",
    "    #print(paths)    \n",
    "\n",
    "    end = time.time()\n",
    "    print(\"\\\\mu: {} \\nRuntime of flow computation: {:4.2f} sec \".format(mu, end-start))\n",
    "\n",
    "    total_fees = 0\n",
    "    paid_fees = 0\n",
    "    residual_amt = 0\n",
    "    number_failed_paths = 0\n",
    "    for path in paths:\n",
    "        success, fee, probability = oracle.test_path(path[0],path[1])\n",
    "        fee /= 1000.\n",
    "        total_fees += fee\n",
    "        print(\"Success: {} \\t fee: {:8.3f}msat \\t p = {:5.2f}%   amt: {:7}sats path hops: {}\".\n",
    "              format(success, fee, probability*100, path[1], len(path[0])))\n",
    "        if success == False:\n",
    "            number_failed_paths += 1\n",
    "            residual_amt += path[1]\n",
    "        else:\n",
    "            paid_fees += fee\n",
    "\n",
    "    print(\"total_fee: {:8.3f} msat \\t paid fees: {:8.3f} msat\".format(total_fees, paid_fees))\n",
    "    return residual_amt, paid_fees, len(paths), number_failed_paths\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def run_pickhardt_payments_experiment(oracle,src,dest,amt,mu=1,base=0):\n",
    "    \"\"\"\n",
    "    conduct one experiment! might need to call oracle.reset_uncertainty_network() first\n",
    "    I could not put it here as some experiments require sharing of liqudity information\n",
    "\n",
    "    \"\"\"\n",
    "    entropy_start=oracle.entropy()\n",
    "    start = time.time()\n",
    "    full_amt = amt\n",
    "    cnt = 0\n",
    "    total_fees = 0\n",
    "    number_number_of_onions = 0\n",
    "    total_number_failed_paths = 0\n",
    "    while amt > 0 and cnt < 10:\n",
    "        print(\"\\nTry: \", amt, \" sats. Round number: \", cnt+1)\n",
    "        amt, paid_fees, num_paths, number_failed_paths = make_attempt(src,dest,amt,mu,base)\n",
    "        number_number_of_onions += num_paths\n",
    "        total_number_failed_paths+=number_failed_paths\n",
    "        total_fees += paid_fees\n",
    "        cnt+=1\n",
    "    end = time.time()\n",
    "    entropy_end = oracle.entropy()\n",
    "    print(\"\\nSUMMARY:\")\n",
    "    print(\"Rounds of mcf-computations: \", cnt)\n",
    "    print(\"Number of onions sent: \", number_number_of_onions)\n",
    "    print(\"Number of failed onions: \", total_number_failed_paths, \" failure rate: {:4.2f}% \".format(total_number_failed_paths*100./number_number_of_onions))\n",
    "    print(\"total runtime (including inefficient memory managment): {:4.3f} sec\".format(end-start))\n",
    "    print(\"Learnt entropy: {:5.2f} bits\".format(entropy_start-entropy_end))\n",
    "    print(\"Fees for successfull delivery: {:8.3f} sat --> {} ppm\".format(total_fees,int(total_fees*1000*1000/full_amt)))\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Conducting experiments\n",
    "\n",
    "We now use our sequential simulation of the uncertainty network to coduct a few experiments. In all cases we try to deliver Payments from Rene's node to Carsten Otto (who is working on an alternative implementation) on a recent snapshot of the channel graph.\n",
    "\n",
    "In the experiments we first want to study a few things: \n",
    "\n",
    "1. What happens if we mainly optimize for high success probability\n",
    "2. What happens if we optimize for both success probability and fees\n",
    "3. what happens if we optimize mainly for fees\n",
    "4. How much better is the delivery of payments if we globaly would know 2 bits of information on alle channels\n",
    "5. What is the effect of the BOLT 14 proposal to reliability where nodes would share liquidity information of their direct peers\n",
    "6. MISSING: How is the difference in paid fee and payment attempts with different focus on various features (selection of \\mu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Rene Pickhardt's public node_key\n",
    "RENE = \"03efccf2c383d7bf340da9a3f02e2c23104a0e4fe8ac1a880c8e2dc92fbdacd9df\"\n",
    "#Carsten Otto's public node key\n",
    "C_OTTO = \"027ce055380348d7812d2ae7745701c9f93e70c1adeb2657f053f91df4f2843c71\"\n",
    "\n",
    "AMT = 50*1000*1000\n",
    "N = 5\n",
    "QUANTIZATION=10000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "channels with full knowlege:  215\n",
      "channels with 2 Bits of less entropy:  8750\n"
     ]
    }
   ],
   "source": [
    "oracle = Oracle()\n",
    "oracle.import_channels(\"listchannels20211028.json\")\n",
    "\n",
    "#we only conduct the computation on the channels that have a basefee of 0\n",
    "oracle.arcs_to_networkx(0)\n",
    "oracle.activate_foaf_uncertainty_reduction(RENE,C_OTTO)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "OPTIMIZE FOR soly for RELIABILITY\n",
      "\n",
      "Try:  50000000  sats. Round number:  1\n",
      "\\mu: 0 \n",
      "Runtime of flow computation: 1.43 sec \n",
      "Success: True \t fee: 6153.950msat \t p = 64.05%   amt: 3350000sats path hops: 3\n",
      "Success: True \t fee: 2152.570msat \t p = 29.87%   amt: 1610000sats path hops: 3\n",
      "Success: True \t fee: 3374.000msat \t p = 69.33%   amt: 2000000sats path hops: 3\n",
      "Success: True \t fee:  312.290msat \t p = 89.94%   amt:  170000sats path hops: 3\n",
      "Success: False \t fee: 12752.550msat \t p = 47.10%   amt: 7650000sats path hops: 3\n",
      "Success: True \t fee:   18.370msat \t p = 96.10%   amt:   10000sats path hops: 4\n",
      "Success: True \t fee: 3248.960msat \t p = 43.40%   amt: 1430000sats path hops: 4\n",
      "Success: True \t fee:  949.000msat \t p = 87.99%   amt:  500000sats path hops: 4\n",
      "Success: True \t fee: 1423.500msat \t p = 22.80%   amt:  750000sats path hops: 4\n",
      "Success: True \t fee: 2738.630msat \t p = 28.11%   amt: 1370000sats path hops: 4\n",
      "Success: True \t fee: 4052.290msat \t p = 82.72%   amt: 1870000sats path hops: 4\n",
      "Success: False \t fee: 37961.370msat \t p = 35.89%   amt: 9110000sats path hops: 4\n",
      "Success: True \t fee: 21620.230msat \t p = 55.79%   amt: 5290000sats path hops: 5\n",
      "Success: True \t fee: 1617.850msat \t p = 25.35%   amt:  650000sats path hops: 5\n",
      "Success: True \t fee: 1937.360msat \t p = 50.20%   amt: 1220000sats path hops: 5\n",
      "Success: True \t fee:  260.910msat \t p = 79.14%   amt:  130000sats path hops: 5\n",
      "Success: False \t fee: 13636.480msat \t p = 32.44%   amt: 7040000sats path hops: 5\n",
      "Success: True \t fee: 2300.160msat \t p = 68.51%   amt: 1280000sats path hops: 5\n",
      "Success: True \t fee: 6468.850msat \t p = 41.34%   amt: 3350000sats path hops: 5\n",
      "Success: True \t fee: 1515.150msat \t p = 88.25%   amt:  650000sats path hops: 6\n",
      "Success: True \t fee: 2757.090msat \t p = 90.46%   amt:  570000sats path hops: 7\n",
      "total_fee: 127251.560 msat \t paid fees: 62901.160 msat\n",
      "\n",
      "Try:  23800000  sats. Round number:  2\n",
      "\\mu: 0 \n",
      "Runtime of flow computation: 0.79 sec \n",
      "Success: True \t fee: 6153.950msat \t p = 64.05%   amt: 3350000sats path hops: 3\n",
      "Success: True \t fee: 2152.570msat \t p = 29.87%   amt: 1610000sats path hops: 3\n",
      "Success: True \t fee: 3374.000msat \t p = 69.33%   amt: 2000000sats path hops: 3\n",
      "Success: True \t fee:  312.290msat \t p = 89.94%   amt:  170000sats path hops: 3\n",
      "Success: True \t fee: 4284.190msat \t p = 80.86%   amt: 2570000sats path hops: 3\n",
      "Success: True \t fee:   18.370msat \t p = 96.10%   amt:   10000sats path hops: 4\n",
      "Success: True \t fee: 3248.960msat \t p = 43.40%   amt: 1430000sats path hops: 4\n",
      "Success: True \t fee: 2738.630msat \t p = 28.11%   amt: 1370000sats path hops: 4\n",
      "Success: True \t fee: 4052.290msat \t p = 82.72%   amt: 1870000sats path hops: 4\n",
      "Success: True \t fee:  166.680msat \t p = 99.66%   amt:   40000sats path hops: 4\n",
      "Success: True \t fee:  759.200msat \t p = 90.32%   amt:  400000sats path hops: 4\n",
      "Success: True \t fee:  664.300msat \t p = 62.30%   amt:  350000sats path hops: 4\n",
      "Success: True \t fee: 15121.900msat \t p = 67.67%   amt: 3700000sats path hops: 5\n",
      "Success: True \t fee: 1617.850msat \t p = 25.35%   amt:  650000sats path hops: 5\n",
      "Success: True \t fee:  260.910msat \t p = 79.14%   amt:  130000sats path hops: 5\n",
      "Success: True \t fee: 1437.600msat \t p = 79.81%   amt:  800000sats path hops: 5\n",
      "Success: True \t fee: 6468.850msat \t p = 41.34%   amt: 3350000sats path hops: 5\n",
      "total_fee: 52832.540 msat \t paid fees: 52832.540 msat\n",
      "\n",
      "SUMMARY:\n",
      "Rounds of mcf-computations:  2\n",
      "Number of onions sent:  38\n",
      "Number of failed onions:  3  failure rate: 7.89% \n",
      "total runtime (including inefficient memory managment): 2.223 sec\n",
      "Learnt entropy: 157.24 bits\n",
      "Fees for successfull delivery: 115733.700 sat --> 2314 ppm\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print(\"OPTIMIZE FOR soly for RELIABILITY\")\n",
    "oracle.reset_uncertainty_network()\n",
    "run_pickhardt_payments_experiment(oracle,RENE,C_OTTO,AMT,mu=0,base=0)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "OTPTIMIZE RELIABILITY AND FEES\n",
      "\n",
      "Try:  50000000  sats. Round number:  1\n",
      "\\mu: 1 \n",
      "Runtime of flow computation: 1.23 sec \n",
      "Success: False \t fee: 14652.900msat \t p = 16.08%   amt: 10050000sats path hops: 3\n",
      "Success: True \t fee: 6631.570msat \t p = 61.60%   amt: 3610000sats path hops: 3\n",
      "Success: True \t fee: 2060.480msat \t p = 23.93%   amt: 1370000sats path hops: 3\n",
      "Success: True \t fee: 1537.000msat \t p = 64.00%   amt: 1000000sats path hops: 3\n",
      "Success: True \t fee:  908.700msat \t p = 23.40%   amt:  650000sats path hops: 3\n",
      "Success: True \t fee: 2152.570msat \t p = 29.87%   amt: 1610000sats path hops: 3\n",
      "Success: True \t fee: 6748.000msat \t p = 44.00%   amt: 4000000sats path hops: 3\n",
      "Success: True \t fee: 1153.600msat \t p = 60.00%   amt:  800000sats path hops: 3\n",
      "Success: True \t fee:  312.290msat \t p = 89.94%   amt:  170000sats path hops: 3\n",
      "Success: True \t fee: 3454.770msat \t p = 75.12%   amt: 2090000sats path hops: 4\n",
      "Success: True \t fee:   18.370msat \t p = 96.10%   amt:   10000sats path hops: 4\n",
      "Success: False \t fee: 15743.040msat \t p = 29.51%   amt: 9920000sats path hops: 4\n",
      "Success: True \t fee: 2108.160msat \t p = 67.86%   amt: 1280000sats path hops: 4\n",
      "Success: True \t fee:  900.350msat \t p = 78.34%   amt:  550000sats path hops: 4\n",
      "Success: True \t fee: 1993.620msat \t p = 36.45%   amt: 1490000sats path hops: 4\n",
      "Success: False \t fee: 3392.260msat \t p = 63.59%   amt: 2260000sats path hops: 4\n",
      "Success: True \t fee: 5067.000msat \t p = 51.20%   amt: 3000000sats path hops: 4\n",
      "Success: False \t fee:  991.600msat \t p = 39.26%   amt:  740000sats path hops: 4\n",
      "Success: True \t fee: 1617.000msat \t p = 50.67%   amt: 1000000sats path hops: 4\n",
      "Success: True \t fee: 3236.000msat \t p = 56.47%   amt: 2000000sats path hops: 4\n",
      "Success: True \t fee:  407.680msat \t p = 69.08%   amt:  260000sats path hops: 4\n",
      "Success: True \t fee: 1518.000msat \t p = 70.81%   amt: 1000000sats path hops: 4\n",
      "Success: False \t fee: 1524.000msat \t p = 37.50%   amt: 1000000sats path hops: 4\n",
      "Success: True \t fee:  191.660msat \t p = 91.92%   amt:  140000sats path hops: 5\n",
      "total_fee: 78320.620 msat \t paid fees: 42016.820 msat\n",
      "\n",
      "Try:  23970000  sats. Round number:  2\n",
      "\\mu: 1 \n",
      "Runtime of flow computation: 1.37 sec \n",
      "Success: True \t fee: 2930.580msat \t p = 77.47%   amt: 2010000sats path hops: 3\n",
      "Success: True \t fee: 2060.480msat \t p = 23.93%   amt: 1370000sats path hops: 3\n",
      "Success: True \t fee: 1537.000msat \t p = 64.00%   amt: 1000000sats path hops: 3\n",
      "Success: True \t fee:  908.700msat \t p = 23.40%   amt:  650000sats path hops: 3\n",
      "Success: True \t fee: 2152.570msat \t p = 29.87%   amt: 1610000sats path hops: 3\n",
      "Success: True \t fee: 4622.380msat \t p = 59.34%   amt: 2740000sats path hops: 3\n",
      "Success: True \t fee: 1153.600msat \t p = 60.00%   amt:  800000sats path hops: 3\n",
      "Success: True \t fee: 3454.770msat \t p = 75.12%   amt: 2090000sats path hops: 4\n",
      "Success: True \t fee: 8538.060msat \t p = 57.36%   amt: 5380000sats path hops: 4\n",
      "Success: True \t fee: 2108.160msat \t p = 67.86%   amt: 1280000sats path hops: 4\n",
      "Success: True \t fee:  900.350msat \t p = 78.34%   amt:  550000sats path hops: 4\n",
      "Success: True \t fee: 1617.000msat \t p = 50.67%   amt: 1000000sats path hops: 4\n",
      "Success: True \t fee:  970.800msat \t p = 85.24%   amt:  600000sats path hops: 4\n",
      "Success: True \t fee:  407.680msat \t p = 69.08%   amt:  260000sats path hops: 4\n",
      "Success: True \t fee: 1518.000msat \t p = 70.81%   amt: 1000000sats path hops: 4\n",
      "Success: True \t fee: 1996.600msat \t p = 32.83%   amt: 1490000sats path hops: 5\n",
      "Success: True \t fee:  191.660msat \t p = 91.92%   amt:  140000sats path hops: 5\n",
      "total_fee: 37068.390 msat \t paid fees: 37068.390 msat\n",
      "\n",
      "SUMMARY:\n",
      "Rounds of mcf-computations:  2\n",
      "Number of onions sent:  41\n",
      "Number of failed onions:  5  failure rate: 12.20% \n",
      "total runtime (including inefficient memory managment): 2.609 sec\n",
      "Learnt entropy: 166.14 bits\n",
      "Fees for successfull delivery: 79085.210 sat --> 1581 ppm\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n\\nOTPTIMIZE RELIABILITY AND FEES\")\n",
    "oracle.reset_uncertainty_network()\n",
    "run_pickhardt_payments_experiment(oracle,RENE,C_OTTO,AMT,mu=1,base=0)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "OTPTIMIZE MAINLY FOR FEES\n",
      "\n",
      "Try:  50000000  sats. Round number:  1\n",
      "\\mu: 100 \n",
      "Runtime of flow computation: 1.28 sec \n",
      "Success: True \t fee: 8354.340msat \t p = 43.36%   amt: 5730000sats path hops: 3\n",
      "Success: True \t fee: 1338.560msat \t p = 46.83%   amt:  890000sats path hops: 3\n",
      "Success: True \t fee: 1089.600msat \t p = 44.00%   amt:  800000sats path hops: 3\n",
      "Success: False \t fee: 1087.200msat \t p = 10.57%   amt:  800000sats path hops: 3\n",
      "Success: False \t fee: 3061.730msat \t p =  6.48%   amt: 2290000sats path hops: 3\n",
      "Success: False \t fee: 4037.600msat \t p =  3.75%   amt: 2800000sats path hops: 3\n",
      "Success: True \t fee:  318.340msat \t p = 47.75%   amt:  220000sats path hops: 4\n",
      "Success: False \t fee:  230.080msat \t p = 51.83%   amt:  160000sats path hops: 4\n",
      "Success: False \t fee:  386.370msat \t p = 45.34%   amt:  270000sats path hops: 4\n",
      "Success: False \t fee:  675.000msat \t p = 44.44%   amt:  500000sats path hops: 4\n",
      "Success: True \t fee:  409.200msat \t p = 66.46%   amt:  300000sats path hops: 4\n",
      "Success: False \t fee:  539.200msat \t p = 38.40%   amt:  400000sats path hops: 4\n",
      "Success: False \t fee: 1078.400msat \t p = 40.48%   amt:  800000sats path hops: 4\n",
      "Success: False \t fee: 3625.980msat \t p =  5.14%   amt: 2710000sats path hops: 4\n",
      "Success: True \t fee:   66.900msat \t p = 78.60%   amt:   50000sats path hops: 4\n",
      "Success: False \t fee: 1144.570msat \t p = 10.26%   amt:  830000sats path hops: 4\n",
      "Success: True \t fee:  256.310msat \t p = 19.19%   amt:  190000sats path hops: 4\n",
      "Success: True \t fee:  354.900msat \t p = 78.08%   amt:  260000sats path hops: 4\n",
      "Success: False \t fee: 1795.600msat \t p =  6.46%   amt: 1340000sats path hops: 4\n",
      "Success: True \t fee:  576.000msat \t p = 40.49%   amt:  400000sats path hops: 5\n",
      "Success: True \t fee:  492.660msat \t p = 41.10%   amt:  340000sats path hops: 5\n",
      "Success: True \t fee:  407.100msat \t p = 56.07%   amt:  300000sats path hops: 5\n",
      "Success: False \t fee:  896.280msat \t p = 32.70%   amt:  660000sats path hops: 5\n",
      "Success: False \t fee: 5668.000msat \t p =  0.00%   amt: 4000000sats path hops: 5\n",
      "Success: False \t fee:  567.600msat \t p = 55.65%   amt:  400000sats path hops: 5\n",
      "Success: False \t fee:  769.500msat \t p = 56.77%   amt:  540000sats path hops: 5\n",
      "Success: True \t fee:  818.400msat \t p = 18.28%   amt:  600000sats path hops: 5\n",
      "Success: True \t fee:  335.250msat \t p = 16.30%   amt:  250000sats path hops: 5\n",
      "Success: False \t fee: 1537.920msat \t p =  5.94%   amt: 1080000sats path hops: 5\n",
      "Success: False \t fee: 2831.520msat \t p = 22.21%   amt: 2040000sats path hops: 5\n",
      "Success: True \t fee:  278.000msat \t p = 74.26%   amt:  200000sats path hops: 5\n",
      "Success: True \t fee:  102.760msat \t p = 96.14%   amt:   70000sats path hops: 5\n",
      "Success: True \t fee:  293.600msat \t p = 59.68%   amt:  200000sats path hops: 5\n",
      "Success: False \t fee:   81.660msat \t p = 65.60%   amt:   60000sats path hops: 6\n",
      "Success: True \t fee: 1011.050msat \t p =  5.76%   amt:  730000sats path hops: 6\n",
      "Success: True \t fee:  271.600msat \t p = 63.79%   amt:  200000sats path hops: 6\n",
      "Success: False \t fee: 5399.800msat \t p =  2.76%   amt: 3800000sats path hops: 6\n",
      "Success: True \t fee:  177.060msat \t p = 75.11%   amt:  130000sats path hops: 6\n",
      "Success: True \t fee:  190.540msat \t p = 41.79%   amt:  140000sats path hops: 6\n",
      "Success: True \t fee:   54.520msat \t p = 80.83%   amt:   40000sats path hops: 6\n",
      "Success: False \t fee: 4307.100msat \t p =  8.05%   amt: 2930000sats path hops: 6\n",
      "Success: True \t fee:  744.660msat \t p = 39.85%   amt:  540000sats path hops: 6\n",
      "Success: False \t fee:  272.000msat \t p = 47.11%   amt:  200000sats path hops: 6\n",
      "Success: False \t fee:  166.800msat \t p = 33.26%   amt:  120000sats path hops: 6\n",
      "Success: True \t fee:   40.530msat \t p = 73.18%   amt:   30000sats path hops: 7\n",
      "Success: False \t fee:  348.920msat \t p =  4.37%   amt:  260000sats path hops: 7\n",
      "Success: True \t fee:  122.580msat \t p = 58.86%   amt:   90000sats path hops: 7\n",
      "Success: False \t fee:  682.560msat \t p = 60.01%   amt:  480000sats path hops: 7\n",
      "Success: True \t fee:   69.100msat \t p = 37.10%   amt:   50000sats path hops: 7\n",
      "Success: True \t fee:  138.300msat \t p = 60.54%   amt:  100000sats path hops: 7\n",
      "Success: False \t fee:  135.900msat \t p = 78.69%   amt:  100000sats path hops: 7\n",
      "Success: False \t fee:  588.400msat \t p = 46.70%   amt:  400000sats path hops: 7\n",
      "Success: False \t fee: 2778.000msat \t p = 14.66%   amt: 2000000sats path hops: 7\n",
      "Success: True \t fee:   85.260msat \t p = 94.30%   amt:   60000sats path hops: 7\n",
      "Success: True \t fee: 1799.590msat \t p = 32.64%   amt: 1270000sats path hops: 7\n",
      "Success: True \t fee:  254.980msat \t p = 68.01%   amt:  190000sats path hops: 7\n",
      "Success: True \t fee:   26.840msat \t p = 73.70%   amt:   20000sats path hops: 7\n",
      "Success: True \t fee:  308.200msat \t p = 54.63%   amt:  230000sats path hops: 7\n",
      "Success: True \t fee:  230.350msat \t p = 61.96%   amt:  170000sats path hops: 7\n",
      "Success: True \t fee:  312.110msat \t p = 57.58%   amt:  230000sats path hops: 8\n",
      "Success: False \t fee:  135.200msat \t p = 67.64%   amt:  100000sats path hops: 8\n",
      "Success: False \t fee: 1472.000msat \t p = 40.64%   amt: 1000000sats path hops: 8\n",
      "Success: False \t fee:  536.800msat \t p = 23.29%   amt:  400000sats path hops: 9\n",
      "Success: True \t fee:  138.500msat \t p = 57.06%   amt:  100000sats path hops: 10\n",
      "Success: True \t fee:  425.320msat \t p = 55.58%   amt:  310000sats path hops: 10\n",
      "Success: False \t fee:  712.920msat \t p = 29.03%   amt:  520000sats path hops: 10\n",
      "Success: False \t fee:  537.810msat \t p = 43.65%   amt:  390000sats path hops: 10\n",
      "Success: True \t fee:  138.400msat \t p = 48.69%   amt:  100000sats path hops: 10\n",
      "Success: True \t fee:   84.600msat \t p = 69.93%   amt:   60000sats path hops: 11\n",
      "Success: True \t fee:   42.240msat \t p = 84.00%   amt:   30000sats path hops: 12\n",
      "total_fee: 70246.670 msat \t paid fees: 22158.250 msat\n",
      "\n",
      "Try:  34380000  sats. Round number:  2\n",
      "\\mu: 100 \n",
      "Runtime of flow computation: 1.22 sec \n",
      "Success: True \t fee: 9360.360msat \t p = 38.11%   amt: 6420000sats path hops: 3\n",
      "Success: True \t fee: 1416.480msat \t p = 31.36%   amt: 1040000sats path hops: 3\n",
      "Success: False \t fee:  706.680msat \t p = 34.37%   amt:  520000sats path hops: 3\n",
      "Success: False \t fee: 2847.810msat \t p = 11.65%   amt: 2130000sats path hops: 3\n",
      "Success: False \t fee: 3662.680msat \t p =  7.53%   amt: 2540000sats path hops: 3\n",
      "Success: True \t fee:  318.340msat \t p = 47.75%   amt:  220000sats path hops: 4\n",
      "Success: True \t fee:  100.170msat \t p = 84.19%   amt:   70000sats path hops: 4\n",
      "Success: True \t fee:  135.000msat \t p = 86.61%   amt:  100000sats path hops: 4\n",
      "Success: True \t fee:  409.200msat \t p = 66.46%   amt:  300000sats path hops: 4\n",
      "Success: False \t fee:  215.680msat \t p = 85.70%   amt:  160000sats path hops: 4\n",
      "Success: False \t fee: 3304.860msat \t p = 10.02%   amt: 2470000sats path hops: 4\n",
      "Success: True \t fee:   66.900msat \t p = 78.60%   amt:   50000sats path hops: 4\n",
      "Success: False \t fee: 1034.250msat \t p = 15.94%   amt:  750000sats path hops: 4\n",
      "Success: True \t fee:  256.310msat \t p = 19.19%   amt:  190000sats path hops: 4\n",
      "Success: False \t fee: 1119.300msat \t p = 40.53%   amt:  820000sats path hops: 4\n",
      "Success: False \t fee: 1581.200msat \t p = 13.86%   amt: 1180000sats path hops: 4\n",
      "Success: True \t fee:  576.000msat \t p = 40.49%   amt:  400000sats path hops: 5\n",
      "Success: True \t fee:  492.660msat \t p = 41.10%   amt:  340000sats path hops: 5\n",
      "Success: True \t fee:  203.550msat \t p = 75.85%   amt:  150000sats path hops: 5\n",
      "Success: False \t fee: 3953.430msat \t p =  9.29%   amt: 2790000sats path hops: 5\n",
      "Success: False \t fee:  113.520msat \t p = 90.64%   amt:   80000sats path hops: 5\n",
      "Success: True \t fee:  818.400msat \t p = 18.28%   amt:  600000sats path hops: 5\n",
      "Success: True \t fee:  335.250msat \t p = 16.30%   amt:  250000sats path hops: 5\n",
      "Success: False \t fee:  854.400msat \t p = 30.42%   amt:  600000sats path hops: 5\n",
      "Success: True \t fee:  777.280msat \t p = 70.27%   amt:  560000sats path hops: 5\n",
      "Success: True \t fee:  278.000msat \t p = 74.26%   amt:  200000sats path hops: 5\n",
      "Success: False \t fee: 1542.240msat \t p = 10.77%   amt: 1120000sats path hops: 5\n",
      "Success: True \t fee:  138.100msat \t p = 60.94%   amt:  100000sats path hops: 6\n",
      "Success: True \t fee:  998.640msat \t p = 57.85%   amt:  720000sats path hops: 6\n",
      "Success: True \t fee:   40.500msat \t p = 73.70%   amt:   30000sats path hops: 6\n",
      "Success: False \t fee:  214.560msat \t p = 26.04%   amt:  160000sats path hops: 6\n",
      "Success: True \t fee: 1011.050msat \t p =  5.76%   amt:  730000sats path hops: 6\n",
      "Success: True \t fee:  163.320msat \t p = 48.77%   amt:  120000sats path hops: 6\n",
      "Success: True \t fee:  108.640msat \t p = 84.20%   amt:   80000sats path hops: 6\n",
      "Success: True \t fee:   54.520msat \t p = 80.83%   amt:   40000sats path hops: 6\n",
      "Success: True \t fee:  122.580msat \t p = 82.30%   amt:   90000sats path hops: 6\n",
      "Success: True \t fee: 1989.400msat \t p = 38.52%   amt: 1400000sats path hops: 6\n",
      "Success: False \t fee:  149.820msat \t p = 51.19%   amt:  110000sats path hops: 7\n",
      "Success: False \t fee: 1716.990msat \t p = 42.37%   amt: 1210000sats path hops: 7\n",
      "Success: True \t fee:   54.120msat \t p = 92.57%   amt:   40000sats path hops: 7\n",
      "Success: True \t fee:   69.100msat \t p = 37.10%   amt:   50000sats path hops: 7\n",
      "Success: True \t fee:  111.120msat \t p = 93.94%   amt:   80000sats path hops: 7\n",
      "Success: True \t fee:   85.260msat \t p = 94.30%   amt:   60000sats path hops: 7\n",
      "Success: True \t fee: 2564.770msat \t p = 18.47%   amt: 1810000sats path hops: 7\n",
      "Success: True \t fee:  268.400msat \t p = 66.54%   amt:  200000sats path hops: 7\n",
      "Success: True \t fee:  312.110msat \t p = 59.01%   amt:  230000sats path hops: 7\n",
      "Success: True \t fee:   26.840msat \t p = 73.70%   amt:   20000sats path hops: 7\n",
      "Success: True \t fee:   67.450msat \t p = 89.50%   amt:   50000sats path hops: 8\n",
      "Success: True \t fee:   13.470msat \t p = 97.94%   amt:   10000sats path hops: 8\n",
      "Success: True \t fee:  271.000msat \t p = 74.22%   amt:  200000sats path hops: 8\n",
      "Success: True \t fee:   26.840msat \t p = 94.31%   amt:   20000sats path hops: 8\n",
      "Success: True \t fee:  138.500msat \t p = 57.06%   amt:  100000sats path hops: 10\n",
      "Success: True \t fee:  285.000msat \t p = 70.23%   amt:  200000sats path hops: 10\n",
      "Success: True \t fee:  275.400msat \t p = 67.89%   amt:  200000sats path hops: 10\n",
      "Success: True \t fee:  151.250msat \t p = 76.32%   amt:  110000sats path hops: 10\n",
      "Success: True \t fee:  138.000msat \t p = 46.62%   amt:  100000sats path hops: 10\n",
      "Success: True \t fee:   28.120msat \t p = 88.34%   amt:   20000sats path hops: 11\n",
      "Success: True \t fee:   56.320msat \t p = 79.11%   amt:   40000sats path hops: 12\n",
      "total_fee: 48131.140 msat \t paid fees: 25113.720 msat\n",
      "\n",
      "Try:  16640000  sats. Round number:  3\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\mu: 100 \n",
      "Runtime of flow computation: 1.27 sec \n",
      "Success: True \t fee: 1934.040msat \t p = 15.27%   amt: 1420000sats path hops: 3\n",
      "Success: False \t fee:  312.570msat \t p = 67.54%   amt:  230000sats path hops: 3\n",
      "Success: False \t fee: 2553.670msat \t p = 19.09%   amt: 1910000sats path hops: 3\n",
      "Success: True \t fee:  243.000msat \t p = 76.76%   amt:  180000sats path hops: 4\n",
      "Success: False \t fee: 3037.260msat \t p = 14.54%   amt: 2270000sats path hops: 4\n",
      "Success: True \t fee:   66.900msat \t p = 78.60%   amt:   50000sats path hops: 4\n",
      "Success: True \t fee:  256.310msat \t p = 19.19%   amt:  190000sats path hops: 4\n",
      "Success: True \t fee:  382.200msat \t p = 76.52%   amt:  280000sats path hops: 4\n",
      "Success: False \t fee: 1206.000msat \t p = 29.14%   amt:  900000sats path hops: 4\n",
      "Success: False \t fee:   82.200msat \t p = 85.37%   amt:   60000sats path hops: 5\n",
      "Success: True \t fee:  203.550msat \t p = 75.85%   amt:  150000sats path hops: 5\n",
      "Success: True \t fee:  818.400msat \t p = 18.28%   amt:  600000sats path hops: 5\n",
      "Success: True \t fee:  335.250msat \t p = 16.30%   amt:  250000sats path hops: 5\n",
      "Success: True \t fee:  694.000msat \t p = 73.10%   amt:  500000sats path hops: 5\n",
      "Success: True \t fee:  950.130msat \t p = 30.76%   amt:  690000sats path hops: 5\n",
      "Success: True \t fee:  278.000msat \t p = 74.26%   amt:  200000sats path hops: 5\n",
      "Success: True \t fee: 1009.590msat \t p =  5.52%   amt:  730000sats path hops: 6\n",
      "Success: True \t fee:  372.330msat \t p = 56.27%   amt:  270000sats path hops: 6\n",
      "Success: True \t fee:  138.100msat \t p = 60.94%   amt:  100000sats path hops: 6\n",
      "Success: True \t fee:  832.200msat \t p = 63.73%   amt:  600000sats path hops: 6\n",
      "Success: True \t fee:   40.500msat \t p = 73.70%   amt:   30000sats path hops: 6\n",
      "Success: False \t fee:  147.510msat \t p = 43.27%   amt:  110000sats path hops: 6\n",
      "Success: False \t fee:   53.720msat \t p = 75.89%   amt:   40000sats path hops: 6\n",
      "Success: True \t fee:  455.730msat \t p = 49.46%   amt:  330000sats path hops: 6\n",
      "Success: True \t fee:   68.100msat \t p = 89.90%   amt:   50000sats path hops: 6\n",
      "Success: True \t fee:  108.640msat \t p = 84.20%   amt:   80000sats path hops: 6\n",
      "Success: False \t fee:  123.660msat \t p = 78.83%   amt:   90000sats path hops: 6\n",
      "Success: True \t fee: 1577.310msat \t p = 47.90%   amt: 1110000sats path hops: 6\n",
      "Success: False \t fee:   13.420msat \t p = 93.43%   amt:   10000sats path hops: 7\n",
      "Success: True \t fee:  108.960msat \t p = 62.89%   amt:   80000sats path hops: 7\n",
      "Success: True \t fee:  108.240msat \t p = 85.57%   amt:   80000sats path hops: 7\n",
      "Success: True \t fee:   69.100msat \t p = 37.10%   amt:   50000sats path hops: 7\n",
      "Success: True \t fee:  166.680msat \t p = 91.02%   amt:  120000sats path hops: 7\n",
      "Success: True \t fee: 1261.130msat \t p = 46.91%   amt:  890000sats path hops: 7\n",
      "Success: True \t fee:  348.920msat \t p = 58.14%   amt:  260000sats path hops: 7\n",
      "Success: True \t fee:  312.110msat \t p = 59.01%   amt:  230000sats path hops: 7\n",
      "Success: True \t fee:   26.840msat \t p = 73.70%   amt:   20000sats path hops: 7\n",
      "Success: True \t fee:  948.500msat \t p = 30.05%   amt:  700000sats path hops: 8\n",
      "Success: True \t fee:   26.840msat \t p = 94.31%   amt:   20000sats path hops: 8\n",
      "Success: True \t fee:   41.160msat \t p = 95.00%   amt:   30000sats path hops: 9\n",
      "Success: True \t fee:  315.100msat \t p = 58.50%   amt:  230000sats path hops: 9\n",
      "Success: True \t fee:  138.500msat \t p = 57.06%   amt:  100000sats path hops: 10\n",
      "Success: True \t fee:   68.600msat \t p = 91.30%   amt:   50000sats path hops: 10\n",
      "Success: True \t fee:  137.700msat \t p = 49.60%   amt:  100000sats path hops: 10\n",
      "Success: True \t fee:   84.180msat \t p = 70.70%   amt:   60000sats path hops: 11\n",
      "Success: True \t fee:  259.350msat \t p = 26.56%   amt:  190000sats path hops: 11\n",
      "total_fee: 22716.200 msat \t paid fees: 15186.190 msat\n",
      "\n",
      "Try:  5620000  sats. Round number:  4\n",
      "\\mu: 100 \n",
      "Runtime of flow computation: 1.43 sec \n",
      "Success: True \t fee: 2152.570msat \t p = 29.87%   amt: 1610000sats path hops: 3\n",
      "Success: True \t fee:  243.000msat \t p = 76.76%   amt:  180000sats path hops: 4\n",
      "Success: True \t fee: 1391.520msat \t p = 52.45%   amt: 1040000sats path hops: 4\n",
      "Success: True \t fee:  256.310msat \t p = 19.19%   amt:  190000sats path hops: 4\n",
      "Success: False \t fee:  991.600msat \t p = 39.26%   amt:  740000sats path hops: 4\n",
      "Success: True \t fee:  335.250msat \t p = 16.30%   amt:  250000sats path hops: 5\n",
      "Success: True \t fee:  696.800msat \t p = 71.72%   amt:  520000sats path hops: 5\n",
      "Success: True \t fee:   93.660msat \t p = 92.28%   amt:   70000sats path hops: 5\n",
      "Success: True \t fee:   66.900msat \t p = 76.25%   amt:   50000sats path hops: 5\n",
      "Success: True \t fee:   40.500msat \t p = 73.70%   amt:   30000sats path hops: 6\n",
      "Success: True \t fee:  108.240msat \t p = 85.57%   amt:   80000sats path hops: 7\n",
      "Success: True \t fee:  147.400msat \t p = 75.79%   amt:  110000sats path hops: 7\n",
      "Success: True \t fee:   26.840msat \t p = 73.70%   amt:   20000sats path hops: 7\n",
      "Success: True \t fee:  201.000msat \t p = 72.36%   amt:  150000sats path hops: 8\n",
      "Success: True \t fee:  757.680msat \t p = 36.37%   amt:  560000sats path hops: 9\n",
      "Success: True \t fee:   26.800msat \t p = 94.02%   amt:   20000sats path hops: 9\n",
      "total_fee: 7536.070 msat \t paid fees: 6544.470 msat\n",
      "\n",
      "Try:  740000  sats. Round number:  5\n",
      "\\mu: 100 \n",
      "Runtime of flow computation: 0.90 sec \n",
      "Success: True \t fee:  280.770msat \t p = 89.68%   amt:  210000sats path hops: 3\n",
      "Success: True \t fee:  708.610msat \t p = 65.98%   amt:  530000sats path hops: 5\n",
      "total_fee:  989.380 msat \t paid fees:  989.380 msat\n",
      "\n",
      "SUMMARY:\n",
      "Rounds of mcf-computations:  5\n",
      "Number of onions sent:  192\n",
      "Number of failed onions:  57  failure rate: 29.69% \n",
      "total runtime (including inefficient memory managment): 6.112 sec\n",
      "Learnt entropy: 268.16 bits\n",
      "Fees for successfull delivery: 69992.010 sat --> 1399 ppm\n"
     ]
    }
   ],
   "source": [
    "    \n",
    "print(\"\\n\\nOTPTIMIZE MAINLY FOR FEES\")\n",
    "oracle.reset_uncertainty_network()\n",
    "run_pickhardt_payments_experiment(oracle,RENE,C_OTTO,AMT,mu=100,base=0)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "OTPTIMIZE MAINLY FOR FEES use global uncertainty reduction\n",
      "\n",
      "Try:  50000000  sats. Round number:  1\n",
      "\\mu: 100 \n",
      "Runtime of flow computation: 1.69 sec \n",
      "Success: False \t fee: 15848.460msat \t p = 12.40%   amt: 10870000sats path hops: 3\n",
      "Success: True \t fee: 2060.480msat \t p = 23.93%   amt: 1370000sats path hops: 3\n",
      "Success: True \t fee: 1921.250msat \t p = 56.25%   amt: 1250000sats path hops: 3\n",
      "Success: True \t fee: 1484.580msat \t p = 28.97%   amt: 1090000sats path hops: 3\n",
      "Success: False \t fee:  231.030msat \t p = 75.48%   amt:  170000sats path hops: 3\n",
      "Success: False \t fee: 2353.120msat \t p = 24.39%   amt: 1760000sats path hops: 3\n",
      "Success: False \t fee: 1442.000msat \t p = 51.56%   amt: 1000000sats path hops: 3\n",
      "Success: True \t fee:  100.660msat \t p = 22.97%   amt:   70000sats path hops: 4\n",
      "Success: True \t fee:  499.500msat \t p = 56.27%   amt:  370000sats path hops: 4\n",
      "Success: True \t fee: 4674.330msat \t p = 14.77%   amt: 3110000sats path hops: 4\n",
      "Success: False \t fee:  512.240msat \t p = 40.68%   amt:  380000sats path hops: 4\n",
      "Success: False \t fee:  176.800msat \t p = 59.82%   amt:  130000sats path hops: 4\n",
      "Success: False \t fee: 2823.180msat \t p = 18.47%   amt: 2110000sats path hops: 4\n",
      "Success: True \t fee:  902.850msat \t p = 15.53%   amt:  650000sats path hops: 4\n",
      "Success: True \t fee:  344.750msat \t p = 65.31%   amt:  250000sats path hops: 4\n",
      "Success: True \t fee:  256.310msat \t p = 19.19%   amt:  190000sats path hops: 4\n",
      "Success: True \t fee:  172.680msat \t p = 66.35%   amt:  120000sats path hops: 4\n",
      "Success: False \t fee:  991.600msat \t p = 39.26%   amt:  740000sats path hops: 4\n",
      "Success: False \t fee: 2277.000msat \t p = 58.12%   amt: 1500000sats path hops: 4\n",
      "Success: True \t fee:  890.940msat \t p =  9.35%   amt:  620000sats path hops: 5\n",
      "Success: True \t fee:  162.840msat \t p = 80.32%   amt:  120000sats path hops: 5\n",
      "Success: True \t fee:  354.250msat \t p = 86.43%   amt:  250000sats path hops: 5\n",
      "Success: True \t fee:  335.250msat \t p = 16.30%   amt:  250000sats path hops: 5\n",
      "Success: True \t fee:  172.080msat \t p = 39.68%   amt:  120000sats path hops: 5\n",
      "Success: True \t fee:  726.240msat \t p = 37.74%   amt:  510000sats path hops: 5\n",
      "Success: True \t fee:   14.190msat \t p = 47.28%   amt:   10000sats path hops: 5\n",
      "Success: True \t fee:  333.600msat \t p = 69.49%   amt:  240000sats path hops: 5\n",
      "Success: True \t fee:  372.600msat \t p =  5.46%   amt:  270000sats path hops: 5\n",
      "Success: True \t fee:  539.090msat \t p = 19.96%   amt:  370000sats path hops: 5\n",
      "Success: False \t fee: 1101.000msat \t p = 63.84%   amt:  750000sats path hops: 5\n",
      "Success: True \t fee:   28.480msat \t p = 79.65%   amt:   20000sats path hops: 5\n",
      "Success: True \t fee:  249.560msat \t p = 64.93%   amt:  170000sats path hops: 5\n",
      "Success: False \t fee: 1541.400msat \t p = 32.09%   amt: 1050000sats path hops: 5\n",
      "Success: True \t fee: 1032.750msat \t p = 27.10%   amt:  750000sats path hops: 5\n",
      "Success: True \t fee:   13.800msat \t p = 63.04%   amt:   10000sats path hops: 5\n",
      "Success: False \t fee:   27.200msat \t p = 86.93%   amt:   20000sats path hops: 5\n",
      "Success: True \t fee:   95.830msat \t p = 42.71%   amt:   70000sats path hops: 5\n",
      "Success: True \t fee:   67.300msat \t p = 78.71%   amt:   50000sats path hops: 5\n",
      "Success: True \t fee:   28.180msat \t p = 67.55%   amt:   20000sats path hops: 6\n",
      "Success: True \t fee:   13.690msat \t p = 64.06%   amt:   10000sats path hops: 6\n",
      "Success: True \t fee:   27.280msat \t p = 75.81%   amt:   20000sats path hops: 6\n",
      "Success: True \t fee:   13.590msat \t p = 87.95%   amt:   10000sats path hops: 6\n",
      "Success: True \t fee:  968.100msat \t p =  6.90%   amt:  700000sats path hops: 6\n",
      "Success: True \t fee:  173.760msat \t p = 67.60%   amt:  120000sats path hops: 6\n",
      "Success: True \t fee:  166.680msat \t p = 53.11%   amt:  120000sats path hops: 6\n",
      "Success: True \t fee:   97.930msat \t p = 53.46%   amt:   70000sats path hops: 6\n",
      "Success: True \t fee:   56.760msat \t p = 54.58%   amt:   40000sats path hops: 6\n",
      "Success: True \t fee:  140.800msat \t p = 66.30%   amt:  100000sats path hops: 6\n",
      "Success: True \t fee:  258.230msat \t p = 45.01%   amt:  170000sats path hops: 6\n",
      "Success: True \t fee:  172.800msat \t p = 61.97%   amt:  120000sats path hops: 6\n",
      "Success: True \t fee:   15.020msat \t p = 73.97%   amt:   10000sats path hops: 6\n",
      "Success: True \t fee:  209.020msat \t p = 78.91%   amt:  140000sats path hops: 6\n",
      "Success: True \t fee:   68.000msat \t p = 42.73%   amt:   50000sats path hops: 6\n",
      "Success: True \t fee:  340.000msat \t p = 20.74%   amt:  250000sats path hops: 6\n",
      "Success: True \t fee:  339.500msat \t p = 56.36%   amt:  250000sats path hops: 6\n",
      "Success: True \t fee:   94.080msat \t p = 25.35%   amt:   70000sats path hops: 6\n",
      "Success: True \t fee:   26.880msat \t p = 73.73%   amt:   20000sats path hops: 6\n",
      "Success: True \t fee:  373.250msat \t p = 27.69%   amt:  250000sats path hops: 6\n",
      "Success: True \t fee:   13.690msat \t p = 87.57%   amt:   10000sats path hops: 7\n",
      "Success: True \t fee:  214.200msat \t p = 38.47%   amt:  150000sats path hops: 7\n",
      "Success: True \t fee: 1488.900msat \t p = 19.20%   amt: 1050000sats path hops: 7\n",
      "Success: True \t fee: 1909.500msat \t p = 15.63%   amt: 1340000sats path hops: 7\n",
      "Success: True \t fee:  301.770msat \t p = 59.62%   amt:  210000sats path hops: 7\n",
      "Success: True \t fee:  855.000msat \t p = 43.54%   amt:  600000sats path hops: 7\n",
      "Success: True \t fee:  693.600msat \t p = 56.43%   amt:  480000sats path hops: 7\n",
      "Success: True \t fee: 1317.810msat \t p = 31.18%   amt:  930000sats path hops: 7\n",
      "Success: True \t fee: 1361.220msat \t p = 43.46%   amt:  980000sats path hops: 7\n",
      "Success: True \t fee:  124.830msat \t p = 88.73%   amt:   90000sats path hops: 7\n",
      "Success: True \t fee:  679.360msat \t p = 36.42%   amt:  440000sats path hops: 7\n",
      "Success: True \t fee:   75.700msat \t p = 41.73%   amt:   50000sats path hops: 7\n",
      "Success: True \t fee:   14.940msat \t p = 97.88%   amt:   10000sats path hops: 7\n",
      "Success: True \t fee:  746.000msat \t p = 36.23%   amt:  500000sats path hops: 7\n",
      "Success: False \t fee:   73.300msat \t p = 58.07%   amt:   50000sats path hops: 7\n",
      "Success: True \t fee: 1020.000msat \t p = 34.36%   amt:  680000sats path hops: 7\n",
      "Success: True \t fee:   13.760msat \t p = 95.38%   amt:   10000sats path hops: 7\n",
      "Success: True \t fee:  151.360msat \t p = 59.82%   amt:  110000sats path hops: 8\n",
      "Success: True \t fee:  161.370msat \t p = 72.01%   amt:  110000sats path hops: 8\n",
      "Success: True \t fee:   93.870msat \t p = 21.86%   amt:   70000sats path hops: 8\n",
      "Success: True \t fee:   95.270msat \t p =  9.51%   amt:   70000sats path hops: 8\n",
      "Success: False \t fee:  164.450msat \t p = 76.36%   amt:  110000sats path hops: 8\n",
      "Success: True \t fee:  179.520msat \t p = 43.82%   amt:  120000sats path hops: 8\n",
      "Success: True \t fee:   14.950msat \t p = 98.77%   amt:   10000sats path hops: 8\n",
      "Success: False \t fee:   14.410msat \t p = 63.12%   amt:   10000sats path hops: 8\n",
      "Success: True \t fee:   14.940msat \t p = 44.42%   amt:   10000sats path hops: 9\n",
      "Success: True \t fee:   14.080msat \t p = 86.65%   amt:   10000sats path hops: 9\n",
      "Success: True \t fee:  731.080msat \t p = 71.19%   amt:  490000sats path hops: 9\n",
      "Success: True \t fee:  269.280msat \t p = 58.32%   amt:  180000sats path hops: 9\n",
      "Success: True \t fee:   15.030msat \t p = 98.41%   amt:   10000sats path hops: 9\n",
      "Success: True \t fee: 2121.480msat \t p = 27.28%   amt: 1420000sats path hops: 9\n",
      "Success: True \t fee:  865.940msat \t p = 46.69%   amt:  580000sats path hops: 9\n",
      "Success: True \t fee:  179.140msat \t p = 66.57%   amt:  130000sats path hops: 9\n",
      "Success: True \t fee:  418.600msat \t p = 58.19%   amt:  280000sats path hops: 9\n",
      "Success: True \t fee:  233.760msat \t p = 55.87%   amt:  160000sats path hops: 9\n",
      "Success: True \t fee:  326.600msat \t p = 37.16%   amt:  230000sats path hops: 9\n",
      "Success: True \t fee:  149.930msat \t p = 60.66%   amt:  110000sats path hops: 9\n",
      "Success: True \t fee:   99.540msat \t p = 27.92%   amt:   70000sats path hops: 9\n",
      "Success: True \t fee:   28.880msat \t p = 91.35%   amt:   20000sats path hops: 9\n",
      "Success: True \t fee:  286.600msat \t p = 25.73%   amt:  200000sats path hops: 10\n",
      "Success: True \t fee:  118.480msat \t p = 55.98%   amt:   80000sats path hops: 10\n",
      "Success: True \t fee:  249.300msat \t p = 34.12%   amt:  180000sats path hops: 10\n",
      "Success: True \t fee:   67.900msat \t p = 63.60%   amt:   50000sats path hops: 10\n",
      "Success: True \t fee:   70.050msat \t p = 40.18%   amt:   50000sats path hops: 10\n",
      "Success: True \t fee:   29.900msat \t p = 95.17%   amt:   20000sats path hops: 10\n",
      "Success: True \t fee:  102.340msat \t p = 53.99%   amt:   70000sats path hops: 10\n",
      "Success: True \t fee:   54.840msat \t p = 91.63%   amt:   40000sats path hops: 10\n",
      "Success: True \t fee:  181.350msat \t p = 64.18%   amt:  130000sats path hops: 10\n",
      "Success: True \t fee:  350.000msat \t p =  8.12%   amt:  250000sats path hops: 10\n",
      "Success: True \t fee:   68.900msat \t p = 35.41%   amt:   50000sats path hops: 11\n",
      "Success: True \t fee:  332.350msat \t p = 31.39%   amt:  230000sats path hops: 11\n",
      "Success: True \t fee:  101.150msat \t p = 50.67%   amt:   70000sats path hops: 11\n",
      "Success: True \t fee:   71.300msat \t p = 58.72%   amt:   50000sats path hops: 11\n",
      "Success: True \t fee:  513.740msat \t p = 24.29%   amt:  340000sats path hops: 11\n",
      "Success: True \t fee:  374.920msat \t p = 12.23%   amt:  260000sats path hops: 12\n",
      "Success: True \t fee:  174.120msat \t p = 46.73%   amt:  120000sats path hops: 12\n",
      "Success: True \t fee:   76.200msat \t p = 34.17%   amt:   50000sats path hops: 14\n",
      "Success: True \t fee:   29.940msat \t p = 88.08%   amt:   20000sats path hops: 14\n",
      "Success: True \t fee:   28.840msat \t p = 93.74%   amt:   20000sats path hops: 14\n",
      "Success: True \t fee:   72.750msat \t p = 14.02%   amt:   50000sats path hops: 15\n",
      "Success: True \t fee:   28.860msat \t p = 92.67%   amt:   20000sats path hops: 16\n",
      "Success: True \t fee:   14.050msat \t p = 90.19%   amt:   10000sats path hops: 17\n",
      "Success: True \t fee:   14.020msat \t p = 84.74%   amt:   10000sats path hops: 17\n",
      "Success: True \t fee:  135.900msat \t p = 37.13%   amt:   90000sats path hops: 17\n",
      "Success: True \t fee:   30.200msat \t p = 66.28%   amt:   20000sats path hops: 17\n",
      "Success: True \t fee:   70.250msat \t p = 32.81%   amt:   50000sats path hops: 17\n",
      "Success: True \t fee:  287.470msat \t p = 34.45%   amt:  190000sats path hops: 17\n",
      "Success: True \t fee:   30.260msat \t p = 57.76%   amt:   20000sats path hops: 17\n",
      "Success: True \t fee:   71.100msat \t p = 41.04%   amt:   50000sats path hops: 18\n",
      "total_fee: 71998.910 msat \t paid fees: 42421.720 msat\n",
      "\n",
      "Try:  20650000  sats. Round number:  2\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\\mu: 100 \n",
      "Runtime of flow computation: 1.13 sec \n",
      "Success: True \t fee: 1484.580msat \t p = 28.97%   amt: 1090000sats path hops: 3\n",
      "Success: True \t fee:  217.440msat \t p = 76.84%   amt:  160000sats path hops: 3\n",
      "Success: False \t fee: 2179.310msat \t p = 29.13%   amt: 1630000sats path hops: 3\n",
      "Success: True \t fee:  100.660msat \t p = 22.97%   amt:   70000sats path hops: 4\n",
      "Success: True \t fee:  499.500msat \t p = 56.27%   amt:  370000sats path hops: 4\n",
      "Success: True \t fee:  350.480msat \t p = 56.01%   amt:  260000sats path hops: 4\n",
      "Success: False \t fee: 2542.200msat \t p = 24.06%   amt: 1900000sats path hops: 4\n",
      "Success: True \t fee:   93.660msat \t p = 70.58%   amt:   70000sats path hops: 4\n",
      "Success: True \t fee:  256.310msat \t p = 19.19%   amt:  190000sats path hops: 4\n",
      "Success: True \t fee:  172.680msat \t p = 66.35%   amt:  120000sats path hops: 4\n",
      "Success: False \t fee:  938.000msat \t p = 41.95%   amt:  700000sats path hops: 4\n",
      "Success: True \t fee:  804.720msat \t p = 13.16%   amt:  560000sats path hops: 5\n",
      "Success: True \t fee:  474.950msat \t p = 50.35%   amt:  350000sats path hops: 5\n",
      "Success: True \t fee:  566.800msat \t p = 78.90%   amt:  400000sats path hops: 5\n",
      "Success: True \t fee:  886.600msat \t p = 13.82%   amt:  650000sats path hops: 5\n",
      "Success: True \t fee:  335.250msat \t p = 16.30%   amt:  250000sats path hops: 5\n",
      "Success: True \t fee:   28.460msat \t p = 45.04%   amt:   20000sats path hops: 5\n",
      "Success: True \t fee:  512.640msat \t p = 52.20%   amt:  360000sats path hops: 5\n",
      "Success: True \t fee:   67.300msat \t p = 78.71%   amt:   50000sats path hops: 5\n",
      "Success: True \t fee:   27.400msat \t p = 79.00%   amt:   20000sats path hops: 5\n",
      "Success: True \t fee:   27.680msat \t p = 70.69%   amt:   20000sats path hops: 6\n",
      "Success: True \t fee:   27.280msat \t p = 75.81%   amt:   20000sats path hops: 6\n",
      "Success: True \t fee:   54.400msat \t p = 52.94%   amt:   40000sats path hops: 6\n",
      "Success: True \t fee:  340.000msat \t p = 20.74%   amt:  250000sats path hops: 6\n",
      "Success: True \t fee:  968.100msat \t p =  6.90%   amt:  700000sats path hops: 6\n",
      "Success: True \t fee:  173.760msat \t p = 67.60%   amt:  120000sats path hops: 6\n",
      "Success: True \t fee:  141.500msat \t p = 49.79%   amt:  100000sats path hops: 6\n",
      "Success: True \t fee:  215.100msat \t p = 72.66%   amt:  150000sats path hops: 6\n",
      "Success: True \t fee:   14.000msat \t p = 47.45%   amt:   10000sats path hops: 6\n",
      "Success: True \t fee:   94.080msat \t p = 25.35%   amt:   70000sats path hops: 6\n",
      "Success: True \t fee:   68.050msat \t p = 76.63%   amt:   50000sats path hops: 6\n",
      "Success: True \t fee: 1040.250msat \t p = 18.68%   amt:  750000sats path hops: 6\n",
      "Success: True \t fee:   13.990msat \t p = 92.20%   amt:   10000sats path hops: 6\n",
      "Success: True \t fee:   26.880msat \t p = 73.73%   amt:   20000sats path hops: 6\n",
      "Success: True \t fee:  544.050msat \t p = 46.97%   amt:  390000sats path hops: 7\n",
      "Success: True \t fee:   13.710msat \t p = 43.05%   amt:   10000sats path hops: 7\n",
      "Success: True \t fee:  114.240msat \t p = 64.00%   amt:   80000sats path hops: 7\n",
      "Success: True \t fee:   27.380msat \t p = 75.72%   amt:   20000sats path hops: 7\n",
      "Success: True \t fee:  470.250msat \t p = 67.28%   amt:  330000sats path hops: 7\n",
      "Success: True \t fee:  855.000msat \t p = 43.54%   amt:  600000sats path hops: 7\n",
      "Success: True \t fee:  510.480msat \t p = 62.17%   amt:  360000sats path hops: 7\n",
      "Success: True \t fee:  165.360msat \t p = 57.92%   amt:  120000sats path hops: 7\n",
      "Success: False \t fee: 2569.650msat \t p = 17.54%   amt: 1850000sats path hops: 7\n",
      "Success: True \t fee:  226.720msat \t p = 88.00%   amt:  160000sats path hops: 7\n",
      "Success: True \t fee:  707.500msat \t p = 48.74%   amt:  500000sats path hops: 7\n",
      "Success: True \t fee:   95.270msat \t p =  9.51%   amt:   70000sats path hops: 8\n",
      "Success: True \t fee:  212.250msat \t p = 86.65%   amt:  150000sats path hops: 8\n",
      "Success: True \t fee:  327.980msat \t p = 63.79%   amt:  230000sats path hops: 8\n",
      "Success: True \t fee:   28.340msat \t p = 98.23%   amt:   20000sats path hops: 8\n",
      "Success: True \t fee: 1232.790msat \t p = 35.71%   amt:  870000sats path hops: 8\n",
      "Success: True \t fee:  651.360msat \t p = 48.47%   amt:  460000sats path hops: 8\n",
      "Success: True \t fee:   93.940msat \t p = 21.06%   amt:   70000sats path hops: 8\n",
      "Success: True \t fee:  164.160msat \t p = 26.66%   amt:  120000sats path hops: 9\n",
      "Success: True \t fee:   68.100msat \t p = 37.01%   amt:   50000sats path hops: 9\n",
      "Success: True \t fee:  179.140msat \t p = 66.57%   amt:  130000sats path hops: 9\n",
      "Success: True \t fee:   83.340msat \t p = 44.50%   amt:   60000sats path hops: 9\n",
      "Success: True \t fee:   70.450msat \t p = 35.18%   amt:   50000sats path hops: 9\n",
      "Success: True \t fee:  355.000msat \t p = 33.25%   amt:  250000sats path hops: 9\n",
      "Success: True \t fee:   99.540msat \t p = 27.92%   amt:   70000sats path hops: 9\n",
      "Success: True \t fee:   27.240msat \t p = 89.33%   amt:   20000sats path hops: 10\n",
      "Success: True \t fee:   13.620msat \t p = 95.64%   amt:   10000sats path hops: 10\n",
      "Success: True \t fee:  490.320msat \t p = 16.43%   amt:  360000sats path hops: 10\n",
      "Success: True \t fee:   67.900msat \t p = 63.60%   amt:   50000sats path hops: 10\n",
      "Success: True \t fee:  249.300msat \t p = 34.12%   amt:  180000sats path hops: 10\n",
      "Success: True \t fee:  286.600msat \t p = 25.73%   amt:  200000sats path hops: 10\n",
      "Success: True \t fee:  178.230msat \t p = 74.95%   amt:  130000sats path hops: 10\n",
      "Success: True \t fee:  288.960msat \t p = 17.44%   amt:  210000sats path hops: 10\n",
      "Success: True \t fee:   27.400msat \t p = 81.30%   amt:   20000sats path hops: 11\n",
      "Success: True \t fee:   55.040msat \t p = 70.06%   amt:   40000sats path hops: 11\n",
      "Success: True \t fee:   42.030msat \t p = 57.56%   amt:   30000sats path hops: 11\n",
      "Success: True \t fee:   67.700msat \t p = 34.09%   amt:   50000sats path hops: 12\n",
      "Success: True \t fee:   85.260msat \t p = 72.16%   amt:   60000sats path hops: 12\n",
      "Success: True \t fee:  369.720msat \t p =  6.48%   amt:  260000sats path hops: 13\n",
      "Success: True \t fee:  142.300msat \t p = 61.87%   amt:  100000sats path hops: 14\n",
      "Success: True \t fee:   13.650msat \t p = 78.28%   amt:   10000sats path hops: 14\n",
      "Success: True \t fee:   94.780msat \t p = 37.30%   amt:   70000sats path hops: 14\n",
      "Success: True \t fee:   40.950msat \t p = 79.93%   amt:   30000sats path hops: 14\n",
      "Success: True \t fee:   13.650msat \t p = 61.84%   amt:   10000sats path hops: 14\n",
      "Success: True \t fee:   28.080msat \t p = 82.16%   amt:   20000sats path hops: 15\n",
      "Success: True \t fee:   40.860msat \t p = 71.38%   amt:   30000sats path hops: 15\n",
      "Success: True \t fee:   70.200msat \t p = 33.78%   amt:   50000sats path hops: 15\n",
      "Success: True \t fee:   27.240msat \t p = 65.31%   amt:   20000sats path hops: 15\n",
      "Success: True \t fee:   27.060msat \t p = 55.86%   amt:   20000sats path hops: 15\n",
      "Success: True \t fee:   99.470msat \t p = 33.11%   amt:   70000sats path hops: 16\n",
      "Success: True \t fee:   71.050msat \t p = 42.26%   amt:   50000sats path hops: 16\n",
      "total_fee: 28528.620 msat \t paid fees: 20299.460 msat\n",
      "\n",
      "Try:  6080000  sats. Round number:  3\n",
      "\\mu: 100 \n",
      "Runtime of flow computation: 1.18 sec \n",
      "Success: True \t fee:  108.720msat \t p = 88.09%   amt:   80000sats path hops: 3\n",
      "Success: True \t fee: 2152.570msat \t p = 29.87%   amt: 1610000sats path hops: 3\n",
      "Success: True \t fee:  499.500msat \t p = 56.27%   amt:  370000sats path hops: 4\n",
      "Success: True \t fee: 2180.940msat \t p = 31.99%   amt: 1630000sats path hops: 4\n",
      "Success: True \t fee:   93.660msat \t p = 70.58%   amt:   70000sats path hops: 4\n",
      "Success: True \t fee:  256.310msat \t p = 19.19%   amt:  190000sats path hops: 4\n",
      "Success: True \t fee:  108.720msat \t p = 56.07%   amt:   80000sats path hops: 5\n",
      "Success: True \t fee:  284.970msat \t p = 67.44%   amt:  210000sats path hops: 5\n",
      "Success: True \t fee:  335.250msat \t p = 16.30%   amt:  250000sats path hops: 5\n",
      "Success: True \t fee:   27.180msat \t p = 76.38%   amt:   20000sats path hops: 6\n",
      "Success: True \t fee:  189.980msat \t p = 70.77%   amt:  140000sats path hops: 6\n",
      "Success: True \t fee:  348.400msat \t p = 59.16%   amt:  260000sats path hops: 6\n",
      "Success: True \t fee:   93.870msat \t p = 22.20%   amt:   70000sats path hops: 6\n",
      "Success: True \t fee:  635.910msat \t p = 48.72%   amt:  470000sats path hops: 7\n",
      "Success: True \t fee:  378.840msat \t p = 55.62%   amt:  280000sats path hops: 8\n",
      "Success: True \t fee:   93.870msat \t p = 23.85%   amt:   70000sats path hops: 8\n",
      "Success: True \t fee:   26.820msat \t p = 72.44%   amt:   20000sats path hops: 8\n",
      "Success: True \t fee:   27.180msat \t p = 83.23%   amt:   20000sats path hops: 9\n",
      "Success: True \t fee:   67.850msat \t p = 63.39%   amt:   50000sats path hops: 9\n",
      "Success: True \t fee:   67.650msat \t p = 37.37%   amt:   50000sats path hops: 10\n",
      "Success: True \t fee:   67.400msat \t p = 40.44%   amt:   50000sats path hops: 11\n",
      "Success: True \t fee:   26.960msat \t p = 61.88%   amt:   20000sats path hops: 11\n",
      "Success: True \t fee:   27.000msat \t p = 57.58%   amt:   20000sats path hops: 12\n",
      "Success: True \t fee:   67.200msat \t p = 25.49%   amt:   50000sats path hops: 12\n",
      "total_fee: 8166.750 msat \t paid fees: 8166.750 msat\n",
      "\n",
      "SUMMARY:\n",
      "Rounds of mcf-computations:  3\n",
      "Number of onions sent:  236\n",
      "Number of failed onions:  19  failure rate: 8.05% \n",
      "total runtime (including inefficient memory managment): 4.032 sec\n",
      "Learnt entropy: 169.60 bits\n",
      "Fees for successfull delivery: 70887.930 sat --> 1417 ppm\n"
     ]
    }
   ],
   "source": [
    "    \n",
    "print(\"\\n\\nOTPTIMIZE MAINLY FOR FEES use global uncertainty reduction\")\n",
    "oracle.reset_uncertainty_network()\n",
    "oracle.activate_network_wide_uncertainty_reduction(2)\n",
    "run_pickhardt_payments_experiment(oracle,RENE,C_OTTO,AMT,mu=100,base=0)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "\n",
      "OTPTIMIZE MAINLY FOR FEES use foaf uncertainty reduction\n",
      "channels with full knowlege:  215\n",
      "channels with 2 Bits of less entropy:  8750\n",
      "\n",
      "Try:  50000000  sats. Round number:  1\n",
      "\\mu: 1 \n",
      "Runtime of flow computation: 0.91 sec \n",
      "Success: True \t fee: 13180.320msat \t p = 21.27%   amt: 9040000sats path hops: 3\n",
      "Success: True \t fee: 2060.480msat \t p = 23.93%   amt: 1370000sats path hops: 3\n",
      "Success: True \t fee: 2197.910msat \t p = 50.98%   amt: 1430000sats path hops: 3\n",
      "Success: True \t fee: 1511.820msat \t p = 28.04%   amt: 1110000sats path hops: 3\n",
      "Success: True \t fee:  217.440msat \t p = 76.84%   amt:  160000sats path hops: 3\n",
      "Success: True \t fee: 2152.570msat \t p = 29.87%   amt: 1610000sats path hops: 3\n",
      "Success: True \t fee: 5971.980msat \t p = 49.35%   amt: 3540000sats path hops: 3\n",
      "Success: True \t fee: 1225.700msat \t p = 57.83%   amt:  850000sats path hops: 3\n",
      "Success: True \t fee:  289.180msat \t p = 78.79%   amt:  190000sats path hops: 4\n",
      "Success: True \t fee:  129.420msat \t p =  6.99%   amt:   90000sats path hops: 4\n",
      "Success: True \t fee:  390.690msat \t p = 38.52%   amt:  270000sats path hops: 4\n",
      "Success: True \t fee:  100.170msat \t p = 84.19%   amt:   70000sats path hops: 4\n",
      "Success: True \t fee:  472.500msat \t p = 58.24%   amt:  350000sats path hops: 4\n",
      "Success: True \t fee: 2057.680msat \t p = 57.80%   amt: 1360000sats path hops: 4\n",
      "Success: True \t fee:  205.050msat \t p = 88.90%   amt:  150000sats path hops: 4\n",
      "Success: True \t fee: 5270.290msat \t p =  2.22%   amt: 3530000sats path hops: 4\n",
      "Success: True \t fee:  465.930msat \t p = 89.42%   amt:  310000sats path hops: 4\n",
      "Success: True \t fee:  350.480msat \t p = 56.01%   amt:  260000sats path hops: 4\n",
      "Success: True \t fee:  696.540msat \t p = 39.41%   amt:  470000sats path hops: 4\n",
      "Success: True \t fee:   95.200msat \t p = 76.94%   amt:   70000sats path hops: 4\n",
      "Success: True \t fee:  685.730msat \t p = 36.73%   amt:  470000sats path hops: 4\n",
      "Success: True \t fee: 1980.240msat \t p = 36.78%   amt: 1480000sats path hops: 4\n",
      "Success: True \t fee:  215.800msat \t p = 89.80%   amt:  130000sats path hops: 4\n",
      "Success: True \t fee:  902.850msat \t p = 15.53%   amt:  650000sats path hops: 4\n",
      "Success: True \t fee:  386.120msat \t p = 61.62%   amt:  280000sats path hops: 4\n",
      "Success: True \t fee:  184.680msat \t p = 93.91%   amt:  120000sats path hops: 4\n",
      "Success: True \t fee:  256.310msat \t p = 19.19%   amt:  190000sats path hops: 4\n",
      "Success: True \t fee:  187.070msat \t p = 63.82%   amt:  130000sats path hops: 4\n",
      "Success: True \t fee: 2113.370msat \t p = 26.47%   amt: 1330000sats path hops: 4\n",
      "Success: True \t fee:  897.800msat \t p = 44.01%   amt:  670000sats path hops: 4\n",
      "Success: True \t fee:   48.540msat \t p = 99.23%   amt:   30000sats path hops: 4\n",
      "Success: True \t fee:  548.640msat \t p = 74.31%   amt:  360000sats path hops: 4\n",
      "Success: True \t fee:  115.760msat \t p = 76.88%   amt:   80000sats path hops: 5\n",
      "Success: True \t fee:   28.760msat \t p = 92.73%   amt:   20000sats path hops: 5\n",
      "Success: True \t fee: 1278.400msat \t p = 19.31%   amt:  800000sats path hops: 5\n",
      "Success: True \t fee:  783.200msat \t p = 34.37%   amt:  550000sats path hops: 5\n",
      "Success: True \t fee: 1896.570msat \t p = 28.04%   amt: 1170000sats path hops: 5\n",
      "Success: True \t fee:  603.540msat \t p = 25.46%   amt:  420000sats path hops: 5\n",
      "Success: True \t fee:  180.240msat \t p = 94.86%   amt:  120000sats path hops: 5\n",
      "Success: True \t fee: 1800.960msat \t p = 51.40%   amt: 1120000sats path hops: 5\n",
      "Success: True \t fee: 1025.440msat \t p = 64.67%   amt:  680000sats path hops: 5\n",
      "Success: True \t fee: 1244.700msat \t p =  0.71%   amt:  900000sats path hops: 6\n",
      "Success: True \t fee:  274.930msat \t p = 53.50%   amt:  190000sats path hops: 6\n",
      "Success: True \t fee:  981.760msat \t p = 32.78%   amt:  640000sats path hops: 6\n",
      "Success: True \t fee:  809.460msat \t p = 59.73%   amt:  540000sats path hops: 6\n",
      "Success: True \t fee:  641.340msat \t p = 70.18%   amt:  420000sats path hops: 6\n",
      "Success: True \t fee:  416.880msat \t p = 48.97%   amt:  270000sats path hops: 6\n",
      "Success: True \t fee:  949.770msat \t p = 20.51%   amt:  610000sats path hops: 7\n",
      "Success: True \t fee:  527.680msat \t p = 34.64%   amt:  340000sats path hops: 7\n",
      "Success: True \t fee:  321.310msat \t p = 65.85%   amt:  230000sats path hops: 7\n",
      "Success: True \t fee:  125.730msat \t p = 90.13%   amt:   90000sats path hops: 7\n",
      "Success: True \t fee:  436.790msat \t p = 45.01%   amt:  310000sats path hops: 7\n",
      "Success: True \t fee:  138.900msat \t p = 85.38%   amt:  100000sats path hops: 7\n",
      "Success: True \t fee: 1089.660msat \t p = 33.08%   amt:  780000sats path hops: 7\n",
      "Success: True \t fee:   43.440msat \t p = 91.82%   amt:   30000sats path hops: 7\n",
      "Success: True \t fee:   14.700msat \t p = 85.67%   amt:   10000sats path hops: 7\n",
      "Success: True \t fee:  116.960msat \t p = 13.21%   amt:   80000sats path hops: 7\n",
      "Success: True \t fee: 1893.480msat \t p = 16.80%   amt: 1240000sats path hops: 8\n",
      "Success: True \t fee:  599.640msat \t p = 53.89%   amt:  380000sats path hops: 8\n",
      "Success: True \t fee:  449.500msat \t p = 53.89%   amt:  290000sats path hops: 8\n",
      "Success: True \t fee:   14.410msat \t p = 94.41%   amt:   10000sats path hops: 8\n",
      "Success: False \t fee:   14.210msat \t p = 94.41%   amt:   10000sats path hops: 8\n",
      "Success: True \t fee:  254.150msat \t p = 26.89%   amt:  170000sats path hops: 8\n",
      "Success: True \t fee:   14.800msat \t p = 47.84%   amt:   10000sats path hops: 8\n",
      "Success: True \t fee: 1344.600msat \t p = 61.55%   amt:  900000sats path hops: 8\n",
      "Success: True \t fee:  288.230msat \t p = 68.52%   amt:  190000sats path hops: 8\n",
      "Success: True \t fee:  805.680msat \t p = 53.61%   amt:  540000sats path hops: 8\n",
      "Success: True \t fee:  150.500msat \t p = 82.16%   amt:  100000sats path hops: 9\n",
      "Success: True \t fee:   45.450msat \t p = 82.45%   amt:   30000sats path hops: 9\n",
      "Success: True \t fee:   14.500msat \t p = 63.10%   amt:   10000sats path hops: 9\n",
      "Success: True \t fee: 1232.460msat \t p = 20.52%   amt:  820000sats path hops: 9\n",
      "Success: True \t fee: 2748.960msat \t p = 17.37%   amt: 1840000sats path hops: 9\n",
      "Success: True \t fee:  804.010msat \t p = 24.76%   amt:  530000sats path hops: 9\n",
      "Success: True \t fee:  395.280msat \t p =  4.86%   amt:  270000sats path hops: 9\n",
      "Success: True \t fee:  138.600msat \t p =  5.81%   amt:   90000sats path hops: 10\n",
      "total_fee: 74503.840 msat \t paid fees: 74489.630 msat\n",
      "\n",
      "Try:  10000  sats. Round number:  2\n",
      "\\mu: 1 \n",
      "Runtime of flow computation: 0.89 sec \n",
      "Success: True \t fee:   13.370msat \t p = 99.28%   amt:   10000sats path hops: 5\n",
      "total_fee:   13.370 msat \t paid fees:   13.370 msat\n",
      "\n",
      "SUMMARY:\n",
      "Rounds of mcf-computations:  2\n",
      "Number of onions sent:  76\n",
      "Number of failed onions:  1  failure rate: 1.32% \n",
      "total runtime (including inefficient memory managment): 1.796 sec\n",
      "Learnt entropy: 53.58 bits\n",
      "Fees for successfull delivery: 74503.000 sat --> 1490 ppm\n"
     ]
    }
   ],
   "source": [
    "print(\"\\n\\nOTPTIMIZE MAINLY FOR FEES use foaf uncertainty reduction\")\n",
    "oracle.reset_uncertainty_network()\n",
    "oracle.arcs_to_networkx(0)\n",
    "oracle.activate_foaf_uncertainty_reduction(RENE,C_OTTO)\n",
    "run_pickhardt_payments_experiment(oracle,RENE,C_OTTO,AMT,mu=1,base=0)\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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}