# How Author Diversity Decay Reduces Scores for Repeated Authors in X Algorithm

> Understand how author diversity decay in the X Algorithm penalizes repeated authors, ensuring a varied content feed. Learn why consistent contributors see lower scores.

- Repository: [SpaceXAI Org/x-algorithm](https://github.com/xai-org/x-algorithm)
- Tags: deep-dive
- Published: 2026-09-11

---

**Author diversity decay progressively lowers the ranking scores of posts from repeatedly seen authors by applying a multiplicative penalty that grows exponentially with each additional appearance, ensuring a diverse content feed.**

The home-mixer component in the `xai-org/x-algorithm` repository implements author diversity decay to prevent content monopolization by a small set of creators. This mechanism adjusts raw ranking scores based on how many times an author has already appeared in the candidate pool, promoting editorial diversity without hard limits on author frequency.

## How Author Diversity Decay Works in X Algorithm

The implementation follows a three-stage pipeline in [`home-mixer/scorers/ranking_scorer.rs`](https://github.com/xai-org/x-algorithm/blob/main/home-mixer/scorers/ranking_scorer.rs). Each stage transforms the data to progressively penalize repeated authors while maintaining ranking stability.

### Counting Previous Author Appearances

The system first establishes the order of posts by sorting them according to their **pre-diversity scores** in descending order. The `author_pool_counts` function then iterates through this ranked list to count how many times each author has already been encountered.

```rust
// home-mixer/scorers/ranking_scorer.rs → lines 29-45
let mut indexed = pre_diversity_scores.iter().enumerate().collect();
indexed.sort_by(|(_, a), (_, b)| b.partial_cmp(a).unwrap_or(Ordering::Equal));
let mut counts = vec![0u32; candidates.len()];
let mut author_counts = FxHashMap::default();
for (idx, _) in indexed {
    let author_id = candidates[idx].author_id;
    let k = author_counts.get(&author_id).copied().unwrap_or(0);
    counts[idx] = k;                     // number of prior posts by this author
    author_counts.insert(author_id, k + 1);
}

```

This produces a vector where each element represents the number of previous appearances (0 for the first post, 1 for the second, etc.) for the corresponding candidate.

### Calculating the Decay Multiplier

For each appearance count `k`, the `diversity_multiplier` function computes a value between a configured **floor** and 1.0. The formula applies an exponential decay based on the `AuthorDiversityDecay` parameter:

```rust
// home-mixer/scorers/ranking_scorer.rs → lines 25-27
fn diversity_multiplier(decay_factor: f64, floor: f64, exponent: f64) -> f64 {
    (1.0 - floor) * decay_factor.powf(exponent) + floor
}

```

The **exponent** corresponds directly to the author-appearance count. When `k` is 0 (first appearance), the multiplier is 1.0 (no penalty). As `k` increases, the multiplier approaches the `AuthorDiversityFloor` asymptotically. These parameters are defined in [`home-mixer/params/param.rs`](https://github.com/xai-org/x-algorithm/blob/main/home-mixer/params/param.rs) and supplied via query context.

### Applying the Penalty to Final Scores

The `apply_author_diversity` function combines these stages to produce final adjusted scores. It multiplies each pre-diversity score by its corresponding decay multiplier:

```rust
// home-mixer/scorers/ranking_scorer.rs → lines 66-78
let counts = Self::author_pool_counts(candidates, pre_diversity_scores);
let multipliers = Self::author_diversity_multipliers(query, &counts);
pre_diversity_scores
    .iter()
    .zip(multipliers)
    .map(|(&score, multiplier)| score * multiplier)
    .collect()

```

This transformation occurs automatically when the `EnableAuthorDiversity` flag is set in the query parameters, feeding the adjusted scores into downstream ranking logic.

## Code Example: Simulating Author Diversity Decay

The following Rust example demonstrates how identical raw scores degrade for successive posts from the same author using a decay factor of 0.5 and a floor of 0.25:

```rust
// Example: three posts from the same author with identical raw scores
let raw_scores = vec![1.0, 1.0, 1.0];
let decay = 0.5;          // AuthorDiversityDecay
let floor = 0.25;         // AuthorDiversityFloor

// Simulated counts: 0, 1, 2 (first, second, third appearance)
let counts = vec![0u32, 1, 2];
let multipliers: Vec<f64> = counts.iter()
    .map(|&k| RankingScorer::diversity_multiplier(decay, floor, k as f64))
    .collect();   // → [1.0, 0.625, 0.25]

let final_scores: Vec<f64> = raw_scores.iter()
    .zip(multipliers)
    .map(|(&s, m)| s * m)
    .collect();   // → [1.0, 0.625, 0.25]

```

The first post retains its full score of 1.0, the second drops to 0.625, and the third falls to the floor of 0.25, effectively eliminating it from top positions unless its original score was substantially higher than competitors.

## Configuration Parameters for Author Diversity

According to the source code in [`home-mixer/params/param.rs`](https://github.com/xai-org/x-algorithm/blob/main/home-mixer/params/param.rs), three parameters control this behavior:

- **AuthorDiversityDecay**: The base value (between 0.0 and 1.0) raised to the power of the appearance count. Lower values create steeper penalties.
- **AuthorDiversityFloor**: The minimum multiplier allowed, preventing scores from approaching zero regardless of repetition.
- **EnableAuthorDiversity**: A boolean flag that determines whether `apply_author_diversity` is invoked during the scoring pipeline.

Tuning these values allows platform operators to balance between author diversity and content quality signals, with aggressive decay factors heavily suppressing repeated authors while higher floors preserve their ranking potential.

## Summary

- Author diversity decay uses exponential penalties based on prior author appearances in the ranked candidate list.
- The `author_pool_counts` function in [`ranking_scorer.rs`](https://github.com/xai-org/x-algorithm/blob/main/ranking_scorer.rs) tracks repetition order, while `diversity_multiplier` applies the mathematical decay function.
- Final scores equal pre-diversity scores multiplied by decay values ranging from 1.0 down to `AuthorDiversityFloor`.
- The mechanism only activates when `EnableAuthorDiversity` is set to true in the query parameters.
- Configuration through `AuthorDiversityDecay` and `AuthorDiversityFloor` allows granular control over the diversity-quality tradeoff.

## Frequently Asked Questions

### What is the formula for author diversity decay in X Algorithm?

The formula implemented in [`home-mixer/scorers/ranking_scorer.rs`](https://github.com/xai-org/x-algorithm/blob/main/home-mixer/scorers/ranking_scorer.rs) is `(1.0 - floor) * decay_factor.powf(exponent) + floor`, where `exponent` is the number of previous appearances by that author. This produces a multiplier that starts at 1.0 and asymptotically approaches the floor value as the author appears more frequently.

### Where is author diversity decay implemented in the X Algorithm codebase?

The core logic resides in [`home-mixer/scorers/ranking_scorer.rs`](https://github.com/xai-org/x-algorithm/blob/main/home-mixer/scorers/ranking_scorer.rs), specifically within the `author_pool_counts`, `diversity_multiplier`, and `apply_author_diversity` functions. The tunable parameters are defined in [`home-mixer/params/param.rs`](https://github.com/xai-org/x-algorithm/blob/main/home-mixer/params/param.rs), and the candidate data structures live in [`home-mixer/models/candidate.rs`](https://github.com/xai-org/x-algorithm/blob/main/home-mixer/models/candidate.rs).

### How can I disable author diversity decay in X Algorithm?

Set the `EnableAuthorDiversity` parameter to `false` in the query configuration. When disabled, the scoring pipeline skips the `apply_author_diversity` step entirely, and posts receive their original pre-diversity scores without author-based penalties.

### What is the minimum score multiplier for repeated authors?

The minimum multiplier is controlled by the `AuthorDiversityFloor` parameter. Regardless of how many times an author appears, the multiplier never falls below this value. For example, if the floor is set to 0.25, even the tenth post from the same author will receive at least 25% of its original score.