accel

type BackendCapabilities struct {
	Backend    BackendType
	Operations map[OperationType]bool
	Categories map[string]bool
}

type BackendComparison struct {
	Operation OperationType
	Results   map[BackendType]BenchmarkResult
	Fastest   BackendType
}

type BackendInfo struct {
	Type        BackendType
	Name        string
	APIVersion  int
	DeviceCount int
}

type BackendType int

type BenchmarkResult struct {
	Backend   BackendType
	Operation OperationType
	Duration  time.Duration
	Error     error
}

type CryptoOps interface {
	// SHA256 computes SHA-256 hashes for a batch of inputs.
	// input: [N, input_len] bytes
	// output: [N, 32] bytes
	SHA256(input, output *UntypedTensor) error

	// Keccak256 computes Keccak-256 (Ethereum hash) for a batch.
	// input: [N, input_len] bytes
	// output: [N, 32] bytes
	Keccak256(input, output *UntypedTensor) error

	// Poseidon computes Poseidon hash (ZK-friendly).
	// input: [N, field_elements] uint64
	// output: [N, 1] uint64
	Poseidon(input, output *UntypedTensor) error

	// ECDSAVerifyBatch verifies multiple ECDSA signatures in parallel.
	// messages: [N, 32] bytes (message hashes)
	// signatures: [N, 64] bytes (r || s)
	// pubkeys: [N, 33] bytes (compressed) or [N, 65] (uncompressed)
	// results: [N] uint8 (1 = valid, 0 = invalid)
	ECDSAVerifyBatch(messages, signatures, pubkeys, results *UntypedTensor) error

	// Ed25519VerifyBatch verifies multiple Ed25519 signatures.
	// messages: [N, msg_len] bytes
	// signatures: [N, 64] bytes
	// pubkeys: [N, 32] bytes
	// results: [N] uint8 (1 = valid, 0 = invalid)
	Ed25519VerifyBatch(messages, signatures, pubkeys, results *UntypedTensor) error

	// BLSVerifyBatch verifies multiple BLS signatures.
	// messages: [N, msg_len] bytes
	// signatures: [N, 96] bytes (G2 points)
	// pubkeys: [N, 48] bytes (G1 points)
	// results: [N] uint8 (1 = valid, 0 = invalid)
	BLSVerifyBatch(messages, signatures, pubkeys, results *UntypedTensor) error

	// BLSAggregate aggregates multiple BLS signatures into one.
	// signatures: [N, 96] bytes
	// aggregated: [96] bytes
	BLSAggregate(signatures, aggregated *UntypedTensor) error

	// MerkleRoot computes Merkle root from leaves.
	// leaves: [N, 32] bytes (N must be power of 2)
	// root: [32] bytes
	MerkleRoot(leaves, root *UntypedTensor) error

	// MerkleBatch computes multiple Merkle roots in parallel.
	// leavesSet: [M, N, 32] bytes
	// roots: [M, 32] bytes
	MerkleBatch(leavesSet, roots *UntypedTensor) error

	// MerkleProof generates Merkle proof for a leaf.
	// leaves: [N, 32] bytes
	// leafIndex: index of the leaf
	// proof: [log2(N), 32] bytes
	MerkleProof(leaves *UntypedTensor, leafIndex int, proof *UntypedTensor) error
}

type DEXOps interface {
	// ConstantProductSwap computes AMM swap output using x*y=k formula.
	// reserveX: [N] uint64 - X token reserves
	// reserveY: [N] uint64 - Y token reserves
	// amountIn: [N] uint64 - input amounts
	// xToY: true for X→Y swap, false for Y→X
	// amountOut: [N] uint64 - output amounts
	// fee: fee percentage (e.g., 0.003 for 0.3%)
	ConstantProductSwap(reserveX, reserveY, amountIn *UntypedTensor, xToY bool, amountOut *UntypedTensor, fee float32) error

	// ConstantProductSwapBatch processes multiple swaps.
	// reserves: [M, 2] uint64 (reserveX, reserveY per pool)
	// swaps: [N, 3] uint64 (poolIndex, amountIn, direction)
	// amounts: [N] uint64 output amounts
	ConstantProductSwapBatch(reserves, swaps, amounts *UntypedTensor, fee float32) error

	// ComputeTWAP computes time-weighted average price.
	// prices: [N] uint64 - historical prices
	// timestamps: [N] uint64 - timestamps
	// start, end: time range
	// twap: [1] uint64 output
	ComputeTWAP(prices, timestamps *UntypedTensor, start, end uint64, twap *UntypedTensor) error

	// MatchOrders matches bid/ask orders.
	// bids: [N, 3] uint64 (price, quantity, orderId)
	// asks: [M, 3] uint64 (price, quantity, orderId)
	// matches: output (bidId, askId, quantity, price)
	// prices: fill prices
	// amounts: fill amounts
	MatchOrders(bids, asks, matches, prices, amounts *UntypedTensor) error

	// MatchOrdersWithPriority matches orders with time/price priority.
	// bids: [N, 4] uint64 (price, quantity, orderId, timestamp)
	// asks: [M, 4] uint64
	MatchOrdersWithPriority(bids, asks, matches *UntypedTensor) error

	// ComputeLiquidity computes concentrated liquidity positions (Uniswap V3 style).
	// tickLower: [N] int32 - lower tick
	// tickUpper: [N] int32 - upper tick
	// amounts: [N, 2] uint64 (amount0, amount1)
	// liquidity: [N] uint128 output
	ComputeLiquidity(tickLower, tickUpper, amounts, liquidity *UntypedTensor) error

	// ComputePositionValue computes position value at current price.
	// liquidity: [N] uint128
	// tickLower: [N] int32
	// tickUpper: [N] int32
	// currentTick: current price tick
	// values: [N, 2] uint64 (token0, token1)
	ComputePositionValue(liquidity, tickLower, tickUpper *UntypedTensor, currentTick int32, values *UntypedTensor) error

	// CalculateFees computes accumulated fees for positions.
	// liquidity: [N] uint128
	// feeGrowthInside0: [N] uint256
	// feeGrowthInside1: [N] uint256
	// fees: [N, 2] uint64 output
	CalculateFees(liquidity, feeGrowthInside0, feeGrowthInside1, fees *UntypedTensor) error

	// BatchSettlement settles multiple trades atomically.
	// trades: [N, 4] uint64 (buyer, seller, token, amount)
	// balances: [M, T] uint64 (M users, T tokens)
	// newBalances: output
	BatchSettlement(trades, balances, newBalances *UntypedTensor) error
}

type DType int

type DeviceCaps uint32

type DeviceInfo struct {
	Backend          BackendType
	Index            int
	Name             string
	Vendor           string
	IsDiscrete       bool
	IsUnifiedMemory  bool
	TotalMemory      uint64 // bytes
	MaxBufferSize    uint64 // bytes
	MaxWorkgroupSize uint32
	SIMDWidth        uint32
	Capabilities     DeviceCaps
}

type Error struct {
	Op      string // Operation that failed
	Backend BackendType
	Err     error
	Detail  string // Additional detail from C library
}

type FHEOps interface {
	// BFVEncrypt encrypts plaintext with BFV scheme.
	// plaintext: [N] int64 values (N ≤ poly_modulus_degree)
	// pk: public key
	// ciphertext: output ciphertext
	BFVEncrypt(plaintext, pk, ciphertext *UntypedTensor) error

	// BFVEncryptBatch encrypts multiple plaintexts.
	// plaintexts: [M, N] int64
	// pk: public key
	// ciphertexts: [M, ...] output
	BFVEncryptBatch(plaintexts, pk, ciphertexts *UntypedTensor) error

	// BFVDecrypt decrypts ciphertext.
	// ciphertext: input ciphertext
	// sk: secret key
	// plaintext: [N] int64 output
	BFVDecrypt(ciphertext, sk, plaintext *UntypedTensor) error

	// BFVAdd adds two ciphertexts.
	// ct1, ct2: input ciphertexts
	// result: output ciphertext
	BFVAdd(ct1, ct2, result *UntypedTensor) error

	// BFVMultiply multiplies ciphertexts with relinearization.
	// ct1, ct2: input ciphertexts
	// relinKey: relinearization key
	// result: output ciphertext
	BFVMultiply(ct1, ct2, relinKey, result *UntypedTensor) error

	// BFVMultiplyPlain multiplies ciphertext by plaintext.
	// ct: input ciphertext
	// plain: [N] int64 plaintext
	// result: output ciphertext
	BFVMultiplyPlain(ct, plain, result *UntypedTensor) error

	// BFVRotate rotates ciphertext slots.
	// ct: input ciphertext
	// galoisKey: Galois key for rotation
	// steps: rotation amount (positive = left)
	// result: output ciphertext
	BFVRotate(ct, galoisKey *UntypedTensor, steps int, result *UntypedTensor) error

	// CKKSEncrypt encrypts with CKKS (approximate arithmetic).
	// plaintext: [N] float64 values
	// pk: public key
	// scale: encoding scale
	// ciphertext: output
	CKKSEncrypt(plaintext, pk *UntypedTensor, scale float64, ciphertext *UntypedTensor) error

	// CKKSDecrypt decrypts CKKS ciphertext.
	// ciphertext: input
	// sk: secret key
	// plaintext: [N] float64 output
	CKKSDecrypt(ciphertext, sk, plaintext *UntypedTensor) error

	// CKKSAdd adds two CKKS ciphertexts.
	CKKSAdd(ct1, ct2, result *UntypedTensor) error

	// CKKSMultiply multiplies CKKS ciphertexts.
	CKKSMultiply(ct1, ct2, relinKey, result *UntypedTensor) error

	// CKKSRescale rescales ciphertext after multiplication.
	CKKSRescale(ct, result *UntypedTensor) error

	// CKKSRotate rotates CKKS slots.
	CKKSRotate(ct, galoisKey *UntypedTensor, steps int, result *UntypedTensor) error

	// Bootstrap refreshes ciphertext noise level (limited support).
	Bootstrap(ct, bootstrapKey, result *UntypedTensor) error
}

type LatticeOps interface {
	// KyberKeyGen generates Kyber (ML-KEM) key pair.
	// pk: [1184] bytes (Kyber768 public key)
	// sk: [2400] bytes (Kyber768 secret key)
	KyberKeyGen(pk, sk *UntypedTensor) error

	// KyberKeyGenBatch generates multiple key pairs in parallel.
	// pk: [N, 1184] bytes
	// sk: [N, 2400] bytes
	KyberKeyGenBatch(pk, sk *UntypedTensor) error

	// KyberEncaps encapsulates shared secret.
	// pk: [1184] bytes public key
	// ct: [1088] bytes ciphertext output
	// ss: [32] bytes shared secret output
	KyberEncaps(pk, ct, ss *UntypedTensor) error

	// KyberEncapsBatch performs batch encapsulation.
	// pk: [N, 1184] bytes
	// ct: [N, 1088] bytes
	// ss: [N, 32] bytes
	KyberEncapsBatch(pk, ct, ss *UntypedTensor) error

	// KyberDecaps decapsulates shared secret.
	// ct: [1088] bytes ciphertext
	// sk: [2400] bytes secret key
	// ss: [32] bytes shared secret output
	KyberDecaps(ct, sk, ss *UntypedTensor) error

	// KyberDecapsBatch performs batch decapsulation.
	// ct: [N, 1088] bytes
	// sk: [N, 2400] bytes
	// ss: [N, 32] bytes
	KyberDecapsBatch(ct, sk, ss *UntypedTensor) error

	// DilithiumKeyGen generates Dilithium (ML-DSA) key pair.
	// pk: [1952] bytes (Dilithium3 public key)
	// sk: [4016] bytes (Dilithium3 secret key)
	DilithiumKeyGen(pk, sk *UntypedTensor) error

	// DilithiumSign signs a message.
	// msg: [msg_len] bytes message
	// sk: [4016] bytes secret key
	// sig: [3293] bytes signature output
	DilithiumSign(msg, sk, sig *UntypedTensor) error

	// DilithiumSignBatch signs multiple messages in parallel.
	// msgs: [N, msg_len] bytes
	// sk: [4016] bytes (same key for all)
	// sigs: [N, 3293] bytes
	DilithiumSignBatch(msgs, sk, sigs *UntypedTensor) error

	// DilithiumVerify verifies a signature.
	// msg: [msg_len] bytes
	// sig: [3293] bytes
	// pk: [1952] bytes
	// Returns true if valid.
	DilithiumVerify(msg, sig, pk *UntypedTensor) (bool, error)

	// DilithiumVerifyBatch verifies multiple signatures.
	// msgs: [N, msg_len] bytes
	// sigs: [N, 3293] bytes
	// pks: [N, 1952] bytes
	// results: [N] uint8 (1 = valid, 0 = invalid)
	DilithiumVerifyBatch(msgs, sigs, pks, results *UntypedTensor) error

	// PolynomialNTT performs NTT in lattice polynomial ring.
	// Operates on polynomials in Z_q[X]/(X^256 + 1).
	PolynomialNTT(input, output *UntypedTensor, q uint32) error

	// PolynomialINTT performs inverse NTT.
	PolynomialINTT(input, output *UntypedTensor, q uint32) error

	// PolynomialMul multiplies polynomials in NTT domain.
	PolynomialMul(a, b, c *UntypedTensor, q uint32) error

	// PolynomialAdd adds polynomials.
	PolynomialAdd(a, b, c *UntypedTensor, q uint32) error
}

type MLOps interface {
	// MatMul performs matrix multiplication: C = A @ B
	MatMul(a, b, c *UntypedTensor) error

	// MatMulTranspose performs C = A @ B^T or C = A^T @ B
	MatMulTranspose(a, b, c *UntypedTensor, transposeA, transposeB bool) error

	// ReLU applies rectified linear unit: y = max(0, x)
	ReLU(input, output *UntypedTensor) error

	// GELU applies Gaussian error linear unit activation
	GELU(input, output *UntypedTensor) error

	// Softmax applies softmax along an axis
	Softmax(input, output *UntypedTensor, axis int) error

	// LayerNorm applies layer normalization
	LayerNorm(input, gamma, beta, output *UntypedTensor, eps float32) error

	// Attention computes scaled dot-product attention
	// output = softmax(Q @ K^T / scale) @ V
	Attention(q, k, v, output *UntypedTensor, scale float32) error

	// Conv2D performs 2D convolution
	Conv2D(input, kernel, output *UntypedTensor, stride, padding [2]int) error

	// MaxPool2D performs 2D max pooling
	MaxPool2D(input, output *UntypedTensor, kernelSize, stride [2]int) error

	// BatchNorm applies batch normalization
	BatchNorm(input, gamma, beta, mean, variance, output *UntypedTensor, eps float32) error

	// Dropout applies dropout with given probability (inference mode)
	Dropout(input, output *UntypedTensor, p float32) error

	// Add performs element-wise addition
	Add(a, b, c *UntypedTensor) error

	// Multiply performs element-wise multiplication
	Multiply(a, b, c *UntypedTensor) error

	// Sum reduces tensor along specified axes
	Sum(input, output *UntypedTensor, axes []int) error

	// Mean reduces tensor along specified axes
	Mean(input, output *UntypedTensor, axes []int) error
}

type OperationType int

type Session struct {
	// contains filtered or unexported fields
}

type SessionOption func(*sessionConfig)

type Tensor[T TensorElement] struct {
	// contains filtered or unexported fields
}

type TensorElement interface {
	float32 | float64 | int32 | int64 | uint8 | uint32 | uint64
}

type UntypedTensor struct {
	// contains filtered or unexported fields
}

type ZKOps interface {
	// NTT performs Number Theoretic Transform.
	// input: [N] uint64 coefficients
	// output: [N] uint64 NTT values
	// roots: [N] uint64 roots of unity
	// modulus: prime modulus
	NTT(input, output, roots *UntypedTensor, modulus uint64) error

	// INTT performs inverse NTT.
	// input: [N] uint64 NTT values
	// output: [N] uint64 coefficients
	// invRoots: [N] uint64 inverse roots of unity
	// modulus: prime modulus
	INTT(input, output, invRoots *UntypedTensor, modulus uint64) error

	// MSM performs multi-scalar multiplication on elliptic curves.
	// scalars: [N, scalar_size] bytes
	// bases: [N, point_size] bytes (affine points)
	// result: [point_size] bytes
	MSM(scalars, bases, result *UntypedTensor) error

	// MSMBatch performs multiple MSMs in parallel.
	// scalars: [M, N, scalar_size] bytes
	// bases: [M, N, point_size] bytes
	// results: [M, point_size] bytes
	MSMBatch(scalars, bases, results *UntypedTensor) error

	// PolyMul multiplies polynomials in coefficient form.
	// a: [N] uint64 coefficients
	// b: [N] uint64 coefficients
	// c: [2N-1] uint64 result coefficients
	// modulus: prime modulus
	PolyMul(a, b, c *UntypedTensor, modulus uint64) error

	// PolyEval evaluates polynomial at given points.
	// coeffs: [degree+1] uint64
	// points: [N] uint64
	// results: [N] uint64
	// modulus: prime modulus
	PolyEval(coeffs, points, results *UntypedTensor, modulus uint64) error

	// CommitPoly computes polynomial commitment (KZG).
	// coeffs: [degree+1, field_size] bytes
	// srs: structured reference string
	// commitment: [point_size] bytes
	CommitPoly(coeffs, srs, commitment *UntypedTensor) error

	// FFT performs Fast Fourier Transform (complex).
	// input: [N, 2] float32 (real, imag)
	// output: [N, 2] float32
	FFT(input, output *UntypedTensor) error

	// IFFT performs inverse FFT.
	IFFT(input, output *UntypedTensor) error

	// FieldAdd adds field elements.
	// a: [N] uint64
	// b: [N] uint64
	// c: [N] uint64
	// modulus: prime modulus
	FieldAdd(a, b, c *UntypedTensor, modulus uint64) error

	// FieldMul multiplies field elements.
	FieldMul(a, b, c *UntypedTensor, modulus uint64) error

	// FieldInv computes modular inverse.
	FieldInv(a, b *UntypedTensor, modulus uint64) error
}