推荐清单只放两条，把所有权重抬高为什么没改变选择概率？

"""Small exact DPP experiment. Standard library only; not a production sampler."""
from fractions import Fraction as F
from itertools import combinations, permutations, product
import json
from pathlib import Path
import platform


def determinant(matrix):
    a = [list(map(F, row)) for row in matrix]
    n = len(a)
    value = F(1)
    for col in range(n):
        pivot = next((r for r in range(col, n) if a[r][col]), None)
        if pivot is None:
            return F(0)
        if pivot != col:
            a[col], a[pivot] = a[pivot], a[col]
            value = -value
        p = a[col][col]
        value *= p
        for row in range(col + 1, n):
            factor = a[row][col] / p
            for j in range(col + 1, n):
                a[row][j] -= factor * a[col][j]
    return value


def determinant_by_permutations(matrix):
    """Independent Leibniz reference, limited to tiny matrices."""
    n = len(matrix)
    total = F(0)
    for perm in permutations(range(n)):
        sign = (-1) ** sum(perm[i] > perm[j] for i in range(n) for j in range(i + 1, n))
        term = F(sign)
        for i in range(n):
            term *= matrix[i][perm[i]]
        total += term
    return total


def inverse(matrix):
    n = len(matrix)
    a = [list(map(F, row)) + [F(i == j) for j in range(n)] for i, row in enumerate(matrix)]
    for col in range(n):
        pivot = next((r for r in range(col, n) if a[r][col]), None)
        if pivot is None:
            raise ValueError('singular matrix')
        a[col], a[pivot] = a[pivot], a[col]
        p = a[col][col]
        a[col] = [x / p for x in a[col]]
        for row in range(n):
            if row != col:
                factor = a[row][col]
                a[row] = [x - factor * y for x, y in zip(a[row], a[col])]
    return [row[n:] for row in a]


def subsets(n):
    return [s for k in range(n + 1) for s in combinations(range(n), k)]


def minor(matrix, subset):
    return [[matrix[i][j] for j in subset] for i in subset]


def rational(value):
    if type(value) is not int and not isinstance(value, F):
        raise ValueError('only exact int/Fraction values are supported; bool and float are rejected')
    return F(value)


def valid_kernel(matrix):
    """Tiny exact PSD check: symmetry and ALL principal minors, not only size k."""
    if not isinstance(matrix, (list, tuple)) or len(matrix) > 5:
        raise ValueError('a list/tuple kernel of size at most 5 is required')
    n = len(matrix)
    if any(not isinstance(row, (list, tuple)) or len(row) != n for row in matrix):
        raise ValueError('square matrix required')
    a = [[rational(x) for x in row] for row in matrix]
    if any(a[i][j] != a[j][i] for i in range(n) for j in range(n)):
        raise ValueError('symmetric matrix required')
    if any(determinant(minor(a, s)) < 0 for s in subsets(n)):
        raise ValueError('PSD kernel required: a principal minor is negative')
    return a


def probabilities(matrix, k=None):
    matrix = valid_kernel(matrix)
    if k is not None and (type(k) is not int or not 0 <= k <= len(matrix)):
        raise ValueError('invalid fixed size')
    weights = {s: determinant(minor(matrix, s)) for s in subsets(len(matrix)) if k is None or len(s) == k}
    if any(w < 0 for w in weights.values()):
        raise ValueError('negative principal minor')
    z = sum(weights.values())
    if not z:
        raise ValueError('requested cardinality has zero probability')
    return {s: w / z for s, w in weights.items()}


def scale(matrix, c):
    c = rational(c)
    if c <= 0:
        raise ValueError('the scale-invariance experiment requires c > 0')
    matrix = valid_kernel(matrix)
    return [[c * x for x in row] for row in matrix]


def gram(vectors):
    if not isinstance(vectors, (list, tuple)) or len(vectors) > 5:
        raise ValueError('at most 5 feature vectors are supported')
    if not vectors:
        return []
    if any(not isinstance(row, (list, tuple)) for row in vectors):
        raise ValueError('feature vectors must be lists or tuples')
    dimension = len(vectors[0])
    if dimension == 0 or any(len(row) != dimension for row in vectors):
        raise ValueError('nonempty feature vectors of equal dimension required')
    features = [[rational(x) for x in row] for row in vectors]
    return [[sum(a * b for a, b in zip(x, y)) for y in features] for x in features]


def expected_size(distribution):
    return sum(len(s) * p for s, p in distribution.items())


def main():
    checks = 0
    def check(condition, label):
        nonlocal checks
        checks += 1
        if not condition:
            raise AssertionError(label)

    two = [[F(1), F(1, 2)], [F(1, 2), F(1)]]
    p = probabilities(two)
    include_a = sum(prob for s, prob in p.items() if 0 in s)
    check(p[()] == F(4, 15), 'two-item empty')
    check(p[(0, 1)] == F(1, 5), 'two-item pair')
    check(include_a == F(7, 15) and include_a != two[0][0], 'L diagonal is not inclusion')
    three = gram([(2, 0), (1, 1), (0, 1)])
    base, larger = probabilities(three), probabilities(scale(three, 3))
    fixed = probabilities(three, 2)
    check(expected_size(base) == F(25, 17), 'base expected size')
    check(expected_size(larger) == F(183, 103), 'scaled expected size')
    check(fixed == {(0, 1): F(4, 9), (0, 2): F(4, 9), (1, 2): F(1, 9)}, 'fixed pair probabilities')
    check(fixed == probabilities(scale(three, 3), 2), 'fixed size scale cancellation')

    matrices = 0
    impossible_fixed_sizes = 0
    for entries in product((-1, 0, 1), repeat=6):
        vectors = [entries[i:i + 2] for i in (0, 2, 4)]
        matrix = gram(vectors)
        ss = subsets(3)
        for s in ss:
            check(determinant(minor(matrix, s)) == determinant_by_permutations(minor(matrix, s)), 'independent determinant reference')
        ident_plus = [[matrix[i][j] + F(i == j) for j in range(3)] for i in range(3)]
        check(sum(determinant(minor(matrix, s)) for s in ss) == determinant(ident_plus), 'normalizer identity')
        dist = probabilities(matrix)
        check(sum(dist.values()) == 1, 'normalization')
        inv = inverse(ident_plus)
        kernel = [[F(i == j) - inv[i][j] for j in range(3)] for i in range(3)]
        for s in ss:
            included = sum(v for t, v in dist.items() if set(s).issubset(t))
            check(included == determinant_by_permutations(minor(kernel, s)), 'inclusion identity')
        check(expected_size(dist) == sum(kernel[i][i] for i in range(3)), 'trace expectation')
        for i, j in combinations(range(3), 2):
            joint = sum(v for t, v in dist.items() if i in t and j in t)
            check(joint == kernel[i][i] * kernel[j][j] - kernel[i][j] ** 2, 'pair dependence')
        for k in range(4):
            try:
                fixed = probabilities(matrix, k)
            except ValueError:
                impossible_fixed_sizes += 1
                continue
            for c in (F(1, 2), F(3)):
                check(fixed == probabilities(scale(matrix, c), k), 'conditional scale invariance')
        check(expected_size(probabilities(scale(matrix, F(1, 2)))) <= expected_size(dist)
              <= expected_size(probabilities(scale(matrix, 3))), 'size monotonicity on tested grid')
        matrices += 1

    check(probabilities([], 0) == {(): F(1)}, 'empty ground set k=0')
    check(probabilities(gram([]), 0) == {(): F(1)}, 'empty feature set k=0')
    zero = [[F(0), F(0)], [F(0), F(0)]]
    check(probabilities(zero, 0) == {(): F(1)}, 'zero kernel k=0')
    check(probabilities(zero)[()] == 1, 'zero kernel chooses empty set')
    check(probabilities(three, 0) == {(): F(1)}, 'nonzero kernel k=0')
    rejected = 0
    rejection_cases = [
        ('rank-deficient fixed size', lambda: probabilities([[F(1), F(1)], [F(1), F(1)]], 2)),
        ('k too large', lambda: probabilities(two, 3)),
        ('negative k', lambda: probabilities(two, -1)),
        ('bool k', lambda: probabilities(two, True)),
        ('negative diagonal hidden by positive 2x2 determinant', lambda: probabilities([[-1, 0], [0, -1]], 2)),
        ('non-square matrix', lambda: probabilities([[1, 0], [0]], 0)),
        ('asymmetric matrix', lambda: probabilities([[1, 1], [0, 1]], 1)),
        ('indefinite matrix with positive diagonal', lambda: probabilities([[1, 2], [2, 1]], 1)),
        ('unequal feature dimensions', lambda: gram([(1, 2), (3,)])),
        ('zero kernel k=1', lambda: probabilities(zero, 1)),
        ('zero kernel k=2', lambda: probabilities(zero, 2)),
        ('zero scale', lambda: scale(two, 0)),
        ('negative scale', lambda: scale(two, -1)),
        ('float kernel unsupported', lambda: probabilities([[0.5]], 1)),
        ('empty feature dimensions unsupported', lambda: gram([[], []])),
        ('kernel outside tiny size bound', lambda: probabilities([[0] * 6 for _ in range(6)])),
    ]
    for label, action in rejection_cases:
        failed = False
        try:
            action()
        except ValueError:
            rejected += 1
            failed = True
        check(failed, label)
    check(rejected == len(rejection_cases), 'all invalid inputs rejected')
    report = {
        'status': 'PASS', 'runtime': platform.python_version(), 'checks': checks,
        'grid_vector_matrices': matrices, 'unique_kernel_count_claimed': False,
        'grid': 'Three 2D vectors; every coordinate in {-1,0,1}; 3^6=729 vector matrices, not necessarily distinct kernels.',
        'impossible_fixed_size_cases_skipped': impossible_fixed_sizes,
        'rejected_input_cases': [label for label, action in rejection_cases],
        'input_contract': 'At most 5 items; exact int/Fraction only; square symmetric kernel; every principal minor nonnegative. Gram features must have equal nonzero dimension, except an empty ground set is accepted.',
        'scale_contract': 'c > 0 only. At c=0 the variable-size process collapses to the empty set and fixed k>0 is undefined. Negative scales are outside this experiment.',
        'main_two_item': {'L_diagonal': '1', 'P_empty': str(p[()]), 'P_pair': str(p[(0, 1)]), 'P_A_included': str(include_a)},
        'main_three_item': {'vectors': [[2, 0], [1, 1], [0, 1]], 'E_size_L': str(expected_size(base)),
                            'E_size_3L': str(expected_size(larger)),
                            'fixed_k_2': {str(s): str(v) for s, v in probabilities(three, 2).items()}},
        'boundary': 'Exact finite arithmetic checks only. No DPP library, random sampler, recommender, training, or model-quality evaluation was run.'}
    Path('report.json').write_text(json.dumps(report, indent=2) + '\n', encoding='utf-8')
    print('L_11=1; P(A included)=7/15; P(empty)=4/15; P(A,B)=1/5')
    print('E[size] at L=25/17; at 3L=183/103')
    print('Fixed k=2 at L and 3L: P(A,B)=4/9, P(A,C)=4/9, P(B,C)=1/9')
    print(f'PASS: {checks} checks; {matrices} vector matrices; {rejected} rejected inputs')


if __name__ == '__main__':
    main()