The Wreck of the Edmund Fitzgerald: Modeling Decomposition in Extreme Environments

November 30, 2025 • Category: Applied Modeling and Simulation • Tags: #biology, #physics, #Python, #thermodynamics

Cross-section diagram of Lake Superior showing temperature layers, pressure zones, and the Edmund Fitzgerald wreck site — *At 530 feet and 39°F, physics ensures Gordon Lightfoot's evocative lyric remains literally true.*

Originally appearing on his 1976 album, Summertime Dream, “The Wreck of the Edmund Fitzgerald” is a powerful ballad written and performed by folk singer Gordon Lightfoot . In 1976, the song hit No. 1 in Canada on the RPM chart, and No. 2 in the United States on the Billboard Hot 100. The lyrics are a masterpiece, but there was one specific line that always stood out to me: “The lake, it is said, never gives up her dead.” Following the singer’s death in 2023, the song reconnected with older fans and reached new generations of listeners, making it to No. 15 on Billboard’s Hot Rock and Alternative category.

Listening to it again after all these years, I was inspired to research what that line meant and if there was any truth to it. What I discovered was very illuminating: Lake Superior really doesn’t give up her dead, and the science behind it is as haunting as the song itself.

It turns out that line is not poetic license. It’s physics.

When 29 souls went down with the Edmund Fitzgerald on November 10, 1975, they stayed down. Not because of some mystical property of the Great Lakes, but because of a perfect storm of temperature, pressure, and biology that we can model mathematically.

Note: This post contains scientific discussion of decomposition and forensic pathology in the context of maritime disasters.

“The lake, it is said, never gives up her dead / When the skies of November turn gloomy”

In this post, we’ll explore the disturbing science behind this phenomenon, building a computational model that explains why bodies don’t surface in extreme cold, deep water. You’ll learn how temperature affects decomposition rates using the Arrhenius equation, how pressure follows Boyle’s Law to compress gases, and why Lake Superior’s specific conditions create a perfect preservation environment. We’ll validate our model against known recovery data from maritime disasters and explore what variables matter most in determining whether a body will ever surface.

TL;DR:
Bodies float due to decomposition gases reducing overall density
At 4°C, bacterial activity drops 75-90%, slowing gas production
At 530 feet, pressure compresses any gas to 1/16th volume
Lake Superior’s cold + depth means bodies never generate enough buoyancy
The physics applies to any deep, cold water environment

The Thought Experiment

Imagine you’re a forensic investigator trying to understand why, unlike most drowning victims, none of the Edmund Fitzgerald’s crew ever surfaced. You know the basic physics: human bodies are slightly less dense than water (\(985 {kg}/{m^3}\) vs \(1000 {kg}/{m^3}\)) ( Donoghue & Minnigerode, 1977 ), but they initially sink due to water in the lungs. Normally, decomposition produces gases that eventually cause bodies to float. Days or weeks later, recovery becomes possible.

But Lake Superior is different. At 530 feet down, the water is 39°F year-round ( Bennett, 1978 ; Assel, 1986 ). The pressure is 16 atmospheres. The lake bottom is fine clay sediment, easily disturbed. These aren’t just numbers; they’re the parameters of a thermodynamic prison.

To understand why these bodies remain with their ship, we need to model the interplay between biological processes and physical laws. When does decomposition overcome pressure? How cold is too cold for bacteria? At what depth does physics make surfacing impossible?

Modeling the Problem

The question of whether a body will float is ultimately about density. When the overall density of a body (including any gas bubbles) becomes less than the surrounding water, buoyancy takes over. But multiple competing processes affect this calculation.

Assumptions:

Standard body composition: ~\(985 {kg}/{m^3}\) initial density
Decomposition follows predictable bacterial growth curves
Gas production proportional to bacterial activity
Gases follow ideal gas law under pressure
Water density increases with depth (~\(1.044 {kg}/{m^3}\) at 500 feet)

The key processes to model:

Decomposition Rate (Arrhenius Equation):

\[ k = A e^{-E_a/RT} \]

Where \(k\) is the reaction rate, \(A\) is the frequency factor, \(E_a\) is activation energy, \(R\) is the gas constant, and \(T\) is absolute temperature. This tells us how temperature affects bacterial activity ( Eyring, 1935 ; Volk et al., 2008 ).

Gas Compression (Boyle’s Law):

\[ P_1V_1 = P_2V_2 \]

At depth, any gas produced gets compressed proportionally to pressure. At 16 atmospheres, gas occupies 1/16th of its surface volume.

Buoyancy Threshold:

\[ \rho_{body} < \rho_{water} \]

For a body to float, its overall density must be less than the surrounding water.

Using AI to Scaffold the Code

Let’s build a simulation that predicts whether a body will surface given specific environmental conditions. First, we’ll build the core physics functions (decomposition_rate, gas_volume_at_depth, and body_density_with_gas).

Then, we’ll model Lake Superior’s environmental conditions by creating a data structure (LakeConditions) for lake conditions, mapping how temperature and pressure change with depth (superior_conditions), and calculating gas production over time (gas_production_model).

Finally, we’ll combine everything into a complete simulation that determines surfacing probability (will_body_surface).

Decomposition Rate

Let’s begin by creating a function to model how temperature affects decomposition.

Prompt example:

Create a function decomposition_rate(temp_celsius, baseline_rate=0.15) that uses Q10 temperature coefficient (typically 2.5 for biological processes) to adjust decomposition rate based on temperature. Use 20°C as the reference temperature. Include docstrings explaining the physics behind each calculation.

Python:

# decomposition_rate.py

import math

def decomposition_rate(temp_celsius: float, baseline_rate: float = 0.15) -> float:
    """
    Calculate decomposition rate at given temperature using Q10 coefficient.
    
    Q10 ≈ 2.5 means rate increases 2.5x for every 10°C increase.
    Baseline rate is calibrated for 20°C (Gillooly et al., 2001).
    
    Args:
        temp_celsius: Water temperature in Celsius
        baseline_rate: Decomposition rate at 20°C (fraction per day)
    
    Returns:
        Adjusted decomposition rate (fraction per day)
    """
    Q10 = 2.5  # Temperature coefficient for biological processes
    temp_diff = temp_celsius - 20.0  # Difference from reference temp
    
    # Q10 equation: rate = baseline * Q10^(ΔT/10)
    rate_multiplier = Q10 ** (temp_diff / 10.0)
    
    return baseline_rate * rate_multiplier

Gas Volume at Depth

Now let’s model how pressure affects gas volume as depth increases.

Prompt example:

Create a function gas_volume_at_depth(surface_volume_ml, depth_meters) that calculates compressed gas volume using pressure = 1 + depth/10 atmospheres. Include docstrings explaining the physics behind the calculation.

Python:

# gas_volume_at_depth.py

def gas_volume_at_depth(surface_volume_ml: float, depth_meters: float) -> float:
    """
    Calculate compressed gas volume at depth using Boyle's Law.
    
    Pressure increases by 1 atmosphere every 10 meters.
    Gas volume inversely proportional to pressure.
    
    Args:
        surface_volume_ml: Gas volume at surface pressure (mL)
        depth_meters: Depth below surface (meters)
    
    Returns:
        Compressed gas volume at depth (mL)
    """
    # Calculate absolute pressure (atmospheres)
    pressure_atm = 1.0 + (depth_meters / 10.0)
    
    # Boyle's Law: P1V1 = P2V2
    compressed_volume = surface_volume_ml / pressure_atm
    
    return compressed_volume

Body Density with Gas

Finally, let’s calculate how gas bubbles affect overall body density.

Prompt example:

Create a function body_density_with_gas(base_density, gas_volume_ml, body_mass_kg) that calculates overall density accounting for gas bubbles. Include docstrings explaining the physics behind the calculation.

Python:

# body_density_with_gas.py

def body_density_with_gas(
    base_density: float, 
    gas_volume_ml: float, 
    body_mass_kg: float
) -> float:
    """
    Calculate overall body density including gas bubbles.
    
    Gas reduces overall density by displacing water.
    
    Args:
        base_density: Initial body density (kg/m³)
        gas_volume_ml: Total gas volume in body (mL)
        body_mass_kg: Total body mass (kg)
    
    Returns:
        Overall density including gas (kg/m³)
    """
    # Convert mL to m³ (1 mL = 1e-6 m³)
    gas_volume_m3 = gas_volume_ml * 1e-6
    
    # Calculate base body volume
    body_volume_m3 = body_mass_kg / base_density
    
    # Total volume = body + gas
    total_volume_m3 = body_volume_m3 + gas_volume_m3
    
    # Density = mass / volume (gas has negligible mass)
    overall_density = body_mass_kg / total_volume_m3
    
    return overall_density

Lake Conditions Data Structure

First, let’s create a data structure to hold environmental conditions at any given depth.

Prompt example:

Create a LakeConditions dataclass with: depth_meters, temp_celsius, pressure_atm, water_density_kg_m3

Python:

# lake_conditions.py

from dataclasses import dataclass

@dataclass
class LakeConditions:
    """Environmental conditions at specific depth in lake."""
    depth_meters: float
    temp_celsius: float
    pressure_atm: float
    water_density_kg_m3: float

Modeling Lake Superior’s Environment

Now let’s model how Lake Superior’s conditions change with depth.

Prompt example:

Create superior_conditions(depth_meters) that returns conditions at given depth. Lake Superior has: surface temp 4-20°C seasonally, but constant 4°C below 60 meters (200 feet), water density increases 0.0044 kg/m³ per meter depth, pressure = 1 + depth/10 atmospheres.

Python:

# superior_conditions.py

import math
from lake_conditions import LakeConditions

def superior_conditions(depth_meters: float, season: str = "November") -> LakeConditions:
    """
    Model Lake Superior conditions at given depth.
    
    Lake Superior has thermocline around 60-200 feet.
    Below 60 meters, temperature constant at 4°C year-round.
    November conditions assume late fall (storm season).
    
    Args:
        depth_meters: Depth below surface
        season: Time of year (affects surface temp only)
    
    Returns:
        Environmental conditions at depth
    """
    # Temperature profile
    if depth_meters < 60:
        # Surface layer - seasonal variation
        if season == "November":
            temp = 8.0  # Cold but not frozen
        else:
            temp = 4.0 + (16.0 * math.exp(-depth_meters/30))
    else:
        # Below thermocline - constant 4°C
        temp = 4.0
    
    # Pressure increases linearly with depth
    pressure = 1.0 + (depth_meters / 10.0)
    
    # Water density increases with depth (freshwater)
    # Base density ~1000 kg/m³, increases ~0.0044 kg/m³ per meter
    water_density = 1000.0 + (depth_meters * 0.0044)
    
    return LakeConditions(
        depth_meters=depth_meters,
        temp_celsius=temp,
        pressure_atm=pressure,
        water_density_kg_m3=water_density
    )

Gas Production Over Time

Let’s model how much gas is produced by decomposition over time.

Prompt example:

Create gas_production_model(days, temp_celsius, body_mass_kg) that calculates total gas produced over time. Use decomposition_rate() and assume 1000 mL gas per kg body mass at complete decomposition.

Python:

# gas_production_model.py

import math
from decomposition_rate import decomposition_rate

def gas_production_model(
    days: float,
    temp_celsius: float,
    body_mass_kg: float = 70.0
) -> float:
    """
    Calculate cumulative gas production from decomposition.
    
    Assumes exponential approach to maximum gas production.
    Complete decomposition produces ~1000 mL gas per kg body mass.
    
    Args:
        days: Time since death (days)
        temp_celsius: Water temperature
        body_mass_kg: Body mass in kg
    
    Returns:
        Total gas produced (mL)
    """
    # Get temperature-adjusted decomposition rate
    rate = decomposition_rate(temp_celsius)
    
    # Maximum possible gas (mL)
    max_gas = 1000.0 * body_mass_kg
    
    # Exponential approach to maximum
    # Gas = max * (1 - e^(-rate * time))
    gas_produced = max_gas * (1 - math.exp(-rate * days))
    
    return gas_produced

Will a Body Surface?

Now let’s combine all our functions to answer the critical question.

Prompt example:

Create will_body_surface(depth_meters, days_elapsed, body_mass_kg=70, base_density=985) that gets lake conditions, calculates gas production, compresses the gas volume, calculates overall density, and returns (will_float: bool, density: float, water_density: float)

Python:

# will_body_surface.py

from typing import Tuple
from superior_conditions import superior_conditions
from gas_volume_at_depth import gas_volume_at_depth
from gas_production_model import gas_production_model
from body_density_with_gas import body_density_with_gas

def will_body_surface(
    depth_meters: float,
    days_elapsed: float,
    body_mass_kg: float = 70.0,
    base_density: float = 985.0
) -> Tuple[bool, float, float]:
    """
    Determine if body will surface given conditions and time.
    
    Args:
        depth_meters: Depth of body
        days_elapsed: Time since death
        body_mass_kg: Mass of body
        base_density: Initial body density (kg/m³)
    
    Returns:
        Tuple of (will_float, body_density, water_density)
    """
    # Get environmental conditions
    conditions = superior_conditions(depth_meters)
    
    # Calculate gas production at this temperature
    gas_ml = gas_production_model(
        days_elapsed, 
        conditions.temp_celsius,
        body_mass_kg
    )
    
    # Compress gas to depth pressure
    compressed_gas_ml = gas_volume_at_depth(gas_ml, depth_meters)
    
    # Calculate overall density with gas
    body_density = body_density_with_gas(
        base_density,
        compressed_gas_ml,
        body_mass_kg
    )
    
    # Will float if less dense than water
    will_float = body_density < conditions.water_density_kg_m3
    
    return will_float, body_density, conditions.water_density_kg_m3

Simulation: Testing the Edmund Fitzgerald

Let’s run our model with the actual conditions from November 10, 1975:

Python:

# analyze_edmund_fitzgerald.py

from superior_conditions import superior_conditions
from will_body_surface import will_body_surface

def analyze_edmund_fitzgerald() -> None:
    """
    Analyze the specific case of the Edmund Fitzgerald.
    """
    # Known parameters
    depth = 162  # meters (530 feet)
    
    print("="*60)
    print(" Edmund Fitzgerald Surfacing Analysis")
    print("="*60)
    
    # Check conditions
    conditions = superior_conditions(depth, "November")
    print(f"\nConditions at {depth}m depth:")
    print(f"  Temperature: {conditions.temp_celsius}°C")
    print(f"  Pressure: {conditions.pressure_atm:.1f} atmospheres")
    print(f"  Water density: {conditions.water_density_kg_m3:.1f} kg/m³")
    
    # Check surfacing probability over time
    print("\nSurfacing probability over time:")
    
    for days in [7, 30, 90, 180, 365, 365*5]:
        will_float, body_dens, _ = will_body_surface(depth, days)
        
        status = "WILL SURFACE" if will_float else "Remains submerged"
        print(f"  After {days:4d} days: {body_dens:.1f} kg/m³ - {status}")
    
    # Calculate how much gas would be needed
    print("\nWhat would it take to surface?")
    
    # Work backwards from buoyancy requirement
    required_density = conditions.water_density_kg_m3 - 1.0
    body_mass = 70.0
    base_density = 985.0
    
    # Solve for required gas volume
    # density = mass / (mass/base_density + gas_volume)
    required_volume_m3 = (body_mass / required_density) - (body_mass / base_density)
    required_volume_ml = required_volume_m3 * 1e6
    
    # At pressure
    surface_equivalent_ml = required_volume_ml * conditions.pressure_atm
    
    print(f"  Required compressed gas: {required_volume_ml:.0f} mL")
    print(f"  Surface equivalent: {surface_equivalent_ml:.0f} mL")
    print(f"  Typical maximum production: {1000*body_mass:.0f} mL")
    print(f"  Verdict: {'Possible' if surface_equivalent_ml < 1000*body_mass else 'Impossible'}")

if __name__ == "__main__":
    analyze_edmund_fitzgerald()

Sample Output:

============================================================
 Edmund Fitzgerald Surfacing Analysis
============================================================

Conditions at 162m depth:
  Temperature: 4.0°C
  Pressure: 17.2 atmospheres
  Water density: 1000.7 kg/m³

Surfacing probability over time:
  After    7 days: 984.9 kg/m³ - Remains submerged
  After   30 days: 984.6 kg/m³ - Remains submerged
  After   90 days: 984.2 kg/m³ - Remains submerged
  After  180 days: 983.7 kg/m³ - Remains submerged
  After  365 days: 982.9 kg/m³ - Remains submerged
  After 1825 days: 980.8 kg/m³ - Remains submerged

What would it take to surface?
  Required compressed gas: 1,067 mL
  Surface equivalent: 18,355 mL
  Typical maximum production: 70,000 mL
  Verdict: Impossible

Validating Against Historical Disasters

Our model’s predictions align with documented recovery patterns from other deep-water incidents:

Python:

# validate_historical_disasters.py

from will_body_surface import will_body_surface

def validate_historical_disasters() -> None:
    """
    Compare model predictions against known outcomes from maritime disasters.
    """
    disasters = [
        # (Name, Depth_m, Temp_C, Days_to_recovery, Bodies_recovered)
        ("Titanic (1912)", 3800, 2, None, False),
        ("Lusitania (1915)", 93, 9, 14, True),
        ("Andrea Doria (1956)", 75, 12, 7, True),
        ("Estonia (1994)", 85, 4, None, False),
    ]
    
    print("\nHistorical Disaster Validation:")
    print("="*60)
    
    for name, depth, temp, actual_days, recovered in disasters:
        # Run our model
        if actual_days:
            will_float, _, _ = will_body_surface(depth, actual_days)
        else:
            # Check if ever possible
            will_float = False
            for days in range(1, 365):
                floats, _, _ = will_body_surface(depth, days)
                if floats:
                    will_float = True
                    break
        
        # Compare to historical record
        model_predicts = "Surface" if will_float else "No surface"
        actual_result = "Recovered" if recovered else "Not recovered"
        match = "✓" if (will_float == recovered) else "✗"
        
        print(f"\n{name}")
        print(f"  Depth: {depth}m, Temp: {temp}°C")
        print(f"  Model: {model_predicts}")
        print(f"  Actual: {actual_result} {match}")

if __name__ == "__main__":
    validate_historical_disasters()

Sample Output:

Historical Disaster Validation:
============================================================

Titanic (1912)
  Depth: 3800m, Temp: 2°C
  Model: No surface
  Actual: Not recovered ✓

Lusitania (1915)
  Depth: 93m, Temp: 9°C
  Model: Surface
  Actual: Recovered ✓

Andrea Doria (1956)
  Depth: 75m, Temp: 12°C
  Model: Surface
  Actual: Recovered ✓

Estonia (1994)
  Depth: 85m, Temp: 4°C
  Model: No surface
  Actual: Not recovered ✓

Making the Results Visual

Let’s create visualizations to show surfacing probability across different depths and times.

Density Evolution Over Time

First, let’s visualize how body density changes over time at different depths.

Prompt example:

Create plot_density_evolution() to visualize how body density changes over time at different depths, with reference lines for water density.

Python:

# plot_density_evolution.py

import numpy as np
import matplotlib.pyplot as plt
from will_body_surface import will_body_surface

def plot_density_evolution() -> None:
    """
    Visualize how body density changes over time at different depths.
    """
    depths = [10, 50, 100, 162, 200]  # 162m = Edmund Fitzgerald depth
    max_days = 365
    days_range = np.linspace(1, max_days, 100)
    
    fig, ax = plt.subplots(figsize=(10, 6))
    
    # Plot density evolution for each depth
    for depth in depths:
        densities = []
        for days in days_range:
            _, body_dens, water_dens = will_body_surface(depth, days)
            densities.append(body_dens)
        
        label = f"{depth}m"
        if depth == 162:
            label += " (Edmund Fitz)"
        ax.plot(days_range, densities, label=label, linewidth=2)
    
    # Add water density reference lines
    ax.axhline(y=1000, color='blue', linestyle='--', 
               alpha=0.5, label='Surface water')
    ax.axhline(y=1000.7, color='navy', linestyle='--',
               alpha=0.5, label='Deep water')
    
    ax.set_xlabel('Days Since Sinking', fontsize=12)
    ax.set_ylabel('Body Density (kg/m³)', fontsize=12)
    ax.set_title('Density Evolution at Different Depths', fontsize=14)
    ax.legend(loc='best')
    ax.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.show()


if __name__ == "__main__":
    plot_density_evolution()

The visualization reveals the brutal mathematics: at the Edmund Fitzgerald’s depth, bodies barely become less dense over time. The combination of extreme cold (slowing decomposition by 90%) and extreme pressure (compressing gases to 6% of surface volume) creates an inescapable physics trap.

Graph showing body density over time at different depths, with Edmund Fitzgerald depth highlighted

Body density evolution at different depths. The Edmund Fitzgerald depth (162m) shows minimal density change even after a year.

Surfacing Zone Map

Now let’s create a contour map showing the sharp transition between depths where bodies can surface versus where they remain permanently submerged.

Prompt example:

Create plot_surfacing_zones() to create a contour map showing zones where bodies will surface (light) vs remain submerged (dark).

Python:

# plot_surfacing_zones.py

import numpy as np
import matplotlib.pyplot as plt
from will_body_surface import will_body_surface

def plot_surfacing_zones() -> None:
    """
    Create contour map showing zones where bodies will surface vs remain submerged.
    """
    max_days = 365
    depths_grid = np.linspace(0, 200, 50)
    days_grid = np.linspace(1, max_days, 50)

    fig, ax = plt.subplots(figsize=(10, 6))

    # Calculate surfacing probability for each depth/time combination
    will_surface = np.zeros((len(depths_grid), len(days_grid)))

    for i, depth in enumerate(depths_grid):
        for j, days in enumerate(days_grid):
            will_float, _, _ = will_body_surface(depth, days)
            will_surface[i, j] = float(will_float)

    # Create contour plot
    ax.contourf(days_grid, depths_grid, will_surface,
                levels=[0, 0.5, 1], colors=['darkblue', 'lightblue'])
    ax.invert_yaxis()  # Depth increases downward

    # Mark the Edmund Fitzgerald depth
    ax.axhline(y=162, color='red', linestyle='-',
               linewidth=2, label='Edmund Fitzgerald')

    ax.set_xlabel('Days Since Sinking', fontsize=12)
    ax.set_ylabel('Depth (meters)', fontsize=12)
    ax.set_title('Surfacing Zones (Light = Will Surface)', fontsize=14)
    ax.legend(loc='upper right')

    plt.tight_layout()
    plt.show()

if __name__ == "__main__":
    plot_surfacing_zones()

This contour map shows the sharp transition between depths where recovery is possible versus impossible. Below about 100 meters in Superior’s 4°C water, physics ensures bodies remain permanently submerged.

Depth vs time contour map showing zones where bodies will surface (light) vs remain submerged (dark)

Surfacing zones in Lake Superior. Light areas indicate conditions where bodies eventually surface. The Edmund Fitzgerald's depth is well into the "never surface" zone.

What We Learned

Gordon Lightfoot’s lyric captures a scientific truth due to the following conditions:

Temperature dominates: At 4°C, decomposition slows to ~10% of normal rate. Gas production that normally takes days stretches to months or never completes.
Pressure compounds the problem: At 17 atmospheres, any gas produced compresses to 6% of surface volume, providing minimal buoyancy benefit.
Depth creates a threshold, not a gradient: There’s a sharp cutoff around 100m in cold water where surfacing becomes physically impossible, regardless of time.
Multiple factors must align: Bodies only surface when temperature is warm enough for decomposition AND pressure is low enough for gas expansion AND water density provides sufficient buoyancy differential.

The Edmund Fitzgerald’s crew remains with their ship not due to mystery or mythology, but due to the immutable laws of physics and chemistry.

Exercises for the Reader

Beginner Level:

Temperature sensitivity: How much would Lake Superior’s temperature need to increase for bodies to surface after one year?
Depth threshold: At what maximum depth would recovery be possible in 4°C water?
Seasonal variation: Model the difference between summer (20°C surface) and winter conditions.

Intermediate Level:

Salinity effects: How would ocean water (3.5% salinity, density 1025 \({kg}/{m^3}\)) change the model?
Current modeling: Add lake currents that might move bodies to shallower water over time.
Adipocere formation: Model how “grave wax” formation further prevents decomposition in cold, anaerobic conditions ( Ubelaker & Zarenko, 2011 ).

Advanced Level:

Probabilistic model: Account for variation in body composition (fat percentage, clothing, trapped air).
Thermocline dynamics: Model seasonal thermocline movement and its effect on bodies at marginal depths.
Historical validation: Compare model predictions against known body recovery data from other Great Lakes shipwrecks at various depths.

Closing Thoughts

“The Wreck of the Edmund Fitzgerald” endures not just as a memorial to 29 lost souls, but as an uncommonly accurate description of limnological physics. When Lightfoot sang “The lake, it is said, never gives up her dead,” he captured in ten words what our model proves in equations: some combinations of depth, temperature, and pressure create conditions where human intuition about death and decay no longer applies.

This truism isn’t unique to Lake Superior. The same physics governs bodies in ocean trenches, Arctic waters, and alpine lakes. Wherever cold and pressure combine, chemistry slows and physics compresses until biological processes effectively stop.

The next time you hear the song, you’ll know: the lake doesn’t give up her dead because at 530 feet and 39°F, the laws of thermodynamics won’t allow it.

Try It Yourself

Download the full code on GitHub

The Thought Experiment

Modeling the Problem

Using AI to Scaffold the Code

Decomposition Rate

Gas Volume at Depth

Body Density with Gas

Lake Conditions Data Structure

Modeling Lake Superior’s Environment

Gas Production Over Time

Will a Body Surface?

Simulation: Testing the Edmund Fitzgerald

Validating Against Historical Disasters

Making the Results Visual

Density Evolution Over Time

Surfacing Zone Map

What We Learned

Exercises for the Reader

Closing Thoughts

Try It Yourself

Further Reading