counterexample attempt

import math
from sympy import isprime

# Find all Pythagorean triples (a^2 + b^2 = P^2)
def find_pythagorean_triples(P):
    PSquare = P*P
    triples = []
    for a in range( 1, math.isqrt(PSquare // 2) ): # P^2=2*a^2 -> a=sqrt(P^2/2)
        bSquare = PSquare - a*a # b^2 = P^2-a^2
        b = math.isqrt(bSquare) # b = sqrt(P^2-a^2)
        if b*b == bSquare: #check if integer
            triples.append((a, b))
    return triples


# Find all representations as a sum of two squares (P = c^2 + d^2)
def find_sums_of_two_squares(P,triples):
    for c in range( 1, math.isqrt(P // 2) ):
        d_squared = P - c*c
        d = math.isqrt(d_squared)
        if d.is_integer():
            cd2 = 2 * c * d
            for a, b in triples:
                if cd2 == a or cd2 == b: #return first valid solution 2*c*d=(a or b)
                    return c, d, cd2
    return None, None, None

# Main function to find counterexamples
def find_counterexample(checkRange):
    no_div_4_composites = []
    no_div_4_primes = []
    cd2_invalid_primes = []
    cd2_invalid_composites = []

    for P in range(checkRange[0],checkRange[1]):
        # Get all Pythagorean triples
        triples = find_pythagorean_triples(P)
        if not triples:
            continue  # Skip if no triples exist

        # Get all sum of two squares
        c, d, cd2 = find_sums_of_two_squares(P, triples)
        if not c:
            continue  # Skip if no sum-of-squares representation exists

        # Categorize based on validity and primality
        if cd2 % 4 != 0:
            if isprime(P):
                no_div_4_primes.append(P)
            else:
                no_div_4_composites.append(P)
        elif not cd2:
            if isprime(P):
                cd2_invalid_primes.append(P)
            else:
                cd2_invalid_composites.append(P)

    return no_div_4_primes, no_div_4_composites, cd2_invalid_primes, cd2_invalid_composites

# Example usage
checkRange = 1,100
no_div_4_primes, no_div_4_composites, cd2_invalid_primes, cd2_invalid_composites = find_counterexample(checkRange)

# Print results
print("Numbers which neither Pythagorean side is divisible by 4")
if no_div_4_primes:
    print(f"Primes: {no_div_4_primes[:10]}")
if no_div_4_composites:
    print(f"Composites: {no_div_4_composites[:10]}")

print("\nNumbers which neither Pythagorean side is 2*c*d")
if cd2_invalid_primes:
    print(f"Primes: {cd2_invalid_primes[:10]}")
if cd2_invalid_composites:
    print(f"Composites: {cd2_invalid_composites[:10]}")

if (no_div_4_primes or no_div_4_composites) and \
   (cd2_invalid_primes or cd2_invalid_composites):
    # Combine all lists and sort them
    all_invalid = sorted(no_div_4_primes + no_div_4_composites + cd2_invalid_primes + cd2_invalid_composites)

    # Print combined list
    print("\nNumbers which break either rule")
    if all_invalid:
        print(f"Combined lists: {all_invalid[:10]}")