Uma abordagem integrada dos fundamentos matemáticos e lógicos da inteligência artificial simbólica, explorando arquiteturas de agentes autônomos, comunicação entre agentes e coordenação em sistemas distribuídos, com aplicações práticas alinhadas à BNCC.
COLEÇÃO ESCOLA DE LÓGICA MATEMÁTICA • VOLUME 89
Autor: João Carlos Moreira
Doutor em Matemática
Universidade Federal de Uberlândia
2025
Capítulo 1: Fundamentos da Inteligência Artificial Simbólica 4
Capítulo 2: Agentes Racionais e Arquiteturas Cognitivas 8
Capítulo 3: Representação do Conhecimento 12
Capítulo 4: Raciocínio Automatizado e Inferência 16
Capítulo 5: Comunicação e Linguagens de Agentes 22
Capítulo 6: Coordenação e Cooperação Multi-Agente 28
Capítulo 7: Negociação e Teoria dos Jogos 34
Capítulo 8: Planejamento Multi-Agente 40
Capítulo 9: Aplicações Práticas e Estudos de Caso 46
Capítulo 10: Tendências Futuras e Desafios 52
Referências Bibliográficas 54
A inteligência artificial simbólica emerge como paradigma computacional que busca emular processos cognitivos humanos através da manipulação formal de símbolos e regras lógicas. Diferentemente das abordagens subsimbólicas baseadas em redes neurais, este ramo privilegia a representação explícita do conhecimento mediante estruturas lógicas transparentes e interpretáveis, permitindo rastreamento preciso dos processos de raciocínio artificial.
Desde os trabalhos pioneiros de John McCarthy e Marvin Minsky na década de 1950, essa área desenvolveu-se como campo interdisciplinar que integra lógica matemática, ciência da computação teórica e filosofia da mente. Os sistemas especialistas da década de 1980 demonstraram a viabilidade prática dessa abordagem em domínios específicos como diagnóstico médico e análise financeira, consolidando a relevância da representação simbólica mesmo diante do posterior avanço das técnicas conexionistas.
A Base Nacional Comum Curricular enfatiza o desenvolvimento de competências relacionadas ao pensamento computacional e raciocínio lógico-matemático. O estudo de sistemas multi-agentes baseados em IA simbólica conecta-se diretamente com essas competências, proporcionando aos estudantes ferramentas conceituais para compreender e criar sistemas inteligentes distribuídos que resolvem problemas complexos através da coordenação autônoma entre entidades computacionais especializadas.
A representação simbólica fundamenta-se na hipótese de que processos cognitivos podem ser modelados através da manipulação de símbolos segundo regras sintáticas bem definidas. Um símbolo não passa de um padrão físico que pode ser combinado com outros símbolos para formar estruturas complexas, carregando significado mediante convenções interpretativas estabelecidas no sistema. Esta perspectiva contrasta com representações distribuídas características do aprendizado profundo, onde informação espalha-se difusamente por milhares de parâmetros numéricos.
Sistemas lógicos formais como cálculo de predicados de primeira ordem oferecem linguagens precisas para expressar conhecimento sobre o mundo. Uma sentença como ∀x(Humano(x) → Mortal(x)) captura uma regra universal mediante quantificadores e predicados que podem ser processados algoritmicamente. A semântica formal associa essas expressões sintáticas a interpretações em modelos matemáticos, estabelecendo condições de verdade rigorosas que permitem verificação automática de propriedades.
Mecanismos de inferência operam sobre essas representações, derivando novos conhecimentos a partir de fatos e regras existentes. O modus ponens, por exemplo, permite concluir que Sócrates é mortal dado que Sócrates é humano e todos os humanos são mortais. Tais processos inferenciais implementam-se computacionalmente através de algoritmos como resolução e encadeamento progressivo, transformando raciocínio lógico em processamento mecânico.
Considere um sistema especialista simplificado para diagnóstico respiratório:
Base de Conhecimento:
• R₁: Tosse(x) ∧ Febre(x) ∧ DorGarganta(x) → Gripe(x)
• R₂: Gripe(x) → Repouso(x) ∧ Hidratação(x)
• R₃: Tosse(x) ∧ FaltaAr(x) → Asma(x)
Fatos Observados (Paciente João):
• Tosse(João) = verdadeiro
• Febre(João) = verdadeiro
• DorGarganta(João) = verdadeiro
Processo de Inferência:
• Aplicando R₁: Como todos os antecedentes são verdadeiros, inferimos Gripe(João)
• Aplicando R₂: Como Gripe(João) é verdadeiro, inferimos Repouso(João) e Hidratação(João)
Conclusão: O sistema recomenda repouso e hidratação adequada baseado em raciocínio lógico explícito, permitindo auditoria completa do processo decisório.
Apesar das vantagens em interpretabilidade, a IA simbólica enfrenta desafios como a aquisição automatizada de conhecimento, tratamento de incerteza e escalabilidade para domínios complexos. A integração com técnicas de aprendizado de máquina representa fronteira ativa de pesquisa.
Um agente inteligente pode ser caracterizado formalmente como uma função que mapeia sequências de percepções em ações. Denotando o conjunto de percepções possíveis por P e o conjunto de ações por A, um agente define-se matematicamente como f: P* → A, onde P* representa o conjunto de todas as sequências finitas de percepções. Esta abstração captura a essência de um sistema autônomo que decide suas ações baseado em seu histórico de interações com o ambiente.
A racionalidade de um agente avalia-se mediante uma medida de desempenho que quantifica o sucesso em alcançar objetivos. Para um agente operando num ambiente E, com histórico de percepções h ∈ P* e ação a = f(h), a utilidade esperada U(a|h,E) determina a qualidade da decisão. Um agente racional maximiza U condicionada às informações disponíveis, formalizando matematicamente a noção intuitiva de comportamento inteligente.
Arquiteturas de agentes especificam a estrutura interna que implementa essa função de decisão. Uma arquitetura reativa simples mapeia diretamente percepções em ações mediante regras do tipo condição-ação. Arquiteturas deliberativas mantêm modelos simbólicos do mundo, planejando sequências de ações que otimizam objetivos de longo prazo. Arquiteturas híbridas combinam camadas reativas para respostas rápidas com módulos deliberativos para decisões estratégicas complexas.
Ambiente: Casa com n salas, cada uma podendo estar limpa ou suja.
Percepções: P = {(loc₁, limpo), (loc₁, sujo), (loc₂, limpo), ..., (locₙ, sujo)}
Ações: A = {Aspirar, MoverDireita, MoverEsquerda, MoverFrente, MoverTrás}
Função do Agente Simples (Reativo):
• f((locᵢ, sujo)) = Aspirar
• f((locᵢ, limpo)) = MoverParaSalaAdjacente
Medida de Desempenho:
• +10 pontos por cada sala limpa em um intervalo de tempo T
• -1 ponto por cada movimento
• -5 pontos se bateria descarregar antes de retornar à base
Agente com Modelo (Deliberativo):
• Mantém mapa M: {loc₁, loc₂, ..., locₙ} → {limpo, sujo, desconhecido}
• Planeja rota ótima minimizando movimentos totais
• Atualiza M baseado em percepções: M(locᵢ) ← estado_percebido
Análise de Racionalidade:
• Agente reativo: Comportamento local ótimo, mas pode revisitar salas desnecessariamente
• Agente com modelo: Planeja globalmente, mas requer memória e processamento adicionais
Ao projetar agentes, equilibre complexidade computacional com desempenho. Ambientes simples e previsíveis favorecem arquiteturas reativas eficientes. Ambientes complexos e parcialmente observáveis demandam representações simbólicas ricas e planejamento sofisticado.
Ambientes onde múltiplos agentes coexistem apresentam propriedades específicas que influenciam profundamente o design de sistemas inteligentes. A observabilidade determina quanto do estado ambiental cada agente pode perceber diretamente. Em ambientes totalmente observáveis, agentes acessam informação completa instantaneamente. Ambientes parcialmente observáveis exigem que agentes mantenham crenças probabilísticas sobre estados ocultos, complicando significativamente o raciocínio requerido.
O determinismo caracteriza se ações produzem efeitos previsíveis. Ambientes determinísticos permitem planejamento preciso baseado em modelos de transição de estados exatos. Ambientes estocásticos incorporam incerteza, demandando técnicas como processos de decisão de Markov parcialmente observáveis que otimizam ações considerando distribuições probabilísticas sobre resultados possíveis.
A natureza episódica versus sequencial afeta como agentes avaliam consequências de longo prazo. Em tarefas episódicas, cada interação é independente, permitindo otimização míope. Tarefas sequenciais requerem que agentes antecipem como decisões presentes afetarão oportunidades futuras, introduzindo complexidade temporal ao problema de decisão racional.
1. Leilão Online (Competitivo, Sequencial, Estocástico):
• Agentes competem por recursos limitados
• Decisões de lance afetam rodadas futuras
• Incerteza sobre estratégias de oponentes
• Observabilidade parcial: agentes não conhecem valorações alheias
2. Robôs de Resgate (Cooperativo, Contínuo, Dinâmico):
• Agentes coordenam para maximizar vítimas resgatadas
• Ambiente muda independentemente: escombros deslocam, fogo espalha
• Comunicação limitada em zonas de desastre
• Decisões em tempo real com informação incompleta
3. Mercado de Ações (Misto, Estocástico, Contínuo):
• Agentes hedge funds, market makers, traders individuais
• Alguns cooperam (pools de investimento), outros competem
• Preços flutuam continuamente baseado em oferta-demanda agregada
• Observabilidade: dados públicos versus informações privilegiadas
4. Tráfego Urbano (Descentralizado, Contínuo, Misto):
• Cada veículo autônomo é um agente
• Cooperação local (respeitar faixas) e competição (disputar vaga)
• Ambiente parcialmente observável (sensores limitados)
• Dinâmico: novos veículos entram, semáforos mudam, acidentes ocorrem
A caracterização precisa do ambiente orienta escolhas arquiteturais. Ambientes competitivos demandam teoria dos jogos. Ambientes cooperativos beneficiam-se de protocolos de coordenação. A estocacidade exige raciocínio probabilístico, enquanto dinamismo necessita mecanismos de monitoramento e replanejamento contínuos.
Herbert Simon revolucionou a compreensão de racionalidade ao introduzir o conceito de racionalidade limitada, reconhecendo que agentes reais operam sob restrições computacionais, temporais e informacionais que impedem otimização perfeita. Em vez de maximizar utilidade absoluta, agentes satisfazem critérios mínimos aceitáveis, equilibrando qualidade de decisão com esforço computacional requerido para alcançá-la.
Esta perspectiva realista contrasta com modelos econômicos clássicos de racionalidade ilimitada. Um agente com recursos computacionais finitos não pode explorar exaustivamente árvores de decisão exponencialmente grandes. Heurísticas tornam-se essenciais, oferecendo aproximações tratáveis que sacrificam garantias de otimalidade em troca de viabilidade prática. A teoria de contratos anytime formaliza esse compromisso, permitindo que agentes retornem soluções progressivamente melhores conforme tempo disponível aumenta.
Mecanismos metacognitivos permitem que agentes monitorem e regulem seus próprios processos de raciocínio. Um agente pode detectar quando está investindo recursos excessivos numa subtarefa relativamente pouco importante, realocando atenção computacional dinamicamente. Tais capacidades aproximam sistemas artificiais da flexibilidade cognitiva humana, que constantemente ajusta profundidade de processamento às demandas situacionais.
Contexto: Motor de xadrez deve decidir lance em tempo limitado.
Espaço de Busca:
• Fator de ramificação médio: b ≈ 35 lances legais por posição
• Profundidade típica de partida: d ≈ 80 movimentos
• Complexidade: b^d ≈ 10^154 posições (impossível explorar completamente)
Estratégias de Racionalidade Limitada:
• Busca em Profundidade Limitada: Explorar apenas d_max = 12 níveis à frente
• Poda Alfa-Beta: Eliminar ramos provadamente subótimos, reduzindo b_efetivo
• Função de Avaliação Heurística: h(posição) estima valor sem busca completa
- Material: Σ(valor_peça) para cada lado
- Posição: controle_centro + segurança_rei + mobilidade_peças
- Estrutura: penalizações por peões duplicados, torres desconectadas
Algoritmo Anytime:
• Iteração 1 (100ms): Busca d=4, retorna lance satisfatório
• Iteração 2 (500ms): Busca d=8, possivelmente melhora lance anterior
• Iteração 3 (2000ms): Busca d=12, refinamento adicional
• Interrupção: Se tempo expirar, retorna melhor lance até momento
Metacognição:
• Se h(posição) >> h_oponente: Aloca menos tempo (vantagem confortável)
• Se posição tática complexa: Aumenta d_max localmente nessa região
• Se abertura conhecida: Recupera lance de biblioteca, economizando recursos
A arquitetura Belief-Desire-Intention oferece modelo computacional inspirado na filosofia da ação humana. Crenças representam conhecimento do agente sobre o estado do mundo, codificadas mediante fórmulas lógicas ou estruturas de dados simbólicas. Desejos especificam estados objetivos que o agente valoriza alcançar, embora possam ser conflitantes ou mutuamente exclusivos. Intenções constituem compromissos com planos específicos que o agente decidiu executar para satisfazer seus desejos prioritários.
O ciclo de raciocínio BDI processa continuamente percepções atualizando crenças, avalia opções gerando novos desejos, filtra desejos em intenções compatíveis mediante deliberação, e seleciona ações de planos intencionados para execução. Esta separação modular entre diferentes aspectos da cognição permite raciocínio claro sobre estados epistêmicos, motivacionais e comprometidos do agente, facilitando análise formal de propriedades como coerência de crenças e persistência de intenções.
Lógicas modais BDI formalizam rigorosamente esses conceitos mediante operadores Bel, Des e Int que qualificam fórmulas proposicionais. Por exemplo, Bel(φ) expressa que o agente acredita em φ, enquanto Int(ψ) indica intenção de tornar ψ verdadeira. Axiomas governam interações entre modalidades, como consistência de crenças (Bel(φ) → ¬Bel(¬φ)) e racionalidade prática (Int(φ) → Des(φ)), assegurando comportamento racionalmente coerente.
Crenças (Base de Conhecimento):
• Bel(Reunião(10:00, Sala_A))
• Bel(TempoViagem(Atual, Sala_A) = 15min)
• Bel(HoraAtual = 09:40)
• Bel(Email_Urgente(cliente_X, pendente))
• Bel(Bateria(smartphone) = 25%)
Desejos (Objetivos):
• Des(Chegar(Reunião, OnTime))
• Des(Responder(Email_Urgente))
• Des(Bateria(smartphone) > 50%)
• Des(Preparar(Apresentação, Reunião))
Processo de Filtragem (Geração de Intenções):
• Análise de conflitos: Responder email completo requer ~20min
• 09:40 + 20min + 15min = 10:15 → Chegaria atrasado à reunião
• Priorização: Reunião tem stakeholders seniores (alta prioridade)
• Decisão: Adiar resposta completa ao email
Intenções (Planos Comprometidos):
• Int(Enviar(Email_Urgente, resposta_breve)): "Retorno em 2h" (~2min)
• Int(Sair(Atual, 09:42)) para chegar 09:57 à Sala_A
• Int(Recarregar(smartphone)) durante trajeto (carregador portátil)
• Int(Revisar(Apresentação)) nos 3min restantes antes da reunião
Execução e Monitoramento:
• 09:41: Envia email breve (confirmando recebimento)
• 09:42: Inicia deslocamento
• Durante trajeto: Percepção nova: Bel(Trânsito_Congestionado)
• Atualização: TempoViagem = 20min → Chegada prevista 10:02
• Replanejamento: Int(Notificar(organizador, atraso_estimado))
Bibliotecas como Jason (Java) e AgentSpeak implementam raciocínio BDI permitindo especificação declarativa de crenças, objetivos e planos. Utilize revisão de crenças para manter consistência quando novas percepções contradizem conhecimento anterior, e implemente mecanismos de abandono de intenções quando premissas falham.
Rodney Brooks desafiou paradigmas deliberativos tradicionais propondo arquiteturas puramente reativas que eliminam representações simbólicas explícitas do mundo. A arquitetura de subsumption organiza comportamentos em camadas hierárquicas, onde níveis superiores podem suprimir ou inibir níveis inferiores. Cada camada implementa um comportamento completo sensório-motor, desde reflexos primitivos até estratégias complexas, sem planejamento centralizado.
Esta abordagem fundamenta-se na filosofia de que inteligência emerge de interações situadas com o ambiente real, não de manipulação de modelos internos abstratos. Um robô móvel pode ter camadas como: evitar obstáculos (nível 0), explorar ambiente (nível 1), retornar à base quando bateria baixa (nível 2). Cada camada opera autonomamente em paralelo, com prioridades resolvidas mediante supressão hierárquica quando conflitos surgem.
Vantagens incluem robustez a falhas parciais, já que camadas superiores danificadas não impedem funcionamento básico, e eficiência computacional pela ausência de planejamento custoso. Limitações manifestam-se em tarefas que demandam coordenação temporal complexa ou raciocínio sobre consequências de longo prazo, que naturalmente favorecem representações simbólicas e deliberação explícita.
Camada 0 - Evitar Obstáculos (Prioridade Máxima):
• Sensores: Ultrassônicos detectando distância d_frontal
• Regra: SE d_frontal < d_segurança ENTÃO girar_direita(90°) E parar_motor_frontal
• Execução: Imediata, interrompe qualquer outro comportamento
Camada 1 - Seguir Paredes:
• Sensores: Lateral direito mede d_direita da parede
• Regra: SE d_direita > d_ideal ENTÃO virar_direita(5°)
• Regra: SE d_direita < d_ideal ENTÃO virar_esquerda(5°)
• Suprimida por: Camada 0 quando obstáculo detectado frontalmente
Camada 2 - Explorar Território Desconhecido:
• Memória: Mapa de ocupação simples (visitado/não-visitado)
• Regra: SE corredor_bifurca ENTÃO escolher_ramo_não_visitado
• Regra: SE área_visitada > 80% ENTÃO aumentar_velocidade_exploração
• Suprimida por: Camadas 0-1 quando necessário evitar ou seguir obstáculos
Camada 3 - Retornar Base (Bateria Baixa):
• Sensor: Monitor de bateria B_atual
• Regra: SE B_atual < B_crítico ENTÃO navegar_para(coordenadas_base)
• Utiliza: Odometria acumulada para estimar posição relativa
• Prioridade: Suprime exploração (Camada 2) mas obedece segurança (Camadas 0-1)
Cenário de Execução:
• t=0s: Robô explorando corredor (Camada 2 ativa)
• t=5s: Parede detectada d_frontal=20cm (Camada 0 suprime, robô gira)
• t=8s: Obstáculo ultrapassado, retoma seguir parede (Camada 1)
• t=45s: Bateria atinge 15% (Camada 3 ativa retorno)
• t=46s: Durante retorno, novo obstáculo (Camada 0 prevalece temporariamente)
• t=120s: Robô alcança base, desativa Camada 3
Enquanto BDI mantém modelos simbólicos complexos e planeja deliberadamente, subsumption reage instantaneamente a estímulos mediante regras simples. BDI excele em tarefas cognitivas complexas. Subsumption brilha em ambientes dinâmicos onde velocidade de resposta é crítica e modelagem completa é impraticável.
Reconhecendo complementaridade entre deliberação e reatividade, arquiteturas híbridas combinam camadas simbólicas de alto nível com módulos reativos de baixo nível. A arquitetura InteRRaP exemplifica essa integração mediante três camadas funcionais: comportamento reativo para respostas imediatas a estímulos, planejamento local para coordenação de curto prazo, e planejamento cooperativo para interações estratégicas com outros agentes.
O modelo de três camadas tornou-se paradigma dominante em robótica autônoma. Uma camada deliberativa executa planejamento baseado em modelos, gerando planos abstratos de alto nível. Uma camada executiva traduz esses planos em sequências de comandos concretos, gerenciando recursos e monitorando progresso. Uma camada reativa implementa controle sensório-motor direto, garantindo segurança básica independentemente de camadas superiores funcionarem corretamente.
Desafios de integração incluem arbitragem quando camadas sugerem ações conflitantes, comunicação eficiente entre níveis de abstração diferentes, e manutenção de coerência quando a camada deliberativa atualiza planos enquanto a camada executiva está processando comandos antigos. Mecanismos como sincronização periódica, buffers de comandos e verificação de precondições endereçam essas questões arquiteturais.
Camada Deliberativa (Planejamento Estratégico):
• Entrada: Destino final, mapa da cidade, previsão de tráfego
• Processamento: Algoritmo A* em grafo de ruas ponderado por tempo estimado
• Saída: Rota ótima R = [rua₁, rua₂, ..., rua_n]
• Atualização: A cada 5 minutos ou se tráfego mudar significativamente
• Representação: Símbolos de alto nível (nomes de ruas, coordenadas GPS)
Camada Executiva (Planejamento Tático):
• Entrada: Segmento atual da rota (ex: "vire à direita na próxima interseção")
• Processamento: Traduz em waypoints concretos no sistema de coordenadas local
• Gerencia: Troca de faixa, ultrapassagens, obediência a semáforos
• Monitora: Obstáculos dinâmicos (pedestres, ciclistas, outros veículos)
• Replaneja: Manobras de curto prazo se caminho bloqueado temporariamente
• Horizonte temporal: próximos 30-60 segundos de viagem
Camada Reativa (Controle Sensório-Motor):
• Entrada: Sensores LiDAR, câmeras, radar (100Hz ou mais)
• Processamento: Regras de emergência implementadas em hardware/firmware
• Comportamentos primitivos:
- SE distância_frontal < 3m ENTÃO freio_emergência
- SE pedestre_cruzando ENTÃO parar_imediatamente
- SE deriva_faixa > limite ENTÃO correção_direção
• Latência: < 10ms para garantir segurança
• Prioridade: Suprime comandos de camadas superiores quando necessário
Cenário Integrado:
• Deliberativa: Planeja rota evitando centro congestionado
• Executiva: Executa troca de faixa preparando conversão à direita
• Reativa: Deteta criança correndo para rua, aciona freios (suprime tudo)
• Após parada: Executiva reavalia segurança, autoriza retomar movimento
• Deliberativa: Monitora atraso, considera rota alternativa se crítico
Atribua responsabilidades claramente entre camadas evitando duplicação. Camadas reativas tratam segurança crítica com latência mínima. Camadas executivas gerenciam planos táticos de médio prazo. Camadas deliberativas otimizam estrategicamente sem pressa. Garanta que falha em camadas superiores não comprometa operação segura básica.
A lógica de primeira ordem estende a lógica proposicional incorporando quantificadores e predicados que permitem expressar relações entre objetos individuais. Enquanto proposições atômicas tratam fatos completos como unidades indivisíveis, predicados decompõem fatos em objetos e propriedades ou relações entre eles. Por exemplo, Médico(João) aplica o predicado unário Médico ao objeto João, e Trata(João, Maria) expressa relação binária entre dois indivíduos.
Quantificadores universais (∀) e existenciais (∃) permitem afirmações sobre coleções de objetos. A sentença ∀x(Humano(x) → Mortal(x)) expressa que todos os humanos são mortais sem enumerar cada indivíduo explicitamente. Variáveis ligadas por quantificadores generalizam sobre domínios potencialmente infinitos, enquanto constantes denotam indivíduos específicos como sócrates ou brasil_2025.
Funções enriquecem expressividade mapeando objetos em objetos. A função mãe(x) retorna a mãe de x, permitindo expressar relações familiares como Avó(x,z) ↔ Mãe(x, mãe(z)). Termos compostos como mãe(mãe(João)) denotam objetos construídos aplicando funções recursivamente, capturando estruturas conceituais arbitrariamente complexas mediante sintaxe composta finita.
Predicados Básicos:
• Pai(x, y): x é pai de y
• Mãe(x, y): x é mãe de y
• Homem(x): x é do sexo masculino
• Mulher(x): x é do sexo feminino
Funções:
• pai(x): retorna o pai de x
• mãe(x): retorna a mãe de x
Fatos (Instâncias):
• Pai(carlos, ana)
• Mãe(beatriz, ana)
• Pai(carlos, bruno)
• Homem(carlos), Homem(bruno), Mulher(beatriz), Mulher(ana)
Regras (Conhecimento Derivado):
• Irmão(x, y) ↔ Homem(x) ∧ (pai(x) = pai(y)) ∧ (mãe(x) = mãe(y)) ∧ (x ≠ y)
• Avô(x, z) ↔ Homem(x) ∧ (Pai(x, pai(z)) ∨ Pai(x, mãe(z)))
• Tio(x, z) ↔ Homem(x) ∧ Irmão(x, pai(z)) ∨ Irmão(x, mãe(z))
• Ancestral(x, y) ↔ Pai(x, y) ∨ Mãe(x, y) ∨ ∃z(Ancestral(x, z) ∧ Ancestral(z, y))
Consultas e Inferências:
• Pergunta: Irmão(bruno, ana)?
- Substituição: x=bruno, y=ana
- Verificação: Homem(bruno)? Sim. pai(bruno)=carlos, pai(ana)=carlos? Sim
- mãe(bruno)=?, mãe(ana)=beatriz. Falta informação sobre mãe de bruno
- Conclusão: Não pode determinar (mundo aberto)
• Pergunta: ∃x Avô(x, ana)?
- Procura x tal que Pai(x, carlos) ou Pai(x, beatriz)
- Se base contém Pai(alberto, carlos): Sim, alberto é avô de ana
Lógica de primeira ordem assume mundo aberto: ausência de informação não implica falsidade. Bancos de dados relacionais assumem mundo fechado: o que não está na base é falso. Esta distinção afeta profundamente o raciocínio em sistemas multi-agentes onde conhecimento é naturalmente incompleto.
Ontologias formalizam conceitualizações compartilhadas de domínios específicos, definindo vocabulários comuns que permitem comunicação semântica entre agentes heterogêneos. Uma ontologia especifica classes de objetos, propriedades que esses objetos podem ter, e relações que podem manter entre si. Hierarquias taxonômicas organizam conceitos mediante relações de subsunção, onde subclasses herdam propriedades de superclasses segundo princípios de especialização.
A Web Ontology Language (OWL) padroniza representação de ontologias mediante lógica descritiva, um fragmento decidível de lógica de primeira ordem. Axiomas OWL expressam restrições como disjunção de classes (Planta ⊔ Animal cobre organismos, Planta ⊓ Animal = ∅ garante exclusão mútua), cardinalidade (Pessoa tem exatamente 1 pai biológico), e equivalências (Humano ≡ Pessoa garante sinonímia).
Redes semânticas visualizam conhecimento mediante grafos dirigidos onde nós representam conceitos e arestas rotuladas denotam relações. A tripla RDF (sujeito, predicado, objeto) constitui unidade básica: (João, trabalha_para, Universidade_X). Frameworks como RDF Schema e SPARQL permitem consultar e raciocinar sobre grandes grafos de conhecimento distribuídos, viabilizando a Web Semântica onde máquinas interpretam significado de conteúdo online.
Hierarquia de Classes (Taxonomia):
• EntidadeMédica
├─ Pessoa
│ ├─ Paciente
│ │ ├─ PacienteInternado
│ │ └─ PacienteAmbulatorial
│ └─ ProfissionalSaúde
│ ├─ Médico
│ │ ├─ Cardiologista
│ │ └─ Neurologista
│ └─ Enfermeiro
├─ Doença
│ ├─ DoençaInfecciosa
│ │ ├─ Gripe
│ │ └─ COVID-19
│ └─ DoençaCrônica
│ ├─ Diabetes
│ └─ Hipertensão
└─ Tratamento
├─ Medicamento
└─ Procedimento
Propriedades de Objeto (Relações):
• diagnosticadoCom: Paciente → Doença
• tratadoPor: Paciente → ProfissionalSaúde
• prescreve: Médico → Medicamento
• especialistaEm: Médico → EspecialidadeMédica
Propriedades de Dados (Atributos):
• temIdade: Pessoa → inteiro
• temPressãoArterial: Paciente → string (ex: "120/80")
• temDataAdmissão: PacienteInternado → data
Axiomas e Restrições:
• Cardiologista ⊑ Médico ⊓ ∃especialistaEm.Cardiologia
• PacienteInternado ⊑ Paciente ⊓ ∃temDataAdmissão.Data
• Médico ⊓ Paciente ⊑ ⊥ (médicos não podem ser pacientes simultaneamente no modelo)
• ∀x(Paciente(x) → ∃y(tratadoPor(x,y) ∧ ProfissionalSaúde(y)))
Instâncias (Indivíduos):
• drSilva: Cardiologista
• pacienteJoão: PacienteInternado
• diagnosticadoCom(pacienteJoão, Hipertensão)
• tratadoPor(pacienteJoão, drSilva)
• temIdade(pacienteJoão, 67)
Consulta SPARQL:
SELECT ?medico WHERE {
?medico rdf:type :Cardiologista .
?paciente :diagnosticadoCom :Hipertensão .
?paciente :tratadoPor ?medico .
}
Retorna: drSilva (cardologista tratando paciente hipertenso)
Frames, propostos por Marvin Minsky, organizam conhecimento em estruturas de dados que agregam informações relacionadas a conceitos prototípicos. Cada frame possui slots que armazenam atributos e valores, podendo incluir valores padrão, restrições, e procedimentos que executam quando valores são acessados ou modificados. Herança permite que frames especializados herdem slots de frames mais gerais, promovendo reuso e consistência em hierarquias de conhecimento.
Scripts codificam conhecimento procedural sobre sequências estereotipadas de eventos. Um script de restaurante especifica roles (cliente, garçom, chef), props (mesa, cardápio, comida), e cenas organizadas temporalmente (entrar, sentar, pedir, comer, pagar, sair). Quando agentes reconhecem situações familiares, ativam scripts apropriados que fornecem expectativas sobre como eventos devem desenrolar-se, facilitando planejamento e interpretação de ações alheias.
Estas representações estruturadas complementam lógica formal oferecendo formas de organização mais próximas de como humanos categorizam experiências. Enquanto lógica excele em raciocínio rigoroso sobre fatos atomizados, frames e scripts capturam padrões holísticos e conhecimento contextual que informam raciocínio de senso comum essencial para agentes operarem em ambientes humanos realísticos.
Frame: Produto_Eletrônico
• Slots:
- nome: [string, obrigatório]
- preço: [float > 0, obrigatório]
- fabricante: [string, padrão="Desconhecido"]
- garantia_meses: [int ≥ 0, padrão=12]
- avaliação_média: [float ∈ [0,5], calculado via procedimento]
- estoque: [int ≥ 0, obrigatório]
• Procedimentos:
- ao_vender(): estoque ← estoque - 1, atualizar_estatísticas()
- aplicar_desconto(porcentagem): preço ← preço × (1 - porcentagem/100)
Frame Especializado: Smartphone (herda de Produto_Eletrônico)
• Slots adicionais:
- tela_polegadas: [float > 0]
- memória_RAM_GB: [int, valores={4, 6, 8, 12, 16}]
- sistema_operacional: [string ∈ {Android, iOS}]
- câmera_MP: [int > 0]
• Procedimentos especializados:
- compatível_com(acessório): verificar compatibilidade de conectores
Script: Processo_de_Compra
• Roles: Cliente, SistemaAgente, ProcessadorPagamento, GestorEstoque
• Props: Carrinho, Produto, CartãoCrédito, Pedido
• Cenas:
1. Navegação:
- Cliente pesquisa produtos
- SistemaAgente recomenda baseado em histórico
- Cliente visualiza detalhes de Produto
2. Seleção:
- Cliente adiciona Produto ao Carrinho
- SistemaAgente verifica estoque via GestorEstoque
- Se estoque=0: sugerir produtos similares
3. Checkout:
- Cliente fornece dados de entrega
- SistemaAgente calcula frete e total
- Cliente insere CartãoCrédito
4. Pagamento:
- ProcessadorPagamento valida CartãoCrédito
- Se aprovado: GestorEstoque atualiza estoque
- SistemaAgente gera Pedido com número de rastreamento
5. Confirmação:
- SistemaAgente envia email confirmação
- Cliente recebe estimativa de entrega
Exemplo de Execução:
• Cliente busca "smartphone 128GB"
• Sistema ativa Frame Smartphone, filtra por memória
• Retorna lista ordenada por avaliação_média
• Cliente seleciona modelo X, adiciona ao carrinho
• Sistema ativa Script Processo_de_Compra
• Executa cenas 1-5 sequencialmente
• Se pagamento falhar na cena 4: retorna à cena 3
Prefira frames quando conhecimento é naturalmente hierárquico e orientado a objetos com muitos atributos inter-relacionados. Use lógica quando precisa raciocínio dedutivo rigoroso e verificação formal de propriedades. Sistemas reais frequentemente combinam ambas abordagens: frames para estruturação, lógica para inferência.
Sistemas de produção implementam raciocínio mediante regras do tipo se-então que transformam estados de conhecimento. O encadeamento progressivo (forward chaining) inicia com fatos conhecidos, aplicando regras cujas premissas são satisfeitas para derivar novos fatos, prosseguindo até alcançar um objetivo ou esgotar regras aplicáveis. Esta estratégia guiada por dados explora consequências de informação disponível, adequando-se a tarefas como monitoramento onde múltiplas conclusões emergem de fluxos contínuos de dados sensoriais.
O encadeamento regressivo (backward chaining) procede na direção oposta, partindo de objetivos a provar e buscando regras que poderiam estabelecê-los. Para cada sub-objetivo nas premissas dessas regras, repete-se o processo recursivamente até alcançar fatos primitivos na base de conhecimento ou falhar. Esta estratégia guiada por objetivos foca recursos computacionais em cadeias de raciocínio relevantes para questões específicas, evitando derivações irrelevantes que encadeamento progressivo exploraria indiscriminadamente.
A escolha entre estratégias depende de características do domínio. Espaços de busca amplos e ramificados favorecem encadeamento regressivo que poda alternativas irrelevantes. Bases com poucos fatos iniciais mas muitas regras beneficiam-se de encadeamento progressivo que materializa consequências sistematicamente. Sistemas híbridos podem combinar ambas direções, utilizando encadeamento bidirecional que encontra cadeias de raciocínio conectando fatos conhecidos a objetivos desejados.
Base de Regras:
• R₁: Usuário(gamer) ∧ Orçamento(alto) → PlacaVídeo(RTX_4080)
• R₂: Usuário(gamer) ∧ Orçamento(médio) → PlacaVídeo(RTX_4060)
• R₃: PlacaVídeo(RTX_4080) → Fonte(850W) ∧ RAM(32GB)
• R₄: PlacaVídeo(RTX_4060) → Fonte(650W) ∧ RAM(16GB)
• R₅: RAM(32GB) → Processador(i7) ∨ Processador(Ryzen_7)
• R₆: Fonte(X) ∧ X ≥ 750W → Gabinete(torre_completa)
Fatos Iniciais:
• Usuário(gamer)
• Orçamento(alto)
Encadeamento Progressivo (Forward):
• Iteração 1: R₁ aplicável (ambas premissas satisfeitas)
→ Deriva: PlacaVídeo(RTX_4080)
• Iteração 2: R₃ aplicável (premissa PlacaVídeo(RTX_4080) satisfeita)
→ Deriva: Fonte(850W), RAM(32GB)
• Iteração 3: R₅ aplicável (premissa RAM(32GB) satisfeita)
→ Deriva: Processador(i7) ∨ Processador(Ryzen_7) [disjunção]
• Iteração 4: R₆ aplicável (Fonte(850W) e 850 ≥ 750)
→ Deriva: Gabinete(torre_completa)
• Conclusão: Sistema derivou configuração completa explorando todas consequências
Encadeamento Regressivo (Backward):
• Objetivo: Provar Gabinete(torre_completa)
• Passo 1: Busca regras concluindo Gabinete(torre_completa)
→ Encontra R₆: necessita Fonte(X) ∧ X ≥ 750W
• Passo 2: Sub-objetivo Fonte(X) onde X ≥ 750W
→ Busca regras concluindo Fonte
→ Encontra R₃: necessita PlacaVídeo(RTX_4080)
• Passo 3: Sub-objetivo PlacaVídeo(RTX_4080)
→ Encontra R₁: necessita Usuário(gamer) ∧ Orçamento(alto)
• Passo 4: Ambos fatos estão na base inicial
→ Sucesso! Cadeia completa: Fatos → R₁ → R₃ → R₆ → Objetivo
Comparação de Eficiência:
• Forward: Explorou todas as 4 regras, derivou 6+ fatos
• Backward: Explorou apenas 3 regras na cadeia direta ao objetivo
• Backward é mais eficiente quando objetivo é específico
• Forward é melhor quando queremos todas as conclusões possíveis
O princípio de resolução constitui regra de inferência completa para lógica de primeira ordem quando fórmulas são convertidas para forma clausal. Uma cláusula representa disjunção de literais, e o método de resolução combina pares de cláusulas contendo literais complementares para derivar novas cláusulas. Robinson demonstrou em 1965 que repetidas aplicações de resolução eventualmente derivam a cláusula vazia se e somente se o conjunto original de cláusulas é insatisfazível, estabelecendo fundamento teórico para demonstração automática de teoremas.
A unificação encontra substituições que tornam expressões sintáticas idênticas. Dado os termos f(x, b) e f(a, y), o unificador mais geral σ = {x/a, y/b} substitui x por a e y por b, resultando em f(a, b) em ambos os casos. Algoritmos de unificação como o de Robinson operam recursivamente sobre estruturas de termos, verificando compatibilidade e acumulando substituições até encontrar um unificador mais geral ou determinar que termos são não-unificáveis.
A resolução SLD (Linear resolution with Selection function for Definite clauses) especializa resolução para cláusulas de Horn, utilizadas em linguagens lógicas como Prolog. Esta restrição sintática garante decidibilidade e eficiência computacional, permitindo que sistemas Prolog executem consultas mediante busca em profundidade com backtracking, unificando objetivos com cabeças de regras e resolvendo recursivamente seus corpos.
Teorema a Provar: "Todo humano é mortal. Sócrates é humano. Logo, Sócrates é mortal."
Passo 1 - Formalização em Lógica de Primeira Ordem:
• Premissa 1: ∀x(Humano(x) → Mortal(x))
• Premissa 2: Humano(sócrates)
• Conclusão: Mortal(sócrates)
Passo 2 - Conversão para Forma Clausal:
• Negar conclusão: ¬Mortal(sócrates)
• Premissa 1 em forma clausal: ¬Humano(x) ∨ Mortal(x)
• Premissa 2 já é literal: Humano(sócrates)
• Negação da conclusão: ¬Mortal(sócrates)
• Conjunto de cláusulas S = {C₁, C₂, C₃}
- C₁: ¬Humano(x) ∨ Mortal(x)
- C₂: Humano(sócrates)
- C₃: ¬Mortal(sócrates)
Passo 3 - Processo de Resolução:
• Iteração 1: Resolver C₁ e C₂
- Unificar Humano(x) com Humano(sócrates): σ₁ = {x/sócrates}
- Aplicar σ₁ a C₁: ¬Humano(sócrates) ∨ Mortal(sócrates)
- Resolver com C₂: Humano(sócrates)
- Eliminar literais opostos: ¬Humano(sócrates) cancela com Humano(sócrates)
- Resolvente C₄: Mortal(sócrates)
• Iteração 2: Resolver C₄ e C₃
- C₄: Mortal(sócrates)
- C₃: ¬Mortal(sócrates)
- Literais são complementares diretamente
- Resolvente C₅: □ (cláusula vazia)
Conclusão: Derivamos □, provando insatisfazibilidade de S. Logo, a conclusão original segue validamente das premissas. Q.E.D.
Árvore de Resolução:
C₁: ¬Humano(x) ∨ Mortal(x) C₂: Humano(sócrates)
↘ ↙
C₄: Mortal(sócrates)
↓
C₃: ¬Mortal(sócrates)
↓
C₅: □
Resolução em lógica de primeira ordem é semi-decidível: se uma fórmula é teorema, o procedimento eventualmente terminará provando-a. Contudo, para fórmulas falsas, o processo pode não terminar. Estratégias de busca como resolução por conjunto de suporte e ordenação de literais melhoram eficiência prática sem sacrificar completude.
Lógica clássica é monotônica: adicionar premissas jamais invalida conclusões previamente derivadas. Contudo, raciocínio de senso comum frequentemente revisa crenças quando nova informação surge. Se acreditamos que Tweety voa porque é um pássaro, descobrir posteriormente que Tweety é um pinguim nos leva a retratar aquela conclusão. Formalismos não-monotônicos modelam essa capacidade de revisão, essencial para agentes operando em ambientes onde conhecimento é incompleto e dinâmico.
Lógicas default introduzem regras que permitem inferências plausíveis na ausência de informação contrária. A regra default Pássaro(x) : Voa(x) / Voa(x) licencia inferir que x voa se sabemos que x é pássaro e é consistente assumir que x voa. O operador ":" testa consistência da conclusão. Extensões default representam conjuntos de crenças coerentemente deriváveis, podendo haver múltiplas extensões quando defaults conflitantes aplicam-se.
Lógicas de circunscrição minimizam a extensão de predicados especificados, formalizando raciocínio de mundo fechado. Circunscrever o predicado Anormal força interpretações onde o mínimo de objetos são considerados anormais, derivando comportamento default para casos típicos. Revisão de crenças mediante operadores AGM (Alchourrón, Gärdenfors, Makinson) garante que atualizações mantenham propriedades racionais como consistência e minimalidade de mudanças.
Cenário: Agentes robóticos em armazém classificando pacotes.
Conhecimento Geral (Lógica Clássica):
• ∀x(Pacote(x) → TemPeso(x))
• ∀x(Frágil(x) → RequerCuidadoEspecial(x))
• ∀x(Peso(x) > 20kg → RequerDoisRobôs(x))
Regras Default (Raciocínio Plausível):
• D₁: Pacote(x) : ¬Frágil(x) / Empilhável(x)
"Pacotes são empilháveis por default, exceto se frágeis"
• D₂: Pacote(x) : Peso(x) ≤ 10kg / ManipulávelPorUmRobô(x)
"Pacotes leves são manipuláveis por um robô, salvo exceções"
• D₃: Entrega(x) : ¬Urgente(x) / Agrupável(x)
"Entregas são agrupáveis em lotes, exceto urgências"
Situação 1 - Raciocínio Default Normal:
• Fato: Pacote(p₁), observação_visual(p₁, caixa_padrão)
• Aplicação D₁: Consistente assumir ¬Frágil(p₁)?
→ Nenhuma evidência de fragilidade na base
→ Conclusão default: Empilhável(p₁)
• Aplicação D₂: Estimativa_peso(p₁) = 8kg
→ Conclusão default: ManipulávelPorUmRobô(p₁)
• Decisão: Agente robô único processa p₁, coloca em pilha
Situação 2 - Retratação por Nova Informação:
• t=0: Mesmo raciocínio default sobre pacote p₂
→ Conclusão: Empilhável(p₂)
• t=5: Sensor tátil detecta conteúdo quebradiço ao manusear
→ Nova informação: Frágil(p₂)
• Revisão de crenças:
- Retratar: Empilhável(p₂) [inconsistente com novo fato]
- Derivar: RequerCuidadoEspecial(p₂) [regra clássica]
- Ação corretiva: Remover p₂ da pilha, isolá-lo
Situação 3 - Múltiplas Extensões:
• Pacote p₃: sem dados de peso, sem marcação de fragilidade
• Extensão E₁: Assume ¬Frágil(p₃), aplica D₁
→ Empilhável(p₃), ManipulávelPorUmRobô(p₃)
• Extensão E₂: Assume Peso(p₃) > 20kg, não aplica D₂
→ RequerDoisRobôs(p₃)
• Ambas extensões são consistentes mas incompatíveis
• Estratégia do agente: Priorizar segurança
→ Escolher E₂ (assumir peso alto), alocar dois robôs
→ Se peso real for baixo: ineficiente mas seguro
→ Se peso real for alto: decisão correta evitou acidente
Agentes reais enfrentam incerteza irredutível sobre estados do mundo. Raciocínio probabilístico quantifica graus de crença mediante distribuições de probabilidade, permitindo decisões racionais sob incerteza. O teorema de Bayes, P(H|E) = P(E|H)P(H) / P(E), atualiza crenças a priori P(H) sobre hipótese H dado evidência E, produzindo probabilidade a posteriori P(H|E) que incorpora informação observada.
Redes bayesianas representam dependências probabilísticas entre variáveis mediante grafos acíclicos dirigidos. Cada nó denota variável aleatória, e arestas capturam influências causais diretas. Tabelas de probabilidade condicional especificam P(X|Pais(X)) para cada nó, codificando como pais afetam a distribuição do filho. A semântica do grafo implica independências condicionais que permitem fatoração eficiente da distribuição conjunta.
Inferência em redes bayesianas calcula probabilidades de consulta dado evidência observada. Algoritmos exatos como eliminação de variáveis exploram estrutura do grafo, enquanto métodos aproximados como amostragem de Gibbs escalam para redes grandes. Agentes utilizam essas distribuições posteriores para tomar decisões que maximizam utilidade esperada, integrando raciocínio probabilístico com teoria da decisão racional.
Variáveis:
• D: Doença (gripe, COVID, resfriado)
• F: Febre (sim, não)
• T: Tosse (sim, não)
• C: Cansaço (sim, não)
Estrutura da Rede:
• D → F, D → T, D → C (doença causa sintomas)
Probabilidades Priori:
• P(D=gripe) = 0,15
• P(D=COVID) = 0,05
• P(D=resfriado) = 0,30
• P(D=nenhuma) = 0,50
Probabilidades Condicionais:
• P(F=sim | D=gripe) = 0,80
• P(F=sim | D=COVID) = 0,85
• P(F=sim | D=resfriado) = 0,20
• P(F=sim | D=nenhuma) = 0,01
• P(T=sim | D=gripe) = 0,70
• P(T=sim | D=COVID) = 0,75
• P(T=sim | D=resfriado) = 0,80
• P(C=sim | D=gripe) = 0,60
• P(C=sim | D=COVID) = 0,90
Consulta: Paciente tem febre e tosse. Qual a probabilidade de COVID?
• Evidência: E = {F=sim, T=sim}
• Calcular: P(D=COVID | F=sim, T=sim)
• Aplicando Bayes:
P(COVID|E) ∝ P(F=sim|COVID) × P(T=sim|COVID) × P(COVID)
= 0,85 × 0,75 × 0,05 = 0,031875
• Similarmente para outras doenças:
P(gripe|E) ∝ 0,80 × 0,70 × 0,15 = 0,084
P(resfriado|E) ∝ 0,20 × 0,80 × 0,30 = 0,048
• Normalizando (soma = 1):
P(COVID|E) = 0,031875 / (0,031875 + 0,084 + 0,048) ≈ 0,194
P(gripe|E) ≈ 0,512
P(resfriado|E) ≈ 0,293
Decisão do Agente:
• Hipótese mais provável: Gripe (51,2%)
• Mas COVID tem probabilidade significativa (19,4%)
• Ação recomendada: Teste para COVID por cautela
Sistemas modernos combinam representação simbólica estruturada com raciocínio probabilístico. Lógica probabilística e programação lógica probabilística permitem expressar regras com incertezas quantificadas, unindo expressividade de linguagens lógicas com robustez de métodos probabilísticos.
O planejamento automatizado constrói sequências de ações que transformam estado inicial em estado objetivo. O formalismo STRIPS (Stanford Research Institute Problem Solver) representa estados mediante conjuntos de proposições verdadeiras, e ações através de precondições que devem ser satisfeitas e efeitos que modificam o estado. Um problema de planejamento especifica-se por tupla (S₀, G, A) onde S₀ denota estado inicial, G especifica condições do objetivo, e A lista ações disponíveis.
Cada ação a ∈ A define-se por três componentes: precondições Pré(a) que devem valer no estado corrente, lista de adição Add(a) de proposições tornadas verdadeiras, e lista de deleção Del(a) de proposições tornadas falsas. Aplicar ação a em estado S produz estado sucessor S' = (S \ Del(a)) ∪ Add(a), assumindo Pré(a) ⊆ S. Um plano é sequência ⟨a₁, a₂, ..., aₙ⟩ cuja execução sequencial a partir de S₀ alcança estado Sₙ onde G ⊆ Sₙ.
Algoritmos de busca exploram espaço de estados ou espaço de planos parciais. Busca progressiva inicia em S₀ aplicando ações até alcançar objetivo. Busca regressiva parte de G e retrocede mediante aplicação inversa de ações. Planejamento por ordem parcial constrói grafos de ações com ordenação flexível, refinando incrementalmente até obter plano linearizável válido. Heurísticas admissíveis guiam busca priorizando estados promissores.
Estado Inicial S₀:
• Em(robô, sala_A), Em(pacote₁, sala_B), Em(pacote₂, sala_A)
• Livre(robô), Porta(sala_A, corredor), Porta(sala_B, corredor)
Objetivo G:
• Em(pacote₁, sala_C) ∧ Em(pacote₂, sala_C)
Ações Disponíveis:
• Mover(robô, de, para):
- Pré: Em(robô, de) ∧ Livre(robô) ∧ Porta(de, para)
- Add: Em(robô, para)
- Del: Em(robô, de)
• Pegar(robô, pacote, local):
- Pré: Em(robô, local) ∧ Em(pacote, local) ∧ Livre(robô)
- Add: Segurando(robô, pacote)
- Del: Em(pacote, local), Livre(robô)
• Soltar(robô, pacote, local):
- Pré: Em(robô, local) ∧ Segurando(robô, pacote)
- Add: Em(pacote, local), Livre(robô)
- Del: Segurando(robô, pacote)
Plano Gerado:
1. Pegar(robô, pacote₂, sala_A)
2. Mover(robô, sala_A, corredor)
3. Mover(robô, corredor, sala_C)
4. Soltar(robô, pacote₂, sala_C)
5. Mover(robô, sala_C, corredor)
6. Mover(robô, corredor, sala_B)
7. Pegar(robô, pacote₁, sala_B)
8. Mover(robô, sala_B, corredor)
9. Mover(robô, corredor, sala_C)
10. Soltar(robô, pacote₁, sala_C)
Verificação: Executar sequência leva S₀ → ... → Sₙ onde G ⊆ Sₙ ✓
Sistemas multi-agentes requerem protocolos de comunicação que permitam troca de informações, coordenação de ações e negociação de objetivos. A comunicação entre agentes transcende mera transmissão de dados, envolvendo atos de fala que alteram estados mentais de receptores. Uma mensagem não apenas carrega conteúdo proposicional, mas também expressa atitude ilocucionária do emissor - informar, requisitar, prometer, ordenar - que orienta como receptor deve processar a informação.
A Foundation for Intelligent Physical Agents (FIPA) estabeleceu padrões para comunicação entre agentes autônomos. A linguagem FIPA-ACL (Agent Communication Language) baseia-se em teoria dos atos de fala, definindo performativas como INFORM, REQUEST, PROPOSE, ACCEPT-PROPOSAL e REJECT-PROPOSAL. Cada mensagem especifica emissor, receptor, conteúdo, linguagem de conteúdo, ontologia compartilhada e protocolo de interação que governa sequências permitidas de mensagens.
Linguagens de conteúdo como KIF (Knowledge Interchange Format) e FIPA-SL (Semantic Language) expressam proposições complexas em sintaxe padronizada interpretável por agentes heterogêneos. Ontologias compartilhadas asseguram que termos usados nas mensagens possuem significados consistentes entre comunicantes, evitando ambiguidades semânticas que comprometeriam coordenação efetiva.
Cenário: Agente gerente busca executor para tarefa de transporte.
Passo 1 - Chamada para Propostas (CFP):
• Emissor: agente_gerente
• Receptor: {agente_transportador₁, agente_transportador₂, agente_transportador₃}
• Performativa: CFP (Call For Proposal)
• Conteúdo:
(ação (transportar origem(armazém_norte) destino(loja_sul)
carga(50kg) prazo(2_horas)))
• Protocolo: fipa-contract-net
Passo 2 - Propostas dos Executores:
• transportador₁ → gerente
- Performativa: PROPOSE
- Conteúdo: (preço 150_reais tempo_estimado 90_min disponível_em 10_min)
• transportador₂ → gerente
- Performativa: REFUSE
- Conteúdo: (motivo veículo_em_manutenção)
• transportador₃ → gerente
- Performativa: PROPOSE
- Conteúdo: (preço 120_reais tempo_estimado 110_min disponível_agora)
Passo 3 - Avaliação e Decisão:
• gerente avalia propostas mediante critérios: custo (40%), rapidez (35%), disponibilidade (25%)
• Score₁ = 0,4×(150/150) + 0,35×(90/90) + 0,25×(10/10) = 1,00
• Score₃ = 0,4×(120/150) + 0,35×(90/110) + 0,25×(0/10) = 0,32 + 0,29 + 0 = 0,61
• Decisão: aceitar proposta de transportador₁
Passo 4 - Comunicação de Decisão:
• gerente → transportador₁
- Performativa: ACCEPT-PROPOSAL
- Conteúdo: (ID_contratoC₁₂₃ confirmação aceita)
• gerente → transportador₃
- Performativa: REJECT-PROPOSAL
- Conteúdo: (motivo proposta_melhor_selecionada)
Passo 5 - Execução e Feedback:
• transportador₁ → gerente
- Performativa: INFORM
- Conteúdo: (status tarefa_iniciada posição_atual km_15)
• [após conclusão]
• transportador₁ → gerente
- Performativa: INFORM-DONE
- Conteúdo: (tarefa_C₁₂₃ status concluída tempo_real 85_min)
A comunicação efetiva entre agentes heterogêneos desenvolvidos por diferentes organizações demanda ontologias compartilhadas que estabeleçam vocabulários comuns. Sem consenso semântico sobre termos utilizados, mensagens tornam-se ambíguas e coordenação fracassa. Ontologias de domínio como FOAF (Friend-of-a-Friend) para redes sociais, GoodRelations para comércio eletrônico, e SNOMED-CT para medicina oferecem taxonomias padronizadas de conceitos e relações.
Alinhamento de ontologias resolve heterogeneidades quando agentes utilizam ontologias distintas mas relacionadas. Mapeamentos estabelecem correspondências entre conceitos: Cliente na ontologia A equivale a Comprador na ontologia B, permitindo tradução automática de mensagens. Técnicas de matching ontológico exploram similaridades sintáticas, estruturais e semânticas para descobrir tais correspondências automaticamente, embora validação humana frequentemente seja necessária para garantir precisão.
A Web Semântica estende esses princípios para escala global, onde bilhões de recursos online são anotados com metadados interpretáveis por máquinas. Linked Data interconecta datasets mediante URIs padronizadas, permitindo que agentes naveguem entre informações distribuídas seguindo links semânticos. SPARQL consulta grafos RDF, recuperando informações relevantes de repositórios heterogêneos integrados mediante ontologias compartilhadas.
Ontologia do Hospital A:
• Classe: PacienteHospitalizado
- Propriedades: ID_internação, leito_ocupado, médico_responsável
• Classe: ProcedimentoMédico
- Propriedades: código_procedimento, duração, custo
Ontologia do Hospital B:
• Classe: Internado
- Propriedades: registro_paciente, quarto_número, doutor_chefe
• Classe: Intervenção
- Propriedades: tipo_intervenção, tempo_estimado, valor
Mapeamentos Descobertos (Alinhamento):
• PacienteHospitalizado ≡ Internado (equivalência de classes)
• ProcedimentoMédico ⊑ Intervenção (subsunção - procedimento é tipo de intervenção)
• ID_internação → registro_paciente (correspondência de propriedades)
• médico_responsável → doutor_chefe (sinônimos)
• duração ≈ tempo_estimado (similaridade semântica alta)
Tradução de Mensagem:
• Mensagem original (Hospital A):
INFORM (PacienteHospitalizado ID_internação=12345
médico_responsável=Dr_Silva
ProcedimentoMédico(cirurgia_cardíaca duração=180min))
• Mensagem traduzida (para Hospital B):
INFORM (Internado registro_paciente=12345
doutor_chefe=Dr_Silva
Intervenção(cirurgia_cardíaca tempo_estimado=180min))
Benefícios:
• Interoperabilidade entre sistemas legados heterogêneos
• Compartilhamento de dados de pacientes entre instituições
• Coordenação de transferências e referências médicas
• Pesquisa clínica agregando dados de múltiplas fontes
Alinhamento ontológico enfrenta desafios como ambiguidade (um termo pode ter múltiplos significados), granularidade diferente (conceitos mais ou menos específicos), e perspectivas divergentes sobre como estruturar conhecimento. Técnicas híbridas combinam métodos automáticos com intervenção especializada para resultados confiáveis.
Protocolos de interação especificam padrões de troca de mensagens que governam conversações entre agentes. Diferentemente de mensagens isoladas, protocolos definem sequências válidas de atos comunicativos, restrições sobre quando cada performativa pode ser utilizada, e expectativas sobre respostas apropriadas. Autômatos de estados finitos ou redes de Petri modelam formalmente esses protocolos, permitindo verificação de conformidade e detecção de violações.
O protocolo Contract-Net organiza alocação distribuída de tarefas mediante anúncios, propostas e atribuições. Leilões implementam-se através de protocolos específicos: leilão inglês com lances crescentes, leilão holandês com preços decrescentes, ou leilões de segundo preço selados onde vencedores pagam o segundo maior lance. Cada variante possui propriedades estratégicas distintas que afetam comportamento racional dos participantes.
Protocolos de compromisso mútuo estabelecem acordos vinculantes entre agentes. Uma vez que agente aceita realizar tarefa, compromete-se a executá-la ou notificar falhas, enquanto requisitante compromete-se a não cancelar arbitrariamente. Convenções sociais sobre manutenção de compromissos emergem de interações repetidas, onde reputação pune agentes que violam acordos sistematicamente, incentivando comportamento cooperativo mesmo em ausência de autoridade central.
Cenário: Cluster de computação científica aloca tempo de processamento.
Protocolo: Leilão de Segundo Preço Selado (Vickrey)
• Item: 100 horas de computação em supercomputador
• Participantes: 5 agentes representando projetos de pesquisa
Fase 1 - Submissão de Lances (Selados):
• Agente_A: lance = 5000 créditos (valoração real = 5500)
• Agente_B: lance = 4500 créditos (valoração real = 4800)
• Agente_C: lance = 5200 créditos (valoração real = 5200)
• Agente_D: lance = 3800 créditos (valoração real = 4000)
• Agente_E: lance = 4800 créditos (valoração real = 5000)
Fase 2 - Abertura e Ordenação:
• Lances ordenados: C(5200) > A(5000) > E(4800) > B(4500) > D(3800)
• Vencedor: Agente_C (maior lance)
• Preço pago: 5000 créditos (segundo maior lance de A)
Análise de Incentivos (Propriedade Strategy-Proof):
• Agente_C pagou menos que sua valoração real (5000 < 5200)
• Ganho líquido: 5200 - 5000 = 200 créditos de utilidade
• Se C tivesse mentido lançando apenas 4900:
- Perderia leilão (A venceria com 5000)
- Utilidade: 0 (pior que 200)
• Se C tivesse exagerado lançando 6000:
- Ainda venceria, mas pagaria 5000 (igual)
- Ganho líquido: 5200 - 5000 = 200 (mesmo resultado)
• Conclusão: Revelar valoração verdadeira é estratégia dominante!
Protocolo de Execução:
1. Leiloeiro → Todos: ANNOUNCE(item=100h_compute deadline=24h)
2. Agente_i → Leiloeiro: BID(valor_i) [mensagem criptografada]
3. Leiloeiro: ordena lances após deadline
4. Leiloeiro → Vencedor_C: AWARD(item preço=5000)
5. Leiloeiro → Outros: INFORM(resultado auction_closed)
6. Vencedor_C → Leiloeiro: ACCEPT(transferir_5000_créditos)
7. Leiloeiro → Vencedor_C: DELIVER(acesso_supercomputador 100h)
Leilões de Vickrey incentivam verdade mas exigem confiança no leiloeiro. Leilões ingleses são transparentes mas podem revelar informações estratégicas prematuramente. Leilões combinatoriais permitem lances em pacotes de itens, úteis quando há complementaridades, mas são computacionalmente complexos.
Linguagens especializadas para programação de agentes oferecem abstrações de alto nível que facilitam implementação de arquiteturas cognitivas complexas. AgentSpeak, baseada em lógica BDI, permite especificação declarativa de crenças, objetivos e planos mediante sintaxe próxima à linguagem natural. Programadores definem bibliotecas de planos que agentes selecionam dinamicamente baseado em contexto e objetivos ativos, eliminando necessidade de codificar explicitamente toda lógica de controle.
Jason estende AgentSpeak com comunicação entre agentes, raciocínio sobre ações de outros agentes, e integração com ambientes Java. Um programa Jason especifica agentes mediante crenças iniciais, objetivos de alcance e manutenção, e planos estruturados com contextos de aplicabilidade e corpos procedimentais. O interpretador Jason gerencia ciclo de raciocínio BDI automaticamente, liberando programadores para focarem em lógica de domínio.
Outras linguagens como GOAL, 2APL e Jadex seguem filosofias similares, variando em expressividade de linguagem de crença, mecanismos de deliberação, e integração com frameworks empresariais. A escolha depende de requisitos específicos: GOAL emphasiza objetivos declarativos, 2APL oferece raciocínio procedural explícito, enquanto Jadex integra-se nativamente com Java Enterprise Edition para aplicações corporativas de larga escala.
Programa Jason - Agente de Segurança Residencial:
Crenças Iniciais:
• alarme(desativado).
• porta_principal(fechada).
• janela_sala(fechada).
• sensor_movimento(inativo).
• modo_operacao(vigilante).
Objetivo Inicial:
• !monitorar_seguranca.
Planos:
// Plano para monitoramento contínuo
+!monitorar_seguranca : modo_operacao(vigilante)
← .wait(1000); // Aguarda 1 segundo
!verificar_sensores;
!monitorar_seguranca. // Recursão para loop contínuo
// Plano para verificação de sensores
+!verificar_sensores
← ?sensor_movimento(Estado); // Consulta crença atual
?porta_principal(P);
?janela_sala(J);
!processar_leituras(Estado,P,J).
// Plano para movimento detectado
+!processar_leituras(ativo, _, _) : alarme(desativado)
← .print("Movimento detectado!");
-alarme(desativado); // Remove crença antiga
+alarme(ativado); // Adiciona crença nova
!notificar_proprietario;
!acionar_sirene.
// Plano para porta/janela aberta suspeita
+!processar_leituras(_, aberta, _) : modo_operacao(vigilante)
← .print("Porta aberta detectada!");
!verificar_autorizacao.
+!processar_leituras(_, _, aberta) : modo_operacao(vigilante)
← .print("Janela aberta detectada!");
!verificar_autorizacao.
// Plano para situação normal
+!processar_leituras(inativo, fechada, fechada)
← .print("Sistema normal").
// Plano de comunicação com proprietário
+!notificar_proprietario
← .send(agente_proprietario, tell, alerta_seguranca(movimento));
.wait(5000); // Aguarda 5 segundos
?resposta_recebida(R);
!processar_resposta(R).
// Evento: recebimento de mensagem do proprietário
+resposta_recebida(falso_alarme)[source(agente_proprietario)]
← .print("Falso alarme confirmado");
!desativar_alarme.
+resposta_recebida(emergencia)[source(agente_proprietario)]
← .print("Emergência confirmada!");
!contatar_policia.
Execução:
• Agente inicia em modo vigilante, monitorando sensores continuamente
• Ao detectar movimento, ativa alarme e notifica proprietário
• Baseado na resposta, ou desativa (falso alarme) ou chama polícia
• Crenças atualizadas dinamicamente refletem estado do ambiente
• Planos selecionados automaticamente baseado em contexto
A semântica formal de linguagens de agentes especifica rigorosamente o significado de programas, permitindo verificação matemática de propriedades como segurança (safety), vivacidade (liveness), e terminação. Lógicas temporais como LTL (Linear Temporal Logic) e CTL (Computation Tree Logic) expressam propriedades sobre trajetórias de execução, enquanto lógicas epistêmicas e deônticas capturam conhecimento e obrigações dos agentes.
Model checking automatiza verificação explorando exaustivamente espaço de estados para determinar se propriedade especificada vale em todos os comportamentos possíveis. Ferramentas como SPIN e NuSMV verificam sistemas concorrentes, detectando deadlocks, violações de protocolos, e race conditions. Para sistemas multi-agentes, verificação enfrenta explosão exponencial de estados conforme número de agentes cresce, demandando técnicas de abstração e redução por simetria.
Proof-carrying code permite que agentes transportem provas formais de que satisfazem requisitos de segurança especificados. Consumidores verificam essas provas antes de executar código, garantindo proteção contra comportamento malicioso sem necessidade de confiar cegamente no produtor. Esta abordagem é especialmente relevante em sistemas abertos onde agentes desenvolvidos por partes não confiáveis devem interagir com recursos críticos.
Sistema: Três agentes robóticos compartilham zona de trabalho crítica.
Propriedades a Verificar:
1. Exclusão Mútua (Safety): □(¬(zona_A ∧ zona_B))
"Sempre verdade que A e B não ocupam zona simultaneamente"
2. Ausência de Deadlock (Liveness): □(requisição_i → ◊entrada_i)
"Sempre que agente requisita, eventualmente entra"
3. Equidade (Fairness): □◊(oportunidade_A) para todo agente
"Infinitamente frequente, cada agente tem oportunidade"
Modelo do Protocolo (Autômato de Estados):
• Estados de cada agente: {Externo, Aguardando, Crítico}
• Transições:
- Externo → Aguardando: agente requisita acesso
- Aguardando → Crítico: recebe permissão E zona vazia
- Crítico → Externo: completa tarefa, libera zona
• Variável global: contador_permissões (distribuído por algoritmo)
Verificação com Model Checker:
• Espaço de estados: 3³ = 27 configurações possíveis
• Verificação de Exclusão Mútua:
- Busca estados onde (status_A = Crítico) ∧ (status_B = Crítico)
- Resultado: NENHUM estado violador encontrado ✓
• Verificação de Ausência de Deadlock:
- Busca ciclos onde todos em Aguardando sem transições possíveis
- Resultado: Ciclo detectado quando token de permissão perdido!
- Bug encontrado: Se agente falha no Crítico sem liberar token
• Correção: Adicionar timeout e recuperação de token
• Re-verificação: Ausência de deadlock confirmada ✓
Propriedades Temporais em LTL:
• φ₁ = □(req_A → ◊(¬req_A ∨ crit_A))
"Requisição de A sempre eventualmente é satisfeita ou cancelada"
• φ₂ = □(crit_A → ◊ext_A)
"Se A entra na zona crítica, eventualmente sai"
• φ₃ = □((crit_A ∧ req_B) → X¬crit_B)
"Se A está em zona e B requisita, B não entra no próximo estado"
Resultado Final:
• Protocolo corrigido satisfaz todas as propriedades ✓
• Certificado de verificação gerado e anexado ao código
• Sistema pode ser implantado com confiança formal
Embora poderosa, verificação formal tem limitações práticas. Explosão de estados torna verificação intratável para sistemas muito grandes. Especificações incorretas ou incompletas podem dar falsa sensação de segurança. Integre verificação formal com testes extensivos e revisão de código para máxima confiabilidade.
Comunicação em sistemas multi-agentes distribuídos enfrenta desafios técnicos significativos como latência de rede, perda de mensagens, ordenação inconsistente de eventos, e particionamento de rede. O teorema CAP estabelece que sistemas distribuídos não podem simultaneamente garantir consistência, disponibilidade e tolerância a partições, forçando compromissos arquiteturais que afetam design de protocolos de coordenação.
Mensagens assíncronas eliminam acoplamento temporal entre emissor e receptor, permitindo que agentes continuem processando sem bloquear aguardando respostas. Buffers de mensagens e filas persistentes garantem entrega eventual mesmo quando receptores estão temporariamente indisponíveis. Contudo, assincronicidade complica raciocínio sobre ordem de eventos, especialmente quando múltiplos agentes modificam estado compartilhado concorrentemente.
Relógios lógicos de Lamport estabelecem ordenação parcial consistente de eventos distribuídos sem sincronização de tempo físico. Cada agente mantém contador local incrementado a cada evento, e mensagens carregam timestamp do emissor. Ao receber mensagem, agente atualiza seu relógio para max(relógio_local, timestamp_mensagem) + 1, garantindo que causa sempre preceda efeito na ordenação lógica, permitindo detecção de anomalias causais.
Problema: Múltiplos agentes devem concordar sobre valor único (ex: líder eleito).
Desafios:
• Agentes podem falhar a qualquer momento
• Mensagens podem ser perdidas ou atrasadas
• Não há relógio global sincronizado
• Decisão deve ser irreversível uma vez tomada
Algoritmo Paxos Simplificado:
Roles:
• Proponente: propõe valores para consenso
• Aceitador: vota em propostas
• Aprendiz: observa resultado final
Fase 1 - Preparação:
• Proponente_A gera número de proposta n₁ (único, crescente)
• A → Todos Aceitadores: PREPARE(n₁)
• Aceitador_i recebe PREPARE(n₁):
- Se n₁ > n_max_visto: promete não aceitar propostas < n₁
- Responde: PROMISE(n₁, valor_já_aceito_se_houver)
- Se n₁ ≤ n_max_visto: ignora (proposta obsoleta)
Fase 2 - Aceitação:
• Proponente_A recebe PROMISE de maioria (quorum)?
- Sim: Escolhe valor v (seu próprio, ou valor_já_aceito de maior n)
- A → Todos: ACCEPT(n₁, v)
• Aceitador_i recebe ACCEPT(n₁, v):
- Se não prometeu respeitar n > n₁: aceita (n₁, v)
- Responde: ACCEPTED(n₁, v)
• Quando maioria aceita (n₁, v): valor v está DECIDIDO!
Execução Concreta:
• Sistema: 5 agentes aceitadores {A₁, A₂, A₃, A₄, A₅}
• Dois proponentes concorrentes querem eleger líder
t=0: Proponente_P propõe "agente_X"
- P → Todos: PREPARE(n=10)
t=1: A₁, A₂, A₃ respondem PROMISE(10)
- P tem quorum (3/5 > 50%)
t=2: P → Todos: ACCEPT(10, "agente_X")
t=3: Proponente_Q concorrente também age
- Q → Todos: PREPARE(n=15)
t=4: A₁, A₂ recebem ambas mensagens
- Já aceitaram (10, "agente_X") mas 15 > 10
- Respondem a Q: PROMISE(15, já_aceitei=(10, "agente_X"))
t=5: Q recebe promises indicando A₁, A₂ já aceitaram "agente_X"
- Q deve propor "agente_X" (não seu próprio valor!)
- Q → Todos: ACCEPT(15, "agente_X")
t=6: Maioria aceita → CONSENSO em "agente_X" ✓
Propriedades Garantidas:
• Safety: Apenas um valor será decidido
• Liveness: Se maioria está disponível, decisão ocorre
• Tolerância a falhas: Suporta f falhas com 2f+1 agentes
Coordenação multi-agente enfrenta o desafio fundamental de alinhar ações de entidades autônomas que possuem perspectivas parciais do problema global. Diferentemente de sistemas centralizados onde controlador único comanda componentes passivos, sistemas multi-agentes distribuem decisão entre agentes que devem reconciliar objetivos potencialmente conflitantes mediante negociação, compromisso e cooperação voluntária.
Mecanismos de coordenação classificam-se em duas categorias principais: coordenação organizacional, que estabelece estruturas hierárquicas ou de equipe com papéis e responsabilidades predefinidos, e coordenação emergente, onde padrões globais surgem de interações locais sem planejamento central. Hierarquias oferecem eficiência decisória mediante autoridade clara, enquanto estruturas planas promovem robustez através de redundância e adaptação descentralizada.
A teoria de dependências modela relações entre objetivos de agentes, identificando quando agente necessita ação de outro para alcançar seus fins. Dependências criam oportunidades para troca: agente A pode auxiliar B com objetivo x em troca de ajuda de B com objetivo y. Grafos de dependências visualizam essas relações, e algoritmos de análise identificam coalizões benéficas onde cooperação mútua aumenta utilidade agregada.
Cenário: 4 drones autônomos devem localizar sobreviventes em área de desastre.
Objetivos Individuais:
• Drone₁: Maximizar área_coberta, minimizar bateria_gasta
• Drone₂: Maximizar detecções, evitar colisões
• Drone₃: Cobrir áreas_prioritárias, retornar antes de 20min
• Drone₄: Seguir trajetória_ótima, comunicar descobertas rapidamente
Desafios de Coordenação:
• Evitar sobreposição excessiva de áreas de busca (desperdício)
• Garantir cobertura completa sem lacunas (efetividade)
• Adaptar planos quando drone falha ou encontra obstáculo
• Priorizar áreas com maior probabilidade de sobreviventes
Abordagem 1 - Decomposição de Tarefas (Organizacional):
• Líder (Drone₁) divide área em 4 quadrantes
• Atribui quadrante_i a Drone_i
• Cada drone executa busca exaustiva em sua região
• Vantagem: Simples, sem redundância
• Desvantagem: Se Drone₃ falhar, quadrante₃ não é coberto
Abordagem 2 - Leilão de Tarefas (Market-Based):
• Divide área em 20 células
• Cada célula é "leiloada" aos drones
• Drone_i calcula custo(célula_j) baseado em: distância, bateria, prioridade
• Lance = valor_esperado / custo
• Células atribuídas a maiores lances
• Vantagem: Alocação eficiente considerando estado individual
• Resultado: Drone mais próximo e com mais bateria cobre células distantes
Abordagem 3 - Stigmergy (Coordenação Emergente):
• Inspirada em formigas: drones deixam "feromônio virtual"
• Mapa compartilhado onde cada célula tem: nível_feromônio[i,j]
• Drone visitando (i,j): deposita feromônio(1.0)
• Feromônio evapora com tempo: nível ← nível × 0.95 a cada segundo
• Decisão de movimento: ir para célula adjacente com MENOR feromônio
• Emergência: Drones naturalmente evitam áreas recém-visitadas
• Robustez: Falha de um drone não afeta outros (sem dependência explícita)
Comparação Experimental:
• Decomposição: 100% cobertura em 15min (sem falhas), 75% com 1 falha
• Leilão: 100% cobertura em 12min, 95% com 1 falha (re-leilão)
• Stigmergy: 98% cobertura em 14min, 93% com 1 falha (adaptação automática)
Teoria de jogos cooperativos estuda como agentes formam grupos para alcançar objetivos mutuamente benéficos que seriam inatingíveis individualmente. Uma coalizão C ⊆ N de agentes gera valor v(C) que pode ser distribuído entre membros. O desafio central é determinar quais coalizões formar e como dividir benefícios equitativamente, incentivando participação enquanto previne deserção.
O núcleo (core) de um jogo cooperativo consiste em alocações onde nenhuma coalizão pode melhorar unilateralmente desertando. Matematicamente, alocação x = (x₁, ..., xₙ) está no núcleo se Σx_i = v(N) e para toda coalizão C, Σ_{i∈C} x_i ≥ v(C). Jogos sem núcleo não admitem distribuições estáveis, levando a renegociações perpétuas. O valor de Shapley oferece solução única que distribui contribuições marginais esperadas de cada agente considerando todas as ordens possíveis de formação.
Algoritmos de formação de coalizões exploram combinatória de subconjuntos, buscando estruturas que maximizem valor social agregado. Para n agentes, existem 2ⁿ coalizões possíveis, tornando enumeração exaustiva intratável. Heurísticas como merge-and-split iterativamente refinam estruturas, fundindo coalizões que ganham sinergia e dividindo aquelas com membros incompatíveis. Leilões combinatoriais permitem que agentes expressem preferências sobre múltiplas configurações simultaneamente.
Cenário: 4 veículos de entrega devem servir 10 destinos em cidade.
Agentes:
• V₁: Van grande (capacidade 8 pacotes, velocidade 50km/h)
• V₂: Van média (capacidade 5 pacotes, velocidade 60km/h)
• V₃: Moto (capacidade 2 pacotes, velocidade 80km/h)
• V₄: Bicicleta elétrica (capacidade 3 pacotes, velocidade 30km/h)
Valor de Coalizões (lucro líquido em R$):
• v({V₁}) = 120 (opera sozinho, cobre 6 destinos em tempo hábil)
• v({V₂}) = 80
• v({V₃}) = 60 (rápido mas baixa capacidade)
• v({V₄}) = 40
• v({V₁, V₂}) = 250 (sinergia: coordenam rotas, cobrem 10 destinos)
• v({V₁, V₃}) = 210 (V₃ faz entregas urgentes, V₁ volume)
• v({V₁, V₄}) = 170
• v({V₂, V₃}) = 180
• v({V₂, V₄}) = 140
• v({V₃, V₄}) = 110
• v({V₁, V₂, V₃}) = 290
• v({V₁, V₂, V₃, V₄}) = 310 (grande coalizão - alguma redundância)
Análise de Estabilidade (Núcleo):
• Proposta: Grande coalizão {V₁, V₂, V₃, V₄} com v = 310
• Divisão ingênua: x = (77.5, 77.5, 77.5, 77.5) - igualitária
• Verificação: {V₁, V₂} pode gerar 250 sozinhos
- Recebem apenas 77.5 + 77.5 = 155 na grande coalizão
- 155 < 250: INSTÁVEL! V₁ e V₂ desertariam
• Divisão no núcleo: x = (100, 90, 70, 50)
- v({V₁, V₂}) = 250 < 100 + 90=190? NÃO, ainda violado!
• Conclusão: Grande coalizão não está no núcleo!
Estrutura Ótima de Coalizões:
• Coalizão C₁ = {V₁, V₂, V₃} com v = 290
• Coalizão C₂ = {V₄} com v = 40
• Valor social total: 290 + 40 = 330 > 310 da grande coalizão!
Distribuição via Valor de Shapley em C₁:
• φ₁(V₁) = contribuição marginal média
• Orderings: {V₁}, {V₁,V₂}, {V₁,V₃}, {V₁,V₂,V₃}, etc.
• Cálculo: φ₁ = (1/6)[120 + 130 + 80 + 110 + 150 + 110] = 116.7
• φ₂ = 100, φ₃ = 73.3
• Verificação: 116.7 + 100 + 73.3 = 290 ✓
• Todos preferem participar (ganham mais que sozinhos) ✓
Para formação dinâmica de coalizões, implemente mecanismos de renegociação periódica onde agentes podem propor novas configurações. Use contratos inteligentes em blockchain para garantir compromissos vinculantes e distribuição automática de recompensas segundo fórmulas pré-acordadas como Shapley.
Mecanismos de mercado oferecem abordagem descentralizada para alocação de recursos em sistemas multi-agentes, explorando princípios econômicos de oferta, demanda e formação de preços. Agentes atuam como compradores e vendedores, negociando recursos mediante lances competitivos que agregam informação distribuída sobre preferências e capacidades. Preços emergem como sinais coordenativos que balanceiam oferta e demanda sem necessidade de autoridade central planejadora.
O equilíbrio de Walras caracteriza alocações onde mercados claram simultaneamente - quantidade demandada iguala quantidade ofertada para todos os bens. Sob condições ideais de convexidade e continuidade, teoremas fundamentais da economia do bem-estar garantem que equilíbrios competitivos são Pareto-eficientes: impossível melhorar situação de um agente sem piorar a de outro. Algoritmos de tatonnement implementam processos iterativos que convergem para esses equilíbrios mediante ajustes sucessivos de preços.
Leilões duplos permitem que múltiplos compradores e vendedores submetam lances simultâneos, com mecanismo central determinando preço de claro que maximiza volume de transações. Bolsas de valores eletrônicas implementam variantes contínuas onde ordens fluem constantemente e matching ocorre em tempo real. Para bens indivisíveis ou com restrições complexas de compatibilidade, leilões combinatoriais permitem lances sobre pacotes, capturando complementaridades e substitutibilidades.
Cenário: Plataforma de trabalho freelance conectando clientes e prestadores.
Lado da Demanda (Clientes):
• Cliente_A: disposto a pagar até R$ 500 por design de logo
• Cliente_B: disposto a pagar até R$ 350 por design de logo
• Cliente_C: disposto a pagar até R$ 450 por design de logo
Lado da Oferta (Designers):
• Designer_X: aceita trabalho por no mínimo R$ 300
• Designer_Y: aceita trabalho por no mínimo R$ 400
• Designer_Z: aceita trabalho por no mínimo R$ 280
Curva de Demanda (ordenada decrescente):
• Preço ≥ R$ 500: 1 unidade demandada (A)
• Preço ≥ R$ 450: 2 unidades (A, C)
• Preço ≥ R$ 350: 3 unidades (A, B, C)
Curva de Oferta (ordenada crescente):
• Preço ≥ R$ 280: 1 unidade ofertada (Z)
• Preço ≥ R$ 300: 2 unidades (Z, X)
• Preço ≥ R$ 400: 3 unidades (Z, X, Y)
Determinação do Equilíbrio:
• Intersecção: entre R$ 350 e R$ 400
• A R$ 350: demanda = 3, oferta = 2 (excesso de demanda)
• A R$ 400: demanda = 2, oferta = 3 (excesso de oferta)
• Preço de equilíbrio: R$ 375 (ponto médio, ou determinado por regra do leilão)
• Quantidade transacionada: 2 unidades
Alocação Final:
• Transação 1: Cliente_A ↔ Designer_Z (R$ 375)
- Excedente A: 500 - 375 = R$ 125
- Excedente Z: 375 - 280 = R$ 95
• Transação 2: Cliente_C ↔ Designer_X (R$ 375)
- Excedente C: 450 - 375 = R$ 75
- Excedente X: 375 - 300 = R$ 75
• Não transacionam: Cliente_B (valoração < preço), Designer_Y (custo> preço)
Propriedades:
• Eficiência: Projetos alocados aos designers de menor custo
• Clientes com maior valoração são atendidos prioritariamente
• Excedente total: 125 + 95 + 75 + 75 = R$ 370 (maximizado)
• Incentivo-compatível: Agentes revelam valorações verdadeiras
Mecanismos de mercado assumem racionalidade perfeita e ausência de externalidades. Na prática, agentes podem ter informação imperfeita, poder de mercado pode distorcer preços, e transações podem gerar efeitos sobre terceiros não capturados pelo sistema de preços. Regulação e mecanismos complementares podem ser necessários.
Normas sociais regulam comportamento de agentes mediante expectativas compartilhadas sobre condutas apropriadas, complementando coordenação explícita com regras implícitas que emergem de interações repetidas. Uma norma prescreve ou proscreve ações em contextos específicos, sendo mantida por sanções sociais como perda de reputação quando violada. Sistemas normativos distribuem responsabilidade de monitoramento entre participantes, promovendo conformidade mediante pressão de pares.
Instituições eletrônicas formalizam normas computacionalmente mediante ontologias que especificam papéis, cenas, transições permitidas e obrigações. A linguagem Islander modela instituições como grafos de cenas conectadas por transições condicionais, onde cada cena define protocolo de interação válido. Agentes navegam pela instituição assumindo papéis que carregam direitos e deveres, com infraestrutura institucional garantindo cumprimento de regras mediante enforcement automático.
Reputação serve como mecanismo descentralizado de sanção, onde agentes mantêm históricos de interações passadas e consultam reputação antes de engajar com parceiros potenciais. Sistemas de confiança agregam avaliações de múltiplas fontes, filtrando relatos espúrios e ponderando contribuições por confiabilidade dos avaliadores. Modelos baseados em teoria dos grafos propagam confiança transitivamente: se A confia em B e B confia em C, então A pode confiar parcialmente em C.
Contexto: Rede peer-to-peer de compartilhamento de arquivos.
Agentes:
• Peers: compartilham e baixam arquivos
• Cada peer mantém tabela de reputação de outros peers
Modelo de Reputação:
• R(A→B) ∈ [-1, 1]: reputação que A atribui a B
- R = 1: totalmente confiável
- R = 0: neutro (sem histórico)
- R = -1: não confiável
Atualização após Interação:
• Se B fornece arquivo correto a A:
R_novo(A→B) = R_antigo + α(1 - R_antigo) onde α = 0.3
• Se B fornece arquivo corrompido:
R_novo(A→B) = R_antigo + β(-1 - R_antigo) onde β = 0.5
Consulta de Reputação Indireta:
• A quer interagir com C mas não tem histórico direto
• A consulta amigos confiáveis B₁, B₂, ..., Bₙ
• R_indireto(A→C) = Σᵢ w(A→Bᵢ) × R(Bᵢ→C) / Σᵢ w(A→Bᵢ)
onde w(A→Bᵢ) = max(R(A→Bᵢ), 0) é peso baseado em confiança
Exemplo Numérico:
• A conhece: B₁ com R(A→B₁) = 0.8, B₂ com R(A→B₂) = 0.6
• B₁ reporta: R(B₁→C) = 0.9
• B₂ reporta: R(B₂→C) = 0.4
• Cálculo: R(A→C) = (0.8×0.9 + 0.6×0.4)/(0.8+0.6)
= (0.72 + 0.24)/1.4 = 0.96/1.4 ≈ 0.69
• Decisão: Reputação moderadamente positiva, A pode tentar interagir
Detecção de Ataques:
• Sybil Attack: Peer cria múltiplas identidades falsas
- Mitigação: Limitar influência de peers novos (sem histórico)
• Badmouthing: Peers maliciosos difamam concorrentes honestos
- Mitigação: Detectar inconsistências (se B₁ diverge muito de maioria)
• Whitewashing: Peer abandona identidade ruim e recomeça
- Mitigação: Custo de entrada (prova de trabalho, validação)
Norma Emergente:
• Após muitas interações, comportamento cooperativo torna-se norma
• Peers com R < 0.3 são ostracizados (ninguém interage)
• Sistema auto-regula sem autoridade central
Aprendizado multi-agente estuda como agentes autônomos melhoram desempenho através de experiência em ambientes povoados por outros agentes adaptativos. Diferentemente de aprendizado de máquina single-agent, o ambiente não é estacionário - estratégias ótimas mudam conforme outros agentes aprendem e modificam comportamentos. Esta não-estacionariedade fundamental complica análise de convergência e estabilidade de algoritmos de aprendizado.
Q-learning distribuído permite que agentes aprendam políticas coordenadas mediante recompensas compartilhadas. Cada agente mantém função Q(s,a) estimando valor esperado de ação a em estado s, atualizando-a baseado em recompensas observadas. Em ambientes cooperativos totalmente observáveis, coordenação emerge quando agentes convergem para políticas que maximizam recompensa conjunta. Contudo, em ambientes parcialmente observáveis ou competitivos, garantias de convergência enfraquecem.
Aprendizado por imitação acelera aquisição de comportamentos complexos mediante observação de demonstrações. Agentes inferem estratégias de experts através de aprendizado supervisionado, depois refinam via reforço. Transfer learning reutiliza conhecimento adquirido em tarefas relacionadas, reduzindo amostras necessárias para domínio de novas situações. Estas técnicas são especialmente valiosas quando exploração autônoma é custosa ou perigosa.
Cenário: Time de 3 robôs jogadores deve coordenar para marcar gols.
Estado do Ambiente:
• s = (pos_bola, pos_R₁, pos_R₂, pos_R₃, pos_adversários, ...)
Ações de Cada Robô:
• a ∈ {mover_norte, mover_sul, chutar, passar_para_R₁, passar_para_R₂, ...}
Recompensa de Equipe:
• +100 pontos: gol marcado
• +10: passe bem-sucedido entre companheiros
• +5: aproximar bola do gol adversário
• -50: gol sofrido
• -5: perder posse de bola
Desafio de Atribuição de Crédito:
• Gol resulta de sequência de ações de múltiplos robôs
• Qual robô merece mais crédito? R₁ que fez assistência ou R₂ que finalizou?
Solução: Q-learning com Difference Rewards:
• Recompensa individual de Rᵢ:
D(Rᵢ) = G(time_completo) - G(time_sem_Rᵢ)
• G mede desempenho global
• D isola contribuição marginal de cada agente
Exemplo de Episódio:
• t=0: R₁ intercepta passe adversário (+5 para R₁)
• t=1: R₁ passa para R₂ (+10 compartilhado)
• t=2: R₂ avança (+3 para R₂)
• t=3: R₃ desmarca, criando espaço (+4 para R₃)
• t=4: R₂ passa para R₃ (+10 compartilhado)
• t=5: R₃ chuta e marca (+100 para todos!)
Atualização Q-values:
• Para R₁: Q(s₀, interceptar) ← Q + α[r + γ max Q(s₁,a) - Q(s₀,interceptar)]
• Onde r incorpora diferença de recompensa
Estratégias Aprendidas após 10.000 episódios:
• R₁ aprende: Defender zona central, iniciar contra-ataques
• R₂ aprende: Conectar defesa e ataque, distribuir passes
• R₃ aprende: Posicionar-se para finalizações, pressionar zagueiros
• Coordenação emergente: Triangulações, coberturas de posição
Métricas de Convergência:
• Episódios 1-1000: 2 gols/jogo (média), coordenação caótica
• Episódios 5000-6000: 8 gols/jogo, passes aumentam
• Episódios 9000-10000: 12 gols/jogo, táticas sofisticadas
Use comunicação explícita para compartilhar modelos aprendidos entre agentes. Imponha estrutura mediante curricula que gradualmente aumentam dificuldade. Combine aprendizado por reforço com modelos simbólicos que fornecem conhecimento a priori sobre domínio.
Sincronização em sistemas distribuídos enfrenta o desafio de coordenar agentes sem relógio global compartilhado. Algoritmos de eleição determinam líder único entre agentes equivalentes, resolvendo assimetrias temporárias necessárias para coordenação. O algoritmo de Bully, por exemplo, garante que agente com maior identificador torna-se líder, recuperando-se automaticamente quando líderes falham e são substituídos.
Snapshots globais consistentes capturam estado distribuído do sistema num instante lógico, essenciais para detecção de propriedades globais como deadlock. O algoritmo de Chandy-Lamport utiliza mensagens marcadoras propagadas pelos canais de comunicação, permitindo que cada agente registre seu estado local e mensagens em trânsito sem interromper execução normal, produzindo snapshot consistente do sistema distribuído.
Blockchain implementa consenso distribuído imutável mediante prova de trabalho ou participação. Mineradores competem para adicionar blocos válidos à cadeia, com regra de consenso privilegiando cadeia mais longa. Esta estrutura garante acordo sobre histórico de transações sem autoridade central confiável, resistindo a tentativas de revisão por atacantes minoritários. Smart contracts executam lógica determinística sobre esse substrato consensual, habilitando automação de acordos multi-agente com garantias criptográficas.
Participantes: Fabricante, Transportadora, Varejista, Regulador
Problema: Rastrear produto do fabricante ao consumidor final.
Solução Tradicional (Problemas):
• Cada parte mantém banco de dados próprio
• Inconsistências quando sistemas dessincronizam
• Disputas sobre estado verdadeiro da cadeia
• Custos de auditoria e reconciliação
Solução com Blockchain:
• Ledger distribuído compartilhado por todos participantes
• Cada transação registrada como bloco imutável
• Consenso garante acordo sobre sequência de eventos
Fluxo de Transações:
• t₁: Fabricante cria produto lote #L123
- Bloco₁: {evento: "produzido", produto: L123, timestamp: t₁,
qualidade: certificado_ISO, hash_anterior: genesis}
• t₂: Produto transferido para Transportadora
- Bloco₂: {evento: "transferido", de: Fabricante, para: Transportadora,
produto: L123, timestamp: t₂, hash_anterior: hash(Bloco₁)}
• t₃: Transportadora confirma recebimento
- Bloco₃: {evento: "recebido", agente: Transportadora, produto: L123,
temperatura_transporte: 4°C, timestamp: t₃}
• t₄: Produto entregue ao Varejista
- Bloco₄: {evento: "entregue", destino: Varejista,
produto: L123, timestamp: t₄}
Smart Contract de Pagamento:
• Código executado automaticamente:
function liquidar_pagamento(lote):
if (confirmar_entrega(lote) AND
verificar_qualidade(lote) AND
prazo_respeitado(lote)):
transferir(Varejista → Fabricante, valor_acordado)
transferir(Varejista → Transportadora, frete)
else if (temperatura_fora_range(lote)):
aplicar_penalidade(Transportadora, 20%)
Vantagens do Consenso Distribuído:
• Transparência: Todos veem mesma versão da verdade
• Imutabilidade: Histórico não pode ser alterado retroativamente
• Automação: Smart contracts eliminam intermediários
• Auditoria: Regulador acessa dados em tempo real
• Confiança: Não depende de autoridade central
Mecanismo de Consenso (Proof-of-Authority):
• Nós validadores pré-aprovados: {Fab, Transp, Varej, Reg}
• Novo bloco requer assinatura de 3/4 validadores
• Finalidade rápida (~3 segundos) adequada para supply chain
Negociação permite que agentes com interesses parcialmente conflitantes alcancem acordos mutuamente benéficos mediante trocas de propostas e concessões. Diferentemente de mecanismos de leilão com regras fixas, protocolos de negociação oferecem flexibilidade para explorar soluções criativas que expandem valor disponível. A zona de acordo possível (ZOPA) delimita região onde existe sobreposição entre preços mínimos aceitáveis para vendedor e máximos para comprador.
Estratégias de negociação variam de abordagens competitivas que maximizam ganho individual até táticas integrativas que buscam soluções win-win mediante identificação de interesses subjacentes. O dilema da negociação balanceia revelação de informação, que facilita identificação de acordos benéficos, contra risco de exploração por oponente oportunista. Agentes computacionais podem utilizar lógica fuzzy para modelar preferências imprecisas e raciocínio abdutivo para inferir objetivos ocultos de interlocutores.
Protocolos bilaterais alternam ofertas entre duas partes até acordo ou impasse. Protocolos multilaterais coordenam negociações complexas envolvendo múltiplas questões e participantes. Argumentação baseia negociação em justificativas lógicas que podem persuadir mediante força de raciocínio, não apenas concessões monetárias. Sistemas de suporte à negociação assistem humanos sugerindo ofertas ótimas baseadas em modelos de preferência e previsões sobre comportamento adversário.
Partes: Empresa_Compradora e Fornecedor_Matéria_Prima
Questões em Negociação:
1. Preço unitário (R$/kg)
2. Quantidade mínima mensal (kg)
3. Prazo de pagamento (dias)
4. Prazo de entrega (dias)
Preferências do Comprador:
• Prioridade alta: Preço baixo, prazo pagamento longo
• Prioridade média: Entrega rápida
• Prioridade baixa: Quantidade flexível
• BATNA (melhor alternativa): Fornecedor concorrente a R$ 12/kg
Preferências do Fornecedor:
• Prioridade alta: Quantidade grande (economia de escala), pagamento rápido
• Prioridade média: Preço justo
• Prioridade baixa: Prazo de entrega (capacidade logística boa)
• BATNA: Manter clientes atuais com margem 15%
Protocolo: Alternating Offers
Rodada 1:
• Comprador propõe: {preço: R$ 10/kg, qtd: 1000kg, pagamento: 60d, entrega: 5d}
• Fornecedor avalia: Utilidade = 0.35 (abaixo de reserva 0.40)
• Fornecedor rejeita, contra-propõe: {R$ 13/kg, 2000kg, 30d, 10d}
Rodada 2:
• Comprador avalia: Utilidade = 0.28 (muito abaixo de BATNA = 0.50)
• Comprador faz concessão estratégica em questão de baixa prioridade:
Nova oferta: {R$ 11/kg, 1500kg, 45d, 7d}
• Fornecedor avalia: Utilidade = 0.42 (acima de reserva, mas pode melhorar)
Rodada 3:
• Fornecedor identifica: Comprador valoriza muito prazo de pagamento
• Fornecedor está disposto a ceder em prazo entrega (baixo custo para ele)
• Troca integrativa: {R$ 11.5/kg, 1800kg, 40d, 5d}
• Comprador avalia: Utilidade = 0.52 (melhor que BATNA!) ✓
• Fornecedor: Utilidade = 0.48 (aceitável, volume compensa preço) ✓
• ACORDO FECHADO
Análise de Ganhos:
• Comprador: Obteve prazo pagamento bom (40d vs 60d desejado)
• Fornecedor: Volume maior (1800kg) compensa preço ligeiramente menor
• Ambos melhoram vs suas BATNAs (situação win-win)
Teoria dos jogos matematiza interações estratégicas onde resultado para cada agente depende de escolhas conjuntas de todos os participantes. Um jogo especifica-se por conjunto de jogadores, espaços de estratégias disponíveis, e funções de utilidade mapeando perfis de estratégia em payoffs. Jogos simultâneos modelam decisões tomadas sem conhecimento das escolhas alheias, enquanto jogos sequenciais permitem observação de movimentos anteriores antes de agir.
O equilíbrio de Nash caracteriza perfis de estratégia onde nenhum agente pode melhorar unilateralmente mudando sua ação, dado que outros mantêm suas escolhas. Formalmente, (s₁*, s₂*, ..., sₙ*) é equilíbrio de Nash se para todo jogador i e toda estratégia alternativa sᵢ', vale uᵢ(s₁*, ..., sᵢ*, ..., sₙ*) ≥ uᵢ(s₁*, ..., sᵢ', ..., sₙ*). Este conceito captura estabilidade estratégica: em equilíbrio, agentes não têm incentivo para desviar.
Jogos podem ter zero, um ou múltiplos equilíbrios de Nash. O dilema do prisioneiro exemplifica jogo onde equilíbrio único é Pareto-ineficiente - cooperação beneficiaria ambos, mas deserção domina. Jogos de coordenação possuem múltiplos equilíbrios, criando desafio de seleção. Estratégias mistas randomizam sobre ações puras, expandindo conceito de equilíbrio para garantir existência em jogos finitos via teorema de Nash.
Contexto: Dois agentes de IA devem decidir cooperar ou desertar repetidamente.
Payoffs (por rodada):
Agente 2 Coopera Agente 2 Deserta
A1 Coopera (3, 3) (0, 5)
A1 Deserta (5, 0) (1, 1)
One-Shot Game (rodada única):
• Análise de dominância: Desertar domina Cooperar para ambos
- Se A2 coopera: A1 ganha 5 (desertando) vs 3 (cooperando)
- Se A2 deserta: A1 ganha 1 (desertando) vs 0 (cooperando)
• Equilíbrio de Nash: (Desertar, Desertar) com payoff (1, 1)
• Pareto-ineficiente: (Cooperar, Cooperar) dá (3, 3) melhor para ambos!
Jogo Iterado (n rodadas):
• Payoff total = Σ payoff_rodada × δᵗ (δ = fator de desconto)
Estratégias Possíveis:
1. Sempre Desertar (AllD):
- Simples mas gera (1,1) perpetuamente
- Payoff total (n rodadas): n × 1 = n
2. Sempre Cooperar (AllC):
- Vulnerável a exploração
- Se oponente deserta: payoff = n × 0 = 0
3. Tit-for-Tat (TFT):
- Rodada 1: Cooperar
- Rodadas seguintes: Copiar ação anterior do oponente
- Retalha deserção mas perdoa retorno à cooperação
4. Pavlov (Win-Stay, Lose-Shift):
- Se payoff anterior ≥ 3: repete ação
- Se payoff < 3: muda ação
Torneio Axelrod (simulação):
• 100 rodadas, múltiplas estratégias competindo
• Resultados:
- TFT vs TFT: ambos cooperam sempre → 100 × 3 = 300 cada
- TFT vs AllD: TFT coopera na rodada 1 (0), depois deserta sempre (99×1=99) → total 99
- AllD vs TFT: exploita 1 vez (5), depois (99×1=99) → total 104
- TFT vs AllC: TFT coopera sempre (explora ingenuidade?) → 300 ou 500?
Na verdade TFT coopera sempre com AllC → ambos 300
• Vencedor: TFT (robusto contra diversas estratégias)
Emergência de Cooperação:
• Em populações com TFT, cooperação torna-se evolutivamente estável
• Reputação importa: agentes cooperam com cooperadores
• Retaliação desincentiva deserção parasitária
• Shadow of the future: n grande favorece cooperação
Teoria dos jogos modelacomportamento em leilões, formação de coalizões, compartilhamento de recursos em redes, e protocolos de roteamento. Compreender equilíbrios ajuda a projetar mecanismos que induzem comportamentos desejados mesmo com agentes egoístas.
Nem todos os jogos possuem equilíbrios em estratégias puras. O jogo da moeda (matching pennies) exemplifica situação onde cada jogador quer antecipar e divergir ou coincidir com oponente, mas qualquer estratégia determinística pode ser explorada. Estratégias mistas resolvem essa limitação permitindo que agentes randomizem sobre ações puras mediante distribuições de probabilidade, tornando comportamento imprevisível e não-explorável.
O teorema fundamental de Nash estabelece que todo jogo finito possui pelo menos um equilíbrio em estratégias mistas. Formalmente, estratégia mista σᵢ para jogador i é distribuição sobre seu conjunto de ações puras. Equilíbrio em estratégias mistas (σ₁*, σ₂*, ..., σₙ*) satisfaz que utilidade esperada de σᵢ* não é superada por qualquer alternativa σᵢ' dado que outros jogam suas estratégias de equilíbrio. Esta generalização garante existência de solução, fundamentando análise de jogos complexos.
Algoritmos de suporte enumeram suportes possíveis das estratégias mistas, resolvendo sistemas de equações de indiferença que caracterizam equilíbrios. Para jogos pequenos, enumeração é viável. Jogos maiores requerem métodos iterativos como fictitious play, onde agentes respondem otimamente a distribuição empírica de ações históricas adversárias. Convergência não é garantida universalmente, mas ocorre em classes importantes como jogos de potencial e jogos de interesse zero-sum.
Jogadores: Segurança (defensor) vs Adversário (atacante)
Locais: 3 portões {A, B, C} no aeroporto
Estratégias:
• Segurança: Escolher 1 portão para inspeção rigorosa
• Adversário: Escolher 1 portão para tentar ataque
Payoffs para Segurança (Adversário obtém oposto):
Adversário→A Adv→B Adv→C
Seg→A 10 -5 -5
Seg→B -3 12 -3
Seg→C -2 -2 8
• Interpretação: Valor positivo = ataque prevenido, negativo = ataque sucede
• Portão B tem mais tráfego (payoff maior se protegido)
Análise de Estratégias Puras:
• Não existe equilíbrio em estratégias puras!
• Se Seg→A, melhor resposta Adv→B (Seg perde -5)
• Se Seg→B, melhor resposta Adv→A (Seg perde -3)
• Qualquer escolha determinística pode ser antecipada
Equilíbrio em Estratégias Mistas:
• Segurança randomiza: σ_S = (p_A, p_B, p_C) onde p_A + p_B + p_C = 1
• Adversário randomiza: σ_Adv = (q_A, q_B, q_C)
• Condição de equilíbrio: Adversário deve estar indiferente entre alvos
Cálculo (simplificado para 2 portões: A e B):
• Utilidade esperada Adversário atacando A:
U_Adv(A) = -10×p_A + 3×p_B = -10p_A + 3(1-p_A) = 3 - 13p_A
• Utilidade esperada Adversário atacando B:
U_Adv(B) = 5×p_A - 12×p_B = 5p_A - 12(1-p_A) = 17p_A - 12
• Indiferença: 3 - 13p_A = 17p_A - 12
• Resolvendo: 15 = 30p_A → p_A* = 0.5
• Logo: Segurança deve inspecionar A e B com probabilidades iguais!
Interpretação Prática:
• Segurança usa randomização para ser imprevisível
• Adversário não pode explorar padrão
• Sistema de sorteio diário determina portão inspecionado
• Utilidade esperada de equilíbrio: U_Seg = 1.5 (valor do jogo)
Implementação Computacional:
• Algoritmo de suporte enumera combinações
• Para 3 portões: Resolve sistema 3×3 de equações
• Software de teoria dos jogos (Gambit) automatiza cálculo
Em populações de agentes que jogam repetidamente, estratégias evolutivamente estáveis (ESS) resistem a invasão por mutantes. Uma ESS é equilíbrio de Nash refinado que não apenas maximiza contra si mesmo, mas também contra pequenas perturbações, modelando dinâmicas evolutivas onde estratégias bem-sucedidas proliferam.
Design de mecanismos inverte teoria dos jogos clássica: em vez de analisar equilíbrios de jogos dados, projeta-se regras de interação que induzem comportamentos desejados mesmo quando agentes são egoístas. Um mecanismo especifica como agentes reportam informação privada (tipos, valorações, custos) e como essas mensagens determinam alocações e transferências monetárias. O desafio central é garantir que verdade seja estratégia dominante - revelação honesta maximiza utilidade individual.
O princípio da revelação estabelece que qualquer equilíbrio de qualquer mecanismo pode ser implementado por mecanismo direto onde agentes simplesmente reportam tipos verdadeiros. Isto justifica restrição de atenção a mecanismos incentivo-compatíveis (IC) onde verdade domina. Mecanismos individualmente racionais (IR) adicionalmente garantem que participação voluntária nunca reduz utilidade abaixo de não participar, assegurando engajamento dos agentes.
O teorema de Myerson-Satterthwaite estabelece limite fundamental: em negociações bilaterais com informação privada sobre valorações, não existe mecanismo eficiente que seja simultaneamente IC, IR e equilibrado (não requer subsídios externos). Este resultado negativo delimita o possível, mas mecanismos aproximadamente eficientes existem, sacrificando levemente eficiência para alcançar outras propriedades desejáveis como simplicidade ou robustez.
Problema: Governo aloca faixas de frequência para operadoras de telecomunicações.
Participantes: n = 4 operadoras {Op₁, Op₂, Op₃, Op₄}
Item: Licença de espectro em região metropolitana
Valorações privadas:
• v₁ = R$ 500 milhões (valor que Op₁ atribui internamente)
• v₂ = R$ 450 milhões
• v₃ = R$ 600 milhões
• v₄ = R$ 400 milhões
• Operadoras conhecem suas próprias valorações, mas não as alheias
Mecanismo VCG (Vickrey-Clarke-Groves):
Passo 1 - Coleta de Lances:
• Cada operadora reporta lance bᵢ (pode mentir sobre vᵢ)
• Op₁ reporta: b₁ = 500
• Op₂ reporta: b₂ = 450
• Op₃ reporta: b₃ = 600
• Op₄ reporta: b₄ = 400
Passo 2 - Alocação:
• Licença alocada para maior lance: Op₃ (b₃ = 600)
Passo 3 - Pagamento VCG:
• Pagamento de Op₃: "Dano externo" que Op₃ causa aos outros
• Sem Op₃: Melhor resultado para outros seria Op₁ ganhando (valor social = 500)
• Com Op₃: Outros não ganham (valor social para eles = 0)
• Dano = 500 - 0 = R$ 500 milhões
• Op₃ paga R$ 500 milhões (não seus próprios 600!)
Análise de Incentivos:
• Utilidade de Op₃: v₃ - pagamento = 600 - 500 = R$ 100 milhões
• Se Op₃ mentisse dizendo b₃ = 550:
- Ainda ganharia (550 > 500)
- Pagamento: ainda 500 (dano aos outros não muda)
- Utilidade: 600 - 500 = 100 (igual!)
• Se Op₃ mentisse dizendo b₃ = 480:
- Perderia para Op₁ (480 < 500)
- Utilidade: 0 (pior que 100)
• Conclusão: Reportar verdade (b₃ = v₃ = 600) é ótimo!
Propriedades do Mecanismo VCG:
✓ Incentivo-compatível: Verdade é estratégia dominante
✓ Eficiente: Licença vai para quem mais valoriza (Op₃)
✓ Individualmente racional: Vencedor tem utilidade positiva
✗ Não equilibrado: Governo arrecada 500, mas valor social é 600
(100 milhões de "excedente" não capturado - custo da IC)
Aplicações Práticas:
• Leilões de espectro em diversos países
• Alocação de slots de pouso em aeroportos
• Publicidade online (leilões de segundo preço no Google Ads)
Negociação baseada em argumentação transcende troca de ofertas numéricas, incorporando justificativas lógicas que podem persuadir mediante força de raciocínio. Agentes apresentam argumentos estruturados que suportam suas posições, atacam argumentos contrários mediante contra-argumentos, e defendem suas propostas contra objeções. Frameworks de argumentação abstrata modelam relações de ataque entre argumentos, determinando quais conjuntos de argumentos são coletivamente defensáveis.
Semânticas de aceitabilidade definem quando argumento é justificado. Um conjunto de argumentos é livre de conflito se nenhum ataca outro no conjunto. É defensor se ataca todo argumento que ataque algum de seus membros. Extensões preferred são conjuntos maximais que são simultaneamente livres de conflito e defensores, representando posições racionalmente sustentáveis no debate. Múltiplas extensões indicam ambiguidade onde diferentes conclusões são igualmente defensáveis.
Protocolos de diálogo regulam turnos de fala, tipos de movimentos permitidos (claim, question, challenge, retract), e condições de terminação. Jogos de diálogo adversariais modelam debates competitivos onde proponente tenta estabelecer tese enquanto oponente busca refutá-la. Jogos colaborativos exploram espaço de argumentos conjuntamente, buscando consenso mediante identificação de premissas compartilhadas e resolução de desacordos sobre fatos ou inferências.
Contexto: Empresa contrata freelancer para projeto de software.
Questão em disputa: Prazo de entrega
Agente Empresa (E):
• Posição: Prazo deve ser 2 meses
• Argumento A₁: "Projeto é crítico para lançamento de produto em setembro"
- Premissa: Lançamento_setembro = verdadeiro
- Premissa: Desenvolvimento_produto requer sistema_pronto
- Conclusão: Sistema deve estar pronto até agosto (2 meses)
Agente Freelancer (F):
• Posição: Prazo deve ser 3 meses
• Contra-argumento B₁ (ataca A₁):
"Projeto tem escopo complexo que realisticamente requer 3 meses"
- Premissa: Escopo inclui 15 módulos + testes + integração
- Premissa: Histórico mostra projetos similares levam 80-90 dias
- Conclusão: 2 meses resultaria em código de baixa qualidade
Diálogo de Argumentação:
Rodada 1:
• E: PROPOSE(prazo=2meses, justificativa=A₁)
• F: CHALLENGE(A₁, baseado_em=B₁)
Rodada 2:
• E: QUESTION("Por que afirma que requer 3 meses?")
• F: PROVIDE_EVIDENCE(dados_históricos_projetos_similares)
• E: ACCEPT_FACT(evidência_histórica)
Rodada 3:
• E: ARGUE_ALTERNATIVE(A₂): "E se aumentarmos orçamento para contratar assistente?"
- Premissa: Dois desenvolvedores podem paralelizar trabalho
- Conclusão: Prazo de 2 meses torna-se viável
• F: EVALUATE(A₂): "Aumento de orçamento em quanto?"
Rodada 4:
• E: SPECIFY(aumento=40%)
• F: ACCEPT_CONDITIONALLY("40% não cobre assistente qualificado")
• F: COUNTER_PROPOSE(aumento=60%, prazo=2.5meses)
Rodada 5:
• E: ARGUE(A₃): "2.5 meses ainda arrisca lançamento setembro"
• F: COMPROMISE(A₄): "E se comprometer entregas parciais?"
- Milestone M₁ (funcionalidade core): 1.5 meses
- Milestone M₂ (funcionalidades secundárias): 2.5 meses
- Conclusão: Lançamento mínimo viável em setembro, completo em outubro
Rodada 6:
• E: ACCEPT(proposta=A₄, "Mitigates risco enquanto permite lançamento")
• F: CONFIRM(acordo_final)
Contrato Final:
• Prazo: 2.5 meses com milestone intermediário em 1.5 meses
• Orçamento: Valor original + 50% (negociado entre 40-60%)
• Qualidade: Ambos satisfeitos (evita rush, permite lançamento)
Análise:
• Argumentação revelou preferências subjacentes (qualidade vs velocidade)
• Solução integrativa encontrada (milestones) não considerada inicialmente
• Persuasão via evidências objetivas (dados históricos) mais efetiva que posições obstinadas
Teoria da escolha social estuda agregação de preferências individuais em decisões coletivas. Sistemas de votação implementam funções que mapeiam perfis de preferências de agentes em rankings sociais ou alternativas vencedoras. Desideratos como universalidade (funciona para quaisquer preferências), unanimidade (se todos preferem x a y, socialmente x prevalece), e independência de alternativas irrelevantes (relação social entre x e y depende apenas de preferências entre x e y) parecem naturais.
O teorema da impossibilidade de Arrow demonstra que nenhuma função de escolha social satisfaz simultaneamente esses critérios razoáveis quando há pelo menos três alternativas, exceto ditadura onde preferências de um único agente determinam resultado social. Este resultado fundamental estabelece trade-offs inevitáveis em design de mecanismos de agregação, forçando relaxamento de algum requisito ou aceitação de regras imperfeitas.
Regras de votação práticas sacrificam diferentes propriedades. Pluralidade (maioria simples) é simples mas ignora intensidades de preferência. Borda conta rankings completos mas é vulnerável a manipulação estratégica. Condorcet elege alternativa que venceria qualquer outra em comparações pareadas, mas ciclos podem existir onde A vence B, B vence C, e C vence A, impossibilitando escolha coerente. Approval voting permite votar em múltiplas alternativas aprovadas, mitigando alguns problemas mas introduzindo outros.
Cenário: Equipe de 5 desenvolvedores escolhe framework para projeto.
Alternativas: {React, Vue, Angular}
Preferências dos Agentes:
• Dev₁: React > Vue > Angular (prefere React, depois Vue, por último Angular)
• Dev₂: React > Angular > Vue
• Dev₃: Vue > React > Angular
• Dev₄: Angular > Vue > React
• Dev₅: Vue > Angular > React
Regra 1: Pluralidade (maioria simples de primeiros lugares):
• React: 2 votos (Dev₁, Dev₂)
• Vue: 2 votos (Dev₃, Dev₅)
• Angular: 1 voto (Dev₄)
• Empate entre React e Vue! Desambiguação necessária
Regra 2: Contagem de Borda (3 pontos=1º, 2=2º, 1=3º):
• React: 3+3+2+1+1 = 10 pontos
• Vue: 2+1+3+2+3 = 11 pontos ← Vencedor Borda
• Angular: 1+2+1+3+2 = 9 pontos
Regra 3: Condorcet (comparações pareadas):
• React vs Vue:
- Preferem React>Vue: Dev₁, Dev₂ (2 agentes)
- Preferem Vue>React: Dev₃, Dev₄, Dev₅ (3 agentes)
- Vencedor: Vue
• Vue vs Angular:
- Preferem Vue>Angular: Dev₁, Dev₃, Dev₅ (3 agentes)
- Preferem Angular>Vue: Dev₂, Dev₄ (2 agentes)
- Vencedor: Vue
• React vs Angular:
- Preferem React>Angular: Dev₁, Dev₂, Dev₃ (3 agentes)
- Preferem Angular>React: Dev₄, Dev₅ (2 agentes)
- Vencedor: React
• Condorcet winner: Vue (vence todas comparações pareadas)
Regra 4: Approval Voting (cada dev aprova quantos quiser):
• Dev₁ aprova: React, Vue
• Dev₂ aprova: React
• Dev₃ aprova: Vue, React
• Dev₄ aprova: Angular, Vue
• Dev₅ aprova: Vue, Angular
• Contagem: React=4, Vue=5, Angular=3
• Vencedor: Vue
Análise:
• Pluralidade: Indecisivo (empate)
• Borda, Condorcet, Approval: Todas elegem Vue
• Vue é escolha robusta (vence sob múltiplos critérios)
• React tem suporte polarizado (amado por alguns, rejeitado por outros)
Manipulação Estratégica:
• Se Dev₂ soubesse que empate em pluralidade iria para Vue
• Poderia votar estrategicamente em Angular (rebaixar Vue)
• Mas isso arriscaria Angular vencer!
• Teorema Gibbard-Satterthwaite: Toda regra não-ditatorial é manipulável
Para decisões importantes com preferências heterogêneas, use Condorcet quando possível (identifica vencedor consensual). Para decisões rápidas, pluralidade é simples. Para capturar intensidades, Borda ou quadratic voting (agentes distribuem pontos com custo quadrático) são superiores.
Planejamento multi-agente enfrenta complexidade combinatória quando múltiplos agentes devem coordenar ações em ambientes dinâmicos. Decomposição hierárquica divide problemas complexos em subproblemas mais simples que podem ser resolvidos independentemente ou com mínima coordenação. Redes de tarefas hierárquicas (HTN) representam conhecimento procedural mediante métodos que especificam como tarefas abstratas decompõem-se em subtarefas mais concretas até alcançar ações primitivas executáveis.
Planejamento centralizado computa planos para todos os agentes simultaneamente, garantindo otimalidade global mas sofrendo com escalabilidade exponencial no número de agentes. Planejamento distribuído delega responsabilidade a agentes individuais que planejam localmente, comunicando-se para resolver conflitos e dependências. Abordagens híbridas balanceiam centralização para decisões estratégicas críticas com autonomia local para execução tática, explorando estrutura modular de problemas reais.
Sincronização de planos assegura que ações de diferentes agentes coordenam-se temporalmente quando necessário. Restrições de precedência especificam que ação A deve completar antes que B inicie. Restrições de simultaneidade exigem que ações sejam executadas concorrentemente. Algoritmos de satisfação de restrições temporais verificam consistência de planos anotados com janelas de tempo, detectando conflitos que demandam replanejamento ou negociação entre agentes para relaxamento de requisitos.
Missão: 3 robôs resgatam vítimas em prédio com incêndio.
Tarefa de Alto Nível:
• Resgatar_Vítimas(prédio, {v₁, v₂, v₃})
Decomposição Hierárquica:
Método M₁ para Resgatar_Vítimas:
• Subtarefas:
1. Explorar_e_Localizar(vítimas)
2. Priorizar(vítimas → ordem_resgate)
3. Alocar_Tarefas(robôs, vítimas_priorizadas)
4. ExecutarResgates_Paralelo()
5. Evacuar_para_Segurança()
Decomposição de Explorar_e_Localizar:
Método M₂:
• Subtarefas:
- Dividir_Área_Busca(prédio → {zona₁, zona₂, zona₃})
- Para cada robô_i:
· Navegar_para(zona_i)
· Escanear_Sensores(zona_i)
· Reportar_Vítimas_Encontradas()
Decomposição de Priorizar:
Método M₃:
• Calcular_Criticidade(vítima_i):
- Score = (sinais_vitais × 0.4) + (proximidade_fogo × 0.3) +
(acessibilidade × 0.2) + (tempo_descoberta × 0.1)
• Ordenar_por_Score_Decrescente()
Plano Concreto Gerado:
Fase 1 - Exploração (paralela):
• t=0-5min:
- Robô_A: Escanear zona_térreo
- Robô_B: Escanear zona_primeiro_andar
- Robô_C: Escanear zona_segundo_andar
Fase 2 - Priorização (centralizada):
• t=5min: Agregação de dados
- v₁: Score 0.95 (crítico, térreo)
- v₂: Score 0.72 (moderado, 1º andar)
- v₃: Score 0.58 (estável, 2º andar)
Fase 3 - Alocação e Execução:
• Alocação ótima:
- Robô_A → v₁ (já está no térreo, vítima crítica)
- Robô_B → v₂ (já está no 1º andar)
- Robô_C → v₃ (já está no 2º andar)
• t=6-12min: Resgates paralelos
Coordenação e Sincronização:
• Restrição: Robô_A deve resgatar v₁ ANTES de Robô_C descer
(v₁ bloqueia escada de acesso)
• Solução: Robô_C aguarda sinal(robô_A_liberou_escada)
• t=9min: Robô_A completa, sinaliza
• t=9min: Robô_C inicia descida com v₃
Replanejamento Dinâmico:
• t=8min: Novo incêndio detectado bloqueando rota de Robô_B
• Falha: Plano original de Robô_B inviável
• Replanejamento:
- Robô_B: Procurar rota_alternativa()
- Encontra janela lateral para evacuação
- Atualiza plano: evacuar_por_janela() em vez de escada
• t=13min: Todos resgatados com sucesso!
Ambientes parcialmente observáveis exigem que agentes mantenham crenças sobre estados ocultos baseando decisões em distribuições de probabilidade sobre possibilidades. Processos de Decisão de Markov Parcialmente Observáveis (POMDPs) formalizam este cenário mediante tupla (S, A, T, R, Ω, O) onde S são estados, A ações, T função de transição, R função de recompensa, Ω observações, e O função de observação mapeando estados em distribuições sobre observações percebíveis.
Estados de crença resumem conhecimento do agente como distribuição de probabilidade b ∈ ∆(S) sobre espaço de estados. Após executar ação a e observar o, estado de crença atualiza-se via filtro Bayesiano: b'(s') ∝ O(o|s')Σₛ T(s'|s,a)b(s). Políticas ótimas mapeiam estados de crença em ações, maximizando recompensa esperada considerando incerteza. Solving POMDPs exatamente é PSPACE-completo, motivando aproximações mediante amostragem de partículas ou compressão de espaço de crenças.
Em contextos multi-agente, observabilidade parcial complica coordenação pois agentes possuem informação privada sobre estados locais. DEC-POMDPs (Decentralized POMDPs) generalizam para múltiplos agentes sem comunicação, onde cada agente mantém crença própria e escolhe ações baseadas em histórico local de observações e ações. Encontrar políticas ótimas é NEXP-completo, mas comunicação seletiva e hierarquias podem tornar problemas tratáveis mediante decomposição estruturada.
Cenário: 2 robôs patrulham armazém, detectando intrusos com sensores imperfeitos.
Estados:
• S = posições dos robôs × presença_intruso × localização_intruso
• Exemplo: s = (robô₁_zona_A, robô₂_zona_C, intruso_presente, intruso_zona_B)
Observações Parciais:
• Robô₁ tem sensor de movimento: detecta movimento em zonas adjacentes
• Sensor ruidoso: P(detecta | intruso_presente) = 0.85 (taxa verdadeiro positivo)
P(detecta | sem_intruso) = 0.15 (falso positivo)
• Robô₂ tem câmera: vê apenas sua zona atual
P(vê_intruso | intruso_mesma_zona) = 0.95
P(vê_intruso | intruso_outra_zona) = 0.0
Raciocínio com Incerteza:
• t=0: Crença inicial uniforme (sem informação)
b₀(intruso_zona_A) = b₀(intruso_zona_B) = b₀(intruso_zona_C) = 1/3
• t=1: Robô₁ em zona_A detecta movimento em zona_B
- Aplicar filtro Bayesiano:
b₁(intruso_zona_B) = P(obs|zona_B) × b₀(zona_B) / Z
= 0.85 × (1/3) / Z ≈ 0.73 (após normalização)
b₁(intruso_zona_A) ≈ 0.13
b₁(intruso_zona_C) ≈ 0.13
• Conclusão: Provavelmente intruso está na zona_B
Decisão sob Incerteza:
• Robô₁ deve ir para zona_B investigar?
- Utilidade esperada de ir_B: 0.73 × R(capturar) - custo_movimento
- Utilidade de continuar patrulhando: E[R(patrulha)]
- Se R(capturar) >> custo: Ação ótima é ir_B
Coordenação com Robô₂:
• Robô₁ envia mensagem: "Suspeita zona_B, investigando"
• Robô₂ atualiza sua crença e plano:
- Como Robô₁ cobre zona_B, Robô₂ foca em zona_C
- Coordenação implícita via comunicação de intenções
t=3: Confirmação Visual:
• Robô₁ chega zona_B, não vê intruso (câmera própria)
• Atualização: b₃(intruso_zona_B | não_visto) ≈ 0.05
(intruso pode ter se movido enquanto Robô₁ se deslocava)
• Nova crença distribuída: b₃(zona_A) ≈ 0.35, b₃(zona_C) ≈ 0.60
• Replanejamento: Robô₁ vai para zona_C (maior probabilidade)
Lições:
• Sensores imperfeitos exigem raciocínio probabilístico
• Ações coletam informação (value of information)
• Comunicação reduz incerteza sobre estados globais
• Políticas reativas puras falham - necessário manter crenças
Em DEC-POMDPs, comunicação pode ser modelada como ação especial que consome recursos mas reduz incerteza entre agentes. Trade-off entre custo de comunicação e benefício de coordenação melhorada. Políticas ótimas comunicam seletivamente quando valor de informação excede custo.
Planejamento realista deve considerar limitações de recursos como tempo, energia, memória computacional, orçamento financeiro e capacidade de comunicação. Recursos consumíveis esgotam-se com uso (combustível, bateria) enquanto recursos reutilizáveis ocupam-se temporariamente mas podem ser liberados (salas de reunião, processadores). Recursos podem ser discretos (número de robôs disponíveis) ou contínuos (litros de combustível), demandando técnicas distintas de modelagem e otimização.
Problemas de satisfação de restrições temporais (TCSP) estendem planejamento clássico com janelas de tempo e durações. Cada ação possui duração mínima e máxima, e restrições especificam intervalos válidos entre eventos. Algoritmos de propagação de restrições deduzem implicações transitivas, detectando inconsistências antes de busca completa. Simple Temporal Networks (STN) admitem verificação de consistência em tempo polinomial via algoritmo de Floyd-Warshall adaptado.
Scheduling multi-agente aloca recursos compartilhados a tarefas concorrentes minimizando makespan (tempo total) ou flowtime (tempo médio de conclusão). Técnicas de programação inteira mista modelam decisões de alocação como variáveis binárias e otimizam mediante solvers como CPLEX ou Gurobi. Para problemas dinâmicos, re-scheduling incremental ajusta planos existentes minimizando perturbações em vez de replanejar do zero, preservando estabilidade operacional.
Cenário: Fábrica com 3 robôs montam produtos usando recursos compartilhados.
Produtos a Fabricar:
• Produto_A: requer 2 horas de montagem, usa estação_solda
• Produto_B: requer 3 horas, usa estação_pintura
• Produto_C: requer 1.5 horas, usa estação_solda e estação_pintura
Recursos Compartilhados:
• Estação_Solda: capacidade 1 (uso exclusivo)
• Estação_Pintura: capacidade 1
• Robôs: R₁, R₂, R₃ (podem trabalhar em paralelo)
Demanda: 2 unidades de A, 1 de B, 2 de C (total: 5 produtos)
Modelagem Temporal:
• Variáveis de decisão:
- tᵢⱼ = tempo de início da tarefa i por robô j
- xᵢⱼ ∈ {0,1} = 1 se robô j executa tarefa i
Restrições:
1. Cada tarefa atribuída a exatamente um robô:
Σⱼ xᵢⱼ = 1, ∀i
2. Recursos exclusivos não se sobrepõem:
Se tarefas i e k usam mesmo recurso:
tᵢ + dᵢ ≤ tₖ OU tₖ + dₖ ≤ tᵢ
3. Robô executa uma tarefa por vez:
Para tarefas i,k do mesmo robô j:
tᵢ + dᵢ ≤ tₖ OU tₖ + dₖ ≤ tᵢ
Objetivo: Minimizar makespan = max(tᵢ + dᵢ)
Solução Ótima (via solver):
Alocação:
• Robô_R₁: Produto_A₁ (0h-2h), Produto_C₁ (2h-3.5h)
• Robô_R₂: Produto_A₂ (0h-2h), Produto_C₂ (3.5h-5h)
- C₂ aguarda C₁ liberar estação_solda
• Robô_R₃: Produto_B (0h-3h)
Timeline Detalhado:
Tempo | R₁ Ação | R₂ Ação | R₃ Ação | Recursos
------|----------------|----------------|-----------------|----------
0-2h | A₁ (solda) | A₂ (solda) | B (pintura) | Conflito!
• Problema detectado: A₁ e A₂ conflitam na estação_solda!
Re-scheduling:
0-2h | A₁ (solda) | Aguarda | B (pintura) | OK
2-3h | C₁ (solda) | A₂ (solda) | - | Conflito!
| espera pintura | | |
Solução Final Otimizada:
0-2h | A₁ (solda) | Aguarda | B (pintura) | ✓
2-4h | Aguarda | A₂ (solda) | Aguarda | ✓
3-4.5h| C₁ (pintura) | continua A₂ | - | ✓
4-5.5h| continua C₁ | C₂ (solda) | - | ✓
| (solda) | | |
5.5-7h| - | C₂ (pintura) | - | ✓
Resultado:
• Makespan: 7 horas (tempo total)
• Utilização de recursos:
- Estação_solda: 6h ativas / 7h = 85.7%
- Estação_pintura: 5.5h / 7h = 78.6%
- Robôs: R₁=64%, R₂=71%, R₃=43%
Adaptação Dinâmica:
• Se Robô_R₁ falhar em t=3h:
- Tarefa C₁ incompleta (50% concluída)
- Re-alocar para R₃ (ocioso após B)
- C₁ continua em t=3h por R₃
- Makespan aumenta para 7.5h (degradação graceful)
Use bibliotecas como OR-Tools (Google) ou OptaPlanner para modelar problemas de scheduling complexos. Para sistemas críticos, valide planos mediante simulação antes de execução. Mantenha planos de contingência para falhas de recursos previsíveis.
Planejamento temporal contínuo lida com ações que possuem duração e cujos efeitos manifestam-se gradualmente ao longo do tempo. Diferentemente de planejamento clássico onde ações são instantâneas, sistemas temporais modelam processos que iniciam, progridem e terminam em momentos distintos. PDDL2.1 (Planning Domain Definition Language) estende PDDL clássico com ações durativas que especificam condições que devem valer no início, durante, e ao fim da execução.
Efeitos contínuos modelam quantidades que variam linearmente como consumo de combustível proporcional à distância percorrida ou enchimento de tanque a taxa constante. Funções numéricas representam valores contínuos e permitem expressões aritméticas em precondições e efeitos. Planejadores como COLIN e POPF compilam problemas temporais em sucessões de estados discretos com timestamps, resolvendo mediante busca heurística informada por relaxamento de recursos.
Execução e monitoramento fecham loop entre planejamento e ação. Enquanto agentes executam planos, sensores detectam desvios de previsões e gatilhos acionam replanejamento. Arquiteturas sense-plan-act clássicas sofrem com latência excessiva; sistemas modernos adotam camadas reativas que respondem rapidamente a anomalias enquanto camadas deliberativas replanejam assincronamente, atualizando planos executados sem interrupções bruscas.
Cenário: 3 satélites coordenam observação astronômica de nebulosa.
Agentes:
• Satélite_A: telescópio óptico
• Satélite_B: espectrógrafo infravermelho
• Satélite_C: detector de raios-X
Restrições Temporais:
• Janela de observação: Nebulosa visível das 02:00 às 05:00 UTC
• Cada satélite precisa reorientar antenas (5min) antes de observação
• Observação simultânea requerida para correlação de dados
• Transmissão de dados: apenas quando sobre estação terrestre
Recursos Contínuos:
• Bateria de cada satélite: 100% inicial
- Reorientação: consome 2%
- Observação: consome 0.5%/min
- Transmissão: consome 3%/min
- Modo inativo: consome 0.1%/min
- Recarga solar: +1%/min (quando iluminado)
Plano Temporal Coordenado:
Fase 1 - Preparação (01:45-02:00):
• 01:45: Todos iniciam reorientação (paralelo)
- Duração: 5 minutos cada
- Consumo: 2% bateria cada
• 01:50: Reorientações concluídas
- Estado bateria: A=98%, B=98%, C=98%
• 01:50-02:00: Calibração de instrumentos (10min)
- Consumo inativo: 0.1%/min × 10min = 1%
- Bateria ao iniciar observação: ~97%
Fase 2 - Observação Coordenada (02:00-04:30):
• Sincronização crítica: ±30 segundos entre satélites
• 02:00:00: Início simultâneo
- Sat_A captura imagens ópticas (exposição 30s cada)
- Sat_B coleta espectros IR (varredura contínua)
- Sat_C monitora emissões raios-X (integração 5min)
• Duração total: 150 minutos
• Consumo: 0.5%/min × 150min = 75%
• Estado bateria ao fim: ~22% (crítico!)
Fase 3 - Recarga e Transmissão (04:30-06:00):
• 04:30: Satélites entram em zona iluminada pelo Sol
- Recarga: +1%/min
- Período: 90 minutos
- Bateria recupera para ~97%
• 05:15: Satélite_A passa sobre estação terrestre Brasil
- Janela de comunicação: 12 minutos
- Transmite dados (1.2 GB) a 10 Mbps
- Consumo transmissão: 3%/min × 12min = 36%
• 05:45: Satélites B e C transmitem para estação Europa
Replanejamento Dinâmico:
• 03:15: Satélite_B detecta anomalia no espectrógrafo
- Sensibilidade reduzida em 40%
- Plano original: observação até 04:30
Decisão Autônoma de B:
• Opção 1: Continuar com dados degradados
- Mantém coordenação, mas qualidade comprometida
• Opção 2: Estender observação para compensar
- Requer +60min (até bateria crítica em 15%)
- Melhor qualidade científica
• Opção 3: Abortar e aguardar próxima janela (amanhã)
Negociação Multi-Agente:
• Sat_B → {Sat_A, Sat_C}: PROPOSE(estender_observação, +60min)
• Sat_A: ACCEPT (bateria suficiente, 22% > 15% mínimo)
• Sat_C: CHALLENGE ("Minha bateria chegará em 10%, arriscado")
• Sat_B: ARGUE("Qualidade científica aumenta 80% com dados completos")
• Coordenador_Terrestre consulta prioridades de missão
• Decisão: APPROVE(extensão até 05:30, monitorar baterias)
Execução Adaptada:
• 05:30: Observação estendida concluída
- Sat_A: 15% bateria
- Sat_B: 12% bateria
- Sat_C: 9% bateria (crítico)
• Todos entram em modo economia até recarga completa
• Transmissão adiada para próximo ciclo (não emergencial)
• Missão científica: Sucesso! Dados de alta qualidade coletados.
Planejamento contingente gera planos que incluem pontos de decisão condicionais onde ações futuras dependem de observações realizadas durante execução. Em vez de sequência linear de ações, plano contingente estrutura-se como árvore ou grafo dirigido onde ramos representam diferentes contingências baseadas em resultados de ações anteriores ou sensoriamento. Esta flexibilidade permite resposta adaptativa a incertezas sem replanejamento completo.
Políticas generalizam planos contingentes mapeando estados observáveis em ações, definindo comportamento para todas as contingências possíveis. Políticas universais garantem alcance de objetivo independentemente de não-determinismo do ambiente, enquanto políticas parciais cobrem apenas subconjunto de estados esperados, falhando em situações inesperadas. Síntese automática de políticas utiliza técnicas de model checking para verificar que política satisfaz especificação formal expressa em lógica temporal.
Planejamento online interleave planejamento e execução, alternando entre deliberação que antecipa futuro e ação que progride em direção a objetivos. Agentes mantêm planos parciais refinados incrementalmente conforme informação adicional torna-se disponível. Anytime planning produz soluções progressivamente melhores que podem ser interrompidas quando deadline aproxima-se, garantindo solução utilizável mesmo sob restrições temporais estritas.
Missão: 2 robôs exploram caverna desconhecida buscando artefatos arqueológicos.
Incertezas:
• Topologia da caverna desconhecida (ramificações, becos sem saída)
• Localização de artefatos incerta
• Estabilidade estrutural imprevisível (risco de desabamento)
• Comunicação entre robôs falha em túneis profundos
Plano Contingente (estrutura de árvore):
Estado Inicial [S₀]:
• Ambos robôs na entrada da caverna
• Bateria: 100% cada
• Mapa: vazio
Ação 1: Avançar_juntos(profundidade=50m)
Ponto de Observação [O₁]: Escanear ambiente
Contingência 1.1: Se detectar_bifurcação:
→ Ação: Dividir_equipe
- Robô₁: explorar_túnel_esquerdo
- Robô₂: explorar_túnel_direito
→ Regra de Coordenação: Reunir em ponto_encontro após 20min
Contingência 1.2: Se detectar_túnel_único:
→ Ação: Continuar_juntos(+30m)
→ Repeat O₁
Contingência 1.3: Se detectar_instabilidade_estrutural:
→ Ação: Retornar_imediatamente
→ Marcar área como perigosa no mapa compartilhado
Durante Exploração Separada:
Ponto de Observação [O₂] para Robô₁:
Contingência 2.1: Se encontrar_artefato:
→ Ação: Fotografar, registrar coordenadas GPS
→ Tentar comunicar_Robô₂ (se sinal disponível)
→ Se artefato_pequeno: coletar
→ Se artefato_grande: marcar localização, continuar
Contingência 2.2: Se bateria < 30%:
→ Ação: Iniciar_retorno_para_entrada
→ Notificar_Robô₂: "Bateria baixa, retornando"
Contingência 2.3: Se perder_comunicação > 10min:
→ Ação: Retornar_ao_último_ponto_comunicação
→ Aguardar_sinal_Robô₂(timeout=5min)
→ Se timeout: Retornar_entrada_sozinho (protocolo de segurança)
Execução Real (Cenário):
• 10min: Bifurcação detectada → Executam Contingência 1.1 (divisão)
• 15min: Robô₁ encontra artefato (cerâmica) → Contingência 2.1
- Fotografa, coleta amostra pequena
- Tenta comunicar Robô₂: Falha (túnel profundo)
• 18min: Robô₂ detecta instabilidade (tremores) → Contingência 1.3
- Inicia retorno imediato
- Não consegue alertar Robô₁ (sem comunicação)
• 22min: Robô₁ no ponto de encontro, Robô₂ ausente
- Aguarda conforme protocolo
• 27min: Timeout aguardando Robô₂ → Contingência 2.3
- Robô₁ decide retornar à entrada
• 30min: Ambos na entrada (encontro bem-sucedido!)
- Compartilham dados: Robô₁ encontrou artefato, Robô₂ detectou perigo
- Atualizam mapa colaborativo com informações de ambos
Política Aprendida para Futuras Missões:
• SE profundidade > 50m E sem_comunicação:
→ Timeout_reunião deve ser 30min (não 20min)
• SE detectar_tremores:
→ Prioridade máxima de comunicação (usar rádio de emergência)
• SE artefato_encontrado E parceiro_incomunicável:
→ Marcar localização com beacon físico (além de GPS)
Verificar formalmente que política é completa (cobre todos os estados alcançáveis) evita falhas catastróficas. Use model checking temporal (CTL/LTL) para provar propriedades como "sempre eventualmente retorna à base com segurança" sob todas as contingências modeladas.
Meta-raciocínio refere-se à capacidade de agentes de raciocinar sobre seus próprios processos de raciocínio, decidindo quando continuar deliberando versus agir com informação disponível. Sob restrições de tempo e recursos computacionais, agentes devem balancear qualidade de decisões com velocidade de resposta. Deliberação excessiva desperdiça tempo precioso, enquanto ação prematura leva a escolhas subótimas. Modelos de utilidade esperada de computação quantificam valor de raciocínio adicional versus custo de oportunidade de ação atrasada.
Agentes bounded-optimal maximizam utilidade esperada sujeitos a restrições computacionais, diferindo de agentes ótimos que assumem recursos ilimitados. Arquiteturas anytime permitem interrupção de algoritmos a qualquer momento, retornando melhor solução encontrada até então. Perfis de performance mapeiam tempo investido em qualidade de solução, permitindo que agentes decidam racionalmente quando parar de deliberar baseado em trade-offs específicos do contexto.
Scheduling de processos mentais aloca ciclos de CPU entre múltiplos processos cognitivos concorrentes - percepção, planejamento, aprendizado, comunicação. Prioridades dinâmicas ajustam-se conforme urgência de decisões e valor esperado de refinamentos. Monitoramento metacognitivo detecta quando raciocínio desvia-se produtivamente, redirecionando atenção para subproblemas mais promissores, emulando flexibilidade cognitiva humana que alterna fluidamente entre diferentes níveis de abstração.
Contexto: Agente negocia contrato com deadline de 5 minutos.
Processos Cognitivos Competindo por CPU:
1. Modelar_Oponente: Inferir preferências do adversário (100s CPU estimado)
2. Otimizar_Oferta: Calcular proposta ótima dada modelo (50s CPU)
3. Avaliar_Contra_Oferta: Analisar proposta recebida (10s CPU)
4. Gerar_Argumento: Criar justificativa persuasiva (30s CPU)
Situação em t=0 (início):
• Tempo disponível: 300 segundos
• Modelo oponente: incerto (distribuição uniforme sobre tipos)
• Oferta inicial preparada (subótima, mas rápida)
Decisão Meta-Raciocínio:
• Utilidade esperada de Modelar_Oponente por 100s:
EU(modelar) = P(modelo_melhora) × ganho_esperado - custo_tempo
= 0.7 × R$ 50.000 - (100s/300s × valor_tempo)
= R$ 35.000 - R$ 10.000 = R$ 25.000
• Utilidade de Propor_Imediatamente (sem modelagem):
EU(imediato) = R$ 80.000 (valor médio, sem otimização)
• Utilidade de Modelar+Otimizar_Então_Propor:
EU(elaborado) = R$ 110.000 (ganho por proposta melhor)
- R$ 15.000 (custo de 150s de 300s)
= R$ 95.000
• Decisão: Investir em modelagem+otimização (maximiza EU)
Execução com Monitoramento:
• t=0-60s: Processo Modelar_Oponente executando
- Progresso: 60%
- Meta-avaliação em t=60s: "Modelo convergindo para tipo conservador"
- Decisão: Continuar (incerteza ainda significativa)
• t=60-90s: Continua modelagem
- t=90s: "Modelo convergiu! Confiança 85%"
- Meta-decisão: INTERROMPER modelagem (retornos decrescentes)
- Economizou 10s que seriam pouco produtivos
• t=90-130s: Processo Otimizar_Oferta
- Calcula proposta ótima dado modelo inferido
- Oferta: {preço: R$ 95.000, prazo: 60d, exclusividade: não}
• t=130s: ENVIA oferta ao oponente
Resposta do Oponente (t=160s):
• Contra-oferta: {preço: R$ 88.000, prazo: 45d, exclusividade: sim}
• Tempo restante: 140 segundos
Nova Decisão Meta-Cognitiva:
• Processo Avaliar_Contra_Oferta (10s) vs Aceitar_Imediatamente
• Custo de avaliar: 10s (7% do tempo restante)
• Benefício: Pode identificar concessões estratégicas
• Decisão: Avaliar (custo baixo, potencial alto)
• t=160-170s: Avaliação rápida
- Análise: Oferta aceitável mas não ótima
- Espaço para contra-negociar existe
t=170s - Gerar Contra-Proposta:
• Tempo restante: 130s
• Opção 1: Gerar_Argumento sofisticado (30s) + proposta
• Opção 2: Contra-proposta rápida (5s) sem argumentação elaborada
• Meta-raciocínio: "Ainda há tempo, adversário mostrou flexibilidade"
• Decisão: Investir em argumentação (Opção 1)
• t=170-200s: Elabora argumento persuasivo
"Exclusividade reduz nosso valor de mercado em R$ 12.000...
proposta justa seria R$ 92.000 sem exclusividade OU
R$ 90.000 com exclusividade parcial (6 meses)..."
• t=200s: ENVIA contra-proposta argumentada
t=240s - Resposta Final:
• Oponente: ACCEPT(R$ 91.000, 50d, exclusividade_6m)
• Acordo fechado! Valor: R$ 91.000 (vs R$ 88.000 inicial)
• Ganho do meta-raciocínio: R$ 3.000 (3.4% melhoria)
Análise Pós-Negociação:
• Tempo usado: 240s de 300s disponíveis (80%)
• Investimento em deliberação: Valeu a pena! (ROI positivo)
• Aprendizado: Adversário tipo "conservador mas racional"
→ Atualizar modelo de tipos de oponentes para futuras negociações
Cidades inteligentes emergem como ecossistemas complexos onde infraestruturas físicas integram-se com sistemas computacionais distribuídos para otimizar mobilidade, consumo energético, segurança pública e qualidade de vida urbana. Sistemas multi-agentes proporcionam arquitetura natural para coordenação descentralizada de serviços heterogêneos - desde semáforos adaptativos que ajustam temporização baseada em fluxo real de tráfego até redes elétricas inteligentes que balanceiam geração renovável intermitente com demanda flutuante.
Agentes representando diferentes entidades urbanas - veículos, edifícios, cidadãos, serviços públicos - negociam uso de recursos compartilhados mediante mecanismos de mercado ou votação. Semáforos inteligentes comunicam-se para criar ondas verdes que minimizam paradas, enquanto sistemas de estacionamento orientam motoristas para vagas disponíveis reduzindo tráfego de busca. Sensores IoT distribuídos alimentam agentes com dados em tempo real sobre poluição, ruído, e ocupação de espaços públicos.
Simulações baseadas em agentes avaliam impactos de políticas urbanas antes de implementação, modelando comportamentos individuais de milhares de cidadãos cujas interações produzem padrões emergentes de congestionamento, segregação espacial, ou difusão de inovações. Estas ferramentas apoiam planejamento participativo onde stakeholders exploram cenários alternativos, negociando trade-offs entre objetivos conflitantes como desenvolvimento econômico versus preservação ambiental mediante visualizações interativas de futuros possíveis.
Cidade: Região metropolitana com 200 interseções semaforizadas.
Agentes do Sistema:
• 200 Agentes_Semáforo (um por interseção)
• 50.000 Agentes_Veículo (carros, ônibus, ambulâncias)
• 10 Agentes_Corredor (coordenadores de avenidas principais)
• 1 Agente_Central (otimizador global, intervenções raras)
Arquitetura Hierárquica:
Nível 1 - Agentes Semáforo (Autônomos):
• Percepção: Detectores de loop indutivo, câmeras de contagem
• Estado: {fase_atual, tempo_restante, fila_norte, fila_sul, fila_leste, fila_oeste}
• Decisão: Ajustar temporização de fases baseado em demanda local
• Regra adaptativa simples:
SE fila_norte > 10 veículos E fila_sul < 3:
→ Estender verde_norte em +5 segundos
Nível 2 - Coordenação entre Semáforos Adjacentes:
• Semáforo_A envia mensagem a Semáforo_B (próximo na avenida):
INFORM("Pelotão de 15 veículos seguindo para você, ETA 30s")
• Semáforo_B ajusta timing:
- Programa sinal verde para coincidir com chegada do pelotão
- Cria "onda verde" que minimiza paradas
Nível 3 - Agentes Corredor (Coordenadores Regionais):
• Corredor_Paulista coordena 15 semáforos na Av. Paulista
• Objetivo: Maximizar vazão no corredor principal
• Negocia com corredores transversais quando há conflitos
Cenário de Operação Normal (manhã típica):
07:30 - Horário de Pico:
• Agentes_Veículo reportam destinos ao entrar na rede
• Sistema agrega: 60% tráfego sentido Centro
• Corredor_Central envia diretiva:
CONFIGURE(prioridade=Centro, bias=+20%_tempo_verde)
• Semáforos ajustam autonomamente mantendo equidade mínima
08:15 - Emergência Detectada:
• Ambulância_A42 ativa sirene (agente de alta prioridade)
• Localização: Cruzamento da Paulista com Augusta
• Destino: Hospital 3.2km ao norte
• Ambulância → Semáforos na rota: REQUEST(via_livre)
• Semáforos coordenam "corredor de emergência":
- t=0s: Semáforo_Paulista_Augusta: verde para ambulância
- t=20s: Próximo semáforo na rota antecipa verde
- t=40s: Semáforo seguinte sincronizado
• Tempo de viagem: 4min 30s (vs 8min em operação normal)
• Tráfego civil: Impacto mínimo (atraso médio +15 segundos)
10:00 - Acidente Bloqueia Via Principal:
• Sensor de fluxo em cruzamento X detecta: vazão = 0 (bloqueio total)
• Agente_Semáforo_X: ALERT("Via bloqueada, acidente provável")
• Corredor_Principal aciona replanejamento:
- Identifica rotas alternativas (vias paralelas)
- Aumenta capacidade de vias alternativas (+30% tempo verde)
- Envia sugestões de desvio para Agentes_Veículo via apps
• Agentes_Veículo recalculam rotas evitando bloqueio
• Sistema de informação variável: "Acidente na Av. X - Use Av. Y"
• Auto-organização: Tráfego redistribui-se em 12 minutos
Métricas de Desempenho (dia completo):
• Tempo médio de viagem: Redução de 18% vs semáforos fixos
• Paradas por veículo: 3.2 (vs 5.8 em sistema tradicional)
• Emissões CO₂: Redução de 12% (menos acelerações/frenagens)
• Satisfação cidadãos: 78% aprovação (pesquisa)
• Tempos de emergência: Ambulâncias 35% mais rápidas
Aprendizado de Longo Prazo:
• Sistema acumula dados sobre padrões de tráfego
• Identifica: Terças-feiras às 18h = pico em região comercial
• Ajuste proativo: Sistema antecipa padrão antes de manifestar
• Melhoria contínua via aprendizado por reforço coletivo
Comércio eletrônico moderno transcendeu vitrines digitais passivas, evoluindo para ecossistemas dinâmicos onde agentes inteligentes intermediam transações, personalizam experiências, e otimizam cadeias de suprimento mediante negociação automatizada. Agentes de compra representam consumidores, buscando produtos que maximizem utilidade individual considerando preferências, restrições orçamentárias e urgência temporal. Agentes vendedores representam comerciantes, ajustando preços dinamicamente baseado em demanda, inventário e comportamento competitivo.
Sistemas de recomendação multi-agente coordenam expertise de múltiplos algoritmos especializados - filtragem colaborativa que identifica usuários similares, filtragem baseada em conteúdo que analisa atributos de produtos, e aprendizado contextual que considera situação corrente do usuário. Agentes agregadores ponderam recomendações de diferentes fontes mediante meta-aprendizado que prevê qual especialista performará melhor para cada consulta específica, adaptando-se continuamente a feedback implícito e explícito.
Marketplaces descentralizados implementam leilões contínuos onde agentes compradores e vendedores submetem lances concorrentes, com mecanismos centrais determinando matching ótimo que maximiza volume de transações ou bem-estar social agregado. Blockchain e smart contracts garantem cumprimento automático de acordos, eliminando necessidade de confiança mútua mediante execução determinística de lógica contratual verificável por todas as partes envolvidas.
Plataforma: E-commerce com 1.000 vendedores e 50.000 compradores ativos.
Agentes Compradores:
• Agente_Pessoal do usuário João busca smartphone
• Preferências codificadas:
- Orçamento_max: R$ 2.500
- Marca_preferida: Samsung > Motorola > Xiaomi
- RAM_min: 6GB
- Urgência: média (pode esperar 3 dias por oferta)
Agentes Vendedores:
• Vendedor_A: Tem Samsung_Galaxy_S21 em estoque
- Custo: R$ 1.800, Preço_base: R$ 2.400
- Estratégia: Maximizar lucro mantendo reputação alta
• Vendedor_B: Mesmo modelo, estoque baixo (2 unidades)
- Preço_base: R$ 2.300 (mais competitivo)
- Estratégia: Vender rápido para liberar capital
Processo de Negociação Automatizada:
Dia 1 - Busca Inicial:
• Agente_João envia consulta ao marketplace:
QUERY(smartphone, budget≤2500, RAM≥6GB)
• Sistema retorna 47 ofertas que satisfazem critérios
• Agente_João filtra por marca preferida: 12 ofertas Samsung
• Menores preços: Vendedor_B (R$ 2.300), Vendedor_C (R$ 2.350)
• Agente_João avalia reputação:
- Vendedor_B: 4.7★ (850 avaliações), entrega 5-7 dias
- Vendedor_C: 4.9★ (2.300 avaliações), entrega 3-5 dias
• Decisão: Aguardar 1 dia para possíveis melhores ofertas
Dia 2 - Monitoramento de Preços:
• Vendedor_A nota interesse em S21 (analytics de tráfego)
• Vendedor_A reduz preço: R$ 2.400 → R$ 2.320
• Agente_João recebe alerta: "Preço caiu em produto monitorado"
• Avalia nova oferta:
- Vendedor_A: R$ 2.320, 4.8★, entrega 2-4 dias
- Ainda acima de Vendedor_B (R$ 2.300)
• Decisão: Continuar aguardando
Dia 3 - Negociação Direta:
• Agente_João envia proposta a Vendedor_B:
PROPOSE(produto=S21, preço=2.200, prazo_entrega=5dias)
• Vendedor_B avalia:
- Margem proposta: 2.200 - 1.800 = R$ 400 (22% lucro)
- Margem atual: 2.300 - 1.800 = R$ 500 (27% lucro)
- Probabilidade de venda nos próximos 2 dias a preço cheio: 60%
- Utilidade esperada de recusar: 0.6×500 + 0.4×200 = R$ 380
(se não vender a 2.300, precisará baixar muito mais)
- Utilidade de aceitar R$ 2.200 agora: R$ 400 > R$ 380 ✓
• Vendedor_B → Agente_João: ACCEPT(2.200)
Execução via Smart Contract:
• Smart contract ativado automaticamente:
CONTRATO_ID: 7A3F2E
COMPRADOR: João (Agente_João)
VENDEDOR: Loja_TechMaster (Vendedor_B)
PRODUTO: Samsung Galaxy S21, 128GB
VALOR: R$ 2.200,00
PRAZO_ENTREGA: 5 dias úteis
ESCROW: Valor bloqueado até confirmação entrega
CONDIÇÕES:
SE entrega_confirmada E produto_conforme:
→ liberar_pagamento(vendedor)
SE NÃO entregue em 7 dias:
→ reembolso_automático(comprador)
→ penalidade(vendedor, -0.1 reputação)
• Dia 5: Produto entregue, João confirma recebimento via app
• Smart contract executa: Libera R$ 2.200 para Vendedor_B
• Sistema solicita avaliação: João dá 5★, aumenta reputação vendedor
Aprendizado dos Agentes:
• Agente_João aprende: Negociar diretamente pode economizar R$ 100
→ Atualiza estratégia para futuras compras
• Vendedor_B aprende: Aceitar propostas justas rapidamente é melhor
que arriscar não vender e ter que baixar muito mais
Impacto Sistêmico (agregado mensal):
• Economia média compradores: 8.5% vs preços de tabela
• Satisfação vendedores: Rotação de estoque +15%
• Taxa de conclusão de negociações: 89% (vs 62% em sistema manual)
• Disputas/Arbitragens: Redução de 73% (smart contracts automatizam)
Smart grids revolucionam distribuição energética mediante coordenação descentralizada de geração, armazenamento e consumo. Agentes representando produtores (usinas solares, eólicas, hidrelétricas), consumidores (residências, indústrias), e dispositivos de armazenamento (baterias) negociam energia em mercados de tempo real, balanceando oferta intermitente de renováveis com demanda flutuante. Preços emergem dinamicamente como sinais econômicos que incentivam consumo quando geração é abundante e conservação durante escassez.
Prosumidores - entidades que simultaneamente produzem e consomem energia - introduzem bidirecionalidade nos fluxos de potência. Residências com painéis solares vendem excedentes para rede durante dia, comprando à noite. Veículos elétricos carregam durante tarifas baixas, alimentando rede durante picos mediante vehicle-to-grid (V2G). Coordenação multi-agente otimiza esses fluxos respeitando restrições físicas de capacidade de linhas e estabilidade de frequência.
Micro-redes isoláveis aumentam resiliência operando autonomamente durante falhas da rede principal. Agentes locais coordenam geração distribuída, armazenamento e cargas críticas para manter ilhamento sustentável até restabelecimento de conectividade. Transições seamless entre modos conectado e isolado requerem sincronização precisa de fases e voltagens, orquestrada mediante protocolos de consenso distribuído que garantem coerência sem controle centralizado vulnerável.
Contexto: Condomínio de 50 casas com geração solar e baterias compartilhadas.
Componentes Agentificados:
• 50 Agentes_Casa (gerenciam consumo individual)
• 1 Agente_Solar (200kW painéis no telhado comum)
• 1 Agente_Bateria (banco de 500kWh de armazenamento)
• 1 Agente_Rede (interface com concessionária)
• 1 Agente_Coordenador (otimizador local)
Operação Típica em Dia Ensolarado:
08:00 - Início de Geração Solar:
• Agente_Solar: Gerando 80kW (40% capacidade, sol nascente)
• Demanda condomínio: 120kW (café da manhã, pico matinal)
• Déficit: 40kW
• Decisão do Coordenador:
OPÇÃO_A: Importar 40kW da rede (custo R$ 0,65/kWh)
OPÇÃO_B: Descarregar bateria 40kW (custo degradação + ciclo)
• Coordenador escolhe A (preço baixo, poupar bateria para pico noturno)
12:00 - Pico de Geração Solar:
• Agente_Solar: Gerando 195kW (98% capacidade, sol a pino)
• Demanda: 65kW (residentes no trabalho/escola)
• Excedente: 130kW
• Negociação entre agentes:
1. Carregar bateria até 100%: 60kW alocados
2. Excedente restante: 70kW
3. Agente_Rede consulta preço de venda: R$ 0,45/kWh (tarifa feed-in)
4. Decisão: Exportar 70kW para rede (receita R$ 31,50/hora)
18:00 - Início do Pico Noturno:
• Geração Solar: Caindo rapidamente (30kW, sol baixo)
• Demanda: Subindo (140kW, residentes retornando)
• Déficit: 110kW
• Agente_Rede reporta: Tarifa pico = R$ 1,85/kWh (muito cara!)
• Coordenador: Priorizar bateria para evitar importação cara
- Descarregar bateria: 90kW
- Importar apenas: 20kW da rede (mínimo necessário)
Resposta a Demanda (Demand Response):
• 18:30: Demanda projetada para 18:45 = 165kW (jantar simultâneo)
• Bateria atual: 60% (300kWh), descarga máxima: 100kW
• Mesmo com bateria full, déficit previsto: 35kW a R$ 1,85
• Coordenador ativa Demand Response:
Coordenador → Agentes_Casa: REQUEST(postergar_cargas_não_críticas)
• Casa_12 responde: "Posso atrasar máquina de lavar em 2h"
• Casa_25: "Posso reduzir ar condicionado de 22°C para 24°C" (3kW)
• Casa_33: "Posso postergar carregamento carro elétrico" (7kW)
• Casa_41: "Aquecedor piscina pode aguardar" (5kW)
• Total de flexibilidade: 20kW reduzidos/postergados
• Novo déficit: apenas 15kW a importar (economia de R$ 37/hora)
• Incentivo aos participantes:
Cada casa recebe crédito proporcional à flexibilidade oferecida
Cenário de Emergência - Queda da Rede Externa:
• 20:15: Agente_Rede detecta: Concessionária offline (apagão)
• Agente_Rede → Coordenador: ALERT(rede_externa_indisponível)
• Coordenador ativa Modo Ilhamento:
1. Desconecta fisicamente da rede (proteção)
2. Inventário de recursos disponíveis:
- Solar: 0kW (noite)
- Bateria: 250kWh (50%)
- Demanda atual: 130kW
3. Autonomia: 250kWh / 130kW ≈ 1.9 horas (insuficiente para noite!)
• Racionamento Cooperativo:
Coordenador → Todas casas: EMERGENCY(reduzir_consumo_50%)
- Prioridade 1: Iluminação essencial, geladeiras
- Desligar: Ar condicionado, aquecimento, cargas não-essenciais
• Residentes cooperam (protocolo de emergência pré-acordado)
• Demanda reduzida para: 55kW
• Nova autonomia: 250kWh / 55kW ≈ 4.5 horas ✓
• Sistema mantém operação até concessionária restaurar às 01:30
Resultados Mensais:
• Conta de energia do condomínio:
- Antes (sem sistema): R$ 18.500/mês
- Depois (com agentes): R$ 7.200/mês
- Economia: 61%
• Autossuficiência energética: 78% (apenas 22% importado)
• Receita de exportação: R$ 2.100/mês
• Resiliência: 3 apagões sem interrupção interna
• Pegada de carbono: Redução de 85% vs rede 100% convencional
Educação personalizada em escala demanda sistemas adaptativos que modelam conhecimento, habilidades e estilo de aprendizagem de cada estudante individualmente. Sistemas tutores inteligentes multi-agente coordenam expertise pedagógica distribuída - agentes especialistas em domínios específicos, agentes tutores que adaptam estratégias instrucionais, e agentes motivacionais que mantêm engajamento mediante gamificação e feedback encorajador.
Modelagem do estudante infere estado cognitivo atual mediante diagnóstico Bayesiano que atualiza probabilidades de domínio de conceitos baseado em desempenho em exercícios. Espaços de conhecimento estruturam conteúdo em grafos de pré-requisitos, determinando ordem ótima de apresentação que respeita dependências conceituais. Algoritmos de planejamento pedagógico selecionam próxima atividade maximizando ganho de aprendizagem esperado sujeito a restrições motivacionais que previnem frustração ou tédio.
Colaboração entre estudantes facilita-se mediante agentes que formam grupos heterogêneos balanceando habilidades complementares, atribuem papéis que maximizam contribuições individuais, e mediam conflitos proporcionando andaimes procedimentais para colaboração efetiva. Análises de learning analytics identificam padrões de dificuldade sistemáticos que informam refinamento de currículos e materiais instrucionais, fechando loop de melhoria contínua que beneficia coortes futuras.
Sistema: Plataforma de ensino adaptativo para Ensino Médio.
Agentes do Ecossistema:
• Agente_Estudante (representa cada aluno, modelo cognitivo)
• Agente_Tutor_Álgebra (especialista em equações, funções)
• Agente_Tutor_Geometria (especialista em figuras, teoremas)
• Agente_Avaliador (diagnóstico de conhecimento)
• Agente_Motivacional (engajamento, gamificação)
• Agente_Coordenador_Pedagógico (orquestra estratégia global)
Caso: Estudante Maria, 15 anos, 1º ano EM
Sessão Inicial - Diagnóstico:
• Agente_Avaliador apresenta teste adaptativo:
- Questão 1 (média): "Resolva 2x + 5 = 13"
- Maria responde corretamente (x = 4)
- Agente infere: P(domina_equações_1º_grau) = 0.75
- Próxima questão aumenta dificuldade
- Questão 2 (difícil): "Resolva 3(x-2) + 5 = 2x + 7"
- Maria erra (confusão com distributiva)
- Atualização Bayesiana: P(domina_equações_1º_grau) = 0.52
P(compreende_distributiva) = 0.35
Planejamento Pedagógico:
• Coordenador_Pedagógico analisa modelo de Maria:
- Pré-requisito fraco: Propriedade distributiva
- Decisão: Rever fundamentos antes de prosseguir
• Coordenador → Agente_Tutor_Álgebra: ASSIGN(revisar_distributiva)
Instrução Adaptativa:
• Agente_Tutor_Álgebra apresenta:
1. Explicação visual interativa da distributiva:
a(b + c) = ab + ac [animação com áreas de retângulos]
2. Exemplo guiado:
"Vamos resolver 3(x - 2) passo a passo..."
Sistema destaca cada etapa, Maria confirma compreensão
3. Exercícios graduados:
Fácil → Médio → Difícil
• Maria completa 5 exercícios, acerta 4
• Agente atualiza: P(compreende_distributiva) = 0.82 ✓
Gamificação e Motivação:
• Agente_Motivacional detecta: Maria está há 35min sem pausa
• Intervenção: "Ótimo progresso! 🎯 Você ganhou badge 'Mestre da Distributiva'"
"Que tal uma pausa de 5 minutos?"
• Maria aceita pausa, mantém foco
Próximo Tópico - Tentativa:
• Coordenador: Agora pode retomar equações mais complexas
• Apresenta novamente: "3(x-2) + 5 = 2x + 7"
• Maria resolve corretamente desta vez! ✓
• Sistema: "Excelente! Você aplicou a distributiva perfeitamente!"
Aprendizagem Colaborativa:
• Coordenador identifica: Maria domina álgebra, mas geometria fraca
• Estudante João: Inverso (geometria forte, álgebra fraca)
• Sistema forma dupla para atividade colaborativa:
"Problema integrado: Calcular área de figura usando equações"
• Maria contribui com álgebra, João com geometria
• Ambos aprendem com strengths do outro (peer learning)
Feedback ao Professor:
• Sistema gera relatório automático:
"Alerta: 35% dos alunos têm dificuldade com propriedade distributiva
Sugestão: Dedicar aula presencial adicional ao tema"
Resultados (semestre):
• Maria: Nota inicial 6.2 → Nota final 8.7 (melhora de 40%)
• Tempo médio por conceito: Redução de 30% (mais eficiente)
• Engajamento: 92% das sessões concluídas vs 68% sistema tradicional
• Retenção de longo prazo: +25% em testes após 3 meses
• Satisfação estudantes: 8.5/10
• Carga de trabalho docente: Redução de 40% em correções
Balance adaptação individual com interação social - aprendizado não é processo solitário. Garanta que diagnósticos sejam justos e não perpetuem vieses. Mantenha professor no loop - tecnologia augmenta, não substitui educadores. Use ética: dados de aprendizagem são sensíveis e devem ser protegidos rigorosamente.
A fronteira da pesquisa em sistemas multi-agentes converge para integração harmônica entre representação simbólica explícita e aprendizado subsimbólico baseado em redes neurais. Arquiteturas neuro-simbólicas prometem combinar interpretabilidade e raciocínio lógico da IA simbólica com capacidade de generalização e robustez ao ruído das abordagens conexionistas. Sistemas híbridos utilizam redes neurais para percepção e extração de características, alimentando módulos simbólicos que realizam raciocínio estruturado e planejamento de alto nível.
Aprendizado por reforço multi-agente profundo aplica técnicas de deep learning para escalar coordenação a ambientes com espaços de estados massivos. Contudo, modelos puramente subsimbólicos carecem de explicabilidade - dificultando debugging, certificação de segurança, e confiança humana. Injection de conhecimento simbólico em redes neurais mediante loss functions estruturadas ou atenção guiada por ontologias melhora eficiência amostral e convergência, reduzindo dados necessários para treinamento.
Verificação formal de sistemas neuro-simbólicos representa desafio aberto. Enquanto componentes simbólicos admitem prova matemática de propriedades, componentes neurais resistem a análise formal devido à natureza contínua e não-linear de seus parâmetros. Técnicas de abstração que aproximam redes por regiões poliédricas permitem verificação conservadora, garantindo que propriedades críticas valem mesmo sob incerteza paramétrica, habilitando certificação de agentes autônomos em aplicações seguras e críticas.
Componente Neural (Percepção):
• Rede convolucional analisa imagem de raio-X
• Saída: Probabilidades P(anomalia_A) = 0.87, P(anomalia_B) = 0.34
• Extrai features: localização, tamanho, textura
Componente Simbólico (Raciocínio):
• Base de conhecimento médico em lógica de primeira ordem:
- SE anomalia_A ∧ idade > 60 → investigar_câncer_pulmão
- SE anomalia_B ∧ histórico_fumante → risco_DPOC
• Integra evidências probabilísticas com regras determinísticas
Decisão Híbrida:
• P(anomalia_A) = 0.87 → aciona regra de investigação
• Consulta prontuário: idade_paciente = 68, histórico_fumante = sim
• Raciocínio simbólico: Recomendar tomografia de acompanhamento
• Explicação gerada automaticamente:
"Detectada anomalia com 87% de confiança. Dado idade do paciente (68 anos),
recomenda-se investigação adicional segundo protocolo clínico..."
Vantagens da Integração:
• Neural: Processa imagens complexas, robustos a variações
• Simbólico: Incorpora conhecimento médico validado, explicável
• Híbrido: Decisões clinicamente fundamentadas E baseadas em dados
Sistemas multi-agentes autônomos levantam questões sobre responsabilidade quando decisões causam danos, privacidade quando agentes coletam dados pessoais, e equidade quando algoritmos perpetuam vieses históricos. Governança de IA requer frameworks regulatórios que balancem inovação com proteção social, demandando colaboração interdisciplinar entre tecnólogos, juristas, filósofos e formuladores de políticas públicas.
O campo de sistemas multi-agentes posiciona-se na intersecção de múltiplas disciplinas, absorvendo avanços em aprendizado de máquina, teoria dos jogos, lógica formal, sistemas distribuídos e ciências cognitivas. As próximas décadas testemunharão proliferação de agentes autônomos em praticamente todos os setores econômicos - desde assistentes pessoais inteligentes que antecipam necessidades humanas até sistemas de gerenciamento de infraestrutura crítica que coordenam recursos energéticos, hídricos e de transporte em escala urbana e nacional.
Questões abertas fundamentais persistem. Como projetar mecanismos que garantam comportamento ético em populações de agentes egoístas? Como escalar coordenação para milhões de agentes heterogêneos mantendo eficiência computacional? Como assegurar que sistemas multi-agentes permaneçam alinhados com valores humanos mesmo quando otimizando objetivos em ambientes complexos? Respostas demandarão avanços técnicos profundos aliados a reflexão cuidadosa sobre implicações sociais e filosóficas da automação inteligente.
Para estudantes e pesquisadores iniciando jornada neste campo fascinante, a mensagem é clara: dominar fundamentos matemáticos e lógicos proporciona base sólida sobre a qual construir soluções inovadoras. Sistemas multi-agentes não são mera aplicação de fórmulas - exigem criatividade para modelar problemas, intuição para projetar interações, e visão sistêmica para antecipar consequências emergentes. Os desafios são imensos, mas as oportunidades para impacto positivo na sociedade são igualmente vastas. O futuro da inteligência artificial é distribuído, adaptativo e fundamentalmente multi-agente.
Explore plataformas práticas como Jason, JADE e NetLogo para implementar sistemas multi-agentes. Participe de competições como RoboCup para aplicar teoria em desafios reais. Contribua para projetos open-source de IA distribuída. Mantenha-se atualizado com conferências como AAMAS, IJCAI e NeurIPS. Cultive pensamento interdisciplinar conectando IA com ética, direito e ciências sociais.
"A verdadeira inteligência emerge não de agentes isolados,
mas da dança coordenada de múltiplas mentes trabalhando em harmonia."
— Conclusão do Volume 89
BORDINI, Rafael H.; HÜBNER, Jomi Fred; WOOLDRIDGE, Michael. Programming Multi-Agent Systems in AgentSpeak Using Jason. Chichester: John Wiley & Sons, 2007.
FERBER, Jacques. Multi-Agent Systems: An Introduction to Distributed Artificial Intelligence. Reading: Addison-Wesley, 1999.
NILSSON, Nils J. Artificial Intelligence: A New Synthesis. San Francisco: Morgan Kaufmann, 1998.
RAO, Anand S.; GEORGEFF, Michael P. BDI Agents: From Theory to Practice. In: Proceedings of the First International Conference on Multi-Agent Systems. San Francisco: AAAI Press, 1995.
RUSSELL, Stuart J.; NORVIG, Peter. Inteligência Artificial. 3ª ed. Rio de Janeiro: Elsevier, 2013.
SHOHAM, Yoav; LEYTON-BROWN, Kevin. Multiagent Systems: Algorithmic, Game-Theoretic, and Logical Foundations. Cambridge: Cambridge University Press, 2009.
WEISS, Gerhard (Ed.). Multiagent Systems. 2ª ed. Cambridge: MIT Press, 2013.
WOOLDRIDGE, Michael. An Introduction to MultiAgent Systems. 2ª ed. Chichester: John Wiley & Sons, 2009.
BROOKS, Rodney A. Intelligence Without Representation. Artificial Intelligence, v. 47, n. 1-3, p. 139-159, 1991.
DASTANI, Mehdi; MEYER, John-Jules Ch. A Practical Agent Programming Language. In: Proceedings of AAMAS 2008. Estoril: ACM Press, 2008.
DURFEE, Edmund H. Distributed Problem Solving and Planning. In: WEISS, G. (Ed.). Multiagent Systems. Cambridge: MIT Press, 1999.
FIPA. FIPA ACL Message Structure Specification. Foundation for Intelligent Physical Agents, 2002.
JENNINGS, Nicholas R.; SYCARA, Katia; WOOLDRIDGE, Michael. A Roadmap of Agent Research and Development. Autonomous Agents and Multi-Agent Systems, v. 1, n. 1, p. 7-38, 1998.
LAMPORT, Leslie. Time, Clocks, and the Ordering of Events in a Distributed System. Communications of the ACM, v. 21, n. 7, p. 558-565, 1978.
SINGH, Munindar P. Agent Communication Languages: Rethinking the Principles. IEEE Computer, v. 31, n. 12, p. 40-47, 1998.
STONE, Peter; VELOSO, Manuela. Multiagent Systems: A Survey from a Machine Learning Perspective. Autonomous Robots, v. 8, n. 3, p. 345-383, 2000.
BRASIL. Ministério da Educação. Base Nacional Comum Curricular: Ensino Médio. Brasília: MEC, 2018.
CASTELFRANCHI, Cristiano. Modelling Social Action for AI Agents. Artificial Intelligence, v. 103, n. 1-2, p. 157-182, 1998.
HUHNS, Michael N.; STEPHENS, Larry M. Multiagent Systems and Societies of Agents. In: WEISS, G. (Ed.). Multiagent Systems. Cambridge: MIT Press, 1999.
LESSER, Victor R. Cooperative Multiagent Systems: A Personal View of the State of the Art. IEEE Transactions on Knowledge and Data Engineering, v. 11, n. 1, p. 133-142, 1999.
McCARTHY, John; HAYES, Patrick J. Some Philosophical Problems from the Standpoint of Artificial Intelligence. In: MELTZER, B.; MICHIE, D. (Eds.). Machine Intelligence 4. Edinburgh: Edinburgh University Press, 1969.
PARSONS, Simon; WOOLDRIDGE, Michael; AMGOUD, Leila. On the Outcomes of Formal Inter-Agent Dialogues. In: Proceedings of AAMAS 2003. Melbourne: ACM Press, 2003.
SICHMAN, Jaime Simão; DEMAZEAU, Yves. On Social Reasoning in Multi-Agent Systems. Revista Iberoamericana de Inteligencia Artificial, v. 13, p. 68-84, 2001.
JASON. AgentSpeak Interpreter and Multi-Agent Platform. Disponível em: http://jason.sourceforge.net/. Acesso em: jan. 2025.
JADE. Java Agent DEvelopment Framework. Disponível em: https://jade.tilab.com/. Acesso em: jan. 2025.
NetLogo. Multi-Agent Programmable Modeling Environment. Disponível em: https://ccl.northwestern.edu/netlogo/. Acesso em: jan. 2025.
SPADE. Smart Python Agent Development Environment. Disponível em: https://spade-mas.readthedocs.io/. Acesso em: jan. 2025.
MASON. Multi-Agent Simulator Of Neighborhoods. Disponível em: https://cs.gmu.edu/~eclab/projects/mason/. Acesso em: jan. 2025.
"Inteligência Artificial Simbólica: Sistemas Multi-Agentes" apresenta exploração abrangente dos fundamentos matemáticos e lógicos que sustentam sistemas de agentes autônomos distribuídos. Este volume da Coleção Escola de Lógica Matemática integra teoria rigorosa com aplicações práticas, demonstrando como representação simbólica do conhecimento, raciocínio automatizado e protocolos de comunicação convergem para criar sistemas inteligentes capazes de cooperação sofisticada.
Desenvolvido em alinhamento com as competências da Base Nacional Comum Curricular, o livro prepara estudantes do ensino médio avançado e graduação para compreender e desenvolver tecnologias emergentes em áreas como robótica colaborativa, veículos autônomos, sistemas de recomendação distribuídos e assistentes inteligentes. Cada capítulo combina formalização matemática rigorosa com exemplos concretos que ilustram conceitos abstratos mediante aplicações tangíveis.
João Carlos Moreira
Universidade Federal de Uberlândia • 2025