fix(speculation): preserve predictor factor contract

## Summary

### Why?

Neutral prediction changed exact scorer prices at 0 and 1, non-finite factors could create certainty, and failed-path compounding relied on duplicate logical paths that a valid path set cannot contain.

### What?

Return the scorer price unchanged for a neutral combined factor, reject non-finite configured factors, keep revised outputs strictly inside the probability range, and apply failed all-succeeds evidence at most once. Extend tests for exact endpoints, large factors, and infinite-factor rejection.

## Test Plan

- ✅ `./tool/bazel test //submitqueue/extension/speculation/predictor/...`

Author: behinddwalls

submitqueue/extension/speculation/predictor/evidence/evidence.go

@@ -35,7 +35,7 @@ type Factors struct {
 	// PathPassed applies once when a build has passed on the batch's
 	// all-succeed path.
 	PathPassed float64
-	// PathFailed applies once per failed all-succeed path, compounding.
+	// PathFailed applies once when the all-succeed path has failed.
 	PathFailed float64
 	// Merging applies while the batch is merging.
 	Merging float64
@@ -66,7 +66,7 @@ type evidence struct {
 // New creates an evidence predictor bound to the queue named in cfg, revising
 // base's price by factors.
 //
-// It rejects a nil base and non-positive factors.
+// It rejects a nil base and factors that are non-finite or not positive.
 func New(cfg predictor.Config, base scorer.Scorer, factors Factors, scope tally.Scope) (predictor.Predictor, error) {
 	if base == nil {
 		return nil, fmt.Errorf("evidence.New: base must not be nil")
@@ -79,8 +79,8 @@ func New(cfg predictor.Config, base scorer.Scorer, factors Factors, scope tally.
 	} {
 		// Zero would permanently pin matching batches to 0; negatives cannot
 		// represent either direction in the factor contract.
-		if !(factor > 0) {
-			return nil, fmt.Errorf("evidence.New: factor %s must be positive, got %v", name, factor)
+		if !(factor > 0) || math.IsInf(factor, 0) {
+			return nil, fmt.Errorf("evidence.New: factor %s must be finite and positive, got %v", name, factor)
 		}
 	}
 	return &evidence{cfg: cfg, base: base, factors: factors, scope: scope}, nil
@@ -103,25 +103,32 @@ func (r *evidence) Predict(ctx context.Context, batch entity.Batch, paths entity
 		return 0, fmt.Errorf("base scorer returned %v, which is not a probability", price)
 	}
 
-	factor := math.Pow(r.factors.PathFailed, float64(countFailed(paths)))
+	factor := 1.0
 	if hasPassedAllSucceedPath(paths) {
 		factor *= r.factors.PathPassed
 	}
+	if hasFailedAllSucceedPath(paths) {
+		factor *= r.factors.PathFailed
+	}
 	switch batch.State {
 	case entity.BatchStateMerging:
 		factor *= r.factors.Merging
 	case entity.BatchStateCancelling:
 		factor *= r.factors.Cancelling
 	}
+	if factor == 1 {
+		return predictor.Probability(price), nil
+	}
 	return revise(math.Min(math.Max(price, epsilon), 1-epsilon), factor), nil
 }
 
 // revise applies the combined factor while keeping the result a probability.
 func revise(price, factor float64) predictor.Probability {
 	if math.IsInf(factor, 1) {
-		return 1
+		return 1 - epsilon
 	}
-	return predictor.Probability(price * factor / (1 - price + price*factor))
+	revised := price * factor / (1 - price + price*factor)
+	return predictor.Probability(math.Min(math.Max(revised, epsilon), 1-epsilon))
 }
 
 // hasPassedAllSucceedPath reports a passed build on the batch's all-succeed
@@ -149,15 +156,13 @@ func assumesAllSucceed(path entity.SpeculationPath) bool {
 	return true
 }
 
-// countFailed counts failed builds on the batch's all-succeed path; each one
-// compounds. Flip-subset failures are ignored: they were built under different
-// assumptions, the same filter PathPassed uses.
-func countFailed(paths entity.SpeculationPathSet) int {
-	failed := 0
+// hasFailedAllSucceedPath reports a failed build on the batch's all-succeed
+// path. Flip-subset failures were built under different assumptions.
+func hasFailedAllSucceedPath(paths entity.SpeculationPathSet) bool {
 	for _, entry := range paths.Paths {
 		if entry.Status == entity.SpeculationPathStatusFailed && assumesAllSucceed(entry.Path) {
-			failed++
+			return true
 		}
 	}
-	return failed
+	return false
 }

submitqueue/extension/speculation/predictor/evidence/evidence_test.go

@@ -73,10 +73,10 @@ func predict(t *testing.T, price float64, factors Factors, batch entity.Batch, p
 }
 
 func TestPredict_NeutralFactorsReturnTheScorersPrice(t *testing.T) {
-	for _, price := range []float64{0.01, 0.25, 0.5, 0.6, 0.9, 0.99} {
+	for _, price := range []float64{0, 0.01, 0.25, 0.5, 0.6, 0.9, 0.99, 1} {
 		t.Run(fmt.Sprintf("price %v", price), func(t *testing.T) {
 			got := predict(t, price, AllOnes(), entity.Batch{}, pathSet(entity.SpeculationPathStatusPassed, entity.SpeculationPathStatusFailed))
-			assert.InDelta(t, price, got, 1e-9)
+			assert.Equal(t, price, got)
 		})
 	}
 }
@@ -108,12 +108,6 @@ func TestPredict_AppliesOneFactorPerEvidence(t *testing.T) {
 			paths:   pathSet(entity.SpeculationPathStatusFailed),
 			want:    0.2,
 		},
-		{
-			name:    "failed paths compound",
-			factors: Factors{PathPassed: 1, PathFailed: 0.5, Merging: 1, Cancelling: 1},
-			paths:   pathSet(entity.SpeculationPathStatusFailed, entity.SpeculationPathStatusFailed),
-			want:    0.2,
-		},
 		{
 			name:    "merging",
 			factors: Factors{PathPassed: 1, PathFailed: 1, Merging: 19, Cancelling: 1},
@@ -212,6 +206,15 @@ func TestPredict_CertainPricesStayInRangeAndStillMove(t *testing.T) {
 	}
 }
 
+func TestPredict_LargeFactorsDoNotProduceCertainty(t *testing.T) {
+	factors := AllOnes()
+	factors.PathPassed = math.MaxFloat64
+
+	got := predict(t, 0.5, factors, entity.Batch{}, pathSet(entity.SpeculationPathStatusPassed))
+	assert.Greater(t, got, 0.99)
+	assert.Less(t, got, 1.0)
+}
+
 func TestPredict_RejectsAPriceThatIsNotAProbability(t *testing.T) {
 	for _, price := range []float64{-0.1, 1.5, math.NaN()} {
 		t.Run(fmt.Sprintf("price %v", price), func(t *testing.T) {
@@ -235,6 +238,8 @@ func TestNew_RejectsUnusableConstruction(t *testing.T) {
 	zeroed.Merging = 0
 	negative := AllOnes()
 	negative.PathFailed = -1
+	infinite := AllOnes()
+	infinite.PathPassed = math.Inf(1)
 
 	tests := []struct {
 		name    string
@@ -244,6 +249,7 @@ func TestNew_RejectsUnusableConstruction(t *testing.T) {
 		{name: "nil base", base: nil, factors: AllOnes()},
 		{name: "zero factor", base: fixedScorer{price: 0.5}, factors: zeroed},
 		{name: "negative factor", base: fixedScorer{price: 0.5}, factors: negative},
+		{name: "infinite factor", base: fixedScorer{price: 0.5}, factors: infinite},
 		{name: "unset factors", base: fixedScorer{price: 0.5}, factors: Factors{}},
 	}
 	for _, tt := range tests {