# Suprimăm mesajele TensorFlow import os import warnings os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2' warnings.filterwarnings('ignore') import numpy as np from scipy.constants import c, h, hbar from typing import Tuple, List import matplotlib.pyplot as plt def get_validated_input(prompt: str, default_val: float, min_val: float = 0, unit: str = "") -> float: """Obține și validează input-ul utilizatorului cu valoare implicită""" while True: try: val = input(f"{prompt} [{unit}] (implicit: {default_val} {unit}): ").strip() if val == "": return default_val val = float(val) if val >= min_val: return val print(f"Eroare: Valoarea trebuie să fie cel puțin {min_val}") except ValueError: print("Eroare: Introduceți un număr valid") def ascii_to_binary(text: str) -> str: """Convertește text ASCII în secvență binară""" return ''.join(format(ord(char), '08b') for char in text) def binary_to_ascii(binary: str) -> str: """Convertește secvență binară în text ASCII""" if len(binary) % 8 != 0: binary = binary.zfill(((len(binary) // 8) + 1) * 8) return ''.join(chr(int(binary[i:i+8], 2)) for i in range(0, len(binary), 8)) def flip_bits(binary: str) -> str: """Inversează toți biții din secvența binară""" return ''.join('1' if bit == '0' else '0' for bit in binary) class RetrocausalQuantumChannel: def __init__(self, config: dict): # Parametri fizici self.FIBER_LENGTH = config['fiber_length'] * 1000 self.REFRACTIVE_INDEX = config['refractive_index'] self.WAVELENGTH = config['wavelength'] * 1e-9 self.BBO_EFFICIENCY = config['bbo_efficiency'] self.PUMP_POWER = config['pump_power'] # Parametri optimizare self.MEASUREMENT_SAMPLES = config['measurement_samples'] self.NOISE_REDUCTION = config['noise_reduction'] self.DETECTION_THRESHOLD = config['detection_threshold'] self.ITERATIONS = config['iterations'] def calculate_propagation_time(self) -> float: """Calculează timpul de propagare prin fibră""" return self.FIBER_LENGTH * self.REFRACTIVE_INDEX / c def wavefunction_bbo(self, t: float) -> np.ndarray: """Generează funcția de undă pentru perechea de fotoni înlănțuiți""" E_photon = h * c / self.WAVELENGTH phase = E_photon * t / hbar return np.array([ [0], [1/np.sqrt(2) - 0.1j], [-1/np.sqrt(2) - 0.1j], [0] ]) * np.exp(1j * phase) def retrocausal_propagator(self, t: float) -> np.ndarray: """Calculează propagatorul retrocauzal""" t_fiber = self.calculate_propagation_time() phase_correction = np.exp(-1j * np.pi/4) return np.array([ [np.exp(1j * t/t_fiber) * phase_correction, 0, 0, 0], [0, np.exp(-1j * t/t_fiber) * phase_correction, 0, 0], [0, 0, np.exp(-1j * t/t_fiber) * phase_correction, 0], [0, 0, 0, np.exp(1j * t/t_fiber) * phase_correction] ]) def measure_with_averaging(self, psi_final: np.ndarray, bit: str) -> float: """Realizează măsurători multiple""" probabilities = [] for _ in range(self.MEASUREMENT_SAMPLES): if bit == '0': prob = float(np.abs(psi_final[1][0])**2) else: prob = float(np.abs(psi_final[2][0])**2) quantum_noise = float(np.random.normal(0, self.NOISE_REDUCTION)) prob = min(1.0, max(0.0, prob + quantum_noise)) probabilities.append(prob) probabilities.sort() filtered_probs = probabilities[1:-1] if len(probabilities) > 2 else probabilities return np.mean(filtered_probs) def simulate_transmission(self, message: str, detection_window: float = 50e-6) -> Tuple[str, List[float]]: """Simulează transmisia retrocauzală""" received_bits = [] detection_probabilities = [] t_fiber = self.calculate_propagation_time() print(f"\nTimp propagare prin fibră: {t_fiber*1e6:.2f} μs") for i, bit in enumerate(message): t_detection = -detection_window accumulated_prob = 0 for _ in range(self.ITERATIONS): psi_0 = self.wavefunction_bbo(t_detection) U = self.retrocausal_propagator(t_detection) psi_final = U @ psi_0 detection_prob = self.measure_with_averaging(psi_final, bit) accumulated_prob += detection_prob final_prob = accumulated_prob / self.ITERATIONS threshold = self.DETECTION_THRESHOLD + 0.02 if bit == '0' else self.DETECTION_THRESHOLD - 0.02 received_bit = '0' if final_prob > threshold else '1' print(f"\nBit {i+1} din {len(message)}:") print(f"t = {t_detection*1e6:.1f}μs: Detecție retrocauzală") print(f"t = 0μs: Transmisie") print(f"Probabilitate detecție: {final_prob:.3f}") print(f"Bit transmis: {bit} -> Bit detectat: {received_bit}") received_bits.append(received_bit) detection_probabilities.append(final_prob * 100) return ''.join(received_bits), detection_probabilities def plot_results(self, message: str, probabilities: List[float]): """Vizualizează rezultatele transmisiei""" fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 8)) times = np.linspace(-50, 0, len(message)) ax1.plot(times, probabilities, 'bo-', label='Probabilitate detecție') ax1.axvline(x=-50, color='r', linestyle='--', label='Moment detecție') ax1.axvline(x=0, color='g', linestyle='--', label='Moment transmisie') ax1.set_xlabel('Timp (μs)') ax1.set_ylabel('Probabilitate (%)') ax1.set_title('Probabilități Detecție Retrocauzală') ax1.grid(True) ax1.legend() x = np.arange(len(message)) width = 0.35 ax2.bar(x - width/2, [int(b) for b in message], width, label='Biți transmiși', color='blue', alpha=0.5) ax2.bar(x + width/2, [p/100 for p in probabilities], width, label='Prob. detecție', color='red', alpha=0.5) ax2.set_xlabel('Poziție bit') ax2.set_ylabel('Valoare') ax2.set_title('Comparație Biți vs. Probabilități') ax2.legend() plt.tight_layout() plt.show() def get_default_config(): """Returnează configurația implicită""" return { 'fiber_length': 10.0, 'refractive_index': 1.5, 'wavelength': 702, 'bbo_efficiency': 2.73e5, 'pump_power': 1e-3, 'measurement_samples': 5, 'noise_reduction': 0.05, 'detection_threshold': 0.5, 'iterations': 3 } def print_parameter_description(param_name: str, description: str, default_val: float, unit: str = ""): """Afișează descrierea formatată a unui parametru""" print(f"\n{param_name}:") for line in description.split('\n'): print(f" {line}") print(f" Valoare implicită: {default_val} {unit}") def main(): print("Experiment de Comunicare Cuantică Retrocauzală") print("=" * 45) print("\nAcest program simulează transmisia retrocauzală de informație") print("folosind fotoni înlănțuiți, conform experimentului din document.") config = get_default_config() print("\nPARAMETRI FIZICI:") print("-" * 20) print_parameter_description( "1. Lungimea fibrei optice", "Determină distanța de propagare a fotonilor.\n" + "Afectează timpul de propagare și pierderile în fibră.\n" + "Valoarea din experimentul original: 10 km", config['fiber_length'], "km" ) config['fiber_length'] = get_validated_input( "Introduceți lungimea fibrei", config['fiber_length'], 0.1, "km") print_parameter_description( "2. Lungimea de undă", "Caracterizează fotonii folosiți în experiment.\n" + "Afectează energia fotonilor și eficiența detecției.\n" + "Experimentul original folosește 702 nm (infraroșu apropiat)", config['wavelength'], "nm" ) config['wavelength'] = get_validated_input( "Introduceți lungimea de undă", config['wavelength'], 100, "nm") print("\nPARAMETRI OPTIMIZARE:") print("-" * 20) print_parameter_description( "1. Măsurători per bit", "Numărul de măsurători efectuate pentru fiecare bit.\n" + "Mai multe măsurători cresc acuratețea dar și timpul de procesare.", config['measurement_samples'] ) config['measurement_samples'] = int(get_validated_input( "Introduceți numărul de măsurători", config['measurement_samples'], 1)) print_parameter_description( "2. Iterații per măsurătoare", "De câte ori se repetă procesul pentru fiecare măsurătoare.\n" + "Mai multe iterații oferă rezultate mai stabile.", config['iterations'] ) config['iterations'] = int(get_validated_input( "Introduceți numărul de iterații", config['iterations'], 1)) print_parameter_description( "3. Factor reducere zgomot", "Controlează nivelul de zgomot cuantic permis.\n" + "Valori mai mici înseamnă mai puțin zgomot și transmisie mai stabilă.", config['noise_reduction'] ) config['noise_reduction'] = get_validated_input( "Introduceți factorul de reducere", config['noise_reduction'], 0.01) channel = RetrocausalQuantumChannel(config) ascii_message = input("\nIntroduceți mesajul ASCII: ") binary_message = ascii_to_binary(ascii_message) print(f"\nMesaj ASCII: {ascii_message}") print(f"Mesaj binar: {binary_message}") print("\nÎncepere simulare transmisie retrocauzală...") received_binary, probabilities = channel.simulate_transmission(binary_message) print("\nREZULTATE FINALE:") print("=" * 20) print(f"Mesaj ASCII transmis: {ascii_message}") # Procesăm și afișăm ambele variante received_ascii_normal = binary_to_ascii(received_binary) received_ascii_flipped = binary_to_ascii(flip_bits(received_binary)) print("\nVarianta 1 (biți primiți direct):") print(f"Mesaj binar: {received_binary}") print(f"Mesaj ASCII: {received_ascii_normal}") print("\nVarianta 2 (biți inversați):") print(f"Mesaj binar: {flip_bits(received_binary)}") print(f"Mesaj ASCII: {received_ascii_flipped}") print("\nMesaj binar transmis: {binary_message}") print(f"Număr total biți: {len(binary_message)}") # Calculăm acuratețea pentru ambele variante correct_bits_normal = sum(1 for a, b in zip(binary_message, received_binary) if a == b) correct_bits_flipped = sum(1 for a, b in zip(binary_message, flip_bits(received_binary)) if a == b) accuracy_normal = (correct_bits_normal / len(binary_message)) * 100 accuracy_flipped = (correct_bits_flipped / len(binary_message)) * 100 print(f"\nAcuratețe varianta 1: {accuracy_normal:.2f}%") print(f"Acuratețe varianta 2: {accuracy_flipped:.2f}%") print(f"Probabilitate medie: {np.mean(probabilities):.2f}%") channel.plot_results(binary_message, probabilities) if __name__ == "__main__": main()