Almost two centuries ago Pierre-Joseph Proudhon proposed social contracts { voluntary agreements among free people { as a foundation from which an egalitarian and just society can emerge. A digital social contract (DSC) is the novel incarnation of this concept for the digital age: a voluntary agreement between people that is speci ed, undertaken, and ful lled in the digital realm. It embodies the notion of \code-is-law" in its purest form, in that a DSC is a program { code in a social contracts programming language, which speci es the digital actions parties to the social contract may take; and the parties to the contract are entrusted, equally, with the task of ensuring that each party abides by the contract. Parties to a social contract are identi ed via their public keys, and the one and only type of action a party to a DSC may take is a \digital speech act" { signing an utterance with her private key and sending it to the other parties to the contract. We present a formal de nition of a DSC as agents that communicate asynchronously via digital speech acts, where the output of each agent is the input of all the other agents. We outline an abstract design for a social contracts programming language and hint on their applicability to social networks, sharing-economy, egalitarian currency networks, and democratic community governance.
Over the last three decades, the Internet has mushroomed from 0 to 4.6 billion
active \users", 60 per cent of the world population (and more than 90 per cent
in the developed world), the fastest di usion in human history. But what kind of
\society" has it created? The digital realm includes a few powerful entities, who
? Full version available on arXiv [
Use permitted under Creative Commons License Attribution 4.0 International (CC
BY 4.0).
control the entire space, and billions of data subjects, as termed by the EU's
General Data Protection Regulation (GDPR), who have almost no rights and cannot
vote, be consulted, or in uence decision-making. They have no due process (e.g.,
in censorship, account blocking, or privacy violation) and are not the owners of
their data. The structure of the digital space remains \feudal" in nature|people
are not even perceived as digital \citizens" but as \users"|and it is not based
on the ideals on which citizenship in democracies is grounded: liberty,
equality, and popular sovereignty. The digital space is further rampant with sybils
(fake/duplicate accounts) and bots, making it a hostile environment and
untenable for democratic governance. To a large extent, digital technology is the great
unequalizer in today's world, making a few digital \barons" rich and powerful
by pro ting from the multitudes performing digital labour without
compensation. Like feudal lords of yore, the digital barons set their platform's rules of
conduct (legislative), interpretation (judicial), and implementation (executive),
and violate the dictum \no taxation without representation". New technologies
do not support the ideals of democracy. Rather, the design of the digital world
presents a dystopian future, with the global reach of surveillance capitalism [
we advocate the development of DSCs to govern digital human behavior. A DSC
is the digital counterpart of social contract theories, as envisioned centuries ago
by the founding philosophers of the Enlightenment { Thomas Hobbes, John
Locke, Jean-Jacques Rousseau, and Pierre-Joseph Proudhon { and more recent
thinkers, such as John Rawls [
On the technological design, DSCs are programs for a distributed,
locallyreplicated, asynchronous blockchain architecture. DSCs embody the notion of
\code-is-law" in that they are a code in a social-contract programming language,
which speci es the digital actions parties may take and the terms. Unlike present
digital platforms, this code is not in icted on the user by a monopolistic
digital entity to its nancial bene t; rather, people who trust each other enter into
a code-regulated relationship voluntarily. DSCs allow for cooperative behavior
because they disallow faulty, non-cooperative actions; a party can behave only
according to the contract. Agents are expected to employ genuine identi ers and
function as both actors and validators. An agent may participate simultaneously
in multiple social contracts; similarly, each contract may have a di erent set of
agents as parties; the result is a hypergraph with agents as vertices and contracts
as hyperedges. Signed indexed transactions (\digital speech acts"), speci ed and
carried out according to a contract, are replicated only among parties to a
contract, who ratify them, and are synchronized independently by each agent. A
transaction carried out is nalized when rati ed by an appropriate
supermajority of the parties to the contract. A party to a contract is typically an agent who
embodies a natural person via her genuine identi er, but, if deterministic, could
also be a synthetic agent (aka \legal person"), which functions algorithmically,
very similar to a \smart contract" of standard blockchains [
In 2017, Mark Zuckerberg published a vision on how to turn Facebook from
a social network to a \Global Community" governing the planet in most aspects
of life, where every user can vote on \global problems that span national
boundaries" and \participate in collective decision-making" [
Two key concepts are employed in DSCs: (1) Digital Speech Acts: Each
party to a DSC is equipped with a key pair { a public key and a private key
(PKI), with which they can digitally sign text strings and verify each other's
signatures. All that a computational agent can do, as a party to a DSC, is
perform and perceive digital speech acts, namely sign a digital utterance and send
it to the other agents that are parties to the contract, or receive signed digital
utterances from these agents. (2) The Person as an Oracle: Computational
agents in a DSC face nondeterministic choices: Which room to book, when and
where? How much to pay and to whom? How to vote on a proposal to accept a
new member to the contract? Computational agents have no volition or free will
and hence cannot make such choices on their own. Therefore, nondeterministic
choices in the social contract code are interpreted as Oracle calls, where the
human operating the computational agent serves as the Oracle. In other words,
nondeterministic choices in the code of an agent specify the interactions
between the \software" and the \user", namely between the computational agent
and the person operating it: When faced with a nondeterministic choice, the
computational agent consults its human operator as to which choice to make.
Related Work The concepts and design presented here are reminiscent of
the notions of blockchains [
A fundamental tenet of our design is that social contracts are made between
people who know and trust each other, directly or indirectly via other people
that they know and trust. This is in stark contrast to the design of
cryptocurrencies and their associated smart contracts, which are made between anonymous
and trustless accounts. A challenge cryptocurrencies address is how to achieve
consensus in the absence of trust, and their solution is based on proof-of-work [
Here we describe a formal model for DSCs { for space constraints, we do not
provide full formal de nitions for some preliminaries. We assume a given nite set
of agents V , each associated with a genuine (unique and singular) [
De nition 1 (Digital Speech Act, v-act). Given a set of agents V , a digital speech act of agent v 2 V consists of (i) signing an utterance (text string) s, resulting in m = v(s); and (ii) broadcasting the message m to V . We refer to a digital speech act by v resulting in the signed action m as the v-act m, and let
De nition 2 (Transition System). A transition system T S = (S; s0; T ) consists of a set of states S, an initial state s0 2 S, and a set of transitions T , T S S, with (s; s0) 2 T written as s ! s0. The set s ! = fs^ j s ! s^ 2 T g is the outgoing transitions of s. A run of T S is a sequence of transitions r = s0 ! s1 ! : : : from the initial state. A family of transition systems T (S) over
Here we de ne DSCs in the abstract; in particular, we do not address a
distributed realization nor agent faults. These issues are addressed in a companion
paper [
De nition 3 (v-act, History). We refer to m = v(a), the result of signing an action a 2 A by agent v 2 V , as a v-act, let M denote the set of all v-acts by all v 2 V , and refer to members of M as acts. A history is a nite sequence of acts h = m0; m1; : : : mn, n 2 N , mi = vi(ai) 2 M, i 2 [n], ai 2 A, vi 2 V . The set of all histories is denoted by H.
De nition 4 (Pre x, Consistent Histories). Given a sequence s = x1; x2; : : : xn, a sequence s0 is a pre x of s, s0 s, if s0 = x1; x2; : : : xk, for some k n. h[u] is the restriction of h to the subsequence of u-acts. Two agent histories h; h0 2 H are consistent if either h[v] h0[v] or vice versa for every v 2 V .
I.e., histories are consistent if they agree on the subsequences signed by each agent. A ledger of a DSC is an indexed tuple of histories of the parties to the contract. Ledgers are the states of the social contract transition system. De nition 5 (Ledger). A ledger l 2 L := HV is a tuple of histories indexed by the agents V , where lv is the history of agent v in l, or l's v-history.
Following De nition 4, we apply the notation lv[u] to denote the subsequence of u-acts in the v-history in l. Our key assumption is that in a ledger that is 7 As agents have public keys with which they sign their sequentially-indexed messages, such a network can be easily realized on an asynchronous network that is not orderpreserving and is only intermittently reliable. a state of a computation, each agent's history is up-to-date about its own acts. Therefore, for agent histories to be consistent with each other, the history of each agent can include at most a pre x (empty, partial or complete) of every other agent's acts. In particular , the history of v cannot include u-acts di erent from the one's taken by u; nor can it run ahead of u and \guess" acts u might take in the future. A ledger is not a linear data structure, like a blockchain, but a tuple of independent agent histories, each of them being a linear sequence of acts. Furthermore, note that lv, the history of v in ledger l, contains, of course, all v-acts, but it also contains acts by other agents received by v via the communication network. Also, note that the v-history lv may be behind on the acts of other agents but is up-to-date, or even can be thought of as the authoritative source in l, regarding its own v-acts.
De nition 6 (Ledger Diagonal, Sound Ledger). Given a ledger l 2 L, the diagonal of l, l , is de ned by lv := lv[v] for all v 2 V . A ledger is sound if lu[v] lv for every u; v 2 V .
As we assume that each agent is up-to-date about its own acts, the diagonal contains the complete sequence of v-acts for each agent v 2 V . Thus, each agent history in a ledger re ects the agent's \subjective view" of what actions were taken, where the diagonal of a ledger contains the \objective truth" about all agents. Next we de ne transitions among these states.
De nition 7 (Transitions). The set of social contract transitions T L L consists of all pairs t = l ! l0 2 L L where l0 = l except for lv0 := lv m, m = u(a) 2 M for some u; v 2 V and a 2 A. The transition t is referred to as a v-transition, and can also be written as t = l (v;m!) l0. tu De nition 8 (Input, Output and Sound Transitions). A v-transition t = l (v;u(a)!) l0 is output if u = v and input if u 6= v. A transition is sound if it is either input with lv0[u] lu[u] or output.
Observation 1 If l is sound and l ! ^l 2 T is sound then ^l is sound.
The next de nition aims to capture the following two requirements: Output - an agent v may take a v-act in state l based solely on its own history lv. In particular, v is free to ignore, or to not know, the other agents' histories in l; Input - v must accept messages from the communication network in any proper order the network chooses to deliver them.
De nition 9 (Closed Set of Transitions). A set of transitions T T is:
transitions t = l (v;m!) ^l, t0 = l0 (v;m!) ^l0 2 T , if lv = lv0 then t 2 T i t0 2 T .
for all u 6= v.
De nition 10 (Digital Social Contract). A DSC among a set of agents V is a transition system SC = (S; l0; T ) with ledgers as states S L, initial state l0 := V , and a closed set of transitions T T . The family of all DSCs over S is denoted by SC(S), and SC(L) is abbreviated as SC.
SC is the family of abstract social contracts, in contrast to its more concrete implementations, and view such as speci cations for programs in a SocialContracts Programming Language.
Example 1 (A Currency Community: Example of a DSC). Let A = fpay(v)gv2V be the set of acts. A message m = u(pay(v)) corresponds to a payment of 1 coin from u to v. A transition t = l w;u(pay(v)!) l0 records in lw a payment of 1 coin from u to v. Agent u can record a payment from u to v only if the balance of u, according to lu, is positive. Formally, let lu = m1; m2; :::; mn, with mi = wi(pay(vi)). Set bal(u) := c + jf1 i n : vi = ugj jf1 i n : wi = ugj, for some c > 0, and let T = fl u;u(pay(v)!) l0 : bal(u) > 0g. Let T T~ denote the closure of T in T . The DSC SC = (S; l0; T~) over the set of agents V speci es a currency community where each agent u 2 V is initially granted c coins. 3
Here we outline the design of a simple social contract programming language. Abstractly, all that an agent can do, as a party to a social contract, is take acts based on its history, and receive acts by others. In a practical social contract, the acts an agent can take typically depend on salient features of its history, rather than on the history in its entirety. So, given that social contracts employ a closed set of transitions, the possible behaviors of an agent can be characterized by a (not necessarily nite and possibly nondeterministic) state transducer. A state transducer reads an input tape (in our case the inputs of an agent v) and writes an output tape (in our case the sequence of v-acts), changing its state in the process. The history of an agent fully speci es, even synchronizes, both tapes.
Hence, our programming language endows each agent with an internal state, which can be viewed as a digest of its history. As in a state transducer, the agent's state may change as a result of an input or an output. Therefore, our proposed Social-Contracts Programming Language (SCPL) presents the program of an agent v as a set of rules of the following form:
where S is the internal state (state, for short) of v prior to taking the transition, m is an input u-act by some u 6= v 2 V , m0 is an output v-act, S0 is the updated state of v, and Conditions are any conditions on S, m, m0, and S0, that are required for the transition to take place. The intended meaning of such a rule is that an agent in internal state S, upon receiving an act m, may take act m0 and change its internal state to S0, if Conditions are satis ed. Note that degenerate rules, i.e., rules that do not have input m and/or output m0 and/or Conditions are allowed. Next we provide an example. 3.1 Egalitarian Governance of Social Contracts We provide a code example implementing the standard principle of democracy, namely \one person, one vote", in e ect showing how a community may form democratically. For simplicity, decisions to add or remove a member are taken by a simple majority, using a secretary that handles ballots, is autonomous, and initiated by the founder.
Program 1: Democratic WhatsApp-like Group founder --> autonomous#secretary([Self]), member. secretary(Members), _(propose(X)) -->
ballot(X,Members,0), secretary(Members). secretary(Members), ballot(X,[],Result) -->
secretary_apply(X,Result,Members). secretary_apply(X,Result,Members) -->
secretary(Members) where Result =< 0. secretary_apply(add(Member),Result,Members) ->
Member#member, secretary([Member|Members]) where Result > 0. secretary_apply(remove(Member),Result,Members) --> please_leave(Member), secretary(Members') where Result > 0,
Members' is the result of removing Member from Members. member --> says(X), member. member, ballot(X,[Self|Members],R) --> ballot(X,Members,R'), member where R' := R, R+1, or R-1. member, _(please_leave(Self)) --> says(bye), stop. member --> says(bye), stop.
Note that this is a very simple program, in particular as (1) there is no option to decline an invitation (2) agents must wait for other agents to vote. Indeed, we provide the program mainly as a proof of concept, but to implement a practical democratic decision process, more complex program is needed. We also note that votes are public to the community members and are not anonymous.
Outlook. We have introduced the concept of DSCs, provided a mathematical
de nition of them, outlined a design for a social contracts programming language,
and demonstrated its social utility via program examples. Much remains to be
done; some is discussed in companion papers [
Ehud Shapiro is the Incumbent of The Harry Weinrebe Professorial Chair of Computer Science and Biology. We thank the generous support of the Braginsky Center for the Interface between Science and the Humanities. Nimrod Talmon was supported by the Israel Science Foundation (ISF; Grant No. 630/19).