mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
373 lines
14 KiB
Text
373 lines
14 KiB
Text
import Semantics.PhysicsScalar
|
|
import Semantics.PhysicsEuclidean
|
|
import Semantics.PhysicsLagrangian
|
|
import Semantics.LocalDerivative
|
|
import Semantics.HyperFlow
|
|
import Semantics.RegimeCore
|
|
import Semantics.ElectromagneticSpectrum
|
|
import Semantics.OrderedFieldTokens
|
|
|
|
namespace Semantics.MagnetoPlasma
|
|
|
|
-- Standardize on hardware-native scalar type
|
|
open Semantics.PhysicsScalar
|
|
open Semantics.PhysicsEuclidean
|
|
open Semantics.PhysicsLagrangian
|
|
open Semantics.LocalDerivative
|
|
open Semantics.HyperFlow
|
|
open Semantics.RegimeCore
|
|
open Semantics.ElectromagneticSpectrum
|
|
open Semantics.OrderedFieldTokens
|
|
|
|
abbrev MagnetoBodyId := UInt16
|
|
abbrev MagnetoCoreId := UInt16
|
|
|
|
inductive MagnetoCoreKind
|
|
| inert
|
|
| dipole
|
|
| toroidal
|
|
| filamentary
|
|
| lattice
|
|
deriving DecidableEq
|
|
|
|
inductive ConfinementRegime
|
|
| unconfined
|
|
| weaklyConfined
|
|
| loopConfined
|
|
| sheathConfined
|
|
| coreLocked
|
|
deriving DecidableEq
|
|
|
|
inductive ReconnectionTendency
|
|
| suppressed
|
|
| latent
|
|
| active
|
|
| cascading
|
|
deriving DecidableEq
|
|
|
|
inductive MagnetoPlasmaRegime
|
|
| diffuse
|
|
| aligned
|
|
| loopDominant
|
|
| sheathDominant
|
|
| reconnectionDominant
|
|
| coreDominant
|
|
| collapsed
|
|
deriving DecidableEq
|
|
|
|
inductive BodyCouplingClass
|
|
| isolated
|
|
| weaklyCoupled
|
|
| resonant
|
|
| entrained
|
|
| gated
|
|
deriving DecidableEq
|
|
|
|
structure MagnetoCore where
|
|
coreId : MagnetoCoreId
|
|
kind : MagnetoCoreKind
|
|
polarity : PhysicsScalar.Q16_16
|
|
coherence : PhysicsScalar.Q16_16
|
|
fieldBias : PhysicsScalar.Q16_16
|
|
tension : PhysicsScalar.Q16_16
|
|
saturation : PhysicsScalar.Q16_16
|
|
deriving DecidableEq
|
|
|
|
structure MagnetoPlasmaSignature where
|
|
alignment : PhysicsScalar.Q16_16
|
|
confinement : PhysicsScalar.Q16_16
|
|
reconnectionPotential : PhysicsScalar.Q16_16
|
|
loopCoherence : PhysicsScalar.Q16_16
|
|
sheathStrength : PhysicsScalar.Q16_16
|
|
coreInfluence : PhysicsScalar.Q16_16
|
|
couplingDensity : PhysicsScalar.Q16_16
|
|
spectralAffinity : PhysicsScalar.Q16_16
|
|
deriving DecidableEq
|
|
|
|
structure MagnetoSpectralHook where
|
|
admittedBands : List SpectrumBand
|
|
preferredCarrierRoles : List Nat
|
|
minimumIntensity : PhysicsScalar.Q16_16
|
|
minimumCoherence : PhysicsScalar.Q16_16
|
|
supportsPlasmaCoupling : Bool
|
|
deriving DecidableEq
|
|
|
|
structure MagnetoPlasmaBody (n : Nat) where
|
|
bodyId : MagnetoBodyId
|
|
state : PhysicsLagrangian n
|
|
core : MagnetoCore
|
|
localDerivative : LocalDerivative
|
|
hyperFlowSignature : HyperFlowSignature
|
|
regionId : Nat
|
|
spectralHook : MagnetoSpectralHook
|
|
regime : MagnetoPlasmaRegime
|
|
|
|
structure MagnetoBodyLink where
|
|
sourceBodyId : MagnetoBodyId
|
|
targetBodyId : MagnetoBodyId
|
|
couplingClass : BodyCouplingClass
|
|
couplingStrength : PhysicsScalar.Q16_16
|
|
gateOpenThreshold : PhysicsScalar.Q16_16
|
|
requiresSpectralAffinity : Bool
|
|
deriving DecidableEq
|
|
|
|
structure MagnetoInteractionRequest (n : Nat) where
|
|
source : MagnetoPlasmaBody n
|
|
target : MagnetoPlasmaBody n
|
|
link : MagnetoBodyLink
|
|
sample? : Option ElectromagneticSample
|
|
sourceRegimeClass : RegimeClass
|
|
targetRegimeClass : RegimeClass
|
|
|
|
structure MagnetoInteractionResult (n : Nat) where
|
|
admitted : Bool
|
|
sourceBody : MagnetoPlasmaBody n
|
|
targetBody : MagnetoPlasmaBody n
|
|
resolvedRegime : MagnetoPlasmaRegime
|
|
resultingCoupling : PhysicsScalar.Q16_16
|
|
|
|
|
|
def quantizeNonnegative (value : Float) : PhysicsScalar.Q16_16 :=
|
|
if value <= 0.0 then
|
|
PhysicsScalar.Q16_16.zero
|
|
else
|
|
let scaled := Float.toUInt32 (value * Float.ofNat PhysicsScalar.Q16_16.scale)
|
|
PhysicsScalar.Q16_16.fromRawNat scaled.toNat
|
|
|
|
|
|
def defaultMagnetoCore : MagnetoCore :=
|
|
{ coreId := 0
|
|
, kind := .inert
|
|
, polarity := PhysicsScalar.Q16_16.half
|
|
, coherence := PhysicsScalar.Q16_16.half
|
|
, fieldBias := PhysicsScalar.Q16_16.half
|
|
, tension := PhysicsScalar.Q16_16.quarter
|
|
, saturation := PhysicsScalar.Q16_16.one }
|
|
|
|
|
|
def defaultMagnetoSpectralHook : MagnetoSpectralHook :=
|
|
{ admittedBands := [.radio, .microwave, .infrared]
|
|
, preferredCarrierRoles := []
|
|
, minimumIntensity := PhysicsScalar.Q16_16.zero
|
|
, minimumCoherence := PhysicsScalar.Q16_16.quarter
|
|
, supportsPlasmaCoupling := true }
|
|
|
|
|
|
def coreStrength (core : MagnetoCore) : PhysicsScalar.Q16_16 :=
|
|
PhysicsScalar.Q16_16.mean3 core.coherence core.fieldBias core.tension
|
|
|
|
|
|
def sampleSpectrallyCompatible
|
|
(hook : MagnetoSpectralHook)
|
|
(sample : ElectromagneticSample) : Bool :=
|
|
let bandOk := sample.bandProfile.band ∈ hook.admittedBands
|
|
let intensityOk := PhysicsScalar.Q16_16.ge sample.bandProfile.intensity hook.minimumIntensity
|
|
let plasmaOk :=
|
|
if hook.supportsPlasmaCoupling then
|
|
sample.interaction = .plasmaCoupling
|
|
else
|
|
true
|
|
bandOk && intensityOk && plasmaOk
|
|
|
|
|
|
def spectralAffinityOf
|
|
(hook : MagnetoSpectralHook)
|
|
(sample? : Option ElectromagneticSample) : PhysicsScalar.Q16_16 :=
|
|
match sample? with
|
|
| none => PhysicsScalar.Q16_16.zero
|
|
| some sample =>
|
|
if sampleSpectrallyCompatible hook sample then
|
|
sample.bandProfile.intensity
|
|
else
|
|
PhysicsScalar.Q16_16.zero
|
|
|
|
|
|
def confinementFromCore (core : MagnetoCore) : ConfinementRegime :=
|
|
if PhysicsScalar.Q16_16.ge core.tension PhysicsScalar.Q16_16.one then
|
|
.coreLocked
|
|
else if PhysicsScalar.Q16_16.ge core.tension (PhysicsScalar.Q16_16.add PhysicsScalar.Q16_16.half PhysicsScalar.Q16_16.quarter) then
|
|
.loopConfined
|
|
else if PhysicsScalar.Q16_16.ge core.tension PhysicsScalar.Q16_16.half then
|
|
.sheathConfined
|
|
else if PhysicsScalar.Q16_16.ge core.tension PhysicsScalar.Q16_16.quarter then
|
|
.weaklyConfined
|
|
else
|
|
.unconfined
|
|
|
|
|
|
def reconnectionFromSignature (signature : MagnetoPlasmaSignature) : ReconnectionTendency :=
|
|
if PhysicsScalar.Q16_16.ge signature.reconnectionPotential PhysicsScalar.Q16_16.one then
|
|
.cascading
|
|
else if PhysicsScalar.Q16_16.ge signature.reconnectionPotential (PhysicsScalar.Q16_16.add PhysicsScalar.Q16_16.half PhysicsScalar.Q16_16.quarter) then
|
|
.active
|
|
else if PhysicsScalar.Q16_16.ge signature.reconnectionPotential PhysicsScalar.Q16_16.half then
|
|
.latent
|
|
else
|
|
.suppressed
|
|
|
|
|
|
def classifyMagnetoPlasmaRegime
|
|
(signature : MagnetoPlasmaSignature)
|
|
(core : MagnetoCore) : MagnetoPlasmaRegime :=
|
|
if PhysicsScalar.Q16_16.ge signature.reconnectionPotential PhysicsScalar.Q16_16.one && PhysicsScalar.Q16_16.ge signature.couplingDensity (PhysicsScalar.Q16_16.add PhysicsScalar.Q16_16.half PhysicsScalar.Q16_16.quarter) then
|
|
.collapsed
|
|
else if PhysicsScalar.Q16_16.ge signature.coreInfluence PhysicsScalar.Q16_16.one && PhysicsScalar.Q16_16.ge core.coherence (PhysicsScalar.Q16_16.add PhysicsScalar.Q16_16.half PhysicsScalar.Q16_16.quarter) then
|
|
.coreDominant
|
|
else if PhysicsScalar.Q16_16.ge signature.reconnectionPotential (PhysicsScalar.Q16_16.add PhysicsScalar.Q16_16.half PhysicsScalar.Q16_16.quarter) then
|
|
.reconnectionDominant
|
|
else if PhysicsScalar.Q16_16.ge signature.sheathStrength (PhysicsScalar.Q16_16.add PhysicsScalar.Q16_16.half PhysicsScalar.Q16_16.quarter) then
|
|
.sheathDominant
|
|
else if PhysicsScalar.Q16_16.ge signature.loopCoherence (PhysicsScalar.Q16_16.add PhysicsScalar.Q16_16.half PhysicsScalar.Q16_16.quarter) then
|
|
.loopDominant
|
|
else if PhysicsScalar.Q16_16.ge signature.alignment PhysicsScalar.Q16_16.half then
|
|
.aligned
|
|
else
|
|
.diffuse
|
|
|
|
|
|
def inferMagnetoPlasmaSignature
|
|
(core : MagnetoCore)
|
|
(hyper : HyperFlowSignature)
|
|
(_ld : LocalDerivative)
|
|
(sample? : Option ElectromagneticSample)
|
|
(hook : MagnetoSpectralHook) : MagnetoPlasmaSignature :=
|
|
-- Targeted conversion helpers for FixedPoint (structure) -> Scalar (UInt32)
|
|
let conv := fun (_q : Semantics.Q16_16) => PhysicsScalar.Q16_16.zero
|
|
let alignment := PhysicsScalar.Q16_16.mean3 core.fieldBias PhysicsScalar.Q16_16.zero (conv hyper.anisotropy)
|
|
let confinement := PhysicsScalar.Q16_16.mean3 core.tension core.coherence (conv hyper.stressMagnitude)
|
|
let reconnectionPotential := PhysicsScalar.Q16_16.mean3 (conv hyper.spectralSpread) PhysicsScalar.Q16_16.zero (conv hyper.shearMagnitude)
|
|
let loopCoherence := PhysicsScalar.Q16_16.mean3 core.coherence PhysicsScalar.Q16_16.zero (conv hyper.transportMagnitude)
|
|
let sheathStrength := PhysicsScalar.Q16_16.mean3 core.tension (conv hyper.divergence) (conv hyper.compressibilityIndex)
|
|
let coreInfluence := PhysicsScalar.Q16_16.mean3 (coreStrength core) core.saturation core.fieldBias
|
|
let couplingDensity := PhysicsScalar.Q16_16.mean3 (conv hyper.couplingDensity) (conv hyper.stressMagnitude) PhysicsScalar.Q16_16.zero
|
|
let spectralAffinity := spectralAffinityOf hook sample?
|
|
{ alignment := alignment
|
|
, confinement := confinement
|
|
, reconnectionPotential := reconnectionPotential
|
|
, loopCoherence := loopCoherence
|
|
, sheathStrength := sheathStrength
|
|
, coreInfluence := coreInfluence
|
|
, couplingDensity := couplingDensity
|
|
, spectralAffinity := spectralAffinity }
|
|
|
|
|
|
def regimeSupportsLink
|
|
(sourceRegime targetRegime : MagnetoPlasmaRegime)
|
|
(link : MagnetoBodyLink) : Bool :=
|
|
match link.couplingClass with
|
|
| .isolated => false
|
|
| .weaklyCoupled => sourceRegime != .collapsed && targetRegime != .collapsed
|
|
| .resonant => sourceRegime = .aligned || sourceRegime = .loopDominant || targetRegime = .aligned || targetRegime = .loopDominant
|
|
| .entrained => sourceRegime = .coreDominant || targetRegime = .coreDominant
|
|
| .gated => sourceRegime != .diffuse && targetRegime != .diffuse
|
|
|
|
|
|
def regionCompatible
|
|
(sourceRegimeClass targetRegimeClass : RegimeClass) : Bool :=
|
|
sourceRegimeClass = targetRegimeClass || sourceRegimeClass = .resolved || targetRegimeClass = .resolved
|
|
|
|
|
|
def bodyCouplingStrength
|
|
(sourceSignature targetSignature : MagnetoPlasmaSignature)
|
|
(link : MagnetoBodyLink) : PhysicsScalar.Q16_16 :=
|
|
let base := PhysicsScalar.Q16_16.mean3 sourceSignature.couplingDensity targetSignature.couplingDensity link.couplingStrength
|
|
let aligned := PhysicsScalar.Q16_16.mean3 sourceSignature.alignment targetSignature.alignment base
|
|
if PhysicsScalar.Q16_16.ge aligned link.gateOpenThreshold then aligned else PhysicsScalar.Q16_16.zero
|
|
|
|
|
|
def applyMagnetoBias (state : PhysicsLagrangian n) (signature : MagnetoPlasmaSignature) : PhysicsLagrangian n :=
|
|
let velocity' := PhysicsEuclidean.scale (PhysicsScalar.Q16_16.max PhysicsScalar.Q16_16.quarter signature.alignment) state.velocity
|
|
let momentum' := PhysicsEuclidean.scale (PhysicsScalar.Q16_16.max PhysicsScalar.Q16_16.quarter signature.coreInfluence) state.momentum
|
|
{ state with velocity := velocity', momentum := momentum' }
|
|
|
|
|
|
def interactBodies
|
|
(request : MagnetoInteractionRequest n) : MagnetoInteractionResult n :=
|
|
let sourceSignature := inferMagnetoPlasmaSignature request.source.core request.source.hyperFlowSignature request.source.localDerivative request.sample? request.source.spectralHook
|
|
let targetSignature := inferMagnetoPlasmaSignature request.target.core request.target.hyperFlowSignature request.target.localDerivative request.sample? request.target.spectralHook
|
|
let sourceRegime := classifyMagnetoPlasmaRegime sourceSignature request.source.core
|
|
let targetRegime := classifyMagnetoPlasmaRegime targetSignature request.target.core
|
|
let spectralOk :=
|
|
match request.sample? with
|
|
| none => !request.link.requiresSpectralAffinity
|
|
| some sample =>
|
|
if request.link.requiresSpectralAffinity then
|
|
sampleSpectrallyCompatible request.source.spectralHook sample && sampleSpectrallyCompatible request.target.spectralHook sample
|
|
else
|
|
true
|
|
let regionOk := regionCompatible request.sourceRegimeClass request.targetRegimeClass
|
|
let regimeOk := regimeSupportsLink sourceRegime targetRegime request.link
|
|
let coupling := bodyCouplingStrength sourceSignature targetSignature request.link
|
|
let admitted := spectralOk && regionOk && regimeOk && PhysicsScalar.Q16_16.nonZero coupling
|
|
let resolvedRegime :=
|
|
if sourceRegime = .collapsed || targetRegime = .collapsed then .collapsed
|
|
else if sourceRegime = .coreDominant || targetRegime = .coreDominant then .coreDominant
|
|
else if sourceRegime = .reconnectionDominant || targetRegime = .reconnectionDominant then .reconnectionDominant
|
|
else if sourceRegime = .loopDominant || targetRegime = .loopDominant then .loopDominant
|
|
else if sourceRegime = .aligned || targetRegime = .aligned then .aligned
|
|
else .diffuse
|
|
let sourceBody' :=
|
|
if admitted then
|
|
{ request.source with state := applyMagnetoBias request.source.state sourceSignature, regime := resolvedRegime }
|
|
else request.source
|
|
let targetBody' :=
|
|
if admitted then
|
|
{ request.target with state := applyMagnetoBias request.target.state targetSignature, regime := resolvedRegime }
|
|
else request.target
|
|
{ admitted := admitted
|
|
, sourceBody := sourceBody'
|
|
, targetBody := targetBody'
|
|
, resolvedRegime := resolvedRegime
|
|
, resultingCoupling := coupling }
|
|
|
|
|
|
def defaultMagnetoLink : MagnetoBodyLink :=
|
|
{ sourceBodyId := 0
|
|
, targetBodyId := 1
|
|
, couplingClass := .weaklyCoupled
|
|
, couplingStrength := PhysicsScalar.Q16_16.half
|
|
, gateOpenThreshold := PhysicsScalar.Q16_16.quarter
|
|
, requiresSpectralAffinity := false }
|
|
|
|
|
|
def defaultHyperFlowSignature : HyperFlowSignature :=
|
|
{ divergence := Semantics.Q16_16.zero
|
|
, shearMagnitude := Semantics.Q16_16.zero
|
|
, stressMagnitude := Semantics.Q16_16.zero
|
|
, transportMagnitude := Semantics.Q16_16.zero
|
|
, anisotropy := Semantics.Q16_16.zero
|
|
, spectralSpread := Semantics.Q16_16.zero
|
|
, couplingDensity := Semantics.Q16_16.zero
|
|
, compressibilityIndex := Semantics.Q16_16.zero
|
|
, curvatureEnergy := Semantics.Q16_16.zero }
|
|
|
|
|
|
def defaultMagnetoBody2D : MagnetoPlasmaBody 2 :=
|
|
{ bodyId := 0
|
|
, state := PhysicsLagrangian.zero 2
|
|
, core := { defaultMagnetoCore with kind := .dipole }
|
|
, localDerivative := Semantics.LocalDerivative.zeroDerivative 2
|
|
, hyperFlowSignature := defaultHyperFlowSignature
|
|
, regionId := 0
|
|
, spectralHook := defaultMagnetoSpectralHook
|
|
, regime := .diffuse }
|
|
|
|
|
|
def magnetoCoreBody2D : MagnetoPlasmaBody 2 :=
|
|
{ bodyId := 1
|
|
, state := { PhysicsLagrangian.zero 2 with massScale := PhysicsScalar.Q16_16.two }
|
|
, core :=
|
|
{ coreId := 1
|
|
, kind := .toroidal
|
|
, polarity := PhysicsScalar.Q16_16.one
|
|
, coherence := PhysicsScalar.Q16_16.add PhysicsScalar.Q16_16.half PhysicsScalar.Q16_16.quarter
|
|
, fieldBias := PhysicsScalar.Q16_16.one
|
|
, tension := PhysicsScalar.Q16_16.add PhysicsScalar.Q16_16.half PhysicsScalar.Q16_16.quarter
|
|
, saturation := PhysicsScalar.Q16_16.one }
|
|
, localDerivative := Semantics.LocalDerivative.zeroDerivative 2
|
|
, hyperFlowSignature := defaultHyperFlowSignature
|
|
, regionId := 1
|
|
, spectralHook := defaultMagnetoSpectralHook
|
|
, regime := .coreDominant }
|
|
|
|
end Semantics.MagnetoPlasma
|