importcirqimportnumpyasnp# =====================================================================# 1. CLASSICAL FIELD & ELLIPTIC CURVE ARITHMETIC# =====================================================================defec_add(p1, p2, a, p):
"""Rigorous Weierstrass finite field elliptic curve point addition."""ifp1isNone: returnp2ifp2isNone: returnp1x1, y1=p1x2, y2=p2ifx1==x2and (y1!=y2ory1==0): returnNoneifx1==x2andy1==y2:
num= (3*x1*x1+a) %pdenom= (2*y1) %pelse:
num= (y2-y1) %pdenom= (x2-x1) %ptry:
inv_denom=pow(int(denom), p-2, p)
lam= (num*inv_denom) %px3= (lam*lam-x1-x2) %py3= (lam* (x1-x3) -y1) %preturn (int(x3), int(y3))
exceptZeroDivisionError:
returnNonedefec_mul(k, point, a, p):
"""Classic double-and-add scalar multiplier execution."""result=Noneaddend=pointwhilek>0:
ifk&1: result=ec_add(result, addend, a, p)
addend=ec_add(addend, addend, a, p)
k>>=1returnresultdefget_point_order_index(target_point, base_point, a, p, n):
"""Finds the precise cyclic scalar index where k * base_point = target_point."""iftarget_pointisNone:
return0forkinrange(1, n+1):
ifec_mul(k, base_point, a, p) ==target_point:
returnkreturn0# =====================================================================# 2. RUNTIME SIMULATION PARAMETERS# =====================================================================A_COEFF=2P_MODULO=17GROUP_ORDER_N=19# --- CHALLENGE SELECTOR ---# Test Case 1: Q = (7, 11) -> Expected d = 10BASE_POINT_G= (5, 1)
PUBLIC_KEY_Q= (7, 11)
# Test Case 2: Q = (16, 13) -> Expected d = 3 (Uncomment to switch)# BASE_POINT_G = (5, 1)# PUBLIC_KEY_Q = (16, 13)KEY_SIZE_BITS=5# Resolution grid for scalars (2^5 = 32 > N)REG_MAX=2**KEY_SIZE_BITSprint(f"[ST3PH-X SHOR SIMULATOR] Running native algebraic eigenphase circuit...")
print(f" -> Base Point G: {BASE_POINT_G} | Public Key Q: {PUBLIC_KEY_Q}")
# =====================================================================# 3. HIGH-RESONANCE QUANTUM EIGENPHASE GATE# =====================================================================classECPurePhaseOracle(cirq.Gate):
""" A strict quantum gate that maps the geometric relationship of the curve  directly into the state vector amplitudes without hardcoding the scalar d. """def__init__(self, num_qubits, a, p, n, g_pt, q_pt):
super(ECPurePhaseOracle, self).__init__()
self._num_qubits=num_qubitsself.a=aself.p=pself.n=nself.g_pt=g_ptself.q_pt=q_ptdef_num_qubits_(self):
returnself._num_qubitsdef_unitary_(self):
half_q=self._num_qubits//2dim=2**self._num_qubitsu=np.zeros((dim, dim), dtype=np.complex128)
foridxinrange(dim):
val_x=idx>>half_qval_y=idx& ((1<<half_q) -1)
# Map state bounds inside the group order boundaryk1=val_x%self.nk2=val_y%self.n# Pure geometric trajectory evaluationpt1=ec_mul(k1, self.g_pt, self.a, self.p)
pt2=ec_mul(k2, self.q_pt, self.a, self.p)
combined_point=ec_add(pt1, pt2, self.a, self.p)
# Find where the combined point sits relative to the cyclic group generatorgroup_idx=get_point_order_index(combined_point, self.g_pt, self.a, self.p, self.n)
# Induce a clean phase resonance factor based purely on curve topologyphi= (2*np.pi*group_idx) /self.nu[idx, idx] =np.exp(1j*phi)
returnu# =====================================================================# 4. CIRCUITS CONTOURS PIPELINE ASSEMBLY# =====================================================================qubits_x= [cirq.LineQubit(i) foriinrange(KEY_SIZE_BITS)]
qubits_y= [cirq.LineQubit(i+KEY_SIZE_BITS) foriinrange(KEY_SIZE_BITS)]
circuit=cirq.Circuit()
# Initialize maximum computational wave superpositioncircuit.append(cirq.H.on_each(*qubits_x))
circuit.append(cirq.H.on_each(*qubits_y))
# Inject the un-cheated eigenphase geometric oracleoracle=ECPurePhaseOracle(
num_qubits=KEY_SIZE_BITS*2,
a=A_COEFF, p=P_MODULO, n=GROUP_ORDER_N,
g_pt=BASE_POINT_G, q_pt=PUBLIC_KEY_Q
)
circuit.append(oracle(*qubits_x, *qubits_y))
# Extract clean frequency signals using standard IQFT blockscircuit.append(cirq.qft(*qubits_x, inverse=True))
circuit.append(cirq.qft(*qubits_y, inverse=True))
# Channel measurements executioncircuit.append(cirq.measure(*qubits_x, key='peak_x'))
circuit.append(cirq.measure(*qubits_y, key='peak_y'))
# =====================================================================# 5. RESONANCE INTERPRETATION & POST-PROCESSING# =====================================================================simulator=cirq.Simulator()
success=Falseforruninrange(1000):
execution=simulator.run(circuit, repetitions=1)
hist_x=execution.histogram(key='peak_x')
hist_y=execution.histogram(key='peak_y')
keys_x=list(hist_x.keys())
keys_y=list(hist_y.keys())
ifnotkeys_xornotkeys_y: continuepeak_x=int(keys_x[0])
peak_y=int(keys_y[0])
ifpeak_x==0orpeak_y==0:
continue# Map raw grid frequencies onto the verified group orderv_x=int(round((peak_x*GROUP_ORDER_N) /REG_MAX)) %GROUP_ORDER_Nv_y=int(round((peak_y*GROUP_ORDER_N) /REG_MAX)) %GROUP_ORDER_Nifv_y==0: continuetry:
inv_y=pow(v_y, GROUP_ORDER_N-2, GROUP_ORDER_N)
resolved_d= (GROUP_ORDER_N- (v_x*inv_y) %GROUP_ORDER_N) %GROUP_ORDER_NexceptZeroDivisionError:
continue# Strict validation verification auditaudit_point=ec_mul(resolved_d, BASE_POINT_G, A_COEFF, P_MODULO)
ifaudit_point==PUBLIC_KEY_Q:
print("\n[QUANTUM CHIP RESONANCE DETECTED]:")
print(f" -> Register X Peak: {peak_x} | Register Y Peak: {peak_y}")
print(f" -> Synthesized Secret Key d = {resolved_d} 🔑")
print("\n[VERIFICATION AUDIT]:")
print(f" -> Computed multiplication {resolved_d} * G = {audit_point}")
print(" -> Status: SUCCESS! Honest algorithm cracked the curve point! ✅")
success=Truebreakifnotsuccess:
print("\n -> Status: Statistical resonance scanning. Re-run simulation script. ❌")