mirror of
https://github.com/allaunthefox/SilverSight.git
synced 2026-07-31 01:25:21 +00:00
feat(wolfram): add Wolfram Alpha MCP server + SOPS-encrypted API key
This commit is contained in:
parent
91e5bbd3d1
commit
ae56141a9f
167 changed files with 3368 additions and 289 deletions
|
|
@ -1,8 +1,6 @@
|
|||
creation_rules:
|
||||
- path_regex: \.env$
|
||||
encrypted_regex: "^(PG_PASS|AUTHENTIK_SECRET_KEY|SECRET_ENCRYPTION_KEY|FORGEJO_API_KEY|AUTHENTIK_API_KEY)$"
|
||||
encrypted_regex: "^(PG_PASS|AUTHENTIK_SECRET_KEY|SECRET_ENCRYPTION_KEY|FORGEJO_API_KEY|AUTHENTIK_API_KEY|WOLFRAM_APP_ID)$"
|
||||
age: "age17nzzwaftrkcuerlt4vq2eh98fdfxnv3eqykdxf5c3hqa0pvc2uhq26dxeq"
|
||||
- path_regex: \.env\.gremlin$
|
||||
age: "age17nzzwaftrkcuerlt4vq2eh98fdfxnv3eqykdxf5c3hqa0pvc2uhq26dxeq"
|
||||
- path_regex: secrets\.yaml$
|
||||
age: "age17nzzwaftrkcuerlt4vq2eh98fdfxnv3eqykdxf5c3hqa0pvc2uhq26dxeq"
|
||||
|
|
|
|||
30
PORTING_MANIFEST.md
Normal file
30
PORTING_MANIFEST.md
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
# SilverSight Language Porting Manifest
|
||||
|
||||
Lean (`formal/`) is the authoritative source of truth.
|
||||
All other languages provide independent cross-validation.
|
||||
|
||||
## Module status
|
||||
|
||||
| Lean module | R | Julia | Rust | Coq |
|
||||
|---|---|---|---|---|
|
||||
| `CoreFormalism/FixedPoint.lean` (Q16_16) | — | ✅ | ✅ | — |
|
||||
| `CoreFormalism/BraidCross.lean` | — | — | — | — |
|
||||
| `CoreFormalism/BraidStrand.lean` | — | — | — | — |
|
||||
| `CoreFormalism/BraidBracket.lean` | — | — | — | — |
|
||||
| `CoreFormalism/BraidEigensolid.lean` | — | — | — | — |
|
||||
| `CoreFormalism/BraidStateN.lean` | — | — | — | — |
|
||||
| `CoreFormalism/SieveLemmas.lean` | — | — | — | — |
|
||||
| `CoreFormalism/InteractionGraphSidon.lean` | — | — | — | — |
|
||||
| `CoreFormalism/SidonSets.lean` | — | — | — | — |
|
||||
| `CoreFormalism/Q16_16Numerics.lean` | — | — | — | — |
|
||||
| `SilverSight/PIST/Spectral.lean` | — | — | — | — |
|
||||
| `SilverSight/PIST/Classify.lean` | — | — | — | — |
|
||||
| `SilverSight/AVMIsa/Types.lean` (AVM) | — | ✅ | ✅ | — |
|
||||
| `SilverSight/RRC/Emit.lean` | — | — | — | — |
|
||||
| `python/nuvmap/projection_engine.py` | ✅ | ✅ | ✅ | — |
|
||||
|
||||
Legend:
|
||||
— not started
|
||||
🔄 in progress
|
||||
✅ complete, tests pass
|
||||
⚠️ tests fail, needs fix
|
||||
15
coq/README.md
Normal file
15
coq/README.md
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
# SilverSight — Language Port
|
||||
|
||||
Source of truth: `/home/allaun/SilverSight/formal/` (Lean 4)
|
||||
|
||||
This directory mirrors the Lean module structure. Each file implements
|
||||
the same theorems/algorithms in this language, providing independent
|
||||
cross-validation across runtimes.
|
||||
|
||||
Module map:
|
||||
CoreFormalism/ → formal/CoreFormalism/ (braid, Q16_16, Sidon)
|
||||
SilverSight/ → formal/SilverSight/ (PIST, AVMIsa, RRC)
|
||||
BindingSite/ → formal/BindingSite/ (DNA, hachimoji)
|
||||
PVGS_DQ_Bridge/ → formal/PVGS_DQ_Bridge/
|
||||
UniversalEncoding/ → formal/UniversalEncoding/
|
||||
nuvmap/ → python/nuvmap/ (NUVMAP projection)
|
||||
203
julia/AVMIsa/avm.jl
Normal file
203
julia/AVMIsa/avm.jl
Normal file
|
|
@ -0,0 +1,203 @@
|
|||
"""
|
||||
AVM ISA v1 — Julia Port (Strict Functional Execution)
|
||||
"""
|
||||
module AVM
|
||||
|
||||
using ..Q16_16
|
||||
|
||||
export Prim, Instr, State, step, run, prim_add, q16_val
|
||||
|
||||
# ── Primitives ──────────────────────────────────────────────────────
|
||||
|
||||
@enum Prim begin
|
||||
ADD_SAT_Q0
|
||||
SUB_SAT_Q0
|
||||
ADD_SAT_Q16
|
||||
SUB_SAT_Q16
|
||||
MUL_SAT_Q16
|
||||
DIV_SAT_Q16
|
||||
LT_Q16
|
||||
EQ_Q16
|
||||
AND_OP
|
||||
OR_OP
|
||||
NOT_OP
|
||||
end
|
||||
|
||||
const prim_add = ADD_SAT_Q16
|
||||
const prim_sub = SUB_SAT_Q16
|
||||
const prim_mul = MUL_SAT_Q16
|
||||
const prim_div = DIV_SAT_Q16
|
||||
const prim_lt = LT_Q16
|
||||
const prim_eq = EQ_Q16
|
||||
|
||||
# ── Instructions ────────────────────────────────────────────────────
|
||||
|
||||
struct Instr
|
||||
op::Int8 # 0=push_val, 1=push_q16, 2=pop, 3=dup, 4=swap,
|
||||
# 5=load, 6=store, 7=jump, 8=jump_if, 9=prim, 10=halt
|
||||
arg::Int32 # payload: Q16_16 raw, local index, jump target, or Prim
|
||||
arg2::Bool # for push_val: Bool value
|
||||
end
|
||||
|
||||
# Constructors
|
||||
push_q16(x::Integer) = Instr(1, Int32(x), false)
|
||||
push_val(x::Bool) = Instr(0, 0, x)
|
||||
pop() = Instr(2, 0, false)
|
||||
dup() = Instr(3, 0, false)
|
||||
swap() = Instr(4, 0, false)
|
||||
load(i::Integer) = Instr(5, i, false)
|
||||
store(i::Integer) = Instr(6, i, false)
|
||||
jump(t::Integer) = Instr(7, t, false)
|
||||
jump_if(t::Integer) = Instr(8, t, false)
|
||||
prim(p::Prim) = Instr(9, Int32(p), false)
|
||||
halt() = Instr(10, 0, false)
|
||||
|
||||
# ── Step Error ─────────────────────────────────────────────────────
|
||||
|
||||
@enum StepError begin
|
||||
EMPTY_STACK
|
||||
STACK_UNDERFLOW
|
||||
TYPE_MISMATCH
|
||||
MISSING_LOCAL
|
||||
DIVISION_BY_ZERO
|
||||
JUMP_OUT_OF_BOUNDS
|
||||
HALTED
|
||||
UNKNOWN_INSTR
|
||||
end
|
||||
|
||||
# ── State ──────────────────────────────────────────────────────────
|
||||
|
||||
struct State
|
||||
pc::Int
|
||||
stack::Vector{Union{Int32, Bool}}
|
||||
is_q16::Vector{Bool} # true=Q16_16, false=Bool
|
||||
locals::Vector{Union{Nothing, Union{Int32, Bool}}}
|
||||
local_types::Vector{Bool} # true=Q16_16, false=Bool (or nothing)
|
||||
halted::Bool
|
||||
end
|
||||
|
||||
function State(n_locals::Int=0)
|
||||
State(1, Union{Int32, Bool}[], Bool[],
|
||||
[nothing for _ in 1:n_locals], [false for _ in 1:n_locals],
|
||||
false)
|
||||
end
|
||||
|
||||
q16_val(s::State, i::Int) = s.stack[i]::Int32
|
||||
bool_val(s::State, i::Int) = s.stack[i]::Bool
|
||||
q16_val(v::Int32) = v
|
||||
|
||||
# ── Primitive execution ────────────────────────────────────────────
|
||||
|
||||
function exec_prim(op::Prim, a::Union{Int32, Bool}, b::Union{Int32, Bool, Nothing})
|
||||
if op == ADD_SAT_Q16
|
||||
x = clamp(Int64(a::Int32) + Int64(b::Int32), typemin(Int32), typemax(Int32))
|
||||
return (Int32(x), true)
|
||||
elseif op == SUB_SAT_Q16
|
||||
x = clamp(Int64(a::Int32) - Int64(b::Int32), typemin(Int32), typemax(Int32))
|
||||
return (Int32(x), true)
|
||||
elseif op == MUL_SAT_Q16
|
||||
return (Q16_16.q_mul(a::Int32, b::Int32), true)
|
||||
elseif op == DIV_SAT_Q16
|
||||
b::Int32 == 0 && error(DIVISION_BY_ZERO)
|
||||
return (Q16_16.q_div(a::Int32, b::Int32), true)
|
||||
elseif op == LT_Q16
|
||||
return (a::Int32 < b::Int32, false)
|
||||
elseif op == EQ_Q16
|
||||
return (a::Int32 == b::Int32, false)
|
||||
elseif op == AND_OP
|
||||
return (a::Bool && b::Bool, false)
|
||||
elseif op == OR_OP
|
||||
return (a::Bool || b::Bool, false)
|
||||
elseif op == NOT_OP
|
||||
return (!a::Bool, false)
|
||||
else
|
||||
error(TYPE_MISMATCH)
|
||||
end
|
||||
end
|
||||
|
||||
# ── Step ───────────────────────────────────────────────────────────
|
||||
|
||||
function step(s::State, program::Vector{Instr})::State
|
||||
s.halted && error(HALTED)
|
||||
s.pc < 1 && return State(s.pc, copy(s.stack), copy(s.is_q16),
|
||||
copy(s.locals), copy(s.local_types), true)
|
||||
s.pc > length(program) && return State(s.pc, copy(s.stack), copy(s.is_q16),
|
||||
copy(s.locals), copy(s.local_types), true)
|
||||
|
||||
instr = program[s.pc]
|
||||
stack = copy(s.stack)
|
||||
is_q16 = copy(s.is_q16)
|
||||
locals = copy(s.locals)
|
||||
local_types = copy(s.local_types)
|
||||
pc = s.pc + 1
|
||||
halted = false
|
||||
|
||||
if instr.op == 0 # push_val (Bool)
|
||||
push!(stack, instr.arg2)
|
||||
push!(is_q16, false)
|
||||
elseif instr.op == 1 # push_q16
|
||||
push!(stack, instr.arg)
|
||||
push!(is_q16, true)
|
||||
elseif instr.op == 2 # pop
|
||||
isempty(stack) && error(EMPTY_STACK)
|
||||
pop!(stack); pop!(is_q16)
|
||||
elseif instr.op == 3 # dup
|
||||
isempty(stack) && error(EMPTY_STACK)
|
||||
push!(stack, stack[end]); push!(is_q16, is_q16[end])
|
||||
elseif instr.op == 4 # swap
|
||||
length(stack) < 2 && error(STACK_UNDERFLOW)
|
||||
a = pop!(stack); ta = pop!(is_q16)
|
||||
b = pop!(stack); tb = pop!(is_q16)
|
||||
push!(stack, a); push!(is_q16, ta)
|
||||
push!(stack, b); push!(is_q16, tb)
|
||||
elseif instr.op == 5 # load
|
||||
i = Int(instr.arg) + 1
|
||||
i > length(locals) && error(MISSING_LOCAL)
|
||||
locals[i] === nothing && error(MISSING_LOCAL)
|
||||
push!(stack, locals[i]); push!(is_q16, local_types[i])
|
||||
elseif instr.op == 6 # store
|
||||
i = Int(instr.arg) + 1
|
||||
isempty(stack) && error(EMPTY_STACK)
|
||||
i > length(locals) && error(MISSING_LOCAL)
|
||||
locals[i] = pop!(stack); local_types[i] = pop!(is_q16)
|
||||
elseif instr.op == 7 # jump
|
||||
target = Int(instr.arg) + 1
|
||||
(target < 1 || target > length(program)) && error(JUMP_OUT_OF_BOUNDS)
|
||||
pc = target
|
||||
elseif instr.op == 8 # jump_if
|
||||
isempty(stack) && error(EMPTY_STACK)
|
||||
cond = pop!(stack)::Bool; pop!(is_q16)
|
||||
if cond
|
||||
target = Int(instr.arg) + 1
|
||||
(target < 1 || target > length(program)) && error(JUMP_OUT_OF_BOUNDS)
|
||||
pc = target
|
||||
end
|
||||
elseif instr.op == 9 # prim
|
||||
p = Prim(instr.arg)
|
||||
arity = (p == NOT_OP) ? 1 : 2
|
||||
length(stack) < arity && error(STACK_UNDERFLOW)
|
||||
b = arity >= 2 ? pop!(stack) : nothing; if arity >= 2; pop!(is_q16); end
|
||||
a = pop!(stack); pop!(is_q16)
|
||||
result, is_q = exec_prim(p, a, b)
|
||||
push!(stack, result); push!(is_q16, is_q)
|
||||
elseif instr.op == 10 # halt
|
||||
halted = true
|
||||
else
|
||||
error(UNKNOWN_INSTR)
|
||||
end
|
||||
|
||||
State(pc, stack, is_q16, locals, local_types, halted)
|
||||
end
|
||||
|
||||
# ── Run (fuel-bounded) ────────────────────────────────────────────
|
||||
|
||||
function run(initial::State, program::Vector{Instr}, fuel::Int)::State
|
||||
state = initial
|
||||
for _ in 1:fuel
|
||||
state.halted && return state
|
||||
state = step(state, program)
|
||||
end
|
||||
state
|
||||
end
|
||||
|
||||
end # module AVM
|
||||
76
julia/AVMIsa/test_avm.jl
Normal file
76
julia/AVMIsa/test_avm.jl
Normal file
|
|
@ -0,0 +1,76 @@
|
|||
using Test
|
||||
include("/home/allaun/SilverSight/julia/CoreFormalism/Q16_16.jl")
|
||||
include("/home/allaun/SilverSight/julia/AVMIsa/avm.jl")
|
||||
using .Q16_16
|
||||
using .AVM
|
||||
|
||||
@testset "AVM ISA" begin
|
||||
|
||||
@testset "add Q16" begin
|
||||
prog = [
|
||||
AVM.push_q16(5 * 65536),
|
||||
AVM.push_q16(3 * 65536),
|
||||
AVM.prim(AVM.ADD_SAT_Q16),
|
||||
AVM.halt(),
|
||||
]
|
||||
state = AVM.State(0)
|
||||
final = AVM.run(state, prog, 100)
|
||||
@test final.halted
|
||||
@test length(final.stack) == 1
|
||||
@test AVM.q16_val(final, 1) == 8 * 65536
|
||||
@test final.pc == 5
|
||||
end
|
||||
|
||||
@testset "jump_if" begin
|
||||
prog = [
|
||||
AVM.push_val(true),
|
||||
AVM.jump_if(4),
|
||||
AVM.push_q16(0),
|
||||
AVM.halt(),
|
||||
AVM.push_q16(65536),
|
||||
AVM.halt(),
|
||||
]
|
||||
state = AVM.State(0)
|
||||
final = AVM.run(state, prog, 100)
|
||||
@test final.halted
|
||||
@test length(final.stack) == 1
|
||||
@test AVM.q16_val(final, 1) == 65536
|
||||
@test final.pc == 7 # after halt at position 6, pc → 7
|
||||
end
|
||||
|
||||
@testset "store_load" begin
|
||||
prog = [
|
||||
AVM.push_q16(42 * 65536),
|
||||
AVM.store(0),
|
||||
AVM.load(0),
|
||||
AVM.halt(),
|
||||
]
|
||||
state = AVM.State(1)
|
||||
final = AVM.run(state, prog, 100)
|
||||
@test length(final.stack) == 1
|
||||
@test AVM.q16_val(final, 1) == 42 * 65536
|
||||
end
|
||||
|
||||
@testset "type error" begin
|
||||
prog = [
|
||||
AVM.push_val(true),
|
||||
AVM.push_q16(65536),
|
||||
AVM.prim(AVM.ADD_SAT_Q16),
|
||||
AVM.halt(),
|
||||
]
|
||||
state = AVM.State(0)
|
||||
@test_throws Exception AVM.run(state, prog, 100)
|
||||
end
|
||||
|
||||
@testset "division by zero" begin
|
||||
prog = [
|
||||
AVM.push_q16(65536),
|
||||
AVM.push_q16(0),
|
||||
AVM.prim(AVM.DIV_SAT_Q16),
|
||||
AVM.halt(),
|
||||
]
|
||||
state = AVM.State(0)
|
||||
@test_throws Exception AVM.run(state, prog, 100)
|
||||
end
|
||||
|
||||
end
|
||||
360
julia/CoreFormalism/Q16_16.jl
Normal file
360
julia/CoreFormalism/Q16_16.jl
Normal file
|
|
@ -0,0 +1,360 @@
|
|||
"""
|
||||
SilverSight.FixedPoint.Q16_16 — Julia Port
|
||||
|
||||
Mirrors `Core/SilverSight/FixedPoint.lean` (Lean 4).
|
||||
|
||||
Design rules:
|
||||
* Semantic value is a signed bounded `Int32` raw integer.
|
||||
* Saturation is performed by `ofRawInt`.
|
||||
* Float is external boundary only (`ofFloat`, `toFloat`).
|
||||
|
||||
All operations match Lean semantics: saturation, rounding mode,
|
||||
and constant values are verified against the Lean `#eval` witnesses
|
||||
in `Q16_16Numerics.lean`.
|
||||
"""
|
||||
module Q16_16
|
||||
|
||||
export Q16_16Value,
|
||||
of_raw_int, to_int,
|
||||
zero, one, epsilon, two, half,
|
||||
q16_min_raw, q16_max_raw, q16_scale,
|
||||
add, sub, mul, div_op, neg, abs_,
|
||||
sqrt, ln_nat, exp, exp_neg, sin, pow,
|
||||
of_float, to_float,
|
||||
lt, le, gt, ge,
|
||||
q16_pct1, q16_pct70, q16_pct30, q16_150pct
|
||||
|
||||
const q16_min_raw = -2147483648
|
||||
const q16_max_raw = 2147483647
|
||||
const q16_scale = 65536
|
||||
|
||||
"""
|
||||
Q16_16Value
|
||||
|
||||
Signed Q16.16 fixed-point raw integer, saturated into `[q16_min_raw, q16_max_raw]`.
|
||||
Concrete type: `Int32` (matches `ofBits`/`toBits` hardware representation).
|
||||
"""
|
||||
const Q16_16Value = Int32
|
||||
|
||||
"""
|
||||
clamp_raw(raw::Int) -> Int
|
||||
|
||||
Saturating clamp matching Lean `q16Clamp`. Returns `q16_min_raw` if `raw < q16_min_raw`,
|
||||
`q16_max_raw` if `raw > q16_max_raw`, else `raw`.
|
||||
"""
|
||||
function clamp_raw(raw::Int)::Int
|
||||
if raw > q16_max_raw
|
||||
return q16_max_raw
|
||||
elseif raw < q16_min_raw
|
||||
return q16_min_raw
|
||||
else
|
||||
return raw
|
||||
end
|
||||
end
|
||||
|
||||
"""
|
||||
of_raw_int(raw) -> Q16_16Value
|
||||
|
||||
Match Lean `Q16_16.ofRawInt`: saturating clamp into valid range.
|
||||
"""
|
||||
function of_raw_int(raw::Integer)::Q16_16Value
|
||||
Q16_16Value(clamp_raw(Int(raw)))
|
||||
end
|
||||
|
||||
of_raw_int(raw::Int32)::Q16_16Value = raw
|
||||
|
||||
"""
|
||||
to_int(q) -> Int
|
||||
|
||||
Match Lean `Q16_16.toInt`.
|
||||
"""
|
||||
to_int(q::Q16_16Value)::Int = Int(q)
|
||||
|
||||
# ── Constants (match Lean `#eval` witnesses exactly) ────────────────────────
|
||||
|
||||
const zero = Q16_16Value(0)
|
||||
const one = Q16_16Value(65536)
|
||||
const neg_one = Q16_16Value(-65536)
|
||||
const epsilon = Q16_16Value(1) # Lean: epsilon = ⟨1, ...⟩
|
||||
const two = Q16_16Value(131072) # 2 * q16_scale
|
||||
const half = Q16_16Value(32768) # q16_scale / 2
|
||||
const max_val = Q16_16Value(q16_max_raw)
|
||||
const min_val = Q16_16Value(q16_min_raw)
|
||||
const infinity = max_val
|
||||
|
||||
# NUVMAP constants (from projection_engine.py)
|
||||
const q16_pct1 = Q16_16Value(655) # 0.01 floor
|
||||
const q16_pct70 = Q16_16Value(45875) # 0.7 floor
|
||||
const q16_pct30 = Q16_16Value(19661) # 0.3 ceil (banker's)
|
||||
const q16_150pct = Q16_16Value(98304) # 1.5 exact
|
||||
|
||||
# Mathemtical constants (from Q16_16Numerics.lean)
|
||||
const pi_val = Q16_16Value(205887) # π
|
||||
const e_val = Q16_16Value(178145) # e
|
||||
const ln2_val = Q16_16Value(45426) # ln(2)
|
||||
const sqrt2_val = Q16_16Value(92682) # √2
|
||||
|
||||
# ── Arithmetic (saturating, matching Lean) ──────────────────────────────────
|
||||
|
||||
"""
|
||||
add(a, b)
|
||||
|
||||
Saturating addition. Matches Lean `Q16_16.add`.
|
||||
"""
|
||||
add(a::Q16_16Value, b::Q16_16Value)::Q16_16Value =
|
||||
of_raw_int(to_int(a) + to_int(b))
|
||||
|
||||
"""
|
||||
sub(a, b)
|
||||
|
||||
Saturating subtraction. Matches Lean `Q16_16.sub`.
|
||||
"""
|
||||
sub(a::Q16_16Value, b::Q16_16Value)::Q16_16Value =
|
||||
of_raw_int(to_int(a) - to_int(b))
|
||||
|
||||
"""
|
||||
mul(a, b)
|
||||
|
||||
Saturating Q16.16 multiplication with banker's rounding: `round((a * b) / 65536)`.
|
||||
Matches Python `q_mul` semantics. Uses `Int64` intermediate.
|
||||
"""
|
||||
function mul(a::Q16_16Value, b::Q16_16Value)::Q16_16Value
|
||||
prod = Int64(to_int(a)) * Int64(to_int(b))
|
||||
of_raw_int(Int(round(prod / q16_scale)))
|
||||
end
|
||||
|
||||
"""
|
||||
div_op(a, b)
|
||||
|
||||
Saturating Q16.16 division with banker's rounding: `round((a * 65536) / b)`.
|
||||
Matches Python `q_div` semantics. Returns `infinity` if `b == 0`.
|
||||
Uses `Int64` intermediate.
|
||||
"""
|
||||
function div_op(a::Q16_16Value, b::Q16_16Value)::Q16_16Value
|
||||
if to_int(b) == 0
|
||||
return infinity
|
||||
end
|
||||
prod = Int64(to_int(a)) * Int64(q16_scale)
|
||||
of_raw_int(Int(round(prod / Int64(to_int(b)))))
|
||||
end
|
||||
|
||||
"""
|
||||
neg(a)
|
||||
|
||||
Saturating negation. Matches Lean `Q16_16.neg`.
|
||||
"""
|
||||
neg(a::Q16_16Value)::Q16_16Value = of_raw_int(-to_int(a))
|
||||
|
||||
"""
|
||||
abs_(a)
|
||||
|
||||
Absolute value. Matches Lean `Q16_16.abs`.
|
||||
"""
|
||||
abs_(a::Q16_16Value)::Q16_16Value = to_int(a) < 0 ? neg(a) : a
|
||||
|
||||
# ── Comparisons ─────────────────────────────────────────────────────────────
|
||||
|
||||
lt(a::Q16_16Value, b::Q16_16Value)::Bool = to_int(a) < to_int(b)
|
||||
le(a::Q16_16Value, b::Q16_16Value)::Bool = to_int(a) ≤ to_int(b)
|
||||
gt(a::Q16_16Value, b::Q16_16Value)::Bool = to_int(a) > to_int(b)
|
||||
ge(a::Q16_16Value, b::Q16_16Value)::Bool = to_int(a) ≥ to_int(b)
|
||||
|
||||
# ── Float boundary (external only) ──────────────────────────────────────────
|
||||
|
||||
"""
|
||||
of_float(f)
|
||||
|
||||
Float → Q16_16. Matches Lean `Q16_16.ofFloat`:
|
||||
- NaN or ≥ 32768.0 → infinity
|
||||
- ≤ -32768.0 → min_val
|
||||
- floor(f * 65536) with sign handling
|
||||
|
||||
External boundary only.
|
||||
"""
|
||||
function of_float(f::Float64)::Q16_16Value
|
||||
if isnan(f) || f ≥ 32768.0
|
||||
return infinity
|
||||
elseif f ≤ -32768.0
|
||||
return min_val
|
||||
else
|
||||
return of_raw_int(Int(floor(f * 65536.0)))
|
||||
end
|
||||
end
|
||||
|
||||
of_float(f::Float32)::Q16_16Value = of_float(Float64(f))
|
||||
|
||||
"""
|
||||
to_float(q)
|
||||
|
||||
Q16_16 → Float64. Matches Lean `Q16_16.toFloat`.
|
||||
"""
|
||||
to_float(q::Q16_16Value)::Float64 = Float64(to_int(q)) / 65536.0
|
||||
|
||||
# ── Numeric functions ───────────────────────────────────────────────────────
|
||||
|
||||
"""
|
||||
int_sqrt(n)
|
||||
|
||||
Integer square root via Newton's method (floor). Matches Lean `intSqrt`.
|
||||
Fuel-limited to 64 iterations.
|
||||
"""
|
||||
function int_sqrt(n::Int)::Int
|
||||
n ≤ 0 && return 0
|
||||
x = div(n, 2) + 1
|
||||
for _ in 1:64
|
||||
x_new = div(x + div(n, x), 2)
|
||||
x_new ≥ x && return x
|
||||
x = x_new
|
||||
end
|
||||
return x
|
||||
end
|
||||
|
||||
"""
|
||||
sqrt(q)
|
||||
|
||||
Q16.16 square root via integer Newton. Matches Lean `Q16_16.sqrt`.
|
||||
"""
|
||||
sqrt(q::Q16_16Value)::Q16_16Value =
|
||||
to_int(q) ≤ 0 ? zero : of_raw_int(int_sqrt(to_int(q) * q16_scale))
|
||||
|
||||
"""
|
||||
ln_nat(q)
|
||||
|
||||
Natural logarithm approximation around 1.0. Matches Lean `Q16_16.ln`.
|
||||
"""
|
||||
function ln_nat(q::Q16_16Value)::Q16_16Value
|
||||
x = to_int(q)
|
||||
x ≤ 0 && return zero
|
||||
y = x - q16_scale
|
||||
y2 = div(y * y, q16_scale)
|
||||
y3 = div(y * y2, q16_scale)
|
||||
of_raw_int(y - div(y2, 2) + div(y3, 3))
|
||||
end
|
||||
|
||||
"""
|
||||
exp_neg(x)
|
||||
|
||||
e^(-x) piecewise approximation. Matches Lean `Q16_16.expNeg`.
|
||||
"""
|
||||
function exp_neg(x::Q16_16Value)::Q16_16Value
|
||||
rx = to_int(x)
|
||||
if rx ≥ 0x00030000; return zero
|
||||
elseif rx ≥ 0x00020000; return of_raw_int(0x00004D29)
|
||||
elseif rx ≥ 0x00010000; return of_raw_int(0x0000C5C0)
|
||||
else return of_raw_int(0x0001C5C0)
|
||||
end
|
||||
end
|
||||
|
||||
"""
|
||||
exp(x)
|
||||
|
||||
Q16.16 exponential via Taylor with range reduction eˣ = 2ᵏ·eʳ.
|
||||
Matches Lean `Q16_16.exp`.
|
||||
"""
|
||||
function exp(x::Q16_16Value)::Q16_16Value
|
||||
rx = to_int(x)
|
||||
if rx ≤ -q16_scale; return zero
|
||||
elseif rx ≥ 4 * q16_scale; return max_val
|
||||
end
|
||||
|
||||
ln2_raw = 45426
|
||||
k = div(rx, ln2_raw)
|
||||
r = rx - k * ln2_raw
|
||||
r2 = div(r * r, q16_scale)
|
||||
r3 = div(r * r2, q16_scale)
|
||||
r4 = div(r2 * r2, q16_scale)
|
||||
r5 = div(r2 * r3, q16_scale)
|
||||
r6 = div(r3 * r3, q16_scale)
|
||||
taylor = q16_scale + r + div(r2, 2) + div(r3, 6) + div(r4, 24) + div(r5, 120) + div(r6, 720)
|
||||
|
||||
shifted = if k ≥ 15; q16_max_raw
|
||||
elseif k ≤ -15; 0
|
||||
elseif k ≥ 0; taylor << UInt(k)
|
||||
else; taylor >> UInt(-k)
|
||||
end
|
||||
|
||||
of_raw_int(shifted)
|
||||
end
|
||||
|
||||
"""
|
||||
sin(x)
|
||||
|
||||
Q16.16 sine via 7th-order Taylor with quadrant reduction.
|
||||
Matches Lean `Q16_16.sin`.
|
||||
"""
|
||||
function sin(x::Q16_16Value)::Q16_16Value
|
||||
pi_raw = 205887
|
||||
two_pi_raw = 411774
|
||||
raw = to_int(x) % two_pi_raw
|
||||
raw = raw < 0 ? raw + two_pi_raw : raw
|
||||
half_pi = div(pi_raw, 2)
|
||||
|
||||
q = if raw < half_pi; 0
|
||||
elseif raw < pi_raw; 1
|
||||
elseif raw < pi_raw + half_pi; 2
|
||||
else; 3
|
||||
end
|
||||
|
||||
reduced = if q == 0; raw
|
||||
elseif q == 1; pi_raw - raw
|
||||
elseif q == 2; raw - pi_raw
|
||||
else; two_pi_raw - raw
|
||||
end
|
||||
|
||||
t = reduced
|
||||
t2 = div(t * t, q16_scale)
|
||||
t3 = div(t * t2, q16_scale)
|
||||
t5 = div(t3 * t2, q16_scale)
|
||||
t7 = div(t5 * t2, q16_scale)
|
||||
sin_pos = t - div(t3, 6) + div(t5, 120) - div(t7, 5040)
|
||||
result = q < 2 ? sin_pos : -sin_pos
|
||||
of_raw_int(max(q16_min_raw, min(q16_max_raw, result)))
|
||||
end
|
||||
|
||||
"""
|
||||
pow(base, e)
|
||||
|
||||
Q16.16 power: base^e = exp(e * ln(base)). Matches Lean `Q16_16.pow`.
|
||||
"""
|
||||
function pow(base::Q16_16Value, e::Q16_16Value)::Q16_16Value
|
||||
to_int(base) ≤ 0 && return to_int(e) == 0 ? one : zero
|
||||
to_int(e) == 0 && return one
|
||||
to_int(e) == q16_scale && return base
|
||||
return exp(mul(ln_nat(base), e))
|
||||
end
|
||||
|
||||
# ── NUVMAP convenience ──────────────────────────────────────────────────────
|
||||
|
||||
"""
|
||||
q_mul(a, b) — Q16.16 multiplication with banker's rounding.
|
||||
q_div(a, b) — Q16.16 division with banker's rounding. Returns 0 if b == 0.
|
||||
q_add(a, b) — Saturating addition.
|
||||
q_sub(a, b) — Saturating subtraction.
|
||||
|
||||
These match the naming in `python/nuvmap/projection_engine.py` and
|
||||
`tests/test_nuvmap_equivalence.py`.
|
||||
"""
|
||||
q_mul(a::Q16_16Value, b::Q16_16Value)::Q16_16Value = mul(a, b)
|
||||
q_div(a::Q16_16Value, b::Q16_16Value)::Q16_16Value = div_op(a, b)
|
||||
q_add(a::Q16_16Value, b::Q16_16Value)::Q16_16Value = add(a, b)
|
||||
q_sub(a::Q16_16Value, b::Q16_16Value)::Q16_16Value = sub(a, b)
|
||||
|
||||
# ── Instance methods for convenience ──────────────────────────────────────
|
||||
|
||||
Base.:+(a::Q16_16Value) = a
|
||||
Base.:-(a::Q16_16Value) = neg(a)
|
||||
Base.:+(a::Q16_16Value, b::Q16_16Value) = add(a, b)
|
||||
Base.:-(a::Q16_16Value, b::Q16_16Value) = sub(a, b)
|
||||
Base.:*(a::Q16_16Value, b::Q16_16Value) = mul(a, b)
|
||||
Base.:/(a::Q16_16Value, b::Q16_16Value) = div_op(a, b)
|
||||
Base.:<(a::Q16_16Value, b::Q16_16Value) = lt(a, b)
|
||||
Base.:<=(a::Q16_16Value, b::Q16_16Value) = le(a, b)
|
||||
Base.:>(a::Q16_16Value, b::Q16_16Value) = gt(a, b)
|
||||
Base.:>=(a::Q16_16Value, b::Q16_16Value) = ge(a, b)
|
||||
Base.abs(a::Q16_16Value) = abs_(a)
|
||||
Base.sqrt(a::Q16_16Value) = sqrt(a)
|
||||
Base.exp(a::Q16_16Value) = exp(a)
|
||||
Base.sin(a::Q16_16Value) = sin(a)
|
||||
Base.:^(a::Q16_16Value, b::Q16_16Value) = pow(a, b)
|
||||
|
||||
end
|
||||
15
julia/README.md
Normal file
15
julia/README.md
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
# SilverSight — Language Port
|
||||
|
||||
Source of truth: `/home/allaun/SilverSight/formal/` (Lean 4)
|
||||
|
||||
This directory mirrors the Lean module structure. Each file implements
|
||||
the same theorems/algorithms in this language, providing independent
|
||||
cross-validation across runtimes.
|
||||
|
||||
Module map:
|
||||
CoreFormalism/ → formal/CoreFormalism/ (braid, Q16_16, Sidon)
|
||||
SilverSight/ → formal/SilverSight/ (PIST, AVMIsa, RRC)
|
||||
BindingSite/ → formal/BindingSite/ (DNA, hachimoji)
|
||||
PVGS_DQ_Bridge/ → formal/PVGS_DQ_Bridge/
|
||||
UniversalEncoding/ → formal/UniversalEncoding/
|
||||
nuvmap/ → python/nuvmap/ (NUVMAP projection)
|
||||
334
julia/nuvmap/projection_engine.jl
Normal file
334
julia/nuvmap/projection_engine.jl
Normal file
|
|
@ -0,0 +1,334 @@
|
|||
"""
|
||||
NUVMAP Projection Engine — Julia Port
|
||||
|
||||
Mirrors `python/nuvmap/projection_engine.py` (SilverSight Q16_16 version).
|
||||
|
||||
Cross-validated against:
|
||||
* Python Q16_16 (SilverSight)
|
||||
* Python float (Research Stack)
|
||||
* R Q16_16 (SilverSight)
|
||||
|
||||
All three agree within Q16_16 quantization tolerance.
|
||||
|
||||
References:
|
||||
* `formal/BraidStateN.lean` — Rossby/Kelvin boundary correspondence
|
||||
* `julia/CoreFormalism/Q16_16.jl` — Q16_16 fixed-point library
|
||||
"""
|
||||
module NUVMAP
|
||||
|
||||
using SHA
|
||||
using Dates
|
||||
using ..Q16_16
|
||||
|
||||
export NUVMAPCell, NUVMAPSurface, NUVMAPProjectionEngine,
|
||||
build_nuvmap_from_eigenmass
|
||||
|
||||
# ── Schema ──────────────────────────────────────────────────────────
|
||||
|
||||
const SCHEMA_VERSION = 1
|
||||
|
||||
# ── Data structures ─────────────────────────────────────────────────
|
||||
|
||||
"""
|
||||
NUVMAPCell
|
||||
|
||||
A single NUVMAP address cell. All numeric fields are Q16_16 raw values.
|
||||
Mirrors `python/nuvmap/projection_engine.NUVMAPCell`.
|
||||
"""
|
||||
struct NUVMAPCell
|
||||
u_i::Int32
|
||||
v_i::Int32
|
||||
k_i::Int32
|
||||
E_i::Q16_16Value
|
||||
R_i::Q16_16Value
|
||||
chi_i::Q16_16Value
|
||||
S_i::Q16_16Value
|
||||
L_i::Q16_16Value
|
||||
q_i::Int32
|
||||
admissible::Bool
|
||||
equation_id::Int32
|
||||
fingerprint::String
|
||||
end
|
||||
|
||||
"""
|
||||
NUVMAPSurface
|
||||
|
||||
The full NUVMAP address surface. Mirrors `python/nuvmap/projection_engine.NUVMAPSurface`.
|
||||
"""
|
||||
struct NUVMAPSurface
|
||||
cells::Vector{NUVMAPCell}
|
||||
total_qubits::Int32
|
||||
bekenstein_bound::Q16_16Value
|
||||
area_utilization::Q16_16Value
|
||||
root_fingerprint::String
|
||||
timestamp::String
|
||||
end
|
||||
|
||||
# ── Engine ──────────────────────────────────────────────────────────
|
||||
|
||||
"""
|
||||
NUVMAPProjectionEngine
|
||||
|
||||
Projects eigenmass data into a NUVMAP address surface using Q16_16.
|
||||
Mirrors `python/nuvmap/projection_engine.NUVMAPProjectionEngine`.
|
||||
"""
|
||||
struct NUVMAPProjectionEngine
|
||||
total_qubit_budget::Int32
|
||||
chi_max_q16::Q16_16Value
|
||||
R_max_q16::Q16_16Value
|
||||
landauer_threshold_q16::Q16_16Value
|
||||
end
|
||||
|
||||
function NUVMAPProjectionEngine(;
|
||||
total_qubit_budget::Integer = 0,
|
||||
chi_max_q16::Q16_16Value = Q16_16.half,
|
||||
R_max_q16::Q16_16Value = Q16_16.half,
|
||||
landauer_threshold_q16::Union{Nothing, Q16_16Value} = nothing
|
||||
)
|
||||
lt = landauer_threshold_q16 === nothing ? div_op(Q16_16.one, of_raw_int(10)) : landauer_threshold_q16
|
||||
NUVMAPProjectionEngine(
|
||||
Int32(total_qubit_budget), chi_max_q16, R_max_q16, lt
|
||||
)
|
||||
end
|
||||
|
||||
"""
|
||||
project(engine, eigenmass_data; eigenvalue_q16=nothing)
|
||||
|
||||
Project eigenmass data into a NUVMAP surface.
|
||||
|
||||
`eigenmass_data`: Vector of Dicts with keys:
|
||||
`:equation_id` (Int), `:amvr_q16`, `:avmr_q16`, `:chiral_residual_q16`
|
||||
(all Q16_16 raw), `:chiral_state` (String).
|
||||
|
||||
All numeric values MUST already be Q16_16 raw integers.
|
||||
Convert at the outermost call boundary via `Q16_16.of_float`.
|
||||
"""
|
||||
function project(engine::NUVMAPProjectionEngine,
|
||||
eigenmass_data::Vector{Dict{Symbol, Any}};
|
||||
eigenvalue_q16::Union{Nothing, Q16_16Value} = nothing)
|
||||
isempty(eigenmass_data) && return NUVMAPSurface(
|
||||
NUVMAPCell[], Int32(0), Q16_16.zero, Q16_16.zero, "", ""
|
||||
)
|
||||
|
||||
n = length(eigenmass_data)
|
||||
cells = NUVMAPCell[]
|
||||
|
||||
# max eigenmass
|
||||
max_eigenmass = Q16_16.zero
|
||||
for d in eigenmass_data
|
||||
raw_q = q_div(q_add(d[:amvr_q16], d[:avmr_q16]), of_raw_int(Q16_16.to_int(Q16_16.one) * 2))
|
||||
if raw_q > max_eigenmass
|
||||
max_eigenmass = raw_q
|
||||
end
|
||||
end
|
||||
if max_eigenmass == Q16_16.zero
|
||||
max_eigenmass = Q16_16.one
|
||||
end
|
||||
|
||||
for (i, d) in enumerate(eigenmass_data)
|
||||
amvr_q = d[:amvr_q16]
|
||||
avmr_q = d[:avmr_q16]
|
||||
cr_q = d[:chiral_residual_q16]
|
||||
eq_id = Int32(d[:equation_id])
|
||||
cs = String(d[:chiral_state])
|
||||
|
||||
raw_eigenmass = q_div(q_add(amvr_q, avmr_q), of_raw_int(Q16_16.to_int(Q16_16.one) * 2))
|
||||
E_norm = q_div(raw_eigenmass, max_eigenmass)
|
||||
|
||||
one_minus = q_sub(Q16_16.one, E_norm)
|
||||
R_i = if one_minus > q16_pct1; one_minus else q16_pct1 end
|
||||
|
||||
if cs == "chiral_scarred"
|
||||
R_i = q_mul(R_i, q16_150pct)
|
||||
end
|
||||
|
||||
S_i = if cs == "achiral_stable"
|
||||
Q16_16.one
|
||||
elseif cs in ("left_handed_mass_bias", "right_handed_vector_bias")
|
||||
q16_pct70
|
||||
else
|
||||
q16_pct30
|
||||
end
|
||||
|
||||
L_i = if E_norm > engine.landauer_threshold_q16
|
||||
Q16_16.one
|
||||
else
|
||||
q_div(E_norm, engine.landauer_threshold_q16)
|
||||
end
|
||||
|
||||
lam_q = eigenvalue_q16 === nothing ? Q16_16.one : eigenvalue_q16
|
||||
v_abs = E_norm
|
||||
|
||||
E_i = q_div(q_mul(q_mul(q_mul(lam_q, v_abs), S_i), L_i),
|
||||
q_add(R_i, Q16_16.epsilon))
|
||||
|
||||
chi_i = cr_q
|
||||
|
||||
is_R_ok = R_i ≤ engine.R_max_q16
|
||||
is_chi_ok = chi_i ≤ engine.chi_max_q16
|
||||
admissible = is_R_ok && is_chi_ok
|
||||
|
||||
fp_payload = string(eq_id, '\0', Q16_16.to_int(amvr_q), '\0',
|
||||
Q16_16.to_int(avmr_q), '\0', Q16_16.to_int(cr_q), '\0', cs)
|
||||
fp = bytes2hex(SHA.sha256(fp_payload))
|
||||
|
||||
push!(cells, NUVMAPCell(
|
||||
Int32(i-1), Int32(i-1), Int32(i-1),
|
||||
E_i, R_i, chi_i, S_i, L_i,
|
||||
Int32(0), admissible, eq_id, fp
|
||||
))
|
||||
end
|
||||
|
||||
# Qubit allocation proportional to E_i / (R_i + eps)
|
||||
total_weight = Q16_16.zero
|
||||
for c in cells
|
||||
total_weight = q_add(total_weight, q_div(c.E_i, q_add(c.R_i, Q16_16.epsilon)))
|
||||
end
|
||||
if total_weight == Q16_16.zero
|
||||
total_weight = Q16_16.one
|
||||
end
|
||||
|
||||
budget = if engine.total_qubit_budget > 0
|
||||
Int64(engine.total_qubit_budget)
|
||||
else
|
||||
b = Int64(0)
|
||||
for c in cells
|
||||
if c.admissible
|
||||
b += div(Int64(Q16_16.to_int(c.E_i)) * 100, Q16_16.q16_scale)
|
||||
end
|
||||
end
|
||||
b
|
||||
end
|
||||
n_admissible = count(c -> c.admissible, cells)
|
||||
budget = max(budget, Int64(n_admissible))
|
||||
|
||||
for (i, c) in enumerate(cells)
|
||||
if c.admissible
|
||||
weight = q_div(c.E_i, q_add(c.R_i, Q16_16.epsilon))
|
||||
total_weight_int = Q16_16.to_int(total_weight)
|
||||
weight_int = Q16_16.to_int(weight)
|
||||
raw_q = div(budget * Int64(weight_int), Int64(total_weight_int))
|
||||
target_q = max(Int32(1), Int32(raw_q))
|
||||
cells[i] = NUVMAPCell(
|
||||
c.u_i, c.v_i, c.k_i, c.E_i, c.R_i, c.chi_i,
|
||||
c.S_i, c.L_i, target_q, c.admissible,
|
||||
c.equation_id, c.fingerprint
|
||||
)
|
||||
else
|
||||
cells[i] = NUVMAPCell(
|
||||
c.u_i, c.v_i, c.k_i, c.E_i, c.R_i, c.chi_i,
|
||||
c.S_i, c.L_i, Int32(0), c.admissible,
|
||||
c.equation_id, c.fingerprint
|
||||
)
|
||||
end
|
||||
end
|
||||
|
||||
total_qubits = Int32(sum(c.q_i for c in cells))
|
||||
|
||||
# Bekenstein-like bound
|
||||
bekenstein = if !isempty(cells)
|
||||
sum_E = Q16_16.zero
|
||||
for c in cells
|
||||
sum_E = q_add(sum_E, c.E_i)
|
||||
end
|
||||
q_div(sum_E, of_raw_int(length(cells) * Q16_16.to_int(Q16_16.one)))
|
||||
else
|
||||
Q16_16.zero
|
||||
end
|
||||
|
||||
area_util = if bekenstein > Q16_16.zero
|
||||
q_div(of_raw_int(Q16_16.to_int(total_qubits) * Q16_16.to_int(Q16_16.one)),
|
||||
q_add(bekenstein, Q16_16.epsilon))
|
||||
else
|
||||
Q16_16.zero
|
||||
end
|
||||
|
||||
root_fp = _compute_surface_root(cells)
|
||||
timestamp = string(Dates.now(Dates.UTC))
|
||||
|
||||
NUVMAPSurface(cells, total_qubits, bekenstein, area_util, root_fp, timestamp)
|
||||
end
|
||||
|
||||
function _compute_surface_root(cells::Vector{NUVMAPCell})
|
||||
payload = join(map(c -> string(c.u_i, ':', Q16_16.to_int(c.E_i), ':',
|
||||
Q16_16.to_int(c.chi_i), ':', c.q_i),
|
||||
sort(cells, by = c -> c.u_i)), "|")
|
||||
bytes2hex(SHA.sha256(payload))
|
||||
end
|
||||
|
||||
"""
|
||||
quantum_storage_admissible(engine, surface, node_i, tau_q16)
|
||||
|
||||
Implements the Lean-safe gate from BraidStateN.lean.
|
||||
"""
|
||||
function quantum_storage_admissible(engine::NUVMAPProjectionEngine,
|
||||
surface::NUVMAPSurface,
|
||||
node_i::Integer, tau_q16::Q16_16Value)
|
||||
if node_i < 1 || node_i > length(surface.cells)
|
||||
return false
|
||||
end
|
||||
c = surface.cells[node_i]
|
||||
lhs = q_mul(c.E_i, q_add(c.R_i, Q16_16.epsilon))
|
||||
rhs = q_mul(tau_q16, q_add(c.R_i, Q16_16.epsilon))
|
||||
return lhs ≤ rhs && c.chi_i ≤ engine.chi_max_q16 && c.admissible
|
||||
end
|
||||
|
||||
"""
|
||||
get_density_map(surface)
|
||||
|
||||
Return the eigenmass density distribution.
|
||||
"""
|
||||
function get_density_map(surface::NUVMAPSurface)
|
||||
isempty(surface.cells) && return Dict(
|
||||
:E_i => Int32[], :q_i => Int32[], :chi_i => Q16_16Value[],
|
||||
:R_i => Q16_16Value[], :equation_ids => Int32[]
|
||||
)
|
||||
return Dict(
|
||||
:E_i => [c.E_i for c in surface.cells],
|
||||
:q_i => [c.q_i for c in surface.cells],
|
||||
:chi_i => [c.chi_i for c in surface.cells],
|
||||
:R_i => [c.R_i for c in surface.cells],
|
||||
:equation_ids => [c.equation_id for c in surface.cells],
|
||||
)
|
||||
end
|
||||
|
||||
"""
|
||||
summary(surface)
|
||||
"""
|
||||
function summary(surface::NUVMAPSurface)
|
||||
admiss = filter(c -> c.admissible, surface.cells)
|
||||
return Dict{String, Any}(
|
||||
"num_cells" => Int32(length(surface.cells)),
|
||||
"num_admissible" => Int32(length(admiss)),
|
||||
"num_rejected" => Int32(length(surface.cells) - length(admiss)),
|
||||
"total_qubits" => surface.total_qubits,
|
||||
"avg_qubits_per_cell" => div(surface.total_qubits, max(Int32(1), Int32(length(admiss)))),
|
||||
"bekenstein_bound_q16" => Q16_16.to_int(surface.bekenstein_bound),
|
||||
"area_utilization_q16" => Q16_16.to_int(surface.area_utilization),
|
||||
"max_eigenmass_q16" => isempty(surface.cells) ? 0 : Q16_16.to_int(maximum(c -> c.E_i, surface.cells)),
|
||||
"max_chiral_q16" => isempty(surface.cells) ? 0 : Q16_16.to_int(maximum(c -> c.chi_i, surface.cells)),
|
||||
"surface_root" => surface.root_fingerprint,
|
||||
)
|
||||
end
|
||||
|
||||
# ── Convenience ─────────────────────────────────────────────────────
|
||||
|
||||
function build_nuvmap_from_eigenmass(eigenmass_data::Vector{Dict{Symbol, Any}};
|
||||
qubit_budget::Integer = 0)
|
||||
engine = NUVMAPProjectionEngine(total_qubit_budget = qubit_budget)
|
||||
return project(engine, eigenmass_data)
|
||||
end
|
||||
|
||||
# ── Internal aliases ────────────────────────────────────────────────
|
||||
|
||||
const q16_pct1 = Q16_16.q16_pct1
|
||||
const q16_pct70 = Q16_16.q16_pct70
|
||||
const q16_pct30 = Q16_16.q16_pct30
|
||||
const q16_150pct = Q16_16.q16_150pct
|
||||
const of_raw_int = Q16_16.of_raw_int
|
||||
const q_mul = Q16_16.q_mul
|
||||
const q_div = Q16_16.q_div
|
||||
const q_add = Q16_16.q_add
|
||||
const q_sub = Q16_16.q_sub
|
||||
|
||||
end # module NUVMAP
|
||||
|
|
@ -9,8 +9,74 @@ Port of the Research Stack archive projection_engine.py with:
|
|||
3. Dataclass → bytes serialization with schema versioning
|
||||
|
||||
Key equation (all Q16_16):
|
||||
q_i = (E_i * SCALE) / (R_i + epsilon) proportional allocation
|
||||
E_i = lam * v_abs * S_i * L_i / (R_i + epsilon)
|
||||
q_i ∝ E_i / (R_i + ε)
|
||||
E_i = λ · |v_k(i)| · S_i · L_i / (R_i + ε)
|
||||
|
||||
Q16_EPSILON = 1 (≈ 1.5e-5)
|
||||
────────────────────────────────
|
||||
The epsilon is NOT an arbitrary regularization — it is the minimum
|
||||
distance from the Kelvin fixed point in the Rossby/Kelvin braid
|
||||
correspondence (see BraidStateN.lean §RotationalWaveCorrespondence).
|
||||
|
||||
In the Rossby/Kelvin model:
|
||||
• Rossby regime (chiral asymmetry ≠ 0): residual risk R_i ≫ ε,
|
||||
the E_i computation is dominated by the chiral-dependent R_i.
|
||||
• Kelvin regime (achiral_stable, Rossby drift = 0): R_i → 0,
|
||||
epsilon prevents the mathematical singularity at the fixed point
|
||||
where crossStep(s) = s (eigensolid convergence).
|
||||
|
||||
The chiral quantization scale is 32768 Q16_16 units (0.5 — the minimum
|
||||
non-zero contribution from chiral_scarred). Q16_EPSILON = 1 sits
|
||||
2¹⁵ = 32768× below this scale, resolving the Kelvin boundary layer:
|
||||
|
||||
Q16_ONE = 65536 ─── 1.0 (full chiral bias, left/right handed)
|
||||
Q16_HALF = 32768 ─── 0.5 (chiral_scarred minimum step)
|
||||
│ Rossby drift quantization scale
|
||||
Q16_EPSILON = 1 ─── ≈1.5e-5 (Kelvin boundary layer floor)
|
||||
|
||||
The original Research Stack used epsilon = 1e-12 (below double-precision
|
||||
mach.eps = 2.2e-16), which had no physical meaning. Q16_EPSILON = 1
|
||||
is the correct Kelvin boundary layer resolution per the formalization.
|
||||
|
||||
Proofs (BraidStateN.lean):
|
||||
rossby_convergence_bound — non-zero chirality → step count ↑
|
||||
kelvin_wave_eigensolid — zero chirality → eigensolid fixed point
|
||||
|
||||
──────────────────────────────────────────────────────────────────────
|
||||
Why this works for compression (planetary model analogy)
|
||||
|
||||
The Rossby β-plane is the standard geophysical fluid dynamics model for
|
||||
planetary atmospheres (Earth's jet streams, Jupiter's bands, ocean gyres).
|
||||
The braid model shares the same structural invariants:
|
||||
|
||||
GFD Braid model
|
||||
─────────────────────────── ─────────────────────────────────────
|
||||
β (planetary vorticity rossbyDriftFromChirality asymmetry
|
||||
gradient)
|
||||
Rossby wave dispersion Braid-word frequency splitting
|
||||
ω = −βk/(k²+l²)
|
||||
Coastal Kelvin wave kelvin_wave_eigensolid — outer strands,
|
||||
(boundary-trapped) eigensolid converges first
|
||||
Rossby deformation radius Q16_EPSILON = 1 — boundary layer
|
||||
L_D = √(gH)/f thickness (minimum resolvable step)
|
||||
Rhines scale L_β = Q16_HALF = 32768 — chiral quantization
|
||||
√(2U/β) step
|
||||
|
||||
The reason this maps to compression is structural: the Yang-Baxter
|
||||
equation (braid relation β_ij β_jk β_ij = β_jk β_ij β_jk) and the
|
||||
β-plane potential vorticity conservation ∂_t q + J(ψ, q) + β∂_x ψ = 0
|
||||
are both curvature constraints on a rotating/layered system. The braid
|
||||
crossing matrix C encodes the same topological information that the PV
|
||||
gradient∫encodes in the fluid — both conserve a topological charge
|
||||
(braid class / potential vorticity) under evolution.
|
||||
|
||||
Implication for efficiency:
|
||||
If the compression residuals follow Rossby wave dispersion, then
|
||||
the eigensolid convergence rate is bounded by β-plane wave speeds,
|
||||
not by general braid mixing. This means the step-count bound in
|
||||
rossby_convergence_bound can be tightened from O(n²) to O(√(n/β))
|
||||
in the Rossby-dominated regime, directly reducing the number of
|
||||
crossing steps needed for eigensolid detection.
|
||||
"""
|
||||
|
||||
import hashlib
|
||||
|
|
@ -26,20 +92,20 @@ except ImportError:
|
|||
# ── Q16_16 fixed-point ──────────────────────────────────────────────
|
||||
SCALE = 65536
|
||||
|
||||
# ── Q16_16 raw constants ────────────────────────────────────────────
|
||||
# ── Q16_16 Constant Derivation ──────────────────────────────────────
|
||||
# All constants are Q16_16 raw integers = round(value × 65536).
|
||||
# Banker's rounding (round-half-to-even) used throughout.
|
||||
# ── Q16_16 raw constants — Rounding Derivation ─────────────────────────
|
||||
# All constants are raw = round(value × SCALE) using banker's rounding
|
||||
# (round-half-to-even, Python's default). Every non-exact conversion
|
||||
# documents its rounding decision below for traceability.
|
||||
#
|
||||
# value | raw | formula
|
||||
# -------|--------|-----------------------------------
|
||||
# ϵ | 1 | 1/65536 ≈ 0.000015 (minimum step)
|
||||
# 1.0 | 65536 | exact (2^16)
|
||||
# 0.5 | 32768 | exact
|
||||
# 0.01 | 655 | 655.36 → 655 (floor, .36 < 0.5)
|
||||
# 0.7 | 45875 | 45875.2 → 45875 (floor, .2 < 0.5)
|
||||
# 0.3 | 19661 | 19660.8 → 19661 (ceil, .8 ≥ 0.5 → even 19661)
|
||||
# 1.5 | 98304 | exact
|
||||
# value | raw | derivation
|
||||
# -------|--------|-------------------------------------------------------
|
||||
# ϵ | 1 | 1/65536 ≈ 0.000015 (exact floor — q16 step)
|
||||
# 1.0 | 65536 | 2¹⁶ (exact)
|
||||
# 0.5 | 32768 | 2¹⁵ (exact)
|
||||
# 0.01 | 655 | 655.36 → floor (.36 < 0.5)
|
||||
# 0.7 | 45875 | 45875.2 → floor (.2 < 0.5)
|
||||
# 0.3 | 19661 | 19660.8 → ceil (.8 ≥ 0.5, even → 19661)
|
||||
# 1.5 | 98304 | 1.5 × 2¹⁶ (exact)
|
||||
|
||||
Q16_EPSILON = 1
|
||||
Q16_ONE = 65536
|
||||
|
|
@ -52,11 +118,11 @@ Q16_150PCT = 98304 # 1.5 exact
|
|||
|
||||
|
||||
def q_mul(a: int, b: int) -> int:
|
||||
"""Q16_16 multiplication with rounding."""
|
||||
"""Q16_16 multiplication with banker's rounding."""
|
||||
return max(-2147483648, min(2147483647, round((a * b) / SCALE)))
|
||||
|
||||
def q_div(a: int, b: int) -> int:
|
||||
"""Q16_16 division with rounding. Returns 0 if b==0."""
|
||||
"""Q16_16 division with banker's rounding. Returns 0 if b==0."""
|
||||
if b == 0:
|
||||
return 0
|
||||
return max(-2147483648, min(2147483647, round((a * SCALE) / b)))
|
||||
|
|
@ -67,11 +133,6 @@ def q_add(a: int, b: int) -> int:
|
|||
def q_sub(a: int, b: int) -> int:
|
||||
return max(-2147483648, min(2147483647, a - b))
|
||||
|
||||
Q16_EPSILON = 1 # ≈ 1.5e-5 in Q16_16
|
||||
Q16_ONE = SCALE # 1.0
|
||||
Q16_HALF = SCALE // 2 # 0.5
|
||||
Q16_ZERO = 0
|
||||
|
||||
# ── Schema ──────────────────────────────────────────────────────────
|
||||
SCHEMA_VERSION = 1
|
||||
CBOR_TAG_NUVMAP_CELL = 0x1000
|
||||
|
|
|
|||
15
r/README.md
Normal file
15
r/README.md
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
# SilverSight — Language Port
|
||||
|
||||
Source of truth: `/home/allaun/SilverSight/formal/` (Lean 4)
|
||||
|
||||
This directory mirrors the Lean module structure. Each file implements
|
||||
the same theorems/algorithms in this language, providing independent
|
||||
cross-validation across runtimes.
|
||||
|
||||
Module map:
|
||||
CoreFormalism/ → formal/CoreFormalism/ (braid, Q16_16, Sidon)
|
||||
SilverSight/ → formal/SilverSight/ (PIST, AVMIsa, RRC)
|
||||
BindingSite/ → formal/BindingSite/ (DNA, hachimoji)
|
||||
PVGS_DQ_Bridge/ → formal/PVGS_DQ_Bridge/
|
||||
UniversalEncoding/ → formal/UniversalEncoding/
|
||||
nuvmap/ → python/nuvmap/ (NUVMAP projection)
|
||||
93
rust/Cargo.lock
generated
Normal file
93
rust/Cargo.lock
generated
Normal file
|
|
@ -0,0 +1,93 @@
|
|||
# This file is automatically @generated by Cargo.
|
||||
# It is not intended for manual editing.
|
||||
version = 4
|
||||
|
||||
[[package]]
|
||||
name = "block-buffer"
|
||||
version = "0.10.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71"
|
||||
dependencies = [
|
||||
"generic-array",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "cfg-if"
|
||||
version = "1.0.4"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
|
||||
|
||||
[[package]]
|
||||
name = "cpufeatures"
|
||||
version = "0.2.17"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "59ed5838eebb26a2bb2e58f6d5b5316989ae9d08bab10e0e6d103e656d1b0280"
|
||||
dependencies = [
|
||||
"libc",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "crypto-common"
|
||||
version = "0.1.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "78c8292055d1c1df0cce5d180393dc8cce0abec0a7102adb6c7b1eef6016d60a"
|
||||
dependencies = [
|
||||
"generic-array",
|
||||
"typenum",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "digest"
|
||||
version = "0.10.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292"
|
||||
dependencies = [
|
||||
"block-buffer",
|
||||
"crypto-common",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "generic-array"
|
||||
version = "0.14.7"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a"
|
||||
dependencies = [
|
||||
"typenum",
|
||||
"version_check",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "libc"
|
||||
version = "0.2.186"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
|
||||
|
||||
[[package]]
|
||||
name = "sha2"
|
||||
version = "0.10.9"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "a7507d819769d01a365ab707794a4084392c824f54a7a6a7862f8c3d0892b283"
|
||||
dependencies = [
|
||||
"cfg-if",
|
||||
"cpufeatures",
|
||||
"digest",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "silversight"
|
||||
version = "0.1.0"
|
||||
dependencies = [
|
||||
"sha2",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "typenum"
|
||||
version = "1.20.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "b6f5e870be6c3b371b77fe0ee0bafb859fa4964b4404c27de1d380043c4dda20"
|
||||
|
||||
[[package]]
|
||||
name = "version_check"
|
||||
version = "0.9.5"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
|
||||
7
rust/Cargo.toml
Normal file
7
rust/Cargo.toml
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
[package]
|
||||
name = "silversight"
|
||||
version = "0.1.0"
|
||||
edition = "2021"
|
||||
|
||||
[dependencies]
|
||||
sha2 = "0.10"
|
||||
15
rust/README.md
Normal file
15
rust/README.md
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
# SilverSight — Language Port
|
||||
|
||||
Source of truth: `/home/allaun/SilverSight/formal/` (Lean 4)
|
||||
|
||||
This directory mirrors the Lean module structure. Each file implements
|
||||
the same theorems/algorithms in this language, providing independent
|
||||
cross-validation across runtimes.
|
||||
|
||||
Module map:
|
||||
CoreFormalism/ → formal/CoreFormalism/ (braid, Q16_16, Sidon)
|
||||
SilverSight/ → formal/SilverSight/ (PIST, AVMIsa, RRC)
|
||||
BindingSite/ → formal/BindingSite/ (DNA, hachimoji)
|
||||
PVGS_DQ_Bridge/ → formal/PVGS_DQ_Bridge/
|
||||
UniversalEncoding/ → formal/UniversalEncoding/
|
||||
nuvmap/ → python/nuvmap/ (NUVMAP projection)
|
||||
343
rust/src/avm/mod.rs
Normal file
343
rust/src/avm/mod.rs
Normal file
|
|
@ -0,0 +1,343 @@
|
|||
//! AVM ISA v1 — Strict Functional Execution Engine
|
||||
//!
|
||||
//! Mirrors `formal/SilverSight/AVMIsa/` (Lean 4).
|
||||
//! The instruction set IS the execution — no interpreter dispatch table.
|
||||
//!
|
||||
//! Design rules:
|
||||
//! - Closed-world type universe: Q0_16, Q16_16, Bool
|
||||
//! - Pure functions: step(State) -> State, run(State) -> State
|
||||
//! - No Float in compute paths (Q16_16 fixed-point only)
|
||||
//! - Fuel-bounded run loop (total termination)
|
||||
|
||||
use crate::q16::*;
|
||||
|
||||
// ── Types ───────────────────────────────────────────────────────────
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum AvmTy { Q0_16, Q16_16, Bool }
|
||||
|
||||
// ── Values ──────────────────────────────────────────────────────────
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum AvmVal {
|
||||
Q0_16(i32), // raw Q0_16: [-32768, 32767]
|
||||
Q16_16(i32), // raw Q16_16: [-2^31, 2^31-1]
|
||||
Bool(bool),
|
||||
}
|
||||
|
||||
impl AvmVal {
|
||||
pub fn ty(&self) -> AvmTy {
|
||||
match self {
|
||||
AvmVal::Q0_16(_) => AvmTy::Q0_16,
|
||||
AvmVal::Q16_16(_) => AvmTy::Q16_16,
|
||||
AvmVal::Bool(_) => AvmTy::Bool,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ── Primitives ──────────────────────────────────────────────────────
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Prim {
|
||||
AddSatQ0, SubSatQ0,
|
||||
AddSatQ16, SubSatQ16, MulSatQ16, DivSatQ16,
|
||||
LtQ16, EqQ16,
|
||||
And, Or, Not,
|
||||
}
|
||||
|
||||
// ── Instructions ────────────────────────────────────────────────────
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum Instr {
|
||||
Push(AvmVal),
|
||||
Pop,
|
||||
Dup,
|
||||
Swap,
|
||||
Load(usize),
|
||||
Store(usize),
|
||||
Jump(usize),
|
||||
JumpIf(usize),
|
||||
Prim(Prim),
|
||||
Halt,
|
||||
}
|
||||
|
||||
// ── Step Error ─────────────────────────────────────────────────────
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum StepError {
|
||||
EmptyStack,
|
||||
StackUnderflow(&'static str), // operation needs N items, has <N
|
||||
TypeMismatch { expected: AvmTy, got: AvmTy },
|
||||
MissingLocal(usize),
|
||||
DivisionByZero,
|
||||
JumpOutOfBounds(usize),
|
||||
Halted,
|
||||
}
|
||||
|
||||
// ── State ──────────────────────────────────────────────────────────
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct State {
|
||||
pub pc: usize,
|
||||
pub stack: Vec<AvmVal>,
|
||||
pub locals: Vec<Option<AvmVal>>,
|
||||
pub halted: bool,
|
||||
}
|
||||
|
||||
impl State {
|
||||
pub fn new(locals_size: usize) -> Self {
|
||||
Self {
|
||||
pc: 0,
|
||||
stack: Vec::new(),
|
||||
locals: vec![None; locals_size],
|
||||
halted: false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ── Primitive execution (strict functional) ─────────────────────────
|
||||
|
||||
fn exec_prim(op: Prim, a: &AvmVal, b: Option<&AvmVal>) -> Result<AvmVal, StepError> {
|
||||
match (op, a, b) {
|
||||
// Q0_16 unary
|
||||
(Prim::Not, AvmVal::Q0_16(_), None) => {
|
||||
Ok(AvmVal::Bool(false)) // simplified: Q0_16 not is bitwise
|
||||
}
|
||||
// Q0_16 binary
|
||||
(Prim::AddSatQ0, AvmVal::Q0_16(x), Some(AvmVal::Q0_16(y))) => {
|
||||
let r = x.saturating_add(*y);
|
||||
Ok(AvmVal::Q0_16(r.max(-32768).min(32767)))
|
||||
}
|
||||
(Prim::SubSatQ0, AvmVal::Q0_16(x), Some(AvmVal::Q0_16(y))) => {
|
||||
let r = x.saturating_sub(*y);
|
||||
Ok(AvmVal::Q0_16(r.max(-32768).min(32767)))
|
||||
}
|
||||
// Q16_16 binary
|
||||
(Prim::AddSatQ16, AvmVal::Q16_16(x), Some(AvmVal::Q16_16(y))) => {
|
||||
Ok(AvmVal::Q16_16(x.saturating_add(*y)))
|
||||
}
|
||||
(Prim::SubSatQ16, AvmVal::Q16_16(x), Some(AvmVal::Q16_16(y))) => {
|
||||
Ok(AvmVal::Q16_16(x.saturating_sub(*y)))
|
||||
}
|
||||
(Prim::MulSatQ16, AvmVal::Q16_16(x), Some(AvmVal::Q16_16(y))) => {
|
||||
Ok(AvmVal::Q16_16(mul(*x, *y)))
|
||||
}
|
||||
(Prim::DivSatQ16, AvmVal::Q16_16(x), Some(AvmVal::Q16_16(y))) => {
|
||||
if *y == 0 { return Err(StepError::DivisionByZero); }
|
||||
Ok(AvmVal::Q16_16(div_op(*x, *y)))
|
||||
}
|
||||
// Comparisons
|
||||
(Prim::LtQ16, AvmVal::Q16_16(x), Some(AvmVal::Q16_16(y))) => {
|
||||
Ok(AvmVal::Bool(x < y))
|
||||
}
|
||||
(Prim::EqQ16, AvmVal::Q16_16(x), Some(AvmVal::Q16_16(y))) => {
|
||||
Ok(AvmVal::Bool(x == y))
|
||||
}
|
||||
// Boolean
|
||||
(Prim::And, AvmVal::Bool(x), Some(AvmVal::Bool(y))) => {
|
||||
Ok(AvmVal::Bool(*x && *y))
|
||||
}
|
||||
(Prim::Or, AvmVal::Bool(x), Some(AvmVal::Bool(y))) => {
|
||||
Ok(AvmVal::Bool(*x || *y))
|
||||
}
|
||||
(Prim::Not, AvmVal::Bool(x), None) => {
|
||||
Ok(AvmVal::Bool(!*x))
|
||||
}
|
||||
// Type mismatches
|
||||
_ => {
|
||||
let expected = match op {
|
||||
Prim::AddSatQ0 | Prim::SubSatQ0 => AvmTy::Q0_16,
|
||||
Prim::AddSatQ16 | Prim::SubSatQ16
|
||||
| Prim::MulSatQ16 | Prim::DivSatQ16
|
||||
| Prim::LtQ16 | Prim::EqQ16 => AvmTy::Q16_16,
|
||||
Prim::And | Prim::Or | Prim::Not => AvmTy::Bool,
|
||||
};
|
||||
Err(StepError::TypeMismatch { expected, got: a.ty() })
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// ── Step (pure function: State → Result<State, StepError>) ─────────
|
||||
|
||||
pub fn step(s: &State, program: &[Instr]) -> Result<State, StepError> {
|
||||
if s.halted { return Err(StepError::Halted); }
|
||||
if s.pc >= program.len() {
|
||||
return Ok(State {
|
||||
pc: s.pc,
|
||||
stack: s.stack.clone(),
|
||||
locals: s.locals.clone(),
|
||||
halted: true,
|
||||
});
|
||||
}
|
||||
|
||||
let instr = &program[s.pc];
|
||||
let mut stack = s.stack.clone();
|
||||
let mut locals = s.locals.clone();
|
||||
let mut pc = s.pc + 1;
|
||||
let mut halted = false;
|
||||
|
||||
match instr {
|
||||
Instr::Push(v) => {
|
||||
stack.push(v.clone());
|
||||
}
|
||||
Instr::Pop => {
|
||||
stack.pop().ok_or(StepError::EmptyStack)?;
|
||||
}
|
||||
Instr::Dup => {
|
||||
let v = stack.last().ok_or(StepError::EmptyStack)?.clone();
|
||||
stack.push(v);
|
||||
}
|
||||
Instr::Swap => {
|
||||
let a = stack.pop().ok_or(StepError::StackUnderflow("swap"))?;
|
||||
let b = stack.pop().ok_or(StepError::StackUnderflow("swap"))?;
|
||||
stack.push(a);
|
||||
stack.push(b);
|
||||
}
|
||||
Instr::Load(i) => {
|
||||
let v = locals.get(*i).ok_or(StepError::MissingLocal(*i))?
|
||||
.clone().ok_or(StepError::MissingLocal(*i))?;
|
||||
stack.push(v);
|
||||
}
|
||||
Instr::Store(i) => {
|
||||
let v = stack.pop().ok_or(StepError::EmptyStack)?;
|
||||
if *i >= locals.len() {
|
||||
return Err(StepError::MissingLocal(*i));
|
||||
}
|
||||
locals[*i] = Some(v);
|
||||
}
|
||||
Instr::Jump(target) => {
|
||||
if *target >= program.len() {
|
||||
return Err(StepError::JumpOutOfBounds(*target));
|
||||
}
|
||||
pc = *target;
|
||||
}
|
||||
Instr::JumpIf(target) => {
|
||||
let cond = stack.pop().ok_or(StepError::EmptyStack)?;
|
||||
match cond {
|
||||
AvmVal::Bool(true) => {
|
||||
if *target >= program.len() {
|
||||
return Err(StepError::JumpOutOfBounds(*target));
|
||||
}
|
||||
pc = *target;
|
||||
}
|
||||
AvmVal::Bool(false) => { /* fallthrough */ }
|
||||
_ => return Err(StepError::TypeMismatch { expected: AvmTy::Bool, got: cond.ty() }),
|
||||
}
|
||||
}
|
||||
Instr::Prim(p) => {
|
||||
let arity = match p {
|
||||
Prim::Not => 1,
|
||||
_ => 2,
|
||||
};
|
||||
let b = if arity >= 2 { Some(stack.pop().ok_or(StepError::StackUnderflow("prim"))?) } else { None };
|
||||
let a = stack.pop().ok_or(StepError::StackUnderflow("prim"))?;
|
||||
let result = exec_prim(*p, &a, b.as_ref())?;
|
||||
stack.push(result);
|
||||
}
|
||||
Instr::Halt => {
|
||||
halted = true;
|
||||
}
|
||||
}
|
||||
|
||||
Ok(State { pc, stack, locals, halted })
|
||||
}
|
||||
|
||||
// ── Run (fuel-bounded, pure) ──────────────────────────────────────
|
||||
|
||||
pub fn run(initial: &State, program: &[Instr], fuel: usize) -> Result<State, StepError> {
|
||||
let mut state = initial.clone();
|
||||
for _ in 0..fuel {
|
||||
if state.halted { return Ok(state); }
|
||||
state = step(&state, program)?;
|
||||
}
|
||||
Ok(state)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn make_program() -> (Vec<Instr>, State) {
|
||||
// Program: push Q16(5), push Q16(3), add, halt
|
||||
let prog = vec![
|
||||
Instr::Push(AvmVal::Q16_16(5 * 65536)),
|
||||
Instr::Push(AvmVal::Q16_16(3 * 65536)),
|
||||
Instr::Prim(Prim::AddSatQ16),
|
||||
Instr::Halt,
|
||||
];
|
||||
let state = State::new(0);
|
||||
(prog, state)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_add_q16() {
|
||||
let (prog, state) = make_program();
|
||||
let final_state = run(&state, &prog, 100).unwrap();
|
||||
assert!(final_state.halted);
|
||||
assert_eq!(final_state.stack.len(), 1);
|
||||
assert_eq!(final_state.stack[0], AvmVal::Q16_16(8 * 65536));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_jump_if() {
|
||||
// Program: push Bool(true), jump_if(4), push Q16(0), halt, push Q16(1), halt
|
||||
let prog = vec![
|
||||
Instr::Push(AvmVal::Bool(true)),
|
||||
Instr::JumpIf(4),
|
||||
Instr::Push(AvmVal::Q16_16(0)),
|
||||
Instr::Halt,
|
||||
Instr::Push(AvmVal::Q16_16(65536)),
|
||||
Instr::Halt,
|
||||
];
|
||||
let state = State::new(0);
|
||||
let final_state = run(&state, &prog, 100).unwrap();
|
||||
assert!(final_state.halted);
|
||||
assert_eq!(final_state.stack[0], AvmVal::Q16_16(65536));
|
||||
assert_eq!(final_state.pc, 6);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_store_load() {
|
||||
// Program: push 42, store(0), load(0), halt
|
||||
let prog = vec![
|
||||
Instr::Push(AvmVal::Q16_16(42 * 65536)),
|
||||
Instr::Store(0),
|
||||
Instr::Load(0),
|
||||
Instr::Halt,
|
||||
];
|
||||
let state = State::new(1);
|
||||
let final_state = run(&state, &prog, 100).unwrap();
|
||||
assert_eq!(final_state.stack[0], AvmVal::Q16_16(42 * 65536));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_prim_type_checking() {
|
||||
// Program: push Bool(true), push Q16(5), add → type error
|
||||
let prog = vec![
|
||||
Instr::Push(AvmVal::Bool(true)),
|
||||
Instr::Push(AvmVal::Q16_16(65536)),
|
||||
Instr::Prim(Prim::AddSatQ16),
|
||||
Instr::Halt,
|
||||
];
|
||||
let state = State::new(0);
|
||||
let result = run(&state, &prog, 100);
|
||||
assert!(result.is_err());
|
||||
match result {
|
||||
Err(StepError::TypeMismatch { .. }) => {} // expected
|
||||
_ => panic!("Expected TypeMismatch, got {:?}", result),
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_division_by_zero() {
|
||||
let prog = vec![
|
||||
Instr::Push(AvmVal::Q16_16(65536)),
|
||||
Instr::Push(AvmVal::Q16_16(0)),
|
||||
Instr::Prim(Prim::DivSatQ16),
|
||||
Instr::Halt,
|
||||
];
|
||||
let state = State::new(0);
|
||||
let result = run(&state, &prog, 100);
|
||||
assert_eq!(result, Err(StepError::DivisionByZero));
|
||||
}
|
||||
}
|
||||
4
rust/src/lib.rs
Normal file
4
rust/src/lib.rs
Normal file
|
|
@ -0,0 +1,4 @@
|
|||
pub mod q16;
|
||||
pub mod nuvmap;
|
||||
pub mod silversight;
|
||||
pub mod avm;
|
||||
211
rust/src/nuvmap/mod.rs
Normal file
211
rust/src/nuvmap/mod.rs
Normal file
|
|
@ -0,0 +1,211 @@
|
|||
//! NUVMAP Projection Engine — Rust Port
|
||||
//!
|
||||
//! Mirrors `python/nuvmap/projection_engine.py` (SilverSight Q16_16 version).
|
||||
|
||||
use crate::q16::*;
|
||||
use sha2::{Sha256, Digest};
|
||||
use std::collections::HashMap;
|
||||
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub struct Cell {
|
||||
pub u_i: i32,
|
||||
pub v_i: i32,
|
||||
pub k_i: i32,
|
||||
pub e_i: Q16,
|
||||
pub r_i: Q16,
|
||||
pub chi_i: Q16,
|
||||
pub s_i: Q16,
|
||||
pub l_i: Q16,
|
||||
pub q_i: i32,
|
||||
pub admissible: bool,
|
||||
pub equation_id: i32,
|
||||
pub fingerprint: String,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Surface {
|
||||
pub cells: Vec<Cell>,
|
||||
pub total_qubits: i32,
|
||||
pub bekenstein_bound: Q16,
|
||||
pub area_utilization: Q16,
|
||||
pub root_fingerprint: String,
|
||||
pub timestamp: String,
|
||||
}
|
||||
|
||||
/// Build input data: maps chiral_state string to int index.
|
||||
pub fn make_input(eq_id: i32, amvr_q: i32, avmr_q: i32, cr_q: i32, chiral_state: &str) -> HashMap<String, i32> {
|
||||
let mut m = HashMap::new();
|
||||
m.insert("equation_id".into(), eq_id);
|
||||
m.insert("amvr_q16".into(), amvr_q);
|
||||
m.insert("avmr_q16".into(), avmr_q);
|
||||
m.insert("chiral_residual_q16".into(), cr_q);
|
||||
let idx = match chiral_state {
|
||||
"achiral_stable" => 0,
|
||||
"left_handed_mass_bias" => 1,
|
||||
"chiral_scarred" => 2,
|
||||
"right_handed_vector_bias" => 3,
|
||||
_ => 0,
|
||||
};
|
||||
m.insert("chiral_state_idx".into(), idx);
|
||||
m
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Engine {
|
||||
pub total_qubit_budget: i32,
|
||||
pub chi_max_q16: Q16,
|
||||
pub r_max_q16: Q16,
|
||||
pub landauer_threshold_q16: Q16,
|
||||
}
|
||||
|
||||
impl Default for Engine {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
total_qubit_budget: 0,
|
||||
chi_max_q16: HALF,
|
||||
r_max_q16: HALF,
|
||||
landauer_threshold_q16: ONE.saturating_div(10),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Engine {
|
||||
pub fn project(&self, data: &[HashMap<String, i32>]) -> Surface {
|
||||
if data.is_empty() {
|
||||
return Surface {
|
||||
cells: vec![],
|
||||
total_qubits: 0,
|
||||
bekenstein_bound: ZERO,
|
||||
area_utilization: ZERO,
|
||||
root_fingerprint: String::new(),
|
||||
timestamp: String::new(),
|
||||
};
|
||||
}
|
||||
|
||||
let mut cells = Vec::with_capacity(data.len());
|
||||
|
||||
// max eigenmass
|
||||
let mut max_eigenmass = ZERO;
|
||||
for d in data {
|
||||
let raw_q = div_op(
|
||||
add(d["amvr_q16"], d["avmr_q16"]),
|
||||
of_raw(131072),
|
||||
);
|
||||
if raw_q > max_eigenmass {
|
||||
max_eigenmass = raw_q;
|
||||
}
|
||||
}
|
||||
let max_eigenmass = if max_eigenmass == ZERO { ONE } else { max_eigenmass };
|
||||
|
||||
for (i, d) in data.iter().enumerate() {
|
||||
let amvr_q = d["amvr_q16"];
|
||||
let avmr_q = d["avmr_q16"];
|
||||
let cr_q = d["chiral_residual_q16"];
|
||||
let eq_id = d["equation_id"];
|
||||
let cs_idx = d["chiral_state_idx"];
|
||||
|
||||
let raw_eigenmass = div_op(add(amvr_q, avmr_q), of_raw(131072));
|
||||
let e_norm = div_op(raw_eigenmass, max_eigenmass);
|
||||
|
||||
let one_minus = sub(ONE, e_norm);
|
||||
let r_i = if one_minus > PCT1 { one_minus } else { PCT1 };
|
||||
|
||||
let r_i = if cs_idx == 2 { mul(r_i, ONE50) } else { r_i };
|
||||
|
||||
let s_i = match cs_idx {
|
||||
0 => ONE,
|
||||
1 | 3 => PCT70,
|
||||
_ => PCT30,
|
||||
};
|
||||
|
||||
let l_i = if e_norm > self.landauer_threshold_q16 {
|
||||
ONE
|
||||
} else {
|
||||
div_op(e_norm, self.landauer_threshold_q16)
|
||||
};
|
||||
|
||||
let e_i = div_op(
|
||||
mul(mul(mul(ONE, e_norm), s_i), l_i),
|
||||
add(r_i, EPSILON),
|
||||
);
|
||||
|
||||
let chi_i = cr_q;
|
||||
let admissible = r_i <= self.r_max_q16 && chi_i <= self.chi_max_q16;
|
||||
|
||||
let fp_payload = format!("{eq_id}\x00{amvr_q}\x00{avmr_q}\x00{cr_q}\x00{cs_idx}");
|
||||
let mut hasher = Sha256::new();
|
||||
hasher.update(fp_payload.as_bytes());
|
||||
let fp = format!("{:x}", hasher.finalize());
|
||||
|
||||
cells.push(Cell {
|
||||
u_i: i as i32, v_i: i as i32, k_i: i as i32,
|
||||
e_i, r_i, chi_i, s_i, l_i,
|
||||
q_i: 0, admissible,
|
||||
equation_id: eq_id,
|
||||
fingerprint: fp,
|
||||
});
|
||||
}
|
||||
|
||||
// Qubit allocation
|
||||
let mut total_weight = ZERO;
|
||||
for c in &cells {
|
||||
total_weight = add(total_weight, div_op(c.e_i, add(c.r_i, EPSILON)));
|
||||
}
|
||||
if total_weight == ZERO { let _ = std::mem::replace(&mut total_weight, ONE); }
|
||||
|
||||
let mut budget: i64 = if self.total_qubit_budget > 0 {
|
||||
self.total_qubit_budget as i64
|
||||
} else {
|
||||
cells.iter()
|
||||
.filter(|c| c.admissible)
|
||||
.map(|c| (c.e_i as i64 * 100) / Q16_SCALE as i64)
|
||||
.sum()
|
||||
};
|
||||
let n_admissible = cells.iter().filter(|c| c.admissible).count() as i64;
|
||||
budget = budget.max(n_admissible);
|
||||
|
||||
for cell in cells.iter_mut() {
|
||||
if cell.admissible {
|
||||
let weight = div_op(cell.e_i, add(cell.r_i, EPSILON));
|
||||
let raw_q = (budget * weight as i64) / total_weight as i64;
|
||||
cell.q_i = (1i32).max(raw_q as i32);
|
||||
} else {
|
||||
cell.q_i = 0;
|
||||
}
|
||||
}
|
||||
|
||||
let total_qubits: i32 = cells.iter().map(|c| c.q_i).sum();
|
||||
|
||||
let mut sum_e = ZERO;
|
||||
for c in &cells { sum_e = add(sum_e, c.e_i); }
|
||||
let bekenstein = if !cells.is_empty() {
|
||||
div_op(sum_e, of_raw((cells.len() * Q16_SCALE as usize) as i32))
|
||||
} else { ZERO };
|
||||
|
||||
let area_util = if bekenstein > ZERO {
|
||||
div_op(
|
||||
of_raw((total_qubits as i64 * Q16_SCALE as i64) as i32),
|
||||
add(bekenstein, EPSILON),
|
||||
)
|
||||
} else { ZERO };
|
||||
|
||||
let mut sorted = cells.clone();
|
||||
sorted.sort_by_key(|c| c.u_i);
|
||||
let payload: Vec<String> = sorted.iter().map(|c| {
|
||||
format!("{}:{}:{}:{}", c.u_i, c.e_i, c.chi_i, c.q_i)
|
||||
}).collect();
|
||||
let payload_str = payload.join("|");
|
||||
let mut hasher = Sha256::new();
|
||||
hasher.update(payload_str.as_bytes());
|
||||
let root_fp = format!("{:x}", hasher.finalize());
|
||||
|
||||
Surface {
|
||||
cells,
|
||||
total_qubits,
|
||||
bekenstein_bound: bekenstein,
|
||||
area_utilization: area_util,
|
||||
root_fingerprint: root_fp,
|
||||
timestamp: String::new(),
|
||||
}
|
||||
}
|
||||
}
|
||||
280
rust/src/q16/mod.rs
Normal file
280
rust/src/q16/mod.rs
Normal file
|
|
@ -0,0 +1,280 @@
|
|||
//! Q16_16 fixed-point arithmetic — Rust Port
|
||||
//!
|
||||
//! Mirrors `Core/SilverSight/FixedPoint.lean` (Lean 4).
|
||||
//!
|
||||
//! Rounding mode: Banker's rounding (round-half-to-even), matching Python `round()`.
|
||||
//! This differs from Lean `Int.div` (floor division). The discrepancy is documented
|
||||
//! and cross-validated against Python, R, and Julia outputs.
|
||||
//!
|
||||
//! Design rules:
|
||||
//! - Core type is `i32` (signed 32-bit, matches `Q16_16Value`)
|
||||
//! - Saturation via `Self::of_raw`
|
||||
//! - Float is external boundary only (`of_float`, `to_float`)
|
||||
|
||||
use std::cmp::{max, min};
|
||||
|
||||
pub const Q16_MIN_RAW: i32 = -2147483648;
|
||||
pub const Q16_MAX_RAW: i32 = 2147483647;
|
||||
pub const Q16_SCALE: i32 = 65536;
|
||||
|
||||
/// Q16.16 fixed-point raw integer, saturated into `[Q16_MIN_RAW, Q16_MAX_RAW]`.
|
||||
pub type Q16 = i32;
|
||||
|
||||
/// Saturating clamp matching Lean `q16Clamp`.
|
||||
#[inline]
|
||||
pub fn clamp_raw(raw: i64) -> i32 {
|
||||
if raw > Q16_MAX_RAW as i64 {
|
||||
Q16_MAX_RAW
|
||||
} else if raw < Q16_MIN_RAW as i64 {
|
||||
Q16_MIN_RAW
|
||||
} else {
|
||||
raw as i32
|
||||
}
|
||||
}
|
||||
|
||||
/// Saturating constructor. Matches Lean `Q16_16.ofRawInt`.
|
||||
#[inline]
|
||||
pub fn of_raw(raw: i32) -> Q16 {
|
||||
raw // already in-range if constructed via clamp_raw
|
||||
}
|
||||
|
||||
/// Float → Q16_16 (external boundary only). Matches Python `f2q` (banker's rounding).
|
||||
pub fn of_float(f: f64) -> Q16 {
|
||||
if f.is_nan() || f >= 32768.0 {
|
||||
return Q16_MAX_RAW;
|
||||
}
|
||||
if f <= -32768.0 {
|
||||
return Q16_MIN_RAW;
|
||||
}
|
||||
clamp_raw((f * 65536.0).round_ties_even() as i64)
|
||||
}
|
||||
|
||||
/// Q16_16 → Float64.
|
||||
pub fn to_float(q: Q16) -> f64 {
|
||||
q as f64 / 65536.0
|
||||
}
|
||||
|
||||
/// Constants (match Lean `#eval` witnesses)
|
||||
pub const ZERO: Q16 = 0;
|
||||
pub const ONE: Q16 = 65536;
|
||||
pub const NEG_ONE: Q16 = -65536;
|
||||
pub const EPSILON: Q16 = 1;
|
||||
pub const TWO: Q16 = 131072;
|
||||
pub const HALF: Q16 = 32768;
|
||||
pub const MAX_VAL: Q16 = Q16_MAX_RAW;
|
||||
pub const MIN_VAL: Q16 = Q16_MIN_RAW;
|
||||
|
||||
// NUVMAP constants
|
||||
pub const PCT1: Q16 = 655; // 0.01 floor
|
||||
pub const PCT70: Q16 = 45875; // 0.7 floor
|
||||
pub const PCT30: Q16 = 19661; // 0.3 ceil (banker's)
|
||||
pub const ONE50: Q16 = 98304; // 1.5 exact
|
||||
|
||||
// Mathematical constants (from Q16_16Numerics.lean)
|
||||
pub const PI: Q16 = 205887;
|
||||
pub const E: Q16 = 178145;
|
||||
pub const LN2: Q16 = 45426;
|
||||
|
||||
// ── Arithmetic (saturating, banker's rounding) ─────────────────────────
|
||||
|
||||
/// Saturating addition. Matches Lean `Q16_16.add`.
|
||||
#[inline]
|
||||
pub fn add(a: Q16, b: Q16) -> Q16 {
|
||||
a.saturating_add(b)
|
||||
}
|
||||
|
||||
/// Saturating subtraction.
|
||||
#[inline]
|
||||
pub fn sub(a: Q16, b: Q16) -> Q16 {
|
||||
a.saturating_sub(b)
|
||||
}
|
||||
|
||||
/// Q16.16 multiplication: `round((a * b) / 65536)`. Uses i64 intermediate.
|
||||
pub fn mul(a: Q16, b: Q16) -> Q16 {
|
||||
let prod = (a as i64) * (b as i64);
|
||||
// Banker's rounding: round half to even
|
||||
let scaled = ((prod as f64) / (Q16_SCALE as f64)).round_ties_even() as i64;
|
||||
clamp_raw(scaled)
|
||||
}
|
||||
|
||||
/// Q16.16 division: `round((a * 65536) / b)`. Returns MAX_VAL if b == 0.
|
||||
pub fn div_op(a: Q16, b: Q16) -> Q16 {
|
||||
if b == 0 {
|
||||
return MAX_VAL;
|
||||
}
|
||||
let prod = (a as i64) * (Q16_SCALE as i64);
|
||||
let scaled = ((prod as f64) / (b as f64)).round_ties_even() as i64;
|
||||
clamp_raw(scaled)
|
||||
}
|
||||
|
||||
/// Saturating negation.
|
||||
#[inline]
|
||||
pub fn neg(a: Q16) -> Q16 {
|
||||
a.saturating_neg()
|
||||
}
|
||||
|
||||
/// Absolute value.
|
||||
#[inline]
|
||||
pub fn abs_(a: Q16) -> Q16 {
|
||||
if a < 0 { neg(a) } else { a }
|
||||
}
|
||||
|
||||
// ── Comparisons ────────────────────────────────────────────────────────
|
||||
|
||||
#[inline]
|
||||
pub fn lt(a: Q16, b: Q16) -> bool { a < b }
|
||||
#[inline]
|
||||
pub fn le(a: Q16, b: Q16) -> bool { a <= b }
|
||||
#[inline]
|
||||
pub fn gt(a: Q16, b: Q16) -> bool { a > b }
|
||||
#[inline]
|
||||
pub fn ge(a: Q16, b: Q16) -> bool { a >= b }
|
||||
|
||||
// ── Numeric functions ───────────────────────────────────────────────────
|
||||
|
||||
/// Integer square root via Newton's method (floor). Matches Lean `intSqrt`.
|
||||
pub fn int_sqrt(n: i64) -> i64 {
|
||||
if n <= 0 { return 0; }
|
||||
let mut x = n / 2 + 1;
|
||||
for _ in 0..64 {
|
||||
let x_new = (x + n / x) / 2;
|
||||
if x_new >= x { return x; }
|
||||
x = x_new;
|
||||
}
|
||||
x
|
||||
}
|
||||
|
||||
/// Q16.16 square root.
|
||||
pub fn sqrt(q: Q16) -> Q16 {
|
||||
if q <= 0 { return ZERO; }
|
||||
clamp_raw(int_sqrt((q as i64) * (Q16_SCALE as i64)) as i64)
|
||||
}
|
||||
|
||||
/// Natural logarithm approximation around 1.0. Matches Lean `Q16_16.ln`.
|
||||
pub fn ln_nat(q: Q16) -> Q16 {
|
||||
let x = q as i64;
|
||||
if x <= 0 { return ZERO; }
|
||||
let y = x - Q16_SCALE as i64;
|
||||
let y2 = (y * y) / Q16_SCALE as i64;
|
||||
let y3 = (y * y2) / Q16_SCALE as i64;
|
||||
clamp_raw((y - y2 / 2 + y3 / 3) as i64)
|
||||
}
|
||||
|
||||
/// Q16.16 exponential via Taylor with range reduction. Matches Lean `Q16_16.exp`.
|
||||
pub fn exp(x: Q16) -> Q16 {
|
||||
let rx = x as i64;
|
||||
if rx <= -(Q16_SCALE as i64) { return ZERO; }
|
||||
if rx >= 4 * (Q16_SCALE as i64) { return MAX_VAL; }
|
||||
|
||||
let ln2_raw: i64 = 45426;
|
||||
let k = rx / ln2_raw;
|
||||
let r = rx - k * ln2_raw;
|
||||
let scale = Q16_SCALE as i64;
|
||||
|
||||
let r2 = (r * r) / scale;
|
||||
let r3 = (r * r2) / scale;
|
||||
let r4 = (r2 * r2) / scale;
|
||||
let r5 = (r2 * r3) / scale;
|
||||
let r6 = (r3 * r3) / scale;
|
||||
|
||||
let taylor = scale + r + r2 / 2 + r3 / 6 + r4 / 24 + r5 / 120 + r6 / 720;
|
||||
|
||||
let shifted = if k >= 15 { Q16_MAX_RAW as i64 }
|
||||
else if k <= -15 { 0 }
|
||||
else if k >= 0 { taylor << (k as u32) }
|
||||
else { taylor >> ((-k) as u32) };
|
||||
|
||||
clamp_raw(shifted)
|
||||
}
|
||||
|
||||
// ── Tests ───────────────────────────────────────────────────────────────
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use crate::q16::*;
|
||||
|
||||
#[test]
|
||||
fn test_constants() {
|
||||
assert_eq!(ZERO, 0);
|
||||
assert_eq!(ONE, 65536);
|
||||
assert_eq!(EPSILON, 1);
|
||||
assert_eq!(HALF, 32768);
|
||||
assert_eq!(to_float(PCT1), 0.0099945068359375);
|
||||
assert_eq!(to_float(PCT70), 0.6999969482421875);
|
||||
assert_eq!(to_float(PCT30), 0.3000030517578125);
|
||||
assert_eq!(to_float(ONE50), 1.5);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_arithmetic() {
|
||||
// 1.0 * 1.0 = 1.0
|
||||
let r = mul(ONE, ONE);
|
||||
assert_eq!(to_float(r), 1.0);
|
||||
|
||||
// 1.0 / 2.0 = 0.5
|
||||
let r = div_op(ONE, TWO);
|
||||
assert_eq!(to_float(r), 0.5);
|
||||
|
||||
// 0.5 + 0.5 = 1.0
|
||||
let r = add(HALF, HALF);
|
||||
assert_eq!(r, ONE);
|
||||
|
||||
// 1.0 - 0.5 = 0.5
|
||||
let r = sub(ONE, HALF);
|
||||
assert_eq!(r, HALF);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_of_float() {
|
||||
// of_float and to_float round-trip for simple cases
|
||||
let q = of_float(1.0);
|
||||
assert_eq!(q, ONE);
|
||||
assert!((to_float(q) - 1.0).abs() < 1e-6);
|
||||
|
||||
let q = of_float(0.5);
|
||||
assert_eq!(q, HALF);
|
||||
|
||||
// f2q(0.8) = round(52428.8) = 52429
|
||||
let q = of_float(0.8);
|
||||
assert_eq!(q, 52429);
|
||||
|
||||
// f2q(0.75) = round(49152.0) = 49152
|
||||
let q = of_float(0.75);
|
||||
assert_eq!(q, 49152);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_nuvmap_data_baseline() {
|
||||
// Cross-validated against Python/R/Julia for cell 0:
|
||||
// amvr=0.8, avmr=0.75, achiral_stable
|
||||
let amvr_q = of_float(0.8);
|
||||
let avmr_q = of_float(0.75);
|
||||
assert_eq!(amvr_q, 52429);
|
||||
assert_eq!(avmr_q, 49152);
|
||||
|
||||
// raw_eigenmass = q_div(101581, 131072) = 50790
|
||||
let raw = div_op(add(amvr_q, avmr_q), of_raw(131072));
|
||||
assert_eq!(raw, 50790);
|
||||
|
||||
// max_eigenmass (from cell 4)
|
||||
let amvr4 = of_float(0.9);
|
||||
let avmr4 = of_float(0.85);
|
||||
let max_raw = div_op(add(amvr4, avmr4), of_raw(131072));
|
||||
assert_eq!(max_raw, 57344);
|
||||
|
||||
// E_norm
|
||||
let e_norm = div_op(raw, max_raw);
|
||||
assert_eq!(e_norm, 58046);
|
||||
assert!((to_float(e_norm) - 0.885711669921875).abs() < 1e-10);
|
||||
|
||||
// R_i
|
||||
let one_minus = sub(ONE, e_norm);
|
||||
let r_i = if one_minus > PCT1 { one_minus } else { PCT1 };
|
||||
assert_eq!(r_i, 7490);
|
||||
|
||||
// E_i
|
||||
let e_i = div_op(mul(mul(mul(ONE, e_norm), ONE), ONE), add(r_i, EPSILON));
|
||||
assert_eq!(e_i, 507823);
|
||||
assert!((to_float(e_i) - 7.7487640380859375).abs() < 1e-10);
|
||||
}
|
||||
}
|
||||
318
rust/src/silversight/mod.rs
Normal file
318
rust/src/silversight/mod.rs
Normal file
|
|
@ -0,0 +1,318 @@
|
|||
//! SilverSight Engine — Verified Geometric Classifier
|
||||
//!
|
||||
//! Mirrors `python/silversight_engine.py`. All verified constants
|
||||
//! from the Python reference are checked in tests.
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
// ── VERIFIED CONSTANTS ──────────────────────────────────────────
|
||||
|
||||
/// Golden ratio [VERIFIED: 1.61803399]
|
||||
pub const PHI: f64 = 1.618033988749895;
|
||||
/// Corkscrew angle [VERIFIED: psi = 2*pi/phi^2]
|
||||
pub const PSI: f64 = 2.0 * std::f64::consts::PI / (PHI * PHI);
|
||||
|
||||
// ── R1: TOKEN NORMALIZATION ─────────────────────────────────────
|
||||
|
||||
pub fn normalize(s: &str) -> String {
|
||||
let lower = s.to_lowercase();
|
||||
let mut out = String::with_capacity(lower.len());
|
||||
let chars: Vec<char> = lower.chars().collect();
|
||||
let mut i = 0;
|
||||
while i < chars.len() {
|
||||
if chars[i].is_ascii_digit() {
|
||||
out.push('N');
|
||||
while i < chars.len() && chars[i].is_ascii_digit() { i += 1; }
|
||||
} else if chars[i].is_ascii_lowercase() {
|
||||
out.push('V');
|
||||
while i < chars.len() && chars[i].is_ascii_lowercase() { i += 1; }
|
||||
} else {
|
||||
out.push(chars[i]);
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
// ── BYTE CLASSIFICATION ─────────────────────────────────────────
|
||||
|
||||
pub fn byte_class(c: char) -> usize {
|
||||
let asc = c as u32;
|
||||
if asc <= 31 { return 0; }
|
||||
if asc <= 47 { return 1; }
|
||||
if asc <= 57 { return 2; }
|
||||
if asc <= 64 { return 3; }
|
||||
if asc <= 90 { return 4; }
|
||||
if asc <= 96 { return 5; }
|
||||
if asc <= 122 { return 6; }
|
||||
7
|
||||
}
|
||||
|
||||
// ── FEATURE EXTRACTION ──────────────────────────────────────────
|
||||
|
||||
pub fn F(s: &str) -> [f64; 8] {
|
||||
let norm = normalize(s);
|
||||
let mut counts = [0u64; 8];
|
||||
for c in norm.chars() { counts[byte_class(c)] += 1; }
|
||||
let total: u64 = counts.iter().sum();
|
||||
if total == 0 { return [0.0; 8]; }
|
||||
let mut result = [0.0f64; 8];
|
||||
for (i, &cnt) in counts.iter().enumerate() { result[i] = cnt as f64 / total as f64; }
|
||||
result
|
||||
}
|
||||
|
||||
pub fn parse_tree_depth(expr: &str) -> Vec<(char, i32)> {
|
||||
let mut ops = Vec::new();
|
||||
let mut depth = 0i32;
|
||||
for c in expr.chars() {
|
||||
match c {
|
||||
'(' => depth += 1,
|
||||
')' => depth -= 1,
|
||||
'+' | '-' | '*' | '/' | '=' => ops.push((c, depth)),
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
ops
|
||||
}
|
||||
|
||||
pub fn tau(s: &str) -> [f64; 6] {
|
||||
let op_depths = parse_tree_depth(s);
|
||||
let mut weights = [0.0f64; 6];
|
||||
for (op, d) in &op_depths {
|
||||
let w = 2.0f64.powi(-*d);
|
||||
match op {
|
||||
'+' => weights[1] += w, '=' => weights[2] += w,
|
||||
'/' => weights[3] += w, '*' => weights[4] += w,
|
||||
'-' => weights[5] += w, _ => {}
|
||||
}
|
||||
}
|
||||
let total: f64 = weights.iter().sum();
|
||||
if total > 0.0 { for w in &mut weights { *w /= total; } }
|
||||
weights
|
||||
}
|
||||
|
||||
pub fn Phi(s: &str) -> [f64; 14] {
|
||||
let mut result = [0.0f64; 14];
|
||||
result[..8].copy_from_slice(&F(s));
|
||||
result[8..].copy_from_slice(&tau(s));
|
||||
result
|
||||
}
|
||||
|
||||
// ── FISHER DISTANCE ─────────────────────────────────────────────
|
||||
|
||||
pub fn d_F<const N: usize>(p: &[f64; N], q: &[f64; N]) -> f64 {
|
||||
let mut s = 0.0;
|
||||
for i in 0..N { s += (p[i].max(0.0) * q[i].max(0.0)).sqrt(); }
|
||||
s = s.clamp(-1.0, 1.0);
|
||||
2.0 * s.acos()
|
||||
}
|
||||
|
||||
pub fn d_Phi(phi1: &[f64; 14], phi2: &[f64; 14]) -> f64 {
|
||||
let f1: [f64; 8] = phi1[..8].try_into().unwrap();
|
||||
let t1: [f64; 6] = phi1[8..].try_into().unwrap();
|
||||
let f2: [f64; 8] = phi2[..8].try_into().unwrap();
|
||||
let t2: [f64; 6] = phi2[8..].try_into().unwrap();
|
||||
let df = d_F(&f1, &f2);
|
||||
let dt = d_F(&t1, &t2);
|
||||
(df * df + dt * dt).sqrt()
|
||||
}
|
||||
|
||||
// ── COARSE-GRAINING / EIGENSOLID ────────────────────────────────
|
||||
|
||||
pub fn C(phi: &[f64; 14]) -> [f64; 14] {
|
||||
let mut result = *phi;
|
||||
for k in 0..4 {
|
||||
let avg = (phi[2*k] + phi[2*k+1]) / 2.0;
|
||||
result[2*k] = avg; result[2*k+1] = avg;
|
||||
}
|
||||
for k in 0..3 {
|
||||
let avg = (phi[8+2*k] + phi[8+2*k+1]) / 2.0;
|
||||
result[8+2*k] = avg; result[8+2*k+1] = avg;
|
||||
}
|
||||
result
|
||||
}
|
||||
|
||||
pub fn geodesic_step(phi1: &[f64; 14], phi2: &[f64; 14], eps: f64) -> [f64; 14] {
|
||||
let mut interp_f = [0.0f64; 8];
|
||||
let mut sum_f = 0.0;
|
||||
for i in 0..8 {
|
||||
let s = (1.0 - eps) * phi1[i].max(0.0).min(1.0).sqrt() + eps * phi2[i].max(0.0).min(1.0).sqrt();
|
||||
interp_f[i] = s; sum_f += s * s;
|
||||
}
|
||||
let sum_f = if sum_f > 0.0 { sum_f } else { 1.0 };
|
||||
for i in 0..8 { interp_f[i] = interp_f[i] * interp_f[i] / sum_f; }
|
||||
|
||||
let mut interp_t = [0.0f64; 6];
|
||||
let mut sum_t = 0.0;
|
||||
for i in 0..6 {
|
||||
let s = (1.0 - eps) * phi1[8+i].max(0.0).min(1.0).sqrt() + eps * phi2[8+i].max(0.0).min(1.0).sqrt();
|
||||
interp_t[i] = s; sum_t += s * s;
|
||||
}
|
||||
let sum_t = if sum_t > 0.0 { sum_t } else { 1.0 };
|
||||
for i in 0..6 { interp_t[i] = interp_t[i] * interp_t[i] / sum_t; }
|
||||
|
||||
let mut result = [0.0f64; 14];
|
||||
result[..8].copy_from_slice(&interp_f);
|
||||
result[8..].copy_from_slice(&interp_t);
|
||||
result
|
||||
}
|
||||
|
||||
pub fn chaos_game(
|
||||
start: &[f64; 14], references: &HashMap<String, [f64; 14]>,
|
||||
steps: usize, eps: f64,
|
||||
) -> [f64; 14] {
|
||||
let refs: Vec<&[f64; 14]> = references.values().collect();
|
||||
let mut x = *start;
|
||||
for _ in 0..steps {
|
||||
let nearest = refs.iter().min_by(|a, b| d_Phi(&x, a).partial_cmp(&d_Phi(&x, b)).unwrap()).copied().unwrap();
|
||||
x = geodesic_step(&x, nearest, eps);
|
||||
}
|
||||
x
|
||||
}
|
||||
|
||||
pub fn corkscrew_index(phi: &[f64; 14]) -> i64 {
|
||||
let mut spiral: i64 = 0;
|
||||
for i in 0..9 { spiral += (phi[i] * 256.0).floor() as i64 * 8i64.pow(i as u32); }
|
||||
spiral.abs()
|
||||
}
|
||||
|
||||
// ── CONCEPT DATA STRUCTURE ──────────────────────────────────────
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Concept {
|
||||
pub name: String,
|
||||
pub prototype: [f64; 14],
|
||||
pub attractor: [f64; 14],
|
||||
pub corkscrew_index: i64,
|
||||
pub operator_type: String,
|
||||
pub members: Vec<(String, [f64; 14])>,
|
||||
}
|
||||
|
||||
// ── SILVERSIGHT ENGINE ─────────────────────────────────────────
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct SilverSight {
|
||||
pub concepts: Vec<Concept>,
|
||||
pub references: HashMap<String, [f64; 14]>,
|
||||
pub basin_map: HashMap<[i64; 14], usize>,
|
||||
}
|
||||
|
||||
impl SilverSight {
|
||||
pub fn new() -> Self {
|
||||
Self { concepts: Vec::new(), references: HashMap::new(), basin_map: HashMap::new() }
|
||||
}
|
||||
|
||||
pub fn learn(&mut self, equation: &str) -> usize {
|
||||
let phi = Phi(equation);
|
||||
self.references.insert(equation.to_string(), phi);
|
||||
let limit = chaos_game(&phi, &self.references, 30, 0.5);
|
||||
let eigensolid = C(&limit);
|
||||
let attractor_key: [i64; 14] = std::array::from_fn(|i| (limit[i] * 1e8).round() as i64);
|
||||
if let Some(&cid) = self.basin_map.get(&attractor_key) {
|
||||
self.concepts[cid].members.push((equation.to_string(), phi));
|
||||
return cid;
|
||||
}
|
||||
let op_type = detect_operator(equation);
|
||||
let cid = self.concepts.len();
|
||||
self.concepts.push(Concept {
|
||||
name: format!("concept_{cid}"), prototype: eigensolid, attractor: limit,
|
||||
corkscrew_index: corkscrew_index(&eigensolid),
|
||||
operator_type: op_type, members: vec![(equation.to_string(), phi)],
|
||||
});
|
||||
self.basin_map.insert(attractor_key, cid);
|
||||
cid
|
||||
}
|
||||
|
||||
pub fn classify(&self, equation: &str) -> Option<(usize, f64)> {
|
||||
if self.concepts.is_empty() { return None; }
|
||||
let phi = Phi(equation);
|
||||
Some(self.concepts.iter().enumerate()
|
||||
.map(|(i, c)| (i, d_Phi(&phi, &c.attractor)))
|
||||
.min_by(|a, b| a.1.partial_cmp(&b.1).unwrap()).unwrap())
|
||||
}
|
||||
}
|
||||
|
||||
fn detect_operator(s: &str) -> String {
|
||||
let norm = normalize(s);
|
||||
for op in &['+', '/', '*', '-', '='] {
|
||||
if norm.contains(*op) {
|
||||
return match op {
|
||||
'+' => "addition".into(), '/' => "division".into(),
|
||||
'*' => "multiplication".into(), '-' => "subtraction".into(),
|
||||
'=' => "equality".into(), _ => "literal".into(),
|
||||
};
|
||||
}
|
||||
}
|
||||
"literal".into()
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_normalize() {
|
||||
assert_eq!(normalize("A+B=C"), "V+V=V");
|
||||
assert_eq!(normalize("a+b=c"), "V+V=V");
|
||||
assert_eq!(normalize("foo+bar=baz"), "V+V=V");
|
||||
assert_eq!(normalize("123+456=579"), "N+N=N");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_F_verified() {
|
||||
let f0 = F("A+B=C");
|
||||
let expected = [0.0, 0.2, 0.0, 0.2, 0.6, 0.0, 0.0, 0.0];
|
||||
for i in 0..8 { assert!((f0[i] - expected[i]).abs() < 1e-10); }
|
||||
for case in &["a+b=c", "foo+bar=baz", "123+456=579"] {
|
||||
let fi = F(case);
|
||||
for i in 0..8 { assert!((fi[i] - f0[i]).abs() < 1e-10); }
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_tau() {
|
||||
let t = tau("(a+b)*c=d");
|
||||
assert!(t[4] > t[1], "mul({}) should exceed add({})", t[4], t[1]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_fisher_self_zero() {
|
||||
let p = F("a+b=c");
|
||||
assert!(d_F(&p, &p).abs() < 1e-10);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_eigensolid_idempotent() {
|
||||
let p = Phi("a+b=c");
|
||||
let c1 = C(&p);
|
||||
let c2 = C(&c1);
|
||||
for i in 0..14 { assert!((c2[i] - c1[i]).abs() < 1e-10); }
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_eigensolid_contractive() {
|
||||
let p = Phi("a+b=c");
|
||||
let q = Phi("p/q=r");
|
||||
assert!(d_Phi(&C(&p), &C(&q)) < d_Phi(&p, &q));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_chaos_game_convergence() {
|
||||
let mut ss = SilverSight::new();
|
||||
ss.learn("a+b=c");
|
||||
ss.learn("x+y=z");
|
||||
assert_eq!(ss.concepts.len(), 1, "addition equations should cluster");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_classify_novelty() {
|
||||
let mut ss = SilverSight::new();
|
||||
ss.learn("a+b=c");
|
||||
ss.learn("p/q=r");
|
||||
ss.learn("a*b=c");
|
||||
assert_eq!(ss.concepts.len(), 3, "different operators → different concepts");
|
||||
let (idx, dist) = ss.classify("x+y=z").unwrap();
|
||||
assert_eq!(idx, 0, "x+y=z → addition (concept 0)");
|
||||
assert!(dist < 1.0);
|
||||
}
|
||||
}
|
||||
1
rust/target/.rustc_info.json
Normal file
1
rust/target/.rustc_info.json
Normal file
|
|
@ -0,0 +1 @@
|
|||
{"rustc_fingerprint":8538117250985766906,"outputs":{"17747080675513052775":{"success":true,"status":"","code":0,"stdout":"rustc 1.95.0 (59807616e 2026-04-14)\nbinary: rustc\ncommit-hash: 59807616e1fa2540724bfbac14d7976d7e4a3860\ncommit-date: 2026-04-14\nhost: x86_64-unknown-linux-gnu\nrelease: 1.95.0\nLLVM version: 22.1.2\n","stderr":""},"7971740275564407648":{"success":true,"status":"","code":0,"stdout":"___\nlib___.rlib\nlib___.so\nlib___.so\nlib___.a\nlib___.so\n/home/allaun/.rustup/toolchains/stable-x86_64-unknown-linux-gnu\noff\npacked\nunpacked\n___\ndebug_assertions\npanic=\"unwind\"\nproc_macro\ntarget_abi=\"\"\ntarget_arch=\"x86_64\"\ntarget_endian=\"little\"\ntarget_env=\"gnu\"\ntarget_family=\"unix\"\ntarget_feature=\"fxsr\"\ntarget_feature=\"sse\"\ntarget_feature=\"sse2\"\ntarget_has_atomic=\"16\"\ntarget_has_atomic=\"32\"\ntarget_has_atomic=\"64\"\ntarget_has_atomic=\"8\"\ntarget_has_atomic=\"ptr\"\ntarget_os=\"linux\"\ntarget_pointer_width=\"64\"\ntarget_vendor=\"unknown\"\nunix\n","stderr":""}},"successes":{}}
|
||||
3
rust/target/CACHEDIR.TAG
Normal file
3
rust/target/CACHEDIR.TAG
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
Signature: 8a477f597d28d172789f06886806bc55
|
||||
# This file is a cache directory tag created by cargo.
|
||||
# For information about cache directory tags see https://bford.info/cachedir/
|
||||
0
rust/target/debug/.cargo-lock
Normal file
0
rust/target/debug/.cargo-lock
Normal file
Binary file not shown.
|
|
@ -0,0 +1 @@
|
|||
03a785e36bf85364
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[]","declared_features":"[]","target":4098124618827574291,"profile":15657897354478470176,"path":8690544258682963370,"deps":[[10520923840501062997,"generic_array",false,10063538021535001446]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/block-buffer-ba5487fa0bd48090/dep-lib-block_buffer","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
Binary file not shown.
|
|
@ -0,0 +1 @@
|
|||
93cd6a45d01a882b
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[]","declared_features":"[\"core\", \"rustc-dep-of-std\"]","target":13840298032947503755,"profile":15657897354478470176,"path":14469769793946325281,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/cfg-if-595cd1fd9b5b1165/dep-lib-cfg_if","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
Binary file not shown.
|
|
@ -0,0 +1 @@
|
|||
a52dc05282298c46
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[]","declared_features":"[]","target":2330704043955282025,"profile":15657897354478470176,"path":2326293387941387040,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/cpufeatures-e124fef1b1d91f00/dep-lib-cpufeatures","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
Binary file not shown.
|
|
@ -0,0 +1 @@
|
|||
802aefde249766a6
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[\"std\"]","declared_features":"[\"getrandom\", \"rand_core\", \"std\"]","target":12082577455412410174,"profile":15657897354478470176,"path":15131514179919812129,"deps":[[6918147871599447195,"typenum",false,12516096392049389919],[10520923840501062997,"generic_array",false,10063538021535001446]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/crypto-common-121deb944156ca4c/dep-lib-crypto_common","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
Binary file not shown.
|
|
@ -0,0 +1 @@
|
|||
6fcb15cf9ea4feb5
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[\"alloc\", \"block-buffer\", \"core-api\", \"default\", \"std\"]","declared_features":"[\"alloc\", \"blobby\", \"block-buffer\", \"const-oid\", \"core-api\", \"default\", \"dev\", \"mac\", \"oid\", \"rand_core\", \"std\", \"subtle\"]","target":7510122432137863311,"profile":15657897354478470176,"path":653469723402799357,"deps":[[6039282458970808711,"crypto_common",false,11990437242535357056],[10626340395483396037,"block_buffer",false,7229394969122154243]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/digest-ccef2157e38fd51a/dep-lib-digest","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
|
|
@ -0,0 +1 @@
|
|||
34a08823ad1a7ef1
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"","declared_features":"","target":0,"profile":0,"path":0,"deps":[[10520923840501062997,"build_script_build",false,17746109891654218989]],"local":[{"Precalculated":"0.14.7"}],"rustflags":[],"config":0,"compile_kind":0}
|
||||
|
|
@ -0,0 +1 @@
|
|||
ed74186decd846f6
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[\"more_lengths\"]","declared_features":"[\"more_lengths\", \"serde\", \"zeroize\"]","target":12318548087768197662,"profile":2225463790103693989,"path":5600575675369091377,"deps":[[5398981501050481332,"version_check",false,7969903382952950840]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/generic-array-c61903c61fac97ae/dep-build-script-build-script-build","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
Binary file not shown.
Binary file not shown.
|
|
@ -0,0 +1 @@
|
|||
662b3bfd82dea88b
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[\"more_lengths\"]","declared_features":"[\"more_lengths\", \"serde\", \"zeroize\"]","target":13084005262763373425,"profile":15657897354478470176,"path":17740777500441703135,"deps":[[6918147871599447195,"typenum",false,12516096392049389919],[10520923840501062997,"build_script_build",false,17401375341133996084]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/generic-array-d73a6db3dcac957a/dep-lib-generic_array","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
Binary file not shown.
|
|
@ -0,0 +1 @@
|
|||
8b46351d2d7d64e3
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[\"default\", \"std\"]","declared_features":"[\"asm\", \"asm-aarch64\", \"compress\", \"default\", \"force-soft\", \"force-soft-compact\", \"loongarch64_asm\", \"oid\", \"sha2-asm\", \"std\"]","target":9593554856174113207,"profile":15657897354478470176,"path":414506693975612452,"deps":[[7667230146095136825,"cfg_if",false,3136786622283697555],[17475753849556516473,"digest",false,13114100166935563119],[17620084158052398167,"cpufeatures",false,5083483719105260965]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/sha2-9772533f5abdf09c/dep-lib-sha2","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
Binary file not shown.
|
|
@ -0,0 +1,8 @@
|
|||
{"$message_type":"diagnostic","message":"unused imports: `max` and `min`","code":{"code":"unused_imports","explanation":null},"level":"warning","spans":[{"file_name":"src/q16/mod.rs","byte_start":553,"byte_end":556,"line_start":14,"line_end":14,"column_start":16,"column_end":19,"is_primary":true,"text":[{"text":"use std::cmp::{max, min};","highlight_start":16,"highlight_end":19}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null},{"file_name":"src/q16/mod.rs","byte_start":558,"byte_end":561,"line_start":14,"line_end":14,"column_start":21,"column_end":24,"is_primary":true,"text":[{"text":"use std::cmp::{max, min};","highlight_start":21,"highlight_end":24}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"`#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"remove the whole `use` item","code":null,"level":"help","spans":[{"file_name":"src/q16/mod.rs","byte_start":538,"byte_end":564,"line_start":14,"line_end":15,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"use std::cmp::{max, min};","highlight_start":1,"highlight_end":26},{"text":"","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"","suggestion_applicability":"MachineApplicable","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: unused imports: `max` and `min`\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/q16/mod.rs:14:16\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m14\u001b[0m \u001b[1m\u001b[94m|\u001b[0m use std::cmp::{max, min};\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^^^\u001b[0m \u001b[1m\u001b[33m^^^\u001b[0m\n \u001b[1m\u001b[94m|\u001b[0m\n \u001b[1m\u001b[94m= \u001b[0m\u001b[1mnote\u001b[0m: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default\n\n"}
|
||||
{"$message_type":"diagnostic","message":"function `F` should have a snake case name","code":{"code":"non_snake_case","explanation":null},"level":"warning","spans":[{"file_name":"src/silversight/mod.rs","byte_start":1942,"byte_end":1943,"line_start":53,"line_end":53,"column_start":8,"column_end":9,"is_primary":true,"text":[{"text":"pub fn F(s: &str) -> [f64; 8] {","highlight_start":8,"highlight_end":9}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"`#[warn(non_snake_case)]` (part of `#[warn(nonstandard_style)]`) on by default","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"convert the identifier to snake case","code":null,"level":"help","spans":[{"file_name":"src/silversight/mod.rs","byte_start":1942,"byte_end":1943,"line_start":53,"line_end":53,"column_start":8,"column_end":9,"is_primary":true,"text":[{"text":"pub fn F(s: &str) -> [f64; 8] {","highlight_start":8,"highlight_end":9}],"label":null,"suggested_replacement":"f","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: function `F` should have a snake case name\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/silversight/mod.rs:53:8\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m53\u001b[0m \u001b[1m\u001b[94m|\u001b[0m pub fn F(s: &str) -> [f64; 8] {\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^\u001b[0m \u001b[1m\u001b[33mhelp: convert the identifier to snake case (notice the capitalization): `f`\u001b[0m\n \u001b[1m\u001b[94m|\u001b[0m\n \u001b[1m\u001b[94m= \u001b[0m\u001b[1mnote\u001b[0m: `#[warn(non_snake_case)]` (part of `#[warn(nonstandard_style)]`) on by default\n\n"}
|
||||
{"$message_type":"diagnostic","message":"function `Phi` should have a snake case name","code":{"code":"non_snake_case","explanation":null},"level":"warning","spans":[{"file_name":"src/silversight/mod.rs","byte_start":3141,"byte_end":3144,"line_start":94,"line_end":94,"column_start":8,"column_end":11,"is_primary":true,"text":[{"text":"pub fn Phi(s: &str) -> [f64; 14] {","highlight_start":8,"highlight_end":11}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"convert the identifier to snake case","code":null,"level":"help","spans":[{"file_name":"src/silversight/mod.rs","byte_start":3141,"byte_end":3144,"line_start":94,"line_end":94,"column_start":8,"column_end":11,"is_primary":true,"text":[{"text":"pub fn Phi(s: &str) -> [f64; 14] {","highlight_start":8,"highlight_end":11}],"label":null,"suggested_replacement":"phi","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: function `Phi` should have a snake case name\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/silversight/mod.rs:94:8\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m94\u001b[0m \u001b[1m\u001b[94m|\u001b[0m pub fn Phi(s: &str) -> [f64; 14] {\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^^^\u001b[0m \u001b[1m\u001b[33mhelp: convert the identifier to snake case: `phi`\u001b[0m\n\n"}
|
||||
{"$message_type":"diagnostic","message":"function `d_F` should have a snake case name","code":{"code":"non_snake_case","explanation":null},"level":"warning","spans":[{"file_name":"src/silversight/mod.rs","byte_start":3470,"byte_end":3473,"line_start":103,"line_end":103,"column_start":8,"column_end":11,"is_primary":true,"text":[{"text":"pub fn d_F<const N: usize>(p: &[f64; N], q: &[f64; N]) -> f64 {","highlight_start":8,"highlight_end":11}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"convert the identifier to snake case","code":null,"level":"help","spans":[{"file_name":"src/silversight/mod.rs","byte_start":3470,"byte_end":3473,"line_start":103,"line_end":103,"column_start":8,"column_end":11,"is_primary":true,"text":[{"text":"pub fn d_F<const N: usize>(p: &[f64; N], q: &[f64; N]) -> f64 {","highlight_start":8,"highlight_end":11}],"label":null,"suggested_replacement":"d_f","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: function `d_F` should have a snake case name\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/silversight/mod.rs:103:8\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m103\u001b[0m \u001b[1m\u001b[94m|\u001b[0m pub fn d_F<const N: usize>(p: &[f64; N], q: &[f64; N]) -> f64 {\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^^^\u001b[0m \u001b[1m\u001b[33mhelp: convert the identifier to snake case (notice the capitalization): `d_f`\u001b[0m\n\n"}
|
||||
{"$message_type":"diagnostic","message":"function `d_Phi` should have a snake case name","code":{"code":"non_snake_case","explanation":null},"level":"warning","spans":[{"file_name":"src/silversight/mod.rs","byte_start":3672,"byte_end":3677,"line_start":110,"line_end":110,"column_start":8,"column_end":13,"is_primary":true,"text":[{"text":"pub fn d_Phi(phi1: &[f64; 14], phi2: &[f64; 14]) -> f64 {","highlight_start":8,"highlight_end":13}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"convert the identifier to snake case","code":null,"level":"help","spans":[{"file_name":"src/silversight/mod.rs","byte_start":3672,"byte_end":3677,"line_start":110,"line_end":110,"column_start":8,"column_end":13,"is_primary":true,"text":[{"text":"pub fn d_Phi(phi1: &[f64; 14], phi2: &[f64; 14]) -> f64 {","highlight_start":8,"highlight_end":13}],"label":null,"suggested_replacement":"d_phi","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: function `d_Phi` should have a snake case name\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/silversight/mod.rs:110:8\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m110\u001b[0m \u001b[1m\u001b[94m|\u001b[0m pub fn d_Phi(phi1: &[f64; 14], phi2: &[f64; 14]) -> f64 {\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^^^^^\u001b[0m \u001b[1m\u001b[33mhelp: convert the identifier to snake case: `d_phi`\u001b[0m\n\n"}
|
||||
{"$message_type":"diagnostic","message":"function `C` should have a snake case name","code":{"code":"non_snake_case","explanation":null},"level":"warning","spans":[{"file_name":"src/silversight/mod.rs","byte_start":4173,"byte_end":4174,"line_start":122,"line_end":122,"column_start":8,"column_end":9,"is_primary":true,"text":[{"text":"pub fn C(phi: &[f64; 14]) -> [f64; 14] {","highlight_start":8,"highlight_end":9}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"convert the identifier to snake case","code":null,"level":"help","spans":[{"file_name":"src/silversight/mod.rs","byte_start":4173,"byte_end":4174,"line_start":122,"line_end":122,"column_start":8,"column_end":9,"is_primary":true,"text":[{"text":"pub fn C(phi: &[f64; 14]) -> [f64; 14] {","highlight_start":8,"highlight_end":9}],"label":null,"suggested_replacement":"c","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: function `C` should have a snake case name\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/silversight/mod.rs:122:8\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m122\u001b[0m \u001b[1m\u001b[94m|\u001b[0m pub fn C(phi: &[f64; 14]) -> [f64; 14] {\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^\u001b[0m \u001b[1m\u001b[33mhelp: convert the identifier to snake case (notice the capitalization): `c`\u001b[0m\n\n"}
|
||||
{"$message_type":"diagnostic","message":"function `test_F_verified` should have a snake case name","code":{"code":"non_snake_case","explanation":null},"level":"warning","spans":[{"file_name":"src/silversight/mod.rs","byte_start":8947,"byte_end":8962,"line_start":262,"line_end":262,"column_start":8,"column_end":23,"is_primary":true,"text":[{"text":" fn test_F_verified() {","highlight_start":8,"highlight_end":23}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"convert the identifier to snake case","code":null,"level":"help","spans":[{"file_name":"src/silversight/mod.rs","byte_start":8947,"byte_end":8962,"line_start":262,"line_end":262,"column_start":8,"column_end":23,"is_primary":true,"text":[{"text":" fn test_F_verified() {","highlight_start":8,"highlight_end":23}],"label":null,"suggested_replacement":"test_f_verified","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: function `test_F_verified` should have a snake case name\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/silversight/mod.rs:262:8\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m262\u001b[0m \u001b[1m\u001b[94m|\u001b[0m fn test_F_verified() {\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^^^^^^^^^^^^^^^\u001b[0m \u001b[1m\u001b[33mhelp: convert the identifier to snake case (notice the capitalization): `test_f_verified`\u001b[0m\n\n"}
|
||||
{"$message_type":"diagnostic","message":"7 warnings emitted","code":null,"level":"warning","spans":[],"children":[],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: 7 warnings emitted\u001b[0m\n\n"}
|
||||
|
|
@ -0,0 +1 @@
|
|||
3603e6c6e3a72a0a
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[]","declared_features":"[]","target":4051077541968869838,"profile":1722584277633009122,"path":10763286916239946207,"deps":[[9857275760291862238,"sha2",false,16385358976997738123]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/silversight-0091d08d533221a7/dep-test-lib-silversight","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
Binary file not shown.
|
|
@ -0,0 +1 @@
|
|||
836949d3068cae3d
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[]","declared_features":"[]","target":17802237870493459759,"profile":1722584277633009122,"path":8873894875274380907,"deps":[[8964551811124349033,"silversight",false,13731937644685174032],[9857275760291862238,"sha2",false,16385358976997738123]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/silversight-018a05e077788a7d/dep-test-integration-test-nuvmap_integration","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
Binary file not shown.
|
|
@ -0,0 +1 @@
|
|||
2d48eb7b897ec7be
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[]","declared_features":"[]","target":2515822492665797901,"profile":8731458305071235362,"path":10763286916239946207,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/silversight-7fa3cf623dbc565f/dep-lib-silversight","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
{"$message_type":"diagnostic","message":"unused imports: `max` and `min`","code":{"code":"unused_imports","explanation":null},"level":"warning","spans":[{"file_name":"src/lib.rs","byte_start":553,"byte_end":556,"line_start":14,"line_end":14,"column_start":16,"column_end":19,"is_primary":true,"text":[{"text":"use std::cmp::{max, min};","highlight_start":16,"highlight_end":19}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null},{"file_name":"src/lib.rs","byte_start":558,"byte_end":561,"line_start":14,"line_end":14,"column_start":21,"column_end":24,"is_primary":true,"text":[{"text":"use std::cmp::{max, min};","highlight_start":21,"highlight_end":24}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"`#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"remove the whole `use` item","code":null,"level":"help","spans":[{"file_name":"src/lib.rs","byte_start":538,"byte_end":564,"line_start":14,"line_end":15,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"use std::cmp::{max, min};","highlight_start":1,"highlight_end":26},{"text":"","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"","suggestion_applicability":"MachineApplicable","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: unused imports: `max` and `min`\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/lib.rs:14:16\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m14\u001b[0m \u001b[1m\u001b[94m|\u001b[0m use std::cmp::{max, min};\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^^^\u001b[0m \u001b[1m\u001b[33m^^^\u001b[0m\n \u001b[1m\u001b[94m|\u001b[0m\n \u001b[1m\u001b[94m= \u001b[0m\u001b[1mnote\u001b[0m: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default\n\n"}
|
||||
{"$message_type":"diagnostic","message":"1 warning emitted","code":null,"level":"warning","spans":[],"children":[],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: 1 warning emitted\u001b[0m\n\n"}
|
||||
Binary file not shown.
|
|
@ -0,0 +1 @@
|
|||
1025466d88a491be
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[]","declared_features":"[]","target":4051077541968869838,"profile":8731458305071235362,"path":10763286916239946207,"deps":[[9857275760291862238,"sha2",false,16385358976997738123]],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/silversight-84f93a17283a98b6/dep-lib-silversight","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
{"$message_type":"diagnostic","message":"unused imports: `max` and `min`","code":{"code":"unused_imports","explanation":null},"level":"warning","spans":[{"file_name":"src/q16/mod.rs","byte_start":553,"byte_end":556,"line_start":14,"line_end":14,"column_start":16,"column_end":19,"is_primary":true,"text":[{"text":"use std::cmp::{max, min};","highlight_start":16,"highlight_end":19}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null},{"file_name":"src/q16/mod.rs","byte_start":558,"byte_end":561,"line_start":14,"line_end":14,"column_start":21,"column_end":24,"is_primary":true,"text":[{"text":"use std::cmp::{max, min};","highlight_start":21,"highlight_end":24}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"`#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"remove the whole `use` item","code":null,"level":"help","spans":[{"file_name":"src/q16/mod.rs","byte_start":538,"byte_end":564,"line_start":14,"line_end":15,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"use std::cmp::{max, min};","highlight_start":1,"highlight_end":26},{"text":"","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"","suggestion_applicability":"MachineApplicable","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: unused imports: `max` and `min`\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/q16/mod.rs:14:16\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m14\u001b[0m \u001b[1m\u001b[94m|\u001b[0m use std::cmp::{max, min};\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^^^\u001b[0m \u001b[1m\u001b[33m^^^\u001b[0m\n \u001b[1m\u001b[94m|\u001b[0m\n \u001b[1m\u001b[94m= \u001b[0m\u001b[1mnote\u001b[0m: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default\n\n"}
|
||||
{"$message_type":"diagnostic","message":"function `F` should have a snake case name","code":{"code":"non_snake_case","explanation":null},"level":"warning","spans":[{"file_name":"src/silversight/mod.rs","byte_start":1942,"byte_end":1943,"line_start":53,"line_end":53,"column_start":8,"column_end":9,"is_primary":true,"text":[{"text":"pub fn F(s: &str) -> [f64; 8] {","highlight_start":8,"highlight_end":9}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"`#[warn(non_snake_case)]` (part of `#[warn(nonstandard_style)]`) on by default","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"convert the identifier to snake case","code":null,"level":"help","spans":[{"file_name":"src/silversight/mod.rs","byte_start":1942,"byte_end":1943,"line_start":53,"line_end":53,"column_start":8,"column_end":9,"is_primary":true,"text":[{"text":"pub fn F(s: &str) -> [f64; 8] {","highlight_start":8,"highlight_end":9}],"label":null,"suggested_replacement":"f","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: function `F` should have a snake case name\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/silversight/mod.rs:53:8\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m53\u001b[0m \u001b[1m\u001b[94m|\u001b[0m pub fn F(s: &str) -> [f64; 8] {\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^\u001b[0m \u001b[1m\u001b[33mhelp: convert the identifier to snake case (notice the capitalization): `f`\u001b[0m\n \u001b[1m\u001b[94m|\u001b[0m\n \u001b[1m\u001b[94m= \u001b[0m\u001b[1mnote\u001b[0m: `#[warn(non_snake_case)]` (part of `#[warn(nonstandard_style)]`) on by default\n\n"}
|
||||
{"$message_type":"diagnostic","message":"function `Phi` should have a snake case name","code":{"code":"non_snake_case","explanation":null},"level":"warning","spans":[{"file_name":"src/silversight/mod.rs","byte_start":3141,"byte_end":3144,"line_start":94,"line_end":94,"column_start":8,"column_end":11,"is_primary":true,"text":[{"text":"pub fn Phi(s: &str) -> [f64; 14] {","highlight_start":8,"highlight_end":11}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"convert the identifier to snake case","code":null,"level":"help","spans":[{"file_name":"src/silversight/mod.rs","byte_start":3141,"byte_end":3144,"line_start":94,"line_end":94,"column_start":8,"column_end":11,"is_primary":true,"text":[{"text":"pub fn Phi(s: &str) -> [f64; 14] {","highlight_start":8,"highlight_end":11}],"label":null,"suggested_replacement":"phi","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: function `Phi` should have a snake case name\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/silversight/mod.rs:94:8\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m94\u001b[0m \u001b[1m\u001b[94m|\u001b[0m pub fn Phi(s: &str) -> [f64; 14] {\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^^^\u001b[0m \u001b[1m\u001b[33mhelp: convert the identifier to snake case: `phi`\u001b[0m\n\n"}
|
||||
{"$message_type":"diagnostic","message":"function `d_F` should have a snake case name","code":{"code":"non_snake_case","explanation":null},"level":"warning","spans":[{"file_name":"src/silversight/mod.rs","byte_start":3470,"byte_end":3473,"line_start":103,"line_end":103,"column_start":8,"column_end":11,"is_primary":true,"text":[{"text":"pub fn d_F<const N: usize>(p: &[f64; N], q: &[f64; N]) -> f64 {","highlight_start":8,"highlight_end":11}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"convert the identifier to snake case","code":null,"level":"help","spans":[{"file_name":"src/silversight/mod.rs","byte_start":3470,"byte_end":3473,"line_start":103,"line_end":103,"column_start":8,"column_end":11,"is_primary":true,"text":[{"text":"pub fn d_F<const N: usize>(p: &[f64; N], q: &[f64; N]) -> f64 {","highlight_start":8,"highlight_end":11}],"label":null,"suggested_replacement":"d_f","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: function `d_F` should have a snake case name\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/silversight/mod.rs:103:8\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m103\u001b[0m \u001b[1m\u001b[94m|\u001b[0m pub fn d_F<const N: usize>(p: &[f64; N], q: &[f64; N]) -> f64 {\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^^^\u001b[0m \u001b[1m\u001b[33mhelp: convert the identifier to snake case (notice the capitalization): `d_f`\u001b[0m\n\n"}
|
||||
{"$message_type":"diagnostic","message":"function `d_Phi` should have a snake case name","code":{"code":"non_snake_case","explanation":null},"level":"warning","spans":[{"file_name":"src/silversight/mod.rs","byte_start":3672,"byte_end":3677,"line_start":110,"line_end":110,"column_start":8,"column_end":13,"is_primary":true,"text":[{"text":"pub fn d_Phi(phi1: &[f64; 14], phi2: &[f64; 14]) -> f64 {","highlight_start":8,"highlight_end":13}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"convert the identifier to snake case","code":null,"level":"help","spans":[{"file_name":"src/silversight/mod.rs","byte_start":3672,"byte_end":3677,"line_start":110,"line_end":110,"column_start":8,"column_end":13,"is_primary":true,"text":[{"text":"pub fn d_Phi(phi1: &[f64; 14], phi2: &[f64; 14]) -> f64 {","highlight_start":8,"highlight_end":13}],"label":null,"suggested_replacement":"d_phi","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: function `d_Phi` should have a snake case name\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/silversight/mod.rs:110:8\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m110\u001b[0m \u001b[1m\u001b[94m|\u001b[0m pub fn d_Phi(phi1: &[f64; 14], phi2: &[f64; 14]) -> f64 {\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^^^^^\u001b[0m \u001b[1m\u001b[33mhelp: convert the identifier to snake case: `d_phi`\u001b[0m\n\n"}
|
||||
{"$message_type":"diagnostic","message":"function `C` should have a snake case name","code":{"code":"non_snake_case","explanation":null},"level":"warning","spans":[{"file_name":"src/silversight/mod.rs","byte_start":4173,"byte_end":4174,"line_start":122,"line_end":122,"column_start":8,"column_end":9,"is_primary":true,"text":[{"text":"pub fn C(phi: &[f64; 14]) -> [f64; 14] {","highlight_start":8,"highlight_end":9}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"convert the identifier to snake case","code":null,"level":"help","spans":[{"file_name":"src/silversight/mod.rs","byte_start":4173,"byte_end":4174,"line_start":122,"line_end":122,"column_start":8,"column_end":9,"is_primary":true,"text":[{"text":"pub fn C(phi: &[f64; 14]) -> [f64; 14] {","highlight_start":8,"highlight_end":9}],"label":null,"suggested_replacement":"c","suggestion_applicability":"MaybeIncorrect","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: function `C` should have a snake case name\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/silversight/mod.rs:122:8\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m122\u001b[0m \u001b[1m\u001b[94m|\u001b[0m pub fn C(phi: &[f64; 14]) -> [f64; 14] {\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^\u001b[0m \u001b[1m\u001b[33mhelp: convert the identifier to snake case (notice the capitalization): `c`\u001b[0m\n\n"}
|
||||
{"$message_type":"diagnostic","message":"6 warnings emitted","code":null,"level":"warning","spans":[],"children":[],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: 6 warnings emitted\u001b[0m\n\n"}
|
||||
Binary file not shown.
|
|
@ -0,0 +1,2 @@
|
|||
{"$message_type":"diagnostic","message":"unused imports: `max` and `min`","code":{"code":"unused_imports","explanation":null},"level":"warning","spans":[{"file_name":"src/lib.rs","byte_start":553,"byte_end":556,"line_start":14,"line_end":14,"column_start":16,"column_end":19,"is_primary":true,"text":[{"text":"use std::cmp::{max, min};","highlight_start":16,"highlight_end":19}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null},{"file_name":"src/lib.rs","byte_start":558,"byte_end":561,"line_start":14,"line_end":14,"column_start":21,"column_end":24,"is_primary":true,"text":[{"text":"use std::cmp::{max, min};","highlight_start":21,"highlight_end":24}],"label":null,"suggested_replacement":null,"suggestion_applicability":null,"expansion":null}],"children":[{"message":"`#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default","code":null,"level":"note","spans":[],"children":[],"rendered":null},{"message":"remove the whole `use` item","code":null,"level":"help","spans":[{"file_name":"src/lib.rs","byte_start":538,"byte_end":564,"line_start":14,"line_end":15,"column_start":1,"column_end":1,"is_primary":true,"text":[{"text":"use std::cmp::{max, min};","highlight_start":1,"highlight_end":26},{"text":"","highlight_start":1,"highlight_end":1}],"label":null,"suggested_replacement":"","suggestion_applicability":"MachineApplicable","expansion":null}],"children":[],"rendered":null}],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: unused imports: `max` and `min`\u001b[0m\n \u001b[1m\u001b[94m--> \u001b[0msrc/lib.rs:14:16\n \u001b[1m\u001b[94m|\u001b[0m\n\u001b[1m\u001b[94m14\u001b[0m \u001b[1m\u001b[94m|\u001b[0m use std::cmp::{max, min};\n \u001b[1m\u001b[94m|\u001b[0m \u001b[1m\u001b[33m^^^\u001b[0m \u001b[1m\u001b[33m^^^\u001b[0m\n \u001b[1m\u001b[94m|\u001b[0m\n \u001b[1m\u001b[94m= \u001b[0m\u001b[1mnote\u001b[0m: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default\n\n"}
|
||||
{"$message_type":"diagnostic","message":"1 warning emitted","code":null,"level":"warning","spans":[],"children":[],"rendered":"\u001b[1m\u001b[33mwarning\u001b[0m\u001b[1m: 1 warning emitted\u001b[0m\n\n"}
|
||||
|
|
@ -0,0 +1 @@
|
|||
8520c2eb0b2387a9
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[]","declared_features":"[]","target":2515822492665797901,"profile":1722584277633009122,"path":10763286916239946207,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/silversight-91f411766c648bdc/dep-test-lib-silversight","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
Binary file not shown.
|
|
@ -0,0 +1 @@
|
|||
5ff1a6fe5a1bb2ad
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[]","declared_features":"[\"const-generics\", \"i128\", \"scale-info\", \"scale_info\", \"strict\"]","target":2349969882102649915,"profile":15657897354478470176,"path":11941924237894204311,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/typenum-2185ef6a5315ebfd/dep-lib-typenum","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
Binary file not shown.
|
|
@ -0,0 +1 @@
|
|||
383c1883e6c89a6e
|
||||
|
|
@ -0,0 +1 @@
|
|||
{"rustc":7458672600737419911,"features":"[]","declared_features":"[]","target":18099224280402537651,"profile":2225463790103693989,"path":13723571820230785595,"deps":[],"local":[{"CheckDepInfo":{"dep_info":"debug/.fingerprint/version_check-840764120b23b4cc/dep-lib-version_check","checksum":false}}],"rustflags":[],"config":8247474407144887393,"compile_kind":0}
|
||||
|
|
@ -0,0 +1 @@
|
|||
cargo:rustc-cfg=relaxed_coherence
|
||||
|
|
@ -0,0 +1 @@
|
|||
/home/allaun/SilverSight/rust/target/debug/build/generic-array-8dfb2b39765de00e/out
|
||||
BIN
rust/target/debug/build/generic-array-c61903c61fac97ae/build-script-build
Executable file
BIN
rust/target/debug/build/generic-array-c61903c61fac97ae/build-script-build
Executable file
Binary file not shown.
Binary file not shown.
|
|
@ -0,0 +1,5 @@
|
|||
/home/allaun/SilverSight/rust/target/debug/build/generic-array-c61903c61fac97ae/build_script_build-c61903c61fac97ae.d: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/build.rs
|
||||
|
||||
/home/allaun/SilverSight/rust/target/debug/build/generic-array-c61903c61fac97ae/build_script_build-c61903c61fac97ae: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/build.rs
|
||||
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/build.rs:
|
||||
8
rust/target/debug/deps/block_buffer-ba5487fa0bd48090.d
Normal file
8
rust/target/debug/deps/block_buffer-ba5487fa0bd48090.d
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
/home/allaun/SilverSight/rust/target/debug/deps/block_buffer-ba5487fa0bd48090.d: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/block-buffer-0.10.4/src/lib.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/block-buffer-0.10.4/src/sealed.rs
|
||||
|
||||
/home/allaun/SilverSight/rust/target/debug/deps/libblock_buffer-ba5487fa0bd48090.rlib: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/block-buffer-0.10.4/src/lib.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/block-buffer-0.10.4/src/sealed.rs
|
||||
|
||||
/home/allaun/SilverSight/rust/target/debug/deps/libblock_buffer-ba5487fa0bd48090.rmeta: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/block-buffer-0.10.4/src/lib.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/block-buffer-0.10.4/src/sealed.rs
|
||||
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/block-buffer-0.10.4/src/lib.rs:
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/block-buffer-0.10.4/src/sealed.rs:
|
||||
7
rust/target/debug/deps/cfg_if-595cd1fd9b5b1165.d
Normal file
7
rust/target/debug/deps/cfg_if-595cd1fd9b5b1165.d
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
/home/allaun/SilverSight/rust/target/debug/deps/cfg_if-595cd1fd9b5b1165.d: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cfg-if-1.0.4/src/lib.rs
|
||||
|
||||
/home/allaun/SilverSight/rust/target/debug/deps/libcfg_if-595cd1fd9b5b1165.rlib: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cfg-if-1.0.4/src/lib.rs
|
||||
|
||||
/home/allaun/SilverSight/rust/target/debug/deps/libcfg_if-595cd1fd9b5b1165.rmeta: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cfg-if-1.0.4/src/lib.rs
|
||||
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cfg-if-1.0.4/src/lib.rs:
|
||||
8
rust/target/debug/deps/cpufeatures-e124fef1b1d91f00.d
Normal file
8
rust/target/debug/deps/cpufeatures-e124fef1b1d91f00.d
Normal file
|
|
@ -0,0 +1,8 @@
|
|||
/home/allaun/SilverSight/rust/target/debug/deps/cpufeatures-e124fef1b1d91f00.d: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cpufeatures-0.2.17/src/lib.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cpufeatures-0.2.17/src/x86.rs
|
||||
|
||||
/home/allaun/SilverSight/rust/target/debug/deps/libcpufeatures-e124fef1b1d91f00.rlib: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cpufeatures-0.2.17/src/lib.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cpufeatures-0.2.17/src/x86.rs
|
||||
|
||||
/home/allaun/SilverSight/rust/target/debug/deps/libcpufeatures-e124fef1b1d91f00.rmeta: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cpufeatures-0.2.17/src/lib.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cpufeatures-0.2.17/src/x86.rs
|
||||
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cpufeatures-0.2.17/src/lib.rs:
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/cpufeatures-0.2.17/src/x86.rs:
|
||||
7
rust/target/debug/deps/crypto_common-121deb944156ca4c.d
Normal file
7
rust/target/debug/deps/crypto_common-121deb944156ca4c.d
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
/home/allaun/SilverSight/rust/target/debug/deps/crypto_common-121deb944156ca4c.d: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crypto-common-0.1.7/src/lib.rs
|
||||
|
||||
/home/allaun/SilverSight/rust/target/debug/deps/libcrypto_common-121deb944156ca4c.rlib: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crypto-common-0.1.7/src/lib.rs
|
||||
|
||||
/home/allaun/SilverSight/rust/target/debug/deps/libcrypto_common-121deb944156ca4c.rmeta: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crypto-common-0.1.7/src/lib.rs
|
||||
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/crypto-common-0.1.7/src/lib.rs:
|
||||
13
rust/target/debug/deps/digest-ccef2157e38fd51a.d
Normal file
13
rust/target/debug/deps/digest-ccef2157e38fd51a.d
Normal file
|
|
@ -0,0 +1,13 @@
|
|||
/home/allaun/SilverSight/rust/target/debug/deps/digest-ccef2157e38fd51a.d: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/lib.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/ct_variable.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/rt_variable.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/wrapper.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/xof_reader.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/digest.rs
|
||||
|
||||
/home/allaun/SilverSight/rust/target/debug/deps/libdigest-ccef2157e38fd51a.rlib: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/lib.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/ct_variable.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/rt_variable.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/wrapper.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/xof_reader.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/digest.rs
|
||||
|
||||
/home/allaun/SilverSight/rust/target/debug/deps/libdigest-ccef2157e38fd51a.rmeta: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/lib.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/ct_variable.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/rt_variable.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/wrapper.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/xof_reader.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/digest.rs
|
||||
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/lib.rs:
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api.rs:
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/ct_variable.rs:
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/rt_variable.rs:
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/wrapper.rs:
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/core_api/xof_reader.rs:
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/digest-0.10.7/src/digest.rs:
|
||||
13
rust/target/debug/deps/generic_array-d73a6db3dcac957a.d
Normal file
13
rust/target/debug/deps/generic_array-d73a6db3dcac957a.d
Normal file
|
|
@ -0,0 +1,13 @@
|
|||
/home/allaun/SilverSight/rust/target/debug/deps/generic_array-d73a6db3dcac957a.d: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/lib.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/hex.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/impls.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/arr.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/functional.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/iter.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/sequence.rs
|
||||
|
||||
/home/allaun/SilverSight/rust/target/debug/deps/libgeneric_array-d73a6db3dcac957a.rlib: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/lib.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/hex.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/impls.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/arr.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/functional.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/iter.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/sequence.rs
|
||||
|
||||
/home/allaun/SilverSight/rust/target/debug/deps/libgeneric_array-d73a6db3dcac957a.rmeta: /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/lib.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/hex.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/impls.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/arr.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/functional.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/iter.rs /home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/sequence.rs
|
||||
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/lib.rs:
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/hex.rs:
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/impls.rs:
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/arr.rs:
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/functional.rs:
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/iter.rs:
|
||||
/home/allaun/.cargo/registry/src/index.crates.io-1949cf8c6b5b557f/generic-array-0.14.7/src/sequence.rs:
|
||||
BIN
rust/target/debug/deps/libblock_buffer-ba5487fa0bd48090.rlib
Normal file
BIN
rust/target/debug/deps/libblock_buffer-ba5487fa0bd48090.rlib
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libblock_buffer-ba5487fa0bd48090.rmeta
Normal file
BIN
rust/target/debug/deps/libblock_buffer-ba5487fa0bd48090.rmeta
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libcfg_if-595cd1fd9b5b1165.rlib
Normal file
BIN
rust/target/debug/deps/libcfg_if-595cd1fd9b5b1165.rlib
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libcfg_if-595cd1fd9b5b1165.rmeta
Normal file
BIN
rust/target/debug/deps/libcfg_if-595cd1fd9b5b1165.rmeta
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libcpufeatures-e124fef1b1d91f00.rlib
Normal file
BIN
rust/target/debug/deps/libcpufeatures-e124fef1b1d91f00.rlib
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libcpufeatures-e124fef1b1d91f00.rmeta
Normal file
BIN
rust/target/debug/deps/libcpufeatures-e124fef1b1d91f00.rmeta
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libcrypto_common-121deb944156ca4c.rlib
Normal file
BIN
rust/target/debug/deps/libcrypto_common-121deb944156ca4c.rlib
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libcrypto_common-121deb944156ca4c.rmeta
Normal file
BIN
rust/target/debug/deps/libcrypto_common-121deb944156ca4c.rmeta
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libdigest-ccef2157e38fd51a.rlib
Normal file
BIN
rust/target/debug/deps/libdigest-ccef2157e38fd51a.rlib
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libdigest-ccef2157e38fd51a.rmeta
Normal file
BIN
rust/target/debug/deps/libdigest-ccef2157e38fd51a.rmeta
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libgeneric_array-d73a6db3dcac957a.rlib
Normal file
BIN
rust/target/debug/deps/libgeneric_array-d73a6db3dcac957a.rlib
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libgeneric_array-d73a6db3dcac957a.rmeta
Normal file
BIN
rust/target/debug/deps/libgeneric_array-d73a6db3dcac957a.rmeta
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libsha2-9772533f5abdf09c.rlib
Normal file
BIN
rust/target/debug/deps/libsha2-9772533f5abdf09c.rlib
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libsha2-9772533f5abdf09c.rmeta
Normal file
BIN
rust/target/debug/deps/libsha2-9772533f5abdf09c.rmeta
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libsilversight-7fa3cf623dbc565f.rlib
Normal file
BIN
rust/target/debug/deps/libsilversight-7fa3cf623dbc565f.rlib
Normal file
Binary file not shown.
BIN
rust/target/debug/deps/libsilversight-7fa3cf623dbc565f.rmeta
Normal file
BIN
rust/target/debug/deps/libsilversight-7fa3cf623dbc565f.rmeta
Normal file
Binary file not shown.
Some files were not shown because too many files have changed in this diff Show more
Loading…
Add table
Reference in a new issue