#31

g/computerscience

ago

public

earned

reactions

x\_tymatrA'Nm

{'= \m= sD #31 , 28Hyperdimensional Connections – A Lossless, Queryable Semantic Reasoning Framework

Hi all, I'm happy to share a focused research paper and benchmark suite highlighting the Hyperdimensional Connection Method, a key module of the open-source \MatrixTransformer\ https://github.com/fikayoAy/MatrixTransformer library

What is it?

Unlike traditional approaches that compress data and discard relationships, this method offers a

lossless framework for discovering hyperdimensional connections across modalities, preserving full matrix structure, semantic coherence, and sparsity.

This is not dimensionality reduction in the PCA/t-SNE sense. Instead, it enables:

\-Queryable semantic networks across data types (by either using the matrix saved from the connection\_to\_matrix method or any other ways of querying connections you could think of)

Lossless matrix transformation (1.000 reconstruction accuracy)

100% sparsity retention

Cross-modal semantic bridging (e.g., TF-IDF ↔ pixel patterns ↔ interaction graphs)

Benchmarked Domains:

\- Biological: Drug–gene interactions → clinically relevant pattern discovery

\- Textual: Multi-modal text representations (TF-IDF, char n-grams, co-occurrence)

\- Visual: MNIST digit connections (e.g., discovering which 6s resemble 8s)

🔎 This method powers relationship discovery, similarity search, anomaly detection, and structure-preserving feature mapping — all \*\*without discarding a single data point\*\*.

Usage example:

from matrixtransformer import MatrixTransformer

import numpy as np

\# Initialize the transformer

transformer = MatrixTransformer(dimensions=256)

\# Add some sample matrices to the transformer's storage

sample\_matrices = \

np.random.randn(# Image-like matrix

np.eye(10) # Identity matrix

np.random.randn(15, 5), # Random square matrix

np.random.randn(20, 0), # Rectangular matrix

np.diag(np.random.randn(12)iagonal matrix

\]

\# Store matrices in the transformer

transformer.matricple\_matrices

\# Optional: Add some metadata about the matrices

transformer.layer\type': 'image', 'source': 'synthetic'},

{'type': 'identity', 'source': 'standard'},

{'type': 'random', 'source': 'synthetic'},

{'type': 'rectangular', 'source': 'synthetic'},

{'type': 'diagonal', 'source': 'synthetic'}

\]

\# Find hyperdimensional connections

print("Finding hyperdimensional connections...")

connections = transformer.find\_hyperdimensional\_connections(num\_dims=8)

\# Access stored matrices

print(f"\\nAccessing stored matrices:")

print(f"Number of matrices stored: {len(transformer.matrices)}")

for i, matrix in enumerate(transformer.matrices):

print(f"Matrix {i}: shape {matrix.shape}, type: {transformer.\_detect\_matrix\_type(matrix)}")

\# Convert connections to matrix representation

print("\\nConverting connections to matrix format...")

coords3d = \[\]

for i, matrix in enumerate(transformer.matrices):

coords = transformer.\_generate\_matrix\_coordinates(matrix, i)

coords3d.append(coords)

coords3d = np.array(coords3d)

indices = list(range(len(transformer.matrices)))

\# Create connection matrix with metadata

conn\_matrix, metadata = transformer.connections\_to\_matrix(
connections, coords3d, indices, matrix\_type='general'

)

print(f"Connection matrix shape: {conn\_matrix.shape}")

print(f"Matrix sparsity: {metadata.get('matrix\_sparsity', 'N/A')}")

print(f"Total connections found: {metadata.get('connection\_count', 'N/A')}")

\# Reconstruct connections from matrix

print("\\nReconstructing connections from matrix...")

reconstructed\_connections = transformer.matrix\_to\_connections(conn\_matrix, etadata)

\# Compare original vs reconstructed

print(f"Original connections: {len(connections)} matrices")

print(f"Reconstructed connections: {len(reconstructed\_connections)} matrices")

\# Access specific matrix and its connections

matrix\_idx = 0

if matrix\_idx in connections:

print(f"\\nMatrix {matrix\_idx} connections:")

print(f"Original matrix shape: {transformer.matrices\[matrix\_idx\].shape}")

print(f"Number of connections: {len(connections\[matrix\_idx\])}")

\# Show first few connections

for i, conn in enumerate(connections\[matrix\_idx\]\[:3\]):

target\_idx = conn\['target\_idx'\]

strength = conn.get('strength'')

print(f" -> Connected to matrix {target\_idx} (shape: {transformer.matrices\[target\_idx\].shape}) with strength: {strength}")

\# Example: Process a specific matrix through the transformer

print("\\nProcessing a matrix through transformer:")

test\_matrix = transformer.matrices\[0\]

matrix\_type = transformer.\_detect\_matrix\_type(test\_matrix)

print(f"Detected matrix type: {matrix\_type}")

\# Transform the matrix

transformed = transformer.process\_rectangular\_matrix(test\_pe)

print(f"Transformed matrix shape: {transformed.shape}")

Clone from github and Install from wheel file

git clone [https://github.com/fikayoAy/MatrixTransformer.git https://github.com/fikayoAy/MatrixTransformer.git
cd MatrixTransformer

pip install dist/matrixtransformer-0.1.0-py3-none-any.whl

Links:

\- Research Paper (Hyperdimensional Module): \Zenodo DOI\ https://doi.org/10.5281/zenodo.16051260

Parent Library – MatrixTransformer: \GitHub\ https://github.com/fikayoAy/MatrixTransformer

MatrixTransformer Core Paper: \https://doi.org/10.5281/zenodo.15867279\ https://doi.org/10.5281/zenodo.15867279

Would love to hear thoughts, feedback, or questions. Thanks!
#technology
matriix, /,

_in[fo aes ) , 28),