Why 1,943 Wins No Longer Count: Repeat Opponent Decay in the Jits Rating Engine

Youth jiu-jitsu has a structural reality that adult combat sports do not: thin competitive pools. A grey belt boy competing at 60 pounds in a given region might face the same three or four opponents at every local tournament. The family is doing everything right — competing regularly, showing up, putting the work in. But the bracket draws from a small pool, and the same matchups recur month after month.

Under the previous rating model, every one of those wins was treated identically. The first time you beat an opponent, the engine credited the full rating gain. The eighth time you beat that same opponent, the engine credited the same full gain. Mathematically, there was no difference between a fighter who had beaten thirty unique opponents and a fighter who had beaten the same three opponents ten times each.

That math was wrong.

The eighth win against the same opponent does not carry the same information as the first win against a new opponent. The first win tells the engine something it did not know: you can beat this person. The eighth win confirms what the engine already modeled with high confidence four wins ago. It is not new evidence. It is a restatement of existing evidence.

When every repeated win received full credit, fighters in thin pools accumulated rating points faster than the evidence justified. A 35-5 record built entirely within a small local circuit produced the same rating trajectory as a 35-5 record built across dozens of unique opponents at national-level events. The leaderboard reflected volume, not proven competitive range.

The model now distinguishes between the two. Here is the decay schedule:

The first two wins against any opponent receive full credit. The third and fourth receive half. From the fifth onward, the win still appears in the record — it happened, and it counts as a win — but the rating engine assigns it zero additional value. The match does not move the number.

Losses are unaffected. Every loss against every opponent carries full weight, regardless of how many times you have faced them. You cannot benefit from repeat opponents on the loss side — every defeat teaches the engine something real about your current level. A loss always carries new information — the opponent may be improving, the matchup dynamic may be shifting, or the competitive gap may be widening. The engine needs to see that.

Before repeat decay touches anything, the engine calculates a raw rating gain using the Glicko-2 algorithm — the same system used by international chess federations and competitive gaming leagues. Every match runs through three functions.

First, the engine weights the opponent's Rating Deviation (RD) — a measure of how confident the system is about their rating:

``` g(φ) = 1 / √(1 + 3φ² / π²) ```

An opponent with a stable, well-established rating (low RD) produces a g-value close to 1. An opponent with a volatile or provisional rating produces a lower g-value. Beating a proven competitor moves the number more than beating someone the engine is still figuring out.

Second, the engine calculates the expected win probability before the match happens:

``` E(μ, μj, φj) = 1 / (1 + exp(-g(φj) × (μ - μj))) ```

μ is the fighter's current rating on the internal Glicko-2 scale. μj is the opponent's rating. φj is the opponent's RD. The output is a number between 0 and 1 — the probability the engine assigned to this fighter winning this match before it happened.

If the engine expected a win and got a win, the rating moves a little. If the engine expected a loss and got a win, the rating moves a lot. This is how upsets produce big rating jumps and wins over weaker opponents produce small ones.

Third, the raw gain is computed from the gap between what happened and what the engine expected:

``` raw_gain = K × (outcome - E) ```

Where outcome is 1 for a win and 0 for a loss, E is the expected probability from above, and K is derived from the fighter's current RD (less certain ratings move faster, more established ratings move slower).

The actual Glicko-2 implementation uses the Illinois algorithm to solve for volatility (σ) — a measure of how consistently a fighter performs relative to their rating. Volatile fighters (big swings between wins and losses) get a slightly wider adjustment window. Consistent fighters get a tighter one. The system constant τ is set to 0.5, balancing responsiveness with stability.

All of this runs on a display scale conversion:

``` INTERNAL_BASELINE = 333 SCALE = 173.7178 DISPLAY_MULTIPLIER = 10

toGlicko2(rating) = (rating - 333) / 173.7178 fromGlicko2(μ) = μ × 173.7178 + 333 toDisplay(internal) = 1000 + (internal - 333) × 10 ```

Internally the math runs in Glicko-2 scale. The number displayed on a fighter profile is converted to a 10,000-point display scale. A rating of 3,200 Jits maps to a specific Glicko-2 μ. The conversion is deterministic — there is no rounding, no approximation.

Between rating periods, fighters who do not compete have their RD inflated:

``` RD_new = RD + 20 × months_inactive Capped at 350 (starting RD for new fighters) ```

An inactive rating gradually becomes less certain. When the fighter returns, the higher RD allows bigger adjustments — the system recalibrates faster because it knows the old number may be stale.

After 2 matches, the rating is published. Before that, it shows as Provisional. This threshold allows the Glicko-2 math to establish a meaningful baseline before the number goes public.

THEN repeat opponent decay is applied to the raw gain. The three mechanisms below modify the output of this engine — they do not replace it.

Mechanism 1: Repeat Opponent Decay

The engine maintains a per-fighter map that tracks how many times each opponent has been beaten. After every match, the winner's gain is multiplied by a decay factor based on prior wins against that specific opponent:

``` wins_vs_opponent >= 4 → multiplier = 0.0 (zero credit) wins_vs_opponent >= 2 → multiplier = 0.5 (half credit) wins_vs_opponent < 2 → multiplier = 1.0 (full credit) ```

The multiplier applies to the positive rating change only. If the raw Glicko-2 calculation produces a gain of +120 Jits, and the multiplier is 0.5, the actual gain is +60 Jits. If the multiplier is 0, the gain is 0 Jits.

This is applied independently to three rating layers: the global rating, the format-specific rating (gi or nogi), and the segment rating (belt/gender/format). All three layers use the same decay schedule.

A concrete micro-example:

By the fifth win, the engine has heard this story before. The record shows 5-0. The rating reflects the first four.

Mechanism 2: Rating Deviation Freeze

Rating Deviation, or RD, is the engine's measure of how confident it is about a rating. Lower RD means higher confidence. In standard Glicko-2, every match reduces RD — more matches, more confidence, tighter interval.

The problem: if repeated wins still reduced RD, a fighter could artificially narrow their confidence interval by beating the same opponent over and over. The rating gain would be zero (from repeat decay), but the system would become increasingly certain about that inflated number. An inflated rating with high confidence is harder to correct than an inflated rating with wide uncertainty.

The fix is straightforward. When repeat decay zeros a match (5th+ win against the same opponent), the engine also freezes RD at its pre-match level:

``` if (decay_multiplier === 0): new_rd = max(calculated_rd, pre_match_rd) ```

The max function ensures RD cannot decrease. It can still increase (through inactivity decay or other mechanisms), but the uninformative match cannot make the system more confident. Applied to global, format, and segment RDs.

Here is what the RD trajectory looks like for a typical fighter, and where the freeze intervenes:

``` RD trajectory for a fighter with 15 matches:

Match 1: RD ≈ 320 (big swings, system is learning) Match 3: RD ≈ 260 Match 5: RD ≈ 210 Match 8: RD ≈ 170 Match 15: RD ≈ 140 (tight confidence, small adjustments) Match 30: RD ≈ 100 (very stable)

Without the RD freeze, a zeroed-gain match (5th+ win vs same opponent) would still push RD from 140 → 135. The freeze prevents this. If the match taught the engine nothing about the rating, it should teach the engine nothing about the confidence either. RD stays at 140. ```

In the March 20 recalculation, 1,943 individual matches triggered the RD freeze — exactly the same 1,943 matches where the rating gain was zeroed. Every zeroed-gain match is also an RD-frozen match. The two mechanisms are consistent: if the match teaches the engine nothing about your rating, it should also teach the engine nothing about how much to trust your rating.

Mechanism 3: Testing Ceiling

After a fighter has competed in 30 or more matches, the engine caps their rating at 1.5 times the highest-rated opponent they have ever beaten:

``` if (match_count >= 30): ceiling = best_opponent_rating × 1.5 final_rating = min(final_rating, ceiling) ```

The ceiling uses each opponent's rating at the time of the match, not their current rating. It captures the strongest proven competition a fighter has faced and prevents the rating from climbing far above that benchmark.

Thirty matches is a generous threshold. By that point, a fighter has had ample opportunity to face quality opponents. If the best opponent across 30+ matches is rated at 2,000 Jits, the ceiling is 3,000 Jits — the system is saying: you have proven you can beat 2,000-level competition convincingly, but we have no evidence you can compete at the 4,000 level. If you can, the fix is simple: go compete against 4,000-level opponents.

In the March 20 recalculation, 5 fighters hit the testing ceiling. This is a narrow intervention — it catches only the most extreme outliers.

Consider two hypothetical fighters with similar records but different competitive patterns. The numbers below are simplified to illustrate the decay mechanics. The actual engine applies additional factors — opponent quality, sample size regression, match method, division difficulty, recency — simultaneously. These examples isolate the repeat opponent effect.

Fighter A

40 matches. 35 wins, 5 losses. Competes at one regional organization. Faces the same small group of opponents regularly — not by choice, but because the bracket draws from a small pool.

Opponent breakdown:

Under the old model, all 35 wins carried full weight. Under the new model, 24 carry value. The rating reflects the competitive range actually proven — not the volume accumulated against familiar opponents.

Fighter B

40 matches. 28 wins, 12 losses. Competes across multiple organizations and regions. No opponent faced more than twice.

Every win carries full weight. The record is the record. Fighter B has a worse raw win-loss ratio (70% vs 87.5%) but a higher effective credit ratio (100% vs 68.6%).

The result:

Fighter A's record did not change. Every win is still in the books. But the rating now reflects competitive breadth, not just competitive volume. Fighter B, who took more losses against a wider range of opponents, emerges with the higher rating — because each of those 28 wins proved something the engine did not already know.

These are illustrative approximations. The Glicko-2 engine produces different numbers based on the specific rating of each opponent at the time of each match, the sequence in which matches occurred, confidence intervals, and dozens of other contextual factors. The directional logic holds: repeat wins carry less weight, and breadth of competition is rewarded.

If a rating dropped under this update, here is what happened and what the path forward looks like.

What happened: The engine re-evaluated which wins carried full information value and which were repetitions of something it already knew. Wins against opponents beaten four or more times were discounted or zeroed. The rating moved to reflect the breadth of competition actually proven.

What did not happen: No wins were deleted. No losses were added. The competitive record is unchanged. The rating engine reweighted existing evidence — it did not invent new evidence.

The path forward is straightforward: compete against new opponents.

Look up any fighter's current rating and full match history at jits.gg/leaderboard. Every match, every opponent, every rating change is there.

Every match against a fighter you have never beaten counts at full value. There is no discount, no decay, no adjustment. The engine is explicitly designed to reward the first and second wins against any opponent at full credit. The third and fourth still carry half weight. Only the fifth and beyond are zeroed.

If the local pool is small and the same opponents keep appearing, the most direct way to prove a higher level is to enter events outside the usual circuit. IBJJF, ADCC, and other national-level organizations draw competitors from across the country. Regional organizations in neighboring states bring different pools. Every new opponent is a full-credit opportunity.

Jits.gg tracks brackets from every major organization. You can view upcoming events, see which divisions have deep fields, and find competitions where the matchups will be fresh. The data is there to help plan a competitive calendar that builds the strongest possible rating foundation.

If geography or cost makes travel difficult, the model is not penalizing anyone. It is reflecting a constraint. A fighter who has beaten every available local opponent has proven what can be proven locally. The rating reflects that proven level accurately — it just cannot project beyond it. When the opportunity to travel arrives, every new win counts at full value, and the rating will respond.

The model does not care about intent. It does not distinguish between a family that cannot travel and a family that chooses not to. It only sees results, opponents, and repetition. That is the design. A rating system that required understanding the reasons behind each fighter's competitive schedule would be subjective. This one is not.

We know that thin pools are not anyone's fault. Rural geography, limited belt-age-weight combinations, and regional scheduling create brackets where the same kids meet every month. Families in those situations are doing exactly what they should be doing: showing up and competing. The model does not penalize that. It adjusts how much confidence the rating carries based on the diversity of evidence behind it.

Every model change is recalculated from scratch across the complete match history — 326,416 matches, processed chronologically, with the same math applied to every fighter. No one is grandfathered. No one gets special treatment. When the model improves, every rating improves with it.

This is the largest change to the Jits rating engine since launch. It will not be the last. The model will continue to evolve as the dataset grows, as edge cases surface, and as the competitive environment changes. Every update will be documented transparently, with the math published, the reasoning explained, and the impact quantified.

The model is math. It does not know anyone's name. It only knows their results, who they faced, and how many times. We take that seriously.

Every new opponent is a full-credit opportunity. The work shows up in the number.

Did any wins get removed?

No. Every win is still in the competitive record. Win-loss numbers are unchanged. The rating engine reweighted existing evidence — it did not remove anything.

Will the rating recover?

Every match against an opponent who has never been beaten counts at full value. No discount, no decay. The rating responds immediately to new competitive evidence.

Will this happen again?

The model will continue to evolve as the dataset grows. Every change will be documented with the same transparency — full math, full reasoning, full impact numbers.