5D Library › Mechanism Design, Vickrey–Clarke–Groves Auctions and Incentive-Compatible Community Engineering · 中文

Chapter 6 Community Incentives: Points Inflation, Badges and Sybil Attacks

The mechanisms of the previous five chapters have clear “objects” and “payments”. The incentive rules of online communities (points, levels, badges, leaderboards, reputation scores) can be analysed in the same language: points are a currency circulating only inside the community, badges are signals and goals, and a reputation score is a function that aggregates many people’s assessments into one number. This chapter asks three questions: why points “inflate”; how badges change behaviour, and how strong the evidence is; and whether reputation functions can be broken when people can cheaply register several identities. All community data in this chapter are simulated; the points-inflation model and the Sybil cost boundary are the author’s models.

Points are a currency

If a community lets points be exchanged for something scarce (mentoring slots, places at events, merchandise), points acquire a price: how many points one unit of reward is worth. The literature on designing virtual economies calls the rules that issue currency “faucets” and those that absorb it “sinks”, and discusses how to balance them (Lehdonvirta and Castronova 2014). The most direct analogy is Fisher’s quantity equation MV=PTMV = PT (Fisher 1911): under the assumption that rewards are allocated at market-clearing prices, the stock of points MM, the share VV spent each period, the quantity of rewards YY available each period and the points price PP satisfy P=VM/YP = VM/Y. This is only an analogy: community points usually cannot be traded freely and prices are often set by moderators; under a fixed price, “inflation” shows up as queues, rewards that cannot be obtained and ever-rising redemption thresholds.

The author’s model. Each month membership NtN_t grows by 4 % and each member receives e=100e = 100 points; Y=200Y = 200 units of reward are allocated each month at the clearing price, ν=25%\nu = 25\% of the stock is bid each month, and redeemed points are destroyed; an optional expiry rate is λ\lambda:

Mt+1=(1−ν−λ)Mt+eNt,Pt=νMt/Y.M_{t+1} = (1 – \nu – \lambda)\,M_t + e\,N_t, \qquad P_t = \nu M_t / Y .

Five scenarios: A, fixed points per member; B, a fixed total issue (the more members, the fewer points each); C, A with 4 % monthly expiry; D, rewards growing in proportion to membership; E, A plus, from month 12, a share of members automating cheap actions to earn five times the points (the share rises by 5 percentage points a month, up to 30 %).

Calculation

# Chapter 6. The author's model of points inflation in an online community (an analogy
# with the quantity equation M V = P Y, not a model of any real platform; all numbers
# are illustrative). Monthly: members N_t grow at g; each member earns e points; the
# community offers Y reward units (e.g. mentoring slots) that are allocated at a
# market-clearing points price; a fraction nu of the outstanding stock M_t is bid each
# month, so P_t = nu M_t / Y, and redeemed points are burned:
#     M_{t+1} = (1 - nu) M_t + e_t N_t - lambda M_t      (lambda: expiry, a "sink")
# Scenarios: A fixed points per member; B fixed total issuance (per-member points fall
# as the community grows); C A plus 4 % monthly expiry; D A, rewards grow with members;
# E A, plus "farming": from month 12 a share of members automate cheap actions and
# earn 5 times the points.
def run(T=36, N0=1000, g=0.04, e=100.0, Y0=200.0, nu=0.25, mode="A"):
    N, M = float(N0), e * N0 / nu                  # start in the steady state of A
    path = []
    for t in range(T + 1):
        Y = Y0 * (N / N0 if mode == "D" else 1.0)
        P = nu * M / Y; path.append(P)
        if mode == "B":
            issue = e * N0
        elif mode == "E" and t >= 12:
            farm = min(0.3, 0.05 * (t - 11))       # farming spreads 5 points a month
            issue = e * N * (1 - farm) + 5 * e * N * farm
        else:
            issue = e * N
        lam = 0.04 if mode == "C" else 0.0
        M = (1 - nu - lam) * M + issue; N *= 1 + g
    return path

if __name__ == "__main__":
    labels = {"A": "fixed points per member", "B": "fixed total issuance",
              "C": "A + 4 % monthly expiry", "D": "rewards grow with members",
              "E": "A + point farming from month 12"}
    print("points price of one reward unit (month 0 = steady state of A, e N / Y = 500)")
    print("  scenario                           m0      m12      m24      m36  "
          "value of 100 pts")
    for k, lab in labels.items():
        p = run(mode=k)
        print(f"  {k} {lab:31s} {p[0]:6.1f} {p[12]:8.1f} {p[24]:8.1f} {p[36]:8.1f}"
              f"  {100 / p[36]:6.3f} units")
    a, b = run(mode="A"), run(mode="B")
    print(f"A: monthly inflation in the last year {(a[36] / a[24]) ** (1 / 12) - 1:.2%}"
          f" (membership growth 4 %); B: {(b[36] / b[24]) ** (1 / 12) - 1:+.2%}")
    print(f"B keeps prices stable, but points per member fall to"
          f" {100 / 1.04 ** 36:.1f} by month 36 (from 100)")
# points price of one reward unit (month 0 = steady state of A, e N / Y = 500)
#   scenario                           m0      m12      m24      m36  value of 100 pts
#   A fixed points per member          500.0    692.3   1104.9   1768.9   0.057 units
#   B fixed total issuance             500.0    500.0    500.0    500.0   0.200 units
#   C A + 4 % monthly expiry           500.0    608.4    971.0   1554.5   0.064 units
#   D rewards grow with members        500.0    432.4    431.1    431.0   0.232 units
#   E A + point farming from month 12  500.0    692.3   2361.7   3889.5   0.026 units
# A: monthly inflation in the last year 4.00% (membership growth 4 %); B: +0.00%
# B keeps prices stable, but points per member fall to 24.4 by month 36 (from 100)

The starting point is scenario A’s steady-state price eN/Y=500eN/Y = 500. In scenario A the price reaches 1,768.9 after 36 months, and monthly inflation in the last year is 4.00 %, exactly the membership growth rate: when issuance grows with membership and rewards do not, points lose value at the rate of membership growth; 100 points buy only 0.057 units of reward at month 36. Expiry (C) lowers the price level somewhat (1,554.5) but cannot change its growth rate. B holds the price at 500, at the cost of cutting each member’s monthly points from 100 to 24.4; long-standing members see “the same contribution earning fewer and fewer points”. D is the only scenario that is both stable and undiluted, but it requires the real supply of rewards to grow with the community. E shows the effect of point farming: the price reaches 2,361.7 at month 24 and 3,889.5 at month 36, and 100 points are worth only 0.026 units.

The model offers not a prediction but an accounting relation: the real value of points depends on the difference between the growth of issuance and the growth of real rewards. It also explains why “points inflation” and Goodhart’s law (Book 27) so often appear together: when points are issued for an action that can be farmed, farming both increases the supply of points and decouples points from real contribution.

Note

The crowding-out of external rewards (Book 24). Book 24 discussed how expected tangible rewards contingent on engagement, completion or performance lower intrinsic motivation for tasks people find interesting (a meta-analysis of 128 experiments), whereas unexpected rewards and verbal positive feedback have no such effect or a positive one. Points that can be exchanged for goods are closer to “tangible rewards”; points that merely record and acknowledge are closer to “feedback”. This distinction matters as much as inflation when points are designed; Book 24’s evidence is not repeated here.

Badges: evidence and a simplified model

Evidence

Anderson, Huttenlocher, Kleinberg and Leskovec studied badges using Stack Overflow’s activity records from its launch in July 2008 to the end of 2010 (Anderson et al. 2013). In their model users have a preferred distribution of actions, deviating from it is costly, and a badge gives a one-off value when an action count reaches a threshold; the model predicts that users “steer” towards a badge as they approach the threshold, more strongly the closer they are, and return to their usual distribution afterwards. The data agree: before the “Electorate” badge (600 votes on questions, with a ratio condition relative to votes on answers), users cast more votes on questions and fewer on answers, returning to baseline soon after receiving the badge; users’ overall activity also rose in the days before they earned such badges. From the model they also derive that the threshold maximising the targeted action for a single badge lies at an interior point far from the origin, and that two badges are best spread roughly evenly with similar values.

On gamification more generally: Hamari, Koivisto and Sarsa reviewed 24 empirical studies; most reported positive effects, but the effects depended on context and users and the studies had many methodological limitations (Hamari et al. 2014). Sailer and Homner’s meta-analysis found effects of gamification on learning of g=0.49g = 0.49 for cognitive outcomes (19 studies, 1,686 participants), g=0.36g = 0.36 for motivational and g=0.25g = 0.25 for behavioural outcomes; but in the subset of rigorously designed studies only the cognitive effect remained significant (g=0.42g = 0.42), while the motivational and behavioural effects did not; the authors describe all three effects as significant small effects (Sailer and Homner 2020).

The program below is a simplified rewrite of the model of Anderson and co-authors (two actions only, without the option of leaving the site); it is not their code and its numbers cannot be compared with theirs. At each step the user takes the target action A1 with probability xx; her preferred probability is p=0.05p = 0.05, deviating costs 2(x−p)22(x-p)^2, she stays on the site with probability θ=0.99\theta = 0.99 per step, and she receives a badge worth VV at her kk-th A1 action.

Calculation

# Chapter 6. A simplified two-action version of the badge model of Anderson,
# Huttenlocher, Kleinberg and Leskovec (2013); our simplification, not their code or
# their numbers. Each step the user takes action A1 with probability x (otherwise
# something else); her preferred rate is p, deviating costs c * 2 (x - p)^2 per step,
# she stays on the site to the next step with probability theta, and a badge worth V is
# awarded at the k-th A1 action (after which she reverts to p). With a = A1 actions so
# far, U(a) = max_x [ -2c(x - p)^2 + theta (x U(a+1) + (1 - x) U(a)) ], U(k) = V.
P, THETA, C, V = 0.05, 0.99, 1.0, 5.0
XS = [i / 2000 for i in range(2001)]

def solve(k, V=V):
    U, X = [0.0] * (k + 1), [0.0] * k
    U[k] = V
    for a in range(k - 1, -1, -1):
        best = None
        for x in XS:
            val = (-2 * C * (x - P) ** 2 + THETA * x * U[a + 1]) / (1 - THETA * (1 - x))
            if best is None or val > best[0]:
                best = (val, x)
        U[a], X[a] = best
    return U, X

def a1_yield(k, V=V):                              # expected lifetime A1 actions
    _, X = solve(k, V); A = P / (1 - THETA)        # after the badge: rate p
    for a in range(k - 1, -1, -1):
        x = X[a]; A = (x + THETA * x * A) / (1 - THETA * (1 - x))
    return A - P / (1 - THETA)                     # extra over no badge

if __name__ == "__main__":
    U, X = solve(60)
    print("badge at k = 60: optimal A1 rate x(a) by A1 actions already taken a")
    print("  a:  " + "".join(f"{a:7d}" for a in (0, 10, 20, 30, 40, 50, 55, 59)))
    print("  x:  " + "".join(f"{X[a]:7.3f}" for a in (0, 10, 20, 30, 40, 50, 55, 59)))
    print(f"  preferred rate p = {P}; after the badge x returns to {P}")
    ks = list(range(5, 121, 5))
    print(f"extra lifetime A1 actions induced (no-badge baseline {P / (1 - THETA):.1f})")
    print("  badge value V   k=5    k=10   k=20   k=40   k=80   best k on grid (yield)")
    for v in (5.0, 20.0, 50.0):
        ys = [a1_yield(k, v) for k in ks]; kb = ks[ys.index(max(ys))]
        cells = "".join(f"{ys[ks.index(k)]:7.2f}" for k in (5, 10, 20, 40, 80))
        print(f"  {v:13.0f}" + cells + f"   {kb:4d} ({max(ys):.2f})")
# badge at k = 60: optimal A1 rate x(a) by A1 actions already taken a
#   a:        0     10     20     30     40     50     55     59
#   x:    0.050  0.050  0.051  0.053  0.068  0.105  0.134  0.159
#   preferred rate p = 0.05; after the badge x returns to 0.05
# extra lifetime A1 actions induced (no-badge baseline 5.0)
#   badge value V   k=5    k=10   k=20   k=40   k=80   best k on grid (yield)
#               5   2.70   3.99   3.15   0.29   0.00     15 (4.00)
#              20   3.79   6.72   9.69   4.53   0.01     20 (9.69)
#              50   4.24   7.94  13.51  15.73   0.41     35 (16.44)

With a threshold of 60 the user barely changes her behaviour for the first 30 actions (xx from 0.050 to 0.053), steers more the closer she gets, reaching 0.159 just before the badge, and returns to 0.05 afterwards: the “acceleration” shape of the original paper. The second table gives the extra A1 actions induced over a lifetime (the no-badge baseline is 5.0): with a badge worth 5 the best threshold is 15 (4.00 extra), a threshold of 40 adds only 0.29 and one of 80 almost nothing, because the user expects not to stay long enough; with badges worth 20 and 50 the best threshold moves to 20 and 35. Too low a threshold makes the badge “too easy” and induces little; too high and users give up. The best threshold depends on the badge’s value and on retention, which have to be estimated, not guessed.

Left: in the simplified badge model, the share of the target action chosen by the user as a function of actions already completed (three thresholds); dotted line: preferred share. Right: power curves of the Chapter 8 experiment under three assumptions about individual differences (normal approximation); vertical line: the planned 150 per arm.

Reputation and Sybil attacks

A community’s reputation score aggregates many people’s assessments into one number. Book 35 discussed reputation norms (image scoring, simple standing and stern judging), assuming that each person has one identity. In online communities identities are cheap, and that assumption often fails.

In 2002 Douceur called “one entity presenting multiple identities” a Sybil attack and argued that without a logically centralised trusted certifying authority, Sybil attacks are always possible except under unrealistic assumptions such as complete resource parity and coordination among entities (Douceur 2002). Friedman and Resnick analysed “cheap pseudonyms” from an economic angle: if leaving and returning under a new identity costs almost nothing, a bad reputation has no bite, and in equilibrium newcomers must “pay their dues” (start with the lowest trust), a social cost borne by honest newcomers (Friedman and Resnick 2001). Cheng and Friedman formalised the problem: a reputation function is sybilproof if an attacker who creates any number of identities that recommend one another cannot raise his reputation; they proved that symmetric reputation functions (which do not distinguish nodes by name, such as PageRank (Page et al. 1999)) cannot be sybilproof, whereas asymmetric functions based on “flow from trusted seeds” can (Cheng and Friedman 2005). In practice TrustRank propagates trust only from manually vetted trusted pages (Gyöngyi et al. 2004), and SybilGuard limits the number of Sybil identities by exploiting the fact that there are only a few “attack edges” between the honest region and the Sybil region of a social network (Yu et al. 2006).

The program below places an attacker in a recommendation network of 200 honest members (each recommends 4 others at random; 5 are trusted seeds): he recommends 4 honest members and is recommended by 2 of them (the attack edges). He then creates kk fake identities, each of which recommends him and each of which he recommends. The program compares three reputation functions: PageRank, personalised PageRank teleporting only to the seeds (TrustRank-like), and the maximum flow from the seeds to the node.

Calculation

# Chapter 6. Sybil attacks on reputation (illustrative graph, not a real platform).
# 200 honest members, each endorsing 4 random others; 5 honest members are trusted
# seeds. An attacker (node 200) endorses 4 honest members and is endorsed by 2 of them
# ("attack edges"). He then creates k fake identities; each endorses him and he
# endorses each. Three reputation functions:
#   PR   PageRank, damping 0.85, uniform teleport (symmetric: every node treated alike)
#   TR   personalised PageRank teleporting to the seeds only (TrustRank-like)
#   MF   max-flow from the seeds to the node, unit capacity per endorsement
# Cheng and Friedman (2005): symmetric functions cannot be sybilproof; flow-based ones
# can. Last part: the author's cost-boundary model for a top-10 bonus.
import collections, random

def graph(k, rng_seed=6):
    rng = random.Random(rng_seed); n = 200; out = collections.defaultdict(set)
    for i in range(n):
        while len(out[i]) < 4:
            j = rng.randrange(n)
            if j != i:
                out[i].add(j)
    A = n
    out[A] |= set(rng.sample(range(n), 4))
    for i in rng.sample(range(5, n), 2):
        out[i].add(A)
    for s in range(n + 1, n + 1 + k):
        out[s].add(A); out[A].add(s)
    return out, n + 1 + k, A

def pagerank(out, N, tele, it=80, d=0.85):
    r = [1.0 / N] * N
    for _ in range(it):
        nr = [(1 - d) * tele[i] for i in range(N)]
        for i in range(N):
            share = d * r[i] / len(out[i])
            for j in out[i]:
                nr[j] += share
        r = nr
    return r

def maxflow(out, N, seeds, t):
    cap = collections.defaultdict(int); adj = collections.defaultdict(set); S = N
    for i in range(N):
        for j in out[i]:
            cap[i, j] += 1; adj[i].add(j); adj[j].add(i)
    for s in seeds:
        cap[S, s] = 10 ** 6; adj[S].add(s); adj[s].add(S)
    flow = 0
    while True:
        prev = {S: None}; q = collections.deque([S])
        while q and t not in prev:
            u = q.popleft()
            for v in adj[u]:
                if v not in prev and cap[u, v] > 0:
                    prev[v] = u; q.append(v)
        if t not in prev:
            return flow
        v = t
        while prev[v] is not None:
            u = prev[v]; cap[u, v] -= 1; cap[v, u] += 1; v = u
        flow += 1

if __name__ == "__main__":
    seeds = range(5); rows = []
    print("   k   PR score  PR rank   TR score  TR rank   MF (max-flow from seeds)")
    for k in (0, 1, 2, 5, 10, 20, 50):
        out, N, A = graph(k)
        pr = pagerank(out, N, [1.0 / N] * N)
        tr = pagerank(out, N, [0.2 if i < 5 else 0.0 for i in range(N)])
        hon = list(range(200)) + [A]                # rank among real members only
        rk = lambda sc: 1 + sum(sc[i] > sc[A] for i in hon)
        mf = maxflow(out, N, seeds, A); rows.append((k, rk(pr)))
        print(f"  {k:2d}  {pr[A] * 1000:8.3f}  {rk(pr):7d}  {tr[A] * 1000:9.3f}"
              f"  {rk(tr):7d}   {mf:3d}")
    out, N, A = graph(0)
    honest_mf = sorted(maxflow(out, N, seeds, i) for i in range(5, 200))
    print(f"honest members' max-flow: median {honest_mf[len(honest_mf) // 2]},"
          f" range {honest_mf[0]}..{honest_mf[-1]} (scores x 1000 for PR and TR)")
    B = 100.0                                      # author's model: top-10 bonus
    need = min((k for k, r in rows if r <= 10), default=None)
    print(f"cost boundary (author's model): top-10 bonus {B:.0f}, reached under PR"
          f" with k = {need} fakes;")
    print(f"  the attack pays unless each fake identity costs more than B / k ="
          f" {B / need:.1f}")
#    k   PR score  PR rank   TR score  TR rank   MF (max-flow from seeds)
#    0     3.065      161      3.012      110     2
#    1     4.307      107      3.518       96     2
#    2     5.662       66      3.962       83     2
#    5    10.191        9      5.019       65     2
#   10    18.568        1      6.199       45     2
#   20    36.081        1      7.526       31     2
#   50    84.253        1      9.030       23     2
# honest members' max-flow: median 4, range 0..11 (scores x 1000 for PR and TR)
# cost boundary (author's model): top-10 bonus 100, reached under PR with k = 5 fakes;
#   the attack pays unless each fake identity costs more than B / k = 20.0

With no fake identities the attacker’s PageRank places him 161st of 201. One fake identity lifts him to 107th, two to 66th, five into the top ten (9th), and ten or more to 1st: the fake identities return the score he passes to them, and PageRank does not distinguish real from fake, which is exactly the weakness of symmetric functions identified by Cheng and Friedman. Personalised PageRank also rises (from 110th to 23rd with 50 fake identities) but much more slowly, because score can enter only from the seeds through the two attack edges, and fake identities merely circulate it a few more times inside his small circle. The maximum flow stays at 2, exactly the number of attack edges: any path from the seeds to the attacker’s fake identities must pass through the attacker himself first, so fake identities add no flow. The median maximum flow of honest members is 4, so the attacker does not look more trustworthy because of his fakes.

The cost boundary (the author’s model). Let G(k)G(k) be the attacker’s gain with kk fake identities and cc the cost of each (registration, verification, the expected loss of a forfeited deposit, time to maintain it). The attack pays if and only if max⁡k[G(k)−ck]>G(0)\max_k\,[G(k) – c\,k] > G(0); to make an attack of any size unprofitable requires

c≥supk≥1G(k)−G(0)k.c \;\ge\; \sup_{k \ge 1} \frac{G(k) – G(0)}{k}.

In the program, if a top-ten place earns a reward of 100 and five fake identities reach the top ten under PageRank, each fake identity must cost more than 20 to deter the attack. For sybilproof functions such as maximum flow, G(k)=G(0)G(k) = G(0), and any positive identity cost deters the attack of “creating fake identities”, though not that of “obtaining more attack edges” (for example by persuading honest members to recommend one). Raising identity costs is not free either: Friedman and Resnick point out that it falls on honest newcomers too (Friedman and Resnick 2001). Real-name verification, deposits, propagating trust only from trusted seeds and limiting identities by the social graph each carry different costs and privacy burdens.

Left: the attacker’s rank among 201 real members (log scale, higher is better) as the number of fake identities grows: PageRank (solid), seeded personalised PageRank (dashed) and maximum flow from the seeds (dotted, right axis). Right: in the author’s points model, the points price of one unit of reward in the five scenarios.

Hypothesis · not established · Flow-based community reputation

The author’s hypothesis (not established): in independent online communities, changing the reputation score from “total likes received” to “recommendation flow from a set of trusted members” will substantially reduce mutual liking among second accounts (as confirmed by human review), while lowering the share of honest newcomers who obtain a first reputation point within 30 days by no more than 10 percentage points. What would show it wrong: in a pre-registered cluster-randomised trial, a confidence interval for the difference in the share of mutual liking among second accounts that includes zero, or a drop of more than 10 percentage points in the share of newcomers obtaining reputation. The book uses no data from the author’s communities.

Chapter summary

Points are a community currency: in the author’s model, when issuance grows with membership and rewards do not, points lose value at the rate of membership growth (4.00 % a month in the example); expiry lowers the level but not the growth rate, a fixed total dilutes each member’s share, and farming accelerates inflation. Badges change behaviour: observational research shows users accelerating as they near a threshold, and meta-analytic effects of gamification on learning are small (close to medium for cognitive outcomes), with only cognitive outcomes stable in rigorous studies; the simplified model shows that the best threshold depends on the badge’s value and on retention. Symmetric reputation functions are not sybilproof: five fake identities lift an attacker from 161st to 9th under PageRank, while the maximum flow from trusted seeds is unaffected by fake identities. The “cost boundary” is the author’s model: each fake identity must cost more than the average gain it brings for an attack to be deterred.

References

Anderson, Ashton, Daniel Huttenlocher, Jon Kleinberg, and Jure Leskovec. 2013. “Steering User Behavior with Badges.” Proceedings of the 22nd International Conference on World Wide Web (WWW ’13), 95–105.
Cheng, Alice, and Eric Friedman. 2005. “Sybilproof Reputation Mechanisms.” Proceedings of the 2005 ACM SIGCOMM Workshop on Economics of Peer-to-Peer Systems (P2PECON ’05), 128–32. https://doi.org/10.1145/1080192.1080202.
Douceur, John R. 2002. “The Sybil Attack.” Peer-to-Peer Systems: First International Workshop, IPTPS 2002, Lecture notes in computer science, vol. 2429: 251–60.
Fisher, Irving. 1911. The Purchasing Power of Money. Macmillan.
Friedman, Eric J., and Paul Resnick. 2001. “The Social Cost of Cheap Pseudonyms.” Journal of Economics and Management Strategy 10 (2): 173–99.
Gyöngyi, Zoltán, Hector Garcia-Molina, and Jan Pedersen. 2004. “Combating Web Spam with TrustRank.” Proceedings of the 30th International Conference on Very Large Data Bases (VLDB 2004), 576–87.
Hamari, Juho, Jonna Koivisto, and Harri Sarsa. 2014. “Does Gamification Work? A Literature Review of Empirical Studies on Gamification.” Proceedings of the 47th Hawaii International Conference on System Sciences (HICSS), 3025–34.
Lehdonvirta, Vili, and Edward Castronova. 2014. Virtual Economies: Design and Analysis. MIT Press.
Page, Lawrence, Sergey Brin, Rajeev Motwani, and Terry Winograd. 1999. The PageRank Citation Ranking: Bringing Order to the Web. Technical Report Nos. 1999-66. Stanford InfoLab.
Sailer, Michael, and Lisa Homner. 2020. “The Gamification of Learning: A Meta-Analysis.” Educational Psychology Review 32 (1): 77–112. https://doi.org/10.1007/s10648-019-09498-w.
Yu, Haifeng, Michael Kaminsky, Phillip B. Gibbons, and Abraham Flaxman. 2006. “SybilGuard: Defending against Sybil Attacks via Social Networks.” Proceedings of ACM SIGCOMM 2006, 267–78.

Fan, Y. (2026). Mechanism Design, Vickrey–Clarke–Groves Auctions and Incentive-Compatible Community Engineering: From Myerson's Optimal Auction and the Hurwicz Impossibility Theorem to Sybil-Resistant Reputation Games, Read Beside Classical Legalist Treatises on Rewards and Incentives [机制设计、维克里—克拉克—格罗夫斯(VCG)拍卖与数字社群激励相容工程] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.23836274 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).