The dividend pathways build on top of one another, so as long as tax is being contributed, new pathways grow, driven by the promise of getting something back. I compared it with a pyramid scheme a while back, as a sort of "positive pyramid scheme" (Waters, 2016) where pyramid schemes are "decentralized wealth transfer systems".

I call the dividend pathway webs "branching schemes" from that, and they're conceived to be an ever-ongoing, fractal system that is based on whatever it is that makes people invest in pyramid schemes (since whatever that is it seems to work pretty well. )

Using smart contracts to build a swarm redistribution network

Dividend pathways can be implemented in a smart contract on Ethereum with the ERC20 standard using just a few lines of code.

function transfer(address _to, uint256 _value) {

            /* Calculate tax */
            uint256 taxCollected = _value * taxRate / 1000;
            
            /* Verify Proof-of-Individuality */
            bool isHuman = proofOfIndividuality.verifyPOI(msg.sender);

            /* Create the dividend pathway */
            dividendPathways[_to].push(dividendPathway({
                from: msg.sender,
                amount: _value,
                timeStamp: now,
                isHuman: isHuman
            }));

            /* Distribute the tax as credit to the swarm tree */
            swarmRedistribution(_to, now, taxCollected);

            /* Add and subtract new balances */

            balanceOf[msg.sender] -= _value;
            balanceOf[_to] += _value - taxCollected;

            /* Notifiy anyone listening that this transfer took place */
            Transfer(msg.sender, _to, _value);
}

The timeStamp makes the pathways branch out in chronological branching schemes.

When pushing the tax into the pathways as how blood flows through veins or capillaries, filter by timestamps at each intersection.

function iterateThroughSwarm(address _node, uint _timeStamp, uint _taxCollected) internal {
            for (uint i = 0; i < dividendPathways[_node].length; i++) {

                    uint timeStamp = dividendPathways[_node][i].timeStamp;
                    if (timeStamp <= _timeStamp) {

                            address node = dividendPathways[_node][i].from;

                            if (
                                    dividendPathways[_node][i].isHuman == true &&
                                    inHumans[node] == false
                            ) {
                                    humans.push(node);
                                    inHumans[node] = true;
                            }

                            if (dividendPathways[_node][i].amount - _taxCollected > 0) {
                                    dividendPathways[_node][i].amount -= _taxCollected;
                            } else removeDividendPathway(_node, i);

                            iterateThroughSwarm(node, timeStamp, _taxCollected);
                    }
            }
}