Yep 😂 — I found the actual issue. You’re fighting the equation upstream, not P2 downstream.

The bug is bigger than the v1146 clamp

v1145 currently does three things that are wrong for the question “will this match reach Set 3?”:

1. It pools both players into one generic serial-transition contrast.
2. It forces that contrast through _tlBo3StationaryTransitionFromDeltaV1145_, which preserves the original set-win marginal.
3. It counts S2→S3 transitions too, even though P3 is determined entirely by whether S1→S2 reverses. (TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

Then it computes:

$$P3_{transition} =q(1-qAfterWin)+(1-q)qAfterLoss$$

and adds the difference versus IID P3 onto structural P3. (TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

So with your example q1 = 0.60 and positive stationary contrast +0.447, the current solver approximately produces:

• qAfterWin = 64.3%
• qAfterLoss = 53.5%
• IID P3 = 48.0%
• transition P3 = 42.8%
• transition delta = -5.2 pp

Therefore structural P3:

47.9% → ~42.7%

and automatically:

P2 52.1% → ~57.3%

So yeah. 😂 P2 isn't mysteriously fighting you. v1145 is literally telling P2 to rise.

Clamping that −5.2 pp to zero gives 47.9/52.1, which is exactly the parking brake you described.

---

The correct owner is S1→S2 reversal

For BO3 Over 2.5, there are only two relevant branches:

$$P3=q_1r_{A\rightarrow B}+(1-q_1)r_{B\rightarrow A}$$

where:

• $r_{A\rightarrow B}$ = B wins Set 2 after A wins Set 1.
• $r_{B\rightarrow A}$ = A wins Set 2 after B wins Set 1.

That's it.

S2→S3 must not enter the P3 estimator at all.

Right now v1145 loops through every adjacent transition:

js
for(var j=0;j<q.wins.length-1;j++)

so a three-set match contributes two observations. (TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

Change the live BO3 history measurement to only wins[0] → wins[1].

---

The two branches should be built cross-player

This is the key part.

Suppose A wins S1.

Evidence that B can reverse comes from two complementary histories:

• A's history of losing the next set after winning the prior set
• B's history of winning the next set after losing the prior set

So:

text
A→B reversal evidence:

A_after_win_then_loss
+
B_after_loss_then_win

Likewise:

text
B→A reversal evidence:

B_after_win_then_loss
+
A_after_loss_then_win

From the counters already collected by v1145:

js
A_after_win_then_loss =
    a.afterWinN - a.afterWinNextWin;

A_after_loss_then_win =
    a.afterLossNextWin;

B_after_win_then_loss =
    b.afterWinN - b.afterWinNextWin;

B_after_loss_then_win =
    b.afterLossNextWin;

Therefore:

js
sAB =
    (a.afterWinN - a.afterWinNextWin)
    + b.afterLossNextWin;

nAB =
    a.afterWinN
    + b.afterLossN;

sBA =
    (b.afterWinN - b.afterWinNextWin)
    + a.afterLossNextWin;

nBA =
    b.afterWinN
    + a.afterLossN;

That is the matchup-oriented information your current pooled delta destroys.

---

Don't shrink toward 50%

There's one more subtle fix.

The structural baseline for the two branches isn't 50/50.

With first-set A probability $q$:

$$r^{base}_{A\rightarrow B}=1-q$$

and

$$r^{base}_{B\rightarrow A}=q$$

So if q = .60, the baseline reversal branches are:

• A wins S1 → B reversal = 40%
• B wins S1 → A reversal = 60%

That naturally produces:

$$.60(.40)+.40(.60)=48\%$$

which is your IID reference.

Therefore shrink each live branch toward its appropriate structural branch, not toward .5, and definitely don't force the two rates to satisfy a stationary marginal equation.

---

Candidate replacement

The core should look like this:

js
function _tlBo3ReversalBranchesV1147_(q,a,b){
  q=_tlBo3ProbV1145_(q);
  a=a||{};
  b=b||{};

  if(!Number.isFinite(q))
    return {valid:false,usable:false,reason:'FIRST_SET_PROB_INVALID'};

  // A won S1 -> B must reverse in S2.
  var sAB =
      Math.max(0,Number(a.afterWinN)||0) -
      Math.max(0,Number(a.afterWinNextWin)||0) +
      Math.max(0,Number(b.afterLossNextWin)||0);

  var nAB =
      Math.max(0,Number(a.afterWinN)||0) +
      Math.max(0,Number(b.afterLossN)||0);

  // B won S1 -> A must reverse in S2.
  var sBA =
      Math.max(0,Number(b.afterWinN)||0) -
      Math.max(0,Number(b.afterWinNextWin)||0) +
      Math.max(0,Number(a.afterLossNextWin)||0);

  var nBA =
      Math.max(0,Number(b.afterWinN)||0) +
      Math.max(0,Number(a.afterLossN)||0);

  var baseAB=1-q;
  var baseBA=q;

  /*
   * Preserve the conservative spirit of v1145,
   * but center the prior on the structural branch.
   *
   * PRIOR_N must be forward-validated; do NOT tune
   * this number to make a particular match reach 55%.
   */
  var PRIOR_N=12;

  var rAB=(sAB + PRIOR_N*baseAB) /
          Math.max(1e-12,nAB+PRIOR_N);

  var rBA=(sBA + PRIOR_N*baseBA) /
          Math.max(1e-12,nBA+PRIOR_N);

  var completeAB=
      Number(a.afterWinN)>0 &&
      Number(b.afterLossN)>0;

  var completeBA=
      Number(b.afterWinN)>0 &&
      Number(a.afterLossN)>0;

  var usable=
      completeAB &&
      completeBA &&
      nAB>=2 &&
      nBA>=2;

  return {
    valid:nAB>0||nBA>0,
    usable:usable,

    rAtoB:rAB,
    rBtoA:rBA,

    rawAtoB:nAB>0?sAB/nAB:NaN,
    rawBtoA:nBA>0?sBA/nBA:NaN,

    successesAtoB:sAB,
    trialsAtoB:nAB,

    successesBtoA:sBA,
    trialsBtoA:nBA,

    baselineAtoB:baseAB,
    baselineBtoA:baseBA,

    reason:usable
      ?'BO3_DIRECTIONAL_REVERSAL_BRANCHES_READY'
      :'BO3_DIRECTIONAL_BRANCH_EVIDENCE_INCOMPLETE'
  };
}

Then the P3 target becomes extremely simple:

js
function _tlBo3TransitionTargetV1147_(firstSetP,structuralP3,a,b){
  var q=_tlBo3ProbV1145_(firstSetP);
  var p3=Number(structuralP3);

  if(!Number.isFinite(q)||!(p3>=0&&p3<=1))
    return {
      valid:false,
      applied:false,
      reason:'BO3_TRANSITION_INPUT_INVALID'
    };

  var br=_tlBo3ReversalBranchesV1147_(q,a,b);

  if(!br.usable)
    return {
      valid:true,
      applied:false,
      reason:br.reason,
      targetP3:p3,
      targetP2:1-p3,
      structuralP3:p3,
      branches:br
    };

  var iidP3=
      q*(1-q) +
      (1-q)*q;

  var branchP3=
      q*br.rAtoB +
      (1-q)*br.rBtoA;

  /*
   * Preserve the canonical structural root.
   * Transition evidence owns only the NON-IID residual.
   */
  var delta=branchP3-iidP3;

  var targetP3=Math.max(
      1e-6,
      Math.min(1-1e-6,p3+delta)
  );

  return {
    valid:true,
    applied:Math.abs(targetP3-p3)>1e-12,

    reason:'DIRECTIONAL_S1_S2_REVERSAL_APPLIED_V1147',

    firstSetP:q,

    structuralP3:p3,

    iidReferenceP3:iidP3,
    directionalTransitionP3:branchP3,

    p3Delta:targetP3-p3,

    targetP3:targetP3,
    targetP2:1-targetP3,

    rAtoB:br.rAtoB,
    rBtoA:br.rBtoA,

    branches:br
  };
}

And delete this from the BO3 live path

js
_tlBo3StationaryTransitionFromDeltaV1145_

along with the pooled stationary owner:

js
rawDelta
effectiveTransitionDeltaLogOdds
qAfterWin
qAfterLoss
stationaryCheck

Those can remain in a research diagnostic temporarily if you want to compare v1145 versus the new branch model, but they should not own P3.

---

Most important data-builder change

This:

js
for(var j=0;j<q.wins.length-1;j++){
    ...
}

should become effectively:

js
var prev=!!q.wins[0];
var next=!!q.wins[1];

out.transitions++;

if(prev===next) out.stays++;
else out.reversals++;

if(prev){
    out.afterWinN++;
    if(next) out.afterWinNextWin++;
}else{
    out.afterLossN++;
    if(next) out.afterLossNextWin++;
}

Only S1→S2.

Otherwise you're using Set 3 to predict whether Set 3 exists. That's conditioning on the outcome you're trying to estimate.

---

Your 60/58/63 example now behaves correctly

Suppose:

text
q1        = 60%
rA→B      = 58%
rB→A      = 63%

Then:

$$P3_{branch} =.60(.58)+.40(.63) =.600$$

IID reference:

$$P3_{iid}=2(.60)(.40)=.480$$

So transition residual:

$$+.120$$

If structural P3 is 47.9%:

$$47.9 + 12.0 = 59.9\%$$

Therefore:

text
P3: 47.9% → 59.9%
P2: 52.1% → 40.1%

That is the behavior you've been trying to get.

Not because we're forcing an Over, but because both target-oriented reversal branches genuinely say the second set is more likely to flip than the stationary point root expects.

---

IPF is not the problem

Your downstream wiring is actually doing the right thing.

v1145 explicitly sends:

js
{'2':1-targetP3,'3':targetP3}

into _tlIpFWinnerLength_(). (TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

And that IPF function simultaneously targets:

• winner row = pA
• P2/P3 columns = requested set counts. (TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

So with Winner = 65% and target P3 = 55%:

text
2-0 + 2-1 = 65%
0-2 + 1-2 = 35%

2-0 + 0-2 = 45%
2-1 + 1-2 = 55%

IPF determines the least-distorting allocation of those four cells relative to the structural PMF.

And _tlBo3ExactScoreRoot_() subsequently derives P2 and P3 directly from those four cells; there isn't another hidden P2 adjustment afterward. (TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

So once the upstream target says P3 = 55%, the mass actually moves.

---

The trace I would add before touching any coefficient

For Droguet/Kjaer, print exactly:

text
[BO3 REVERSAL TRACE]

q1 A = xx.x%
structural P3 = 47.9%
structural P2 = 52.1%

A:
  after S1 win -> S2 loss = x / n
  after S1 loss -> S2 win = x / n

B:
  after S1 win -> S2 loss = x / n
  after S1 loss -> S2 win = x / n

A->B branch:
  A lead-surrender evidence = x/n
  B response evidence       = x/n
  combined raw              = xx.x%
  shrunk                    = xx.x%
  structural baseline       = xx.x%

B->A branch:
  B lead-surrender evidence = x/n
  A response evidence       = x/n
  combined raw              = xx.x%
  shrunk                    = xx.x%
  structural baseline       = xx.x%

IID P3       = xx.x%
branch P3    = xx.x%
P3 residual  = +/-x.x pp

structural P3 = 47.9%
target P3     = xx.x%
target P2     = xx.x%

PMF BEFORE:
2-0 / 2-1 / 0-2 / 1-2

PMF AFTER IPF:
2-0 / 2-1 / 0-2 / 1-2

That trace settles the question immediately.

The decision rule is then clean

If both directional branches produce enough reversal pressure that:

text
directional transition P3 > IID reference P3

then structural P3 must rise and P2 must fall.

If:

text
directional transition P3 < IID reference P3

then the matchup evidence really does indicate persistence, and P2 should rise.

No sign clamp. No minimum-55 hack. No Over floor.

That's the distinction you've been looking for.

One limitation: the uploaded source contains the code that reads the live Match Inputs sheet, but it does not contain Droguet/Kjaer's actual visible row values, so I can't truthfully tell you yet whether their two branches are reversal or persistence. But the code diagnosis is clear: first-transition-only directional reversal branches are the next model to trace; the pooled stationary delta is the wrong P3 owner.

Do you want to test the directional-branch replacement first, or inspect the Droguet/Kjaer branch trace before changing the model?