"""Quantum field excitation for sensory modalities (SPECTRAL A.1)."""
from dataclasses import dataclass
from enum import Enum
from typing import Dict, Optional
import numpy as np
[docs]
class ModalityField(Enum):
"""Sensory modalities with their field types."""
VISUAL = "visual" # EM field, 400-700 THz
AUDITORY = "auditory" # Pressure field, 20 Hz-20 kHz
TACTILE = "tactile" # Surface EM/force field, 0-500 Hz
OLFACTORY = "olfactory" # Chemical potential field
GUSTATORY = "gustatory" # Molecular binding field
AFFECTIVE = "affective" # Neural EMF, 1-100 Hz
PROPRIOCEPTIVE = "proprioceptive" # Mechanical strain field
VESTIBULAR = "vestibular" # Inertial/gravitational field
INTEROCEPTIVE = "interoceptive" # Metabolic chemical field
THERMOCEPTIVE = "thermoceptive" # Thermal gradient field
CHRONOCEPTIVE = "chronoceptive" # Oscillator phase field
[docs]
@dataclass
class FieldSpec:
"""Specification for a quantum field."""
modality: ModalityField
frequency_min: float # Hz
frequency_max: float # Hz
coupling_coefficient: float
field_type: str # "em", "pressure", "chemical", "mechanical", "thermal", "phase"
# Field specifications based on SPECTRAL A.1
FIELD_SPECS = {
ModalityField.VISUAL: FieldSpec(ModalityField.VISUAL, 4e14, 7e14, 0.6, "em"),
ModalityField.AUDITORY: FieldSpec(ModalityField.AUDITORY, 20.0, 20000.0, 0.8, "pressure"),
ModalityField.TACTILE: FieldSpec(ModalityField.TACTILE, 0.0, 500.0, 0.7, "em_force"),
ModalityField.OLFACTORY: FieldSpec(ModalityField.OLFACTORY, 0.0, 0.0, 0.5, "chemical"),
ModalityField.GUSTATORY: FieldSpec(ModalityField.GUSTATORY, 0.0, 0.0, 0.4, "chemical"),
ModalityField.AFFECTIVE: FieldSpec(ModalityField.AFFECTIVE, 1.0, 100.0, 0.9, "em"),
ModalityField.PROPRIOCEPTIVE: FieldSpec(
ModalityField.PROPRIOCEPTIVE, 0.1, 100.0, 0.7, "mechanical"
),
ModalityField.VESTIBULAR: FieldSpec(ModalityField.VESTIBULAR, 0.0, 20.0, 0.7, "mechanical"),
ModalityField.INTEROCEPTIVE: FieldSpec(ModalityField.INTEROCEPTIVE, 0.0, 0.0, 0.6, "chemical"),
ModalityField.THERMOCEPTIVE: FieldSpec(ModalityField.THERMOCEPTIVE, 0.0, 0.0, 0.7, "thermal"),
ModalityField.CHRONOCEPTIVE: FieldSpec(ModalityField.CHRONOCEPTIVE, 1e-6, 1e-4, 0.5, "phase"),
}
[docs]
class QuantumFieldOperator:
"""
Represents a quantum field operator for a sensory modality.
Implements: Φ̂_m(r, t) = Σ_ω √(ħ/(2ε₀ω)) (â_ω e^{-iωt} ψ_ω(r) + h.c.)
Simplified for simulation: we track field amplitude and phase.
"""
def __init__(
self, modality: ModalityField, spec: FieldSpec, spatial_points: int = 10, modes: int = 5
):
self.modality = modality
self.spec = spec
self.spatial_points = spatial_points
self.modes = modes
# Discrete frequencies within the band
if spec.frequency_max > spec.frequency_min:
self.frequencies = np.linspace(spec.frequency_min, spec.frequency_max, modes)
else:
self.frequencies = np.array([1.0]) # placeholder for static fields
# Amplitudes for each mode (complex)
self.amplitudes = np.zeros(modes, dtype=complex)
# Spatial mode functions (simplified: plane waves)
self.spatial_modes = np.zeros((modes, spatial_points), dtype=complex)
self._initialize_spatial_modes()
def _initialize_spatial_modes(self):
"""Initialize plane wave spatial modes."""
x = np.linspace(0, 1, self.spatial_points)
for i, k in enumerate(self.frequencies / 340.0): # rough wavenumber
self.spatial_modes[i, :] = np.exp(1j * k * x)
[docs]
def excitation_amplitude(self, pattern_energy: float, pattern_coherence: float) -> float:
"""
Compute the field excitation amplitude based on pattern properties.
A = coupling * sqrt(pattern_energy) * coherence_factor.
"""
return (
self.spec.coupling_coefficient * np.sqrt(max(pattern_energy, 1e-30)) * pattern_coherence
)
[docs]
def evolve(
self,
dt: float,
pattern_energy: float,
pattern_coherence: float,
external_drive: Optional[np.ndarray] = None,
):
"""
Time evolution of field amplitudes.
dA/dt = -γ A + excitation + external_drive
"""
gamma = 0.1 * self.spec.coupling_coefficient # decay rate
excitation = self.excitation_amplitude(pattern_energy, pattern_coherence)
for i in range(self.modes):
# Natural decay
self.amplitudes[i] *= 1 - gamma * dt
# Excitation from pattern
self.amplitudes[i] += excitation * dt
# External drive (e.g., from another branch)
if external_drive is not None and i < len(external_drive):
self.amplitudes[i] += external_drive[i] * dt
[docs]
def field_strength(self, position_idx: int = 0) -> float:
"""Compute field strength at a spatial point."""
value = 0.0
for i in range(self.modes):
value += np.real(self.amplitudes[i] * self.spatial_modes[i, position_idx])
return value
[docs]
class UnifiedField:
"""
Manages all modality fields and their interactions.
"""
def __init__(self, spatial_points: int = 10):
self.fields: Dict[ModalityField, QuantumFieldOperator] = {}
self.spatial_points = spatial_points
self._initialize_fields()
def _initialize_fields(self):
for modality, spec in FIELD_SPECS.items():
self.fields[modality] = QuantumFieldOperator(modality, spec, self.spatial_points)
[docs]
def evolve_all(
self,
dt: float,
pattern_energy: float,
pattern_coherence: float,
external_drives: Optional[Dict[ModalityField, np.ndarray]] = None,
):
"""Evolve all fields."""
for modality, field in self.fields.items():
ext = external_drives.get(modality) if external_drives else None
field.evolve(dt, pattern_energy, pattern_coherence, ext)
[docs]
def get_field_strengths(self, position_idx: int = 0) -> Dict[ModalityField, float]:
"""Return field strengths for all modalities."""
return {mod: field.field_strength(position_idx) for mod, field in self.fields.items()}
[docs]
def manifestation_probability(self, modality: ModalityField, threshold: float = 0.1) -> float:
"""
Probability that field excitation exceeds perceptual threshold.
"""
field = self.fields[modality]
strength = field.field_strength()
# Sigmoid: 1/(1+exp(-β(strength - threshold)))
beta = 10.0
return 1.0 / (1.0 + np.exp(-beta * (strength - threshold)))