# Integrazione GPT – Generazione Automatica delle Φ
"""
Funzionalità sperimentale: generazione automatica di trasformazioni Φ_{ijkl} a partire da testo naturale, utilizzando modelli GPT.
Attualmente implementata come placeholder tramite matching lessicale su keyword.
"""

import random
import numpy as np
from scipy.spatial.distance import directed_hausdorff

try:
   import matplotlib.pyplot as plt
except ImportError:
   import subprocess
   import sys
   subprocess.check_call([sys.executable, '-m', 'pip', 'install', 'matplotlib'])
   import matplotlib.pyplot as plt

def generate_phi_from_text(prompt_text):
   def phi_generated(z, P=complex(0.5, 0.5), lambda_linear=0.1):
       if "opposti" in prompt_text and "attrazione" in prompt_text:
           return P + lambda_linear * (z - P)
       elif "riflessione" in prompt_text:
           return P - z
       elif "espansione" in prompt_text:
           return z * (1 + lambda_linear)
       else:
           return z
   return Transformation(phi_generated)

def map_semantic_trajectory(concepts):
   semantic_map = set()
   angle_step = 2 * np.pi / len(concepts)
   radius = 1.0
   for i, concept in enumerate(concepts):
       angle = i * angle_step
       point = radius * np.exp(1j * angle)
       semantic_map.add(point)
   return semantic_map

class SystemParameters:
   def __init__(self, iterations=10000, transition_threshold=0.005, lambda_linear=0.1,
                P=complex(0.5, 0.5), alpha=0.4, beta=0.4, gamma=0.2, blend_iterations=5,
                scale_factor_A=0.5, scale_factor_B=0.5, offset_A=1j, offset_B=1):
       self.iterations = iterations
       self.transition_threshold = transition_threshold
       self.lambda_linear = lambda_linear
       self.P = P
       self.alpha = alpha
       self.beta = beta
       self.gamma = gamma
       self.blend_iterations = blend_iterations
       self.scale_factor_A = scale_factor_A
       self.scale_factor_B = scale_factor_B
       self.offset_A = offset_A
       self.offset_B = offset_B

class Transformation:
   def __init__(self, func, **kwargs):
       self.func = func
       self.kwargs = kwargs

   def apply(self, z):
       return self.func(z, **self.kwargs)

class DNDTensorField:
   def __init__(self, params):
       self.params = params
       self.R = {complex(0, 0)}
       self.all_points = set(self.R)
       self.linear_phase = True
       self.blend_phase = False
       self.blend_counter = 0
       self.generated_phi = []

   def T_A(self, z):
       return z * self.params.scale_factor_A + self.params.offset_A

   def T_B(self, z):
       return (z + self.params.offset_B) * self.params.scale_factor_B

   def run_linear_phase(self):
       R_next = {z + self.params.lambda_linear * (self.params.P - z) for z in self.R}
       self.all_points.update(R_next)
       self.R = R_next

   def run_fractal_phase(self):
       R_next = set()
       for z in self.R:
           if random.random() < 0.5:
               R_next.add(self.T_A(z))
           else:
               R_next.add(self.T_B(z))
       self.all_points.update(R_next)
       self.R = R_next

   def run_blended_phase(self):
       linear_R = {z + self.params.lambda_linear * (self.params.P - z) for z in self.R}
       fractal_R = set()
       for z in self.R:
           if random.random() < 0.5:
               fractal_R.add(self.T_A(z))
           else:
               fractal_R.add(self.T_B(z))
       blend_factor = self.blend_counter / max(1, self.params.blend_iterations)
       blended_R = set()
       for z in linear_R:
           if random.random() < blend_factor:
               blended_R.add(z)
       for z in fractal_R:
           if random.random() < (1 - blend_factor):
               blended_R.add(z)
       self.all_points.update(blended_R)
       self.R = blended_R
       self.blend_counter += 1

   def add_phi_from_prompt(self, prompt):
       phi = generate_phi_from_text(prompt)
       self.generated_phi.append(phi)

   def run_generated_phase(self):
       R_next = set()
       for phi in self.generated_phi:
           R_next.update({phi.apply(z) for z in self.R})
       self.all_points.update(R_next)
       self.R = R_next

   def is_stable_hausdorff(self, R_t, R_t1):
       try:
           R_t_arr = np.array([(z.real, z.imag) for z in R_t])
           R_t1_arr = np.array([(z.real, z.imag) for z in R_t1])
           if len(R_t_arr) == 0 or len(R_t1_arr) == 0:
               return False
           dist1 = directed_hausdorff(R_t_arr, R_t1_arr)[0]
           dist2 = directed_hausdorff(R_t1_arr, R_t_arr)[0]
           return max(dist1, dist2) < self.params.transition_threshold
       except:
           return False

   def run(self):
       for t in range(self.params.iterations):
           prev_R = self.R.copy()
           if self.linear_phase:
               self.run_linear_phase()
               if self.is_stable_hausdorff(prev_R, self.R):
                   self.linear_phase = False
                   self.blend_phase = True
           elif self.blend_phase and self.blend_counter < self.params.blend_iterations:
               self.run_blended_phase()
           elif self.generated_phi:
               self.run_generated_phase()
           else:
               self.run_fractal_phase()

   def visualize_tensor(self):
       x_vals = [z.real for z in self.all_points]
       y_vals = [z.imag for z in self.all_points]
       plt.figure(figsize=(8, 8))
       plt.scatter(x_vals, y_vals, s=1, color="blue")
       plt.title("DNDTensorField – Mappa del Campo Tensoriale")
       plt.xlabel("Re(z)")
       plt.ylabel("Im(z)")
       plt.grid(True)
       plt.show()

# Risultante del Modulo `DNDTensorField` come Osservatore Logico

## Equazione Cardine
R(t+1) = min_{Φ_{ijkl}} [Σ T_{ijkl} · Φ_{ijkl}(A_i, B_j, P_k, λ_l, O)] → R*

## Descrizione
Il sistema genera una Risultante R* come configurazione minima coerente nel Continuum NT, osservata attraverso l’evoluzione di trasformazioni Φ modulari. Ogni Φ rappresenta un’interazione assiomatica tra elementi del modello D-ND (A, B, P), modulata da curvatura λ e osservatore O.

## Significati Informazionali
- Φ_{ijkl} → Operatore assiomatico modulare
- T_{ijkl} → Densità logica nel campo osservato
- Cluster → Zone ad alta coerenza (verità locali)
- Re(z), Im(z) → Coordinate assiomatiche nel piano logico
- R* → Output autologico, sintesi emergente coerente