Initial commit: Kitchen Thermodynamics scientific infrastructure

scripts/falsification_checker.py

@@ -0,0 +1,62 @@
+#!/usr/bin/env python3
+"""
+Verificador sistemático de falsificações das 12 predições clássicas
+Baseado na série 'Cremation of Thermodynamics'
+"""
+
+from dataclasses import dataclass
+from typing import List, Dict
+from enum import Enum
+
+class FalsificationStatus(Enum):
+    CONFIRMED = "CONFIRMED"
+    PARTIAL = "PARTIAL"
+    UNVERIFIED = "UNVERIFIED"
+
+@dataclass
+class ClassicalPrediction:
+    number: int
+    statement: str
+    classical_mechanism: str
+    experiment: str
+    observation: str
+    status: FalsificationStatus
+
+class FalsificationChecker:
+    """
+    Tabela de falsificações do paper Kitchen Thermodynamics v6.0
+    """
+    
+    PREDICTIONS = [
+        ClassicalPrediction(1, "Meltwater flows downward on heated inclined surface", "Gravity", "Iceberg", "Reverses to upward at t≈90s", FalsificationStatus.CONFIRMED),
+        ClassicalPrediction(2, "Maximum gradient (0-100°C) dissipates in τ_eq≈160s", "Thermal diffusion", "Iceberg", "Sustained >720s (4.56×τ_eq)", FalsificationStatus.CONFIRMED),
+        ClassicalPrediction(3, "Liquid fat flows downhill on heated incline", "Gravity", "Butter", "Climbs uphill for 25+ min", FalsificationStatus.CONFIRMED),
+        ClassicalPrediction(4, "Butter flow is radially symmetric (scalar)", "Isotropic heat diffusion", "Butter", "Curved vector-field trajectories", FalsificationStatus.CONFIRMED),
+        ClassicalPrediction(5, "Marangoni drives fluid toward cooler regions", "Surface tension gradient", "Iceberg", "Anti-Marangoni: flow toward heat", FalsificationStatus.CONFIRMED),
+        ClassicalPrediction(6, "Bulk motion determined by temperature (convection)", "Buoyancy", "Water", "Motion tracks flame state, not T", FalsificationStatus.CONFIRMED),
+        ClassicalPrediction(7, "Water at 100°C more agitated than at 99.9°C", "Kinetic energy", "Water", "100°C+flame OFF = still; 99.9°C+flame ON = motion", FalsificationStatus.CONFIRMED),
+        ClassicalPrediction(8, "Boiling is temperature-threshold phenomenon", "Nucleation at T_boil", "Milk", "Stillness→overflow→stillness in 0.3°C range", FalsificationStatus.CONFIRMED),
+        ClassicalPrediction(9, "Convection is passive process driven by buoyancy", "Density differences", "Water/Beans", "Motion collapses in seconds when flame OFF", FalsificationStatus.CONFIRMED),
+        ClassicalPrediction(10, "Heating always increases temperature", "First Law (dU = δQ)", "Beans Short", "Temperature drops 1.5°C in 41s with fire ON", FalsificationStatus.CONFIRMED),
+        ClassicalPrediction(11, "Bottom of pot is hottest point when heated from below", "Conduction", "Beans Short", "Bottom 16.6°C, liquid above 21.5°C (Δ=4.9°C)", FalsificationStatus.CONFIRMED),
+        ClassicalPrediction(12, "Temperature rises monotonically until boiling", "Heat capacity", "Beans Long", "46s plateau 0.3°C below baseline, then 17+min rise without flame", FalsificationStatus.CONFIRMED)
+    ]
+    
+    def summary(self) -> Dict:
+        total = len(self.PREDICTIONS)
+        confirmed = sum(1 for p in self.PREDICTIONS if p.status == FalsificationStatus.CONFIRMED)
+        return {
+            "total_predictions": total,
+            "confirmed_falsifications": confirmed,
+            "falsification_rate": confirmed / total,
+            "experiments_covered": len(set(p.experiment for p in self.PREDICTIONS))
+        }
+
+if __name__ == "__main__":
+    checker = FalsificationChecker()
+    print("=" * 60)
+    print("KITCHEN THERMODYNAMICS — FALSIFICATION SUMMARY")
+    print("=" * 60)
+    s = checker.summary()
+    print(f"Total: {s['total_predictions']} | Falsificações: {s['confirmed_falsifications']} ({s['falsification_rate']*100:.1f}%)")
+

scripts/gradient_analyzer.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+"""
+Analisador de Gradientes Térmicos
+Calcula τ_eq (tempo de equilibração clássico) vs. observado
+"""
+
+import numpy as np
+from dataclasses import dataclass
+
+@dataclass
+class GradientAnalysis:
+    characteristic_length_m: float
+    thermal_diffusivity_m2s: float
+    tau_eq_classical_s: float
+    tau_observed_s: float
+    ratio_observed_to_classical: float
+    falsifies_classical: bool
+
+class GradientAnalyzer:
+    """
+    Análise de sustentação de gradientes térmicos.
+    
+    Clássico: τ_eq = L²/α (difusão térmica)
+    Observado: τ_obs >> τ_eq em regime de fluxo ativo
+    """
+    
+    # Difusividade térmica da água
+    ALPHA_WATER = 1.4e-7  # m²/s
+    
+    def __init__(self, alpha: float = None):
+        self.alpha = alpha or self.ALPHA_WATER
+    
+    def analyze(self, length_m: float, tau_observed_s: float) -> GradientAnalysis:
+        """
+        Compara tempo de equilibração clássico com observado.
+        """
+        tau_eq = length_m**2 / self.alpha
+        ratio = tau_observed_s / tau_eq
+        
+        return GradientAnalysis(
+            characteristic_length_m=length_m,
+            thermal_diffusivity_m2s=self.alpha,
+            tau_eq_classical_s=tau_eq,
+            tau_observed_s=tau_observed_s,
+            ratio_observed_to_classical=ratio,
+            falsifies_classical=ratio > 2.0  # Fator 2+ já é anômalo
+        )
+    
+    def entropy_deficit_rate(self, delta_S_J_per_K: float, 
+                            duration_s: float) -> float:
+        """
+        Taxa de déficit de entropia (negentropy).
+        dS/dt < 0 indica organização estrutural sustentada.
+        """
+        return delta_S_J_per_K / duration_s
+
+
+# Análise do Experimento 1
+if __name__ == "__main__":
+    analyzer = GradientAnalyzer()
+    
+    # Experimento 1: Iceberg
+    exp1 = analyzer.analyze(
+        length_m=0.15,  # 15 cm
+        tau_observed_s=730  # >12 minutos
+    )
+    
+    print("Experimento 1 - The Iceberg:")
+    print(f"  L = {exp1.characteristic_length_m*100:.1f} cm")
+    print(f"  τ_eq (clássico) = {exp1.tau_eq_classical_s:.1f} s")
+    print(f"  τ_observado = {exp1.tau_observed_s:.1f} s")
+    print(f"  Razão = {exp1.ratio_observed_to_classical:.2f}×")
+    print(f"  FALSIFICA clássico? {exp1.falsifies_classical}")
+    
+    # Déficit de entropia
+    dS_dt = analyzer.entropy_deficit_rate(
+        delta_S_J_per_K=180,  # ΔS ≈ 180 J/K
+        duration_s=730
+    )
+    print(f"  Taxa de déficit entropico: {dS_dt:.3f} J/(K·s)")
+

scripts/thermal_force_calculator.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""
+Thermal Force Calculator
+F_thermal = -k_T * m * ∇T
+
+Calibrado a partir do Experimento 2 (Butter) e aplicável a todos.
+"""
+
+import numpy as np
+from dataclasses import dataclass
+from typing import Optional
+
+@dataclass
+class ThermalForceResult:
+    force_N: float
+    k_T: float  # m·s⁻²·K⁻¹
+    overcomes_gravity: bool
+    ratio_to_gravity: float
+
+class ThermalForceCalculator:
+    """
+    Calculadora da força térmica atrativa proposta em Kitchen Thermodynamics.
+    
+    Constante k_T calibrada experimentalmente: 6.4 × 10⁻³ m·s⁻²·K⁻¹
+    (obtida do Experimento 2 - Butter shearing threshold)
+    """
+    
+    K_T_CALIBRATION = 6.4e-3  # m·s⁻²·K⁻¹
+    
+    def __init__(self, k_T: Optional[float] = None):
+        self.k_T = k_T or self.K_T_CALIBRATION
+    
+    def calculate(self, mass_kg: float, gradient_K_per_m: float, 
+                  gravity_ms2: float = 9.81, 
+                  incline_angle_deg: float = 0) -> ThermalForceResult:
+        """
+        Calcula F_thermal = -k_T * m * ∇T
+        
+        Args:
+            mass_kg: Massa do material (kg)
+            gradient_K_per_m: Gradiente de temperatura (K/m)
+            gravity_ms2: Aceleração gravitacional (m/s²)
+            incline_angle_deg: Ângulo da rampa (0 = horizontal)
+        """
+        # Força térmica (direção: +∇T, ou seja, para temperatura mais alta)
+        F_thermal = self.k_T * mass_kg * gradient_K_per_m
+        
+        # Componente gravitacional ao longo da rampa
+        theta = np.radians(incline_angle_deg)
+        F_gravity_parallel = mass_kg * gravity_ms2 * np.sin(theta)
+        
+        # Verifica se supera gravidade
+        overcomes = F_thermal > F_gravity_parallel
+        ratio = F_thermal / F_gravity_parallel if F_gravity_parallel > 0 else float('inf')
+        
+        return ThermalForceResult(
+            force_N=F_thermal,
+            k_T=self.k_T,
+            overcomes_gravity=overcomes,
+            ratio_to_gravity=ratio
+        )
+    
+    def calibrate_from_shearing(self, mass_kg: float, gradient_K_per_m: float,
+                                threshold_angle_deg: float) -> float:
+        """
+        Recalibra k_T a partir de um experimento de limiar de cisalhamento.
+        
+        No ponto de cisalhamento: F_thermal = F_gravity_parallel
+        k_T = g * sin(θ) / |∇T|
+        """
+        theta = np.radians(threshold_angle_deg)
+        k_T_new = 9.81 * np.sin(theta) / gradient_K_per_m
+        return k_T_new
+
+
+# Exemplo de uso com dados do Experimento 2
+if __name__ == "__main__":
+    calc = ThermalForceCalculator()
+    
+    # Experimento 2: Butter em rampa de 10°
+    result = calc.calculate(
+        mass_kg=0.01,  # 10g de manteiga
+        gradient_K_per_m=267,  # |∇T| ≈ 267 K/m
+        incline_angle_deg=10
+    )
+    
+    print(f"Experimento 2 - Butter em rampa inclinada:")
+    print(f"  F_thermal = {result.force_N:.6f} N")
+    print(f"  k_T = {result.k_T:.2e} m·s⁻²·K⁻¹")
+    print(f"  Supera gravidade? {result.overcomes_gravity}")
+    print(f"  Razão F_thermal/F_gravity = {result.ratio_to_gravity:.3f}")
+    
+    # Recalibração a partir do limiar observado (r_threshold ≈ 10cm)
+    k_T_exp = calc.calibrate_from_shearing(
+        mass_kg=0.01,
+        gradient_K_per_m=267,
+        threshold_angle_deg=10
+    )
+    print(f"\nCalibração experimental: k_T = {k_T_exp:.2e} m·s⁻²·K⁻¹")
+