Pete Repeat

I too don't have a solution but since discussion pages now have became almost obsolete I intend to spark some discussion here.

My focus here will be on primitive Pythagorean triples, mostly because I have an unproven hunch that the next clean-repeat would be primitive. Since every primitive triple $(a,b,c)$ can be represented by integers $m,n$ via $(m^2-n^2, 2mn, m^2+n^2)$ , the area of such a triangle is $A = \frac{ab}{2} = nm(n+m)(m-n)$ given that $m>n$ .

From here it is easy to prove that:

1. $A \equiv 0 \text{ mod } 6$
2. $A \equiv 0,1,4 \text{ mod } 5$
3. $A \equiv 0, 1, 2, 4, 6, 7, 8, 9, 10, 11, 13, 15, 16 \text{ mod } 17$

I wrote some code to generate these and it is given below as gen_mod . I like how after so many years brilliant still doesn't support multiple code blocks so I dumped everything there as you would see.

Either ways, the above mod rules act as very quick filters for candidate $A$ . From these filters, you can see that $A$ has to be either of the form $444...444$ or $666...666$ . Of course we are only considering primitive triples here. I also provided some very simple code to generate candidate $A$ s.

I will update this post when I get a fast prime factorizer working. So far I've search to 48 digits to no avail.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67

##########################
# Generating mod filters #
##########################
def gen_possible_mods(N):

    "Generates possible a such that n*m*(m-n)*(m+n)=a mod N"

    d = set()
    for n in range(N):
        for m in range(N):
            a = n*m*(n-m)*(m+n) % N
            d.add(a)
            if len(d)==N: return d
    return d

def gen_primes():

    "Generate an infinite sequence of prime numbers."

    D = {}
    q = 2

    while True:
        if q not in D:
            yield q
            D[q * q] = [q]
        else:
            for p in D[q]:
                D.setdefault(p + q, []).append(p)
            del D[q]
        q += 1

fs = []
for p in gen_primes():
    if p>=100: break
    mods = gen_possible_mods(p)
    if len(mods) == p: continue
    fs.append((p,mods))
print(fs)
# [(2, {0}), (3, {0}), (5, {0, 1, 4}), (17, {0, 1, 2, 4, 6, 7, 8, 9, 10, 11, 13, 15, 16})]

##########################
# Generating candidate A #
##########################

def gen_candidate_A(n_digits, fs):

    "Generates candidate A of n_digits given filters fs"

    pos = "46"
    candidates = []

    for nd in range(1,n_digits):
        for p in pos:

            n = int(p*nd)

            cont = False
            for p,f in fs:
                if n%p not in f:
                    cont = True
                    break
            if cont: continue

            candidates.append(n)

    return candidates