#!/usr/bin/env python3 """ Enhanced Validation Test for Quantum Photon Beam Simulator ========================================================== Independently validates simulation output against physics expectations. No hardcoded values — all thresholds computed from physical principles. """ import numpy as np import json import sys from quantum_simulator_enhanced import ( QuantumPhotonBeamSimulator, SimulationConfig, MaterialProperties, PhysicalConstants, SplitStepPropagator, MetricsCalculator, QuantumNoiseModel, NonlinearOpticsModel, CavityModel, CONST ) class ValidationTest: """Single validation test with pass/fail criteria.""" def __init__(self, name: str, description: str): self.name = name self.description = description self.passed = False self.value = None self.expected = None self.tolerance = None self.error = None self.details = {} def check(self, value, expected, tolerance, unit=""): """Check if value is within tolerance of expected.""" self.value = value self.expected = expected self.tolerance = tolerance if expected != 0: self.error = abs(value - expected) / abs(expected) else: self.error = abs(value - expected) self.passed = self.error <= tolerance status = "PASS" if self.passed else "FAIL" print(f" [{status}] {self.name}: {value:.4e} {unit}" f" (expected {expected:.4e}, error {self.error:.2e}," f" tol {tolerance:.2e})") return self.passed def check_bound(self, value, lower=None, upper=None, unit=""): """Check if value is within bounds.""" self.value = value in_lower = lower is None or value >= lower in_upper = upper is None or value <= upper self.passed = in_lower and in_upper bound_str = "" if lower is not None and upper is not None: bound_str = f"[{lower}, {upper}]" self.expected = f"{lower} to {upper}" elif lower is not None: bound_str = f">= {lower}" self.expected = f">= {lower}" elif upper is not None: bound_str = f"<= {upper}" self.expected = f"<= {upper}" status = "PASS" if self.passed else "FAIL" print(f" [{status}] {self.name}: {value:.4e} {unit}" f" (required {bound_str})") return self.passed class EnhancedValidationTester: """ Independent validation of the quantum photon beam simulator. Each test computes expected values from physics principles and compares against simulation output. No hardcoded values. """ def __init__(self): self.tests = [] self.config = SimulationConfig() self.material = MaterialProperties() def run_all(self): """Run complete validation suite.""" print("=" * 65) print(" ENHANCED VALIDATION TEST SUITE") print(" Independent Physics Verification") print("=" * 65) # Run the simulator print("\n Running quantum photon beam simulator...") simulator = QuantumPhotonBeamSimulator(self.config) results = simulator.run() print("\n" + "=" * 65) print(" INDEPENDENT VALIDATION TESTS") print("=" * 65) # Run all validation categories self.validate_beam_quality(results, simulator) self.validate_energy_conservation(results, simulator) self.validate_efficiency(results, simulator) self.validate_squeezing(results) self.validate_critical_power(results) self.validate_cavity_optics(results) self.validate_thermal(results, simulator) self.validate_fce_dynamics(results, simulator) self.validate_self_focusing(results) self.validate_dimensional_consistency(results) # Summary passed = sum(1 for t in self.tests if t.passed) total = len(self.tests) print(f"\n{'=' * 65}") print(f" VALIDATION SUMMARY: {passed}/{total} tests passed") print(f"{'=' * 65}") if passed == total: print(" Status: ALL TESTS PASSED") else: failed = [t for t in self.tests if not t.passed] print(f" Failed tests:") for t in failed: print(f" - {t.name}: {t.description}") # Generate report report = self._generate_report(results) with open('enhanced_validation_report.json', 'w') as f: json.dump(report, f, indent=2, default=self._json_convert) print(f"\n Report saved: enhanced_validation_report.json") return report def validate_beam_quality(self, results, simulator): """Validate M^2 beam quality measurement.""" print("\n --- Beam Quality ---") phys = results['physics_results'] # Test: M^2 >= 1.0 (Heisenberg uncertainty principle) t = ValidationTest("M2_heisenberg", "M^2 >= 1.0 by Heisenberg uncertainty") self.tests.append(t) M2 = phys['beam_quality_M2']['value'] t.check_bound(M2, lower=1.0, unit="(dimensionless)") # Test: M^2 < 2.0 for a well-corrected cavity beam t = ValidationTest("M2_reasonable", "M^2 < 2.0 for corrected beam") self.tests.append(t) t.check_bound(M2, upper=2.0, unit="(dimensionless)") # Test: Pure Gaussian should give M^2 ≈ 1.0 # (already validated by analytical tests, cross-check here) t = ValidationTest("M2_gaussian_crosscheck", "Independent Gaussian M^2 = 1.0") self.tests.append(t) prop = SplitStepPropagator(self.config, self.material) quantum = QuantumNoiseModel(self.config) metrics = MetricsCalculator(self.config, quantum) E_gauss = prop.initialize_gaussian() M2_gauss = metrics.compute_M_squared(E_gauss, prop.x, prop.dx) t.check(M2_gauss, 1.0, 0.01, "(dimensionless)") # Test: M^2 uncertainty is positive and reasonable t = ValidationTest("M2_uncertainty", "M^2 uncertainty is physically reasonable") self.tests.append(t) M2_unc = phys['beam_quality_M2']['uncertainty'] t.check_bound(M2_unc, lower=0.0, upper=1.0, unit="(dimensionless)") def validate_energy_conservation(self, results, simulator): """Validate energy conservation.""" print("\n --- Energy Conservation ---") eb = results['energy_balance'] # Test: Conservation error < 1e-6 (round-trip balance) t = ValidationTest("energy_conservation", "Round-trip energy conservation") self.tests.append(t) t.check_bound(eb['conservation_error'], upper=1e-6) # Test: Stored energy decreased (cavity decaying, not amplifying) t = ValidationTest("energy_decay", "Cavity energy decays (passive system)") self.tests.append(t) # With R1×R2 < 1, the cavity should lose energy per round-trip # (injection is small compared to OC transmission) t.check_bound(eb['stored_final_J'], upper=eb['stored_initial_J'] * 1.01) # Test: Output energy > 0 t = ValidationTest("output_positive", "Output energy is positive") self.tests.append(t) t.check_bound(eb['output_energy_J'], lower=0.0) def validate_efficiency(self, results, simulator): """Validate quantum efficiency.""" print("\n --- Efficiency ---") phys = results['physics_results'] # Test: η <= 1.0 for passive system (no gain medium) t = ValidationTest("efficiency_passive", "Efficiency <= 1.0 for passive system") self.tests.append(t) eta = phys['quantum_efficiency']['value'] t.check_bound(eta, upper=1.0 + 1e-6) # Test: η > 0 (some light gets through) t = ValidationTest("efficiency_positive", "Efficiency > 0 (some transmission)") self.tests.append(t) t.check_bound(eta, lower=0.0) # Test: η is reasonable for the cavity configuration # With coherent injection (constructive interference), the cavity # retains more power than the simple decay estimate (R1×R2)^N. # Steady-state: P_ss = T1×P_laser/(1-√(R1R2))² ≈ 30W for this cavity. # Starting at 20W (below steady state), power should stay high. # Use field amplitude model: E(n) = a^n × E(0) + b × (1-a^n)/(1-a) a = np.sqrt(self.config.R1 * self.config.R2) # RT field decay n_rt = self.config.n_roundtrips T1 = 1 - self.config.R1 # Amplitude ratio after n round-trips (injection + decay) # P(n)/P(0) ≈ (a^n + (1-a^n)/(1-a) × √(T1))² amp_ratio = a**n_rt + (1 - a**n_rt) / (1 - a) * np.sqrt(T1) expected_eta = amp_ratio**2 t = ValidationTest("efficiency_estimate", "Efficiency matches cavity field evolution model") self.tests.append(t) t.check(eta, expected_eta, 0.30, "(dimensionless)") def validate_squeezing(self, results): """Validate squeezing measurement.""" print("\n --- Squeezing ---") phys = results['physics_results'] # Without a parametric squeezing process (OPO, FWM), # squeezing should be near 0 dB (standard quantum limit) t = ValidationTest("squeezing_X_SQL", "X-quadrature near SQL (no parametric process)") self.tests.append(t) sq_X = phys['squeezing_X_dB']['value'] t.check(sq_X, 0.0, 3.0, "dB") # Within ±3 dB of SQL t = ValidationTest("squeezing_P_SQL", "P-quadrature near SQL (no parametric process)") self.tests.append(t) sq_P = phys['squeezing_P_dB']['value'] t.check(sq_P, 0.0, 3.0, "dB") # No impossible squeezing levels (> 15 dB requires extreme lab conditions) t = ValidationTest("squeezing_physical", "Squeezing level physically achievable") self.tests.append(t) t.check_bound(abs(sq_X), upper=15.0, unit="dB") def validate_critical_power(self, results): """Validate critical power calculation.""" print("\n --- Critical Power ---") phys = results['physics_results'] # Compute expected Marburger critical power independently lam = self.config.wavelength n0 = self.material.n0 n2 = self.material.n2 P_cr_expected = 3.77 * lam**2 / (8 * np.pi * n0 * n2) t = ValidationTest("critical_power_marburger", "P_cr matches Marburger formula") self.tests.append(t) P_cr = phys['critical_power_W']['value'] t.check(P_cr, P_cr_expected, 1e-6, "W") # Check order of magnitude: should be ~MW for fused silica at 450nm t = ValidationTest("critical_power_order", "P_cr is in MW range for fused silica") self.tests.append(t) t.check_bound(P_cr, lower=1e5, upper=1e7, unit="W") def validate_cavity_optics(self, results): """Validate cavity finesse and Q-factor.""" print("\n --- Cavity Optics ---") phys = results['physics_results'] # Independent finesse calculation R = np.sqrt(self.config.R1 * self.config.R2) F_expected = np.pi * np.sqrt(R) / (1 - R) t = ValidationTest("cavity_finesse", "Finesse matches F = pi*sqrt(R)/(1-R)") self.tests.append(t) t.check(phys['cavity_finesse']['value'], F_expected, 1e-6, "(dimensionless)") # Independent Q-factor calculation Q_expected = (2 * np.pi * self.material.n0 * self.config.cavity_length / (self.config.wavelength * (1 - R))) t = ValidationTest("cavity_Q", "Q-factor matches 2*pi*n*L/(lambda*(1-R))") self.tests.append(t) t.check(phys['cavity_Q_factor']['value'], Q_expected, 1e-6, "(dimensionless)") def validate_thermal(self, results, simulator): """Validate thermal model.""" print("\n --- Thermal ---") therm = results['thermal_results'] # For 20W beam with α = 1e-5/m over 0.5m, absorbed power is tiny # Temperature should barely change from ambient P_absorbed_est = self.config.power * self.material.alpha_abs * self.config.cavity_length # P_absorbed ~ 20 × 1e-5 × 0.5 = 1e-4 W — negligible heating t = ValidationTest("thermal_near_ambient", "Temperature near ambient (tiny absorption)") self.tests.append(t) t.check(therm['final_temperature_K'], 293.15, 0.01, "K") # Stability should be very small t = ValidationTest("thermal_stability", "Temperature stability (std) is small") self.tests.append(t) t.check_bound(therm['stability_K'], upper=1.0, unit="K") # No runaway heating t = ValidationTest("thermal_no_runaway", "No thermal runaway (T < 500K)") self.tests.append(t) t.check_bound(therm['max_temperature_K'], upper=500.0, unit="K") def validate_fce_dynamics(self, results, simulator): """Validate Fractal Correction Engine dynamics.""" print("\n --- FCE Dynamics ---") fce = results['fce_results'] # Lorenz attractor: state should be near one of the fixed points # C+ ≈ (8.485, 8.485, 27.0) or C- ≈ (-8.485, -8.485, 27.0) sigma, rho, beta = 10.0, 28.0, 8.0/3.0 x_eq = np.sqrt(beta * (rho - 1)) # ≈ 8.485 z_eq = rho - 1 # = 27.0 final = fce['lorenz_state_final'] dist_Cplus = np.sqrt((final[0]-x_eq)**2 + (final[1]-x_eq)**2 + (final[2]-z_eq)**2) dist_Cminus = np.sqrt((final[0]+x_eq)**2 + (final[1]+x_eq)**2 + (final[2]-z_eq)**2) min_dist = min(dist_Cplus, dist_Cminus) t = ValidationTest("fce_near_fixed_point", "Lorenz state near C+ or C- fixed point") self.tests.append(t) t.check_bound(min_dist, upper=5.0, unit="(Lorenz units)") t.details = {'dist_C+': dist_Cplus, 'dist_C-': dist_Cminus} # Lyapunov exponent should be positive (chaotic) # Lorenz attractor has λ₁ ≈ 0.906 for standard parameters t = ValidationTest("fce_lyapunov_positive", "Positive Lyapunov exponent (chaotic dynamics)") self.tests.append(t) t.check_bound(fce['lyapunov_exponent'], lower=0.0, unit="(1/Lorenz time)") # Fractal dimension should be between 1 and 3 # Lorenz attractor theoretical: D ≈ 2.06 t = ValidationTest("fce_fractal_dimension", "Fractal dimension in [1, 3]") self.tests.append(t) t.check_bound(fce['fractal_dimension'], lower=1.0, upper=3.0, unit="(dimensionless)") # Trajectory should have enough points for dynamics to develop t = ValidationTest("fce_trajectory_length", "Sufficient trajectory for dynamics") self.tests.append(t) t.check_bound(float(fce['trajectory_points']), lower=50.0, unit="points") # Curvature should be positive (trajectory is not a straight line) t = ValidationTest("fce_curvature_positive", "Positive mean curvature (nontrivial trajectory)") self.tests.append(t) t.check_bound(fce['curvature_mean'], lower=0.0, unit="(1/Lorenz length)") def validate_self_focusing(self, results): """Validate self-focusing analysis.""" print("\n --- Self-Focusing ---") phys = results['physics_results'] # At 20W, P/P_cr should be << 1 (far below self-focusing) t = ValidationTest("self_focusing_negligible", "P/P_cr << 1 (no self-focusing at 20W)") self.tests.append(t) ratio = phys['self_focusing_ratio']['value'] t.check_bound(ratio, upper=0.01, unit="(dimensionless)") # Independent calculation P_cr = phys['critical_power_W']['value'] expected_ratio = self.config.power / P_cr t = ValidationTest("self_focusing_ratio_check", "P/P_cr matches P_laser / P_cr") self.tests.append(t) t.check(ratio, expected_ratio, 1e-6, "(dimensionless)") def validate_dimensional_consistency(self, results): """Check dimensional consistency of all output values.""" print("\n --- Dimensional Consistency ---") phys = results['physics_results'] # All physical values should be finite t = ValidationTest("no_nan_inf", "No NaN or Inf in physics results") self.tests.append(t) all_finite = True for key, val in phys.items(): if isinstance(val, dict) and 'value' in val: v = val['value'] if not np.isfinite(v): all_finite = False t.details[key] = v t.passed = all_finite status = "PASS" if t.passed else "FAIL" print(f" [{status}] {t.name}: {'all finite' if all_finite else 'contains NaN/Inf'}") # Kerr phase should be positive and small t = ValidationTest("kerr_phase_positive", "Kerr phase is positive and small") self.tests.append(t) kerr = phys['kerr_phase_accumulated_rad']['value'] t.check_bound(kerr, lower=0.0, upper=1.0, unit="rad") # Decoherence time should be positive t = ValidationTest("decoherence_positive", "Decoherence time is positive and finite") self.tests.append(t) T_coh = phys['decoherence_time_s']['value'] t.check_bound(T_coh, lower=0.0, unit="s") def _generate_report(self, results): """Generate comprehensive validation report.""" phys = results['physics_results'] fce = results['fce_results'] therm = results['thermal_results'] eb = results['energy_balance'] passed = sum(1 for t in self.tests if t.passed) total = len(self.tests) report = { "validation_summary": { "tests_passed": passed, "tests_total": total, "pass_rate": passed / total if total > 0 else 0, "status": "ALL PASSED" if passed == total else "SOME FAILED" }, "test_results": { t.name: { "passed": t.passed, "description": t.description, "value": t.value, "expected": t.expected, "error": t.error } for t in self.tests }, "physics_validation": { "beam_quality": { "M2": phys['beam_quality_M2']['value'], "M2_uncertainty": phys['beam_quality_M2']['uncertainty'], "heisenberg_satisfied": phys['beam_quality_M2']['value'] >= 1.0, "diffraction_limited": phys['beam_quality_M2']['value'] < 1.2 }, "energy_conservation": { "conservation_error": eb['conservation_error'], "input_energy_J": eb['input_energy_J'], "output_energy_J": eb['output_energy_J'], "loss_energy_J": eb['loss_energy_J'] }, "quantum_state": { "squeezing_X_dB": phys['squeezing_X_dB']['value'], "squeezing_P_dB": phys['squeezing_P_dB']['value'], "state": "coherent (SQL)" if abs(phys['squeezing_X_dB']['value']) < 3 else "non-classical" }, "nonlinear_optics": { "P_cr_W": phys['critical_power_W']['value'], "self_focusing_ratio": phys['self_focusing_ratio']['value'], "kerr_phase_rad": phys['kerr_phase_accumulated_rad']['value'], "regime": "linear" if phys['self_focusing_ratio']['value'] < 0.01 else "nonlinear" } }, "fce_validation": { "lorenz_near_equilibrium": fce['lorenz_state_final'], "lyapunov_exponent": fce['lyapunov_exponent'], "fractal_dimension": fce['fractal_dimension'], "dynamics_developed": fce['trajectory_points'] > 50 }, "thermal_validation": { "final_temperature_K": therm['final_temperature_K'], "stability_K": therm['stability_K'], "ambient_K": therm['ambient_K'], "thermally_stable": abs(therm['final_temperature_K'] - therm['ambient_K']) < 1.0 } } return report @staticmethod def _json_convert(obj): """Convert numpy types for JSON serialization.""" if isinstance(obj, (np.integer,)): return int(obj) elif isinstance(obj, (np.floating,)): return float(obj) elif isinstance(obj, np.ndarray): return obj.tolist() elif isinstance(obj, np.bool_): return bool(obj) return str(obj) def main(): tester = EnhancedValidationTester() report = tester.run_all() # Exit with non-zero code if any tests failed passed = report['validation_summary']['tests_passed'] total = report['validation_summary']['tests_total'] sys.exit(0 if passed == total else 1) if __name__ == "__main__": main()