With a curve like ratio = 1 − (distance/maximum_propagation_distance)^2
,
where distance is in number of people, along a radius from the origin point of the swarm redistribution pulse (horizontally at any given distance people get the same ratio, only decreases with distance), maximum_propagation_distance
is how far the pulse travels, an example being maximum_propagation_distance = 10
.
The swarm redistribution pulse itself can be separated into segments, and employees can be used similar to miners, who are rewarded with a tiny bit of the universal basic income reward (has to be higher than gas cost, but as low as possible after that based on market price. ) Any miner can choose to process as big a segment as they wish, using uint _iterate
, and continue on what others have processed, using _tip
(latest node at some point in a pulse), and can pre-compute the pulse off-state to know how many iterations is profitable.
function processSegment(bytes32 _taxID, uint _tip, uint _iterate) {
address root = taxRecord[_taxID].tips[_tip].node;
uint timestamp = taxRecord[_taxID].tips[_tip].timestamp;
uint rootHuman = taxRecord[_taxID].tips[_tip].rootHuman;
uint distance = taxRecord[_taxID].distance[rootHuman];
computeSwarm(root, timestamp, distance, _iterate, _taxID);
delete iterateCount;
}
That the swarm redistribution "pulse" can be done in segments is a way to manage GAS costs and potential transaction size limitations (with that, block size limitations on Ethereum are no problem. )
The computeSwarm()
function then looks something like this:
function computeSwarm
(
address _node,
uint _timeStamp,
uint _distance,
uint _iterate,
bytes32 _taxID
)
internal
{
for (uint i = 0; i < dividendPathways[_node].length; i++) {
address node = dividendPathways[_node][i].from;
uint timeStamp = dividendPathways[_node][i].timeStamp;
if (timeStamp <= _timeStamp && taxRecord[_taxID].distance[node] == 0) {
if (verifyPoP[node] == true) {
_distance++;
taxRecord[_taxID].distance[node] = _distance;
// Get values for capping the amount of basic income using auto-regulation from a bell curve
taxRecord[_taxID].bellcurve.basicincome[node] = basicIncome[node];
taxRecord[_taxID].bellcurve.total += basicIncome[node];
if(_distance < 10) {
uint ratio = 1 − (_distance/10)^2;
taxRecord[_taxID].ratio[node] = ratio;
taxRecord[_taxID].sum += ratio;
}
}
if(iterateCount <= _iterate) {
iterateCount++;
computeSwarm(node, timeStamp, _distance, _iterate, _taxID);
}
}
}
}