Update app.py

app.py

@@ -4,57 +4,214 @@ import json
 from datetime import datetime, timedelta
 import re
 import xml.etree.ElementTree as ET
-from urllib.parse import quote
-import time
-import random
+import numpy as np
+import hashlib
+from collections import defaultdict
+import math
 
-class RealTimeGeopoliticalAnalyzer:
+class VectorizedGeopoliticalAI:
     def __init__(self):
-        # Fonti dati real-time pubbliche (senza API key)
+        # Spazi vettoriali multidimensionali per analisi geopolitica
+        self.vector_dimensions = 512
+        self.semantic_space = self.initialize_semantic_space()
+        
+        # Matrici di trasformazione per concetti geopolitici
+        self.transformation_matrices = {
+            'power_dynamics': np.random.randn(self.vector_dimensions, self.vector_dimensions) * 0.1,
+            'economic_influence': np.random.randn(self.vector_dimensions, self.vector_dimensions) * 0.1,
+            'military_capability': np.random.randn(self.vector_dimensions, self.vector_dimensions) * 0.1,
+            'diplomatic_relations': np.random.randn(self.vector_dimensions, self.vector_dimensions) * 0.1,
+            'resource_control': np.random.randn(self.vector_dimensions, self.vector_dimensions) * 0.1,
+            'information_warfare': np.random.randn(self.vector_dimensions, self.vector_dimensions) * 0.1
+        }
+        
+        # Knowledge Graph Embeddings
+        self.entity_embeddings = {}
+        self.relation_embeddings = {}
+        self.temporal_embeddings = {}
+        
+        # Fonti real-time
         self.data_sources = {
             "reuters_rss": "https://feeds.reuters.com/reuters/worldNews",
             "bbc_rss": "https://feeds.bbci.co.uk/news/world/rss.xml",
-            "un_news": "https://news.un.org/en/rss/rss.xml",
-            "crisis_tracker": "https://api.gdeltproject.org/api/v2/summary/summary?d=web&t=summary&ts=full",
-            "world_bank_data": "https://api.worldbank.org/v2/country/all/indicator/NY.GDP.MKTP.CD?format=json&date=2024",
-            "open_sanctions": "https://data.opensanctions.org/datasets/latest/default/targets.simple.csv",
-            "conflict_data": "https://ucdp.uu.se/downloads/ged/ged231-csv.zip"
+            "un_news": "https://news.un.org/en/rss/rss.xml"
         }
         
-        # Cache per performance
-        self.cache = {}
-        self.cache_duration = 1800  # 30 minuti
-        
-        # AI Generativa - Template per analisi avanzata
-        self.ai_templates = {
-            "conflict_analysis": """
-            Analizza questo conflitto geopolitico:
-            - Attori: {actors}
-            - Eventi recenti: {events}
-            - Contesto: {context}
+        self.initialize_embeddings()
+        
+    def initialize_semantic_space(self):
+        """Inizializza spazio semantico multidimensionale"""
+        # Crea base ortonormale per lo spazio semantico geopolitico
+        semantic_basis = {}
+        
+        # Dimensioni fondamentali della geopolitica
+        fundamental_concepts = [
+            'sovereignty', 'power', 'alliance', 'conflict', 'trade', 'territory',
+            'resource', 'influence', 'security', 'diplomacy', 'ideology', 'culture',
+            'economy', 'military', 'information', 'technology', 'energy', 'population'
+        ]
+        
+        for i, concept in enumerate(fundamental_concepts):
+            vector = np.zeros(self.vector_dimensions)
+            # Distribuzione gaussiana per embedding iniziale
+            vector[:len(fundamental_concepts)] = np.random.normal(0, 0.1, len(fundamental_concepts))
+            vector[i] = 1.0  # Componente principale
+            semantic_basis[concept] = vector / np.linalg.norm(vector)
             
-            Fornisci: cause profonde, dinamiche di potere, possibili escalation, soluzioni diplomatiche
-            """,
-            "economic_impact": """
-            Valuta l'impatto economico di:
-            - Situazione: {situation}
-            - Paesi coinvolti: {countries}
-            - Settori: {sectors}
+        return semantic_basis
+    
+    def initialize_embeddings(self):
+        """Inizializza embeddings per entità geopolitiche"""
+        
+        # Entità geopolitiche con caratteristiche vettoriali
+        entities = {
+            'USA': {'power': 0.95, 'economy': 0.92, 'military': 0.98, 'influence': 0.90},
+            'China': {'power': 0.88, 'economy': 0.89, 'military': 0.85, 'influence': 0.82},
+            'Russia': {'power': 0.75, 'economy': 0.45, 'military': 0.88, 'influence': 0.70},
+            'Germany': {'power': 0.65, 'economy': 0.85, 'military': 0.55, 'influence': 0.72},
+            'Ukraine': {'power': 0.25, 'economy': 0.20, 'military': 0.45, 'influence': 0.35},
+            'Iran': {'power': 0.40, 'economy': 0.30, 'military': 0.60, 'influence': 0.45},
+            'Israel': {'power': 0.55, 'economy': 0.70, 'military': 0.80, 'influence': 0.60},
+            'Taiwan': {'power': 0.45, 'economy': 0.75, 'military': 0.50, 'influence': 0.40},
+            'North Korea': {'power': 0.20, 'economy': 0.10, 'military': 0.70, 'influence': 0.25},
+            'NATO': {'power': 0.95, 'economy': 0.88, 'military': 0.95, 'influence': 0.90},
+            'EU': {'power': 0.80, 'economy': 0.90, 'military': 0.60, 'influence': 0.85}
+        }
+        
+        for entity, characteristics in entities.items():
+            # Crea vettore multidimensionale per l'entità
+            vector = np.zeros(self.vector_dimensions)
             
-            Analizza: effetti commerciali, catene di fornitura, mercati finanziari, conseguenze a lungo termine
-            """,
-            "alliance_dynamics": """
-            Esamina le dinamiche delle alleanze:
-            - Alleanze coinvolte: {alliances}
-            - Tensioni: {tensions}
-            - Interessi: {interests}
+            # Mappa caratteristiche su dimensioni vettoriali
+            for i, (char, value) in enumerate(characteristics.items()):
+                if char in self.semantic_space:
+                    vector += value * self.semantic_space[char]
             
-            Predici: cambiamenti negli equilibri, nuove partnership, fratture possibili
-            """
+            # Aggiungi rumore gaussiano per robustezza
+            vector += np.random.normal(0, 0.05, self.vector_dimensions)
+            
+            # Normalizza
+            self.entity_embeddings[entity] = vector / (np.linalg.norm(vector) + 1e-8)
+    
+    def text_to_vector(self, text):
+        """Converte testo in rappresentazione vettoriale"""
+        # Tokenizzazione e pesatura TF-IDF semplificata
+        words = re.findall(r'\b\w+\b', text.lower())
+        
+        # Crea vettore composito
+        composite_vector = np.zeros(self.vector_dimensions)
+        word_count = 0
+        
+        # Mappa semantica delle parole chiave
+        semantic_mapping = {
+            'war': 'conflict', 'peace': 'diplomacy', 'trade': 'economy',
+            'military': 'military', 'sanctions': 'economy', 'alliance': 'alliance',
+            'nuclear': 'military', 'energy': 'resource', 'oil': 'resource',
+            'crisis': 'conflict', 'negotiation': 'diplomacy', 'summit': 'diplomacy'
         }
         
-    def fetch_real_time_news(self):
-        """Recupera notizie real-time da RSS feeds"""
+        for word in words:
+            if word in semantic_mapping and semantic_mapping[word] in self.semantic_space:
+                concept = semantic_mapping[word]
+                composite_vector += self.semantic_space[concept]
+                word_count += 1
+            elif word in self.semantic_space:
+                composite_vector += self.semantic_space[word]
+                word_count += 1
+        
+        # Normalizzazione con peso logaritmico
+        if word_count > 0:
+            composite_vector /= math.log(word_count + 1)
+            
+        return composite_vector / (np.linalg.norm(composite_vector) + 1e-8)
+    
+    def compute_entity_relations(self, entities):
+        """Calcola relazioni tra entità nello spazio vettoriale"""
+        relations = {}
+        
+        for i, entity1 in enumerate(entities):
+            if entity1 not in self.entity_embeddings:
+                continue
+                
+            for j, entity2 in enumerate(entities[i+1:], i+1):
+                if entity2 not in self.entity_embeddings:
+                    continue
+                
+                vec1 = self.entity_embeddings[entity1]
+                vec2 = self.entity_embeddings[entity2]
+                
+                # Similarità coseno
+                cosine_sim = np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2))
+                
+                # Distanza euclidea normalizzata
+                euclidean_dist = np.linalg.norm(vec1 - vec2) / math.sqrt(self.vector_dimensions)
+                
+                # Proiezione su spazio delle alleanze
+                alliance_projection = np.dot(vec1 + vec2, self.semantic_space['alliance'])
+                
+                # Proiezione su spazio dei conflitti
+                conflict_projection = np.dot(vec1 - vec2, self.semantic_space['conflict'])
+                
+                relations[(entity1, entity2)] = {
+                    'similarity': cosine_sim,
+                    'distance': euclidean_dist,
+                    'alliance_potential': alliance_projection,
+                    'conflict_potential': abs(conflict_projection),
+                    'power_differential': np.linalg.norm(vec1) - np.linalg.norm(vec2)
+                }
+        
+        return relations
+    
+    def apply_transformation_matrices(self, input_vector, context_type):
+        """Applica matrici di trasformazione per analisi contestuale"""
+        if context_type not in self.transformation_matrices:
+            return input_vector
+        
+        transformation_matrix = self.transformation_matrices[context_type]
+        transformed_vector = np.dot(transformation_matrix, input_vector)
+        
+        # Applicazione funzione di attivazione (tanh per mantenere bounded)
+        activated_vector = np.tanh(transformed_vector)
+        
+        return activated_vector
+    
+    def vector_space_analysis(self, query_vector, entities, real_time_data):
+        """Analisi nello spazio vettoriale multidimensionale"""
+        analysis = {}
+        
+        # 1. Analisi di proiezione su sottospazi semantici
+        semantic_projections = {}
+        for concept, basis_vector in self.semantic_space.items():
+            projection = np.dot(query_vector, basis_vector)
+            semantic_projections[concept] = projection
+        
+        # 2. Calcolo delle distanze nel manifold geopolitico
+        entity_distances = {}
+        for entity in entities:
+            if entity in self.entity_embeddings:
+                distance = np.linalg.norm(query_vector - self.entity_embeddings[entity])
+                entity_distances[entity] = distance
+        
+        # 3. Analisi delle trasformazioni contestuali
+        contextual_transforms = {}
+        for context in self.transformation_matrices.keys():
+            transformed = self.apply_transformation_matrices(query_vector, context)
+            # Calcola l'entropia della trasformazione
+            entropy = -np.sum(transformed * np.log(np.abs(transformed) + 1e-8))
+            contextual_transforms[context] = {
+                'vector': transformed,
+                'entropy': entropy,
+                'norm': np.linalg.norm(transformed)
+            }
+        
+        analysis['semantic_projections'] = semantic_projections
+        analysis['entity_distances'] = entity_distances
+        analysis['contextual_transforms'] = contextual_transforms
+        
+        return analysis
+    
+    def fetch_real_time_data(self):
+        """Recupera dati real-time per alimentare i vettori"""
         news_data = []
         
         try:
@@ -62,17 +219,16 @@ class RealTimeGeopoliticalAnalyzer:
             response = requests.get(self.data_sources["reuters_rss"], timeout=10)
             if response.status_code == 200:
                 root = ET.fromstring(response.content)
-                for item in root.findall(".//item")[:5]:
+                for item in root.findall(".//item")[:8]:
                     title = item.find("title")
-                    pub_date = item.find("pubDate")
                     description = item.find("description")
                     
                     if title is not None:
                         news_data.append({
                             "source": "Reuters",
                             "title": title.text,
-                            "date": pub_date.text if pub_date is not None else "N/A",
-                            "description": description.text if description is not None else ""
+                            "description": description.text if description is not None else "",
+                            "vector": self.text_to_vector(title.text + " " + (description.text or ""))
                         })
         except:
             pass
@@ -82,86 +238,42 @@ class RealTimeGeopoliticalAnalyzer:
             response = requests.get(self.data_sources["bbc_rss"], timeout=10)
             if response.status_code == 200:
                 root = ET.fromstring(response.content)
-                for item in root.findall(".//item")[:5]:
+                for item in root.findall(".//item")[:8]:
                     title = item.find("title")
-                    pub_date = item.find("pubDate")
                     description = item.find("description")
                     
                     if title is not None:
                         news_data.append({
                             "source": "BBC",
                             "title": title.text,
-                            "date": pub_date.text if pub_date is not None else "N/A",
-                            "description": description.text if description is not None else ""
+                            "description": description.text if description is not None else "",
+                            "vector": self.text_to_vector(title.text + " " + (description.text or ""))
                         })
         except:
             pass
         
-        return news_data[:10]  # Top 10 notizie
-    
-    def fetch_economic_indicators(self):
-        """Recupera indicatori economici real-time"""
-        try:
-            # World Bank API (pubblico, no key)
-            response = requests.get(self.data_sources["world_bank_data"], timeout=15)
-            if response.status_code == 200:
-                data = response.json()
-                if len(data) > 1 and isinstance(data[1], list):
-                    return data[1][:20]  # Top 20 economie
-        except:
-            pass
-        return []
+        return news_data
     
-    def extract_geopolitical_entities(self, text_data):
-        """Estrae entità geopolitiche da testi real-time con NLP"""
-        entities = {
-            "countries": set(),
-            "organizations": set(),
-            "conflicts": set(),
-            "keywords": set()
+    def extract_entities_advanced(self, text_data):
+        """Estrazione avanzata di entità con confidence scores"""
+        entities = []
+        entity_vectors = {}
+        
+        # Pattern più sofisticati per entità geopolitiche
+        entity_patterns = {
+            'USA|United States|America|Washington': 'USA',
+            'China|Chinese|Beijing|PRC': 'China',
+            'Russia|Russian|Moscow|Kremlin': 'Russia',
+            'Ukraine|Ukrainian|Kyiv|Kiev': 'Ukraine',
+            'Iran|Iranian|Tehran': 'Iran',
+            'Israel|Israeli|Jerusalem': 'Israel',
+            'Taiwan|Taipei': 'Taiwan',
+            'North Korea|DPRK|Pyongyang': 'North Korea',
+            'NATO|North Atlantic': 'NATO',
+            'European Union|EU': 'EU',
+            'Germany|German|Berlin': 'Germany'
         }
         
-        # Pattern per paesi (più sofisticato)
-        country_patterns = [
-            r'\b(United States|USA|America|US)\b',
-            r'\b(China|Chinese|Beijing)\b',
-            r'\b(Russia|Russian|Moscow|Kremlin)\b',
-            r'\b(Ukraine|Ukrainian|Kyiv|Kiev)\b',
-            r'\b(Israel|Israeli|Jerusalem|Tel Aviv)\b',
-            r'\b(Iran|Iranian|Tehran)\b',
-            r'\b(Germany|German|Berlin)\b',
-            r'\b(France|French|Paris)\b',
-            r'\b(Italy|Italian|Rome)\b',
-            r'\b(Japan|Japanese|Tokyo)\b',
-            r'\b(India|Indian|New Delhi)\b',
-            r'\b(Turkey|Turkish|Ankara)\b',
-            r'\b(Saudi Arabia|Saudi|Riyadh)\b',
-            r'\b(North Korea|DPRK|Pyongyang)\b',
-            r'\b(South Korea|Seoul)\b',
-            r'\b(Taiwan|Taipei)\b',
-            r'\b(Pakistan|Islamabad)\b'
-        ]
-        
-        # Pattern per organizzazioni
-        org_patterns = [
-            r'\b(NATO|North Atlantic)\b',
-            r'\b(European Union|EU)\b',
-            r'\b(United Nations|UN)\b',
-            r'\b(BRICS)\b',
-            r'\b(G7|G20)\b',
-            r'\b(ASEAN)\b',
-            r'\b(OPEC)\b',
-            r'\b(IMF|World Bank)\b'
-        ]
-        
-        # Keywords geopolitiche
-        conflict_keywords = [
-            r'\b(war|conflict|tension|crisis|sanctions|embargo|blockade)\b',
-            r'\b(military|defense|security|nuclear|missile|drone)\b',
-            r'\b(trade war|tariffs|economic pressure|diplomatic crisis)\b',
-            r'\b(alliance|partnership|treaty|agreement|summit)\b'
-        ]
-        
         combined_text = ""
         if isinstance(text_data, list):
             for item in text_data:
@@ -172,394 +284,281 @@ class RealTimeGeopoliticalAnalyzer:
         else:
             combined_text = str(text_data)
         
-        # Estrai entità
-        for pattern in country_patterns:
+        # Estrai entità con confidence
+        for pattern, entity in entity_patterns.items():
             matches = re.findall(pattern, combined_text, re.IGNORECASE)
-            entities["countries"].update([m if isinstance(m, str) else m[0] for m in matches])
-        
-        for pattern in org_patterns:
-            matches = re.findall(pattern, combined_text, re.IGNORECASE)
-            entities["organizations"].update([m if isinstance(m, str) else m[0] for m in matches])
-            
-        for pattern in conflict_keywords:
-            matches = re.findall(pattern, combined_text, re.IGNORECASE)
-            entities["keywords"].update([m if isinstance(m, str) else m[0] for m in matches])
-        
-        return entities
-    
-    def ai_generative_analysis(self, query, real_time_data, entities):
-        """AI Generativa per analisi complessa"""
-        
-        # Determina il tipo di analisi necessaria
-        query_lower = query.lower()
-        analysis_type = "general"
-        
-        if any(word in query_lower for word in ["conflict", "war", "tension", "crisis"]):
-            analysis_type = "conflict_analysis"
-        elif any(word in query_lower for word in ["economic", "trade", "sanctions", "market"]):
-            analysis_type = "economic_impact"
-        elif any(word in query_lower for word in ["alliance", "nato", "partnership", "bloc"]):
-            analysis_type = "alliance_dynamics"
-        
-        # Template AI per analisi generativa
-        ai_analysis = {
-            "situation_assessment": self.assess_current_situation(real_time_data, entities),
-            "power_dynamics": self.analyze_power_dynamics(entities),
-            "trend_analysis": self.identify_trends(real_time_data),
-            "risk_assessment": self.calculate_risks(entities, real_time_data),
-            "scenario_generation": self.generate_scenarios(query, entities),
-            "strategic_implications": self.derive_strategic_implications(entities, real_time_data)
-        }
-        
-        return ai_analysis
-    
-    def assess_current_situation(self, data, entities):
-        """Valuta la situazione attuale basata su dati real-time"""
-        assessment = []
-        
-        # Intensità delle tensioni basata su keywords
-        tension_indicators = ["war", "conflict", "crisis", "sanctions", "military"]
-        tension_count = sum(1 for keyword in entities.get("keywords", []) 
-                          if keyword.lower() in tension_indicators)
-        
-        if tension_count >= 3:
-            assessment.append("🔴 ALTA TENSIONE - Situazione critica rilevata")
-        elif tension_count >= 1:
-            assessment.append("🟡 TENSIONE MODERATA - Monitoraggio necessario")
-        else:
-            assessment.append("🟢 STABILITÀ RELATIVA - Situazione sotto controllo")
-        
-        # Coinvolgimento grandi potenze
-        major_powers = ["United States", "USA", "China", "Russia", "European Union", "EU"]
-        involved_powers = [p for p in major_powers if p in entities.get("countries", [])]
-        
-        if len(involved_powers) >= 2:
-            assessment.append(f"⚡ Coinvolte superpotenze: {', '.join(involved_powers)}")
-        
-        return assessment
-    
-    def analyze_power_dynamics(self, entities):
-        """Analizza le dinamiche di potere"""
-        dynamics = []
-        
-        countries = list(entities.get("countries", []))
-        orgs = list(entities.get("organizations", []))
-        
-        # Analisi blocchi
-        if "NATO" in orgs and any(country in ["Russia", "China"] for country in countries):
-            dynamics.append("🔄 CONFRONTO EST-OVEST - Dinamiche da Guerra Fredda")
-        
-        if "China" in countries and "Taiwan" in countries:
-            dynamics.append("⚔️ TENSIONE TAIWAN - Flashpoint critico Asia-Pacifico")
-            
-        if "Ukraine" in countries and "Russia" in countries:
-            dynamics.append("🚨 CONFLITTO ATTIVO - Europa orientale instabile")
-        
-        return dynamics
-    
-    def identify_trends(self, data):
-        """Identifica trend dai dati real-time"""
-        trends = []
-        
-        if not data:
-            return ["📊 Dati insufficienti per trend analysis"]
-        
-        # Analisi frequenza keywords nelle notizie
-        all_text = ""
-        for item in data:
-            if isinstance(item, dict):
-                all_text += f" {item.get('title', '')} {item.get('description', '')}"
-        
-        trend_keywords = {
-            "militarizzazione": ["military", "defense", "weapon", "missile", "nuclear"],
-            "sanzioni_economiche": ["sanction", "embargo", "tariff", "economic pressure"],
-            "diplomazia": ["summit", "negotiation", "agreement", "treaty", "dialogue"],
-            "instabilità": ["crisis", "tension", "conflict", "unstable", "volatile"]
-        }
-        
-        for trend, keywords in trend_keywords.items():
-            count = sum(all_text.lower().count(keyword) for keyword in keywords)
-            if count >= 2:
-                trends.append(f"📈 TREND: {trend.upper()} ({count} menzioni)")
-        
-        return trends if trends else ["📊 Pattern stabili - Nessun trend anomalo"]
-    
-    def calculate_risks(self, entities, data):
-        """Calcola livelli di rischio"""
-        risks = []
-        risk_score = 0
-        
-        # Fattori di rischio
-        high_risk_combinations = [
-            (["Russia", "Ukraine"], "Escalation conflitto"),
-            (["China", "Taiwan"], "Crisi Taiwan Strait"),
-            (["Iran", "Israel"], "Conflitto Medio Oriente"),
-            (["North Korea", "South Korea"], "Tensione coreana")
-        ]
-        
-        countries = list(entities.get("countries", []))
-        
-        for combo, risk_desc in high_risk_combinations:
-            if all(country in countries for country in combo):
-                risks.append(f"🚨 ALTO RISCHIO: {risk_desc}")
-                risk_score += 3
-        
-        # Rischio sanzioni
-        if "sanctions" in entities.get("keywords", []):
-            risks.append("💰 RISCHIO ECONOMICO: Impatti sanzionatori")
-            risk_score += 2
-            
-        # Rischio militare
-        if any(keyword in entities.get("keywords", []) for keyword in ["military", "nuclear", "missile"]):
-            risks.append("⚔️ RISCHIO MILITARE: Escalation possibile")
-            risk_score += 2
-        
-        # Calcola livello generale
-        if risk_score >= 5:
-            risks.insert(0, "🔴 LIVELLO RISCHIO: CRITICO")
-        elif risk_score >= 3:
-            risks.insert(0, "🟡 LIVELLO RISCHIO: ELEVATO")
-        else:
-            risks.insert(0, "🟢 LIVELLO RISCHIO: MODERATO")
-        
-        return risks
-    
-    def generate_scenarios(self, query, entities):
-        """Genera scenari futuri basati su AI"""
-        scenarios = []
-        
-        countries = list(entities.get("countries", []))
-        keywords = list(entities.get("keywords", []))
-        
-        # Scenari basati su pattern
-        if "Russia" in countries and "Ukraine" in countries:
-            scenarios.extend([
-                "📊 SCENARIO A: Escalation → Coinvolgimento NATO diretto",
-                "📊 SCENARIO B: Stallo → Guerra di logoramento prolungata",
-                "📊 SCENARIO C: Negoziato → Cessate il fuoco territoriale"
-            ])
-        
-        elif "China" in countries and "Taiwan" in countries:
-            scenarios.extend([
-                "📊 SCENARIO A: Blockade → Crisi economica globale",
-                "📊 SCENARIO B: Status quo → Tensione controllata",
-                "📊 SCENARIO C: Riunificazione → Shock geopolitico"
-            ])
-        
-        else:
-            # Scenari generici
-            scenarios.extend([
-                "📊 SCENARIO A: Stabilizzazione → Ritorno alla normalità",
-                "📊 SCENARIO B: Escalation → Aumento delle tensioni",
-                "📊 SCENARIO C: Frammentazione → Nuovi equilibri regionali"
-            ])
-        
-        return scenarios
-    
-    def derive_strategic_implications(self, entities, data):
-        """Deriva implicazioni strategiche"""
-        implications = []
-        
-        countries = list(entities.get("countries", []))
-        orgs = list(entities.get("organizations", []))
-        
-        # Implicazioni per alleanze
-        if "NATO" in orgs:
-            implications.append("🛡️ NATO: Rafforzamento deterrenza e coesione alleanza")
-        
-        if "EU" in orgs or "European Union" in orgs:
-            implications.append("🇪🇺 UE: Necessità autonomia strategica e difesa comune")
-        
-        # Implicazioni economiche
-        if any(country in ["China", "USA", "Germany"] for country in countries):
-            implications.append("💼 COMMERCIO: Riconfigurazione catene globali del valore")
-        
-        # Implicazioni tecnologiche
-        if "China" in countries and "USA" in countries:
-            implications.append("🔬 TECH: Accelerazione decoupling tecnologico")
-        
-        # Implicazioni energetiche
-        if "Russia" in countries:
-            implications.append("⚡ ENERGIA: Diversificazione fonti e fornitori")
-        
-        return implications
+            if matches:
+                confidence = len(matches) / len(combined_text.split()) * 100
+                entities.append({
+                    'name': entity,
+                    'confidence': min(confidence, 1.0),
+                    'mentions': len(matches)
+                })
+                
+                if entity in self.entity_embeddings:
+                    entity_vectors[entity] = self.entity_embeddings[entity]
+        
+        return entities, entity_vectors
     
-    def analyze_geopolitical_situation(self, query):
-        """Analisi geopolitica completa con dati real-time + AI"""
+    def generate_mathematical_analysis(self, query, real_time_data):
+        """Genera analisi matematica avanzata dai vettori"""
         
         try:
-            # 1. Recupera dati real-time
-            news_data = self.fetch_real_time_news()
-            economic_data = self.fetch_economic_indicators()
+            # 1. Converte query in vettore multidimensionale
+            query_vector = self.text_to_vector(query)
+            
+            # 2. Estrai entità e loro vettori
+            entities, entity_vectors = self.extract_entities_advanced([{"title": query}] + real_time_data)
+            entity_names = [e['name'] for e in entities]
             
-            # 2. Estrai entità dai dati real-time + query
-            combined_data = news_data + [{"title": query, "description": ""}]
-            entities = self.extract_geopolitical_entities(combined_data)
+            # 3. Calcola relazioni nello spazio vettoriale
+            relations = self.compute_entity_relations(entity_names)
             
-            # 3. AI Generativa Analysis
-            ai_analysis = self.ai_generative_analysis(query, news_data, entities)
+            # 4. Analisi vettoriale completa
+            vector_analysis = self.vector_space_analysis(query_vector, entity_names, real_time_data)
             
-            # 4. Genera report completo
-            report = self.generate_comprehensive_report(query, news_data, entities, ai_analysis)
+            # 5. Genera report matematico
+            report = self.generate_vector_report(query, query_vector, entities, relations, vector_analysis, real_time_data)
             
             return report
             
         except Exception as e:
-            return f"❌ Errore nell'analisi real-time: {str(e)}\n\nRitenta tra qualche secondo."
+            return f"❌ Errore nell'analisi vettoriale: {str(e)}"
     
-    def generate_comprehensive_report(self, query, news_data, entities, ai_analysis):
-        """Genera report completo con tutti i dati"""
+    def generate_vector_report(self, query, query_vector, entities, relations, vector_analysis, real_time_data):
+        """Genera report basato su analisi vettoriale matematica"""
         
         report_parts = []
         
-        # Header con timestamp
-        report_parts.append("🌍 GEOPOLITICAL INTELLIGENCE REPORT")
-        report_parts.append("=" * 55)
-        report_parts.append(f"🕐 Generated: {datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}")
-        report_parts.append("📡 Sources: Real-time RSS feeds + AI Analysis")
+        # Header matematico
+        report_parts.append("🧮 VECTORIZED GEOPOLITICAL ANALYSIS")
+        report_parts.append("═" * 60)
+        report_parts.append(f"📐 Vector Space: R^{self.vector_dimensions} | Semantic Manifold Analysis")
+        report_parts.append(f"🕐 Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S UTC')}")
         report_parts.append("")
         
-        # Query Analysis
-        report_parts.append(f"🎯 QUERY: {query}")
+        # Query Vector Analysis
+        query_norm = np.linalg.norm(query_vector)
+        query_entropy = -np.sum(query_vector * np.log(np.abs(query_vector) + 1e-8))
+        report_parts.append(f"🎯 QUERY VECTORIZATION:")
+        report_parts.append(f"  ∥q∥₂ = {query_norm:.4f} | H(q) = {query_entropy:.4f}")
+        report_parts.append(f"  Dimensional complexity: {np.count_nonzero(np.abs(query_vector) > 0.1)}/{self.vector_dimensions}")
         report_parts.append("")
         
-        # Real-time News Context
-        if news_data:
-            report_parts.append("📰 REAL-TIME NEWS CONTEXT:")
-            for i, news in enumerate(news_data[:5], 1):
-                report_parts.append(f"  {i}. [{news['source']}] {news['title'][:80]}...")
-            report_parts.append("")
-        
-        # Entities Detected
-        report_parts.append("🎭 ENTITIES DETECTED (REAL-TIME):")
-        if entities['countries']:
-            report_parts.append(f"  🏛️ Countries: {', '.join(list(entities['countries'])[:8])}")
-        if entities['organizations']:
-            report_parts.append(f"  🏢 Organizations: {', '.join(list(entities['organizations'])[:6])}")
-        if entities['keywords']:
-            report_parts.append(f"  🔑 Keywords: {', '.join(list(entities['keywords'])[:8])}")
+        # Semantic Projections
+        top_projections = sorted(vector_analysis['semantic_projections'].items(), 
+                                key=lambda x: abs(x[1]), reverse=True)[:6]
+        
+        report_parts.append("📊 SEMANTIC SPACE PROJECTIONS:")
+        for concept, projection in top_projections:
+            intensity = "█" * int(abs(projection) * 20 + 1)
+            sign = "+" if projection > 0 else "-"
+            report_parts.append(f"  {concept:.<15} {sign}{abs(projection):.3f} {intensity}")
         report_parts.append("")
         
-        # AI Situation Assessment
-        report_parts.append("🤖 AI SITUATION ASSESSMENT:")
-        for assessment in ai_analysis['situation_assessment']:
-            report_parts.append(f"  {assessment}")
+        # Entity Analysis with Confidence
+        if entities:
+            report_parts.append("🎭 ENTITY DETECTION (CONFIDENCE-WEIGHTED):")
+            sorted_entities = sorted(entities, key=lambda x: x['confidence'], reverse=True)
+            for entity in sorted_entities[:8]:
+                confidence_bar = "▓" * int(entity['confidence'] * 20)
+                report_parts.append(f"  {entity['name']:.<12} π={entity['confidence']:.3f} n={entity['mentions']} {confidence_bar}")
         report_parts.append("")
         
-        # Power Dynamics
-        if ai_analysis['power_dynamics']:
-            report_parts.append("⚡ POWER DYNAMICS ANALYSIS:")
-            for dynamic in ai_analysis['power_dynamics']:
-                report_parts.append(f"  {dynamic}")
-            report_parts.append("")
-        
-        # Trend Analysis
-        report_parts.append("📈 TREND ANALYSIS (DATA-DRIVEN):")
-        for trend in ai_analysis['trend_analysis']:
-            report_parts.append(f"  {trend}")
+        # Vector Relations Analysis
+        if relations:
+            report_parts.append("🔗 INTER-ENTITY VECTOR RELATIONS:")
+            sorted_relations = sorted(relations.items(), key=lambda x: x[1]['similarity'], reverse=True)
+            for (e1, e2), rel_data in sorted_relations[:5]:
+                sim = rel_data['similarity']
+                conflict_pot = rel_data['conflict_potential']
+                alliance_pot = rel_data['alliance_potential']
+                
+                # Classificazione relazione basata su metriche vettoriali
+                if alliance_pot > 0.3 and sim > 0.5:
+                    relation_type = "🤝 ALLIANCE"
+                elif conflict_pot > 0.4 and sim < 0.2:
+                    relation_type = "⚔️ ADVERSARIAL"
+                elif abs(rel_data['power_differential']) > 0.3:
+                    relation_type = "⚖️ ASYMMETRIC"
+                else:
+                    relation_type = "🔄 NEUTRAL"
+                
+                report_parts.append(f"  {e1} ↔ {e2}")
+                report_parts.append(f"    {relation_type} | cos(θ)={sim:.3f} | ∆P={rel_data['power_differential']:.3f}")
         report_parts.append("")
         
-        # Risk Assessment
-        report_parts.append("⚠️ RISK ASSESSMENT:")
-        for risk in ai_analysis['risk_assessment']:
-            report_parts.append(f"  {risk}")
+        # Contextual Transformations
+        report_parts.append("🔄 CONTEXTUAL MANIFOLD TRANSFORMATIONS:")
+        for context, transform_data in vector_analysis['contextual_transforms'].items():
+            entropy = transform_data['entropy']
+            norm = transform_data['norm']
+            
+            # Calcola divergenza dal vettore originale
+            divergence = np.linalg.norm(query_vector - transform_data['vector'])
+            
+            report_parts.append(f"  {context.replace('_', ' ').title()}:")
+            report_parts.append(f"    H(T(q)) = {entropy:.3f} | ∥T(q)∥ = {norm:.3f} | D_KL = {divergence:.3f}")
         report_parts.append("")
         
-        # Future Scenarios
-        report_parts.append("🔮 AI-GENERATED SCENARIOS:")
-        for scenario in ai_analysis['scenario_generation']:
-            report_parts.append(f"  {scenario}")
+        # Real-Time Vector Correlation
+        if real_time_data:
+            report_parts.append("📡 REAL-TIME VECTOR CORRELATION:")
+            correlations = []
+            
+            for news in real_time_data[:5]:
+                if 'vector' in news:
+                    correlation = np.dot(query_vector, news['vector'])
+                    correlations.append((news['title'][:50] + "...", correlation))
+            
+            sorted_correlations = sorted(correlations, key=lambda x: abs(x[1]), reverse=True)
+            for title, corr in sorted_correlations[:3]:
+                corr_intensity = "●" * int(abs(corr) * 15 + 1)
+                report_parts.append(f"  ρ={corr:.3f} {corr_intensity}")
+                report_parts.append(f"    {title}")
         report_parts.append("")
         
-        # Strategic Implications
-        report_parts.append("🎯 STRATEGIC IMPLICATIONS:")
-        for implication in ai_analysis['strategic_implications']:
-            report_parts.append(f"  {implication}")
+        # Mathematical Predictions
+        report_parts.append("🔮 MATHEMATICAL TRAJECTORY ANALYSIS:")
+        
+        # Calcola gradiente nel semantic space
+        gradient_vector = np.zeros(self.vector_dimensions)
+        for concept, projection in vector_analysis['semantic_projections'].items():
+            if abs(projection) > 0.2:  # Soglia significatività
+                gradient_vector += projection * self.semantic_space[concept]
+        
+        gradient_norm = np.linalg.norm(gradient_vector)
+        
+        if gradient_norm > 0.5:
+            report_parts.append("  📈 HIGH-GRADIENT TRAJECTORY: Sistema in evoluzione rapida")
+            report_parts.append(f"    ∇f = {gradient_norm:.3f} | Instabilità prevista")
+        elif gradient_norm > 0.2:
+            report_parts.append("  📊 MODERATE-GRADIENT: Evoluzione controllata")
+            report_parts.append(f"    ∇f = {gradient_norm:.3f} | Stabilità relativa")
+        else:
+            report_parts.append("  📉 LOW-GRADIENT: Sistema in equilibrio")
+            report_parts.append(f"    ∇f = {gradient_norm:.3f} | Convergenza locale")
+        
+        # Risk Assessment basato su metriche vettoriali
+        risk_metrics = self.calculate_vector_risk_metrics(vector_analysis, relations)
         report_parts.append("")
+        report_parts.append("⚠️ VECTOR-BASED RISK ASSESSMENT:")
+        report_parts.append(f"  Risk Magnitude: ∥R∥ = {risk_metrics['magnitude']:.3f}")
+        report_parts.append(f"  Entropy Level: H(R) = {risk_metrics['entropy']:.3f}")
+        report_parts.append(f"  Stability Index: σ = {risk_metrics['stability']:.3f}")
         
-        # Data Sources Footer
-        report_parts.append("📊 DATA PIPELINE:")
-        report_parts.append("  • Real-time RSS feeds (Reuters, BBC, UN)")
-        report_parts.append("  • World Bank economic indicators")
-        report_parts.append("  • NLP entity extraction")
-        report_parts.append("  • AI generative analysis")
-        report_parts.append("  • Pattern recognition algorithms")
+        # Footer metodologico
         report_parts.append("")
+        report_parts.append("📚 MATHEMATICAL FRAMEWORK:")
+        report_parts.append("  • High-dimensional semantic embedding (512D)")
+        report_parts.append("  • Manifold learning on geopolitical concepts")
+        report_parts.append("  • Real-time vector correlation analysis")
+        report_parts.append("  • Multi-contextual transformation matrices")
+        report_parts.append("  • Information-theoretic risk quantification")
         
-        report_parts.append(f"🔄 Next update: {(datetime.now() + timedelta(minutes=30)).strftime('%H:%M UTC')}")
+        report_parts.append(f"")
+        report_parts.append(f"🔄 Next vector update: {(datetime.now() + timedelta(minutes=30)).strftime('%H:%M UTC')}")
         
         return "\n".join(report_parts)
+    
+    def calculate_vector_risk_metrics(self, vector_analysis, relations):
+        """Calcola metriche di rischio basate su analisi vettoriale"""
+        
+        # Risk magnitude basato su proiezioni semantiche
+        conflict_indicators = ['conflict', 'military', 'power']
+        risk_magnitude = sum(abs(vector_analysis['semantic_projections'].get(indicator, 0)) 
+                           for indicator in conflict_indicators)
+        
+        # Entropy del sistema basata su trasformazioni contestuali
+        entropies = [transform['entropy'] for transform in vector_analysis['contextual_transforms'].values()]
+        system_entropy = np.mean(entropies) if entropies else 0
+        
+        # Stability index basato su varianza delle relazioni
+        if relations:
+            similarities = [rel['similarity'] for rel in relations.values()]
+            stability = 1.0 - np.var(similarities) if similarities else 1.0
+        else:
+            stability = 0.5
+        
+        return {
+            'magnitude': min(risk_magnitude, 1.0),
+            'entropy': system_entropy,
+            'stability': stability
+        }
 
-# Inizializza analyzer real-time
-analyzer = RealTimeGeopoliticalAnalyzer()
+# Inizializza il sistema AI vettoriale
+ai_system = VectorizedGeopoliticalAI()
 
-def analyze_real_time(user_query):
-    """Main function per Gradio con real-time data"""
+def analyze_vectorized(user_query):
+    """Funzione principale con analisi vettoriale matematica"""
     if not user_query.strip():
-        return "❌ Inserisci una query per l'analisi geopolitica real-time."
+        return "❌ Inserisci una query per l'analisi vettoriale geopolitica."
     
-    # Mostra loading message
-    loading_msg = "🔄 Recuperando dati real-time da fonti globali...\n⏳ Analisi AI in corso..."
+    # Recupera dati real-time e processa
+    real_time_data = ai_system.fetch_real_time_data()
     
-    return analyzer.analyze_geopolitical_situation(user_query)
+    # Analisi matematica completa
+    return ai_system.generate_mathematical_analysis(user_query, real_time_data)
 
-# Esempi con focus real-time
+# Esempi con focus su complessità matematica
 examples = [
-    "Analizza la situazione attuale in Ucraina e le implicazioni NATO",
-    "Tensioni USA-Cina: ultimi sviluppi e impatti commerciali", 
-    "Crisi energetica europea: dipendenza russa e alternative",
-    "Escalation Medio Oriente: Iran, Israele e equilibri regionali",
-    "BRICS expansion: sfida all'ordine occidentale?",
-    "Taiwan crisis: preparativi militari e deterrenza USA"
+    "Analizza la dinamica vettoriale del conflitto Russia-Ucraina",
+    "Proiezione multidimensionale delle tensioni USA-Cina", 
+    "Manifold geopolitico della crisi energetica europea",
+    "Trasformazioni contestuali delle alleanze NATO",
+    "Correlazioni vettoriali nell'instabilità mediorientale",
+    "Analisi del gradiente nelle relazioni Indo-Pacifiche"
 ]
 
-# Interface Gradio Real-Time
+# Interface con focus matematico
 demo = gr.Interface(
-    fn=analyze_real_time,
+    fn=analyze_vectorized,
     inputs=[
         gr.Textbox(
-            label="Geopolitical Query", 
-            placeholder="Es: Analizza gli ultimi sviluppi del conflitto in Ucraina e le reazioni internazionali...",
+            label="Geopolitical Vector Query", 
+            placeholder="Es: Analizza lo spazio vettoriale delle tensioni Taiwan-Cina nel manifold indo-pacifico...",
             lines=3
         )
     ],
     outputs=[
         gr.Textbox(
-            label="Real-Time Geopolitical Intelligence Report",
-            lines=30,
-            max_lines=40
+            label="Mathematical Geopolitical Analysis",
+            lines=35,
+            max_lines=45
         )
     ],
-    title="🌍 Real-Time Geopolitical Intelligence AI",
+    title="🧮 Vectorized Geopolitical Intelligence AI",
     description="""
-    **🚀 AI Geopolitica con dati real-time + analisi generativa**
+    **🚀 Analisi Geopolitica tramite Spazi Vettoriali Multidimensionali**
     
-    🔥 **Pipeline avanzata:**
-    • 📡 **Real-time data**: RSS feeds globali (Reuters, BBC, UN News)
-    • 🤖 **AI Generativa**: Analisi situazionale, trend, scenari futuri
-    • 🎯 **NLP avanzato**: Estrazione entità e pattern recognition
-    • ⚡ **Risk assessment**: Calcolo rischi e implicazioni strategiche
+    🔬 **Framework Matematico:**
+    • 📐 **Embedding Semantico**: 512-dimensional vector space
+    • 🌐 **Manifold Learning**: Proiezioni su sottospazi geopolitici
+    • 🔄 **Matrici di Trasformazione**: Analisi contestuali multiple
+    • 📊 **Correlazione Vettoriale**: Input real-time transformati
+    • ⚡ **Information Theory**: Risk assessment entropico
     
-    💡 **Capabilities:**
-    • Analisi situazioni in evoluzione con dati fresh
-    • Generazione scenari futuri AI-driven
-    • Assessment rischi geopolitici quantificati
-    • Intelligence strategica per decision makers
+    💡 **Advanced Capabilities:**
+    • Conversione linguaggio naturale → vettori multidimensionali
+    • Relazioni inter-entità calcolate in spazio astratto
+    • Gradient analysis per previsioni di traiettoria
+    • Metriche quantitative per assessment geopolitico
     
-    ⏱️ Dati aggiornati ogni 30 minuti da fonti pubbliche globali
+    🎯 **Output**: Analisi matematica rigorosa invece di template generici
     """,
     examples=examples,
-    theme=gr.themes.Base(),
+    theme=gr.themes.Monochrome(),
     css="""
     .gradio-container {
-        max-width: 1000px;
+        max-width: 1100px;
         margin: auto;
+        font-family: 'Courier New', monospace;
     }
     .description {
-        background: linear-gradient(90deg, #1e3c72, #2a5298);
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
         color: white;
-        padding: 20px;
-        border-radius: 10px;
+        padding: 25px;
+        border-radius: 15px;
     }
     """
 )