Create a gist now

Instantly share code, notes, and snippets.

What would you like to do?

Resilience — RES with built-in dividend pathways and swarm redistribution, for decentralized basic income

The idea to use the global financial network of daily transactions, and to link these transactions together into a web, is a bit similar to Tim Berners-Lee's idea to link all documents on the internet together with the Hypertext Transfer Protocol (HTTP), which gave us the world wide web.

When Tim Berners-Lee had the idea for the world wide web in the 80s, there were already documents on the internet. He did not have to invent the internet, and his contribution was instead that he saw a way to harness the information on the internet in a new way.

The same goes for the Resilience protocol. The world is electrified with millions, or billions, of financial transactions happening every single day. The global financial network is part of our infrastructure already. What Resilience aims to do is to re-purpose these transaction networks, into a web-of-links, where each transaction forms a dividend pathway.

The main resource which Resilience taps into, is transactions as a network.

Dividend Pathways form with each transaction

transfer: (_to, _amount) ->
    dividendPathway = 
            from: msg.sender
            amount: _amount
            timestamp: now
    @dividendPathways[_to].push dividendPathway

In the model below, available on http://agentbase.org/model.html?dc6b30c40a1354fdf7338b77cfa3b1e9, transactions between agents (one dot forming a link to another dot, with a slight angle of the line between them) form these dividend pathways.

Each column on the x axis (pink and white columns) represents one agent, and to show time, an agent appears as a new dot for each transaction they make or receive.

branching schemes

Swarm Redistribution sends tax into the dividend pathways

iterateThroughSwarm: (_node, _timeStamp) ->
  for dividendPathway, index in @dividendPathways[_node]

    timeStamp = dividendPathway.timeStamp
    if timeStamp <= _timeStamp
        # Pathways are decayed with decayPathways() at later time
 
        pathway = node: _node
                  pathway: index           
        
        @swarmTree.push pathway
        
        from = dividendPathway.from
        # Humans in the swarm redistribution pulse get share of tax
        if @isHuman[from] == true and @inHumans[from] == false
            @humans.push from
            @inHumans[from] = true
        iterateThroughSwarm(node, timeStamp, _taxCollected)
doSwarm:(share) ->
  for human in @humans
    @totalBasicIncome[human] += share
    @inHumans[human] = false
  @humans = []

Exponential decay of dividend pathways

The decay rate of pathways should increase exponentially (for example, double every two months). The base decay would then be share = taxCollected / humans.length (the whole pathway recycled), and then increase exponentially over time (possibly with an upper limit, for example taxCollected)

decayPathways: (share) -> 
  for sheduledForDecay in @swarmTree
    node = sheduledForDecay.node
    pathwayIndex = sheduledForDecay.pathway
    # Decay rate doubles every two months
    timestamp = @dividendPathways[node][pathway].timestamp
    # two months is 5184000 seconds
    doublings = Math.floor(now - timestamp) / 5184000) 
    decayRate = Math.pow(2, doublings)
    decayAmount = share * decayRate
    if @dividendPathways[node][pathway].amount > decayAmount
        @dividendPathways[node][pathway].amount -= decayAmount 
    else 
        @dividendPathways[node].splice pathway, 1 
  @swarmTree = []

Pathways form "branching schemes", which grow chronologically

Each transaction forms a pathway that includes a timestamp,

    dividendPathway = 
            from: msg.sender
            amount: _amount
            timestamp: now
    @dividendPathways[_to].push dividendPathway

and, during swarm redistribution, pathways are iterated through with a filter by timestamp.

iterateThroughSwarm: (_node, _timeStamp) ->
  for dividendPathway, index in @dividendPathways[_node]

    timeStamp = dividendPathway.timeStamp
    if timeStamp <= _timeStamp

dividend pathways connect in a way that follows the order in which transactions occurred, chronologically.

Each transaction will grow links and pathways which connect across many nodes (using node as in a person or a company, steps in a supply chain or employees being paid out), and as tax is collected during swarm redistribution, it will flow down through the pathways. Every transaction connects to its own unique tree of pathways, which extend from it. In the Resilience protocol these trees are called "branching schemes.

In branching schemes, each branch behaves like its own wealth transfer system. The word "branching scheme" is based on pyramid scheme. Pyramid schemes could be viewed as "decentralized wealth transfer systems", and like pyramid schemes, the Resilience protocol promises a reward if the branching scheme continues to grow. In contrast to pyramid schemes, each person stays on top only for a short time since their pathway decays when it acts as a conduit for tax during swarm redistribution.

Branching schemes could be viewed as "positive pyramid schemes". Within Resilience, there will be billions of these "decentralized wealth transfer systems" open at any given time.

branching scheme

The tendency to "chase security" as the "engine" of the Resilience protocol

Pyramid schemes could be viewed as “decentralized wealth transfer systems”, where people invest because they are lured into it by the promise of reward. To join a pyramid scheme is not based on rational decisions, but instead its motivated by systemic biases which humans have.

triune brain

The engine behind branching schemes is then that it would tap into those systemic biases and the tendency of the brain to “chase security”, which produces stigmergic effects where disparate agents choose to use RES without any planning or co-ordination, relying on a hope of a high rate of return.

Basic income targets that systemic bias to chase security, and elevates people up Maslow’s pyramid. The idea with the Resilience protocol is then to use that same bias as an “engine” for a decentralized basic income system.

maslows hierarchy of needs

Resilience as a protocol for "voluntary taxation", or what could also be called "P2P taxation" or "emergent swarm taxation"

The Resilience system is largely based on the tendency for the brain to chase security (taps into circuits of the limbic system and brain stem), whereas nation-state taxation systems are based on the tendency for brains to comply with external coercion, and enculturation through family ties.

P2P taxation would then, like coercive taxation, also use survival instincts as the “engine”. The instincts to secure basic needs could, akin to the instinct to comply with coercion, be viewed as an incentive in rule of law, and would then build the foundation for a voluntary taxation system, a system which reaches a bit higher into the sky compared to more primitive coercive taxation.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment