Social Proof and Authority

The previous lesson showed that a default silently steers the user’s decision. The interface has one more tool that speaks openly: showing what others have done. In the catalog, “users who borrowed this record also borrowed,” “most borrowed this month,” or a borrow count shown next to a record are all of this kind.

Social proof is a person using others’ behavior as a source of information in an uncertain situation. The mechanism is sound at its core: others’ choices may carry something they know. This lesson measures where that soundness ends.

A Visible Count Destroys Independent Information

The first computation models a catalog situation. A work has two editions; one is genuinely better (more complete, more legible). Looking on their own, each user can tell the correct edition apart with 68 percent probability — a good but imperfect signal.

Forty users arrive in sequence. Two layouts are compared: one where each user sees only their own signal, and one where they also see the borrow counts accumulated so far.

// social.mjs — effect of a visible count on information-carrying capacity

function generator(seed) {
  let s = seed >>> 0;
  return () => { s = (s * 1664525 + 1013904223) >>> 0; return s / 4294967296; };
}

const SIGNAL = 0.68;      // accuracy of the user's own signal
const USERS = 40;
const RUNS = 4000;

// ---- 1) Correct majority decision: independent vote versus visible count ----
// There are two editions, one genuinely better (1). Each user gets a 68% accurate signal.
function sequential(visibleCount, rnd) {
  let n0 = 0, n1 = 0, ownSignal = 0, cascadeStart = null;
  for (let i = 0; i < USERS; i++) {
    const signal = rnd() < SIGNAL ? 1 : 0;
    const diff = n1 - n0;
    let choice;
    if (!visibleCount || Math.abs(diff) < 2) { choice = signal; ownSignal++; }
    else { choice = diff >= 2 ? 1 : 0; if (cascadeStart === null) cascadeStart = i; }
    if (choice === 1) n1++; else n0++;
  }
  return { n0, n1, ownSignal, cascadeStart };
}

// Probability that the majority of k independent signals is correct
function binomialCoeff(n, k) {
  let r = 1;
  for (let i = 1; i <= k; i++) r = (r * (n - k + i)) / i;
  return r;
}
function majorityAccuracy(k, q) {
  let t = 0;
  for (let i = Math.floor(k / 2) + 1; i <= k; i++) t += binomialCoeff(k, i) * q ** i * (1 - q) ** (k - i);
  return t;
}

console.log("layout          majority correct  used own signal  cascade started at");
const measured = {};
for (const visible of [false, true]) {
  const rnd = generator(20260527);
  let majorityCorrect = 0, own = 0, start = 0, startCount = 0;
  for (let k = 0; k < RUNS; k++) {
    const r = sequential(visible, rnd);
    if (r.n1 > r.n0) majorityCorrect++;
    own += r.ownSignal;
    if (r.cascadeStart !== null) { start += r.cascadeStart; startCount++; }
  }
  const rate = majorityCorrect / RUNS;
  measured[visible ? "visible" : "hidden"] = rate;
  console.log(
    `${(visible ? "count visible" : "count hidden").padEnd(15)} ${((rate * 100).toFixed(1) + " %").padStart(16)}` +
    ` ${(own / RUNS).toFixed(1).padStart(16)} ${(startCount === 0 ? "-" : "user " + (start / startCount).toFixed(1)).padStart(24)}`
  );
}

// How many independent votes the visible-count layout is equivalent to
console.log("\nindependent votes  probability majority is correct");
for (const k of [1, 3, 5, 11, 21, 41]) {
  console.log(`${String(k).padStart(18)}  ${(majorityAccuracy(k, SIGNAL) * 100).toFixed(1)} %`);
}
let equiv = 1;
while (equiv < 41 && majorityAccuracy(equiv, SIGNAL) < measured.visible) equiv += 2;
console.log(`with the count visible, 40 users amount to ${equiv} independent votes`);

// ---- 2) The self-reinforcing effect of the "most borrowed" list ----
const RECORDS = 200, ROUNDS = 60, ROUND_USERS = 100, LIST = 10, LIST_BOOST = 6;

function rankCorrelation(a, b) {                 // Spearman rank correlation
  const rank = (v) => {
    const s = v.map((x, i) => [x, i]).sort((p, q) => q[0] - p[0]);
    const r = new Array(v.length);
    s.forEach(([, i], k) => { r[i] = k + 1; });
    return r;
  };
  const ra = rank(a), rb = rank(b), n = a.length, mean = (n + 1) / 2;
  let num = 0, pa = 0, pb = 0;
  for (let i = 0; i < n; i++) {
    num += (ra[i] - mean) * (rb[i] - mean);
    pa += (ra[i] - mean) ** 2; pb += (rb[i] - mean) ** 2;
  }
  return num / Math.sqrt(pa * pb);
}

function popularity(listShown) {
  const rnd = generator(20260601);
  const quality = Array.from({ length: RECORDS }, () => 0.2 + rnd() * 0.8);
  const counts = new Array(RECORDS).fill(0), firstRound = new Array(RECORDS).fill(0);
  for (let round = 0; round < ROUNDS; round++) {
    const topTen = [...counts.keys()].sort((a, b) => counts[b] - counts[a]).slice(0, LIST);
    const inList = new Set(listShown ? topTen : []);
    const weight = quality.map((q, i) => q * (inList.has(i) ? LIST_BOOST : 1));
    const total = weight.reduce((a, b) => a + b, 0);
    for (let u = 0; u < ROUND_USERS; u++) {
      let x = rnd() * total, i = 0;
      while (x > weight[i] && i < RECORDS - 1) { x -= weight[i]; i++; }
      counts[i]++;
      if (round === 0) firstRound[i]++;
    }
  }
  return { quality, counts, firstRound };
}

console.log("\nlist                quality correlation  first-round luck correlation  true top 10 in top 10");
for (const listShown of [false, true]) {
  const { quality, counts, firstRound } = popularity(listShown);
  const best = new Set([...quality.keys()].sort((a, b) => quality[b] - quality[a]).slice(0, LIST));
  const topTen = [...counts.keys()].sort((a, b) => counts[b] - counts[a]).slice(0, LIST);
  console.log(
    `${(listShown ? "list shown" : "no list").padEnd(20)} ${rankCorrelation(counts, quality).toFixed(3).padStart(19)}` +
    ` ${rankCorrelation(counts, firstRound).toFixed(3).padStart(29)} ${(topTen.filter((i) => best.has(i)).length + " / 10").padStart(24)}`
  );
}

// ---- 3) When does an authority signal replace one's own signal ----
console.log("\nauthority accuracy  follows authority  own signal  follows the more reliable  5 independent votes");
const fiveVotes = majorityAccuracy(5, SIGNAL);
for (const a of [0.50, 0.60, 0.68, 0.80, 0.92]) {
  console.log(
    `${a.toFixed(2).padStart(18)}  ${((a * 100).toFixed(1) + " %").padStart(16)} ${((SIGNAL * 100).toFixed(1) + " %").padStart(10)}` +
    ` ${((Math.max(a, SIGNAL) * 100).toFixed(1) + " %").padStart(28)} ${((fiveVotes * 100).toFixed(1) + " %").padStart(21)}`
  );
}

layout          majority correct  used own signal  cascade started at
count hidden              98.4 %             40.0                        -
count visible             82.1 %              3.5                 user 3.5

independent votes  probability majority is correct
                 1  68.0 %
                 3  75.8 %
                 5  80.9 %
                11  89.7 %
                21  95.8 %
                41  99.2 %
with the count visible, 40 users amount to 7 independent votes

list                quality correlation  first-round luck correlation  true top 10 in top 10
no list                            0.918                         0.177                   7 / 10
list shown                         0.858                         0.290                   1 / 10

authority accuracy  follows authority  own signal  follows the more reliable  5 independent votes
              0.50            50.0 %     68.0 %                       68.0 %                80.9 %
              0.60            60.0 %     68.0 %                       68.0 %                80.9 %
              0.68            68.0 %     68.0 %                       68.0 %                80.9 %
              0.80            80.0 %     68.0 %                       80.0 %                80.9 %
              0.92            92.0 %     68.0 %                       92.0 %                80.9 %

The Information Cascade and the Effective Vote Count

The first table gives a reversed result. When the count is hidden, the majority of forty users finds the correct edition 98.4 percent of the time. When the count is visible, that rate drops to 82.1 percent. Giving users more information makes the collective decision worse.

The reason is in the second column. When the count is hidden, all forty of the forty users use their own signal. When it is visible, only 3.5 do. On average, after user 3.5, the count difference reaches two votes, and beyond that point no user’s own signal is enough to change the decision. Everyone follows the count, the count grows, and the reason to follow it strengthens.

This structure is called an information cascade. (It should not be confused with cascading in CSS; what cascades here is decisions, not style rules.) The cascade’s critical property is this: the information held by the thirty-six people who arrive after the fourth user never enters the system. The count grows, but the information inside it does not.

The third block reduces this to a single number. A majority of independent votes gives 80.9 percent accuracy at 5 votes and 99.2 percent at 41 votes. The 82.1 percent accuracy produced by forty users in the visible-count layout is equivalent to seven independent votes. Thirty-three of the forty users contribute nothing at all to the collective information.

The design consequence is clear: the moment the count is shown matters. A count shown after the user has made their own decision does not corrupt information; a count shown before the decision suppresses the information of every user who comes after it.

A Popularity List Feeds Itself

The second computation follows borrows in a two-hundred-record catalog over sixty rounds. Each record has a quality. Two layouts are compared: one where the “ten most borrowed records” list is shown and one where it is not.

Without the list, the ranking’s rank correlation with quality is 0.918, with first-round luck it is 0.177; seven of the resulting top ten records are genuinely among the ten highest-quality records. With the list shown, the quality correlation drops to 0.858, the luck correlation rises to 0.290, and only one of the resulting top ten is in the true top ten.

This third number exposes what the first two conceal. The overall correlation degrades very little (0.918 to 0.858) because the ranking of the one hundred ninety records outside the list is still determined by quality. What degrades is exactly the list itself: records that got lucky in the first round enter the list, being on the list gives them six times the visibility, that visibility raises their counts, and that keeps them on the list. Records that are high quality but unlucky in the first round never rise again.

The result is that the list does not measure what it claims to. The “most borrowed” heading promises the user a quality ranking; what it measures is, to a large extent, early visibility. If the user knew how this list was produced, they would not look at it as a quality signal.

This does not mean a popularity list is wrong under every condition. What produces the distortion is the feedback loop: being on the list makes staying on the list easier. There are design decisions that break the loop — limiting the list to a narrow time window, removing records from the list for a period after they enter it, binding the list to a harder-to-game metric such as completion or post-return rating instead of borrow count. Each of these decouples the visibility gain from the count.

Authority Is Information Only If It Is More Reliable

The last table addresses the authority signal: labels like “on the department reading list,” “librarian’s pick,” “faculty selection.”

The user’s own signal is 68 percent correct. At an authority accuracy of 0.50, following the authority is 50 percent correct — had the user decided on their own, they would have gotten 68 percent. When authority accuracy rises to 0.68, the two options are tied. Only at 0.80 and 0.92 does following the authority pay off.

The rule is this: an authority signal is information to the degree that it is more reliable than the user’s own judgment; if it is not, it has merely taken over the decision. When a label is shown in the interface, the user cannot make this comparison, because they do not know the label’s accuracy. What makes a label meaningful is that its basis is visible: “which course’s reading list,” “who recommended it,” “selected by what criterion.” An authority label whose basis is not written gives the user not a number but only a direction.

The last column ties the table back to the first part of this lesson. A majority of five independent users gives 80.9 percent accuracy — better than an authority with 0.80 accuracy. A crowd, as long as it stays independent, is more reliable than most authorities. But the first computation showed that a visible count destroys exactly this independence. What makes social proof valuable and the way it is displayed undo each other.

Criteria for Recognition and Rejection

Whether a social proof or authority signal is legitimate is audited with three questions.

Does the number have a verifiable basis? “412 users borrowed this record” corresponds to a countable fact. “This record is very popular” corresponds to nothing and cannot be audited. An unauditable claim is not social proof; it is the appearance of social proof.

Is the number shown before or after the user’s decision? A count shown before the decision produces a cascade. Instead of showing the borrow count to the user opening the record, saying “users who borrowed this record also borrowed” after they have borrowed gives the same information without breaking independence.

Is the scarcity real? The claim “the last remaining copy of this record,” if true from the catalog data, is information useful to the user: it changes their waiting decision. If the same claim is shown independent of the actual copy count, it is a fabricated scarcity signal manufactured to push the user into a hasty decision. The two look the same on screen; the distinction lies in the data’s source.

The common thread of these three questions is the criterion this topic has used from the start. Would the decision change if the user knew how the number they see was produced? If the borrow count comes from a real tally, it would not. If the popularity list comes from a self-reinforcing loop, it would. If the scarcity warning is shown independent of stock, it would — and that means the decision’s power comes from the user’s ignorance.

Summary

• Social proof is the use of others’ behavior as a source of information; its value depends on that behavior arising from independent judgments.
• A visible count produces an information cascade: in the simulation, majority accuracy dropped from 98.4 percent to 82.1 percent, and only 3.5 of forty users were able to use their own signal.
• Forty users under a visible count produce information equivalent to seven independent votes; the remaining users’ information never enters the system.
• A popularity list builds a feedback loop: in the computation, only one of the resulting top ten was genuinely among the ten highest-quality records; the list measures early visibility, not quality.
• An authority signal carries information only if it is more reliable than the user’s own judgment; a majority of five independent users is more accurate than an authority with 0.80 accuracy.
• The audit is done with three questions: does the number have a verifiable basis, is it shown before the decision, and is the scarcity real?

Next Step

This lesson addressed the information the interface gives the user about others. There is one more kind of information the interface gives, and it concerns the user directly: where they are, how far they have come, how much is left. The next lesson computes the effect of visible progress on flow completion, addresses the thresholds at which feedback delay changes behavior, and separates when a progress indicator is information and when it is decoration.