Skip to content
Option | How to Help
Option | How to Help

Deposing the Dictator

We’ve shown in that even in instances where a single person can dictate the endorsement behavior of the entire global economy, users of Index Wallets — including those dictators of endorsements — still have a selfish incentive to fund public goods and to purchase from less wealthy vendors.
We used this assumption of an endorsement dictator to derive an inequality which states that as long as the inflation (left hand term) is less than the profit on a sale, then they should make the sale.
r in this case is from the perspective of the shopkeeper after they receive the payment. The shopkeeper is thinking, “I paid $750 for this item, if I sell it for $1000 I’ll have made $250.” They have their own list of endorsements which informs what counts to them as $250. Now a new customer comes along with new money and the shopkeeper has a choice. If they legitimize the new currency by endorsing it above 0, they’ll endure inflation, but they’ll lower the price for their customer.
Both of these effects rely on the endorsement dictator assumption. The fact that inflation occurs at all is due to the fact that the shopkeeper’s endorsements are mirrored by everyone else. Meanwhile, the fact they can change their endorsement without concern for whether the next person they pay will accept it at the new face value (whether r_before is the same as r_after) is also thanks to the endorsement dictator assumption.
What happens when we loosen this assumption and instead assume people don’t have global control over endorsement behavior?

It’s been really hard to do this analytically, so here’s some code that’s proven useful in running experiments and writing simulations:
class Wallet:
pass # Placeholder definition because python is bad at types

class Valuation(np.ndarray):
def __new__(cls, input_array):
obj = np.asarray(input_array, dtype=np.float64).view(cls)
return obj

class Wallet(np.ndarray):
def __new__(cls, input_array):
obj = np.asarray(input_array, dtype=np.float64).view(cls)
return obj

def value(s, valuation: Valuation):
return np.sum(s * np.array(valuation))

def index(s, valuation: Valuation, quantity: float):
value = s.value(valuation)
if value == 0:
return Index(np.zeros_like(s))
return Index(s * (quantity / value))

def conciliation(s, source: Wallet, target: Wallet, quantity: float):
return s.index(target, quantity).value(source) - quantity

def payment(s, source: Wallet, target: Wallet, quantity: float):
return s.index(source, s.conciliation(source, target, quantity) + quantity)

def send(s, payer: Wallet, recipient: Wallet):
raise TypeError(
"The send method should be called on an Index object, not a Wallet. "
"You can create an Index object with the `index` or `payment` method. "
"Example: `index = wallet.index(valuation, quantity)`, then call "
"`index.send(wallet, recipient)`."

class Index(Wallet):
def __new__(cls, input_array):
return super().__new__(cls, input_array)

def send(s, payer: Wallet, recipient: Wallet):
if np.any(payer - s < 0):
raise ValueError(
"Insufficient funds: Attempting to send more than available in the wallet."
payer -= s
recipient += s
return payer, recipient
You can find a Colab notebook here to play around with this in your browser:

Basically, the goal here is to write a simulation which allows us to answer questions about how economies behave when people pay via Index Wallets. There are so many questions. Some obvious ones:
How does the magnitude of a player’s benefit relate to their valuation?
What’s a player’s incentive to endorse a particular currency when they benefit?
Are the permission (and wealth) equalizing dynamics of the initial article maintained under what conditions?
Can we recover the conditions required to replicate the results of the original article? I.e. what conditions give rise to our endorsement dictator as a special case of a more general theory?
What happens along “benefit boundaries”; players that disagree on the value of the public good a token funds (e.g. hunters and mountain bikers on the topic of trails)

An intermediate result here would be answer the question of optimal valuation:
Let’s imagine that a player has perfect information about the demand and supply curves of all other players in the market, as well as how much they benefit, and the tokens they hold (extremely improbable assumptions that completely violate privacy and maybe physics, but always useful to start with perfect information and then work backward).
First Order: Given all this information, how should a player update their valuation so as to maximize revenue and minimize costs?
Second Order: Given their knowledge of market sensitivity to their moves, how should they change their valuations so as to maximize their profit and the funding for projects they benefit from (including are paid by)?

Some useful terms

vendor: a person who sells something.
customer: the person who buys from a vendor
supplier: a vendor’s vendor. A vendor buys from a supplier
shopkeeper: the first vendor who is our protagonist

Here’s a series of working sessions where we try to create a simulation that will allow us to depose the dictator:

Want to print your doc?
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
) instead.