KMP匹配失败时，为什么不是把已匹配长度直接清零？

"""KMP retains a matched suffix; resetting it can lose overlapping matches."""
from itertools import product


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


def valid_string(value, empty=True):
    if type(value) is not str or len(value) > 200 or (not empty and not value):
        raise ValueError("a string of at most 200 lowercase ASCII letters required")
    if any(not "a" <= char <= "z" for char in value):
        raise ValueError("lowercase ASCII only")


def prefix(pattern):
    valid_string(pattern, False)
    pi = [0] * len(pattern)
    for i in range(1, len(pattern)):
        j = pi[i - 1]
        while j and pattern[i] != pattern[j]:
            j = pi[j - 1]
        if pattern[i] == pattern[j]:
            j += 1
        pi[i] = j
    return pi


def search(text, pattern, reset=False):
    valid_string(text)
    pi = prefix(pattern)
    if type(reset) is not bool:
        raise ValueError("reset must be bool")
    j, matches, trace = 0, [], []
    for i, char in enumerate(text):
        before, falls = j, []
        while j and char != pattern[j]:
            target = 0 if reset else pi[j - 1]
            falls.append((j, target))
            j = target
        if char == pattern[j]:
            j += 1
        matched = None
        if j == len(pattern):
            matched = i - len(pattern) + 1
            matches.append(matched)
            j = 0 if reset else pi[-1]
        trace.append((i, char, before, falls, j, matched))
    return matches, trace


def naive(text, pattern):
    return [i for i in range(len(text) - len(pattern) + 1)
            if text[i:i + len(pattern)] == pattern]


def main():
    for text, pattern in [("abababaca", "ababaca"), ("abababa", "aba")]:
        good, _ = search(text, pattern)
        bad, _ = search(text, pattern, True)
        print(f"text={text}; pattern={pattern}; prefix={prefix(pattern)}")
        print(f"keep_suffix={good}; reset_to_zero={bad}")
        require(good == naive(text, pattern) and good != bad, "visible counterexample")
    cases = 0
    for n in range(8):
        for letters in product("ab", repeat=n):
            text = "".join(letters)
            for m in range(1, 5):
                for letters in product("ab", repeat=m):
                    pattern = "".join(letters)
                    actual, _ = search(text, pattern)
                    require(actual == naive(text, pattern), "all starting positions")
                    cases += 1
    prefix_cases = 0
    for m in range(1, 7):
        for letters in product("ab", repeat=m):
            pattern = "".join(letters)
            expected = []
            for end in range(1, m + 1):
                word = pattern[:end]
                expected.append(max(k for k in range(end) if word[:k] == word[end-k:]))
            require(prefix(pattern) == expected, "proper prefix/suffix enumeration")
            prefix_cases += 1
    for args in [("abc", ""), ("A", "a"), ("a", "é"), (True, "a"), ("a" * 201, "a")]:
        try:
            search(*args)
        except ValueError:
            pass
        else:
            raise AssertionError("invalid input accepted")
    print(f"search_cases={cases}; prefix_cases={prefix_cases}; invalid_inputs=5")
    print("PASS: all-start-position search and independent proper-border enumeration")


if __name__ == "__main__":
    main()