Negociando com Mecânica Quântica: Como Criar um Agente de IA Autônomo

A mesma matemática que descreve uma partícula em dois lugares ao mesmo tempo pode descrever um portfólio em duas posições simultaneamente. Veja como transformar a estrutura da mecânica quântica em um agente de negociação autônomo - e, igualmente importante, onde a analogia deixa de ser real e começa a ser marketing.

1. Por que quântico, e por que agora

Todos os hedge funds do planeta estão moendo as mesmas três ideias até virarem pó: momentum, reversão à média e algum tipo de aprendizado de máquina em fluxo de ordens. A vantagem continua diminuindo porque o modelo de mercado que todos compartilham é idêntico - um modelo clássico, onde um preço é um número único e o futuro é um único caminho ruidoso.

A mecânica quântica oferece um modelo de dados diferente. Um sistema quântico nunca está em um único estado. Ele vive em uma superposição de todos os estados possíveis ao mesmo tempo, cada um carregando uma amplitude de probabilidade complexa. Isso acaba sendo uma descrição surpreendentemente boa de um mercado antes de você colocar uma ordem: o ativo está simultaneamente subindo, descendo e lateralizando, cada resultado ponderado por uma probabilidade, até que sua ordem force a realidade a escolher um.

Aqui está a parte que a maioria dos artigos pula, então vou deixá-la clara desde já. Você não precisa de um computador quântico físico para nada disso, e a maior parte do que se segue não é literalmente quântico. É inspirado em quântica: algoritmos clássicos que pegam emprestada a estrutura matemática da mecânica quântica - vetores de estado, amplitudes complexas, hamiltonianos, recozimento, interferência - e rodam na mesma GPU que você já possui. O valor está na estrutura, não nos qubits. Ser honesto sobre essa distinção é o que separa uma estrutura utilizável de um buzzword.

Bancos e quant shops - entre eles Goldman Sachs, JPMorgan, HSBC e especialistas como Multiverse Computing - pesquisaram e publicaram ativamente sobre métodos quânticos e inspirados em quântica para precificação de derivativos, risco de Monte Carlo e otimização de portfólio. A teoria é pública. O que quase ninguém documentou é como conectá-la a um agente autônomo - um sistema que percebe, decide, executa e aprende por conta própria. É isso que construímos aqui.

2. O dicionário quântico-para-mercado

Antes de qualquer código, você precisa do mapeamento. Cada conceito quântico abaixo tem um análogo preciso de negociação. Trate esta seção como o contrato conceitual para tudo o que se segue.

Amplitude de probabilidade mapeia para convicção - mas com uma fase. Probabilidades clássicas são apenas números não negativos. Amplitudes quânticas são complexas: cada uma carrega uma magnitude e um ângulo de fase. A fase é a atualização completa. É o que permite que dois sinais de alta interfiram destrutivamente e se cancelem, ou que dois sinais fracos interfiram construtivamente em um forte. Um ensemble clássico que calcula a média de probabilidades positivas fisicamente não consegue fazer isso - o melhor que pode fazer é diluir. A fase permite que os sinais se vetem ativamente.

Emaranhamento mapeia para correlação que você não consegue separar. Quando dois ativos se movem como um regime vinculado - pense em uma moeda principal e as memecoins que surfam sua liquidez - você não consegue descrever honestamente um sem o outro. O agente codifica isso como um estado não separável, que captura o co-movimento vinculado ao regime que uma matriz de correlação estática tende a achatar e subestimar, especialmente nas caudas.

O Hamiltoniano mapeia para sua função de custo risco/retorno. Na física, o Hamiltoniano H codifica a energia de um sistema. Na negociação, você codifica seu objetivo - maximizar o retorno esperado, minimizar a variância, respeitar limites de posição e orçamento - como uma paisagem de energia. O portfólio ótimo é então o estado fundamental: a configuração de menor energia de H. A construção do portfólio se torna um problema de minimização de energia, que é algo muito bem estudado de se resolver.

Medição e colapso mapeiam para execução. No instante em que você envia uma ordem, a superposição colapsa em um resultado realizado. O verdadeiro trabalho do agente é escolher quando e o que medir para que o colapso tenda a pousar em uma configuração lucrativa. Há até um princípio de risco embutido por analogia a Heisenberg: você não pode fixar simultaneamente o preço exato de uma posição e seu momento exato com precisão ilimitada. Exigir mais certeza em um custa certeza no outro. Isso é uma analogia, não uma lei das finanças - mas é útil, e mais tarde se transforma em uma regra concreta de dimensionamento de posição.

3. A arquitetura de um agente de negociação quântico

O agente é um loop fechado de seis módulos. O diagrama de arquitetura anexado a este post mostra o ciclo completo; aqui está o que cada etapa faz.

1. Percepção. Ingerir dados brutos de mercado - livro de ordens, OHLCV, taxas de funding, fluxo on-chain. Normalizar em um vetor de características x. Isso é encanamento quant comum; nada quântico ainda.

3. Construtor de Hamiltoniano. Traduzir seu objetivo de risco/retorno mais restrições em um Hamiltoniano QUBO / Ising H. É aqui que limites de orçamento, aversão ao risco e retornos esperados são incorporados em uma paisagem de energia.

4. Solucionador inspirado em quântica. Encontrar o estado fundamental de H - a seleção ótima de ativos - via recozimento simulado, um circuito QAOA em um simulador ou um solucionador de rede tensorial. Este módulo é seu otimizador de portfólio, e é deliberadamente intercambiável.

5. Decisão por medição. Colapsar o estado em posições e tamanhos concretos, com a regra estilo Heisenberg reduzindo a exposição quando a incerteza é alta.

6. Execução e feedback. Roteirizar as ordens, observar o P&L realizado e atualizar as amplitudes. O resultado medido se torna a priori do dia seguinte - um loop de reforço que permite ao agente se adaptar em vez de executar uma estratégia congelada.

4. Código: codificando o mercado como um estado quântico

Usaremos numpy para a matemática de estado e nos apoiaremos nas convenções do qiskit / pennylane para as partes inspiradas em quântica. Nada aqui precisa de hardware quântico real - roda em um laptop.

A interferência é o ponto central, então a codificação deve permitir que os sinais se somem como números complexos antes de você calcular as probabilidades. Cada modelo alfa contribui com uma amplitude complexa - magnitude igual à convicção, fase igual ao timing ou alinhamento de regime - para cada cenário de mercado. Você soma as contribuições entre os modelos, e só então aplica a regra de Born.

1import numpy as np
2
3def combine_signals(contributions: np.ndarray) -> np.ndarray:
4    """
5    contributions: matriz complexa de forma [n_sinais, n_cenarios].
6                   |valor| = convicção de um modelo para um cenário,
7                   angulo = sua fase (timing / alinhamento de regime).
8    retorna:       estado normalizado |psi> sobre os cenários.
9    """
10    amplitudes = contributions.sum(axis=0)          # sinais INTERFEREM aqui
11    return amplitudes / np.linalg.norm(amplitudes)
12
13# Cenários: [sobe, desce, lateral, rompimento]
14# Dois modelos de momentum ambos inclinam 'sobe' -- mas estão fora de fase, então cancelam parcialmente.
15signal_A = np.array([0.7+0j, 0.1+0j, 0.2+0j, 0.3+0j])       # altista, fase 0
16signal_B = np.array([0.6*np.exp(1j*2.7), 0.15, 0.2, 0.25])  # altista mas ~antifase
17
18psi = combine_signals(np.vstack([signal_A, signal_B]))
19
20# Probabilidade de cada cenário = |amplitude|^2  (regra de Born)
21probs = np.abs(psi) ** 2
22print(probs.round(3))   # -> [0.147 0.102 0.26 0.491]

A linha chave é a regra de Born: probabilidade é igual ao quadrado da magnitude da amplitude. Como os dois sinais de alta são somados como números complexos antes da quadratura, seus componentes fora de fase se cancelam, e o cenário "sobe" lotado é suprimido de um ingênuo 0,76 para 0,147. O agente automaticamente desvanece uma aposta de consenso supercorrelacionada. Essa é a diferença concreta e mensurável entre isso e um ensemble simples de média de probabilidades, e o diagrama de interferência anexado a este post mostra os mesmos números lado a lado.

5. A parte difícil que ninguém mostra: de onde vem a fase?

Todo artigo que te vende "negociação quântica" codifica as fases silenciosamente e espera que você não perceba. No trecho acima eu escrevi np.exp(1j\2.7) manualmente. Em um sistema real, inventar a fase é o problema de pesquisa inteiro*, e fingir o contrário é a maneira mais rápida de se enganar.

Então trate a fase como um alvo de modelagem de primeira classe, não uma decoração. Algumas maneiras fundamentadas de derivá-la em vez de adivinhar:

Timing / fase de ciclo. Execute cada sinal por uma transformada de Hilbert ou uma decomposição wavelet e leia a fase instantânea do ciclo dominante. Dois modelos de momentum que disparam na mesma direção, mas em fases de ciclo diferentes, devem realmente cancelar parcialmente - isso é exatamente a lotação que você quer detectar.

Fase de liderança-atraso. Estime a defasagem de correlação cruzada entre um sinal e os retornos futuros. Converta essa defasagem em um ângulo. Sinais que lideram o preço recebem uma fase; retardatários que estão apenas perseguindo recebem outra, então eles interferem destrutivamente com os líderes em vez de contagem dupla.

Fase de regime. Mapeie um classificador de regime (tendência vs. lateral, alta vs. baixa volatilidade) em um ângulo para que a contribuição de um sinal gire conforme o regime gira. Um modelo de rompimento e um modelo de reversão à média então naturalmente se sentam perto de fases opostas.

A disciplina é simples: se você não consegue explicar por que um sinal tem a fase que tem, você não pode usar a fase. Volte para a fase 0 para tudo, e você está de volta a um ensemble clássico - o que é bom e honesto. A fase é poderosa precisamente porque é difícil de obter.

6. Código: o portfólio como uma busca de estado fundamental

A seleção de portfólio sob restrições é otimização combinatória - escolha o melhor subconjunto de ativos sujeito a um orçamento e limites de risco. Essa é exatamente a forma do problema para o qual o recozimento foi construído. Codificamos "quais ativos manter" como um QUBO (Quadratic Unconstrained Binary Optimization), o equivalente clássico de um Hamiltoniano Ising.

1import numpy as np
2
3def build_portfolio_hamiltonian(expected_returns, cov, risk_aversion=1.0,
4                                budget=3, penalty=5.0):
5    """
6    Constrói uma matriz QUBO Q de modo que minimizar x^T Q x  (x em {0,1}^n)
7    escolha os melhores ativos 'budget': maximize retorno, minimize risco,
8    e penalize suavemente quebrar a restrição orçamentária.
9    """
10    n = len(expected_returns)
11    Q = np.zeros((n, n))
12
13    # retorno (negado, pois minimizamos) mais um termo de risco da covariância
14    for i in range(n):
15        Q[i, i] += -expected_returns[i] + risk_aversion * cov[i, i]
16        for j in range(i + 1, n):
17            Q[i, j] += 2 * risk_aversion * cov[i, j]
18
19    # restrição orçamentária (sum x_i - budget)^2 como penalidade suave
20    for i in range(n):
21        Q[i, i] += penalty * (1 - 2 * budget)
22        for j in range(i + 1, n):
23            Q[i, j] += 2 * penalty
24    return Q
25
26def simulated_anneal(Q, steps=20000, T0=5.0):
27    """Recozimento inspirado em quântica: esfrie lentamente o sistema até seu estado fundamental."""
28    n = Q.shape[0]
29    x = np.random.randint(0, 2, n)
30    def energy(x): return x @ Q @ x
31    e = energy(x)
32    for t in range(steps):
33        T = T0 * (1 - t / steps)                 # programação linear de temperatura
34        i = np.random.randint(n)
35        x_new = x.copy(); x_new[i] ^= 1          # inverte um ativo (inclui/exclui)
36        e_new = energy(x_new)
37        # aceita melhorias sempre, e movimentos piores às vezes (é assim que escapa de mínimos locais)
38        if e_new < e or np.random.rand() < np.exp(-(e_new - e) / max(T, 1e-9)):
39            x, e = x_new, e_new
40    return x, e
41
42returns = np.array([0.12, 0.09, 0.15, 0.04, 0.11])
43cov = np.array([
44    [0.10, 0.02, 0.01, 0.00, 0.03],
45    [0.02, 0.08, 0.02, 0.01, 0.01],
46    [0.01, 0.02, 0.18, 0.00, 0.02],
47    [0.00, 0.01, 0.00, 0.03, 0.00],
48    [0.03, 0.01, 0.02, 0.00, 0.09],
49])
50Q = build_portfolio_hamiltonian(returns, cov, risk_aversion=2.0, budget=2)
51selection, ground_energy = simulated_anneal(Q)
52print("Manter ativos:", np.where(selection == 1)[0], "| energia:", round(ground_energy, 3))

Uma nota honesta sobre escala. Com cinco ativos você não precisa de recozimento - você poderia testar todas as 32 combinações por força bruta. O recozimento ganha seu valor em centenas de ativos com restrições difíceis, onde o espaço de busca explode e os solucionadores exatos engasgam. A razão para escrever desta forma em pequena escala é que a interface nunca muda: troque simulated_anneal por um backend real - o recozedor da D-Wave, um circuito QAOA em um simulador Qiskit, ou um solucionador de rede tensorial do tipo que a Multiverse comercializa - e nada mais no agente se move. O solucionador é um plugue.

7. Código: o loop do agente (percepção ao colapso à execução)

Agora conecte tudo. Este é o esqueleto de um agente autônomo - o mesmo loop de controle perceber/decidir/agir que um agente LLM usa, mas com um estado estilo quântico como seu modelo de mundo em vez de texto.

1class QuantumTradingAgent:
2    def __init__(self, universe, risk_aversion=2.0, budget=2, gross_leverage=1.0):
3        self.universe = universe
4        self.risk_aversion = risk_aversion
5        self.budget = budget
6        self.gross_leverage = gross_leverage
7        self.memory = []                     # buffer de feedback / RL
8
9    def perceive(self, market):
10        contributions = self.model_conviction(market)   # seus modelos alfa -> matriz complexa
11        return combine_signals(contributions)            # -> estado |psi> sobre cenários
12
13    def deliberate(self, market):
14        Q = build_portfolio_hamiltonian(
15            market["expected_returns"], market["cov"],
16            self.risk_aversion, self.budget)
17        selection, _ = simulated_anneal(Q)
18        return selection
19
20    def measure(self, psi, selection, market):
21        """
22        Colapsar em ordens. Duas coisas acontecem aqui:
23        1) uma porta de CONVICÇÃO GLOBAL do estado do cenário (direcional + encolhimento de volatilidade Heisenberg)
24        2) um PESO POR ATIVO para que os ativos escolhidos sejam dimensionados por seu próprio retorno esperado
25        """
26        scenario_probs = np.abs(psi) ** 2
27        directional = scenario_probs[0] + scenario_probs[3]      # P(sobe) + P(rompimento)
28        vol = market["volatility"]
29        gate = directional / (1.0 + self.risk_aversion * vol)   # encolhe em alta volatilidade / baixa convicção
30
31        idx = np.where(selection == 1)[0]
32        if len(idx) == 0:
33            return {}
34        edge = np.clip(market["expected_returns"][idx], 0, None) # apenas nomes com retorno esperado positivo
35        weights = edge / edge.sum() if edge.sum() > 0 else np.ones(len(idx)) / len(idx)
36
37        sizes = self.gross_leverage * gate * weights
38        return {int(a): round(float(s), 4) for a, s in zip(idx, sizes)}
39
40    def act(self, market):
41        psi = self.perceive(market)
42        selection = self.deliberate(market)
43        orders = self.measure(psi, selection, market)
44        # execute(orders)   <- rotear para exchange / corretora aqui
45        self.memory.append((market, orders))
46        return orders

Olhe atentamente para measure(), porque a versão ingênua anterior tinha uma falha real: aplicava um tamanho idêntico a cada ativo selecionado, ignorando quão bom cada um realmente era. Esta versão corrige isso com dois estágios. Uma porta global lê o estado do cenário - convicção direcional, que é P(sobe) + P(rompimento), dividida por um termo de volatilidade. Essa divisão é a regra estilo Heisenberg fazendo gerenciamento de risco: quanto mais o mercado resiste à precificação precisa, ou seja, maior volatilidade, menor o comprometimento total do agente. Em seguida, um peso por ativo distribui esse orçamento entre os nomes selecionados em proporção à sua própria vantagem esperada, e se recusa a comprar qualquer coisa com retorno esperado negativo. A convicção define quanto você aposta; a vantagem por ativo define onde vai.

8. A verificação da realidade de Wall Street

Onde isso realmente ganha dinheiro e onde é uma bela demonstração? Ser específico aqui é o que torna o resto crível.

Vantagem genuína hoje, em hardware clássico:

Otimização de portfólio em escala. Com centenas de ativos e restrições difíceis, recozedores e métodos de rede tensorial lidam com a combinatória e as restrições de forma mais elegante do que solucionadores ingênuos de média-variância, e muitas vezes mais rápido. Esta é a aplicação mais madura e menos propensa a hype.

Estimativa de risco via estimativa de amplitude quântica. Em teoria, isso oferece uma aceleração quadrática sobre o Monte Carlo clássico para VaR e CVaR. Continua sendo uma das direções de pesquisa mais ativas em grandes bancos, porque as execuções de risco são caras e rodam constantemente. Nota da ressalva: a aceleração principal é um resultado assintótico teórico, e o hardware de hoje ainda não a realiza em escala de produção.

Combinação de sinais via interferência. Modelar a convicção com uma fase para que negociações lotadas e supercorrelacionadas se cancelem é uma reformulação genuinamente útil, e funciona na sua GPU atual hoje. É a ideia mais imediatamente prática neste artigo - desde que você resolva o problema da fase da Seção 5 honestamente.

Ainda majoritariamente pesquisa:

Precificação de derivativos ponta a ponta em hardware quântico real. Promissor em princípio, mas ruído e contagens de qubits limitam hoje.

Previsão de preço "ML quântico". Fortemente superestimado. O custo de carregar dados de mercado clássicos em um estado quântico geralmente consome qualquer aceleração que você esperava ganhar. Seja muito cético com quem vende isso.

O resultado final honesto: o agente inspirado em quântica é construível e backtestável agora mesmo, porque cada módulo roda em hardware clássico. Você captura as ideias estruturais - uma superposição de hipóteses, interferência destrutiva contra lotação, otimização baseada em Hamiltoniano - sem esperar por computadores quânticos tolerantes a falhas. Quando o hardware amadurecer, você troca o módulo 4 e mantém o resto.

9. O que realmente vai matar isso em produção

Toda estratégia parece brilhante até encontrar o mercado. Antes de arriscar um dólar, internalize as quatro coisas que silenciosamente destroem agentes inspirados em quântica especificamente.

Custos de transação e slippage. A camada de interferência reembaralha a convicção toda vez que novos dados chegam, o que tenta o agente a agitar seu livro. Taxas e slippage não se importam com o quão elegante é seu vetor de estado. Adicione uma penalidade de rotatividade diretamente no Hamiltoniano e execute novamente - muitas "vantagens" evaporam no momento em que custos realistas são cobrados.

Sobreajuste das fases. A fase te dá um conjunto extra inteiro de parâmetros livres, e parâmetros livres são como os backtests mentem. É trivialmente fácil ajustar as fases até o ano passado imprimir dinheiro e o próximo ano sangrar. Fixe as regras de fase a partir da teoria (Seção 5) antes de olhar para os retornos, e nunca deixe o backtest escolhê-las por você.

Data snooping através do loop. Como este é um loop de feedback fechado, o vazamento se acumula. Se seu modelo de convicção, sua estimativa de covariância ou seus rótulos de regime espiarem mesmo que ligeiramente o futuro, o agente inteiro herda a mentira. Teste walk-forward o loop inteiro, não apenas o sinal isoladamente.

Fragilidade de regime da covariância. O QUBO depende de uma matriz de covariância, e as covariâncias explodem exatamente quando você precisa delas - em um crash, as correlações convergem para um. Teste de estresse a seleção de estado fundamental sob uma covariância chocada, não apenas a de mercado calmo, ou o otimizador felizmente lhe entregará um portfólio que é diversificado apenas no papel.

10. Sua lista de verificação de construção

Se você quer realmente implementar isso, aqui está a ordem das operações.

Comece com o solucionador inspirado em quântica - numpy puro mais recozimento simulado. Sem hardware, sem contas, sem dependências.

Substitua as amplitudes ajustadas à mão por um modelo de convicção aprendido alimentando combine_signals, e derive as fases da teoria em vez de ajustá-las.

Backteste o loop inteiro, com custos, não apenas o sinal. Cobre taxas e slippage realistas, adicione uma penalidade de rotatividade e execute walk-forward. A lógica de interferência e dimensionamento é onde tanto a vantagem quanto o autoengano se escondem.

Somente depois que a abstração tiver se pago em simulação, você deve buscar um backend real - simulador Qiskit ou PennyLane primeiro, depois D-Wave, depois hardware. Trocar o módulo 4 é uma mudança de uma linha por design.

O mercado sempre foi uma onda de probabilidade. Quase todo mundo ainda negocia como um número único - e a lacuna entre essas duas visões é toda a oportunidade.

Se isso remodelou como você pensa sobre mercados, reposte o topo e siga. O repositório completo do agente open-source sai na próxima. ⚛️

Aviso Legal. Não é conselho financeiro, nem uma promessa de retornos. Inspirado em quântica não significa garantido quântico - a maior parte do que faz isso funcionar é modelagem clássica disciplinada vestindo um casaco quântico. Backteste tudo com custos reais; o mercado colapsa sua função de onda quer você esteja pronto ou não.