找到一个可疑位，不代表只坏了一位：亲手拆开 Hamming(7,4)

"""Hamming(7,4): single-bit correction does not distinguish two-bit errors."""
import itertools
import json


def validate(bits, length):
    bits = tuple(bits)
    if len(bits) != length or any(type(b) is not int or b not in (0, 1) for b in bits):
        raise ValueError("exact number of integer zero/one bits required")
    return bits


def encode(data):
    data = validate(data, 4)
    word = [0] * 8  # Position zero is unused.
    for position, bit in zip((3, 5, 6, 7), data):
        word[position] = bit
    for p in (1, 2, 4):
        word[p] = sum(word[i] for i in range(1, 8) if i & p) % 2
    return tuple(word[1:])


def syndrome(word):
    word = validate(word, 7)
    return sum(p for p in (1, 2, 4)
               if sum(word[i-1] for i in range(1, 8) if i & p) % 2)


def correct_assuming_at_most_one(word):
    word = list(validate(word, 7))
    suspect = syndrome(word)
    if suspect:
        word[suspect - 1] ^= 1
    return tuple(word)


def flip(word, positions):
    result = list(word)
    for p in positions:
        result[p-1] ^= 1
    return tuple(result)


def reference_codebook():
    # Independent oracle: enumerate all 128 words and use explicit parity sets.
    # This does not call encode(), syndrome(), or the bit-index construction.
    checks = ((0, 2, 4, 6), (1, 2, 5, 6), (3, 4, 5, 6))
    return [word for word in itertools.product((0, 1), repeat=7)
            if all(sum(word[i] for i in row) % 2 == 0 for row in checks)]


def distance(a, b):
    return sum(x != y for x, y in zip(a, b))


def nearest(word, codebook):
    ranked = sorted((distance(word, code), code) for code in codebook)
    if ranked[0][0] == ranked[1][0]:
        raise AssertionError("ambiguous nearest word")
    return ranked[0][1]


def main():
    checks, singles, doubles = 0, 0, 0
    def check(ok):
        nonlocal checks
        if not ok:
            raise AssertionError("Hamming check failed")
        checks += 1
    codebook = reference_codebook()
    check(len(codebook) == 16)
    check(min(distance(a, b) for a, b in itertools.combinations(codebook, 2)) == 3)
    for data in itertools.product((0, 1), repeat=4):
        word = encode(data)
        check(word in codebook)
        check(tuple(word[i-1] for i in (3, 5, 6, 7)) == data)
        check(correct_assuming_at_most_one(word) == word)
        for p in range(1, 8):
            damaged = flip(word, (p,))
            corrected = correct_assuming_at_most_one(damaged)
            check(syndrome(damaged) == p)
            check(corrected == word)
            check(corrected == nearest(damaged, codebook))
            singles += 1
        for p, q in itertools.combinations(range(1, 8), 2):
            damaged = flip(word, (p, q))
            corrected = correct_assuming_at_most_one(damaged)
            check(syndrome(damaged) != 0)
            check(corrected != word and corrected in codebook)
            check(corrected == nearest(damaged, codebook))
            doubles += 1
    # Every 7-bit input is at distance <= 1 from exactly one legal codeword.
    for word in itertools.product((0, 1), repeat=7):
        check(correct_assuming_at_most_one(word) == nearest(word, codebook))
    original = encode((1, 0, 1, 1))
    double = flip(original, (1, 2))
    triple = flip(original, (1, 2, 3))
    check(syndrome(double) == 3)
    check(syndrome(triple) == 0 and triple != original)
    for bad in [(True, 0, 0, 0), (1, 0, 1), (1, 0, 2, 0)]:
        try:
            encode(bad)
        except ValueError:
            check(True)
        else:
            raise AssertionError("invalid data accepted")
    print(json.dumps({"checks_passed": checks, "single_bit_cases_restored": singles,
                      "double_bit_cases_detectable_but_miscorrected": doubles,
                      "original_positions_1_to_7": original,
                      "flip_1_2": {"received": double, "syndrome": syndrome(double),
                                   "assumed_single_correction": correct_assuming_at_most_one(double)},
                      "flip_1_2_3": {"received": triple, "syndrome": syndrome(triple)},
                      "scope": "plain (7,4), even parity; no eighth parity bit and no SECDED decoder"}, indent=2))


if __name__ == "__main__":
    main()