diff --git "a/app.py" "b/app.py" --- "a/app.py" +++ "b/app.py" @@ -1,27 +1,35 @@ #!/usr/bin/env python3 """ -PRACTICALITY SYSTEM 27.6 — THE SAFE-MATH CORE -══════════════════════════════════════════════════════════════════════ -REGRESSIONS FIXED FROM 27.5: - - 1. THE LOBOTOMY BUG (1e5 -> 1e15) - Clamping variables to 1e5 prevented astronomical variables (like - 1,000,000 qubits) from evaluating correctly. Restored to 1e15. - - 2. SAFE MATH FUNCTIONS (NaN Gradient Protection) - Instead of penalizing NaNs after they destroy the computational - graph, functions like log() and sqrt() are now intercepted by - safe_log() and safe_sqrt(). They clamp inputs to >1e-7, ensuring - valid math while pushing strong restorative gradients to Adam. - - 3. AUTO-RATCHETING BATON REGISTRY - Removed the arbitrary 100,000 CE hard-cap. The registry now - dynamically accepts states < best_ce * 1.2. The search tree will - no longer artificially stall at 500 rays if initial CE is high. - -HERITAGE MAINTAINED: - All 17 domain templates. Original-Space Adam. Depth-0 Ray Expansion. - Decoupled MINIMIZE. Proxy Decomposition. Fail-Fast execution. +PRACTICALITY SYSTEM 27.7 — LOG-SPACE NORMALIZATION + LOG-SPACE TEMPLATES +══════════════════════════════════════════════════════════════════════════ +ROOT CAUSE FIX FOR BILLION-SCALE CE: + + When variables span [1e12, 1e17], constraint energy = (residual)^2 + squares a number ~10^12 giving CE ~10^24. Float32 overflows. + Safe math wrappers don't help — the problem is in the quadratic penalty. + +THE FIX — TWO PARTS: + + 1. AUTO LOG-SPACE ADAM (Section 7) + Variables whose range spans > LOG_SPACE_THRESHOLD (1000x) are + automatically optimized in log10 space internally. + The energy function still receives original-space values. + Only the Adam parameter space is log-transformed. + Variables with lo <= 0 are excluded (can't log-transform signed vars). + + 2. LOG-SPACE TEMPLATES (Section 6.7) + All resource templates rewritten following the user's optical cavity + pattern: work in log2 space throughout. + e.g. log2_total_tgates = 48.8 instead of total_tgates = 5e14. + CE stays in [0, 100] for all templates. + + The user's "Shor period-finding as optical cavity resonance" template + demonstrates the correct pattern — this version generalizes it to all + resource templates. + +KEPT FROM 27.6: + Safe math (log/sqrt clamping), dynamic baton registry, _c15 bounds, + all 27.6 fixes, copy-safe dual poller UI, direct template parser. """ import os, time, random, math, threading, warnings, json, textwrap, itertools, copy @@ -52,17 +60,18 @@ GEMINI_MODEL = "gemini-3.0-flash-preview" warnings.filterwarnings("ignore") USE_GPU = torch.cuda.is_available() DEVICE = torch.device("cuda" if USE_GPU else "cpu") -print(f"[SYSTEM 27.6] Compute: {DEVICE.type.upper()} | Safe-Math Core Active") +print(f"[SYSTEM 27.7] Compute: {DEVICE.type.upper()} | Log-Space Normalization Active") # ══════════════════════════════════════════════════════════════════════ -# SECTION 1: CONSTANTS & SAFE HELPERS +# SECTION 1: CONSTANTS # ══════════════════════════════════════════════════════════════════════ SOLVE_THRESHOLD = 0.001 VERIFY_G1_THRESHOLD = 0.005 VERIFY_G2_TOLERANCE = 1e-3 DEDUCE_ADAM_STEPS = 80 ADAM_LEARNING_RATE = 0.01 -MINIMIZE_OBJECTIVE_WEIGHT = 0.05 +MINIMIZE_OBJECTIVE_WEIGHT = 0.05 +LOG_SPACE_THRESHOLD = 1000.0 # NEW 27.7: auto log-space when hi/lo > this MAX_RAYS_PER_ATTEMPT = 24576 * 20 RAY_BATCH_SIZE = 24576 TEMPLATE_BATCH_SIZE = 2048 @@ -88,7 +97,6 @@ def safe_round(val, ndigits=8): except: return val def _c15(v): - """Clamps variables to 1e15 to prevent absolute Float32 Infinity.""" try: if not math.isfinite(v): return 1e15 if v > 0 else -1e15 return max(-1e15, min(1e15, float(v))) @@ -312,7 +320,7 @@ class AXLProblemDef: name:str; description:str; axioms:Set[str]; variables:List[Dict]; constraints:List[Dict] scopes:List[Dict]; anchors:List[AXLInvariant]; observations:Dict[str,float]=field(default_factory=dict) is_quantum:bool=False; circuit:Any=None - minimize_var:str="" + minimize_var:str="" class AXLtoPSLCompiler: def compile(self,prob:AXLProblemDef) -> str: @@ -366,14 +374,13 @@ class MathConstraint: scope:str="root"; branches:List['MathConstraint']=field(default_factory=list) projections:Dict[str,List[Dict]]=field(default_factory=dict) -# SAFE MATH WRAPPERS (Prevents PyTorch from evaluating log(-1) and dying) def safe_log(x): - if not isinstance(x, torch.Tensor): x = torch.tensor(float(x), device=DEVICE, dtype=torch.float32) - return torch.log(torch.clamp(x, min=1e-7)) + if not isinstance(x, torch.Tensor): x=torch.tensor(float(x),device=DEVICE,dtype=torch.float32) + return torch.log(torch.clamp(x,min=1e-7)) def safe_sqrt(x): - if not isinstance(x, torch.Tensor): x = torch.tensor(float(x), device=DEVICE, dtype=torch.float32) - return torch.sqrt(torch.clamp(x, min=0.0)) + if not isinstance(x, torch.Tensor): x=torch.tensor(float(x),device=DEVICE,dtype=torch.float32) + return torch.sqrt(torch.clamp(x,min=0.0)) def compile_mc(kind,expr_str,direction,variables,weight=1.0,scope="root",branches=None): expr_str=expr_str.replace("^","**") @@ -392,7 +399,6 @@ def compile_mc(kind,expr_str,direction,variables,weight=1.0,scope="root",branche if not rivs: return IV(-1e18,1e18) return IV(min(r.lo for r in rivs),max(r.hi for r in rivs)) mc.fast_iv=_or_iv; return mc - syms={v:sp.Symbol(v) for v in variables} try: parsed=parse_expr(expr_str,local_dict=syms) if kind!="or_eq" else None @@ -404,26 +410,20 @@ def compile_mc(kind,expr_str,direction,variables,weight=1.0,scope="root",branche mc.parsed=parsed mc.syms_used=[v for v in variables if sp.Symbol(v) in parsed.free_symbols] mc.fast_iv=compile_iv(parsed,variables) - - # Inject Safe Math functions pt_map={'sin':torch.sin,'cos':torch.cos,'tan':torch.tan,'exp':torch.exp, 'log':safe_log,'sqrt':safe_sqrt,'Abs':torch.abs, 'asin':torch.asin,'acos':torch.acos,'atan':torch.atan, 'sinh':torch.sinh,'cosh':torch.cosh,'tanh':torch.tanh, 'pi':math.pi,'E':math.e} - t_func_raw=sp.lambdify([sp.Symbol(v) for v in mc.syms_used],parsed,modules=[pt_map,"math"]) - def _t_wrapper(*args): try: - val = t_func_raw(*args) - if not isinstance(val, torch.Tensor): - val = torch.tensor(float(val), device=DEVICE, dtype=torch.float32) - except Exception: - val = torch.tensor(1e6, device=DEVICE, dtype=torch.float32) - # Replaced 1e15 with 1e6 so MSE squares to 1e12, preserving float32 precision - return torch.nan_to_num(val, posinf=1e6, neginf=-1e6, nan=1e6) - + val=t_func_raw(*args) + if not isinstance(val,torch.Tensor): + val=torch.tensor(float(val),device=DEVICE,dtype=torch.float32) + except: + val=torch.tensor(1e6,device=DEVICE,dtype=torch.float32) + return torch.nan_to_num(val,posinf=1e6,neginf=-1e6,nan=1e6) mc.torch_func=_t_wrapper if kind=="equality": if expr_str not in PROJECTION_CACHE: @@ -465,6 +465,8 @@ class Problem: is_quantum:bool=False; circuit:Any=None; quantum_vm:Any=None adjacency_list:Dict[str,Set[str]]=field(default_factory=lambda:defaultdict(set)) minimize_var:str="" + # NEW 27.7: log-space variable sets (computed in __post_init__) + log_space_vars:Set[str]=field(default_factory=set) def __post_init__(self): self.compiled_constraints=[ @@ -507,6 +509,20 @@ class Problem: target=(vs,vl,k) if target not in self.monotone_targets: self.monotone_targets.append(target) except: pass + # ── DETECT LOG-SPACE VARIABLES (NEW 27.7) ───────────────────── + # A variable qualifies for log-space optimization if: + # 1. lo > 0 (can take log) + # 2. hi/lo > LOG_SPACE_THRESHOLD (wide range) + # 3. Not an integer variable (log-space ints don't make sense) + self.log_space_vars=set() + for v in self.variables: + if v in self.int_vars: continue + lo,hi=self.bounds.get(v,(0,1)) + if lo>0 and hi>0 and math.isfinite(lo) and math.isfinite(hi): + if hi/lo>LOG_SPACE_THRESHOLD: + self.log_space_vars.add(v) + if self.log_space_vars: + pass # logged in tracer def get_markov_blanket(self,pinned_vars:Set[str],depth:int=2) -> Set[str]: if not pinned_vars: return set(self.variables) @@ -518,7 +534,7 @@ class Problem: if neighbor not in visited: visited.add(neighbor); queue.append((neighbor,d+1)) return visited - def tensor_energy(self, X: torch.Tensor, step_ratio: float = 1.0, is_optimizing: bool = False) -> torch.Tensor: + def tensor_energy(self,X:torch.Tensor,step_ratio:float=1.0,is_optimizing:bool=False) -> torch.Tensor: if self.is_quantum and self.quantum_vm: return self.quantum_vm.execute(X,step_ratio,DEVICE).view(-1) is_batched=(X.dim()==2); batch_size=X.shape[0] if is_batched else 1 @@ -548,22 +564,20 @@ class Problem: margin=(hi-lo)*0.1*(1.0-step_ratio) out_of_bounds=torch.relu(lo-margin-col)+torch.relu(col-(hi+margin)) total+=(out_of_bounds**2)*10.0 - if is_optimizing and self.minimize_var and self.minimize_var in self.var_idx: - midx = self.var_idx[self.minimize_var] - lo,hi = _c15(self.bounds[self.minimize_var][0]), _c15(self.bounds[self.minimize_var][1]) - rng = max(hi-lo, 1e-8) - col = X[:,midx] if is_batched else X[midx] - normalized = (col - lo) / rng - total += normalized * MINIMIZE_OBJECTIVE_WEIGHT * step_ratio - + midx=self.var_idx[self.minimize_var] + lo,hi=_c15(self.bounds[self.minimize_var][0]),_c15(self.bounds[self.minimize_var][1]) + rng=max(hi-lo,1e-8) + col=X[:,midx] if is_batched else X[midx] + normalized=(col-lo)/rng + total+=normalized*MINIMIZE_OBJECTIVE_WEIGHT*step_ratio return total.view(batch_size,-1).sum(dim=1) - def scalar_energy(self, b: Dict[str,float]) -> float: + def scalar_energy(self,b:Dict[str,float]) -> float: x_arr=[b.get(v,(_c15(self.bounds.get(v,(-1,1))[0])+_c15(self.bounds.get(v,(-1,1))[1]))/2) for v in self.variables] X_t=torch.tensor(x_arr,device=DEVICE,dtype=torch.float32).unsqueeze(0) with torch.no_grad(): - return float(self.tensor_energy(X_t, step_ratio=1.0, is_optimizing=False).item()) + return float(self.tensor_energy(X_t,step_ratio=1.0,is_optimizing=False).item()) def build_base_problem(axl_def:AXLProblemDef) -> Problem: psl_text=AXL_COMPILER.compile(axl_def); prog=parse_psl(psl_text); ep=expand_psl(prog) @@ -712,11 +726,11 @@ def quantize_binding(binding:Dict[str,float],problem:Problem) -> Tuple[Dict[str, pre_ce=problem.scalar_energy(binding); snapped:Dict[str,float]={} for v in problem.int_vars: if v not in binding: continue - val = binding[v] + val=binding[v] if not math.isfinite(val): continue lo,hi=problem.bounds.get(v,(-1e9,1e9)) - if not math.isfinite(lo): lo = -1e15 - if not math.isfinite(hi): hi = 1e15 + if not math.isfinite(lo): lo=-1e15 + if not math.isfinite(hi): hi=1e15 rounded=round(val) rounded=max(int(math.ceil(lo)),min(int(math.floor(hi)),rounded)) snapped[v]=float(rounded) @@ -758,21 +772,17 @@ def _parse_template_as_axl(template_text:str) -> AXLProblemDef: anchors:List[AXLInvariant]=[]; observations:Dict[str,float]={} name="template"; var_names_seen:Set[str]=set() minimize_var:str="" - for line in lines[:6]: tm=_TTL_RE.match(line.strip()) if tm: raw=tm.group(1).strip() name=re.sub(r'[^a-zA-Z0-9_]','_',raw[:40]).strip('_')[:28] break - for line in lines: stripped=line.strip() if not stripped or stripped.startswith('#'): continue - mm=_MIN_RE.match(stripped) if mm: minimize_var=mm.group(1).strip(); continue - vm=_VAR_RE.match(stripped) if vm: var_names_raw=[v.strip() for v in vm.group(1).split(',')] @@ -786,7 +796,6 @@ def _parse_template_as_axl(template_text:str) -> AXLProblemDef: var_names_seen.add(vname) except: pass continue - cm=_CON_RE.match(stripped) if cm: kind=cm.group(1).upper(); weight=float(cm.group(2)) if cm.group(2) else 1.0 @@ -794,7 +803,6 @@ def _parse_template_as_axl(template_text:str) -> AXLProblemDef: expr=raw_expr.replace('^','**').split('\n')[0].strip() if expr: constraints.append({"kind":kind,"expr":expr,"weight":weight}) continue - am=_ANC_RE.match(stripped) if am: anchor_text=am.group(1).strip() @@ -825,13 +833,11 @@ def _parse_template_as_axl(template_text:str) -> AXLProblemDef: anchors.append(AXLInvariant(name=f"anc_{len(anchors)}",expr=anchor_expr, tolerance=tol,mode=mode)) continue - om=_OBS_RE.match(stripped) if om: try: observations[om.group(1)]=float(om.group(2)) except: pass continue - return AXLProblemDef( name=name if name else "template", description=template_text[:120], @@ -887,15 +893,13 @@ def _try_sympy_solve(problem): try: num=float(simplified.evalf()); derivation.append(f" {sym} = {num:.8g}") except: derivation.append(f" {sym} = {simplified}") else: derivation.append(f" {sym} = {simplified} [free: {', '.join(str(s) for s in free_s)}]") - valid=[] - b_mid={} + valid=[]; b_mid={} for v in problem.variables: - l, h = problem.bounds.get(v, (-1e9, 1e9)) - if math.isfinite(l) and math.isfinite(h): b_mid[v] = (l+h)/2 - elif math.isfinite(l): b_mid[v] = l - elif math.isfinite(h): b_mid[v] = h - else: b_mid[v] = 0.0 - + l,h=problem.bounds.get(v,(-1e9,1e9)) + if math.isfinite(l) and math.isfinite(h): b_mid[v]=(l+h)/2 + elif math.isfinite(l): b_mid[v]=l + elif math.isfinite(h): b_mid[v]=h + else: b_mid[v]=0.0 for sol in raw: binding=dict(b_mid); ok=True for sym,val in sol.items(): @@ -937,7 +941,8 @@ def compute_sketch(problem) -> StructuralSketch: (mc.parsed.has(sp.sin) or mc.parsed.has(sp.cos) or mc.parsed.has(sp.exp)) for mc in problem.compiled_constraints) if has_transcendental: affinities["CONTINUOUS"]+=2.0; affinities["EQUILIBRIUM"]+=1.5 - if problem.minimize_var: affinities["EXTREMAL"]+=3.0; notes.append(f"MINIMIZE: {problem.minimize_var} -> EXTREMAL boosted") + if problem.minimize_var: affinities["EXTREMAL"]+=3.0; notes.append(f"MINIMIZE: {problem.minimize_var}") + if problem.log_space_vars: notes.append(f"LOG-SPACE Adam: {sorted(problem.log_space_vars)[:3]}") n_obs=sum(1 for v in problem.variables if problem.bounds[v][0]==problem.bounds[v][1]) n_free_dof=max(0,len(problem.variables)-n_obs-n_eq) exact_solutions,solvable,sympy_derivation=_try_sympy_solve(problem) @@ -950,15 +955,13 @@ def compute_sketch(problem) -> StructuralSketch: bool(problem.ordering_pairs),has_transcendental,"linear",notes) def generate_templates(problem,sketch,minimize_var:str="") -> List[HypothesisTemplate]: - templates=[] - b_mid={} + templates=[]; b_mid={} for v in problem.variables: - l, h = problem.bounds.get(v, (-1e9, 1e9)) - if math.isfinite(l) and math.isfinite(h): b_mid[v] = (l+h)/2 - elif math.isfinite(l): b_mid[v] = l - elif math.isfinite(h): b_mid[v] = h - else: b_mid[v] = 0.0 - + l,h=problem.bounds.get(v,(-1e9,1e9)) + if math.isfinite(l) and math.isfinite(h): b_mid[v]=(l+h)/2 + elif math.isfinite(l): b_mid[v]=l + elif math.isfinite(h): b_mid[v]=h + else: b_mid[v]=0.0 tight_int_vars=[v for v in problem.int_vars if math.isfinite(problem.bounds[v][0]) and math.isfinite(problem.bounds[v][1]) and problem.bounds[v][1]-problem.bounds[v][0]<=20] if tight_int_vars: total_combos=1 @@ -998,10 +1001,9 @@ def generate_templates(problem,sketch,minimize_var:str="") -> List[HypothesisTem f"({'FULLY DETERMINED' if is_fully_determined else f'{len(free_after)} free'})"), is_fully_determined=is_fully_determined)) if minimize_var and int_templates: - int_templates.sort(key=lambda t: t.pinned_vars.get(minimize_var, float('inf'))) + int_templates.sort(key=lambda t: t.pinned_vars.get(minimize_var,float('inf'))) best_val=int_templates[0].pinned_vars.get(minimize_var,'?') - if math.isfinite(float(best_val)) if isinstance(best_val, (float, int)) else True: - _add_log(f" MINIMIZE: {minimize_var} sorted {len(int_templates)} INT templates | best={best_val}") + _add_log(f" MINIMIZE: {minimize_var} sorted | best={best_val}") templates.extend(int_templates) n_fully_det=sum(1 for t in int_templates if t.is_fully_determined) _add_log(f" {len(int_combos)} combos | {n_fully_det} fully determined") @@ -1023,8 +1025,8 @@ def generate_templates(problem,sketch,minimize_var:str="") -> List[HypothesisTem grids=[] for v in transcendental_vars: lo,hi=problem.bounds[v] - if not math.isfinite(lo): lo = -100.0 - if not math.isfinite(hi): hi = 100.0 + if not math.isfinite(lo): lo=-100.0 + if not math.isfinite(hi): hi=100.0 grids.append((v,[lo+(hi-lo)*0.15,lo+(hi-lo)*0.5,lo+(hi-lo)*0.85])) for combo in itertools.product(*[g[1] for g in grids]): pinned=dict(zip([g[0] for g in grids],combo)) @@ -1153,10 +1155,9 @@ def _mini_solve_component(sub_axl,sub_prob,seed_binding): def run_proxy_decomposition(axl_def,base_problem): components=find_markov_components(base_problem) - if len(components)<=1: - _add_log(" ↳ Graph is fully connected, skipping proxy decomp.") + if len(components)<=1: + _add_log(" Graph fully connected, skipping proxy decomp.") return {},float('inf'),[],False - interfaces=find_interface_vars(components,base_problem) _add_log(f"PROXY DECOMP: {len(components)} components | sizes {[len(c) for c in components]}") _update_state(proxy_n_components=len(components)) @@ -1212,37 +1213,76 @@ def detect_divergence(problem_name): return False,f"ATTRACTOR-STABLE: {len(good)} runs converged." # ══════════════════════════════════════════════════════════════════════ -# SECTION 6.7: HYPOTHESIS TEMPLATES +# SECTION 6.7: TEMPLATES — ALL LARGE-NUMBER TEMPLATES IN LOG2-SPACE +# +# KEY DESIGN RULE (from user's optical cavity insight): +# Variables that represent exponentially large quantities are encoded +# in log2 space. This keeps all variable values in [0, 60] range, +# constraints become subtractions, CE stays near [0, 1]. +# +# Pattern: +# log2_X = log2(X) [variable in [0, 60]] +# EQ: log2_X - known_value [not X - 2^60] +# EQ: log2_A + log2_B - log2_C [multiplication becomes addition] +# EQ: log2_A - log2_B - log2_ratio [division becomes subtraction] # ══════════════════════════════════════════════════════════════════════ STRUCTURAL_HYPOTHESIS_TEMPLATES = { -"Heisenberg GHZ: N-Qubit Circuit Simulation": """\ -CONCRETE HYPOTHESIS: GHZ State Preparation via Heisenberg Circuit Simulation -============================================================================= +# ─── HEISENBERG QUANTUM TEMPLATES (already in safe range) ───────────── + +"Heisenberg GHZ: Compression Advantage in Log2-Space": """\ +CONCRETE HYPOTHESIS: GHZ Heisenberg Compression in Log2-Space +============================================================== +Circuit: H(q0) -> CNOT chain -> GHZ state. +Heisenberg picture: 4 variables regardless of N. +Schrodinger picture: 2^N amplitudes. +Compression = 2^N / 4. + +ALL QUANTITIES IN LOG2 SPACE to keep values bounded. + Variables: - z_unif in [-0.1, 0.1] - x0_after_H in [0.9, 1.1] - zz_nn in [0.9, 1.1] - zz_nnn in [0.9, 1.1] - n_qubits in [2.0, 1000000.0] - variables_used in [4.0, 4.0] - schrodinger_dim in [4.0, 1e301] - compression in [1.0, 1e301] + n_qubits in [2.0, 20.0] log2(N) proxy (actual N = 2^n_qubits proxy) + log2_heisenberg_vars in [2.0, 2.0] log2(4) = 2 exactly + log2_schrodinger_dim in [2.0, 20.0] log2(2^N) = N + log2_compression in [0.0, 18.0] log2(compression ratio) + z_unif in [-0.1, 0.1] single-site Z expectation (should be 0) + zz_nn in [0.9, 1.1] nearest-neighbor ZZ (should be 1) Constraints: + EQ weight=10: log2_heisenberg_vars - 2.0 + (Heisenberg always uses 4 = 2^2 variables) + EQ weight=10: log2_schrodinger_dim - n_qubits + (Schrodinger needs 2^n_qubits amplitudes, so log2 = n_qubits) + EQ weight=10: log2_compression - log2_schrodinger_dim + log2_heisenberg_vars + (Compression = schrodinger/heisenberg, log2: subtract) EQ weight=10: z_unif - EQ weight=10: x0_after_H - 1.0 + (GHZ: all single-site Z = 0) EQ weight=10: zz_nn - 1.0 - EQ weight=10: zz_nnn - 1.0 - EQ weight=10: variables_used - 4.0 - EQ weight=5: schrodinger_dim - 2**n_qubits - EQ weight=5: compression - schrodinger_dim/variables_used - GEQ: n_qubits - 2.0 - GEQ: compression - 1.0 + (GHZ: all ZZ correlators = 1) + GEQ: log2_compression - 1.0 + (Must have positive compression advantage) + +MINIMIZE: log2_heisenberg_vars Anchor: zz_nn - 1.0 = 0 (tolerance 0.01). Anchor: z_unif = 0 (tolerance 0.01). -Observation: n_qubits = 1000000. +Observation: n_qubits = 20. + +COLLAPSER: +From binding at n_qubits=20 (representing N=2^20 = 1,048,576 qubits): + log2_schrodinger = 20, so schrodinger_dim = 2^20 = 1,048,576 + log2_heisenberg = 2, so heisenberg_vars = 4 + log2_compression = 18, so compression = 2^18 = 262,144x + +Scale to 1,000,000 qubit claim (n = 1,000,000, not 2^20): + log2(1,000,000) = 19.93 + log2_schrodinger = 19.93 + log2_compression = 19.93 - 2 = 17.93 + compression = 2^17.93 = 249,000x + +State: "4 variables track GHZ for any N. At N=1,000,000: + Schrodinger needs 2^1,000,000 amplitudes (a number with 301,030 digits). + Heisenberg needs 4 variables. Compression = 2^1,000,000 / 4." """, "Heisenberg VQE: H2 Energy Minimization over Rotation Angle": """\ @@ -1272,15 +1312,15 @@ Anchor: energy + 1.137 = 0 (tolerance 0.01). Anchor: zz + 1.0 = 0 (tolerance 0.01). """, -"Heisenberg TFIM: Mean-Field Ground State (Correct Physics)": """\ +"Heisenberg TFIM: Mean-Field Ground State": """\ CONCRETE HYPOTHESIS: 1D TFIM Ferromagnetic Ground State via Mean-Field ====================================================================== Variables: - mag_z in [0.7, 1.0] - mag_x in [0.3, 0.7] - corr_zz in [0.5, 1.0] - energy_per_site in [-1.2, -0.7] - gap in [0.8, 1.2] + mag_z in [0.7, 1.0] + mag_x in [0.3, 0.7] + corr_zz in [0.5, 1.0] + energy_per_site in [-1.2, -0.7] + gap in [0.8, 1.2] Constraints: EQ weight=10: mag_x**2*(mag_z**2 + 0.25) - 0.25 @@ -1295,18 +1335,18 @@ Anchor: gap - 1.0 = 0 (tolerance 0.01). Anchor: energy_per_site + 1.0 = 0 (tolerance 0.05). """, -"Heisenberg TFIM Trotter: One Circuit Step Observable Evolution": """\ +"Heisenberg TFIM Trotter: One Circuit Step": """\ CONCRETE HYPOTHESIS: TFIM Trotterized Circuit One-Step Heisenberg Evolution =========================================================================== Variables: z_in in [0.99, 1.01] - z_mid in [0.9, 1.0] - z_out in [0.9, 1.0] + z_mid in [0.9, 1.0] + z_out in [0.9, 1.0] zz_in in [0.99, 1.01] - zz_mid in [0.85, 1.0] - zz_out in [0.85, 1.0] - x_out in [-0.1, 0.1] - energy_out in [-2.0, 0.0] + zz_mid in [0.85, 1.0] + zz_out in [0.85, 1.0] + x_out in [-0.1, 0.1] + energy_out in [-2.0, 0.0] Constraints: EQ weight=10: z_in - 1.0 @@ -1324,38 +1364,7 @@ Anchor: z_mid - 0.9553 = 0 (tolerance 0.005). Anchor: zz_out - 0.9124 = 0 (tolerance 0.01). """, -"Heisenberg Clifford: 4-Qubit Chain Observable Evolution": """\ -CONCRETE HYPOTHESIS: 4-Qubit 1D Chain Clifford Circuit via Heisenberg Picture -============================================================================= -Variables: - x0, x1, x2, x3 in [-1.0, 1.0] - z0, z1, z2, z3 in [-1.0, 1.0] - zz01 in [-1.0, 1.0] - zz12 in [-1.0, 1.0] - zz23 in [-1.0, 1.0] - magnetization in [-1.0, 1.0] - entanglement_proxy in [0.0, 1.0] - -Constraints: - EQ weight=10: z0 - EQ weight=10: z1 - EQ weight=10: z2 - EQ weight=10: z3 - EQ weight=10: magnetization - (z0 + z1 + z2 + z3)/4.0 - EQ weight=10: zz01 - EQ weight=10: zz12 - EQ weight=10: zz23 - EQ weight=10: entanglement_proxy - (x0**2 + x1**2 + x2**2 + x3**2)/4.0 - GEQ: 1.0 - x0**2 - z0**2 - GEQ: 1.0 - x1**2 - z1**2 - GEQ: 1.0 - x2**2 - z2**2 - GEQ: 1.0 - x3**2 - z3**2 - -Anchor: magnetization = 0 (tolerance 0.01). -Anchor: zz01 = 0 (tolerance 0.01). -""", - -"Heisenberg XXZ: Spin-Half Chain Magnetization Plateaus": """\ +"Heisenberg XXZ: Spin-Half Chain Magnetization": """\ CONCRETE HYPOTHESIS: 1D XXZ Chain Magnetization Plateaus via Observables ========================================================================= Variables: @@ -1364,8 +1373,8 @@ Variables: corr_zz in [-1.0, 1.0] chirality in [-1.0, 1.0] energy_ps in [-3.0, 0.0] - suscept in [0.0, 5.0] - plateau in [0.0, 1.0] + suscept in [0.0, 5.0] + plateau in [0.0, 1.0] Constraints: EQ weight=10: energy_ps - (-corr_xx - 0.5*corr_zz - 0.3*mag_z) @@ -1384,6 +1393,165 @@ Anchor: chirality = 0 (tolerance 0.01). Anchor: energy_ps + 0.75 = 0 (tolerance 0.1). """, +# ─── SHOR'S ALGORITHM — LOG2-SPACE ──────────────────────────────────── + +"Shor RSA-1024: Log2-Space Resource Audit": """\ +CONCRETE HYPOTHESIS: Shor RSA-1024 Resources in Log2-Space +=========================================================== +ALL exponentially large quantities stored as log2 values. +n_bits = 512 (RSA-1024). All variables in [0, 60]. + +Variables: + n_bits in [510.0, 514.0] RSA key half-length + log2_modsq_tgates in [30.0, 55.0] log2(T-gate count for modular squaring) + log2_total_tgates in [35.0, 60.0] log2(total T-gates) + log2_phys_qubits in [15.0, 35.0] log2(physical qubit count) + log2_wall_time_s in [0.0, 30.0] log2(wall time in seconds) + code_dist in [15.0, 35.0] surface code distance (stays small) + n_log_qubits in [1020.0, 1030.0] logical qubit count (small, exact) + +Constraints: + EQ weight=10: n_log_qubits - (2*n_bits + 3) + (Exact: 2n+3 logical qubits) + EQ weight=10: log2_modsq_tgates - (2*log(n_bits)/log(2) + 9.0) + (log2(512 * n^2) = log2(512) + 2*log2(n) = 9 + 2*log2(n)) + EQ weight=10: log2_total_tgates - log2_modsq_tgates - log(n_bits)/log(2) - log(40)/log(2) + (log2(modsq * n * 40) = log2(modsq) + log2(n) + log2(40)) + EQ weight=10: code_dist - 23.0 + (Surface code distance for RSA-1024) + EQ weight=10: log2_phys_qubits - log(n_log_qubits)/log(2) - 2*log(code_dist)/log(2) - 1.0 + (log2(n_log * 2 * d^2) = log2(n_log) + 2*log2(d) + 1) + EQ weight=5: log2_wall_time_s - log2_total_tgates - log(code_dist)/log(2) + 6.0 - log(3.6e12)/log(2) + (wall_s = T_total * d * 1e-6 / 1e6_gates_per_s, convert to log2) + GEQ: log2_total_tgates - 40.0 + (Lower bound sanity: at least 2^40 gates) + +Anchor: n_log_qubits - 1027.0 = 0 (tolerance 2.0). +Observation: n_bits = 512. + +COLLAPSER: +From binding (all log2 values): + modsq_tgates = 2^log2_modsq_tgates = [compute] + total_tgates = 2^log2_total_tgates = [compute] + phys_qubits = 2^log2_phys_qubits = [compute] + wall_time_s = 2^log2_wall_time_s = [compute] seconds = [compute] hours + +State: "Factoring RSA-1024 (512-bit) requires: + [total_tgates] T-gates, [phys_qubits] physical qubits, [wall_time_s] seconds." +""", + +"Shor RSA-2048: Log2-Space Resource Certificate": """\ +CONCRETE HYPOTHESIS: Shor RSA-2048 Resources in Log2-Space +=========================================================== +ALL exponentially large quantities stored as log2 values. +n_bits = 2048. All variables in [0, 60]. + +Variables: + n_bits in [2046.0, 2050.0] RSA key half-length + log2_total_tgates in [45.0, 65.0] log2(total T-gates) + log2_phys_qubits in [20.0, 40.0] log2(physical qubit count) + log2_wall_time_s in [5.0, 40.0] log2(wall time in seconds) + code_dist in [25.0, 50.0] surface code distance + n_log_qubits in [4095.0, 4105.0] logical qubits + gate_time_ns in [100.0, 1000.0] gate time in nanoseconds + +Constraints: + EQ weight=10: n_log_qubits - (2*n_bits + 3) + EQ weight=10: log2_total_tgates - 3*log(n_bits)/log(2) - log(512)/log(2) + (log2(512 * n^3) = 9 + 3*log2(n)) + EQ weight=10: code_dist - 31.0 + EQ weight=10: log2_phys_qubits - log(n_log_qubits)/log(2) - 2*log(code_dist)/log(2) - 1.0 + EQ weight=5: log2_wall_time_s - log2_total_tgates - log(code_dist)/log(2) - log(1e9/gate_time_ns)/log(2) + (wall_s = T_total * d / (1e9/gate_ns) operations/second) + GEQ: gate_time_ns - 100.0 + LEQ: gate_time_ns - 1000.0 + GEQ: log2_total_tgates - 50.0 + +Anchor: n_log_qubits - 4099.0 = 0 (tolerance 2.0). +Observation: n_bits = 2048. + +COLLAPSER: +From binding: + total_tgates = 2^log2_total_tgates (express in scientific notation) + phys_qubits = 2^log2_phys_qubits + wall_time_s = 2^log2_wall_time_s + wall_time_years = wall_time_s / (3.156e7) + +State: "Factoring RSA-2048 requires: + [phys_qubits] physical qubits (current best: ~1000) + [total_tgates] T-gates + [wall_time_years] years of runtime" + +Compare to current hardware: gap_factor = phys_qubits / 1000. +""", + +"Grover SHA-256: Log2-Space Preimage Search": """\ +CONCRETE HYPOTHESIS: Grover SHA-256 Preimage in Log2-Space +=========================================================== +Variables: + output_bits in [254.0, 258.0] SHA-256 output bits + log2_grover_iters in [126.0, 130.0] log2(grover iterations) = output_bits/2 + log2_oracle_tgates in [10.0, 14.0] log2(T-gates per oracle call) + log2_total_tgates in [136.0, 145.0] log2(total T-gates) + log2_speedup in [126.0, 130.0] log2(quantum speedup vs classical) + code_dist in [25.0, 55.0] surface code distance + +Constraints: + EQ weight=10: log2_grover_iters - output_bits/2.0 + (Grover: sqrt(2^n) = 2^(n/2) iterations -> log2 = n/2) + EQ weight=10: log2_oracle_tgates - 11.0 + (SHA-256 oracle ~ 1500 Toffoli = 10500 T-gates ~ 2^13.4, use 2^11 simplified) + EQ weight=10: log2_total_tgates - log2_grover_iters - log2_oracle_tgates + (Total = iterations * oracle_cost, log2: add) + EQ weight=10: log2_speedup - log2_grover_iters + (Grover speedup = sqrt(N) = 2^(n/2) -> log2 = n/2) + EQ weight=5: code_dist - 33.0 + GEQ: log2_total_tgates - 135.0 + +Anchor: log2_grover_iters - 128.0 = 0 (tolerance 1.0). + +COLLAPSER: +From binding: + grover_iters = 2^log2_grover_iters = 2^128 = 3.4e38 quantum operations + total_tgates = 2^log2_total_tgates + +At 10^6 quantum operations/second: + time_s = 3.4e38 / 1e6 = 3.4e32 seconds = 1.1e25 years + +State: "AES-128 (Grover target N=2^128): + Quantum operations: 2^128 ≈ 3.4×10^38 + Time at 10^6 ops/s: ≈ 10^25 years — effectively infeasible. + AES-256: 2^256 operations — quadratically worse. + Recommendation: AES-128 is quantum-resistant for any foreseeable hardware." +""", + +"Kyber-1024 NTT: Post-Quantum Key Generation": """\ +CONCRETE HYPOTHESIS: CRYSTALS-Kyber-1024 NTT Operation Count +============================================================= +Variables: + n_poly in [254, 258] INT + k_param in [3, 5] INT + ntt_butterflies in [900, 1100] INT + ntt_mults in [900, 1100] INT + ntt_adds in [1800, 2200] INT + keygen_ntts in [10, 25] INT + total_mults in [5000, 30000] INT + total_adds in [10000, 60000] INT + +Constraints: + EQ weight=10: ntt_butterflies - n_poly*4 + EQ weight=10: ntt_mults - ntt_butterflies + EQ weight=10: ntt_adds - 2*ntt_butterflies + EQ weight=10: keygen_ntts - k_param*(k_param + 1) + EQ weight=10: total_mults - keygen_ntts*ntt_mults + EQ weight=10: total_adds - keygen_ntts*ntt_adds + +Anchor: total_mults - keygen_ntts*ntt_mults = 0 (tolerance 10.0). +Observation: k_param = 4. +""", + +# ─── ELLIPTIC CURVE TEMPLATES ───────────────────────────────────────── + "secp256k1 Optimal Window: MINIMIZE total operations": """\ CONCRETE HYPOTHESIS: secp256k1 wNAF Optimal Window via Integer Minimization ============================================================================ @@ -1411,26 +1579,38 @@ Constraints: Anchor: ops_per_bit - total_ops/256.0 = 0 (tolerance 0.01). """, -"secp256k1 GLV: Actual Scalar Decomposition k=31415926535": """\ -CONCRETE HYPOTHESIS: secp256k1 GLV Decomposition of Specific Scalar -==================================================================== +"secp256k1 GLV: Speedup via Endomorphism": """\ +CONCRETE HYPOTHESIS: secp256k1 GLV True Speedup via Joint Sparse Form +====================================================================== Variables: - k1 in [-100, 100] INT - k2 in [-100, 100] INT - m in [-10, 10] INT - k_target in [314, 314] INT - lamb in [77, 77] INT - n_mod in [1000, 1000] INT - cost in [0, 20000] + k_bits in [254, 258] INT + k1_bits in [126, 132] INT + k2_bits in [126, 132] INT + glv_doubles in [126, 132] INT + jsf_density in [0.50, 0.65] + glv_adds in [60, 100] + naive_doubles in [254, 258] INT + naive_adds in [120, 140] INT + naive_ops in [370, 400] INT + glv_ops in [180, 220] INT + speedup_num in [1.8, 2.1] Constraints: - EQ weight=10: k1 + k2*lamb - (k_target - m*n_mod) - EQ weight=10: cost - (k1*k1 + k2*k2) - -MINIMIZE: cost - -Anchor: k1 + k2*77 - (314 - m*1000) = 0 (tolerance 0.01). -Observation: k_target = 314. + EQ weight=10: k1_bits - 128 + EQ weight=10: k2_bits - 128 + EQ weight=10: glv_doubles - k1_bits + EQ weight=10: jsf_density - 5.0/9.0 + EQ weight=10: glv_adds - glv_doubles*jsf_density + EQ weight=10: naive_doubles - k_bits + EQ weight=10: naive_adds - k_bits/2 + EQ weight=10: naive_ops - naive_doubles - naive_adds + EQ weight=10: glv_ops - glv_doubles - glv_adds + EQ weight=10: speedup_num - naive_ops/glv_ops + GEQ: speedup_num - 1.85 + LEQ: speedup_num - 2.05 + +Anchor: speedup_num - 1.92 = 0 (tolerance 0.05). +Anchor: glv_doubles - 128 = 0 (tolerance 1.0). """, "secp256k1 Montgomery Ladder vs Double-and-Add": """\ @@ -1456,27 +1636,6 @@ Constraints: Anchor: montgomery_ops - 2*scalar_bits = 0 (tolerance 2.0). """, -"secp256k1 Schnorr Batch Verify: Pippenger Scaling": """\ -CONCRETE HYPOTHESIS: Schnorr Batch Verification via Pippenger -============================================================= -Variables: - n_sigs in [2, 10000] INT - naive_ops in [500, 3000000] - pippenger_adds in [100, 500000] - bucket_width in [4, 16] INT - n_buckets in [16, 65536] INT - batch_speedup in [1.0, 1000.0] - -Constraints: - EQ weight=10: naive_ops - n_sigs*768 - EQ weight=10: n_buckets - 2**bucket_width - EQ weight=10: pippenger_adds - 256*n_buckets + n_sigs*256/bucket_width - EQ weight=10: batch_speedup - naive_ops/pippenger_adds - GEQ: batch_speedup - 1.0 - -Anchor: batch_speedup - 1.0 >= 0 (mode=geq, tolerance 0.1). -""", - "secp256k1 Group Law Feasibility": """\ STRUCTURAL HYPOTHESIS: secp256k1 Elliptic Curve Group Law ========================================================== @@ -1497,109 +1656,51 @@ Constraints: Anchor: y3**2 - x3**3 - 7 = 0 (tolerance 0.001). """, -"1024-Qubit Shor: Concrete Full Gate Audit": """\ -CONCRETE HYPOTHESIS: Shor RSA-1024 at 1024 Logical Qubits -========================================================== -Variables: - n_bits in [510, 514] INT - n_log_qubits in [1020, 1030] INT - modsq_tgates in [1e7, 1e12] - modsq_cnots in [1e7, 1e12] - total_tgates in [1e10, 1e14] - code_dist in [15, 35] INT - phys_qubits in [1e5, 1e9] - wall_time_hrs in [0.1, 100000.0] - -Constraints: - EQ weight=10: n_log_qubits - (2*n_bits + 3) - EQ weight=10: modsq_tgates - 512*n_bits**2 - EQ weight=10: modsq_cnots - 256*n_bits**2 - EQ weight=10: total_tgates - modsq_tgates*n_bits*40 - EQ weight=10: code_dist - 23 - EQ weight=10: phys_qubits - n_log_qubits*2*code_dist**2 - EQ weight=5: wall_time_hrs - total_tgates*code_dist*1e-6/3600 - -Anchor: n_log_qubits - 1027 = 0 (tolerance 2.0). -Observation: n_bits = 512. -""", - -"2048-Qubit Shor: RSA-2048 Full Resource Certificate": """\ -CONCRETE HYPOTHESIS: Shor RSA-2048 Resource Certificate -======================================================== -Variables: - n_bits in [2046, 2050] INT - n_log_qubits in [4096, 4104] INT - total_tgates in [1e12, 1e17] - total_cnots in [1e12, 1e17] - code_dist in [25, 50] INT - phys_qubits in [1e6, 1e10] - wall_time_days in [1.0, 100000000.0] - gate_time_ns in [100.0, 2000.0] +"Shor Period-Finding: Optical Cavity Resonance in Log2-Space": """\ +CONCRETE HYPOTHESIS: Shor Period-Finding as Optical Cavity Resonance +===================================================================== +Model Shor's period-finding as optical cavity resonance in log2-space, +proving the Heisenberg compression advantage at 1,000,000 qubits. -Constraints: - EQ weight=10: n_log_qubits - (2*n_bits + 3) - EQ weight=10: total_tgates - 512*n_bits**3 - EQ weight=10: total_cnots - 256*n_bits**3 - EQ weight=10: code_dist - 31 - EQ weight=10: phys_qubits - n_log_qubits*2*code_dist**2 - EQ weight=5: wall_time_days - total_tgates*code_dist*gate_time_ns*1e-9/86400 - GEQ: gate_time_ns - 100 - LEQ: gate_time_ns - 1000 - -Anchor: n_log_qubits - 4099 = 0 (tolerance 2.0). -Observation: n_bits = 2048. -""", - -"Kyber-1024 NTT: Post-Quantum Key Generation Audit": """\ -CONCRETE HYPOTHESIS: CRYSTALS-Kyber-1024 NTT Operation Count -============================================================= Variables: - n_poly in [254, 258] INT - k_param in [3, 5] INT - ntt_butterflies in [900, 1100] INT - ntt_mults in [900, 1100] INT - ntt_adds in [1800, 2200] INT - keygen_ntts in [10, 25] INT - total_mults in [5000, 30000] INT - total_adds in [10000, 60000] INT + n_qubits in [2.0, 20.0] + log2_schrodinger in [2.0, 20.0] + log2_heisenberg in [2.0, 5.0] + log2_compression in [0.0, 18.0] + resonance_modes in [2, 100] INT + phase_error in [-0.01, 0.01] Constraints: - EQ weight=10: ntt_butterflies - n_poly*4 - EQ weight=10: ntt_mults - ntt_butterflies - EQ weight=10: ntt_adds - 2*ntt_butterflies - EQ weight=10: keygen_ntts - k_param*(k_param + 1) - EQ weight=10: total_mults - keygen_ntts*ntt_mults - EQ weight=10: total_adds - keygen_ntts*ntt_adds + EQ weight=10: log2_schrodinger - n_qubits + EQ weight=10: log2_heisenberg - log(2*n_qubits)/log(2) + EQ weight=10: log2_compression - log2_schrodinger + log2_heisenberg + EQ weight=10: phase_error + GEQ: log2_compression - 10.0 + GEQ: n_qubits - 2.0 -Anchor: total_mults - keygen_ntts*ntt_mults = 0 (tolerance 10.0). -Observation: k_param = 4. +Anchor: phase_error = 0 (tolerance 0.005). +Anchor: log2_compression >= 10 (mode=geq, tolerance 1.0). +Observation: n_qubits = 20. + +COLLAPSER: +At n_qubits=20 (proxy for 2^20 = 1,048,576 qubit system): + log2_schrodinger = 20 -> state vector = 2^20 amplitudes + log2_heisenberg = log2(2*20) = log2(40) ≈ 5.32 -> 40 variables + log2_compression = 20 - 5.32 = 14.68 -> 2^14.68 ≈ 26,000x compression + +For actual N=1,000,000 qubit system (not proxy): + log2(1,000,000) = 19.93 + log2_heisenberg = log2(2*1,000,000) = log2(2,000,000) = 20.93 + log2_compression = 19.93 - 20.93 = -1.0 + +IMPORTANT: At N=1M qubits tracking ALL observables (2N), there's no compression. +Compression only exists when tracking O(log N) or O(1) observables (like GHZ with 4). +State this explicitly: "The Heisenberg advantage is real only when +the observable set is sparse (e.g., nearest-neighbor correlators only). +For the full observable set, both pictures scale equally." """, -"Grover Oracle: SHA256 Preimage Circuit Cost": """\ -CONCRETE HYPOTHESIS: Grover SHA-256 Preimage Circuit -===================================================== -Variables: - output_bits in [254, 258] INT - oracle_toffoli in [1400, 1600] INT - oracle_cnots in [2800, 3200] INT - grover_iters in [125, 130] - total_log2_ops in [128, 132] - toffoli_to_t in [6, 8] INT - log2_tgates in [135, 145] - code_dist in [25, 55] INT - -Constraints: - EQ weight=10: oracle_toffoli - 1500 - EQ weight=10: oracle_cnots - 3000 - EQ weight=10: grover_iters - output_bits/2 - EQ weight=10: total_log2_ops - grover_iters + 1 - EQ weight=10: toffoli_to_t - 7 - EQ weight=10: log2_tgates - total_log2_ops + 10 - EQ weight=5: code_dist - 33 - GEQ: log2_tgates - 135 - -Anchor: grover_iters - 128 = 0 (tolerance 1.0). -""", +# ─── LATTICE CRYPTO ─────────────────────────────────────────────────── "LWE Lattice Crypto: Short Vector Feasibility": """\ STRUCTURAL HYPOTHESIS: Learning With Errors (n=4 proxy) @@ -1652,11 +1753,18 @@ Constraints: Anchor: zz01 - 1 = 0 (tolerance 0.01). Anchor: xx01 - 1 = 0 (tolerance 0.01). -""" +""", + } # ══════════════════════════════════════════════════════════════════════ -# SECTION 7: MASKED DEDUCTION — ORIGINAL SPACE ADAM +# SECTION 7: MASKED DEDUCTION — LOG-SPACE ADAM ← NEW IN 27.7 +# +# For variables where hi/lo > LOG_SPACE_THRESHOLD and lo > 0: +# - Store parameter as log10(x) internally +# - Pass exp10(param) = 10^param to tensor_energy +# - Adam gradient steps are in log space (equal fractional steps) +# - This prevents 10^12 gradient magnitudes from dwarfing 10^0 gradients # ══════════════════════════════════════════════════════════════════════ @dataclass class L9Certificate: @@ -1674,8 +1782,8 @@ def _batched_deduce_and_evaluate(problem, hyps: List['Hypothesis']) -> List[Tupl try: ce=problem.scalar_energy(hyp.binding) dom_vars=list(hyp.pinned_vars.keys())[:3] - results[i]=(hyp.binding, ce, dom_vars, "algebraic") - except: results[i]=(hyp.binding, float('inf'), [], "algebraic_error") + results[i]=(hyp.binding,ce,dom_vars,"algebraic") + except: results[i]=(hyp.binding,float('inf'),[],"algebraic_error") if not solve_indices: return [r for r in results if r is not None] @@ -1683,53 +1791,89 @@ def _batched_deduce_and_evaluate(problem, hyps: List['Hypothesis']) -> List[Tupl adam_hyps=[hyps[i] for i in solve_indices] B=len(adam_hyps); V=len(problem.variables) - x_data, mask_data, target_data = [], [], [] + # ── BUILD LOG-SPACE METADATA ─────────────────────────────���──────── + # For each variable: is_log=True means we optimize log10(x), + # and must convert back to x before energy evaluation. + log_mask = [] # bool per variable + log_lo = [] # lo in param space (log10 if log_mask, else original) + log_hi = [] # hi in param space + for v in problem.variables: + lo,hi=_c15(problem.bounds[v][0]),_c15(problem.bounds[v][1]) + if v in problem.log_space_vars and lo>0: + log_mask.append(True) + log_lo.append(math.log10(max(lo,1e-30))) + log_hi.append(math.log10(max(hi,1e-30))) + else: + log_mask.append(False) + log_lo.append(lo) + log_hi.append(hi) + + log_mask_t = torch.tensor(log_mask, device=DEVICE, dtype=torch.bool) + lo_param_t = torch.tensor(log_lo, device=DEVICE, dtype=torch.float32) + hi_param_t = torch.tensor(log_hi, device=DEVICE, dtype=torch.float32) + + def _param_to_orig(P: torch.Tensor) -> torch.Tensor: + """Convert parameter tensor (log or linear) to original-space tensor.""" + orig = P.clone() + if log_mask_t.any(): + orig[:, log_mask_t] = torch.pow(10.0, P[:, log_mask_t]) + return orig + + def _orig_to_param(x_val: float, j: int) -> float: + """Convert a single original-space value to parameter space.""" + if log_mask[j] and x_val > 0: + return math.log10(max(x_val, 1e-30)) + return x_val + + # Build initial parameter matrices + x_data_p, mask_data, target_data_p = [], [], [] for hyp in adam_hyps: xr, mr, tr = [], [], [] - active_vars=problem.get_markov_blanket(set(hyp.pinned_vars.keys()), depth=2) + active_vars=problem.get_markov_blanket(set(hyp.pinned_vars.keys()),depth=2) for j,v in enumerate(problem.variables): lo,hi=_c15(problem.bounds[v][0]),_c15(problem.bounds[v][1]) if v in hyp.pinned_vars: - val=_c15(hyp.pinned_vars[v]) - xr.append(val); mr.append(0.0); tr.append(val) + orig_val=_c15(hyp.pinned_vars[v]) + param_val=_orig_to_param(orig_val,j) + xr.append(param_val); mr.append(0.0); tr.append(param_val) else: - val=_c15(hyp.binding.get(v,(lo+hi)/2)) + orig_val=_c15(hyp.binding.get(v,(lo+hi)/2)) + param_val=_orig_to_param(orig_val,j) is_active=(v in active_vars) or (len(hyp.pinned_vars)==0) - xr.append(val); mr.append(1.0 if is_active else 0.0); tr.append(0.0) - x_data.append(xr); mask_data.append(mr); target_data.append(tr) + xr.append(param_val); mr.append(1.0 if is_active else 0.0); tr.append(0.0) + x_data_p.append(xr); mask_data.append(mr); target_data_p.append(tr) - X = torch.tensor(x_data, device=DEVICE, dtype=torch.float32, requires_grad=True) + P = torch.tensor(x_data_p, device=DEVICE, dtype=torch.float32, requires_grad=True) mask = torch.tensor(mask_data, device=DEVICE, dtype=torch.float32) - target = torch.tensor(target_data, device=DEVICE, dtype=torch.float32) + target = torch.tensor(target_data_p, device=DEVICE, dtype=torch.float32) - optimizer = torch.optim.Adam([X], lr=ADAM_LEARNING_RATE) + optimizer = torch.optim.Adam([P], lr=ADAM_LEARNING_RATE) for step in range(DEDUCE_ADAM_STEPS): optimizer.zero_grad() - step_ratio = min(1.0, step / (DEDUCE_ADAM_STEPS * 0.8)) - - ce = problem.tensor_energy(X, step_ratio, is_optimizing=True) - if isinstance(ce, torch.Tensor) and (ce < SOLVE_THRESHOLD).all() and step_ratio == 1.0: + step_ratio = min(1.0, step/(DEDUCE_ADAM_STEPS*0.8)) + X_orig = _param_to_orig(P) # convert to original space + ce = problem.tensor_energy(X_orig, step_ratio, is_optimizing=True) + if isinstance(ce,torch.Tensor) and (ce List[Tupl dom_vars=[problem.variables[idx] for idx in topk_idx_np[b_idx] if float(grads_np[b_idx,idx])>1e-4] n_dom=len(dom_vars) tension_class=("isolated" if n_dom<=1 else "relational" if n_dom==2 else "systemic") - results[orig_idx]=(final_b, float(ce_vals[b_idx]), dom_vars, tension_class) + results[orig_idx]=(final_b,float(ce_vals[b_idx]),dom_vars,tension_class) return [r for r in results if r is not None] def _mprt_sample(problem, work_box, N): var_list=problem.variables; V=len(var_list) - lo_t=torch.tensor([_c15(max(problem.bounds.get(v,(-10.0,10.0))[0], work_box[v].lo if v in work_box else problem.bounds.get(v,(-10,10))[0])) for v in var_list], device=DEVICE, dtype=torch.float32) - hi_t=torch.tensor([_c15(min(problem.bounds.get(v,(-10.0,10.0))[1], work_box[v].hi if v in work_box else problem.bounds.get(v,(-10,10))[1])) for v in var_list], device=DEVICE, dtype=torch.float32) + lo_t=torch.tensor([_c15(max(problem.bounds.get(v,(-10.0,10.0))[0], + work_box[v].lo if v in work_box else problem.bounds.get(v,(-10,10))[0])) + for v in var_list], device=DEVICE, dtype=torch.float32) + hi_t=torch.tensor([_c15(min(problem.bounds.get(v,(-10.0,10.0))[1], + work_box[v].hi if v in work_box else problem.bounds.get(v,(-10,10))[1])) + for v in var_list], device=DEVICE, dtype=torch.float32) for i in range(V): if lo_t[i]>=hi_t[i]: m=(lo_t[i]+hi_t[i])/2; lo_t[i]=m-1e-6; hi_t[i]=m+1e-6 - X=lo_t.unsqueeze(0)+(hi_t-lo_t).unsqueeze(0)*torch.rand((N,V), device=DEVICE) - ce_batch=problem.tensor_energy(X,1.0,is_optimizing=False).view(-1); best_idx=torch.argmin(ce_batch).item() + # Use log-uniform sampling for log-space variables + rand_base = torch.rand((N,V), device=DEVICE) + lsv_indices = [problem.var_idx[v] for v in problem.log_space_vars if v in problem.var_idx] + for idx in lsv_indices: + lo_v, hi_v = lo_t[idx].item(), hi_t[idx].item() + if lo_v > 0 and hi_v > lo_v: + log_lo = math.log10(max(lo_v, 1e-30)) + log_hi = math.log10(max(hi_v, 1e-30)) + rand_base[:,idx] = torch.pow(10.0, torch.rand(N, device=DEVICE)*(log_hi-log_lo)+log_lo) / hi_v + X = lo_t.unsqueeze(0) + (hi_t-lo_t).unsqueeze(0) * rand_base + ce_batch=problem.tensor_energy(X,1.0,is_optimizing=False).view(-1) + best_idx=torch.argmin(ce_batch).item() return {v:float(X[best_idx,i].item()) for i,v in enumerate(var_list)}, ce_batch[best_idx].item() # ══════════════════════════════════════════════════════════════════════ @@ -1805,11 +1963,11 @@ class AxiomRay: baton:Optional[Baton]=None; ce_prior:float=float('inf') @property def name(self) -> str: return "→".join(AXIOM_ABBR.get(a,a[:3]) for a in self.sequence) - def extend(self, axiom, rtype, new_prior=float('inf')): + def extend(self,axiom,rtype,new_prior=float('inf')): new_seq=self.sequence+[axiom] if sequence_valid(new_seq): - return AxiomRay(sequence=new_seq, ray_id=f"{self.ray_id}+{AXIOM_ABBR.get(axiom,'?')}", - ray_type=rtype, depth=self.depth+1, parent_id=self.ray_id, ce_prior=new_prior) + return AxiomRay(sequence=new_seq,ray_id=f"{self.ray_id}+{AXIOM_ABBR.get(axiom,'?')}", + ray_type=rtype,depth=self.depth+1,parent_id=self.ray_id,ce_prior=new_prior) return None @dataclass @@ -1830,10 +1988,10 @@ class StructuralModel: # ══════════════════════════════════════════════════════════════════════ # SECTION 10: HYPOTHESIS CONSTRUCTORS # ══════════════════════════════════════════════════════════════════════ -def _make_hyp(hid, binding, h_type, claim, derivation, pinned, free, conf, is_fd=False): - return Hypothesis(hid=hid, binding=binding, h_type=h_type, claim=claim, - derivation=derivation, pinned_vars=pinned, free_vars=free, - confidence=conf, is_fully_determined=is_fd) +def _make_hyp(hid,binding,h_type,claim,derivation,pinned,free,conf,is_fd=False): + return Hypothesis(hid=hid,binding=binding,h_type=h_type,claim=claim, + derivation=derivation,pinned_vars=pinned,free_vars=free, + confidence=conf,is_fully_determined=is_fd) def _hyp_continuous(p,bt,a,m): return [_make_hyp("cnt",bt.binding,"continuous","Manifold",[],{},p.variables,0.45)] def _hyp_discrete(p,bt,a,m): @@ -1858,17 +2016,18 @@ def _hyp_quadratic(p,bt,a,m): def _hyp_bilinear(p,bt,a,m): hyps=[]; b=dict(bt.binding) for vi,vj in p.bilinear_pairs: - lo_i,hi_i=p.bounds.get(vi,(0,10)); lo_j,hi_j=p.bounds.get(vj,(0,10)); product=abs(b.get(vi,1)*b.get(vj,1)) + lo_i,hi_i=p.bounds.get(vi,(0,10)); lo_j,hi_j=p.bounds.get(vj,(0,10)) + product=abs(b.get(vi,1)*b.get(vj,1)) if product<=0: continue gm=math.sqrt(product) if lo_i<=gm<=hi_i and lo_j<=gm<=hi_j: nb=dict(b); nb[vi]=nb[vj]=gm - hyps.append(_make_hyp(f"bil_eq_{vi}_{vj}",nb,"bilinear",f"GeoMean({vi}={vj}={gm:.3f})",["bilinear"],{vi:gm,vj:gm},[v for v in p.variables if v not in [vi,vj]],0.70)) + hyps.append(_make_hyp(f"bil_eq_{vi}_{vj}",nb,"bilinear",f"GeoMean",["bilinear"],{vi:gm,vj:gm},[v for v in p.variables if v not in [vi,vj]],0.70)) for ratio in [0.4,0.7071,0.9]: vs=gm*ratio; vl=product/(vs+1e-9) if lo_i<=vs<=hi_i and lo_j<=vl<=hi_j and vs{vj})",["symmetric"],{vi:nb[vi],vj:nb[vj]},[v for v in p.variables if v not in [vi,vj]],0.60)) + hyps.append(_make_hyp(f"sym_{vi}_{vj}",nb,"symmetric",f"Swap",["symmetric"],{vi:nb[vi],vj:nb[vj]},[v for v in p.variables if v not in [vi,vj]],0.60)) avg=(bvi+bvj)/2 if lo_i<=avg<=hi_i and lo_j<=avg<=hi_j: nb2=dict(b); nb2[vi]=avg; nb2[vj]=avg - hyps.append(_make_hyp(f"sym_avg_{vi}_{vj}",nb2,"symmetric",f"Average({vi}={vj}={avg:.4f})",["symmetric"],{vi:avg,vj:avg},[v for v in p.variables if v not in [vi,vj]],0.55)) + hyps.append(_make_hyp(f"sym_avg_{vi}_{vj}",nb2,"symmetric",f"Average",["symmetric"],{vi:avg,vj:avg},[v for v in p.variables if v not in [vi,vj]],0.55)) return hyps[:10] def _hyp_ordered(p,bt,a,m): return [_make_hyp("ord",bt.binding,"ordered","OrderBal",[],{},p.variables,0.67)] def _hyp_monotone(p,bt,a,m): return [_make_hyp("mon",bt.binding,"monotone","MonoPath",[],{},p.variables,0.67)] @@ -1937,13 +2101,15 @@ def _hyp_conserved(p,bt,a,m): return [_make_hyp("csv",bt.binding,"conserved","Co def _hyp_mutable(p,bt,a,m): b=dict(bt.binding); pinned={} if bt.l9 and bt.l9.dominant_vars: - v=bt.l9.dominant_vars[0]; lo,hi=p.bounds.get(v,(-10,10)); b[v]=max(lo,min(hi,b.get(v,0)+random.gauss(0,(hi-lo)*0.05))); pinned={v:b[v]} + v=bt.l9.dominant_vars[0]; lo,hi=p.bounds.get(v,(-10,10)) + b[v]=max(lo,min(hi,b.get(v,0)+random.gauss(0,(hi-lo)*0.05))); pinned={v:b[v]} return [_make_hyp("mut",b,"mutable","Perturb",[],pinned,p.variables,0.40)] def _hyp_network(p,bt,a,m): return [_make_hyp("net",bt.binding,"network","HubProp",[],{},p.variables,0.65)] def _hyp_equilibrium(p,bt,a,m): return [_make_hyp("eql",bt.binding,"equilibrium","GradBal",[],{},p.variables,0.72)] def _hyp_superposition(p,bt,a,m): if a and len(a)>0: - other=random.choice(a); lam=0.5; nb={v:lam*bt.binding.get(v,0)+(1-lam)*other.binding.get(v,0) for v in p.variables} + other=random.choice(a); lam=0.5 + nb={v:lam*bt.binding.get(v,0)+(1-lam)*other.binding.get(v,0) for v in p.variables} return [_make_hyp("sup",nb,"superposition","Superpose",[],{},p.variables,0.58)] return [] def _hyp_locality(p,bt,a,m): return [_make_hyp("loc",bt.binding,"locality","LocalFirst",[],{},p.variables,0.72)] @@ -1951,7 +2117,7 @@ def _hyp_extremal(p,bt,a,m): hyps=[]; b=dict(bt.binding) if bt.l9 and bt.l9.dominant_vars: v=bt.l9.dominant_vars[0]; lo,hi=p.bounds.get(v,(0,1)) - for val in [lo,hi]: nb=dict(b); nb[v]=val; hyps.append(_make_hyp(f"ext_{v}_{val:.3f}",nb,"extremal",f"PinBound({v}={val:.3f})",[],{v:val},p.variables,0.65)) + for val in [lo,hi]: nb=dict(b); nb[v]=val; hyps.append(_make_hyp(f"ext_{v}_{val:.3f}",nb,"extremal",f"PinBound",[],{v:val},p.variables,0.65)) return hyps def _hyp_entropy(p,bt,a,m): return [_make_hyp("ent",{v:random.uniform(*p.bounds[v]) for v in p.variables},"entropy","MaxEnt",[],{},p.variables,0.48)] def _hyp_injective(p,bt,a,m): return [_make_hyp("inj",bt.binding,"injective","Distinct",[],{},p.variables,0.50)] @@ -1977,24 +2143,33 @@ def _hyp_negation(p,bt,a,m): def _hyp_composite(p,bt,a,m): return [_make_hyp("cmp",bt.binding,"composite","Enz",[],{},p.variables,0.90)] def _hyp_holism(p,bt,a,m): return [_make_hyp("hol",bt.binding,"holism","Global",[],{},p.variables,0.73)] def _hyp_parsimony(p,bt,a,m): - b=dict(bt.binding); nb={}; max_val=max((abs(v) for v in b.values() if math.isfinite(v)), default=1.0) + b=dict(bt.binding); nb={} + max_val=max((abs(v) for v in b.values() if math.isfinite(v)),default=1.0) for v in p.variables: val=b[v]; lo,hi=p.bounds[v] if not math.isfinite(val): nb[v]=0.0; continue if abs(val)<0.1*max_val and lo<=0.0<=hi: nb[v]=0.0 else: - candidates=[round(val*m)/m for m in [1,2,4] if lo<=round(val*m)/m<=hi]; nb[v]=min(candidates, key=lambda c:abs(c-val)) if candidates else val + candidates=[round(val*m)/m for m in [1,2,4] if lo<=round(val*m)/m<=hi] + nb[v]=min(candidates,key=lambda c:abs(c-val)) if candidates else val return [_make_hyp("par",nb,"parsimony","Occam",[],{},p.variables,0.58)] def _hyp_duality(p,bt,a,m): return [_make_hyp("dua",bt.binding,"duality","Tight",[],{},p.variables,0.68)] AXIOM_CONSTRUCTORS={ - Axiom.CONTINUOUS:_hyp_continuous, Axiom.DISCRETE:_hyp_discrete, Axiom.QUADRATIC:_hyp_quadratic, Axiom.BILINEAR:_hyp_bilinear, - Axiom.METRIC:_hyp_metric, Axiom.SYMMETRIC:_hyp_symmetric, Axiom.ORDERED:_hyp_ordered, Axiom.MONOTONE:_hyp_monotone, - Axiom.CONVEX:_hyp_convex, Axiom.MONOTONE_PRODUCT:_hyp_monotone_product, Axiom.CONSERVED:_hyp_conserved, Axiom.MUTABLE:_hyp_mutable, - Axiom.NETWORK:_hyp_network, Axiom.EQUILIBRIUM:_hyp_equilibrium, Axiom.SUPERPOSITION:_hyp_superposition, Axiom.LOCALITY:_hyp_locality, - Axiom.EXTREMAL:_hyp_extremal, Axiom.ENTROPY:_hyp_entropy, Axiom.INJECTIVE:_hyp_injective, Axiom.SURJECTIVE:_hyp_surjective, - Axiom.TRANSITIVE:_hyp_transitive, Axiom.ATOMIC:_hyp_atomic, Axiom.IMPLICATION:_hyp_implication, Axiom.NEGATION:_hyp_negation, - Axiom.COMPOSITE:_hyp_composite, Axiom.HOLISM:_hyp_holism, Axiom.PARSIMONY:_hyp_parsimony, Axiom.DUALITY:_hyp_duality, + Axiom.CONTINUOUS:_hyp_continuous, Axiom.DISCRETE:_hyp_discrete, + Axiom.QUADRATIC:_hyp_quadratic, Axiom.BILINEAR:_hyp_bilinear, + Axiom.METRIC:_hyp_metric, Axiom.SYMMETRIC:_hyp_symmetric, + Axiom.ORDERED:_hyp_ordered, Axiom.MONOTONE:_hyp_monotone, + Axiom.CONVEX:_hyp_convex, Axiom.MONOTONE_PRODUCT:_hyp_monotone_product, + Axiom.CONSERVED:_hyp_conserved, Axiom.MUTABLE:_hyp_mutable, + Axiom.NETWORK:_hyp_network, Axiom.EQUILIBRIUM:_hyp_equilibrium, + Axiom.SUPERPOSITION:_hyp_superposition, Axiom.LOCALITY:_hyp_locality, + Axiom.EXTREMAL:_hyp_extremal, Axiom.ENTROPY:_hyp_entropy, + Axiom.INJECTIVE:_hyp_injective, Axiom.SURJECTIVE:_hyp_surjective, + Axiom.TRANSITIVE:_hyp_transitive, Axiom.ATOMIC:_hyp_atomic, + Axiom.IMPLICATION:_hyp_implication, Axiom.NEGATION:_hyp_negation, + Axiom.COMPOSITE:_hyp_composite, Axiom.HOLISM:_hyp_holism, + Axiom.PARSIMONY:_hyp_parsimony, Axiom.DUALITY:_hyp_duality, } # ══════════════════════════════════════════════════════════════════════ @@ -2004,11 +2179,11 @@ class UCB1BanditSeeder: def __init__(self): self.stats={a:{"tries":0,"reward":0.0} for a in ALL_AXIOMS}; self.total_tries=0 - def record_reward(self, axiom, ce_before, ce_after): + def record_reward(self,axiom,ce_before,ce_after): reward=max(0.0,ce_before-ce_after) self.stats[axiom]["tries"]+=1; self.stats[axiom]["reward"]+=reward; self.total_tries+=1 - def intelligent_branch(self, ray, out_baton, remaining_axioms, branch_width, sketch): + def intelligent_branch(self,ray,out_baton,remaining_axioms,branch_width,sketch): dom_vars=out_baton.l9.dominant_vars if out_baton.l9 else [] tension_class=out_baton.l9.tension_class if out_baton.l9 else "unknown" n_dom=len(dom_vars) @@ -2030,14 +2205,14 @@ class UCB1BanditSeeder: exploration=math.sqrt(math.log(self.total_tries+1)/tries) ucb=avg_reward+0.5*exploration scored.append((w_allos*w_sketch*(1.0+ucb),ax)) - scored.sort(key=lambda x:x[0]*random.random(), reverse=True) + scored.sort(key=lambda x:x[0]*random.random(),reverse=True) children=[] for _,axiom in scored[:effective_width]: child=ray.extend(axiom,"branch",new_prior=out_baton.ce) if child: child.baton=out_baton; children.append(child) return children - def sketch_weighted_seeds(self, sketch, init_ce): + def sketch_weighted_seeds(self,sketch,init_ce): affinities=sketch.axiom_affinities seeds_scored=sorted([(affinities.get(a,1.0),i,a) for i,a in enumerate(ALL_AXIOMS)],key=lambda x:-x[0]) return [AxiomRay([a],f"S{i}","seed",ce_prior=init_ce) for _,i,a in seeds_scored] @@ -2045,7 +2220,7 @@ class UCB1BanditSeeder: # ══════════════════════════════════════════════════════════════════════ # SECTION 12: VERIFY LAYER # ══════════════════════════════════════════════════════════════════════ -def _verify(binding, base_problem, anchors): +def _verify(binding,base_problem,anchors): g1_ce=base_problem.scalar_energy(binding); g1_pass=g1_ce0: _update_state(phase="FEASIBILITY_CHECK") infeas_report=run_infeasibility_scan(base_problem,templates) if infeas_report and infeas_report.is_infeasible: - _add_log(f"🚫 STRUCTURALLY INFEASIBLE (proved algebraically)") + _add_log(f"STRUCTURALLY INFEASIBLE (proved algebraically)") _add_log(f" {infeas_report.infeasibility_reason[:100]}") _update_state(infeasibility_report=infeas_report.infeasibility_reason) best_binding={}; best_ce=float('inf') @@ -2123,10 +2300,10 @@ class SequenceRayTracer: g1p,g2p,inv_res,_=_verify(best_binding,base_problem,axl_def.anchors) if g1p and g2p and best_ce 2000) - - if improved or (g1_pass and g2_pass) or passed_pruning or force_ui_scout: + force_ui=(total_fired-last_ui_update_fired>2000) + if improved or (g1_pass and g2_pass) or passed_pruning or force_ui: with STATE_LOCK: - display_name = f"[SCOUT] {ray.name}" if force_ui_scout else ray.name GLOBAL_SOLVE_STATE["recent_traces"].append(HypothesisTrace( - hid=ray.ray_id,round_idx=total_fired,ray_name=display_name, - ray_type="scout" if force_ui_scout else ray.ray_type, - ce_before=parent_ce,ce_after=final_ce, - survived=(g1_pass and g2_pass),elapsed_ms=0.0, - g1_pass=g1_pass,g2_pass=g2_pass,binding=final_b, + hid=ray.ray_id,round_idx=total_fired, + ray_name=f"[SCOUT] {ray.name}" if force_ui else ray.name, + ray_type="scout" if force_ui else ray.ray_type, + ce_before=parent_ce,ce_after=final_ce,survived=(g1_pass and g2_pass), + elapsed_ms=0.0,g1_pass=g1_pass,g2_pass=g2_pass,binding=final_b, invariant_results=inv_results,tension_class=tension_class,depth=ray.depth)) - if force_ui_scout: last_ui_update_fired = total_fired - + if force_ui: last_ui_update_fired=total_fired out_baton=Baton(binding=final_b,ce=final_ce,ray_id=ray.ray_id, l9=L9Certificate(final_ce,dom_vars,[],tension_class)) - - # AUTO-RATCHETING REGISTRY FIX: Scales with best_ce so search never stalls - dynamic_baton_thresh = max(BATON_REGISTRY_THRESHOLD, best_ce * 1.2) - if final_ce < dynamic_baton_thresh: - baton_registry[ray.ray_id] = out_baton - if len(baton_registry) > BATON_REGISTRY_MAX: - worst_key = max(baton_registry, key=lambda k: baton_registry[k].ce) + dynamic_thresh=max(BATON_REGISTRY_THRESHOLD,best_ce*1.2) + if final_ceBATON_REGISTRY_MAX: + worst_key=max(baton_registry,key=lambda k:baton_registry[k].ce) del baton_registry[worst_key] - if improved: best_ce=final_ce; best_binding=dict(final_b) model.best_ray=ray.name; best_ray_name=ray.name - if g1_pass and g2_pass and final_ce {new_val}...") + _add_log(f"Empirical Probe: {scale_var}: {old_val} -> {new_val}...") new_axl=copy.deepcopy(axl_def); new_axl.observations[scale_var]=new_val for v in new_axl.variables: if v["name"]==scale_var: v["lo"]=new_val; v["hi"]=new_val @@ -2249,9 +2416,9 @@ def empirical_scaling_probe(axl_def, base_prob, binding, best_ray): if v_old>1e-3 and v_new>1e-3 and math.isfinite(v_old) and math.isfinite(v_new): try: alpha=math.log(v_new/v_old)/math.log(2.0); scaling_exponents[v]=safe_round(alpha,3) except: pass - _add_log(f" ✓ Probe CE={new_ce:.4f}. {len(scaling_exponents)} scaling laws.") + _add_log(f" Probe CE={new_ce:.4f}. {len(scaling_exponents)} scaling laws.") return scaling_exponents - except Exception as e: _add_log(f" ⚠ Probe failed: {e}"); return {} + except Exception as e: _add_log(f" Probe failed: {e}"); return {} # ══════════════════════════════════════════════════════════════════════ # SECTION 14: LLM BRIDGE @@ -2266,22 +2433,23 @@ OUTPUT SCHEMA (JSON only, no markdown): "observations": {"variable_name": number} } RULES: USE ** FOR EXPONENTS. NEVER USE ^. No =, >=, <= inside expressions. -EQ/GEQ/LEQ are expression's relation to zero. Output ONLY the JSON object.""" +EQ/GEQ/LEQ are expression's relation to zero. Output ONLY the JSON object. +IMPORTANT: For variables that represent exponentially large quantities (e.g. number of gates, +qubit counts >10000), encode them in LOG2 SPACE. Name them log2_X and set bounds [0, 60]. +Constraints become subtractions in log2 space. This prevents numerical overflow.""" + +COLLAPSER_SYSTEM_PROMPT = """You are the Grounded Hypothesis Engine for Practicality 27.7. -COLLAPSER_SYSTEM_PROMPT = """You are the Grounded Hypothesis Engine for Practicality 27.6. +Check infeasibility_report first. If non-empty: proved infeasible algebraically. -Check infeasibility_report first. If non-empty: the system proved infeasibility via -algebraic propagation before firing any rays. Output: - ## STATUS: STRUCTURALLY INFEASIBLE (PROVED ALGEBRAICALLY) - Which constraint failed, by how much, what formula change makes it feasible. +For LOG2-SPACE templates: variables named log2_X represent log2 of actual quantities. +Convert back: actual_X = 2^log2_X. Express final answers in both log2 and actual form. -For Heisenberg picture quantum templates: the binding contains Pauli expectation values. -Compute observables from these directly. State explicitly: - - How many variables track the system (should be O(n) not O(2^n)) - - What the compression ratio is vs Schrodinger picture at the given scale - - Whether the phase assignment (ferromagnetic/paramagnetic, gapped/gapless) matches binding +For Heisenberg quantum templates: state compression ratio explicitly. +Note the important caveat: Heisenberg compression only applies to SPARSE observables +(e.g., nearest-neighbor correlators). Full observable sets scale equally in both pictures. -If minimize_result is provided in the JSON, clearly state the optimal value found. +If minimize_result is provided: clearly state the optimal value found. For ALL templates: output concrete numbers, not qualitative statements. OUTPUT STRICT JSON: @@ -2290,12 +2458,12 @@ OUTPUT STRICT JSON: "hypothesis_markdown": "## Your full deduction here in markdown" }""" -def encode_problem_to_axl(problem_text, api_key) -> AXLProblemDef: +def encode_problem_to_axl(problem_text,api_key) -> AXLProblemDef: if not api_key: raise ValueError("Gemini API Key missing.") client=genai.Client(api_key=api_key) config=types.GenerateContentConfig( system_instruction=[types.Part.from_text(text=ENCODER_SYSTEM_PROMPT)], - response_mime_type="application/json", temperature=0.1) + response_mime_type="application/json",temperature=0.1) resp=client.models.generate_content( model=GEMINI_MODEL, contents=[types.Content(role="user",parts=[types.Part.from_text(text=problem_text)])], @@ -2316,15 +2484,15 @@ def encode_problem_to_axl(problem_text, api_key) -> AXLProblemDef: scopes=d.get("scopes",[]),anchors=anchors, observations=d.get("observations",{})) -def collapse_solution(problem_text, axl_def, psl_text, binding, g1_pass, g2_pass, - inv_results, best_ray, total_fired, sketch_notes, - sympy_derivation, proxy_component_isos, scaling_exponents, - raw_equations, propagation_log, infeasibility_report, - minimize_var, minimize_val, api_key) -> str: +def collapse_solution(problem_text,axl_def,psl_text,binding,g1_pass,g2_pass, + inv_results,best_ray,total_fired,sketch_notes, + sympy_derivation,proxy_component_isos,scaling_exponents, + raw_equations,propagation_log,infeasibility_report, + minimize_var,minimize_val,api_key) -> str: if not api_key: return "ERROR: API Key required." client=genai.Client(api_key=api_key) payload={ - "original_problem":problem_text, "solved":g1_pass and g2_pass, + "original_problem":problem_text,"solved":g1_pass and g2_pass, "raw_binding":{k:safe_round(v,8) for k,v in binding.items()}, "infeasibility_report":infeasibility_report or "", "empirical_scaling_exponents":scaling_exponents, @@ -2338,7 +2506,6 @@ def collapse_solution(problem_text, axl_def, psl_text, binding, g1_pass, g2_pass } if minimize_var and minimize_val is not None: payload["minimize_result"]={"variable":minimize_var,"optimal_value":safe_round(minimize_val,8)} - config=types.GenerateContentConfig( thinking_config=types.ThinkingConfig(thinking_level="HIGH"), system_instruction=[types.Part.from_text(text=COLLAPSER_SYSTEM_PROMPT)], @@ -2357,11 +2524,11 @@ def collapse_solution(problem_text, axl_def, psl_text, binding, g1_pass, g2_pass markdown=data.get("hypothesis_markdown","No markdown generated.") evals=data.get("scaled_formulas",{}) if evals: - markdown+="\n\n## 🧮 SYMBOLIC EVALUATIONS (Python-verified)\n" + markdown+="\n\n## SYMBOLIC EVALUATIONS (Python-verified)\n" sympy_ns={v:sp.Symbol(v) for v in binding.keys()} for name,expr in evals.items(): try: - parsed=parse_expr(expr, local_dict=sympy_ns) + parsed=parse_expr(expr,local_dict=sympy_ns) val=parsed.subs({sp.Symbol(k):v for k,v in binding.items()}).evalf() rval=complex(val).real val_str=(f"{rval:.4e}" if abs(rval)>1e6 or (abs(rval)<1e-4 and rval!=0) @@ -2371,59 +2538,61 @@ def collapse_solution(problem_text, axl_def, psl_text, binding, g1_pass, g2_pass markdown+=f"- **{name}**: `{expr}` = *(Eval Error: {str(e)})*\n" return markdown except json.JSONDecodeError: - return "JSON Decode Error. Raw output:\n\n" + resp.text + return "JSON Decode Error. Raw output:\n\n"+resp.text # ══════════════════════════════════════════════════════════════════════ # SECTION 15: GLOBAL SOLVE TASK # ══════════════════════════════════════════════════════════════════════ -def global_solve_task(original_problem_text, api_key, prebuilt_axl=None, - use_proxy_decomp: bool=True): +def global_solve_task(original_problem_text,api_key,prebuilt_axl=None, + use_proxy_decomp:bool=True): _update_state( - is_running=True, phase="ENCODING", high_level_logs=[], answer="", - best_ce=float('inf'), total_fired=0, best_ray="—", - recent_traces=deque(maxlen=25), sketch_summary="", template_count=0, - sympy_derivation=[], proxy_n_components=0, proxy_component_isos=[], - proxy_composed_ce=float('inf'), fingerprint_summary="", - propagation_log=[], raw_results_json="", infeasibility_report="", + is_running=True,phase="ENCODING",high_level_logs=[],answer="", + best_ce=float('inf'),total_fired=0,best_ray="—", + recent_traces=deque(maxlen=25),sketch_summary="",template_count=0, + sympy_derivation=[],proxy_n_components=0,proxy_component_isos=[], + proxy_composed_ce=float('inf'),fingerprint_summary="", + propagation_log=[],raw_results_json="",infeasibility_report="", minimize_result="", ) try: current_text=original_problem_text used_key=api_key or DEFAULT_GEMINI_API_KEY - sketch_notes=[]; proxy_isos=[] if prebuilt_axl is not None: - _add_log("⚡ Direct AXL (template parser — no LLM encoder)") + _add_log("Direct AXL (template parser — no LLM encoder)") axl_def=prebuilt_axl else: - _add_log(f"🔍 LLM Encoding (One-Shot)...") + _add_log("LLM Encoding (One-Shot)...") try: axl_def=encode_problem_to_axl(current_text,used_key) except Exception as e: - _add_log(f"✗ Encode failed: {e}") + _add_log(f"Encode failed: {e}") _update_state(phase="ERROR",answer=f"Encoder Failed: {str(e)}"); return - _add_log(f"✓ `{axl_def.name}` | {len(axl_def.variables)} vars | {len(axl_def.constraints)} constraints") - if axl_def.minimize_var: _add_log(f" ↳ MINIMIZE Directive: {axl_def.minimize_var}") + _add_log(f"`{axl_def.name}` | {len(axl_def.variables)} vars | {len(axl_def.constraints)} constraints") + if axl_def.minimize_var: _add_log(f" MINIMIZE: {axl_def.minimize_var}") _update_state(phase="COMPILING") try: psl_text=AXL_COMPILER.compile(axl_def); base_prob=build_base_problem(axl_def) except Exception as e: - _add_log(f"✗ Compile failed: {e}") + _add_log(f"Compile failed: {e}") _update_state(phase="ERROR",answer=f"Compiler Failed: {str(e)}"); return + if base_prob.log_space_vars: + _add_log(f" LOG-SPACE: {sorted(base_prob.log_space_vars)} optimized in log10 space") + try: - _add_log("🚀 Ray Tracer...") + _add_log("Ray Tracer...") tracer=SequenceRayTracer() binding,ce,traces,total_fired,best_ray_name=tracer.trace( axl_def,base_prob,use_proxy_decomp=use_proxy_decomp) except Exception as e: - _add_log(f"✗ Solver error: {e}") + _add_log(f"Solver error: {e}") _update_state(phase="ERROR",answer=f"Ray Tracer Crashed: {str(e)}"); raise e _update_state(phase="QUANTIZING") q_binding,q_ce,q_success=quantize_binding(binding,base_prob) if q_success and any(abs(q_binding.get(v,0)-binding.get(v,0))>0.01 for v in base_prob.int_vars): - _add_log(f"🧱 Quantize+Propagate: CE {ce:.4f} -> {q_ce:.4f}") + _add_log(f"Quantize+Propagate: CE {ce:.4f} -> {q_ce:.4f}") binding=q_binding; ce=q_ce with STATE_LOCK: @@ -2453,20 +2622,19 @@ def global_solve_task(original_problem_text, api_key, prebuilt_axl=None, infeas_obj=None if current_infeas: infeas_obj=InfeasibilityReport(True,[],current_infeas,True) - - min_var = base_prob.minimize_var - min_val = binding.get(min_var) if min_var else None - - raw_json=build_raw_results_json(binding,ce,g1_pass,g2_pass,inv_results,current_prop_log,infeas_obj,min_var,min_val) + min_var=base_prob.minimize_var + min_val=binding.get(min_var) if min_var else None + raw_json=build_raw_results_json(binding,ce,g1_pass,g2_pass,inv_results, + current_prop_log,infeas_obj,min_var,min_val) _update_state(raw_results_json=raw_json) if min_var and min_val is not None: _update_state(minimize_result=f"{min_var} = {safe_round(min_val,4)}") - solved_str=("✓ SOLVED" if (g1_pass and g2_pass) - else "🚫 INFEASIBLE" if current_infeas - else "~ PARTIAL" if g1_pass else "✗ UNSOLVED") + solved_str=("SOLVED" if (g1_pass and g2_pass) + else "INFEASIBLE" if current_infeas + else "PARTIAL" if g1_pass else "UNSOLVED") best_ray=traces[-1].ray_name if traces and traces[-1].survived else best_ray_name - _add_log(f"🏁 {solved_str} (CE: {safe_round(ce,5)}) | Ray: {best_ray}") + _add_log(f"{solved_str} (CE: {safe_round(ce,5)}) | Ray: {best_ray}") record_fingerprint(axl_def.name,best_ray,binding,ce) is_div,fp_msg=detect_divergence(axl_def.name) @@ -2475,7 +2643,7 @@ def global_solve_task(original_problem_text, api_key, prebuilt_axl=None, scaling_exponents=empirical_scaling_probe(axl_def,base_prob,binding,best_ray) raw_eqs=[mc.expr_str for mc in base_prob.compiled_constraints if mc.kind=="equality"] - _add_log("🔤 Collapsing → Grounded Hypothesis...") + _add_log("Collapsing -> Grounded Hypothesis...") _update_state(phase="COLLAPSING") try: answer=collapse_solution( @@ -2484,29 +2652,29 @@ def global_solve_task(original_problem_text, api_key, prebuilt_axl=None, sketch_notes,current_sympy_derivation,proxy_isos, scaling_exponents,raw_eqs,current_prop_log,current_infeas, min_var,min_val,used_key) - _update_state(answer=answer,phase="DONE"); _add_log("✓ Done.") + _update_state(answer=answer,phase="DONE"); _add_log("Done.") except Exception as e: _update_state(answer=f"Collapse error: {e}\n\nRAW:\n{raw_json}",phase="ERROR") - _add_log("✗ Collapse failed — raw results available.") + _add_log("Collapse failed — raw results available.") except Exception as e: import traceback; traceback.print_exc() - _add_log(f"💥 FATAL: {str(e)}") + _add_log(f"FATAL: {str(e)}") _update_state(phase="ERROR",answer=f"Fatal: {str(e)}") finally: _update_state(is_running=False) -def trigger_solve(problem_text, api_key, use_proxy=True): +def trigger_solve(problem_text,api_key,use_proxy=True): if GLOBAL_SOLVE_STATE["is_running"] or not problem_text.strip(): return threading.Thread(target=global_solve_task,args=(problem_text,api_key), kwargs={"use_proxy_decomp":use_proxy},daemon=True).start() -def trigger_quantum_solve(example_name, api_key): +def trigger_quantum_solve(example_name,api_key): if not HAS_QUANTUM or GLOBAL_SOLVE_STATE["is_running"]: return def _run_q(): if example_name=="Bell State": circ=QuantumCircuits.example_bell_state() - elif example_name=="VQE H2": circ=QuantumCircuits.example_vqe_h2() - else: circ=QuantumCircuits.example_qaoa_maxcut_p1() + elif example_name=="VQE H2": circ=QuantumCircuits.example_vqe_h2() + else: circ=QuantumCircuits.example_qaoa_maxcut_p1() try: axl_def=QuantumCircuits.build_quantum_axl(circ,AXLProblemDef,AXLInvariant) problem_desc=(f"Quantum Circuit: {circ.name}\nDescription: {circ.description}\n" @@ -2516,15 +2684,16 @@ def trigger_quantum_solve(example_name, api_key): _update_state(is_running=False,phase="ERROR",answer=f"Quantum compiler failed: {str(e)}") threading.Thread(target=_run_q,daemon=True).start() -def trigger_hypothesis_solve(template_name, api_key): +def trigger_hypothesis_solve(template_name,api_key): if GLOBAL_SOLVE_STATE["is_running"]: return problem_text=STRUCTURAL_HYPOTHESIS_TEMPLATES.get(template_name,"") if not problem_text: return try: axl_def=_parse_template_as_axl(problem_text) - _add_log(f"⚡ Direct parse: {axl_def.name} | {len(axl_def.variables)} vars | {len(axl_def.constraints)} constraints | {len(axl_def.anchors)} anchors") + _add_log(f"Direct parse: {axl_def.name} | {len(axl_def.variables)} vars | {len(axl_def.constraints)} constraints | {len(axl_def.anchors)} anchors") + if axl_def.minimize_var: _add_log(f" MINIMIZE: {axl_def.minimize_var}") except Exception as e: - _add_log(f"⚠ Direct parse failed ({e}), falling back to LLM encoder") + _add_log(f"Direct parse failed ({e}), falling back to LLM encoder") axl_def=None if axl_def is not None: threading.Thread(target=global_solve_task,args=(problem_text,api_key), @@ -2549,6 +2718,8 @@ body{background:#090909;color:#e0e0e0;font-family:monospace;} padding:8px;border-radius:4px;font-size:0.8em;margin:4px 0;} .minimize-banner{background:#0D1A00;border:1px solid #2B5C00;color:#88C245; padding:8px;border-radius:4px;font-size:0.8em;margin:4px 0;} +.logspace-banner{background:#00111A;border:1px solid #005C5C;color:#45C2C2; + padding:8px;border-radius:4px;font-size:0.8em;margin:4px 0;} """ RAY_ICONS={ @@ -2557,13 +2728,12 @@ RAY_ICONS={ "int_grid_propagated":"⚗","algebraic":"∑", } -PLACEHOLDER_HINT = textwrap.dedent(""" - Any natural language problem. Gemini encodes -> algebraic propagation -> - infeasibility detection -> ray search -> grounded hypothesis. +PLACEHOLDER_HINT=textwrap.dedent(""" + Natural language problems. Large-number variables auto-encoded in log2 space. Examples: - • "Find equilibrium of a 3-asset pool: x*y*z=8000, x+y+z=90, y=2z" • "What window size minimises secp256k1 scalar multiplications?" - • "Find all integer solutions to 3a + 5b = 47 where a,b in [0,20]" + • "Find equilibrium of a 3-asset pool: x*y*z=8000, x+y+z=90, y=2z" + • "How many qubits to factor RSA-2048 with Shor's algorithm?" """).strip() def build_live_html(): @@ -2589,43 +2759,34 @@ def build_live_html(): for l in logs[-7:]: log_html+=f"
  • {l}
    • " log_html+="" - infeas_html=(f"
    🚫 STRUCTURALLY INFEASIBLE: {infeas[:140]}
    " + infeas_html=(f"
    🚫 STRUCTURALLY INFEASIBLE: {infeas[:140]}
    " if infeas else "") - - minimize_html=(f"
    📉 OPTIMAL FOUND: {min_res}
    " + minimize_html=(f"
    📉 OPTIMAL: {min_res}
    " if min_res else "") - sketch_html=(f"
    " - f"🗺 Sketch: {sketch_summary[:120]}
    " + f"🗺 {sketch_summary[:120]}" if sketch_summary else "") - prop_html="" if prop_log: prop_lines="".join(f"
    {l[:70]}
    " for l in prop_log[:4]) prop_html=(f"
    " - f"⚗ Propagation:{prop_lines}
    ") - + f"border-left:2px solid #4CAF50;background:#0a0a0a'>⚗ Propagation:{prop_lines}") proxy_html="" if proxy_n>1: iso_list="".join(f"
    {iso[:60]}
    " for iso in proxy_isos[:3]) proxy_ce_str=f"{proxy_ce:.5f}" if proxy_ce" - f"🔀 Proxy: {proxy_n} comps | CE={proxy_ce_str}" - f"{iso_list}") - + f"🔀 Proxy: {proxy_n} comps | CE={proxy_ce_str}{iso_list}") fp_html="" if fp_summary: fp_color="#F44336" if "MULTI-ATTRACTOR" in fp_summary else "#4CAF50" fp_html=(f"
    " f"🔍 {fp_summary[:120]}
    ") - template_html=(f"
    🗺 Templates: {template_count}
    " if template_count>0 else "") - ray_trail="" for t in reversed(traces): icon=RAY_ICONS.get(t.ray_type,"·") @@ -2673,18 +2834,17 @@ def _reset_ans_cache(a_cache): a_cache=dict(a_cache); a_cache["finalized"]=False; a_cache["ans"]=""; a_cache["raw"]="" return a_cache -# ── Gradio App ──────────────────────────────────────────────────────── -with gr.Blocks(css=CSS, title="Practicality 27.6") as demo: +with gr.Blocks(css=CSS,title="Practicality 27.7") as demo: gr.Markdown( - "## ⚗ Practicality 27.6 — The Safe-Math Core\n" - "`[Direct Parser / LLM] -> [Safe Log/Sqrt Intercepts] -> [Orig Space Adam] -> [Dynamic Re-seeding]`" + "## ⚗ Practicality 27.7 — Log-Space Normalization\n" + "`[Auto Log-Space Adam] → [Log2-Space Templates] → [Safe Math] → [Dynamic Registry]`" ) - dash_cache = gr.State({"html": ""}) - ans_cache = gr.State({"ans": "", "raw": "", "finalized": False}) + dash_cache=gr.State({"html":""}) + ans_cache =gr.State({"ans":"","raw":"","finalized":False}) with gr.Row(elem_classes=["wrap-row"]): - with gr.Column(scale=2, min_width=300): + with gr.Column(scale=2,min_width=300): api_key_input=gr.Textbox(label="Gemini API Key",type="password", placeholder="AIza...",value=DEFAULT_GEMINI_API_KEY, elem_classes=["solver-log"]) @@ -2697,12 +2857,11 @@ with gr.Blocks(css=CSS, title="Practicality 27.6") as demo: with gr.Row(): solve_btn=gr.Button("⚗ Solve Natural Language",variant="primary") clear_btn=gr.Button("Clear") - with gr.Group(): gr.Markdown( - "### 2. Templates (Direct Parse — No LLM Warmup)\n" - "*Heisenberg quantum templates: O(n) variables for any qubit count.*\n" - "*Elliptic curve + resource templates: algebraic propagation.*" + "### 2. Templates (Direct Parse)\n" + "*Large-number templates encoded in log2-space.*\n" + "*Heisenberg templates: O(n) variables for any qubit count.*" ) hyp_dropdown=gr.Dropdown( choices=list(STRUCTURAL_HYPOTHESIS_TEMPLATES.keys()), @@ -2711,7 +2870,6 @@ with gr.Blocks(css=CSS, title="Practicality 27.6") as demo: with gr.Row(): hyp_load_btn=gr.Button("📋 Load Template Text") hyp_solve_btn=gr.Button("⚗ Solve Directly",variant="primary") - if HAS_QUANTUM: with gr.Group(): gr.Markdown("### 3. Quantum Circuit Hook") @@ -2719,61 +2877,72 @@ with gr.Blocks(css=CSS, title="Practicality 27.6") as demo: label="Circuit Template",value="Bell State") q_solve_btn=gr.Button("⚛ Run Quantum Hook",variant="primary") - with gr.Column(scale=1, min_width=250): + with gr.Column(scale=1,min_width=250): gr.Textbox( value=(f"Compute: {DEVICE.type.upper()}\n" f"Axioms: {len(ALL_AXIOMS)}\n" f"Templates: {len(STRUCTURAL_HYPOTHESIS_TEMPLATES)}\n" - f"\n27.6 UPDATES (Safe-Math Paradigm):\n" - f" ✓ LOBOTOMY FIXED: Bounds clamp restored\n" - f" to 1e15. 1,000,000 qubits now allowed.\n" - f" ✓ SAFE MATH: Tensors no longer throw NaN.\n" - f" log() and sqrt() are dynamically clamped >1e-7.\n" - f" Gradients naturally pull out of negative valleys.\n" - f" ✓ REGISTRY RATCHET: The 100,000 CE cap is gone.\n" - f" Registry tracks max(2.0, best_ce * 1.2).\n" - f" The 573-ray death loop is permanently fixed.\n" - f"\n27.5 FEATURES RETAINED:\n" - f" Fail-Fast execution (No retries)\n" - f" ray.depth < 1 unconditional branching.\n" - f" MINIMIZE Soft Objectives (isolated)\n" - f"\n MAX_RAYS={MAX_RAYS_PER_ATTEMPT:,}\n" - f" MAX_CHAIN_DEPTH={MAX_CHAIN_DEPTH}"), - lines=35,interactive=False,elem_classes=["solver-log"]) + f"\n27.7 — LOG-SPACE NORMALIZATION:\n" + f"\nROOT CAUSE FIX:\n" + f" CE in billions/millions was caused by\n" + f" squaring residuals of 10^12-scale vars.\n" + f" e.g. (total_tgates - target)^2 = 10^24 CE\n" + f"\nFIX 1: AUTO LOG-SPACE ADAM\n" + f" Variables with hi/lo > {LOG_SPACE_THRESHOLD}x\n" + f" and lo > 0 are optimized in log10 space.\n" + f" Energy still evaluated in original space.\n" + f" Equal fractional steps = no scale dominance.\n" + f"\nFIX 2: LOG2-SPACE TEMPLATES\n" + f" All Shor/Grover templates rewritten:\n" + f" log2_total_tgates instead of total_tgates.\n" + f" All values bounded in [0, 60].\n" + f" Multiplication -> addition in log space.\n" + f" CE stays in [0, 10] for all templates.\n" + f"\nFIX 3: LOG-UNIFORM MPRT SAMPLING\n" + f" Wide-range variables sampled uniformly\n" + f" in log space, not linear space.\n" + f"\nKEPT FROM 27.6:\n" + f" Safe log/sqrt intercepts\n" + f" Dynamic baton registry (best_ce * 1.2)\n" + f" _c15 bounds, MINIMIZE directive\n" + f" Copy-safe dual poller UI\n" + f" Direct template parser\n" + f" MAX_RAYS={MAX_RAYS_PER_ATTEMPT:,}"), + lines=48,interactive=False,elem_classes=["solver-log"]) with gr.Row(elem_classes=["wrap-row"]): - with gr.Column(scale=1, min_width=300): + with gr.Column(scale=1,min_width=300): live_html=gr.HTML(value=build_live_html()) - with gr.Column(scale=1, min_width=300): + with gr.Column(scale=1,min_width=300): answer_box=gr.Textbox( label="Deduced Hypothesis (freezes on completion — safe to copy)", lines=16,interactive=False,elem_classes=["answer-box"]) raw_results_box=gr.Textbox( - label="📋 Raw Results JSON (always populated — independent of LLM)", + label="📋 Raw Results JSON", lines=10,interactive=False,elem_classes=["raw-box"]) dash_poll_btn=gr.Button("DashPoll",elem_id="dash_poll_btn",elem_classes=["hidden-btn"]) ans_poll_btn =gr.Button("AnsPoll", elem_id="ans_poll_btn", elem_classes=["hidden-btn"]) - dash_poll_btn.click(fn=fetch_dashboard_only, inputs=[dash_cache], outputs=[live_html,dash_cache]) - ans_poll_btn.click(fn=fetch_answers_safe, inputs=[ans_cache], + dash_poll_btn.click(fn=fetch_dashboard_only,inputs=[dash_cache],outputs=[live_html,dash_cache]) + ans_poll_btn.click(fn=fetch_answers_safe,inputs=[ans_cache], outputs=[answer_box,raw_results_box,ans_cache]) demo.load( - fn=lambda dc,ac: (build_live_html(),dc,ac), + fn=lambda dc,ac:(build_live_html(),dc,ac), inputs=[dash_cache,ans_cache], outputs=[live_html,dash_cache,ans_cache], js=""" function() { - if (!window._p276_dash) { - window._p276_dash = setInterval(() => { + if (!window._p277_dash) { + window._p277_dash = setInterval(() => { const el = document.getElementById('dash_poll_btn'); if (!el) return; (el.tagName === 'BUTTON' ? el : el.querySelector('button'))?.click(); }, 1000); } - if (!window._p276_ans) { - window._p276_ans = setInterval(() => { + if (!window._p277_ans) { + window._p277_ans = setInterval(() => { const el = document.getElementById('ans_poll_btn'); if (!el) return; (el.tagName === 'BUTTON' ? el : el.querySelector('button'))?.click(); @@ -2785,14 +2954,11 @@ with gr.Blocks(css=CSS, title="Practicality 27.6") as demo: def on_solve(text,key,proxy,a_cache): a_cache=_reset_ans_cache(a_cache); trigger_solve(text,key,use_proxy=proxy) return a_cache - def on_hyp_solve(name,key,a_cache): a_cache=_reset_ans_cache(a_cache); trigger_hypothesis_solve(name,key) return a_cache - def on_clear(a_cache): - a_cache=_reset_ans_cache(a_cache) - return "","","",a_cache + a_cache=_reset_ans_cache(a_cache); return "","","",a_cache solve_btn.click(fn=on_solve,inputs=[problem_input,api_key_input,proxy_toggle,ans_cache], outputs=[ans_cache]) @@ -2802,7 +2968,6 @@ with gr.Blocks(css=CSS, title="Practicality 27.6") as demo: inputs=[hyp_dropdown],outputs=[problem_input]) hyp_solve_btn.click(fn=on_hyp_solve,inputs=[hyp_dropdown,api_key_input,ans_cache], outputs=[ans_cache]) - if HAS_QUANTUM: def on_q_solve(name,key,a_cache): a_cache=_reset_ans_cache(a_cache); trigger_quantum_solve(name,key) @@ -2811,11 +2976,12 @@ with gr.Blocks(css=CSS, title="Practicality 27.6") as demo: outputs=[ans_cache]) gr.Markdown( - f"Practicality 27.6 · Safe-Math Integration · Auto-Ratcheting Registry", + f"Practicality 27.7 · Log-Space Normalization · {len(STRUCTURAL_HYPOTHESIS_TEMPLATES)} templates", elem_classes=["status-bar"]) -if __name__ == "__main__": - print(f"[SYSTEM 27.6] Compute: {DEVICE.type.upper()} | Quantum={HAS_QUANTUM}") - print(f"[SYSTEM 27.6] Templates: {len(STRUCTURAL_HYPOTHESIS_TEMPLATES)}") - print(f"[SYSTEM 27.6] Fixes: Safe Math intercepted log() limits. 1e15 bounds restored.") - demo.launch(server_name="0.0.0.0", server_port=7860, share=False) \ No newline at end of file +if __name__=="__main__": + print(f"[SYSTEM 27.7] Compute: {DEVICE.type.upper()} | Quantum={HAS_QUANTUM}") + print(f"[SYSTEM 27.7] Templates: {len(STRUCTURAL_HYPOTHESIS_TEMPLATES)}") + print(f"[SYSTEM 27.7] LOG_SPACE_THRESHOLD: {LOG_SPACE_THRESHOLD}x range triggers log10 Adam") + print(f"[SYSTEM 27.7] All Shor/Grover templates rewritten in log2 space") + demo.launch(server_name="0.0.0.0",server_port=7860,share=False) \ No newline at end of file