def localPointsBeforeTreshold(N): def hypoTreshold(a0, a1, b0, b1): def value(a, b): return -np.sin(a) * np.sin(b) / (np.cos(a) * np.cos(b) - 1) return value(a0, b0), value(a0, b1), value(a1, b0), value(a1, b1) for i in range(N): if i % 100 == 0: print(f'{i+1}/{N}') a0 = np.random.rand() * np.pi a1 = np.random.rand() * np.pi b0 = np.random.rand() * np.pi b1 = np.random.rand() * np.pi P = T.find_P(np.pi / 2, a0, a1, b0, b1) if T.TLM(P): # treshold = tresholdTheta(a0,a1,b0,b1, 1e-5) tresholds = hypoTreshold(a0, a1, b0, b1) n = 100 # Theta = np.linspace(0, treshold,n) Theta = np.linspace(0, np.pi / 2, n) for theta in Theta: for tresh in tresholds: if np.abs(theta - tresh) < 0.03: print("facet") P = T.find_P(theta, a0, a1, b0, b1) nl = T.is_nonlocalPoint(P) print(nl) print("next")
def decomposition(N): Deter = T.find_deterministic_points() a0 = 0 #np.random.rand()*np.pi b0 = 0 #np.random.rand()*np.pi a1 = np.random.rand() * np.pi b1 = np.random.rand() * np.pi Theta = np.linspace(0, np.pi / 2, N) theta_b = np.arcsin(T.hypoTresholdImproved(a0, a1, b0, b1)) P_b = T.find_P(theta_b, a0, a1, b0, b1) decomposers = np.r_[Deter, [P_b]] for theta in Theta: # theta = np.random.rand()*np.pi/2 P = T.find_P(theta, a0, a1, b0, b1) # print(decomposers) alpha, min, status = T.decomposeP(P, decomposers) if status == 0: nonl = T.is_nonlocalPoint(P) print(theta) print(nonl) # print(P, "point") # print(alpha, min, "alpha, min\n") else: print('xd') print(theta_b)
def check(theta, a0, a1, b0, b1): P = T.find_P(theta, a0, a1, b0, b1) Qs = St.satoshiTestComment(P) tlm = T.TLM(T.find_P(np.pi / 2, a0, a1, b0, b1)) wholeSp, thetaNew = St.SPlusCondition(P) Qw = newTest(theta, a0, a1, b0, b1) # flag = optimalTheta(a0,a1,b0,b1) Qn = T.is_exposed(theta, a0, a1, b0, b1, 0.0001) print(theta, a0, a1, b0, b1) print(Qs, Qw, Qn, "extremal") print(tlm, wholeSp)
def newTest(theta, a0, a1, b0, b1): Pmax = T.find_P(np.pi / 2, a0, a1, b0, b1) tlm = T.TLM(Pmax) if tlm: P = T.find_P(theta, a0, a1, b0, b1) wholeSp, thetaNew = St.SPlusCondition(P) if np.abs(thetaNew - theta) > acc: print("something is wrong with theta") if wholeSp: return 1 return 0
def compareSatoshiAndNumeric(N): bothEx = 0 bothNoEx = 0 SatEx = 0 NumEx = 0 for i in range(N): if i % 100 == 0: print(f'{i+1}/{N}') theta = np.random.rand() * np.pi / 4 a0 = np.random.rand() * 2 * np.pi a1 = np.random.rand() * 2 * np.pi b0 = np.random.rand() * 2 * np.pi b1 = np.random.rand() * 2 * np.pi P = T.find_P(theta, a0, a1, b0, b1) isExtremal = St.satoshiTest(P) accuracy = 0.001 isExtremal2 = T.is_exposed(theta, a0, a1, b0, b1, accuracy, limit=1) if isExtremal: if isExtremal2: bothEx += 1 else: SatEx += 1 else: if isExtremal2: NumEx += 1 else: bothNoEx += 1 print(bothNoEx, bothEx, SatEx, NumEx)
def largerTheta(theta): P = T.find_P(theta, a0, a1, b0, b1) S_p, S_m = St.SPlusTemp(P) # print(S_p) # print(S_m) thetaNew = getThetaFromSinSquared(maximum(S_p)) return thetaNew
def hypothesis2(N): tlm0flag0 = 0 tlm0flag1 = 0 tlm1flag0 = 0 tlm1flag1 = 0 for i in range(N): if i % 100 == 0: print(f'{i+1}/{N}') a0 = np.random.rand() * 2 * np.pi a1 = np.random.rand() * 2 * np.pi b0 = np.random.rand() * 2 * np.pi b1 = np.random.rand() * 2 * np.pi theta = np.pi / 2 P = T.find_P(theta, a0, a1, b0, b1) tlm = T.TLM(P) # print("TLM", tlm) flag = optimalTheta(a0, a1, b0, b1) # print(tlm, flag, "tutaj") if tlm: if flag: tlm1flag1 += 1 else: tlm1flag0 += 1 else: if flag: tlm0flag1 += 1 else: tlm0flag0 += 1 print(tlm1flag1, tlm1flag0, tlm0flag1, tlm0flag0)
def satoshiConditions(N): s0STLM0 = 0 s1STLM0 = 0 s0STLM1 = 0 s1STLM1 = 0 for i in range(N): if i % 100 == 0: print(f'{i+1}/{N}') theta = np.random.rand() * np.pi / 4 a0 = np.random.rand() * 2 * np.pi a1 = np.random.rand() * 2 * np.pi b0 = np.random.rand() * 2 * np.pi b1 = np.random.rand() * 2 * np.pi P = T.find_P(theta, a0, a1, b0, b1) correct1, realisation, wholeSp = T.twoQubitRepresentation(P) theta = realisation[0] correct2 = St.STLM(P, theta) if not correct1: print("no 2-qubit realisation????") if correct2 and wholeSp: s1STLM1 += 1 elif correct2 and (not wholeSp): s0STLM1 += 1 elif (not correct2) and wholeSp: s1STLM0 += 1 elif (not correct2) and (not wholeSp): s0STLM0 += 1 print(s0STLM0, s0STLM1, s1STLM0, s1STLM1)
def notUniquePointsInvestigating(N): for i in range(N): P = np.round(T.notUniquePoints(), 6) correct, realisation, wholeSp = T.twoQubitRepresentationSpecial(P) if correct: print(P, "point") theta, a0, a1, b0, b1 = realisation # print(correct, theta, a0/np.pi, a1/np.pi, b0/np.pi, b1/np.pi, wholeSp, np.sin(theta)**2, "tu") # print(P[0]/np.cos(theta), P[1]/np.cos(theta), P[2]/np.cos(theta), P[3]/np.cos(theta), "cosinusy prawdziwe") print(St.STLM(P, theta), "stlm") Ptlm = T.find_P(np.pi / 2, a0, a1, b0, b1) print(T.find_P(theta, a0, a1, b0, b1), "Punkt zwrotny") print(T.is_nonlocalPoint(P), "is nonlocal?") print(T.TLM(Ptlm), "Tlm") print(T.is_exposed(theta, a0, a1, b0, b1, 0.001), "exposed")
def optimalTheta(a0, a1, b0, b1): n = 100 Theta = np.linspace(0, np.pi / 2, n) flag = 0 for theta in Theta: P = T.find_P(theta, a0, a1, b0, b1) Q = St.satoshiTest(P) print(theta, Q)
def notUniquePoint(): # P = [0.4445537842667646, 0.24544802147218514, 0.734354006208671, 0.734354006208671, 0.542908951128687, 0.542908951128687, 0.3966948365612542, 0.3966948365612542] P5 = [0.024973, 0.058992, 0.5, 0.5, 0.07546, 0.07546, 0.092469, 0.092469] P4 = [ 0.25, 0.125, -0.262176, -0.0930301, -0.731555, -0.689269, -0.698783, 0.654382 ] P2 = [ 0.5, 0.5, -np.sqrt(2 / 5), 0, -np.sqrt(5 / 2) / 2, -np.sqrt(5 / 2) / 2 + 1 / np.sqrt(10), -np.sqrt(5 / 2) / 2, np.sqrt(5 / 2) / 2 - 1 / np.sqrt(10) ] P3 = [ 1 / 4, 1 / 2, -np.sqrt(7 / 3) / 3, 1 / np.sqrt(21), -37 / (12 * np.sqrt(21)), -37 / (12 * np.sqrt(21)) + 1 / 4 * (np.sqrt(7 / 3) / 3 + 1 / np.sqrt(21)), -np.sqrt(7 / 3) / 12 - 37 / (12 * np.sqrt(21)), -np.sqrt(7 / 3) / 12 + 43 / (12 * np.sqrt(21)) ] b = np.random.rand() a1 = np.random.rand() a0 = np.random.rand() b = 0.5 a0 = 0.25 a1 = 0.5 A0B0 = (a0 + a1 + a0 * b**2 - a1 * b**2) / (2 * b) A0B1 = A0B0 A1B0 = A0B0 - b * (a0 - a1) A1B1 = A0B0 - b * (a0 - a1) P = [a0, a1, b, b, A0B0, A0B1, A1B0, A1B1] # if A0B0 < 1: print(P, "punkt") correct, realisation, wholeSp = T.twoQubitRepresentation(P) theta, a0, a1, b0, b1 = realisation # print(correct, theta, a0/np.pi, a1/np.pi, b0/np.pi, b1/np.pi, wholeSp, np.sin(theta)**2, "tu") # print(P[0]/np.cos(theta), P[1]/np.cos(theta), P[2]/np.cos(theta), P[3]/np.cos(theta), "cosinusy prawdziwe") print(St.STLM(P, theta), "stlm") Ptlm = T.find_P(np.pi / 2, a0, a1, b0, b1) print(T.find_P(theta, a0, a1, b0, b1), "Punkt zwrotny") print(T.TLM(Ptlm), "Tlm") print(T.is_exposed(theta, a0, a1, b0, b1, 0.001), "exposed")
def tlmVSstlm(N): for i in range(N): if i % 100 == 0: print(f'{i+1}/{N}') a0 = np.random.rand() * 2 * np.pi a1 = np.random.rand() * 2 * np.pi b0 = np.random.rand() * 2 * np.pi b1 = np.random.rand() * 2 * np.pi theta = np.random.rand() * np.pi / 2 P1 = T.find_P(np.pi / 2, a0, a1, b0, b1) P2 = T.find_P(theta, a0, a1, b0, b1) tlm = T.TLM(P1) stlm = St.STLM(P2, theta) wholeSp, theta = St.SPlusCondition(P2) # print(tlm, stlm) if stlm and (not tlm): print(tlm, stlm) if stlm and (not tlm) and wholeSp: print(tlm, stlm, wholeSp) print("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
def minimalTheta(): eps = 1e-5 a0 = eps**2 b0 = eps a1 = np.pi - eps b1 = np.pi - eps**2 theta = np.arcsin(T.hypoTreshold(a0, a1, b0, b1)) print(theta) Q = T.is_exposed(theta + eps, a0, a1, b0, b1, 1e-5) P = T.find_P(theta + eps, a0, a1, b0, b1) nl = T.is_nonlocalPoint(P) print(Q, nl)
def zeroProbability(N): def sinT(a, b, ax, by): return -((-1)**(a + b) * np.sin(ax) * np.sin(by)) / ( 1 + (-1)**(a + b) * np.cos(ax) * np.cos(by)) def cosT(a, b, ax, by): return -(np.cos(ax + (-1)**(a + b) * np.cos(by))) / ( 1 + (-1)**(a + b) * np.cos(ax) * np.cos(by)) def expression(a, b, ax, by): c1 = 1 + (-1)**(a + b) * np.cos(ax) * np.cos(by) c2 = (-1)**(a) * np.cos(ax) + (-1)**(b) * np.cos(by) c3 = (-1)**(a + b) * np.sin(ax) * np.sin(by) return c1 + cosT(a, b, ax, by) * c2 + sinT(a, b, ax, by) * c3 def expression2(theta, a, b, ax, by): c1 = 1 + (-1)**(a + b) * np.cos(ax) * np.cos(by) c2 = (-1)**(a) * np.cos(ax) + (-1)**(b) * np.cos(by) c3 = (-1)**(a + b) * np.sin(ax) * np.sin(by) return c1 + np.cos(theta) * c2 + np.sin(theta) * c3 for i in range(N): if i % 100 == 0: print(f'{i+1}/{N}') a0 = np.random.rand() * 2 * np.pi a1 = np.random.rand() * 2 * np.pi b0 = np.random.rand() * 2 * np.pi b1 = np.random.rand() * 2 * np.pi theta = np.arcsin(T.hypoTreshold(a0, a1, b0, b1)) aa = [a0, a1] bb = [b0, b1] P = T.find_P(theta, a0, a1, b0, b1) A, B, AB = T.createCorrelatorsAndMarginals(P) for x in range(2): for y in range(2): v1 = 1 + A[x] + B[y] + AB[x][y] v2 = 1 + A[x] - B[y] - AB[x][y] v3 = 1 - A[x] + B[y] - AB[x][y] v4 = 1 - A[x] - B[y] + AB[x][y] print(x, y) print(np.sin(aa[x]) * np.sin(bb[y])) print(v1, v2, v3, v4) print(expression2(theta, 0, 0, aa[x], bb[y]), expression2(theta, 0, 1, aa[x], bb[y]), expression2(theta, 1, 0, aa[x], bb[y]), expression2(theta, 1, 1, aa[x], bb[y])) print(expression(0, 0, aa[x], bb[y]), expression(0, 1, aa[x], bb[y]), expression(1, 0, aa[x], bb[y]), expression(1, 1, aa[x], bb[y])) print(np.sin(theta), sinT(0, 0, aa[x], bb[y]), sinT(0, 1, aa[x], bb[y]), sinT(1, 0, aa[x], bb[y]), sinT(1, 1, aa[x], bb[y]))
def tangentToCriticalPoint(N): a0 = 0 b0 = 0 a1 = np.random.rand() * np.pi b1 = np.random.rand() * np.pi theta_b = np.arcsin(T.hypoTresholdImproved(a0, a1, b0, b1)) def pointOnTangent(g): P0 = np.array( [0, 0, 0, 0, 1, np.cos(b1), np.cos(a1), np.cos(a1) * np.cos(b1)]) Pm = np.array([1, np.cos(a1), 1, np.cos(b1), 0, 0, 0, 0]) Pc = np.array([0, 0, 0, 0, 0, 0, 0, np.sin(a1) * np.sin(b1)]) return P0 + Pm * (np.cos(theta_b) - g * np.sin(theta_b)) + Pc * ( np.sin(theta_b) + g * np.cos(theta_b)) P_b = T.find_P(theta_b, a0, a1, b0, b1) nonNeg = T.isOnNonNegativityFacet(P_b) BrokenNonNeg = T.BeyondNonNegativityFacet(P_b) nonLoc = T.is_nonlocalPoint(P_b) print(nonNeg, BrokenNonNeg, nonLoc, "\n") G = np.linspace(-1, 0, N) for g in G: print(g) P = pointOnTangent(g) print(P) nonNeg = T.isOnNonNegativityFacet(P) BrokenNonNeg = T.BeyondNonNegativityFacet(P) nonLoc = T.is_nonlocalPoint(P) print(nonNeg, BrokenNonNeg, nonLoc, "\n") acc = 1e-6 l = -1 p = 0 while p - l > acc: s = (l + p) / 2 P = pointOnTangent(s) BrokenNonNeg = T.BeyondNonNegativityFacet(P) if BrokenNonNeg: l = s else: p = s s = (l + p) / 2 print("\n\n", p) print((np.cos(theta_b) - 1) / np.sin(theta_b)) P_g = pointOnTangent(p) print(P_g) nonNeg = T.isOnNonNegativityFacet(P_g) BrokenNonNeg = T.BeyondNonNegativityFacet(P_g) nonLoc = T.is_nonlocalPoint(P_g) print(nonNeg, BrokenNonNeg, nonLoc, "\n")
def research(theta, a0, a1, b0, b1): def maximum(S): m = 0 for x in range(2): for y in range(2): if S[x][y] > m: m = S[x][y] return m def getThetaFromSinSquared(s): return np.arccos(np.sqrt(1 - s)) P = T.find_P(theta, a0, a1, b0, b1) S_p, S_m = St.SPlusTemp(P) print(S_p) print(S_m) flag = False for x in range(2): for y in range(2): thetaNew = getThetaFromSinSquared(S_p[x][y]) Pnew = T.find_P(thetaNew, a0, a1, b0, b1) stlm = St.STLM(Pnew, thetaNew) print(stlm, "STLM") Qs = St.satoshiTest(Pnew) print(Qs, thetaNew) if Qs: flag = True for x in range(2): for y in range(2): thetaNew = getThetaFromSinSquared(S_m[x][y]) Pnew = T.find_P(thetaNew, a0, a1, b0, b1) stlm = St.STLM(Pnew, thetaNew) print(stlm, "STLM") Qs = St.satoshiTest(Pnew) print(Qs, thetaNew) if Qs: flag = True print("i co?", flag)
def random2QPoints(N): for i in range(N): if i % 100 == 0: print(f'{i+1}/{N}') theta = np.random.rand() * np.pi / 4 a0 = np.random.rand() * 2 * np.pi a1 = np.random.rand() * 2 * np.pi b0 = np.random.rand() * 2 * np.pi b1 = np.random.rand() * 2 * np.pi P = T.find_P(theta, a0, a1, b0, b1) if satoshiTest(P): print("extremal")
def SpSmTheta(N): Theta = np.linspace(0, np.pi / 2, N) a0 = np.random.rand() * 2 * np.pi a1 = np.random.rand() * 2 * np.pi b0 = np.random.rand() * 2 * np.pi b1 = np.random.rand() * 2 * np.pi thetaB = np.arcsin(T.hypoTreshold(a0, a1, b0, b1)) print("graniczna", thetaB) for theta in Theta: P = T.find_P(theta, a0, a1, b0, b1) T.SpSm(P) print(theta, "\n")
def functionalBehaviour(N): for i in range(N): print(f'{i+1}/{N}') a0 = np.random.rand() * 2 * np.pi a1 = np.random.rand() * 2 * np.pi b0 = np.random.rand() * 2 * np.pi b1 = np.random.rand() * 2 * np.pi F1 = [] Tet = [] MAXI = [] tlm = T.TLM(T.find_P(np.pi / 2, a0, a1, b0, b1)) print(tlm) if tlm: thetag = T.getThetaFromSinSquared( T.hypoTreshold(a0, a1, b0, b1)**2) n = 500 Theta = np.linspace(thetag, np.pi / 2, n) for theta in Theta: # a0 = 3/4*np.pi # a1 = np.pi/4 # b0 = np.pi/2 # b1 = np.pi P = T.find_P(theta, a0, a1, b0, b1) wholeSp, thetaNew = St.SPlusCondition(P) # if wholeSp: # f1,m1 = T.Best_func(theta, a0, a1, b0, b1) f2, m2 = T.Best_func_restricted(theta, a0, a1, b0, b1) # print(m1-m2,"hmm") # print(f1) # print(f2) MAXI.append(m2) Tet.append(theta) F1.append(f2) # plt.plot(Tet,F1) plt.plot(Tet, MAXI) plt.show()
def nonnegativitySingularity(N): for i in range(1): a0 = 0 a1 = np.random.rand() * 2 * np.pi b0 = 0 b1 = np.random.rand() * 2 * np.pi P = T.find_P(np.pi / 2, a0, a1, b0, b1) # print(P) tlm = T.TLM(P) # Sp, Sm = St.SPlusTemp(P) # print(Sp) # print(Sm) # theta = np.random.rand()*np.pi/2 # thetaB = np.arcsin(T.hypoTreshold(a0,a1,b0,b1)) # print(thetaB) thetaGr = np.arcsin(T.hypoTresholdImproved(a0, a1, b0, b1)) print(thetaGr) Theta = np.linspace(0, np.pi / 2, N) for theta in Theta: # print(theta) # if i%100 == 0: # print(i) P = T.find_P(theta, a0, a1, b0, b1) stlm = St.STLM(P, theta) c1, thetan = St.SPlusCondition(P) if theta >= thetaGr: c2 = 1 else: c2 = 0 # sat = St.satoshiTest(P) # ex = T.is_exposed(theta,a0,a1,b0,b1, 0.001) if c1 and (not stlm): stlm2 = St.STLMComment(P, theta) print(tlm, stlm, c1, c2)
def plotExposed(D): acc = 1e-4 x0 = 0 x_end = np.pi / 2 y0 = 0 y_end = 1 Y = np.linspace(y0, y_end, D) X = np.linspace(x0, x_end, D) Map = np.zeros((D, D)) for y, CosA in enumerate(Y): for x, theta in enumerate(X): a0 = 0 b0 = 0 a1 = np.arccos(CosA) b1 = -np.arccos(CosA) + 2 * np.pi P = T.find_P(theta, a0, a1, b0, b1) P2 = symmetricPoint2(theta, CosA) # print(np.round(P-P2,7)) # exp1 = T.is_exposed(theta, a0, a1, b0, b1, acc) exp2 = T.is_exposed_hypo(theta, a0, a1, b0, b1) exp3 = St.satoshiTest(P) nonloc = T.is_nonlocalPoint(P) print(exp2) stlm = St.STLM(P, theta) Ptlm = T.find_P(np.pi / 2, a0, a1, b0, b1) tlm = T.TLM(Ptlm) print(stlm, tlm) Map[x][D - y - 1] = exp2 plt.imshow(Map.T, extent=[x0, x_end, y0, y_end]) plt.colorbar() plt.xlabel("theta") plt.ylabel("cos(a)") plt.savefig("symmetric.png") plt.show()
def verify(theta, a0, a1, b0, b1): def createCorrelatorsAndMarginals(P): A = np.array([P[0], P[1]]) B = np.array([P[2], P[3]]) AB = np.array([[P[4], P[5]], [P[6], P[7]]]) return A, B, AB P = T.find_P(theta, a0, a1, b0, b1) A, B, AB = createCorrelatorsAndMarginals(P) S = np.zeros((2, 2)) for x in range(2): for y in range(2): S[x][y] = AB[x][y]**2 - A[x]**2 - B[y]**2 + 1 - 2 + np.sin( theta)**2 return S
def tresholdThetaTest(N): for i in range(N): if i % 100 == 0: print(f'{i+1}/{N}') a0 = np.random.rand() * 2 * np.pi a1 = np.random.rand() * 2 * np.pi b0 = np.random.rand() * 2 * np.pi b1 = np.random.rand() * 2 * np.pi treshold = tresholdTheta(a0, a1, b0, b1, 1e-5) sinThetaHypo = T.hypoTreshold(a0, a1, b0, b1) thetaHypo = T.getThetaFromSinSquared(sinThetaHypo) P = T.find_P(thetaHypo, a0, a1, b0, b1) if T.is_nonlocalPoint(P): print(sinThetaHypo, np.sin(treshold), "nonlocal hypo") else: print(sinThetaHypo, np.sin(treshold), "local hypo")
def tresholdTheta(a0, a1, b0, b1, acc): l = 0 r = np.pi / 2 P0 = T.find_P(r, a0, a1, b0, b1) if not T.TLM(P0): return np.pi / 2 while r - l > acc: theta = (r + l) / 2 Q = newTest(theta, a0, a1, b0, b1) # print(l,r,Q) if Q: r = theta else: l = theta return (r + l) / 2
def SpvsThreshold(N): for i in range(N): if i % 100 == 0: print(i) a0 = np.random.rand() * 2 * np.pi a1 = np.random.rand() * 2 * np.pi b0 = np.random.rand() * 2 * np.pi b1 = np.random.rand() * 2 * np.pi theta = np.random.rand() * np.pi / 2 thetaB = np.arcsin(T.hypoTreshold(a0, a1, b0, b1)) # print("graniczna", thetaB) P = T.find_P(theta, a0, a1, b0, b1) c1, thetan = St.SPlusCondition(P) if theta >= thetaB: c2 = 1 else: c2 = 0 if c1 != c2: print(c1, c2, "aaaaaa")
def research2(theta, a0, a1, b0, b1): def maximum(S): m = 0 for x in range(2): for y in range(2): if S[x][y] > m: m = S[x][y] return m def getThetaFromSinSquared(s): return np.arccos(np.sqrt(1 - s)) def largerTheta(theta): P = T.find_P(theta, a0, a1, b0, b1) S_p, S_m = St.SPlusTemp(P) # print(S_p) # print(S_m) thetaNew = getThetaFromSinSquared(maximum(S_p)) return thetaNew print("Optimal theta start") optTheta = optimalTheta(a0, a1, b0, b1) print("Optimal theta end") flag = False while (theta < optTheta - acc) and (not flag): Pnew = T.find_P(theta, a0, a1, b0, b1) stlm = St.STLM(Pnew, theta) Qs = St.satoshiTest(Pnew) print(Qs, stlm, theta) thetaNew = largerTheta(theta) if Qs: flag = True if abs(thetaNew - theta) < acc: flag = True theta = thetaNew print("Next")
def compareTests(N): St0we0 = 0 St0we1 = 0 St1we0 = 0 St1we1 = 0 for i in range(N): if i % 100 == 0: print(f'{i+1}/{N}') a0 = np.random.rand() * 2 * np.pi a1 = np.random.rand() * 2 * np.pi b0 = np.random.rand() * 2 * np.pi b1 = np.random.rand() * 2 * np.pi theta = np.random.rand() * np.pi / 2 P = T.find_P(theta, a0, a1, b0, b1) Qs = St.satoshiTest(P) Qw = newTest(theta, a0, a1, b0, b1) if Qs: if Qw: St1we1 += 1 else: St1we0 += 1 print(theta, a0, a1, b0, b1) check(theta, a0, a1, b0, b1) break else: if Qw: St0we1 += 1 print(theta, a0, a1, b0, b1) check(theta, a0, a1, b0, b1) break else: St0we0 += 1 print(St1we1, St1we0, St0we1, St0we0)
def hypothesis(N): def research(theta, a0, a1, b0, b1): def maximum(S): m = 0 for x in range(2): for y in range(2): if S[x][y] > m: m = S[x][y] return m def getThetaFromSinSquared(s): return np.arccos(np.sqrt(1 - s)) P = T.find_P(theta, a0, a1, b0, b1) S_p, S_m = St.SPlusTemp(P) print(S_p) print(S_m) flag = False for x in range(2): for y in range(2): thetaNew = getThetaFromSinSquared(S_p[x][y]) Pnew = T.find_P(thetaNew, a0, a1, b0, b1) stlm = St.STLM(Pnew, thetaNew) print(stlm, "STLM") Qs = St.satoshiTest(Pnew) print(Qs, thetaNew) if Qs: flag = True for x in range(2): for y in range(2): thetaNew = getThetaFromSinSquared(S_m[x][y]) Pnew = T.find_P(thetaNew, a0, a1, b0, b1) stlm = St.STLM(Pnew, thetaNew) print(stlm, "STLM") Qs = St.satoshiTest(Pnew) print(Qs, thetaNew) if Qs: flag = True print("i co?", flag) def research2(theta, a0, a1, b0, b1): def maximum(S): m = 0 for x in range(2): for y in range(2): if S[x][y] > m: m = S[x][y] return m def getThetaFromSinSquared(s): return np.arccos(np.sqrt(1 - s)) def largerTheta(theta): P = T.find_P(theta, a0, a1, b0, b1) S_p, S_m = St.SPlusTemp(P) # print(S_p) # print(S_m) thetaNew = getThetaFromSinSquared(maximum(S_p)) return thetaNew print("Optimal theta start") optTheta = optimalTheta(a0, a1, b0, b1) print("Optimal theta end") flag = False while (theta < optTheta - acc) and (not flag): Pnew = T.find_P(theta, a0, a1, b0, b1) stlm = St.STLM(Pnew, theta) Qs = St.satoshiTest(Pnew) print(Qs, stlm, theta) thetaNew = largerTheta(theta) if Qs: flag = True if abs(thetaNew - theta) < acc: flag = True theta = thetaNew print("Next") s0STLM0 = 0 s1STLM0 = 0 s0STLM1 = 0 s1STLM1 = 0 for i in range(N): if i % 100 == 0: print(f'{i+1}/{N}') theta = np.random.rand() * np.pi / 4 a0 = np.random.rand() * 2 * np.pi a1 = np.random.rand() * 2 * np.pi b0 = np.random.rand() * 2 * np.pi b1 = np.random.rand() * 2 * np.pi P = T.find_P(theta, a0, a1, b0, b1) correct1, realisation, wholeSp = T.twoQubitRepresentation(P) theta = realisation[0] correct2 = St.STLM(P, theta) if not correct1: print("no 2-qubit realisation????") if correct2 and wholeSp: s1STLM1 += 1 elif correct2 and (not wholeSp): research2(theta, a0, a1, b0, b1) s0STLM1 += 1 elif (not correct2) and wholeSp: s1STLM0 += 1 elif (not correct2) and (not wholeSp): s0STLM0 += 1