布隆过滤器删掉一项，为什么另一项也突然查不到了？

"""Fixed SHA-256 positions; show why deletion needs counts AND membership facts."""
import hashlib
import itertools
import json


def positions(key, width=16, hashes=3):
    if type(key) is not str or width < 1 or hashes < 1:
        raise ValueError("invalid key or filter parameters")
    return sorted({int.from_bytes(hashlib.sha256((str(i) + ":" + key).encode("utf-8")).digest()[:8],
                                  "big") % width for i in range(hashes)})


class BitFilter:
    def __init__(self):
        self.bits = [0] * 16

    def add(self, key):
        for index in positions(key):
            self.bits[index] = 1

    def maybe(self, key):
        return all(self.bits[index] for index in positions(key))

    def wrong_clear(self, key):
        for index in positions(key):
            self.bits[index] = 0


class CountingFilter:
    def __init__(self):
        self.counts = [0] * 16

    def add(self, key):
        for index in positions(key):
            self.counts[index] += 1

    def maybe(self, key):
        return all(self.counts[index] > 0 for index in positions(key))

    def remove_known_inserted(self, key):
        """Caller must prove an unmatched insertion exists; positive counts do not prove it."""
        indexes = positions(key)
        if any(self.counts[index] <= 0 for index in indexes):
            raise ValueError("counter underflow")
        for index in indexes:
            self.counts[index] -= 1


def guarded_remove(filter_, exact_members, key):
    if key not in exact_members:
        return False
    filter_.remove_known_inserted(key)
    exact_members.remove(key)
    return True


def main():
    first, survivor = "alpha", "gamma"
    bits = BitFilter()
    for key in (first, survivor):
        bits.add(key)
    assert bits.maybe(first) and bits.maybe(survivor)
    before_bits = list(bits.bits)
    bits.wrong_clear(first)
    assert not bits.maybe(survivor)
    counts = CountingFilter()
    for key in (first, survivor):
        counts.add(key)
    counts.remove_known_inserted(first)
    assert counts.maybe(survivor)
    checks = 3
    # A false positive whose deletion steals at least one unique contribution.
    unsafe = CountingFilter()
    members = {first, survivor}
    for key in members:
        unsafe.add(key)
    ghost = next("ghost-" + str(i) for i in range(10000)
                 if unsafe.maybe("ghost-" + str(i))
                 and any(unsafe.counts[j] == 1 for j in positions("ghost-" + str(i))))
    assert ghost not in members
    saved = list(unsafe.counts)
    assert not guarded_remove(unsafe, members, ghost) and unsafe.counts == saved
    checks += 2
    unsafe.remove_known_inserted(ghost)  # Deliberate precondition violation.
    lost = sorted(key for key in members if not unsafe.maybe(key))
    assert lost
    checks += 1
    # All subsets of six fixed keys; delete each known member and recheck all survivors.
    keys = ["key-" + str(i) for i in range(6)]
    for size in range(7):
        for subset in itertools.combinations(keys, size):
            for deleted in subset:
                filter_ = CountingFilter()
                truth = set(subset)
                for key in subset:
                    filter_.add(key)
                assert guarded_remove(filter_, truth, deleted)
                checks += 1
                for key in truth:
                    assert filter_.maybe(key)
                    checks += 1
                expected = [sum(index in positions(key) for key in truth) for index in range(16)]
                assert filter_.counts == expected
                checks += 1
    duplicate = CountingFilter()
    duplicate.add(first)
    duplicate.add(first)
    duplicate.remove_known_inserted(first)
    assert duplicate.maybe(first)
    duplicate.remove_known_inserted(first)
    assert not duplicate.maybe(first)
    checks += 2
    print(json.dumps({"checks_passed": checks,
                      "positions": {first: positions(first), survivor: positions(survivor), ghost: positions(ghost)},
                      "shared_positions": sorted(set(positions(first)) & set(positions(survivor))),
                      "bit_vector_before_wrong_delete": before_bits,
                      "survivor_after_wrong_clear": bool(bits.maybe(survivor)),
                      "survivor_after_counted_delete": bool(counts.maybe(survivor)),
                      "never_inserted_false_positive": ghost, "lost_after_unsafe_ghost_delete": lost,
                      "guard_rejected_ghost": True,
                      "boundary": "tiny deterministic example; exact truth set is test/guard data, not free memory"}, indent=2))


if __name__ == "__main__":
    main()