mirror of
https://github.com/allaunthefox/Research-Stack.git
synced 2026-07-31 03:05:21 +00:00
189 lines
6.8 KiB
Text
189 lines
6.8 KiB
Text
/-
|
|
Semantics/Decoder.lean - Model 141 Self-Instantiating Weird Machine
|
|
|
|
This module implements the OISC-SLUG3 engine as described in the N-Folded MMR
|
|
Gossip EBML Schema. It executes 27 ternary opcodes while enforcing
|
|
Integrability and Stability constraints from the simulation manifold.
|
|
|
|
Lean is the source of truth.
|
|
-/
|
|
|
|
import Mathlib.Data.Nat.Basic
|
|
import Mathlib.Data.Int.Basic
|
|
import Semantics.DynamicCanal
|
|
import Semantics.BraidBracket
|
|
import Semantics.Connectors
|
|
import Semantics.FixedPoint
|
|
import Semantics.SLUG3
|
|
|
|
namespace Semantics.Decoder
|
|
|
|
open DynamicCanal
|
|
open Semantics.BraidBracket
|
|
open Semantics.Connectors
|
|
open Semantics.Q16_16
|
|
open Semantics.BraidBracket
|
|
open Semantics.ManifoldFlow
|
|
open Semantics.SLUG3
|
|
|
|
/-- Machine State for Model 141 -/
|
|
structure MachineState where
|
|
pc : Nat
|
|
stack : List Q16_16
|
|
memory : Array Q16_16
|
|
exhausted : Bool
|
|
frustPrevX : BraidBracket.PhaseVec -- Hardware cache for P_{m-1}
|
|
frustAniso : AnisotropyTensor -- Hardware cache for A_ij
|
|
|
|
/-- Initial state with 1024 words of memory -/
|
|
def MachineState.init (initialMem : List Q16_16) : MachineState :=
|
|
{ pc := 0
|
|
, stack := []
|
|
, memory := (initialMem ++ (List.replicate (1024 - initialMem.length) Q16_16.zero)).toArray
|
|
, exhausted := false
|
|
, frustPrevX := BraidBracket.PhaseVec.zero
|
|
, frustAniso := { xx := Q16_16.zero, xy := Q16_16.zero, yy := Q16_16.zero } }
|
|
|
|
instance : Inhabited MachineState := ⟨MachineState.init []⟩
|
|
|
|
namespace Ports
|
|
def ioIn : Int := -1
|
|
def ioOut : Int := -2
|
|
def frustPrevX : Int := -23
|
|
def frustAniso : Int := -24
|
|
def frustResult : Int := -25
|
|
end Ports
|
|
|
|
/-- Instruction format: 6 bytes
|
|
[Opcode (1) | OperandA (2) | OperandB (2) | Result (1)]
|
|
-/
|
|
structure Instruction where
|
|
op : OISCOp
|
|
argA : Q16_16
|
|
argB : Q16_16
|
|
dest : Nat
|
|
|
|
/-- Native Port Reading Header -/
|
|
def MachineState.read (state : MachineState) (addr : Int) : Q16_16 :=
|
|
if addr >= 0 then
|
|
if _hSize : 0 < state.memory.size then
|
|
state.memory[addr.toNat % state.memory.size]!
|
|
else
|
|
Q16_16.zero
|
|
else match addr with
|
|
| -25 => -- frustResult
|
|
interlockingEnergy BraidBracket.PhaseVec.zero state.frustPrevX state.frustAniso
|
|
| _ => Q16_16.zero
|
|
|
|
/-- Native Port Writing Header -/
|
|
def MachineState.write (state : MachineState) (addr : Int) (val : Q16_16) : MachineState :=
|
|
if addr >= 0 then
|
|
if _hSize : 0 < state.memory.size then
|
|
let idx := addr.toNat % state.memory.size
|
|
{ state with memory := state.memory.set! idx val }
|
|
else
|
|
state
|
|
else match addr with
|
|
| -23 => { state with frustPrevX := { x := val, y := Q16_16.zero : PhaseVec } }
|
|
| -24 => { state with frustAniso := { xx := val, xy := Q16_16.zero, yy := Q16_16.zero } }
|
|
| _ => state
|
|
|
|
def MachineState.pcUpdate (state : MachineState) (n : Nat) : MachineState :=
|
|
{ state with pc := state.pc + n }
|
|
|
|
/-- Execute a single SLUG-3 Opcode update to the state -/
|
|
def executeOp (state : MachineState) (inst : Instruction) : MachineState :=
|
|
let a := inst.argA
|
|
let b := inst.argB
|
|
let nextState := match inst.op with
|
|
| .nop => { state with pc := state.pc + 1 }
|
|
| .add =>
|
|
let res := a + b
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .sub =>
|
|
let res := a - b
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .mul =>
|
|
let res := a * b
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .div =>
|
|
let res := a / b
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .min =>
|
|
let res := Q16_16.min a b
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .max =>
|
|
let res := Q16_16.max a b
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .abs =>
|
|
let res := Q16_16.abs a
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .neg =>
|
|
let res := -a
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .shl =>
|
|
let res := a * Q16_16.ofFloat ((2 ^ (a.val.toNat % 16)).toFloat)
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .shr =>
|
|
let res := a / Q16_16.ofFloat ((2 ^ (a.val.toNat % 16)).toFloat)
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .and =>
|
|
let res : Q16_16 := ⟨a.val &&& b.val⟩
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .or =>
|
|
let res : Q16_16 := ⟨a.val ||| b.val⟩
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .xor =>
|
|
let res : Q16_16 := ⟨a.val ^^^ b.val⟩
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .eq =>
|
|
let res := if a == b then Q16_16.one else Q16_16.zero
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .lt =>
|
|
let res := if a.val < b.val then Q16_16.one else Q16_16.zero
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .gt =>
|
|
let res := if a.val > b.val then Q16_16.one else Q16_16.zero
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .load =>
|
|
let res := state.read (Int.ofNat a.val.toNat)
|
|
MachineState.pcUpdate (state.write (Int.ofNat inst.dest) res) 1
|
|
| .store =>
|
|
MachineState.pcUpdate (state.write (Int.ofNat a.val.toNat) b) 1
|
|
| .jmp => { state with pc := a.val.toNat % state.memory.size }
|
|
| .jz =>
|
|
if a.val == 0 then { state with pc := b.val.toNat % state.memory.size }
|
|
else { state with pc := state.pc + 1 }
|
|
| .jnz =>
|
|
if a.val != 0 then { state with pc := b.val.toNat % state.memory.size }
|
|
else { state with pc := state.pc + 1 }
|
|
| .call =>
|
|
{ state with pc := a.val.toNat % state.memory.size, stack := Q16_16.ofFloat (state.pc + 1).toFloat :: state.stack }
|
|
| .ret =>
|
|
match state.stack with
|
|
| [] => { state with exhausted := true }
|
|
| s :: ss => { state with pc := s.val.toNat % state.memory.size, stack := ss }
|
|
| .dup => { state with stack := a :: state.stack, pc := state.pc + 1 }
|
|
| .drop =>
|
|
match state.stack with
|
|
| [] => { state with pc := state.pc + 1 }
|
|
| _ :: ss => { state with stack := ss, pc := state.pc + 1 }
|
|
| .halt => { state with exhausted := true }
|
|
nextState
|
|
|
|
def interlockingEnergyPort
|
|
(currentX prevX : BraidBracket.PhaseVec)
|
|
(a : AnisotropyTensor) : Q16_16 :=
|
|
interlockingEnergy currentX prevX a
|
|
|
|
def guardIntegrity (_state : MachineState) (v : BraidBracket.PhaseVec) (acc : BraidBracket.PhaseVec) (ε : Q16_16) : Bool :=
|
|
-- Link to Connector 1
|
|
isIntegrable (BraidBracket.PhaseVec.add acc v) [v] ε
|
|
|
|
/-- Max Bandwidth Guard: Link to Connector 2 (Parcae/OMT) -/
|
|
def guardBandwidth (norm : SpectralNorm) (nodes : Nat) (τ : Q16_16) (ops : Nat) : Bool :=
|
|
-- Halt if operations per frame exceed bandwidth Ω_max
|
|
let limit := (omegaMax norm nodes τ).val.toNat
|
|
ops < limit
|
|
|
|
end Semantics.Decoder
|