analogos
Programmable Analogy Framework · v0.5.0 · Apache-2.0
"Analogy is not a way to explain systems. Analogy is the system."
What is analogos?
analogos is a general-purpose framework that formalizes analogy as a programmable primitive.
It is a systems algebra — a minimal set of operators that describes the behavior of any system where information is generated, distributed, filtered, propagated, and composed.
The central proposition:
Different complex systems — neural networks, financial markets, immune systems, blockchains — are instances of the same structural pattern.
Install
pip install analogs
🚀 AI Mainframe: PyTorch & JAX Integration (v0.5.0)
O analogos agora opera como um mainframe de alto desempenho para IA, suportando tensores nativos e execução em hardware acelerado (GPU/TPU).
- Diferenciação Automática: Pritimitivas prontas para integração em loops de treino PyTorch.
- XLA Compilation: Performance otimizada via JAX para processamento de analogias em larga escala.
- Hardware Agnostic: Alterne entre CPU, CUDA e TPU apenas mudando o backend.
import torch
from analogos.backends import TorchPipeline
# Execução em GPU com tensores de alta dimensão
pipeline = TorchPipeline(device='cuda')
result = pipeline.run(source=query_tensor, entities=tensor_space)
Universal Kernel (v0.5.0)
The Kernel is the new central runtime — it executes any domain from a JSON config, a built-in name, or an inline dict.
from analogos import Kernel, Entity
k = Kernel()
# built-in domain
result = k.run(source, entities, domain="neuro")
# external JSON file
result = k.run(source, entities, domain="my_domain.json")
# inline dict
result = k.run(source, entities, domain={
"name": "custom",
"broadcast": {"falloff": "linear", "intensity": 0.8},
"candidate": {"threshold": 0.1},
"propagate": {"social_factor": 0.5},
"compose": {"mode": "top_k", "top_k": 5},
})
print(result.summary())
Built-in domain configs (analogos/domains/*.json):
| Domain | falloff | threshold | social_factor | compose |
|---|---|---|---|---|
neuro |
quadratic | 0.25 | 0.65 | top_k (8) |
market |
sqrt | 0.15 | 0.75 | top_k (6) |
immune |
quadratic | 0.30 | 0.80 | top_k (6) |
blockchain |
linear | 0.03 | 0.60 | vote (5) |
The Five Universal Primitives
scan → broadcast → candidate → propagate → compose
| Primitive | Description | Complexity |
|---|---|---|
| scan() | Traverses the entity space and builds a reference map | O(n) |
| broadcast() | Source emits a signal; intensity decays with distance | O(k) |
| candidate() | Filters entities that received sufficient signal | O(k) |
| propagate() | Candidates relay signal to neighbors — emerging clusters | O(k·r) |
| compose() | Aggregates the cluster into a unified output | O(k) |
Domain Instances
O analogos permite parametrizar diferentes domínios sem reescrever a lógica central:
| Domain | Application |
|---|---|
| analog-attention | Mecanismos de atenção baseados em analogia. |
| analog-neuro | Simulação de caminhos de ativação neuronal. |
| analog-market | Contágio de sinais de preço em ativos financeiros. |
| analog-immune | Cascatas de resposta imunológica. |
| analog-blockchain | Propagação de consenso e validação em rede. |
Project Structure
analogos/
├── core/ ← Primitivas universais (scan, broadcast, etc)
├── backends/ ← Integração PyTorch e JAX (v0.5.0)
├── domains/ ← Implementações específicas (Neuro, Market, etc)
├── adaptive.py ← Engine de calibração automática
└── memory.py ← Analogical Memory Loop
License
Apache License 2.0 — use, modifique e distribua livremente, inclusive para fins comerciais. Diferente da GPL-3.0 anterior, a Apache 2.0 permite:
- Integração em projetos proprietários sem obrigatoriedade de abrir o código derivado.
- Concessão explícita de direitos de patente.
- Segurança jurídica para uso em ecossistemas de produção industrial.
Author
Zaqueu Ribeiro · github.com/omega-Core-Dev
"The pattern was always there. It just needed a name."
print(r1.summary())
cycle 2 — correlates with cycle 1, adapts parameters
r2 = ap.process("Financial markets propagate price signals across assets...", doc_id="market") print(r2.summary())
→ finds shared patterns: ['signals', 'propagation', 'activation', 'patterns']
→ adjusts threshold and social_factor based on structural correlation
retrieve documents similar to the query
similar = ap.memory.retrieve_similar(source_entity, top_k=3)
Each cycle:
1. Converts raw text into `Entity` objects via hash-stable random projections (numpy-only, no ML dependencies)
2. Runs the full analogy pipeline
3. Computes Jaccard + cosine similarity against memory
4. Adjusts `threshold` and `social_factor` based on cluster density and correlation strength
5. Stores the result for future cycles
---
## Domain Instances
Each domain is a parameterization of the five primitives — no new code, only different parameters.
| Domain | scan | broadcast | candidate | propagate | compose |
|--------|------|-----------|-----------|-----------|---------|
| **analog-attention** | tokens | query vector | keys ≥ threshold | value context | weighted sum |
| **analog-neuro** | neurons | action potential | threshold neurons | synaptic relay | firing pattern |
| **analog-market** | assets | price signal | eligible assets | market contagion | portfolio |
| **analog-immune** | antigens | receptor signal | activated cells | immune cascade | response |
| **analog-blockchain** | nodes | broadcast tx | validators | peer relay | block commit |
### analog-neuro
```python
from analogos.domains.neuro import NeuroPipeline, Neuron, Stimulus
neurons = [
Neuron("LGN_1", "LGN", layer=4, neurotransmitter="glutamate"),
Neuron("V1_L4", "V1", layer=4, neurotransmitter="glutamate"),
Neuron("V2_1", "V2", layer=2, neurotransmitter="glutamate"),
Neuron("MT_1", "MT", layer=4, neurotransmitter="glutamate"),
Neuron("PFC_1", "PFC", layer=3, neurotransmitter="dopamine"),
]
stimulus = Stimulus("s1", "flash visual", modality="visual", target_region="V1")
result = NeuroPipeline().fire(stimulus, neurons)
print(result.summary())
# Caminho de ativação: LGN → V1 → V2 → MT → PFC
analog-market
from analogos.domains.market import MarketPipeline, Asset, MarketEvent
assets = [
Asset("TLT", "iShares 20Y Treasury", sector="bonds", beta=-0.3),
Asset("XLF", "Financial Select", sector="financials", beta=1.3),
Asset("QQQ", "NASDAQ-100", sector="tech", beta=1.5),
Asset("GLD", "Gold Trust", sector="commodities",beta=-0.1),
]
event = MarketEvent("fed_hike", "Fed rate hike +75bps", magnitude=0.85,
affected_sectors=["bonds", "financials"])
result = MarketPipeline().shock(event, assets)
print(result.summary())
# Contágio setorial: bonds → financials → tech → commodities
analog-immune
from analogos.domains.immune import ImmunePipeline, ImmuneCell, Pathogen
cells = [
ImmuneCell("dc1", "dendritic", specificity=0.95),
ImmuneCell("th1", "T_helper", specificity=0.85),
ImmuneCell("bc_mem", "B_cell", specificity=0.92, is_memory=True),
ImmuneCell("tc1", "T_cytotoxic", specificity=0.90),
]
pathogen = Pathogen("flu", "Influenza H3N2", pathogen_type="virus", virulence=0.75)
result = ImmunePipeline().respond(pathogen, cells)
print(result.summary())
# Resposta: mista (inata + adaptativa) · células de memória: [bc_mem]
analog-blockchain
from analogos.domains.blockchain import BlockchainPipeline, Node, Transaction
nodes = [
Node("val_01", "validator", stake=0.95, reputation=0.98, region="north_america"),
Node("val_02", "validator", stake=0.90, reputation=0.96, region="europe"),
Node("full_01","full_node", stake=0.20, reputation=0.88, region="asia_pacific"),
]
tx = Transaction("tx_001", "DeFi swap 50 ETH → USDC", fee=0.08, priority=0.9)
result = BlockchainPipeline().broadcast_tx(tx, nodes)
print(result.summary())
# Consenso: ✓ ATINGIDO · Bloco: ✓ COMMITADO
Project Structure
analogos/ ← installable package
├── __init__.py ← full public API
├── py.typed ← PEP 561 — IDE autocomplete & type checking
├── core/
│ ├── entity.py ← Entity base class
│ └── primitives/
│ ├── scan.py
│ ├── broadcast.py
│ ├── candidate.py
│ ├── propagate.py
│ └── compose.py
├── pipeline.py ← Pipeline · PipelineConfig · PipelineResult
├── ingest.py ← TextIngester (text → Entity[])
├── memory.py ← AnalogMemory (incremental record store)
├── correlator.py ← cross-document structural correlation
└── adaptive.py ← AdaptivePipeline
examples/ ← runnable demos
tests/ ← pytest suite
pyproject.toml ← pip-installable, PEP 517/518
IDE Support
The package ships with py.typed (PEP 561) and full type annotations.
Autocomplete, go-to-definition, and inline docs work out of the box in VS Code, PyCharm, Neovim, and any LSP-compatible editor.
from analogos import Entity, Pipeline, AdaptivePipeline # fully typed
Roadmap
- v0.1.0 — Foundation: five primitives in pure Python + architecture
- v0.2.0 — Installable library:
pip install analogos, typed API, adaptive pipeline, memory loop, 11 unit tests - v0.3.0 — Domains:
analog_neuro,analog_market,analog_immune,analog_blockchain— 33 unit tests - v0.4.1 — Integrations: PyTorch tensors, JAX, benchmark vs dot-product attention
- v0.5.0 — Universal Kernel: JSON-configurable domains,
Kernel.run(source, entities, domain=...), declarative domain schema - v1.0.0 — Multi-language bindings (Rust/PyO3, gRPC) + technical paper
Theoretical Foundation
Conventional use of analogy in computing is didactic: it explains a hard concept using a familiar domain, then discards the analogy.
analogos inverts this flow.
The central claim is that the structure of the analogy is the structure of the system. The immune system is not "similar to" an attention mechanism. Both are instances of the same formal pattern:
scan → broadcast → candidate → propagate → compose
What does not exist in the literature is the formalization of analogy as a reusable programmable primitive — an operator that can be instantiated across any domain without rewriting the core logic.
That is what analogos proposes.
License
Apache-2.0 — use, modify, and redistribute freely. See the LICENSE file for details.
Author
Zaqueu Ribeiro · github.com/omega-Core-Dev
"The pattern was always there. It just needed a name."
Metadata
Release files for analogos 0.5.0
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| analogos-0.5.0.tar.gz | 67.8 kB | With provenance | Details for analogos-0.5.0.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| analogos-0.5.0-py3-none-any.whl | Python 3 | none | any | Details for analogos-0.5.0-py3-none-any.whl |
Total release size: 148.4 kB
Release files / analogos-0.5.0.tar.gz
| Download URL | analogos-0.5.0.tar.gz |
|---|---|
| Size | 67.8 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
2ef4e9cf59e6431789ac4b166d5e12f4f6e1c4854912d8c104cc2859376e5483
|
|
BLAKE2b-256 checksum How to use checksums |
abac7a1a9c8efb54ae5b0d28437ba89c4c08c99203354abf967db7eb9727eff2
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/6.1.0 CPython/3.13.12
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Apr 16, 2026.
Transparency logRelease files / analogos-0.5.0-py3-none-any.whl
| Download URL | analogos-0.5.0-py3-none-any.whl |
|---|---|
| Size | 80.7 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
08615d29a367f2234ac1eb50417588c8f5834d75d1d2b09e2dab27fbb3df4802
|
|
BLAKE2b-256 checksum How to use checksums |
e798e7a2febb576755d0ab1bf45240977c6c2a89d91e1e84949f019a1865843e
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
Yes |
| Uploaded via |
twine/6.1.0 CPython/3.13.12
|
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Apr 16, 2026.
Transparency logSecurity for analogos 0.5.0
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
Full provenance
Both files in this release have been uploaded with provenance metadata.
Attestation for analogos-0.5.0.tar.gz
PyPI Publish Attestation
PyPI verified that this artifact, at this checksum, originated from the publisher listed below.
Signed by GitHub Actions, verified by PyPI on Apr 16, 2026.
Transparency logA note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.