File size: 2,391 Bytes
b19d528 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 | /-!
# Sovereign Array Language — Core Array Type
Mathematical foundation (valid isomorphisms only, per architectural review):
| NumPy Concept | HoTT / Unimath Translation | Status |
|-------------------|-----------------------------------------------|--------|
| Array | Dependent function `I → α` | Sound |
| Shape / Index | Finite type `I : Type` | Sound |
| Vectorized Op | `Π (i : I), op (A i) (B i)` (pointwise) | Sound |
| Equality of Array | Function extensionality | Sound |
We deliberately do NOT claim:
- proof complexity = computational complexity
- lossy quotient invariants (Abjad / digital root) are universal arithmetic
- univalence replaces SIMD at the metalayer
-/
namespace SovereignArray
universe u v
/-- An array indexed by shape `I` with elements of type `α`.
This is exactly the dependent-function model used in Cubical Agda / Lean. -/
def Array (I : Type u) (α : Type v) : Type (max u v) := I → α
namespace Array
variable {I : Type u} {α : Type v}
/-- Pointwise lifting of a binary operation.
Categorical semantics of a vectorized op: a `Π`-map over the index space `I`. -/
def pmap₂ (op : α → α → α) (a b : Array I α) : Array I α :=
fun i => op (a i) (b i)
/-- `O(1)` *proof* equality is function extensionality.
Computational equality is `O(|I|)`; we never conflate the two. -/
theorem pmap₂_congr {op : α → α → α} {a a' b b' : Array I α}
(ha : ∀ i, a i = a' i) (hb : ∀ i, b i = b' i) :
pmap₂ op a b = pmap₂ op a' b' := by
funext i
simp [pmap₂, ha i, hb i]
/-- `pmap₂` fusion: applying a post-map to a `pmap₂` is itself a `pmap₂`.
Fusion = `Π`-map fusion; no loop exists in the denotation. -/
theorem pmap₂_fusion {op : α → α → α} {a b : Array I α} (f : α → α) :
(fun i => f (pmap₂ op a b i)) = pmap₂ (fun x _ => f (op x x)) a b := by
funext i
simp [pmap₂]
/-- `pmap₂` is associative in the operation when the operation is. -/
theorem pmap₂_assoc {op : α → α → α} {a b c : Array I α}
(h : ∀ x y z, op (op x y) z = op x (op y z)) :
pmap₂ op (pmap₂ op a b) c = pmap₂ op a (pmap₂ op b c) := by
funext i
simp [pmap₂, h]
end Array
end SovereignArray
|