检索给了同分，为什么调换两行就把NDCG从1变成了三分之一？

"""Linear-gain NDCG with exact ties; independent permutation enumeration."""
from itertools import permutations, product
from math import isclose, isfinite, log2


def require(condition, message):
    if not condition:
        raise AssertionError(message)


def ndcg(relevance, scores, k):
    if not isinstance(relevance, (list, tuple)) or not isinstance(scores, (list, tuple)):
        raise ValueError("paired sequences required")
    if not 2 <= len(relevance) <= 7 or len(scores) != len(relevance):
        raise ValueError("need 2 to 7 paired entries")
    if type(k) is not int or not 1 <= k <= len(relevance):
        raise ValueError("integer k within the list required")
    if any(type(r) not in (int, float) or not isfinite(r) or not 0 <= r <= 10 for r in relevance):
        raise ValueError("nonnegative finite relevance at most 10 required")
    if not any(relevance) or any(type(s) not in (int, float) or not isfinite(s) for s in scores):
        raise ValueError("positive ideal gain and finite scores required")
    order = sorted(range(len(scores)), key=lambda i: (-scores[i], i))
    discount = lambda rank: 1 / log2(rank + 2)
    ideal = sum(gain * discount(rank) for rank, gain in enumerate(sorted(relevance, reverse=True)[:k]))
    arbitrary = sum(relevance[i] * discount(rank) for rank, i in enumerate(order[:k]))
    averaged, start = 0.0, 0
    while start < len(order):
        end = start + 1
        while end < len(order) and scores[order[end]] == scores[order[start]]:
            end += 1
        mean_gain = sum(relevance[i] for i in order[start:end]) / (end - start)
        averaged += mean_gain * sum(discount(rank) for rank in range(start, min(end, k)))
        start = end
    return arbitrary / ideal, averaged / ideal


def permutation_oracle(relevance, scores, k):
    orders = list(permutations(range(len(scores))))
    dcg = lambda order: sum(relevance[i] / log2(rank + 2) for rank, i in enumerate(order[:k]))
    ideal = max(map(dcg, orders))
    allowed = [order for order in orders if all(scores[order[i]] >= scores[order[i + 1]]
                                               for i in range(len(order) - 1))]
    return sum(map(dcg, allowed)) / len(allowed) / ideal


def main():
    for relevance, scores, k in [([3, 1, 0], [.8, .8, .1], 1),
                                 ([1, 3, 0], [.8, .8, .1], 1),
                                 ([3, 1, 0], [.8, .8, .1], 2),
                                 ([3, 1, 0], [.9, .8, .1], 1)]:
        arbitrary, averaged = ndcg(relevance, scores, k)
        print(f"relevance={relevance}; scores={scores}; k={k}; input_tiebreak={arbitrary:.6f}; tie_average={averaged:.6f}")
    count = 0
    for relevance in product((0, 1, 3), repeat=3):
        if not any(relevance):
            continue
        for scores in product((0, 1), repeat=3):
            for k in (1, 2, 3):
                require(isclose(ndcg(relevance, scores, k)[1], permutation_oracle(relevance, scores, k),
                                abs_tol=1e-12), "all tied permutations oracle")
                count += 1
    require(count == 624, "case count")
    for invalid in [([0, 0], [1, 1], 1), ([3, -1], [1, 1], 1), ([3, 1], [1, 1], True)]:
        try:
            ndcg(*invalid)
        except ValueError:
            pass
        else:
            raise AssertionError("invalid input accepted")
    print(f"PASS: {count} cases match every permitted permutation; invalid cases rejected")


if __name__ == '__main__':
    main()