Download spec/type-rules.md from Snapkitty/sovereign-forge: direct link, hf CLI and curl.
- Browser
- Download file 6.05 kB
-
https://huggingface.co/Snapkitty/sovereign-forge/resolve/main/spec/type-rules.md
- Command line
-
hf download hf://Snapkitty/sovereign-forge/spec/type-rules.md
-
curl -L -o type-rules.md https://huggingface.co/Snapkitty/sovereign-forge/resolve/main/spec/type-rules.md
Sovereign Stack Machine: Type Rules (Formal)
Version: 1.0.0
Judgment Forms
Ξ β’ p β (Ο, O, Ξ')
where:
Ξ = input stack type
p = program (instruction sequence)
Ο = type of computed value (if any)
O = generated obligations
Ξ' = output stack type
Forward Type Inference (Deterministic)
Algorithm: infer(p: List Instr, Ξβ: StackType) β (Ξ_out: StackType, O: List Obligation) βͺ Error
Base Case: Empty program
Ξ β’ [] β (unit, [], Ξ)
Inductive Step:
Ξ β’ i β (Ο, O_i, Ξ') Ξ' β’ p β (Ο', O_p, Ξ'')
ββββββββββββββββββββββββββββββββββββββββββββββββββββ
Ξ β’ (i :: p) β (Ο', O_i ++ O_p, Ξ'')
Individual Instruction Rules
Push x
Ξ β’ Push x β (int64_t, [], Scalar :: Ξ)
Dup
h β Ξ Ξ = h :: t
βββββββββββββββββββ
Ξ β’ Dup β (unit, [], h :: h :: t)
Error: Stack empty
Swap
Ξ = hβ :: hβ :: t
βββββββββββββββββββ
Ξ β’ Swap β (unit, [], hβ :: hβ :: t)
Error: Fewer than 2 elements
Add
Case 1: Scalar + Scalar
Ξ = Scalar :: Scalar :: t
βββββββββββββββββββββββββββ
Ξ β’ Add β (unit, [AddBounds], Scalar :: t)
Case 2: Vec n + Vec n
Ξ = Vec n :: Vec n :: t
βββββββββββββββββββββββββββ
Ξ β’ Add β (unit, [VecAddBounds n], Vec n :: t)
Case 3: Mat m n + Mat m n
Ξ = Mat m n :: Mat m n :: t
ββββββββββββββββββββββββββββββ
Ξ β’ Add β (unit, [MatAddBounds m n], Mat m n :: t)
Error: Shape mismatch
MatPush m n
ββββββββββββββββββββββββ
Ξ β’ MatPush m n β (unit, [], Mat m n :: Ξ)
MatFill
Ξ = Mat m n :: Scalar :: ... :: Scalar :: t (m*n scalars)
ββββββββββββββββββββββββββββββββββββββββββββββββ
Ξ β’ MatFill β (unit, [MatFillBounds m n], Mat m n :: t)
Error: Insufficient scalars, or shape mismatch
MatMul
Ξ = Mat m n :: Mat n k :: t
ββββββββββββββββββββββββββββββββββββββββββββ
Ξ β’ MatMul β (unit, [MatMulShape m n k, MatMulBounds m n k], Mat m k :: t)
Obligations:
MatMulShape m n k: Assert n values match (compile-time, runtime check)MatMulBounds m n k: No overflow in any element
Error: Shape mismatch
MatTrans
Ξ = Mat m n :: t
ββββββββββββββββββ
Ξ β’ MatTrans β (unit, [], Mat n m :: t)
MatAug
Ξ = Mat m nβ :: Mat m nβ :: t
ββββββββββββββββββββββββββββββββ
Ξ β’ MatAug β (unit, [MatAugShape m nβ nβ], Mat m (nβ + nβ) :: t)
Error: Row mismatch
Inv
Ξ = Proof("Invertible") :: Mat n n :: t
βββββββββββββββββββββββββββββββββββββββββββ
Ξ β’ Inv β (unit, [InvBounds n], Mat n n :: t)
Obligation: InvBounds n β check no overflow in Gauss-Jordan steps
Error: Non-square, or missing proof
Solve
Ξ = Proof("Invertible") :: Mat n 1 :: Mat n n :: t
βββββββββββββββββββββββββββββββββββββββββββββββββββ
Ξ β’ Solve β (unit, [SolveBounds n], Mat n 1 :: t)
Lstsq
Ξ = Proof("FullColumnRank") :: Mat m 1 :: Mat m n :: t (m β₯ n)
βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ
Ξ β’ Lstsq β (unit, [LstsqBounds m n], Mat n 1 :: t)
VerifyInv
Ξ = Mat n n :: Mat n n :: t
ββββββββββββββββββββββββββββ
Ξ β’ VerifyInv β (unit, [VerifyInvObligation n], Proof("InvOK") :: t)
Obligation: VerifyInvObligation n β verify A*X == I
VerifySol
Ξ = Mat n 1 :: Mat n n :: Mat n 1 :: t
ββββββββββββββββββββββββββββββββββββββ
Ξ β’ VerifySol β (unit, [VerifySolObligation n], Proof("SolOK") :: t)
VerifyLstsq
Ξ = Mat n 1 :: Mat m n :: Mat m 1 :: t (m β₯ n)
ββββββββββββββββββββββββββββββββββββββββββββββββββ
Ξ β’ VerifyLstsq β (unit, [VerifyLstsqObligation m n], Proof("LstsqOK") :: t)
Unification Algorithm
For symbolic dimensions in branching code (not in core ISA):
unify(Οβ: ValType, Οβ: ValType) β (Substitution βͺ Conflict)
Base cases:
unify(Scalar, Scalar) = {}
unify(Vec nβ, Vec nβ) = if nβ == nβ then {} else Conflict("Vec dimension mismatch")
unify(Mat mβ nβ, Mat mβ nβ) = if mβ==mβ && nβ==nβ then {} else Conflict(...)
unify(Οβ, Οβ) when Οβ β Οβ = Conflict("Type mismatch")
Apply substitution:
apply(Ο: Substitution, Ξ: StackType) : StackType
Completeness & Soundness
Completeness: If a program is valid (no underflow, correct shapes), infer succeeds and produces Ξ'.
Soundness: If infer(p, Ξ) succeeds with (Ξ', O), then execution of p starting with stack type Ξ produces stack type Ξ' and only generates obligations in O.
Proof: By induction on program length and instruction structure. Each instruction rule preserves type safety and obligation correctness.
END TYPE RULES