Lesson 3 of 10

How much shared work to fund, and where expertise should sit

How many blocks of shared practice are worth more than the work they push out, and who should get them?

The problem

The next block already has a job

Shared practice never competes with an empty calendar. It competes with today's work. This lesson asks how much of it to fund, and who should receive it.

Lesson 2 showed that a shared route earns its place through expertise, and that expertise grows with practice. In the pump company, practice for the shared document reader means real work: building a test set of scanned annexes, running a vendor model against it, diagnosing why it misreads exclusions, trying a fix. Each block of that work uses something scarce. It may be a week of the one senior machine-learning engineer everyone queues for, a slice of compute, or part of the vendor budget for evaluation runs.

Every one of those blocks already has a job. The engineer could be fixing Dispatch's routing errors. The compute could run a product release. So the question is not "is practice good?" It is "how many blocks are worth more than the work they push out?" And once the company has decided how much, a second question follows: should all the practice go to one person, who becomes deep, or be spread across two, who each become competent?

The intuition

Compounding against crowding out

Funding shared practice has a strong argument behind it. What the shared route learns is used by every team it serves, again and again, long after the block is spent. Local teams, practicing alone, never get that reuse. That is the compounding side.

Against it stand three things. Each block pushes out useful work now. Starting a shared program at all has a setup cost, paid once: finding the documents, agreeing access, building the test harness. And practice has diminishing returns: the first block teaches the most, because there is the most to learn; each later block closes less of what remains.

Diminishing returns also shape the second question. Two people who split the practice each sit on the steep early part of the curve, so together they learn more than one person who gets it all. But skill only has value where it is used. If one person will serve most of the future work, depth in that person may be worth more than breadth across two.

This is now an optimization problem. We must choose a whole number of blocks among many, and a placement between two people. A tempting shortcut is to add blocks while the next one pays and stop at the first that does not. Is that local test safe, or could stopping early miss a better program further on? And does the setup cost change the answer? These are exactly the questions where intuition slips, and where a checked proof is worth having.

The model

Value of practice, minus what it displaces

Lesson 2 gave practice a value. Over the future work the shared route will actually serve, learning saves errors worth at most $g$ , where

Derived by hand from lesson 2

g=\tfrac12\,\sigma^2\,(1-x_0)\sum_{\text{future jobs}} j

In words: the most practice could ever be worth is the slip size squared, times the expertise still missing, times the future work it will serve.

Only work that can actually be served counts. A hypothetical company-wide rollout adds nothing to $g$ until there is capacity to serve it. With $h$ blocks, the learning curve closes the fraction $h/(1 + h)$ of the gap, and each block pushes out useful work worth $c$ . So the gain from $h$ blocks, before setup, is

Definition

\begin{aligned}G(h)&=g\,\frac{h}{1+h}-c\,h\\\text{value of the program}&=\begin{cases}0&h=0\\G(h)-f&1\le h\le H\end{cases}\end{aligned}

In words: learning gained minus work pushed out, and the one-off setup $f$ is paid only if the program starts. Funding nothing is always an option, worth zero.

Here $f$ is the same one-off cost as in lesson 1. This lesson is about that term: how large the shared investment should be. One more block is worth adding exactly when its extra learning beats the work it displaces:

Checked in Lean · next_packet_worthwhile

G(h+1)>G(h)\iff g>c\,(h+1)(h+2)

In words: the next block's learning, $g$ divided by $(h+1)(h+2)$ , shrinks with every block; keep adding while it is larger than $c$ .

Then the setup cost decides whether to start at all. With $h$ blocks, the program beats doing nothing exactly when

Checked in Lean · activation_threshold

f<G(h)\iff g\,h>(f+c\,h)(1+h)

In words: the learning from $h$ blocks must cover both the work they push out and the setup.

For the second question, give two people the same starting expertise $x_0$ and the same total practice, $2h$ blocks. Either all $2h$ go to person 1, or each gets $h$ . Person 1 will serve future work $j_1$ and person 2 will serve $j_2$ . Measure learning value as expertise gained times the work it will serve; the factor $\tfrac12 \sigma^2$ is common to both choices and drops out. The difference in learning value between concentrating and splitting is

Checked in Lean · concentration_gap, concentration_wins_iff

\begin{aligned}V_C-V_S&=\frac{(1-x_0)\,h\,\bigl[j_1-(1+2h)\,j_2\bigr]}{(1+h)(1+2h)}\\V_C>V_S&\iff j_1>(1+2h)\,j_2\end{aligned}

In words: concentrate only if person 1 will serve more than $(1 + 2h)$ times the work of person 2; the bar rises as practice grows.

What each letter stands for

$h$: Blocks of shared practice fundedwhole blocks
$H$: Blocks still available after today’s committed work is protectedwhole blocks
$g$: The most practice could ever be worth, over the future work it will serveillustrative units
$c$: Useful work pushed out by one blockillustrative units per block
$f$: One-off setup, paid only if the program startsillustrative units
$G$: Learning gained minus work pushed out, before setupillustrative units
$j_1,\ j_2$: Future work each person will serve, weighted by what an error there costsillustrative units
$x_0$: Starting expertise, the same for both peoplebetween 0 and 1
$V_C,\ V_S$: Learning value when practice is concentrated or splitillustrative units

Lesson 3 · Figure 1

Fund blocks while the next one teaches more than it displaces.

Shown at Blocks of shared practice funded, $h$ : 1 blocks; Work pushed out by one block, $c$ : 2.0 units; One-off setup, $f$ : 15.0 units. Turn on JavaScript to move the values.

Add blocks: block 2 still teaches 5, more than the 2 of work it displaces. A losing first step does not mean the program loses: setup is paid once, and later blocks recover it.

Net value of 1 block: −2 units
Best choice: 3 blocks (1.5 units)
Extra learning from block 2, $g$ ÷ $(h+1)(h+2)$: 5 vs displaced work $c$ = 2

Only whole blocks exist; the line joins them. Learning ceiling $g = 30$ and six blocks available. The flat line is funding nothing. Values come from the tested frontier engine; the stopping rule is checked in Lean.

Model result · checked in Lean

The starting position is the trap. One block, after a setup of 15, is worth −2: a loss. Move to two blocks: +1. Three: +1.5, the best. Four: back to +1. The first block lost money and the program still wins, because setup is paid once and later blocks recover it. Now drop the setup to zero. Three blocks are still best, worth 16.5, and so 16.5 is the most setup this program can carry at this price of time. Raise $c$ , the work each block pushes out, and the best number of blocks falls; at a high enough $c$ , funding nothing wins.

Lesson 3 · Figure 2

Concentrate practice only where one person will serve most of the work.

Shown at Future work person 1 will serve, $j_1$ (person 2 serves the rest of 8): 6 units; Practice per person if split, $h$ : 2 blocks. Turn on JavaScript to move the values.

Split: person 1 serves 6, not more than (1 + 2 × 2) × 2 = 10. Each extra block teaches less than the last, so two half-trained people learn more in total.

Future work person 1 can serve, j₁: 6
Future work person 2 can serve, j₂: 2
Concentrate: 4.8
Split: 5.33

Both people start with no expertise. The total future work is 8, shared between them. The crossover is where $j_1 = (1 + 2h) j_2$ . Values come from the tested allocation engine.

Model result · checked in Lean

With person 1 serving 6 of the 8 units of future work, concentrating and splitting tie at one block each, and from two blocks each, splitting wins. Slide person 1's share up to 7 and concentration wins at one and two blocks each, ties at three, and loses after. Give person 1 everything and concentration always wins: person 2's skill would have nowhere to go. Make the shares equal and splitting wins at every amount.

What Lean checks

In the source file, Lean's $a$ is our $g$ ; the other letters match. The function gross is our $G$ .

Checked in Lean

Adding one more block raises the gain exactly when $g$ is larger than $c(h+1)(h+2)$ .

next_packet_worthwhile in ExpertiseScarcity.lean

Show the Lean statement

theorem next_packet_worthwhile (a c h : Rat) (hh : 0 ≤ h) :
    gross a c h < gross a c (h+1) ↔ a > c*((h+1)*(h+2))

Checked in Lean

If the $k$ -th block was worth adding and the next one would not be, then $k$ blocks give at least as much gain, before setup, as any whole number of blocks from 0 to $H$ : the local stopping rule finds the global best.

finite_packet_optimum in ExpertiseScarcity.lean

Show the Lean statement

theorem finite_packet_optimum (a c : Rat) (H k : Nat)
    (hc : 0 ≤ c) (hkH : k ≤ H)
    (hleft : 0 < k → c*(k:Rat)*((k:Rat)+1) ≤ a)
    (hright : k < H → a ≤ c*((k:Rat)+1)*((k:Rat)+2)) :
    ∀ y : Nat, y ≤ H → gross a c (y:Rat) ≤ gross a c (k:Rat)

Checked in Lean

A program of $h$ blocks beats paying its setup $f$ exactly when $gh$ is larger than $(f + ch)(1 + h)$ .

activation_threshold in ExpertiseScarcity.lean

Show the Lean statement

theorem activation_threshold (a c f h : Rat) (hh : 0 ≤ h) :
    f < gross a c h ↔ a*h > (f+c*h)*(1+h)

Checked in Lean

With some practice and expertise not yet full, concentrating all practice in person 1 gives more learning value than splitting it exactly when $j_1$ is larger than $(1 + 2h) j_2$ .

concentration_wins_iff in ExpertiseScarcity.lean

Show the Lean statement

theorem concentration_wins_iff (x h w1 w2 : Rat)
    (hx : x<1) (hh : 0<h) :
    0 < concentrationGain x h w1 w2 ↔ (1+2*h)*w2 < w1

Checked in Lean

Both answers really occur: with equal future work, splitting wins; when person 1 serves four times as much, concentrating wins.

spread_equal_workload_wins · concentrate_unequal_workload_wins in ExpertiseScarcity.lean

Show the Lean statement

theorem spread_equal_workload_wins : concentrationGain 0 1 1 1 < 0
theorem concentrate_unequal_workload_wins : 0 < concentrationGain 0 1 4 1

The optimum theorem is the one with real content. It rules out a better program hiding further along, for every whole number of blocks up to the cap, not just the neighbors. It proves the stopping conditions are enough; it does not prove they are the only way to describe the best choice.

What Lean does not check: that blocks are all alike, that the work each displaces is worth the same, or that the future work $j$ is known in advance. It knows nothing about deadlines, about two jobs needing the same expert on the same day, or about the right devices being free together. It does not check the learning curve or the value of $g$ . The figures are drawn by separately tested JavaScript, which reproduces these thresholds exactly; they are not produced by Lean.

What it means

A simple stopping rule is enough here

Add a block while the next one teaches more than the work it pushes out; stop at the first that does not. Because each block teaches less than the last while costing the same, that local test gives the global answer. Then, separately, check that the best program covers its setup.

Do not judge a program by its first block

Because setup comes first, one block can lose while three win: with $g = 30$ , $c = 2$ and $f = 15$ , one block is worth −2 and three are worth +1.5. Without a setup cost the logic flips: if the first block does not pay for itself, no later block will, and stopping is right.

Expensive time shrinks the right program

When the specialist's or the compute's alternative use is valuable, $c$ is high, and the best number of blocks falls, possibly to zero. A shared program that made sense in a quiet quarter may not in a launch quarter. The answer is a threshold, not a percentage of the budget that belongs to the center.

Depth needs somewhere to go

If two people will serve similar amounts of future work, spread practice between them. Concentrate only when one person will serve much more, and remember that the bar, $(1 + 2h)$ times the other's work, rises as practice grows. In the pump company, deep expertise in one shared engineer pays when that engineer will really serve both teams' documents. If each team's work stays with its own person, splitting wins.

Concentration has a cost this model leaves out

One deep expert is one calendar. Two products that need that expert before the same deadline cannot both be served, however many hours the expert has next month. Forcing every job through one person turns depth into a queue, which is the waiting cost $w$ of lesson 1, and lesson 8's subject. A pool that could reproduce every local schedule, with the same cost and information, could not do worse; a rule that forces everything through one person can.

When the shared program loses

It loses when the work it displaces is valuable, when there is little future work for the learning to serve, when setup is large, or when practice is concentrated in someone who will not serve enough of the work. All the numbers here are chosen to show the shape. None has been measured.

Next: when every request is urgent

So far one planner decided, knowing the value of every block. Real requests for scarce blocks come from teams, and each team knows more about its own project than the sponsor does. If claiming urgency is free, every team claims it. Lesson 4 brings in game theory: what happens when everything is P1, and what kind of test sorts strong ideas from weak ones.