Alright guys I may have a new strategy. VQC said it only took a couple steps for a c=145 right? So I am making an exhaustive search for a certain depth of steps using functions we know. I have generated a ton of pathways doing this
def AB(A,B):
C = A * B
D = int(math.sqrt(C))
E = C - D * D
X = D - A
N = int(((X * X)+E)/(2 * A))
return (int(E),int(N),int(D),int(X),int(A),int(B))
def EDX(E,D,X):
C = D*D + E
A = D - X
B = int(C/A)
N = int((XX+E)/(2A))
return (E,N,D,X,A,B)
def F(rec):
newE = rec[e] - ((2*rec[d])+1)
newN = rec[n] - 1
newD = rec[d] + 1
newX = rec[x] + 1
return (newE, newN, newD, newX, rec[a], rec[b])
def FI(rec): #F inverse
N = rec[n] + 1
D = rec[d] - 1
X = rec[x] - 1
E = rec[e] + (2*D) + 1
return (E,N,D,X, rec[a], rec[b])
def C(C):
return AB(1,C)
def nextT(rec):
A = rec[b]
B = 2*rec[b] - rec[a] + 4
X = rec[x] + 2
D = rec[b] + rec[x] + 2
return (rec[e], rec[n], D, X, A, B)
def search(c, depth):
for i in range(2,c):
if(c%i==0):
if(i<c/i):
goal = AB(i,int(c/i))
else:
goal = AB(int(c/i),i)
start = AB(1,c)
path = "S/"
inSearch(start, goal, depth, path)
def checkRec(a,b, path):
for i in range(len(a)):
if(a[i]!=b[i]):
return
print("True", path)
def l(i):
if(i==0):return "e"
if(i==1):return "n"
if(i==2):return "d"
if(i==3):return "x"
if(i==4):return "a"
if(i==5):return "b"
return "?"+str(i)
def inSearch(rec,goal, count, path):
if(rec==None): return
checkRec(rec,goal, path)
if(count==0): return
inSearch(F(rec), goal, count-1, path + "F/")
inSearch(FI(rec), goal, count-1, path + "Fi/")
inSearch(nextT(rec), goal, count-1, path + "+t/")
for i in range(len(rec)):
if(rec[i]<0):continue
inSearch(C(rec[i]), goal, count-1, path + "C("+l(i)+")/")
for i in range(len(rec)):
for j in range(len(rec)):
if(rec[i]*rec[j]<0):continue
if(rec[i]0 or rec[j]0):continue
inSearch(AB(rec[i],rec[j]), goal, count-1, path + "AB("+l(i)+","+l(j)+")/")
for i in range(len(rec)):
for j in range(len(rec)):
for k in range(len(rec)):
if(rec[j]-rec[k]==0):continue
inSearch(EDX(rec[i],rec[j],rec[k]), goal, count-1, path+"EDX("+l(i)+","+l(j)+","+l(k)+")/")
Here is all the python code.
Here is some output:
>>> search(145,2)
True S/C(n)/EDX(a,e,d)/
True S/AB(e,n)/EDX(a,e,d)/
True S/AB(n,e)/EDX(b,e,d)/
True S/AB(n,a)/EDX(b,e,d)/
True S/AB(a,n)/EDX(a,e,d)/
>>> search(145,3)
True S/+t/C(n)/EDX(a,e,d)/
True S/+t/AB(e,n)/EDX(a,e,d)/
True S/+t/AB(n,e)/EDX(b,e,d)/
True S/C(n)/C(b)/EDX(a,e,d)/
True S/C(n)/AB(a,b)/EDX(a,e,d)/
True S/C(n)/AB(b,a)/EDX(b,e,d)/
True S/C(n)/EDX(e,n,d)/EDX(n,e,x)/
True S/C(n)/EDX(e,d,x)/EDX(a,e,d)/
True S/C(n)/EDX(e,d,a)/EDX(n,e,d)/
True S/C(n)/EDX(e,d,a)/EDX(x,e,d)/
True S/C(n)/EDX(e,a,d)/EDX(d,e,x)/
True S/C(n)/EDX(n,d,a)/EDX(x,b,d)/
True S/C(n)/EDX(d,e,a)/EDX(x,d,e)/
True S/C(n)/EDX(d,a,e)/EDX(d,x,e)/
True S/C(n)/EDX(d,b,e)/EDX(n,x,e)/
output for depth of 3.
I am going to make a thing that generates these strings and matches them up against other correct pathways for other coprimes and I'm going to see if we can brute force this thing.
Here are some paths that worked for this 3 depth.
So for the products of the primes [3,5,7,11,13,17,19] I did a depth search where I went at most 3 steps deep to see if I could solve for the correct record. Each step deeper could either be F, F inverse, next T (didn't do previous t), or AB(1,y), AB(x,y), EDX(x,y,z), where x,y,z could be any 3 entries in (e,n,d,x,a,b).
S/EDX(e,a,d)/EDX(x,e,a)/EDX(d,e,n)/ 7 27
S/EDX(n,e,d)/EDX(x,d,n)/EDX(d,e,n)/ 6 27
S/EDX(d,b,e)/EDX(b,x,e)/AB(a,n)/ 6 27
S/EDX(x,e,d)/AB(a,b)/EDX(d,x,e)/ 9 27
S/EDX(x,d,e)/AB(a,b)/EDX(x,d,e)/ 6 27
S/EDX(d,e,n)/EDX(d,e,n)/EDX(e,d,b)/ 6 27
Numbers at the end are amount of times this path worked, then the total times tried. Someone want to take a crack at analyzing these? It doesn't work for every one, but maybe one step (or a couple) need to be iterated.