Skip to content
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:
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.
This is not the way.
Try clicking the ⋯ next to your doc name or using a keyboard shortcut (
CtrlP
) instead.