consciousness_experiments 2.0.0

#!/usr/bin/env python3
"""
PHYSICS WORLD MODEL - Compound Integration System

A comprehensive physics knowledge and reasoning system that:
1. Functions independently for physics questions and simulations
2. Integrates with GAIA consciousness system via query interface
3. Covers Classical Mechanics, Thermodynamics, Electromagnetism,
   Quantum Mechanics, and Sacred Geometry

Architecture:
- PhysicsKnowledgeBase: Core facts and principles
- PhysicsReasoner: Logical inference and constraint checking
- PhysicsSimulator: System dynamics and evolution
- PhysicsExplainer: Intuitive explanations of phenomena
- GAIAPhysicsInterface: Bridge to consciousness module
"""

import torch
import numpy as np
from typing import Dict, List, Tuple, Optional, Any
from dataclasses import dataclass
from enum import Enum
import math


# ============================================================================
# PHYSICS DOMAIN ENUMERATIONS
# ============================================================================

class PhysicsDomain(Enum):
    """Physics domains covered by the world model."""
    CLASSICAL_MECHANICS = "classical"
    THERMODYNAMICS = "thermo"
    ELECTROMAGNETISM = "electro"
    QUANTUM_MECHANICS = "quantum"
    SACRED_GEOMETRY = "geometry"


class PhysicalPrinciple(Enum):
    """Fundamental physics principles."""
    CONSERVATION_ENERGY = "energy_conservation"
    CONSERVATION_MOMENTUM = "momentum_conservation"
    CONSERVATION_ANGULAR_MOMENTUM = "angular_momentum_conservation"
    CONSERVATION_CHARGE = "charge_conservation"
    ENTROPY_INCREASE = "entropy_increase"
    UNCERTAINTY_PRINCIPLE = "uncertainty_principle"
    SYMMETRY_PRINCIPLE = "symmetry"
    GOLDEN_RATIO = "golden_ratio"
    HARMONIC_RESONANCE = "harmonic_resonance"


# ============================================================================
# DATA STRUCTURES
# ============================================================================

@dataclass
class PhysicalObject:
    """Represents a physical object in the world model."""
    name: str
    mass: Optional[float] = None
    charge: Optional[float] = None
    position: Optional[np.ndarray] = None  # (x, y, z)
    velocity: Optional[np.ndarray] = None  # (vx, vy, vz)
    properties: Dict[str, Any] = None

    def __post_init__(self):
        if self.properties is None:
            self.properties = {}


@dataclass
class PhysicalLaw:
    """Represents a physics law or principle."""
    name: str
    domain: PhysicsDomain
    principle: PhysicalPrinciple
    equation: str
    constraints: List[str]
    conditions: List[str]


@dataclass
class PhysicsQuery:
    """A physics question or reasoning task."""
    question: str
    domain: PhysicsDomain
    requires_simulation: bool = False
    requires_constraint_check: bool = True
    requires_explanation: bool = True


@dataclass
class PhysicsAnswer:
    """A physics answer with reasoning and explanation."""
    answer: str
    confidence: float
    domain: PhysicsDomain
    reasoning: List[str]
    principles_used: List[PhysicalPrinciple]
    explanation: str
    simulation_data: Optional[Dict] = None


# ============================================================================
# PHYSICS KNOWLEDGE BASE
# ============================================================================

class PhysicsKnowledgeBase:
    """
    Comprehensive physics knowledge base covering all domains.
    Stores facts, laws, principles, and relationships.
    """

    def __init__(self):
        self.laws = self._initialize_laws()
        self.constants = self._initialize_constants()
        self.principles = self._initialize_principles()
        self.relationships = self._initialize_relationships()

    def _initialize_laws(self) -> Dict[str, PhysicalLaw]:
        """Initialize fundamental physics laws."""
        laws = {}

        # Classical Mechanics
        laws['newtons_first'] = PhysicalLaw(
            name="Newton's First Law (Inertia)",
            domain=PhysicsDomain.CLASSICAL_MECHANICS,
            principle=PhysicalPrinciple.CONSERVATION_MOMENTUM,
            equation="F = 0 → a = 0 (no acceleration without force)",
            constraints=["Object in isolation", "Inertial reference frame"],
            conditions=["No external forces"]
        )

        laws['newtons_second'] = PhysicalLaw(
            name="Newton's Second Law",
            domain=PhysicsDomain.CLASSICAL_MECHANICS,
            principle=PhysicalPrinciple.CONSERVATION_MOMENTUM,
            equation="F = ma",
            constraints=["Constant mass", "Inertial frame"],
            conditions=["Net force applied"]
        )

        laws['newtons_third'] = PhysicalLaw(
            name="Newton's Third Law (Action-Reaction)",
            domain=PhysicsDomain.CLASSICAL_MECHANICS,
            principle=PhysicalPrinciple.CONSERVATION_MOMENTUM,
            equation="F_AB = -F_BA",
            constraints=["Instantaneous interaction"],
            conditions=["Two objects interacting"]
        )

        laws['conservation_energy'] = PhysicalLaw(
            name="Conservation of Energy",
            domain=PhysicsDomain.CLASSICAL_MECHANICS,
            principle=PhysicalPrinciple.CONSERVATION_ENERGY,
            equation="E_total = KE + PE = constant",
            constraints=["Closed system", "Conservative forces"],
            conditions=["No external work", "No dissipation"]
        )

        # Thermodynamics
        laws['first_law_thermo'] = PhysicalLaw(
            name="First Law of Thermodynamics",
            domain=PhysicsDomain.THERMODYNAMICS,
            principle=PhysicalPrinciple.CONSERVATION_ENERGY,
            equation="dU = dQ - dW",
            constraints=["Well-defined state", "Equilibrium assumptions"],
            conditions=["Energy exchange"]
        )

        laws['second_law_thermo'] = PhysicalLaw(
            name="Second Law of Thermodynamics",
            domain=PhysicsDomain.THERMODYNAMICS,
            principle=PhysicalPrinciple.ENTROPY_INCREASE,
            equation="dS_universe >= 0",
            constraints=["Isolated system", "Macroscopic scale"],
            conditions=["Natural processes"]
        )

        # Electromagnetism
        laws['coulombs_law'] = PhysicalLaw(
            name="Coulomb's Law",
            domain=PhysicsDomain.ELECTROMAGNETISM,
            principle=PhysicalPrinciple.CONSERVATION_CHARGE,
            equation="F = k*q1*q2/r²",
            constraints=["Point charges", "Vacuum/medium"],
            conditions=["Electrostatic interaction"]
        )

        laws['gauss_law'] = PhysicalLaw(
            name="Gauss's Law",
            domain=PhysicsDomain.ELECTROMAGNETISM,
            principle=PhysicalPrinciple.CONSERVATION_CHARGE,
            equation="∮E·dA = Q_enc/ε₀",
            constraints=["Closed surface", "Static fields"],
            conditions=["Charge distribution"]
        )

        # Quantum Mechanics
        laws['uncertainty_principle'] = PhysicalLaw(
            name="Heisenberg Uncertainty Principle",
            domain=PhysicsDomain.QUANTUM_MECHANICS,
            principle=PhysicalPrinciple.UNCERTAINTY_PRINCIPLE,
            equation="Δx·Δp >= ℏ/2",
            constraints=["Quantum regime", "Microscopic scale"],
            conditions=["Position-momentum measurement"]
        )

        laws['schrodinger_equation'] = PhysicalLaw(
            name="Schrödinger Equation",
            domain=PhysicsDomain.QUANTUM_MECHANICS,
            principle=PhysicalPrinciple.SYMMETRY_PRINCIPLE,
            equation="iℏ(∂ψ/∂t) = Ĥψ",
            constraints=["Non-relativistic", "Single particle"],
            conditions=["Quantum system evolution"]
        )

        # Sacred Geometry
        laws['golden_ratio'] = PhysicalLaw(
            name="Golden Ratio Principle",
            domain=PhysicsDomain.SACRED_GEOMETRY,
            principle=PhysicalPrinciple.GOLDEN_RATIO,
            equation="φ = (1 + √5)/2 ≈ 1.618",
            constraints=["Natural patterns", "Fibonacci sequences"],
            conditions=["Self-similar structures"]
        )

        laws['harmonic_resonance'] = PhysicalLaw(
            name="Harmonic Resonance",
            domain=PhysicsDomain.SACRED_GEOMETRY,
            principle=PhysicalPrinciple.HARMONIC_RESONANCE,
            equation="f_resonant = c/λ (integer ratios)",
            constraints=["Wave systems", "Periodic boundaries"],
            conditions=["Natural frequencies"]
        )

        return laws

    def _initialize_constants(self) -> Dict[str, float]:
        """Initialize fundamental physical constants."""
        return {
            'G': 6.67430e-11,           # Gravitational constant (m³/kg·s²)
            'c': 299792458.0,            # Speed of light (m/s)
            'h': 6.62607015e-34,        # Planck constant (J·s)
            'hbar': 1.054571817e-34,    # Reduced Planck constant
            'k_B': 1.380649e-23,        # Boltzmann constant (J/K)
            'e': 1.602176634e-19,       # Elementary charge (C)
            'epsilon_0': 8.8541878128e-12, # Permittivity of free space
            'mu_0': 1.25663706212e-6,   # Permeability of free space
            'k_e': 8.9875517923e9,      # Coulomb constant (N·m²/C²)
            'phi': 1.618033988749895,   # Golden ratio
            'pi': math.pi,
            'e_math': math.e,
        }

    def _initialize_principles(self) -> Dict[PhysicalPrinciple, str]:
        """Initialize fundamental physics principles."""
        return {
            PhysicalPrinciple.CONSERVATION_ENERGY:
                "Energy cannot be created or destroyed, only transformed",
            PhysicalPrinciple.CONSERVATION_MOMENTUM:
                "Total momentum of an isolated system remains constant",
            PhysicalPrinciple.CONSERVATION_ANGULAR_MOMENTUM:
                "Angular momentum is conserved in closed systems",
            PhysicalPrinciple.CONSERVATION_CHARGE:
                "Electric charge is conserved in all interactions",
            PhysicalPrinciple.ENTROPY_INCREASE:
                "Entropy of an isolated system always increases or stays constant",
            PhysicalPrinciple.UNCERTAINTY_PRINCIPLE:
                "Certain pairs of physical properties cannot be simultaneously known to arbitrary precision",
            PhysicalPrinciple.SYMMETRY_PRINCIPLE:
                "Laws of physics are invariant under certain transformations",
            PhysicalPrinciple.GOLDEN_RATIO:
                "Natural systems exhibit proportions related to the golden ratio",
            PhysicalPrinciple.HARMONIC_RESONANCE:
                "Systems resonate at frequencies governed by harmonic relationships",
        }

    def _initialize_relationships(self) -> Dict[str, List[str]]:
        """Initialize relationships between concepts."""
        return {
            'force': ['mass', 'acceleration', 'momentum_change'],
            'energy': ['work', 'heat', 'kinetic', 'potential'],
            'momentum': ['force', 'time', 'velocity', 'mass'],
            'charge': ['electric_field', 'magnetic_field', 'current'],
            'wave': ['frequency', 'wavelength', 'amplitude', 'phase'],
            'particle': ['position', 'momentum', 'energy', 'spin'],
            'system': ['energy', 'entropy', 'temperature', 'structure'],
        }

    def get_law(self, law_name: str) -> Optional[PhysicalLaw]:
        """Retrieve a physics law by name."""
        return self.laws.get(law_name)

    def get_constant(self, constant_name: str) -> Optional[float]:
        """Retrieve a fundamental constant."""
        return self.constants.get(constant_name)

    def get_principle_description(self, principle: PhysicalPrinciple) -> str:
        """Get description of a principle."""
        return self.principles.get(principle, "Unknown principle")


# ============================================================================
# PHYSICS REASONER
# ============================================================================

class PhysicsReasoner:
    """
    Logical inference engine for physics.
    Applies conservation laws, checks constraints, and derives conclusions.
    """

    def __init__(self, knowledge_base: PhysicsKnowledgeBase):
        self.kb = knowledge_base

    def reason_about_system(self,
                           objects: List[PhysicalObject],
                           query: PhysicsQuery) -> Tuple[str, List[str]]:
        """
        Reason about a physical system given objects and a query.
        Returns conclusion and reasoning steps.
        """
        reasoning_steps = []

        # Identify applicable principles
        applicable_principles = self._identify_applicable_principles(query.domain)
        reasoning_steps.append(f"Domain: {query.domain.value}")
        reasoning_steps.append(f"Applicable principles: {[p.value for p in applicable_principles]}")

        # Check conservation laws
        conservation_checks = self._check_conservation_laws(objects, applicable_principles)
        reasoning_steps.extend(conservation_checks)

        # Derive conclusion
        conclusion = self._derive_conclusion(query, applicable_principles, conservation_checks)

        return conclusion, reasoning_steps

    def _identify_applicable_principles(self, domain: PhysicsDomain) -> List[PhysicalPrinciple]:
        """Identify which principles apply to a domain."""
        domain_principles = {
            PhysicsDomain.CLASSICAL_MECHANICS: [
                PhysicalPrinciple.CONSERVATION_MOMENTUM,
                PhysicalPrinciple.CONSERVATION_ENERGY,
                PhysicalPrinciple.CONSERVATION_ANGULAR_MOMENTUM,
            ],
            PhysicsDomain.THERMODYNAMICS: [
                PhysicalPrinciple.CONSERVATION_ENERGY,
                PhysicalPrinciple.ENTROPY_INCREASE,
            ],
            PhysicsDomain.ELECTROMAGNETISM: [
                PhysicalPrinciple.CONSERVATION_CHARGE,
                PhysicalPrinciple.CONSERVATION_ENERGY,
            ],
            PhysicsDomain.QUANTUM_MECHANICS: [
                PhysicalPrinciple.UNCERTAINTY_PRINCIPLE,
                PhysicalPrinciple.CONSERVATION_ENERGY,
                PhysicalPrinciple.SYMMETRY_PRINCIPLE,
            ],
            PhysicsDomain.SACRED_GEOMETRY: [
                PhysicalPrinciple.GOLDEN_RATIO,
                PhysicalPrinciple.HARMONIC_RESONANCE,
                PhysicalPrinciple.SYMMETRY_PRINCIPLE,
            ],
        }
        return domain_principles.get(domain, [])

    def _check_conservation_laws(self,
                                objects: List[PhysicalObject],
                                principles: List[PhysicalPrinciple]) -> List[str]:
        """Check if conservation laws are satisfied."""
        checks = []

        if PhysicalPrinciple.CONSERVATION_ENERGY in principles:
            total_ke = sum(0.5 * obj.mass * np.linalg.norm(obj.velocity)**2
                          for obj in objects if obj.mass and obj.velocity is not None)
            checks.append(f"Total kinetic energy: {total_ke:.4e} J")

        if PhysicalPrinciple.CONSERVATION_MOMENTUM in principles:
            total_momentum = sum(obj.mass * obj.velocity
                               for obj in objects
                               if obj.mass and obj.velocity is not None)
            checks.append(f"Total momentum: {total_momentum}")

        if PhysicalPrinciple.CONSERVATION_CHARGE in principles:
            total_charge = sum(obj.charge for obj in objects if obj.charge)
            checks.append(f"Total charge: {total_charge:.4e} C")

        return checks

    def _derive_conclusion(self,
                          query: PhysicsQuery,
                          principles: List[PhysicalPrinciple],
                          checks: List[str]) -> str:
        """Derive conclusion from reasoning."""
        if not checks:
            return f"Question about {query.domain.value} physics is reasonable but requires specific objects"
        return f"System satisfies {len(principles)} key physics principles"


# ============================================================================
# PHYSICS SIMULATOR
# ============================================================================

class PhysicsSimulator:
    """
    Simulates physical systems and their evolution over time.
    Supports numerical integration of equations of motion.
    """

    def __init__(self, knowledge_base: PhysicsKnowledgeBase):
        self.kb = knowledge_base

    def simulate_motion(self,
                       objects: List[PhysicalObject],
                       forces: Dict[str, np.ndarray],
                       time_steps: int = 100,
                       dt: float = 0.01) -> Dict[str, np.ndarray]:
        """
        Simulate motion of objects under given forces.
        Returns trajectory history.
        """
        trajectories = {obj.name: [] for obj in objects}

        # Initialize
        current_state = {obj.name: obj for obj in objects}

        # Time stepping
        for step in range(time_steps):
            for obj in objects:
                if obj.name in forces and obj.mass:
                    # F = ma → a = F/m
                    acceleration = forces[obj.name] / obj.mass
                    # v = v₀ + at
                    if obj.velocity is not None:
                        obj.velocity += acceleration * dt
                    # x = x₀ + vt
                    if obj.position is not None:
                        obj.position += obj.velocity * dt

                trajectories[obj.name].append(obj.position.copy() if obj.position is not None else None)

        return trajectories

    def simulate_resonance(self,
                          frequencies: List[float],
                          duration: float = 1.0,
                          sample_rate: float = 1000) -> Dict[str, np.ndarray]:
        """Simulate harmonic resonance patterns."""
        t = np.linspace(0, duration, int(duration * sample_rate))
        waves = {}

        for i, freq in enumerate(frequencies):
            waves[f'harmonic_{i}'] = np.sin(2 * np.pi * freq * t)

        # Combined wave shows interference patterns
        combined = sum(waves.values()) / len(frequencies)
        waves['combined'] = combined

        return {'time': t, 'waves': waves}


# ============================================================================
# PHYSICS EXPLAINER
# ============================================================================

class PhysicsExplainer:
    """
    Generates intuitive explanations of physics phenomena.
    Connects formal laws to observable behaviors.
    """

    def __init__(self, knowledge_base: PhysicsKnowledgeBase):
        self.kb = knowledge_base

    def explain_phenomenon(self, phenomenon: str, domain: PhysicsDomain) -> str:
        """Provide intuitive explanation of a physics phenomenon."""
        explanations = {
            (PhysicsDomain.CLASSICAL_MECHANICS, 'inertia'):
                "Objects resist changes in motion. A ball rolling on ice keeps rolling "
                "because nothing is pushing against it to slow it down.",

            (PhysicsDomain.CLASSICAL_MECHANICS, 'gravity'):
                "All objects with mass attract each other. Earth pulls you down with "
                "gravity, and you pull Earth up—but Earth is so massive you don't notice.",

            (PhysicsDomain.THERMODYNAMICS, 'entropy'):
                "Systems naturally tend toward disorder. A broken egg can't reassemble itself "
                "because there are far more ways to be broken than intact.",

            (PhysicsDomain.ELECTROMAGNETISM, 'magnetism'):
                "Moving charges create magnetic fields. Electrons spinning and orbiting create "
                "magnetism in materials. This is why magnets align with Earth's magnetic field.",

            (PhysicsDomain.QUANTUM_MECHANICS, 'superposition'):
                "At quantum scales, particles exist in multiple states simultaneously until measured. "
                "A quantum coin is both heads and tails until you look at it.",

            (PhysicsDomain.SACRED_GEOMETRY, 'golden_ratio'):
                "The golden ratio appears throughout nature: in flower petals, spiral galaxies, "
                "and human proportions. It represents optimal balance and efficiency.",

            (PhysicsDomain.SACRED_GEOMETRY, 'resonance'):
                "Systems vibrate most easily at their natural frequencies. Push a swing at the "
                "right moment, and it builds momentum. Push at the wrong time, and it fights back.",
        }

        key = (domain, phenomenon.lower())
        return explanations.get(key, f"The phenomenon of {phenomenon} in {domain.value} is a "
                               "deep and complex subject in physics.")

    def explain_law(self, law_name: str) -> str:
        """Provide intuitive explanation of a physics law."""
        law = self.kb.get_law(law_name)
        if not law:
            return f"Unknown law: {law_name}"

        explanation = f"""
Law: {law.name}
Domain: {law.domain.value}
Equation: {law.equation}

Principle: {self.kb.get_principle_description(law.principle)}

Conditions: {', '.join(law.conditions)}
Constraints: {', '.join(law.constraints)}
"""
        return explanation


# ============================================================================
# GAIA PHYSICS INTERFACE
# ============================================================================

class GAIAPhysicsInterface:
    """
    Bridge between standalone physics system and GAIA consciousness module.
    Enables GAIA to query physics knowledge and reasoning.
    """

    def __init__(self, knowledge_base: PhysicsKnowledgeBase):
        self.kb = knowledge_base
        self.reasoner = PhysicsReasoner(knowledge_base)
        self.simulator = PhysicsSimulator(knowledge_base)
        self.explainer = PhysicsExplainer(knowledge_base)

    def answer_physics_question(self, query: PhysicsQuery) -> PhysicsAnswer:
        """
        Main interface for GAIA to ask physics questions.
        Returns structured answer with reasoning and explanation.
        """
        # Identify applicable laws
        applicable_laws = [law for law in self.kb.laws.values()
                          if law.domain == query.domain]

        # Perform reasoning
        reasoning_steps = [f"Query: {query.question}"]
        reasoning_steps.append(f"Domain: {query.domain.value}")
        reasoning_steps.append(f"Found {len(applicable_laws)} applicable laws")

        # Extract principles
        principles_used = []
        for law in applicable_laws:
            if law.principle not in principles_used:
                principles_used.append(law.principle)

        reasoning_steps.extend([f"- {law.name}" for law in applicable_laws[:3]])

        # Generate answer
        answer_text = f"This question involves {query.domain.value} physics. "
        answer_text += f"Key principles: {', '.join(p.value for p in principles_used[:2])}"

        # Generate explanation
        explanation = self.explainer.explain_phenomenon(
            query.question.lower(),
            query.domain
        )

        # Confidence based on clarity of applicable principles
        confidence = min(0.95, 0.5 + 0.45 * (len(principles_used) / 9))

        return PhysicsAnswer(
            answer=answer_text,
            confidence=confidence,
            domain=query.domain,
            reasoning=reasoning_steps,
            principles_used=principles_used,
            explanation=explanation
        )

    def get_physics_knowledge(self, aspect: str) -> Dict[str, Any]:
        """
        Get structured physics knowledge for GAIA integration.
        """
        return {
            'constants': self.kb.constants,
            'principles': {p.value: desc for p, desc in self.kb.principles.items()},
            'laws': {name: {
                'equation': law.equation,
                'domain': law.domain.value,
                'principle': law.principle.value
            } for name, law in self.kb.laws.items()},
        }


# ============================================================================
# MAIN PHYSICS WORLD MODEL
# ============================================================================

class PhysicsWorldModel:
    """
    Main physics world model with all capabilities.
    Can function standalone or integrate with GAIA.
    """

    def __init__(self):
        self.kb = PhysicsKnowledgeBase()
        self.reasoner = PhysicsReasoner(self.kb)
        self.simulator = PhysicsSimulator(self.kb)
        self.explainer = PhysicsExplainer(self.kb)
        self.gaia_interface = GAIAPhysicsInterface(self.kb)

    def answer_question(self, question: str, domain: PhysicsDomain) -> PhysicsAnswer:
        """Answer a physics question (standalone mode)."""
        query = PhysicsQuery(
            question=question,
            domain=domain,
            requires_explanation=True
        )
        return self.gaia_interface.answer_physics_question(query)

    def query_gaia(self, question: str, domain: PhysicsDomain) -> Dict[str, Any]:
        """
        Interface for GAIA to query physics (compound integration mode).
        """
        answer = self.answer_question(question, domain)
        return {
            'answer': answer.answer,
            'confidence': answer.confidence,
            'reasoning': answer.reasoning,
            'explanation': answer.explanation,
            'principles': [p.value for p in answer.principles_used],
        }

    def list_domains(self) -> List[str]:
        """List all physics domains available."""
        return [d.value for d in PhysicsDomain]

    def list_laws(self, domain: Optional[PhysicsDomain] = None) -> Dict[str, str]:
        """List laws in a domain."""
        laws = {}
        for name, law in self.kb.laws.items():
            if domain is None or law.domain == domain:
                laws[name] = f"{law.name} ({law.domain.value})"
        return laws


# ============================================================================
# DEMO
# ============================================================================

if __name__ == "__main__":
    print("=" * 80)
    print("PHYSICS WORLD MODEL - Compound Integration System")
    print("=" * 80)
    print()

    # Initialize
    physics = PhysicsWorldModel()

    # Show available domains
    print("Available Physics Domains:")
    for domain in physics.list_domains():
        print(f"  • {domain}")
    print()

    # Show available laws
    print("Available Physics Laws:")
    laws = physics.list_laws()
    for i, (name, description) in enumerate(laws.items(), 1):
        if i <= 10:
            print(f"  {i}. {description}")
    print(f"  ... and {len(laws) - 10} more")
    print()

    # Example 1: Answer a physics question
    print("=" * 80)
    print("EXAMPLE 1: Standalone Physics Question")
    print("=" * 80)
    answer = physics.answer_question(
        "Why does gravity pull objects down?",
        PhysicsDomain.CLASSICAL_MECHANICS
    )
    print(f"Question: Why does gravity pull objects down?")
    print(f"Answer: {answer.answer}")
    print(f"Confidence: {answer.confidence:.1%}")
    print(f"Explanation: {answer.explanation}")
    print()

    # Example 2: GAIA integration
    print("=" * 80)
    print("EXAMPLE 2: GAIA Integration")
    print("=" * 80)
    gaia_result = physics.query_gaia(
        "How does entropy work?",
        PhysicsDomain.THERMODYNAMICS
    )
    print(f"GAIA Query: How does entropy work?")
    print(f"Physics Response: {gaia_result['answer']}")
    print(f"Confidence: {gaia_result['confidence']:.1%}")
    print(f"Principles Used: {', '.join(gaia_result['principles'])}")
    print()

    # Example 3: Sacred Geometry
    print("=" * 80)
    print("EXAMPLE 3: Sacred Geometry")
    print("=" * 80)
    answer = physics.answer_question(
        "What is the golden ratio?",
        PhysicsDomain.SACRED_GEOMETRY
    )
    print(f"Question: What is the golden ratio?")
    print(f"Answer: {answer.answer}")
    print(f"Explanation: {answer.explanation}")
    print()

    print("=" * 80)
    print("Physics World Model Ready for Integration")
    print("=" * 80)