两个余数条件各自都合法，为什么放在一起可能无解？

"""Merge two exact congruences; non-coprime moduli may agree or conflict."""
import json
from math import gcd


def merge_with_trace(a, m, b, n):
    if any(type(value) is not int for value in (a, m, b, n)):
        raise ValueError("all inputs must be integers, not booleans")
    if not 2 <= m <= 1_000_000 or not 2 <= n <= 1_000_000:
        raise ValueError("moduli must be in 2..1000000")
    if abs(a) > 10**12 or abs(b) > 10**12:
        raise ValueError("residue magnitude must be at most 10**12")
    a, b = a % m, b % n
    g = gcd(m, n)
    difference = b - a
    reduced_m, reduced_n = m // g, n // g
    trace = {"normalized": [[a, m], [b, n]], "gcd": g,
             "difference": difference, "residues_mod_gcd": [a % g, b % g],
             "reduced_modulus": reduced_n}
    if difference % g:
        trace["compatible"] = False
        return None, trace
    # x=a+m*t; after division by g, reduced_m and reduced_n are coprime.
    if reduced_n == 1:
        inverse = None
        t = 0  # The second congruence adds no restriction after compatibility.
    else:
        inverse = pow(reduced_m, -1, reduced_n)
        t = (difference // g * inverse) % reduced_n
    period = m * reduced_n
    representative = (a + m * t) % period
    trace.update({"compatible": True, "reduced_coefficient": reduced_m,
                  "reduced_right_side": difference // g,
                  "inverse": inverse, "t": t, "period": period})
    return (representative, period), trace


def merge_congruences(a, m, b, n):
    return merge_with_trace(a, m, b, n)[0]


def direct_oracle(a, m, b, n):
    """No gcd, inverse or merge formula: find a common period and scan it."""
    if not 2 <= m <= 20 or not 2 <= n <= 20:
        raise ValueError("oracle moduli limited to 2..20")
    period = next(value for value in range(max(m, n), m * n + 1)
                  if value % m == 0 and value % n == 0)
    matches = [value for value in range(period)
               if value % m == a % m and value % n == b % n]
    if len(matches) > 1:
        raise AssertionError("more than one representative in minimum common period")
    return (matches[0], period) if matches else None


def main():
    checks = 0
    systems = 0
    compatible = 0
    reduced_modulus_one = 0

    def check(condition):
        nonlocal checks
        if not condition:
            raise AssertionError("congruence verification failed")
        checks += 1

    for m in range(2, 21):
        for n in range(2, 21):
            for a in range(m):
                for b in range(n):
                    wanted = direct_oracle(a, m, b, n)
                    actual, trace = merge_with_trace(a, m, b, n)
                    check(actual == wanted)
                    check(merge_congruences(b, n, a, m) == wanted)
                    check(merge_congruences(a - 2 * m, m, b + 3 * n, n) == wanted)
                    if actual is not None:
                        representative, period = actual
                        check(0 <= representative < period
                              and representative % m == a
                              and representative % n == b
                              and (representative + period) % m == a
                              and (representative + period) % n == b)
                        compatible += 1
                        reduced_modulus_one += trace["reduced_modulus"] == 1
                    else:
                        check(trace["residues_mod_gcd"][0] != trace["residues_mod_gcd"][1])
                    systems += 1

    possible, possible_trace = merge_with_trace(2, 6, 5, 9)
    impossible, impossible_trace = merge_with_trace(2, 6, 4, 9)
    redundant, redundant_trace = merge_with_trace(5, 12, 1, 4)
    check(possible == (14, 18))
    check(impossible is None)
    check(redundant == (5, 12) and redundant_trace["reduced_modulus"] == 1)
    check(merge_congruences(7, 6, 1, 6) == (1, 6))
    check(merge_congruences(1, 6, 2, 6) is None)
    check(merge_congruences(-4, 6, -4, 9) == (14, 18))
    check(merge_congruences(10**12, 1_000_000, -10**12, 1_000_000) == (0, 1_000_000))
    product_window = [x for x in range(6 * 9) if x % 6 == 2 and x % 9 == 5]
    check(product_window == [14, 32, 50])
    invalid = [(0, 1, 0, 2), (0, 0, 0, 2), (0, -2, 0, 2),
               (0, 2, 0, 1_000_001), (0, True, 0, 2), (True, 2, 0, 3),
               (0.0, 2, 0, 3), (0, 2, "0", 3), (0, 2, 0, 3.0),
               (10**12 + 1, 2, 0, 3), (0, 2, -10**12 - 1, 3)]
    for args in invalid:
        try:
            merge_congruences(*args)
        except ValueError:
            check(True)
        else:
            raise AssertionError("invalid congruence input accepted")

    report = {"checks_passed": checks, "exhaustive_systems": systems,
              "compatible_systems": compatible, "incompatible_systems": systems - compatible,
              "compatible_reduced_modulus_one_cases": reduced_modulus_one,
              "possible": {"solution": possible, "trace": possible_trace},
              "impossible": {"solution": impossible, "trace": impossible_trace},
              "redundant": {"solution": redundant, "trace": redundant_trace},
              "solutions_in_product_window_0_to_53": product_window,
              "invalid_inputs_rejected": len(invalid),
              "scope": "two exact integer congruences; normalized solution modulo lcm; no real calendar model"}
    print(json.dumps(report, indent=2))


if __name__ == "__main__":
    main()