Yes 😂 — I found the actual structural fix, and there’s an additional bug upstream that makes the v1145 signal even less trustworthy than we thought.

Do not patch P2. Do not clamp negative P3 movement. Replace the BO3 transition owner.

The correct object is:

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

where the two reversal branches are constructed separately.

The two bugs in v1145

First, v1145 collapses both players into one pooled persistence statistic. It sums both players’ afterWin and afterLoss outcomes, computes one log-odds contrast, then _tlBo3StationaryTransitionFromDeltaV1145_ forces the resulting transition process to preserve the original set-win marginal. (TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

That is exactly why a positive contrast becomes:

won previous set → more likely to win next set

which means more sweeps → higher P2 → lower P3.

For illustration, with q1 = .60 and delta = +0.447, the existing v1145 equations imply approximately:

text
qAfterWin  = 64.3%
qAfterLoss = 53.5%

iid P3     = 48.0%
non-IID P3 = 42.8%

So if structural P3 were 47.9%, v1145 wants to move it to roughly 42.7%, not upward.

Clipping that to 47.9% in v1146 would indeed just hide the bad direction.

But there is a second problem.

v1145 is counting the wrong transitions too

This loop:

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

collects every adjacent transition in the match. So for a three-set match it counts both:

text
S1 -> S2
S2 -> S3

(TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

For P(3 sets), only one transition matters:

text
S1 -> S2

A third set exists iff the S2 winner is different from the S1 winner.

S2 -> S3 tells you who wins the deciding set. It has absolutely no causal role in whether the deciding set exists.

So the current +0.447 is not even a clean measurement of the event we're trying to price.

That should be removed in v1146.

---

The replacement

For each player, collect only wins[0] -> wins[1].

For player A:

text
A wins S1:
    reversal = A loses S2

A loses S1:
    reversal = A wins S2

For player B, same thing.

Then construct the actual matchup-oriented branches.

If A wins S1:

text
rAtoB evidence =
    A's historical losses of S2 after winning S1
    +
    B's historical wins of S2 after losing S1

Therefore:

js
nAB =
    a.afterWinN +
    b.afterLossN;

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

If B wins S1:

js
nBA =
    b.afterWinN +
    a.afterLossN;

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

That is the symmetry we actually want.

Not:

text
A history + B history -> one generic persistence delta

but:

text
A-leading branch  -> evidence that B responds
B-leading branch  -> evidence that A responds

---

There's an even cleaner structural prior already inside your engine

This is the nice part.

Your state space already retains:

js
firstSetScoreByScore

conditional on each final exact match score. (TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

And you already have _tlFirstSetFromStateRoot_, which reweights first-set distributions against a supplied final exact-score PMF. (TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

So we don't need to invent 2*q*(1-q) as the baseline anymore.

We can recover the structural reversal branches themselves.

Define:

text
r0_AtoB = P(S2=B | S1=A) from the structural state root
r0_BtoA = P(S2=A | S1=B) from the structural state root

Then by construction:

$$P3_{struct} = q_1 r^0_{A\to B} + (1-q_1)r^0_{B\to A}$$

That is much cleaner than v1145's:

js
iidP3 = 2*q*(1-q)
target = structuralP3 + (transitionP3 - iidP3)

because the structural root may already contain posterior mixture/dependence that makes its P3 different from the naive IID expression.

The exact-score root itself confirms that P3 is literally the 2-1 + 1-2 mass. (TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

---

What I would put into v1146

1. First-transition-only evidence

Replace the inner loop with this logic:

js
function _tlBo3VisibleTransitionEvidenceV1146_(name,surface){
  var out={
    valid:false,
    usable:false,
    source:'MATCH_INPUTS_VISIBLE_BO3_S1_TO_S2_TRANSITIONS_V1146',
    player:String(name||''),
    matches:0,
    transitions:0,

    afterWinN:0,
    afterWinNextWin:0,
    afterWinReversal:0,

    afterLossN:0,
    afterLossNextWin:0,
    afterLossReversal:0,

    reversals:0,
    stays:0,
    skipped:0,
    reason:'NO_VISIBLE_ORDERED_ROWS'
  };

  try{
    if(!name || typeof ioSheets==='undefined' || !ioSheets ||
       typeof ioSheets.getSheet!=='function'){
      out.reason='MATCH_INPUTS_UNAVAILABLE';
      return out;
    }

    var sh=ioSheets.getSheet('Match Inputs');
    if(!sh){
      out.reason='MATCH_INPUTS_SHEET_MISSING';
      return out;
    }

    var norm=function(x){
      try{
        return typeof _afIdentityNormV709_==='function'
          ? _afIdentityNormV709_(x)
          : _tlLengthNormName_(x);
      }catch(_e){
        return _tlLengthNormName_(x);
      }
    };

    var nm=norm(name);
    var aName=norm(String(sh.getRange('A2').getDisplayValue()||''));
    var bName=norm(String(sh.getRange('A11').getDisplayValue()||''));

    var start=nm===aName
      ? ROWSASTART
      : (nm===bName ? ROWSBSTART : NaN);

    if(!Number.isFinite(Number(start))){
      out.reason='PLAYER_NOT_MAPPED_TO_VISIBLE_ROWS';
      return out;
    }

    var n=Number(MAXLAST5ROWS)||7;
    var scores=sh.getRange(start,COLS.MATCH_SCORE,n,1).getDisplayValues();
    var results=sh.getRange(start,COLS.MATCH_RESULT,n,1).getDisplayValues();
    var notes=sh.getRange(start,COLS.MATCH_SCORE,n,1).getNotes();
    var want=_tlLengthNormSurface_(surface);

    for(var i=0;i<n;i++){
      var score=String(scores[i]&&scores[i][0]||'').trim();
      var res=String(results[i]&&results[i][0]||'').toUpperCase();
      var meta=null;

      try{
        meta=_tlParseHistoryMetaNoteV444_(notes[i]&&notes[i][0]);
      }catch(_eMeta){
        meta=null;
      }

      if(!score||!meta||!meta.tl){
        out.skipped++;
        continue;
      }

      if(meta.playerNorm&&norm(meta.playerNorm)!==nm){
        out.skipped++;
        continue;
      }

      var rowSurface=_tlLengthNormSurface_(meta.surface||'');
      if(want!=='UNKNOWN'&&rowSurface!==want){
        out.skipped++;
        continue;
      }

      var won=/\bWON\b|^W\b/.test(res);
      var lost=/\bLOST\b|^L\b/.test(res);

      if(!won&&!lost){
        out.skipped++;
        continue;
      }

      var m={
        scoreRaw:score,
        won:won,
        result:won?'W':'L',
        date:String(meta.dateIso||''),
        surface:String(meta.surface||surface||'')
      };

      var q=_tlOrderedWinsFromMatchObject_(m,3);

      if(!q||!q.valid||!Array.isArray(q.wins)||q.wins.length<2){
        out.skipped++;
        continue;
      }

      // V1146: ONLY S1 -> S2 owns P(3 sets).
      var s1=!!q.wins[0];
      var s2=!!q.wins[1];

      out.matches++;
      out.transitions++;

      if(s1===s2) out.stays++;
      else out.reversals++;

      if(s1){
        out.afterWinN++;

        if(s2){
          out.afterWinNextWin++;
        }else{
          out.afterWinReversal++;
        }
      }else{
        out.afterLossN++;

        if(s2){
          out.afterLossNextWin++;
          out.afterLossReversal++;
        }
      }
    }

    out.valid=out.transitions>0;

    // Final usability is better decided after the two matchup
    // branches are constructed.
    out.usable=out.valid;

    out.reason=out.valid
      ? 'VISIBLE_BO3_S1_TO_S2_READY_V1146'
      : 'NO_VISIBLE_BO3_S1_TO_S2_TRANSITIONS';

    return out;

  }catch(e){
    out.reason='VISIBLE_BO3_S1_TO_S2_EXCEPTION_V1146';
    out.error=String(e&&e.message||e);
    return out;
  }
}

---

2. Reconstruct structural branches

Something like:

js
function _tlBo3FirstSetAProbFromDistV1146_(d){
  if(!d||typeof d!=='object') return NaN;

  var z=0,a=0;

  for(var k in d){
    if(!Object.prototype.hasOwnProperty.call(d,k)) continue;

    var p=Number(d[k]);
    var s=String(k).split('-');
    var ga=Number(s[0]);
    var gb=Number(s[1]);

    if(!(p>0) || s.length!==2 ||
       !Number.isFinite(ga) || !Number.isFinite(gb)) continue;

    z+=p;
    if(ga>gb) a+=p;
  }

  return z>0 ? a/z : NaN;
}


function _tlBo3StructuralBranchesV1146_(state,scorePmf){
  var pmf=_tlNormalizeSetScorePmf_(scorePmf,3);
  var by=state&&state.firstSetScoreByScore;

  if(!pmf||!by){
    return {
      valid:false,
      reason:'STRUCTURAL_FIRST_SET_BY_SCORE_UNAVAILABLE'
    };
  }

  var keys=['2-0','2-1','0-2','1-2'];
  var q1=0;
  var threeAfterA=0;
  var threeAfterB=0;
  var coverage=0;

  for(var i=0;i<keys.length;i++){
    var sk=keys[i];
    var w=Number(pmf[sk]||0);

    if(!(w>0)) continue;

    var firstA=_tlBo3FirstSetAProbFromDistV1146_(by[sk]);

    if(!Number.isFinite(firstA)){
      return {
        valid:false,
        reason:'STRUCTURAL_FIRST_SET_CONDITIONAL_INVALID',
        score:sk
      };
    }

    coverage+=w;
    q1+=w*firstA;

    if(sk==='2-1'||sk==='1-2'){
      threeAfterA+=w*firstA;
      threeAfterB+=w*(1-firstA);
    }
  }

  if(coverage<0.999999999 || !(q1>0&&q1<1)){
    return {
      valid:false,
      reason:'STRUCTURAL_BRANCH_COVERAGE_INVALID'
    };
  }

  var rAtoB=threeAfterA/q1;
  var rBtoA=threeAfterB/(1-q1);

  var structuralP3=
      Number(pmf['2-1']||0)+
      Number(pmf['1-2']||0);

  var reconstructedP3=
      q1*rAtoB+
      (1-q1)*rBtoA;

  if(Math.abs(reconstructedP3-structuralP3)>1e-8){
    return {
      valid:false,
      reason:'STRUCTURAL_BRANCH_IDENTITY_FAILED',
      structuralP3:structuralP3,
      reconstructedP3:reconstructedP3
    };
  }

  return {
    valid:true,
    q1:q1,
    rAtoB:rAtoB,
    rBtoA:rBtoA,
    structuralP3:structuralP3,
    reconstructedP3:reconstructedP3
  };
}

This is important because it makes the branch model an actual extension of the existing structural root, rather than comparing it against the artificial 2q(1-q) object.

---

3. Fuse the two real reversal branches

I'd use the structural branch probabilities as the Bayesian prior instead of Beta(2,2) centered blindly at 50%.

js
function _tlBo3DirectedTransitionTargetV1146_(
  state,
  structuralPmf,
  a,
  b
){
  a=a||{};
  b=b||{};

  var s=_tlBo3StructuralBranchesV1146_(state,structuralPmf);

  if(!s.valid){
    return {
      valid:true,
      applied:false,
      reason:s.reason||'STRUCTURAL_BRANCH_BUILD_FAILED'
    };
  }

  // A wins S1 -> does B reverse in S2?
  var nAB=
      Number(a.afterWinN||0)+
      Number(b.afterLossN||0);

  var xAB=
      Number(a.afterWinReversal||0)+
      Number(b.afterLossReversal||0);

  // B wins S1 -> does A reverse in S2?
  var nBA=
      Number(b.afterWinN||0)+
      Number(a.afterLossN||0);

  var xBA=
      Number(b.afterWinReversal||0)+
      Number(a.afterLossReversal||0);

  if(nAB<2 || nBA<2 || (nAB+nBA)<6){
    return {
      valid:true,
      applied:false,
      reason:'DIRECTED_REVERSAL_BRANCHES_TOO_THIN_V1146',
      targetP3:s.structuralP3,
      targetP2:1-s.structuralP3,
      structural:s,
      nAtoB:nAB,
      nBtoA:nBA
    };
  }

  /*
   * 12 per branch gives approximately the same shrinkage scale
   * as the old N/(N+24) pooled mechanism when evidence is
   * reasonably balanced across the two branches.
   */
  var priorN=12;

  var rawAtoB=xAB/nAB;
  var rawBtoA=xBA/nBA;

  var rAtoB=
      (xAB + priorN*s.rAtoB) /
      (nAB + priorN);

  var rBtoA=
      (xBA + priorN*s.rBtoA) /
      (nBA + priorN);

  rAtoB=_tlBo3ProbV1145_(rAtoB);
  rBtoA=_tlBo3ProbV1145_(rBtoA);

  var targetP3=
      s.q1*rAtoB+
      (1-s.q1)*rBtoA;

  targetP3=Math.max(
    1e-6,
    Math.min(1-1e-6,targetP3)
  );

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

    reason:'DIRECTED_S1_TO_S2_REVERSAL_BRANCHES_APPLIED_V1146',

    structuralP3:s.structuralP3,
    targetP3:targetP3,
    targetP2:1-targetP3,
    p3Delta:targetP3-s.structuralP3,

    firstSetP:s.q1,

    structuralRAtoB:s.rAtoB,
    structuralRBtoA:s.rBtoA,

    rawRAtoB:rawAtoB,
    rawRBtoA:rawBtoA,

    finalRAtoB:rAtoB,
    finalRBtoA:rBtoA,

    nAtoB:nAB,
    reversalsAtoB:xAB,

    nBtoA:nBA,
    reversalsBtoA:xBA,

    shrinkageAtoB:nAB/(nAB+priorN),
    shrinkageBtoA:nBA/(nBA+priorN),

    playerA:a,
    playerB:b,

    structural:s
  };
}

Notice what is not in there:

js
_tlBo3StationaryTransitionFromDeltaV1145_

Gone.

Also gone:

js
rawDelta
effectiveDelta
iidP3
nonIidP3 - iidP3
stationaryCheck

They are solving a different statistical problem.

---

4. Then let the existing IPF do its job

This part of v1145 is already correct:

js
_targetCounts={
  '2':1-targetP3,
  '3':targetP3
};

_recon=_tlIpFWinnerLength_(
  base,
  3,
  pA,
  _targetCounts
);

The current source explicitly already does exactly that and verifies both the winner and length margins to 1e-8. (TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

So if your new branch model says:

text
structural:
P2 = 52.1
P3 = 47.9

directed transition:
P2 = 43.8
P3 = 56.2

IPF must physically move:

text
8.3 points

FROM:
2-0 + 0-2

TO:
2-1 + 1-2

while retaining, say:

text
P(A wins) = 65%
P(B wins) = 35%

That's exactly the operation you've been trying to get.

---

The trace I would add before touching another coefficient

For Droguet/Kjaer it should print something like:

text
[BO3 BRANCH A->B]
S1 winner: Droguet
Droguet after-win reversal: x/n
Kjaer after-loss response: x/n
combined raw reversal: xx.x%
structural reversal: xx.x%
shrunk reversal: xx.x%

[BO3 BRANCH B->A]
S1 winner: Kjaer
Kjaer after-win reversal: x/n
Droguet after-loss response: x/n
combined raw reversal: xx.x%
structural reversal: xx.x%
shrunk reversal: xx.x%

[BO3 LENGTH IDENTITY]
q1 A wins S1: xx.x%
A->B contribution: q1*rAB = xx.x%
B->A contribution: (1-q1)*rBA = xx.x%
structural P3: 47.9%
directed P3: xx.x%
P3 delta: +/-x.xpp
target P2: xx.x%

And separately:

text
[BO3 EVIDENCE SANITY]
matches A: n
S1->S2 observations A: n
matches B: n
S1->S2 observations B: n
S2->S3 observations used: ZERO

That last line is important.

The decisive test

If Droguet/Kjaer's actual first-transition branches come out something like:

text
rA->B = 58%
rB->A = 63%
q1     = 60%

then:

$$P3=.60(.58)+.40(.63)=.600$$

and therefore:

text
P3 = 60.0%
P2 = 40.0%

No P2 adjustment. No Over boost. No floor. No clamp.

The three-set probability rises because both matchup-oriented reversal hazards say a split is likely.

If instead the real branches are:

text
rA->B = 39%
rB->A = 44%

then P3 should fall. We shouldn't interfere with it.

---

One more thing I would change

v1145 gets q directly from state.firstSetScorePmf. (TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

But the structural PMF fed into the transition code has already been winner-aligned before the length seed runs. (TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

Your own _tlFirstSetFromStateRoot_ already exists specifically to reweight first-set probabilities against a final score PMF. (TennisLocks_FINAL_v1145_BO3_NONIID_SET_TRANSITION_20260913.txt)

So v1146 should derive q1 from the same winner-aligned structural PMF, not from the unreconciled raw first-set marginal.

That eliminates another subtle mismatch.

Bottom line

You were looking in the right direction, but I would go one step further than your proposed fix:

v1146 should be a DIRECTED S1→S2 REVERSAL BRANCH model.

Delete the pooled stationary-delta owner.

Do not clip negative P3 deltas.

Do not touch P2 independently.

Do not use S2→S3 observations to model whether S3 occurs.

Use:

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

with each r shrunk toward its own structural branch prior. Then keep your existing IPF, because that portion is already doing the right mass transfer.

I can't tell from the uploaded script alone whether Droguet/Kjaer's live branches are reversal or persistence, because their current Match Inputs ordered-score rows aren't embedded in this file. But this patch will make the next trace answer that question directly instead of laundering it through +0.447.

And yes — I think the S2→S3 contamination plus the stationary pooling is very plausibly why you've been fighting this ridiculous “P2 keeps rising while we're trying to model a three-set candidate” behavior.