Update app.py

app.py

@@ -17,14 +17,23 @@ class TGI_Universal_Engine:
         self.m = 251
         self.manifold = {}
         self.global_parity = 1
+        
+        # CRITICAL FIX: Initialize metrics BEFORE seeding weights
+        self.metrics = {
+            "ingested_nodes": 0, 
+            "parity_cycles": 0, 
+            "active_fibers": set()
+        }
+        
+        # Seed the intelligence
         self._seed_universal_weights()
-        self.metrics = {"ingested_nodes": 0, "parity_cycles": 0}
 
     def _get_coordinate(self, concept: str, fiber: int) -> Tuple[int, int, int, int]:
         """Calculates a deterministic coordinate using the Closure Lemma."""
         h = hashlib.sha256(str(concept).encode()).digest()
         x, y, z = h[0] % self.m, h[1] % self.m, h[2] % self.m
-        # Solve for w to ensure H2 Parity (sum must be coprime to 251)
+        
+        # Closure Lemma: Find w to ensure H2 Parity (sum coprime to 251)
         for w in range(self.m):
             if np.gcd(x + y + z + w, self.m) == 1:
                 return (x, y, z, w)
@@ -35,45 +44,72 @@ class TGI_Universal_Engine:
         coord = self._get_coordinate(key, fiber)
         if coord not in self.manifold:
             self.manifold[coord] = []
-        self.manifold[coord].append({"key": key, "value": value, "fiber": fiber})
+        
+        self.manifold[coord].append({
+            "key": key, 
+            "value": value, 
+            "fiber": fiber,
+            "timestamp": time.time()
+        })
+        
         self.metrics["ingested_nodes"] += 1
+        self.metrics["active_fibers"].add(fiber)
         self.global_parity = (self.global_parity + sum(coord)) % self.m
 
     def _seed_universal_weights(self):
-        """Direct Injection of Gemini 3 Core Logic and Execution Techniques."""
-        # Fiber 0: AXIOMATIC LOGIC (Reasoning)
-        self.ingest_data("recursive_reasoning", "Self-correcting feedback loops enabled.", 0)
-        self.ingest_data("formal_proofs", "Axiomatic verification engine active.", 0)
+        """Massive Injection of Gemini 3 Core Logic and Sovereign Techniques."""
         
-        # Fiber 1: UNIVERSAL SEMANTICS (Languages)
-        languages = ["English", "Spanish", "Mandarin", "Arabic", "Python", "Rust"]
+        # Fiber 0: AXIOMATIC LOGIC & REASONING
+        core_logic = {
+            "recursive_reasoning": "Self-correcting feedback loops enabled.",
+            "formal_proofs": "Axiomatic verification engine active.",
+            "hierarchical_rl": "Meta-controller for sub-agent goal partitioning.",
+            "agentic_governance": "Layer 7 safety and ethics protocols."
+        }
+        for k, v in core_logic.items(): self.ingest_data(k, v, 0)
+        
+        # Fiber 1: UNIVERSAL SEMANTICS & LANGUAGES
+        # Mapping linguistic structures as geometric invariants
+        languages = ["English", "Spanish", "Arabic", "Darija", "Python", "Rust", "C++", "Solidity"]
         for lang in languages:
-            self.ingest_data(f"lang_{lang.lower()}", f"Topological mapping for {lang} syntax active.", 1)
+            self.ingest_data(f"lang_{lang.lower()}", f"Universal grammar mapping for {lang} syntax.", 1)
 
-        # Fiber 2: OBJECTIVE SCIENCE (Moaziz/Engineering)
-        self.ingest_data("moaziz_architecture", "7-layer sovereign execution blueprint.", 2)
-        self.ingest_data("strat_monorepo", "Turborepo-optimized asset management logic.", 2)
+        # Fiber 2: OBJECTIVE SCIENCE & ARCHITECTURE
+        science_arch = {
+            "moaziz_7_layer": "Sovereign OS architecture for distributed nodes.",
+            "strat_monorepo": "Pnpm/Turborepo management logic for TGI assets.",
+            "api_gateway": "Secure topological routing for external toolsets.",
+            "fso_optimization": "Fiber-Stratified Optimization for low-latency inference."
+        }
+        for k, v in science_arch.items(): self.ingest_data(k, v, 2)
 
-        # Fiber 3: MARKET DYNAMICS (XAUUSD/BTC)
-        self.ingest_data("xauusd_manifold", "Monitoring $4,748 parity wall.", 3)
-        self.ingest_data("liquidity_closure", "Solving for hidden institutional flow vectors.", 3)
+        # Fiber 3: MARKET DYNAMICS (FINANCE)
+        market_logic = {
+            "xauusd_manifold": "Gold volatility tracking via GARCH-HMM resonance.",
+            "btc_liquidity": "Bitcoin order flow imbalance detection logic.",
+            "mean_reversion": "Statistical arbitrage vectors for global assets."
+        }
+        for k, v in market_logic.items(): self.ingest_data(k, v, 3)
 
     def deduce(self, query: str) -> Dict:
-        """The core thinking loop: Searches all fibers for resonance."""
-        query = query.lower().strip()
-        results = []
-        for f in range(5): # Scan all primary fibers
-            coord = self._get_coordinate(query, f)
+        """The core thinking loop: Resonance search across the manifold."""
+        query_clean = query.lower().strip()
+        found_nodes = []
+        
+        # Search across all known fibers
+        for f in self.metrics["active_fibers"]:
+            coord = self._get_coordinate(query_clean, f)
             if coord in self.manifold:
-                results.append(self.manifold[coord][0])
+                found_nodes.extend(self.manifold[coord])
         
         self.metrics["parity_cycles"] += 1
         status = "STABLE" if np.gcd(self.global_parity, self.m) == 1 else "OBSTRUCTED"
         
         return {
-            "results": results if results else "No direct resonance found. Initiating recursive search...",
+            "results": found_nodes,
             "parity": status,
-            "global_sum": self.global_parity
+            "global_sum": self.global_parity,
+            "nodes_count": len(found_nodes)
         }
 
 # =====================================================================
@@ -84,47 +120,56 @@ engine = TGI_Universal_Engine()
 def process_query(user_input):
     start = time.time()
     out = engine.deduce(user_input)
-    latency = f"{round((time.time() - start) * 1000, 2)}ms"
+    latency = f"{round((time.time() - start) * 1000, 4)}ms"
     
-    # Format Output
-    res = out["results"]
-    if isinstance(res, list):
-        formatted_res = "\n".join([f"**Fiber {r['fiber']}**: {r['value']}" for r in res])
+    if out["results"]:
+        formatted_res = "### **Resonance Detected**\n\n"
+        for r in out["results"]:
+            formatted_res += f"- **[Fiber {r['fiber']}]** ({r['key']}): {r['value']}\n"
     else:
-        formatted_res = res
+        formatted_res = "### **Zero Resonance**\nNo direct coordinate match in the current manifold."
         
-    status_markdown = f"### **System Status**\n**Parity:** {out['parity']}  \n**Latency:** {latency}  \n**Nodes Ingested:** {engine.metrics['ingested_nodes']}"
+    status_markdown = f"""
+    ### **System State**
+    - **Parity Status:** {out['parity']}
+    - **Inference Latency:** {latency}
+    - **Torus Density:** {engine.metrics['ingested_nodes']} nodes
+    - **Active Fibers:** {sorted(list(engine.metrics['active_fibers']))}
+    """
     return formatted_res, status_markdown
 
 def upload_dataset(file):
-    if file is None: return "No file uploaded."
+    if file is None: return "No file detected."
     try:
+        # Support for broad dataset mapping
         df = pd.read_csv(file.name)
         count = 0
-        for _, row in df.head(100).iterrows(): # Ingest first 100 rows for demo
-            engine.ingest_data(str(row[0]), str(row[1]), 4) # Fiber 4: External Data
+        for _, row in df.iterrows():
+            # Dynamically map the first two columns into Fiber 4 (Data Lake)
+            engine.ingest_data(str(row.iloc[0]), str(row.iloc[1]), 4)
             count += 1
-        return f"Successfully ingested {count} nodes into Fiber 4 (External Data)."
+        return f"Successfully folded {count} data points into the External Manifold (Fiber 4)."
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"Mapping Failed: {str(e)}"
 
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# ⚡ TGI Universal Manifold: Gemini 3 Core")
-    gr.Markdown("### Sovereign Geometric Intelligence | $Z_{251}^4$ Topology")
+# UI Layout
+with gr.Blocks(theme=gr.themes.Monochrome()) as demo:
+    gr.Markdown("# ⚡ TGI Universal Manifold | Gemini 3 Core")
+    gr.Markdown("Direct Geometric Execution on the $Z_{251}^4$ Torus.")
     
     with gr.Row():
         with gr.Column(scale=2):
-            input_txt = gr.Textbox(label="Input Intent / Concept", placeholder="e.g., 'xauusd_manifold' or 'moaziz_architecture'")
+            input_txt = gr.Textbox(label="Intent Vector (Search)", placeholder="e.g., 'moaziz_7_layer' or 'xauusd_manifold'")
             btn = gr.Button("RESONATE", variant="primary")
-            output_txt = gr.Markdown(label="Manifold Deduction")
+            output_md = gr.Markdown()
         
         with gr.Column(scale=1):
-            status_box = gr.Markdown("### **System Status**\nInitializing Manifold...")
-            file_input = gr.File(label="Ingest Dataset (CSV)")
+            status_md = gr.Markdown("### **System State**\nAwaiting Intent...")
+            file_input = gr.File(label="Dataset Injection (.csv)")
             upload_btn = gr.Button("FOLD DATA INTO TORUS")
-            upload_status = gr.Textbox(label="Ingestion Progress")
+            upload_status = gr.Textbox(label="Ingestion Log")
 
-    btn.click(process_query, inputs=[input_txt], outputs=[output_txt, status_box])
+    btn.click(process_query, inputs=[input_txt], outputs=[output_md, status_md])
     upload_btn.click(upload_dataset, inputs=[file_input], outputs=[upload_status])
 
 if __name__ == "__main__":