diff --git a/examples/black_hole.py b/examples/black_hole.py index a2ab6a8..99a2f5e 100644 --- a/examples/black_hole.py +++ b/examples/black_hole.py @@ -26,6 +26,7 @@ from constants import CONSTANTS from core.state import QuantumState from physics.verification import UnifiedTheoryVerification +from physics.observables import compute_black_hole_entropy from utils.io import QuantumGravityIO, MeasurementResult from matplotlib.gridspec import GridSpec @@ -665,7 +666,7 @@ def run_simulation(self, t_final: float) -> None: # Calculate derived quantities horizon_radius = 2 * CONSTANTS['G'] * self.qg.state.mass - entropy = np.pi * horizon_radius**2 / (4 * CONSTANTS['l_p']**2) + entropy = compute_black_hole_entropy(horizon_radius, include_log_correction=False) # Calculate temperature diff --git a/physics/models/dark_matter.py b/physics/models/dark_matter.py index 1476f4d..2cc372f 100644 --- a/physics/models/dark_matter.py +++ b/physics/models/dark_matter.py @@ -2,16 +2,23 @@ from constants import CONSTANTS, SI_UNITS from physics.quantum_geometry import QuantumGeometry +# v7 Holographic Fisher Geometry parameters +# γ₀ = 0.274 (Immirzi parameter from LQG, Meissner 2004) +# Dark matter ratio M_DM/M_b = π/(2γ₀) ≈ 5.73 +GAMMA_0 = CONSTANTS.get('gamma_0', 0.274) +DM_RATIO_V7 = CONSTANTS.get('dm_ratio_v7', np.pi / (2 * GAMMA_0)) + + class DarkMatterAnalysis: - def __init__(self, + def __init__(self, observed_mass: float, - total_mass: float, + total_mass: float, radius: float, velocity_dispersion: float, dark_mass: float = None, visible_mass: float = None): self.observed_mass = observed_mass # Solar masses - self.total_mass = total_mass # Solar masses + self.total_mass = total_mass # Solar masses self.radius = radius # Light years self.visible_mass = visible_mass # Solar masses self.velocity_dispersion = velocity_dispersion # km/s @@ -19,6 +26,9 @@ def __init__(self, # Initialize quantum geometry self.qg = QuantumGeometry() + # v7 Immirzi parameter + self.gamma_0 = GAMMA_0 + # Compute quantum parameters from cluster properties self.beta = self._compute_beta() self.gamma_eff = self._compute_gamma() @@ -37,29 +47,33 @@ def _compute_beta(self): return (1/M_scale) * np.exp(-r_scale/self.qg.phi) def _compute_gamma_parameter(self): - """Compute quantum geometric coupling gamma""" - qg = QuantumGeometry() + """Compute quantum geometric coupling gamma using v7 formulation.""" beta = self.compute_beta_parameter() - - # γ = φ⁻¹β√(Λ/24) - gamma = (1/qg.phi) * beta * np.sqrt(qg.Lambda/24) - + + # v7 formulation: γ_eff = γ₀ × (1 + β²) + # where γ₀ = 0.274 is the Immirzi parameter + gamma = self.gamma_0 * (1 + beta**2) + return gamma def _compute_gamma(self): - """Compute quantum geometric coupling gamma""" - qg = QuantumGeometry() + """Compute quantum geometric coupling gamma using v7 formulation.""" beta = self.compute_beta_parameter() - - # γ = φ⁻¹β√(Λ/24) - gamma = (1/qg.phi) * beta * np.sqrt(qg.Lambda/24) - + + # v7 formulation: γ_eff = γ₀ × (1 + β²) + gamma = self.gamma_0 * (1 + beta**2) + return gamma def compute_geometric_enhancement(self): - leech_factor = np.sqrt(196560/24) - # Apply precise normalization - return leech_factor * (1 - 5e-3) # Within 0.5% of expected value + """ + Compute geometric enhancement factor for dark matter. + + v7 formulation: M_DM/M_b = π/(2γ₀) ≈ 5.73 + This replaces the deprecated Leech lattice formula √(196560/24). + """ + # v7 dark matter ratio from Immirzi parameter + return DM_RATIO_V7 def compare_with_observations(self): @@ -78,21 +92,31 @@ def compute_dark_matter_ratio(self): return (self.total_mass - self.visible_mass) / self.visible_mass def quantum_nfw_profile(self, r): - """Q(r) = 1 + c(M)exp(-r/(rs×φ))√(Λ/(24×φ))""" + """ + Quantum-corrected NFW profile using v7 formulation. + + Q(r) = 1 + c(M) × exp(-r/(rs×φ)) × γ₀ + where γ₀ = 0.274 is the Immirzi parameter. + """ rs = self.scale_radius mass_coupling = self.compute_mass_coupling() - - quantum_term = mass_coupling * np.exp(-r/(rs*self.phi)) - geometric_factor = np.sqrt(self.Lambda/(24*self.phi)) - + phi = (1 + np.sqrt(5)) / 2 + + quantum_term = mass_coupling * np.exp(-r / (rs * phi)) + # v7: use γ₀ instead of √(Λ/(24×φ)) + geometric_factor = self.gamma_0 + return 1 + quantum_term * geometric_factor def _compute_geometric_entanglement(self): - """Scale geometric entanglement to match 0.4 threshold""" - qg = QuantumGeometry() + """ + Compute geometric entanglement using v7 formulation. + + v7: E = β × γ₀ (replaces β × √(Λ/24)) + """ beta = self._compute_beta() - lattice_factor = np.sqrt(qg.Lambda/24) - return beta * lattice_factor * 0.4 + # v7 formulation: use γ₀ instead of Leech lattice factor + return beta * self.gamma_0 * 0.4 def quantum_correction_factor(self): """Calculate quantum correction factor for geometric enhancement""" diff --git a/physics/observables.py b/physics/observables.py index 31d5ce4..4f33788 100644 --- a/physics/observables.py +++ b/physics/observables.py @@ -13,6 +13,46 @@ from utils.io import MeasurementResult import cProfile + +def compute_black_hole_entropy(horizon_radius: float, include_log_correction: bool = False) -> float: + """ + Compute black hole entropy using Bekenstein-Hawking formula with optional LQG correction. + + Leading order (Bekenstein-Hawking): + S = A/(4*l_p²) = 4πr_h²/(4*l_p²) = πr_h²/l_p² + + With LQG logarithmic correction (Meissner 2004, Kaul-Majumdar 2000): + S = A/(4*l_p²) - (1/2)*ln(A/l_p²) + + The logarithmic correction arises from quantum corrections to the area spectrum + in Loop Quantum Gravity and becomes significant for Planck-scale black holes. + + Args: + horizon_radius: Schwarzschild radius r_h = 2GM/c² + include_log_correction: If True, include the LQG logarithmic correction + + Returns: + Black hole entropy in units of k_B (Boltzmann constant) + """ + l_p_sq = CONSTANTS['l_p']**2 + + # Horizon area A = 4π*r_h² + area = 4 * np.pi * horizon_radius**2 + + # Leading order Bekenstein-Hawking entropy: S = A/(4*l_p²) = πr_h²/l_p² + entropy = area / (4 * l_p_sq) + + if include_log_correction: + # LQG logarithmic correction: -½ ln(A/l_p²) + # This correction is derived from microstate counting in LQG + area_ratio = area / l_p_sq + if area_ratio > 1.0: # Only apply for macroscopic black holes + log_correction = -0.5 * np.log(area_ratio) + entropy += log_correction + + return entropy + + class Observable(ABC): """Base class for quantum gravity observables.""" @@ -1915,7 +1955,7 @@ class RadiationEntropyObservable(Observable): - G_μν^Fisher of radiation encodes recovered information """ - def __init__(self, grid, initial_entropy: float = None): + def __init__(self, grid, initial_entropy: float = None, include_log_correction: bool = False): """ Initialize radiation entropy observable. @@ -1923,9 +1963,12 @@ def __init__(self, grid, initial_entropy: float = None): grid: Computational grid initial_entropy: Initial black hole entropy S_BH(0). If None, will be set on first measurement. + include_log_correction: If True, use LQG logarithmic correction to entropy. + Default False for backward compatibility. """ super().__init__(grid) self.initial_entropy = initial_entropy + self.include_log_correction = include_log_correction self.page_time = None self._max_radiation_entropy = 0.0 self._max_entropy_time = None @@ -1945,9 +1988,9 @@ def measure(self, state) -> 'MeasurementResult': Returns: MeasurementResult with radiation entropy value """ - # Get current black hole entropy + # Get current black hole entropy using utility function horizon_radius = 2 * CONSTANTS['G'] * state.mass - current_entropy = np.pi * horizon_radius**2 / (4 * CONSTANTS['l_p']**2) + current_entropy = compute_black_hole_entropy(horizon_radius, self.include_log_correction) # Set initial entropy on first call if self.initial_entropy is None: diff --git a/tests/test_black_hole_simulation.py b/tests/test_black_hole_simulation.py index 1e901cc..6ff5ef2 100644 --- a/tests/test_black_hole_simulation.py +++ b/tests/test_black_hole_simulation.py @@ -166,11 +166,11 @@ def test_information_conservation(self): self.default_sim.run_simulation(t_final=10.0) initial_entropy = self.default_sim.entropy_history[0] final_entropy = self.default_sim.entropy_history[-1] - + # As black hole evaporates, entropy decreases due to mass loss self.assertLess(final_entropy, initial_entropy) - # Verify entropy scales with area using correct factor - expected_entropy = np.pi * self.default_mass**2 + # Verify entropy scales with area: S = A/(4l_p²) = 4*pi*M² in Planck units + expected_entropy = 4 * np.pi * self.default_mass**2 self.assertAlmostEqual(initial_entropy, expected_entropy, delta=0.1*initial_entropy) @@ -198,9 +198,9 @@ def test_mass_scaling(self): for mass in test_masses: bh = BlackHoleSimulation(mass=mass) bh.run_simulation(t_final=1.0) - - # Test entropy scaling - expected_S = np.pi * mass**2 + + # Test entropy scaling: S = A/(4l_p²) = 4*pi*M² in Planck units + expected_S = 4 * np.pi * mass**2 initial_entropy = bh.entropy_history[0] self.assertAlmostEqual(initial_entropy/expected_S, 1.0, delta=0.1) diff --git a/tests/test_page_curve.py b/tests/test_page_curve.py index dace0ad..a39e773 100644 --- a/tests/test_page_curve.py +++ b/tests/test_page_curve.py @@ -51,11 +51,11 @@ def compute_black_hole_entropy(mass: float) -> float: """ Compute Bekenstein-Hawking entropy for a Schwarzschild black hole. - S_BH = pi * r_h^2 / (4 * l_p^2) + S_BH = A / (4 * l_p^2) = 4*pi*r_h^2 / (4*l_p^2) = pi * r_h^2 / l_p^2 where r_h = 2GM is the horizon radius. - In Planck units (G = l_p = 1): S_BH = pi * (2M)^2 / 4 = pi * M^2 + In Planck units (G = l_p = 1): S_BH = pi * (2M)^2 = 4 * pi * M^2 Args: mass: Black hole mass in Planck units @@ -64,7 +64,7 @@ def compute_black_hole_entropy(mass: float) -> float: Black hole entropy in Planck units """ horizon_radius = 2 * CONSTANTS['G'] * mass - return np.pi * horizon_radius**2 / (4 * CONSTANTS['l_p']**2) + return np.pi * horizon_radius**2 / CONSTANTS['l_p']**2 def compute_evaporation_time(mass: float) -> float: @@ -329,16 +329,18 @@ def test_entropy_scaling_with_mass(self): ) def test_entropy_formula_explicit(self): - """Test the explicit entropy formula S = pi * M^2.""" + """Test the explicit entropy formula S = 4 * pi * M^2.""" mass = 100.0 S_BH = compute_black_hole_entropy(mass) # In Planck units with G = l_p = 1: - # S = pi * (2GM)^2 / (4 * l_p^2) = pi * M^2 - expected = np.pi * mass**2 + # r_h = 2GM = 2M + # A = 4*pi*r_h^2 = 16*pi*M^2 + # S = A/(4*l_p^2) = 4*pi*M^2 + expected = 4 * np.pi * mass**2 assert np.isclose(S_BH, expected, rtol=0.01), ( - f"S_BH = {S_BH}, expected pi * M^2 = {expected}" + f"S_BH = {S_BH}, expected 4*pi*M^2 = {expected}" ) diff --git a/tests/test_quantum_effects.py b/tests/test_quantum_effects.py index 7560465..5d12675 100644 --- a/tests/test_quantum_effects.py +++ b/tests/test_quantum_effects.py @@ -126,7 +126,11 @@ def test_quantum_corrections(self): # assert abs(enhancement - expected)/expected < 0.01 def test_leech_lattice_contribution(self): - """Verify Leech lattice enhancement factor""" - enhancement = self.dm_analysis.compute_geometric_enhancement() # Use correct method name - expected = np.sqrt(196560/24) - assert abs(enhancement - expected)/expected < 0.01 + """Verify v7 dark matter enhancement factor (replaces Leech lattice)""" + enhancement = self.dm_analysis.compute_geometric_enhancement() + + # v7 formulation: M_DM/M_b = π/(2γ₀) ≈ 5.73 + # where γ₀ = 0.274 is the Immirzi parameter + # This replaces the deprecated Leech lattice formula √(196560/24) ≈ 90.5 + expected = np.pi / (2 * 0.274) # ≈ 5.73 + assert abs(enhancement - expected) / expected < 0.01 diff --git a/theory/page_curve.md b/theory/page_curve.md new file mode 100644 index 0000000..3c9d9f7 --- /dev/null +++ b/theory/page_curve.md @@ -0,0 +1,278 @@ +# The Page Curve and Information Preservation in v7 Holographic Fisher Geometry + +## 1. Introduction: The Black Hole Information Paradox + +### 1.1 The Problem + +Hawking's calculation (1975) showed that black holes emit thermal radiation at temperature: + +``` +T_H = ℏc³/(8πGMk_B) +``` + +This radiation appears to be exactly thermal - carrying no information about what fell into the black hole. If the black hole completely evaporates, the information seems to be lost, violating quantum mechanical unitarity. + +### 1.2 The Page Curve + +Don Page (1993) argued that if black hole evaporation is unitary, the entanglement entropy of the radiation must follow a characteristic curve: + +``` +S_rad(t) + │ + │ ╱╲ + │ ╱ ╲ + │ ╱ ╲ + │ ╱ ╲ + │ ╱ ╲ + │ ╱ ╲ + │ ╱ ╲ + └─────────────────── time + ↑ ↑ + early late + (rising) (falling) + ↑ + Page time +``` + +**Key features:** +- **Early times**: S_rad increases as radiation becomes entangled with the black hole +- **Page time**: S_rad reaches maximum (~half the initial BH entropy) +- **Late times**: S_rad decreases as information transfers to radiation + +The Page time occurs approximately when half the black hole has evaporated: +``` +t_Page ~ (G_N M₀³)/(ℏc⁴) +``` + +--- + +## 2. Recent Breakthroughs: The Island Formula + +### 2.1 The QES Prescription (2019-2020) + +Penington, Almheiri, Engelhardt, Marolf, and Maxfield derived the Page curve using the **island formula**: + +``` +S(R) = min[ext(Area(∂I)/(4G_N) + S_bulk(R ∪ I))] +``` + +Where: +- **R** = radiation region (outside black hole) +- **I** = "island" (region inside black hole included in entropy calculation) +- **∂I** = boundary of the island (quantum extremal surface) +- **S_bulk** = bulk quantum field theory entropy + +### 2.2 The Key Insight + +At late times, the entropy is minimized by including an **island** inside the black hole: + +- **Early times (no island)**: S(R) = S_bulk(R) ~ number of emitted quanta (grows) +- **Late times (with island)**: S(R) = Area(∂I)/(4G_N) + S_bulk(R ∪ I) (shrinks with BH) + +The transition between these regimes produces the Page curve. + +--- + +## 3. Connection to v7 Framework + +### 3.1 The Master Equation + +The v7 Holographic Fisher Geometry framework: + +``` +g_μν = ℓ_P²(G_μν^Fisher + γ₀E_μν) +``` + +Contains the conceptual ingredients for the Page curve: + +| Component | Role in Page Curve | +|-----------|-------------------| +| G_μν^Fisher | Encodes state distinguishability of radiation | +| E_μν | Tracks BH-radiation entanglement | +| γ₀ | Couples entanglement to geometry | + +### 3.2 Physical Interpretation + +**Early times (rising S_rad):** +- E_μν dominates: BH-radiation entanglement grows +- Each Hawking quantum is maximally entangled with its partner behind the horizon +- The entanglement strain tensor captures this growing correlation + +**Page time (maximum S_rad):** +- Transition point where E_μν contribution equals G_μν^Fisher contribution +- The quantum extremal surface jumps to include the island + +**Late times (falling S_rad):** +- G_μν^Fisher of radiation dominates +- Information encoded in Fisher information metric transfers to radiation +- Entanglement between radiation subsystems becomes detectable + +### 3.3 The Entanglement Strain Tensor + +The v7 entanglement strain tensor: + +``` +E_μν = ∂_μS_ent · ∂_νS_ent - ½η_μν(∂S_ent)² +``` + +During evaporation: +- S_ent initially grows (more entanglement across horizon) +- ∂_μS_ent points radially inward (entanglement concentrated at horizon) +- E_μν peaks at the Page time +- After Page time, island formation causes E_μν to decrease + +--- + +## 4. Current Implementation Status + +### 4.1 What the Simulator Currently Tracks + +| Quantity | Status | File | +|----------|--------|------| +| S_BH(t) - Black hole entropy | ✅ Implemented | `examples/black_hole.py` | +| M(t) - Mass evolution | ✅ Implemented | `examples/black_hole.py` | +| T(t) - Hawking temperature | ✅ Implemented | `examples/black_hole.py` | +| Radiation flux | ✅ Implemented | `examples/black_hole.py` | +| **S_rad(t) - Radiation entropy** | ❌ Not yet | Planned | +| **Page time detection** | ❌ Not yet | Planned | + +### 4.2 What's Needed for Page Curve + +1. **Radiation entropy tracking**: Compute S_rad = ∫(dM·c²)/(k_B·T) dt +2. **Page time detection**: Find t where dS_rad/dt = 0 +3. **Total entropy verification**: Check S_BH + S_rad bounded by initial S_BH +4. **v7 connection**: Show E_μν peaks at Page time + +--- + +## 5. Theoretical Requirements for Rigorous Derivation + +### 5.1 Full Derivation Would Require + +1. **Explicit Hilbert space decomposition**: + ``` + H_total = H_BH ⊗ H_radiation + ``` + +2. **Hawking pair dynamics**: + ``` + |Ψ⟩ = Σ_n c_n |n⟩_BH ⊗ |n⟩_rad + ``` + +3. **Partial trace for radiation density matrix**: + ``` + ρ_rad = Tr_BH(|Ψ⟩⟨Ψ|) + ``` + +4. **Von Neumann entropy**: + ``` + S_rad = -Tr(ρ_rad log ρ_rad) + ``` + +5. **Quantum extremal surface identification**: + ``` + δS_gen/δγ = 0 where S_gen = Area(γ)/(4G_N) + S_bulk + ``` + +### 5.2 Connection to Replica Wormholes + +The island formula was derived using gravitational path integrals with replica wormholes. A complete v7 derivation would need to show that: + +- The Fisher metric path integral reproduces replica wormhole contributions +- Island saddles emerge from entanglement strain extremization +- The QES condition follows from v7 master equation variation + +--- + +## 6. Simplified Numerical Approach + +### 6.1 Information Flow Model + +For numerical demonstration, we use the information flow approximation: + +**Radiation entropy increment:** +``` +dS_rad = (dM · c²)/(k_B · T_Hawking) +``` + +This captures the essential physics: +- Each emitted quantum carries energy dE = dM·c² +- At temperature T, entropy per quantum ~ E/T +- Cumulative radiation entropy grows then falls + +**Why this works:** +- Early times: High T → low entropy per quantum, but many quanta +- Late times: Low T → high entropy per quantum, but BH nearly gone +- Page time emerges naturally from this competition + +### 6.2 Expected Results + +For a black hole with initial mass M₀: + +| Quantity | Expected Value | +|----------|----------------| +| Initial S_BH | πr_s²/(ℓ_P²) = 4πG²M₀²/(ℏc) | +| Page time | ~0.65 × t_evap (see note below) | +| Max S_rad | ~0.5 × S_BH(0) | +| Final S_rad | → 0 (information recovered) | + +**Note on Page time**: The naive expectation is t_Page ~ 0.5 × t_evap (when half the entropy +has been radiated). However, with the cubic-root mass evolution M(t) = M₀(1-t/t_evap)^(1/3), +the Page time shifts to ~0.65 × t_evap. This is because: +- Entropy scales as S ∝ M², so S(t) = S₀(1-t/t_evap)^(2/3) +- Page time occurs when S_rad = S_BH, i.e., when (1-t/t_evap)^(2/3) = 0.5 +- Solving: t_Page/t_evap = 1 - 0.5^(3/2) ≈ 0.65 + +--- + +## 7. Open Questions + +### 7.1 Within v7 Framework + +1. **Can the island be derived from v7?** + - Does extremizing g_μν = ℓ_P²(G_μν^Fisher + γ₀E_μν) give QES condition? + +2. **Role of Immirzi parameter γ₀**: + - Does γ₀ = 0.274 affect the Page time? + - Is there a γ₀ correction to the entropy formula? + +3. **Fisher metric of radiation**: + - How does G_μν^Fisher of the radiation field encode BH information? + - Can we compute this explicitly? + +### 7.2 General Open Questions + +1. **Interior reconstruction**: How is the BH interior reconstructed from radiation? +2. **Firewalls**: Does the v7 framework avoid the firewall paradox? +3. **Scrambling time**: How does information spread before Page time? + +--- + +## 8. Conclusion + +The Page curve represents the definitive test of unitarity in black hole evaporation. The v7 Holographic Fisher Geometry framework has the conceptual ingredients to address this: + +- **Entanglement strain tensor E_μν** tracks BH-radiation entanglement +- **Fisher information metric G_μν^Fisher** encodes quantum state distinguishability +- **The master equation** unifies geometry and information + +A full derivation would be a significant research contribution. The current implementation plan provides a numerical demonstration that captures the essential physics while connecting to v7 concepts. + +--- + +## References + +1. Page, D.N. (1993). "Information in black hole radiation," *Phys. Rev. Lett.* **71**, 3743. + +2. Hawking, S.W. (1975). "Particle creation by black holes," *Commun. Math. Phys.* **43**, 199. + +3. Penington, G. (2020). "Entanglement wedge reconstruction and the information paradox," *JHEP* **09**, 002. + +4. Almheiri, A., Engelhardt, N., Marolf, D., & Maxfield, H. (2019). "The entropy of bulk quantum fields and the entanglement wedge of an evaporating black hole," *JHEP* **12**, 063. + +5. Almheiri, A., Mahajan, R., Maldacena, J., & Zhao, Y. (2020). "The Page curve of Hawking radiation from semiclassical geometry," *JHEP* **03**, 149. + +--- + +*This document accompanies the v7 Holographic Fisher Geometry proposal.* +*See also: theory/quantum-gravity-proposal-v7.md*