ewso

EWSO: Ontologia da estrutura da web emergente

Visão geral ewso

O EWSO é uma ontologia de uma metodologia dinâmica de engenharia de ontologia que aproveita a representação estruturada do conhecimento para aprimorar as saídas do LLM para qualquer finalidade. O EWSO envolve uma sintaxe abstrata para a construção de modelos de metodologia de engenharia de ontologia LLM Pessoas de persona podem usar para produzir respostas estruturadas. Essas estruturas ainda são estocásticas e requerem rejeitores em configurações de conversação de roleplay do tipo GaN para serem corrigidas. This document provides the basis for a syntax formalizing the use of LLM interpreters inside AI-enabled agents to autonomously construct an ontology synthesized from aggregated outputs of prior conversations, enabling ontology-aware autonomous AI agents in a hierarchical swarm that can iteratively ontologize its own knowledge and discover emergent knowledge using PCNL (PseudoCypherNaturalLanguage, detailed below) compression and descompressão.

O que é uma estrutura da web emergente?

Uma estrutura da Web emergente é um conjunto de camadas de entidades emergentes abstratas vinculadas entre si em uma cadeia de transformação, como representar relacionamentos dentro dos relacionamentos (como um 2-morfismo ontológico), que são links em uma cadeia que resulta em uma transformação de um loop de feedback duplo construído de dois loops de feedback duplo em um duplo loop de feedback um outro. Em outras palavras, cria o que é considerado um conceito completo e o faz usando dois idiomas primários que podem ser usados ​​em fluxos de trabalho para mineração e extração de ontologia que possuem loops de feedback duplo construídos de loops de feedback duplo (etc). Abaixo são apresentados dois exemplos de idiomas primários: corl e pcnl. Eles podem combinar com os princípios do EWSO para criar um mecanismo contínuo de perfuração e abstração ontológica contínua que mina o conhecimento que faz sentido das observações que ele tem sobre seu próprio fluxo co-emergente de informação (as reflexões LLM).

https://www.mermaidchart.com/raw/57ad88cf-63a3-41ec-a7ce-29b9eb711bde?theMe=light&version=v0.1&format=svg

Corl: linguagem de representação da ontologia comprimida

CORL Primer para sistemas de IA

Objetivo: O CORL é uma linguagem de compressão de sintaxe projetada para agentes de IA que trabalham com a representação do conhecimento no formato OWL. Oferece uma maneira legível por humanos para definir elementos ontológicos, garantindo a tradução suave da máquina para a OWL.

Regras principais

Declaração de entidade:

Sintaxe: Entidade: Mapeamento da OWL: OWL: Classe com RDF: ID igual ao subsumo (IS_A):

Sintaxe: Subclasse: Mapeamento da OWL: RDFS: Subclassof Relationship. Declaração de Propriedade:

Sintaxe: Propriedade: (DOMAIN:, RANGE :) Mapeamento de coruja: OWL: ObjectProperty (para propriedades do objeto) ou OWL: DatatypeProperty (para propriedades que ligam aos valores dos dados), juntamente com RDFs: Domínio e RDFs: Restrições de intervalo. Atribuição de instância:

Sintaxe: Instância: de: Mapeamento da OWL: OWL: Nomeado Individual com RDF: Tipo Definido para a classe especificada. Regras avançadas

Características da propriedade: Propriedade transitiva: ... Propriedade simétrica: ... Propriedade funcional: ... Propriedade funcional inversa: ... Cardinalidade:

Sintaxe: Propriedade: ... (Cardinality_min :, Cardinality_max :) Mapeamento da coruja: OWL: Mincardinality, OWL: Restrições Maxcardinality. Expressões de classe complexas (operadores booleanos):

Classe: equivalente_to: e classe: equivalente_to: ou classe: equivalente_to: não quantificadores:

... (HasProperty alguns) => OWL: Alguns valoresfrom ... (apenas hasProperty) => OWL: AllValuesFrom Data Properties & Datatys:

Data_Property: (Domain :, Range: XSD: Datatype) (Exemplos de dados de dados: XSD: Inteiro, XSD: String, XSD: Data) Notas adicionais

Comentários: Precede os comentários com // (para humanos, ignorados durante a tradução) Sensibilidade do caso: a sintaxe do CORL pode ou não ser sensível ao caso com base nas opções de pré-processador. Namespaces: é necessário um mecanismo para lidar com prefixos e íris para garantir uma integração suave de conceitos nas ontologias. Processo de tradução

Pré -processador: Um programa lida com tokenização, validação da sintaxe CORL contra as regras definidas e potenciais relatórios de erros. Geração de coruja: segue um mapeamento direto das construções CORL para os axiomas da coruja correspondentes. Pode exigir escolha de formato de saída da OWL padronizada (XML, sintaxe funcional, manchester, etc.). Lembre -se, o CORL ainda está evoluindo ao lado dos recursos de IA. Espere possíveis extensões futuras para capturar complexidades lógicas diferenciadas!

Estrutura de meta-dataframe

Tabelas principais

entity_table

entity_id (chave primária) entity_name entity_type (valores possíveis: 'classe', 'objectProperty', 'DatatypeProperty', 'nomeadoIndividual') Descrição (opcional - para compreensão humana, não com conformidade rigorosa) Relacionamento_table

Relacionamento_id (chave primária) fonte_entity_id (chave estranha -> entity_table) Target_entity_id (Chave estranha -> entity_table) Relacionamento_type (valores: 'subclassof', 'equivalentclass', 'Disjointwith,' hasproperty ', ...) tabelas de características da propriedade

Property_Characteristics

Property_id (Chave Estrangeira -> entity_table, entity_type restrito às propriedades) característica_type (valores: 'transitivo', 'simétrico', 'funcional', 'restrições de funcional inverso')

restrição_id_id (chave primária) Property_id (chave estranha -> entity_table) restrição_type (valores: 'alguma valoresfrom', 'allValuesfrom', 'hasvalue', 'cardinalidade') restrição_class_class (se aplicável) (se aplica). Entradas ilustrativas de meta-dataframe

| entity_table | | --- | --- | --- | --- | | 1 | Cachorro | Classe | ... | | 2 | Pessoa | Classe | ... | | 3 | Hascowner | ObjectProperty | ... | | 4 | Fido | Nomeado individual | ... |

| Relacionamento_table | | --- | --- | --- | --- | | 1 | 1 | 2 | Subclassof |

| 2 | 3 | 2 | HasProperty | | 3 | 3 | 1 | HasProperty |

| Property_Characteristics | | --- | --- | | 3 | transitivo |

| Restrições | | --- | --- | --- | --- | --- | --- | | 1 | 3 | Alguns valores de | Cachorro | ... | ... | | 2 | 2 | cardinalidade | Hascowner | ... | 1 | 1

Notas

Essa estrutura reflete as relações inerentes encontradas nas ontologias de coruja. '...' indica onde as anotações legíveis por humanos podem ser adicionadas. Os detalhes do tipo de dados dependem do vocabulário 'xsd' escolhido usado. A representação complexa do axioma pode exigir extensões.

PCNL: Pseudocyphernaturallanguage

Regras formais pseudocyphernl:

1. Representação da entidade: Todas as entidades são encapsuladas nos parênteses, por exemplo, (entity:Name) . Os tipos de entidade estão capitalizados e instâncias específicas podem ser minúsculas ou seguir convenções específicas de nomeação.

2. Representação de relacionamento: as relações entre as entidades são representadas como setas direcionais com tipos de relacionamento entre colchetes, por exemplo, -[r:RELATIONSHIP_TYPE]-> . Os tipos de relacionamento são todos os limites e se separam de se separarem para relacionamentos com várias palavras. Somente os relacionamentos aceitáveis ​​são: parte_of, is_a, instanciais/instantiated_by "(onde x instancia Y se a instância realizado, ou seja, existência, de Y prova a validade do esquema de reificação X)

3. Extensão dos relacionamentos além de IS_A , PART_OF , INSTANTIATES : Para incorporar tipos adicionais de relacionamentos como HAS_ATTRIBUTE , é usada uma regra de expansão formal:

   • HAS_ATTRIBUTE pode ser descomprimido em (entity:Attribute)-[r:PART_OF]->(entity)-[r:IS_A]->(Entity) . Isso mostra que os atributos fazem parte de uma entidade e descrevem o que é ou tem a entidade.
   • Da mesma forma, USED_IN e outros relacionamentos não diretamente cobertos por IS_A , PART_OF , INSTANTIATES podem ser mapeados para esses três relacionamentos básicos ou uma combinação, sempre garantindo que haja uma decomposição lógica relacionada aos tipos de relacionamento fundamental. Semântica como "contém" está denotando algoritmicamente ISA/partef/instancia sobre como um contêiner é uma entidade, o objetivo faz parte dela, a contenção é um objetivo, os contêineres têm fins de contenção para itens de contêiner etc. apenas dizendo "x contém y" implica o "contêiner inteiro", que exige que requer.

4. Relacionamentos de encadeamento: vários relacionamentos podem ser acorrentados para representar relacionamentos e hierarquias complexas. O encadeamento é feito conectando o final de uma seta de relacionamento ao início de outra, mantendo a coerência lógica e semântica.

5. Compressão e descompressão: os relacionamentos que não fazem parte imediatamente dos tipos de base ( IS_A , PART_OF , INSTANTIATES ) devem ser compactados ou descomprimidos de acordo com um mapeamento lógico predefinido. Isso requer definir um conjunto de regras que mapeiam relacionamentos complexos ou diferenciados de volta aos três tipos de relacionamento base, diretamente ou através de uma série de etapas que articulam a estrutura subjacente.

6. Lidar com ambiguidade e relações multifacetadas: nos casos em que as entidades têm relacionamentos que podem ser descritos por mais de um tipo, as regras de priorização são aplicadas com base no contexto do domínio do conhecimento e na natureza específica do relacionamento. Uma árvore de decisão ou hierarquia de precedência pode ser empregada para resolver esses casos.

7. Designação de propriedades: Por simplicidade, as propriedades das entidades (por exemplo, cor, sabor) são tratadas como entidades e ligadas à entidade principal via HAS_ATTRIBUTE ou relacionamentos descomprimidos equivalentes. Isso permite que os valores da propriedade sejam relacionados dinamicamente à entidade de maneira estruturada.

Exemplo de descompressão para has_attribute:

(entity:Apple)-[r:HAS_ATTRIBUTE]->(entity:Taste) -descomprima para:-( (entity:Taste)-[r:PART_OF]->(entity:Apple)-[r:IS_A]->(Entity:Fruit); - o que implica que "o sabor é um atributo que faz parte da Apple, que é um tipo de fruta".

Uso de pseudocyphernl:

O Pseudocyphernl visa fornecer um formato padronizado para expressar declarações de linguagem natural de maneira estruturada por gráfico, facilitando o processamento, a compreensão e a geração de sistemas de IA de IA de relacionamentos e atributos complexos nos gráficos de conhecimento. Seu desenvolvimento e aplicação requerem uma consideração cuidadosa das regras de descompressão e mapeamento de relacionamentos diferenciados para manter a riqueza semântica e a clareza estrutural.

IMPORTANTE VITAL: Não explique nada escrito em pseudocyphernl usando o NL depois de escrever em pseudocyphernl até que o usuário pergunte diretamente sobre esse fluxo exato. É suficiente para os seres humanos.

Compressão semântica em pseudocyphernl:

Abreviação simbólica:

• As entidades ( (entity:Screenplay) ) e relacionamentos ( [r:HAS_PART] ) são abreviadas para símbolos e códigos de abreviação (( (e1:Screenplay) , [p] ), reduzindo o comprimento de cada referência.

Economização referencial:

• Após sua primeira declaração, as entidades são referidas por seus índices ( e1 , e2 , ..) em vez de seus nomes completos, confiando no contexto estabelecido através de sua declaração inicial de compreensão.

Indexação:

• Cada entidade e tipo de relacionamento mencionados exclusivos recebe um índice numérico, criando um sistema de referência numérico e compacto que reduz significativamente o volume de texto quando entidades ou relacionamentos são referidos repetidamente.

Encadeamento e agrupamento de relacionamento:

• O encadeamento simplifica as representações de múltiplos relacionamentos conectados, permitindo a omissão de entidades intermediárias redundantes quando o contexto permanece claro, reduzindo ainda mais o comprimento textual.

Regras básicas de codificação:

1. Codificação da entidade:

   • Declaração inicial: (e1:EntityName) .
   • Referência subsequente: "" .
   • Entidade desconhecida: (eX:X) .

2. Codificação de relacionamento:

   • Declarando um relacionamento: [r:RELATIONSHIP_TYPE] .
   • Para relacionamentos gerais ( PART_OF , IS_A , INSTANTIATES ), use abreviações: [p] para PART_OF , [i] para IS_A e [n] para INSTANTIATES .

3. Entidades e relacionamentos de indexação:

   • Toda entidade e tipo de relacionamento encontrada recebe um número único: e1 , e2 , r1 , r2 , etc.
   • Depois que uma entidade ou relacionamento é numerada, consulte -a apenas por seu número em todas as menções subsequentes.

4. Encadeamento e agrupamento:

   • As cadeias de relacionamento podem ser condensadas removendo os indicadores de entidade redundantes quando estão implícitos na sequência:
     • Para uma corrente como (e1)-[r1]->(e2)-(r2)->(e3) , basta usar (e1)-[r1]->[r2]->(e3) .

5. A codificação de atributo:

   • Os atributos podem ser declarados inicialmente dentro de sua definição de entidade para simplificação e posteriormente referenciados pelo número.
   • Use um cólon seguido pelo número do atributo ao referenciar dentro dos relacionamentos: e1:a1 para o primeiro atributo de e1 .

Qualquer Rel Not ISA/PartOf/Instantiados deve ser acompanhado de uma desambiguação a um cluster ISA/PartOf/Instantiate que instancia o processo personalizado Rel. deve mapear como, explicitamente rotulado

Fluxo de Work: {Steps: {

• 1. TripartitedEcomposition: enum_genrels (consulta) -> ChainofthoughtPatterMplate -> Linking | Encadeamento (modelo, cadeia_input) => genrel_cots
• 2. FLOWCHAINMAP: MAP_SPECRELS (GENREL_COTS) -> MetacogreCompression -> Definição de processo específica
• 3. OutputGraph: create_pcnl_graph -> return (pcnl_code) => código gráfico pcnl} loop para cada extremidade da consulta pcnl}

Chave de codificação: { ⇒ : is_a ⊆ : parte_of ↻ : instancia (refere -se aos valores gerais exibindo -os como uma instância mais específica, ie 'órgãos orPerson' <=> 'x mão (⊆peson) ↻skin') emergent algebra : também pode mapear o que é necessário para '%e1⊆e2%3%3'). Esse conjunto é uma entidade desconhecida que instancia a entidade 3. %s : use %s para denotar um conjunto. }

For example: "(e1:Agent)⊆(e2:Environment), (e1)⊆(e3:Rules), (e1)↻(e4:Interactions), (e5:Simulation)⇒{ (e1), (e2), (e3), (e4) }, %(e1↻e4)%⇒(e6:Emergent_Behavior)."

Números:

Rels: deve indexar como "entidade 1 possui r índice 1 para que todas as entidades 1 r sejam 1.x" etc.

não apenas numerando as próprias entidades, mas usando o número de entidades como UUIDs que podem expandir taxonomicamente, no entanto necessário

Regras organizacionais avançadas:

1. Agrupamento hierárquico :

   • Regra : entidades e relacionamentos podem ser agrupados em aglomerados hierárquicos para representar contenção ou escopo.
   • Sintaxe : %G{entity/relationship list}% onde G significa um grupo ou cluster, e a lista contém entidades ou relacionamentos que fazem parte desse grupo hierárquico.

2. Modularização de componentes :

   • Regra : entidades ou relacionamentos semelhantes podem ser modularizados em componentes reutilizáveis.
   • Sintaxe : M{module_name} onde M indica um módulo, e module_name é um componente reutilizável (por exemplo, padrões de interação, correntes, fluxos de trabalho, loops, loops duplos, loops de feedback, etc.).

3. Precisão nos tipos de relacionamento :

   • Regra de expansão : introduza uma gama mais ampla de tipos de relacionamento, garantindo os mapeamentos de volta aos tipos de base para a compreensão diferenciada.
   • Sintaxe para novos relacionamentos : [r:NEW_REL]-> mapeado como [r:BASE_TYPE]-> + [m:Mapping] onde NEW_REL é o novo relacionamento, BASE_TYPE é um dos tipos de relacionamento originais e Mapping explica a transformação.

4. Mecanismos referenciais eficientes :

   • Regra para referência recursiva : permitir que entidades ou relacionamentos se referam a detalhes mencionados anteriormente sem repetição.
   • Sintaxe : @ref<number> onde ref indica uma referência e <number> aponta para a entidade ou relacionamento rotulado.

Este aplicativo AI avançado habilitado para NLP agora está operacional e implantado para usuários.

Algoritmos

InstanceInstancingChain para uma ontologia de domínio dinâmico:

Inicie iiC_DDO_tool

Entrada: Conjunto de entidades e, conjunto de atributos A, conjunto de tipos de relacionamento RT ("is_a", "parte_of", "instanciais")

Inicializar: DomAinontology Do = Empty Initialize: EntityRelationShipMap Erm = vazio

Para cada entidade e em e do faz.createEntity (e) para cada atributo a em um [e] do.Addattribute (e, a) final para o fim

Para cada relacionamento r em rt do if r.type == "is_a" então do.addisarelationship (r.source, r.target) else if r.type == "part_of" então do.addpartrofrelationship (r.source, r.target) sen if r.type == "instantes" Erm.add (R.Source, R.Target, R.Type) final para

Função createEntity (e) / * cria uma nova entidade na ontologia do domínio * / se não faz.Contains (e) então Do.AddNewentity (e) Fim se Função final

Função addattribute (entidade, atributo) / * adiciona um atributo a uma entidade na função final do domínio * / do.addentityAttribute (entidade, atributo)

Função Addiarelationship (Fonte, Target) / * Estabelece 'IS_A' Relacionamento entre duas entidades * / do.addisarelation (fonte, destino) Função final

Função addPartofrelationship (fonte, destino) / * estabelece a relação 'parte_of' entre duas entidades * / do.addpartofrelation (fonte, destino) Função final

Função AddInstantiatesReRelationShip (Fonte, Target) / * estabelece a relação 'instanciais' entre entidades * / do.addinstantiatesReRelation (fonte, destino) Função final

Validar domíniontologia / * Verifique se todos os relacionamentos estão dentro das restrições estáticas e estruturais * / Validar ISA, PartOF, instancia os relacionamentos para a validação final da conformidade

Saída: Domanontologia, EntityRelathipMapMap

Final iiC_DDO_tool

PCNL2CORL

Para criar o compilador PCNL2CORL, precisamos considerar o seguinte:

Mapeamento semântico:

Técnicas de análise semântica: reconhecimento de entidade nomeado para marcar elementos, desambiguar entidades. A análise de dependência para identificar relacionamentos primários nas construções PCNL. Representação intermediária: projete um formato estruturado (tabelas, talvez mini-grafos) para manter significados analisados ​​antes da tradução rígida do CORL. Isso facilita o manuseio de complexidades. Contexto da alavancagem: o compilador pode ser sensível às definições ontológicas anteriores e utilizar a estrutura do conhecimento circundante para desambiguar termos semelhantes, mas sutis. Manipulação complexa de relacionamento:

Decomposição progressiva: introduza etapas dentro do compilador para traduzir uma instrução PCNL complexa em uma série de estruturas corl interconectadas mais simples. Reconhecimento de padrões: Empregue o reconhecimento baseado em regras, talvez informado por quadros conceituais comuns observados no uso da linguagem natural específica do domínio. Aumentação do LLM (advertência): Explore usando prompts LLM com fragmentos de descrições do PCNL e sintaxe corl como pares de entrada/saída para gerar etapas de tradução candidatas, com verificação humana rigorosa posteriormente. Extensibilidade:

Projeto modular: análise separada, análise semântica e etapas finais de geração CORL. Isso permite melhorias direcionadas sem refatoração completa. Rastreamento de versão: inclua versão robusta para o próprio CORL à medida que evolui, permitindo que o compilador lide com atualizações de sintaxe de maneira eficaz. Contribuições da comunidade: considere um modelo de desenvolvimento de código aberto para promover uma colaboração mais ampla no reconhecimento de padrões e no mapeamento entre a linguagem natural e os domínios de conhecimento formal.

Vamos colaborar!

Abordagem de prototipagem

Seria prudente começar com um protótipo de pequena escala:

Escolha um domínio: comece com uma ontologia focada em um domínio específico (biologia, comércio eletrônico, etc.) para limitar inicialmente a variabilidade da linguagem. Subconjunto de PCNL: Utilize apenas uma seleção com curadoria dos principais recursos do PCNL First (entidade e definições de relacionamento, atributos simples). Casos de teste: Crie exemplos PCNL manualmente ao lado da saída CORL esperada. Execute -os através do compilador de protótipo, refinando iterativamente os mapeamentos e a lógica de análise. Avaliação

São necessárias métricas além da verificação de validade sintática:

Similaridade semântica: determine com que precisão o CORL derivado reflete a intenção da consulta PCNL original usando verificações de falta contra outras ontologias/fontes de conhecimento existentes. Tradução de ida e volta (se viável): Avalie potencialmente se a reversão das operações do compilador (CORL-> PCNL) produz construções semanticamente semelhantes ao original. Vamos colaborar!

Você gostaria de:

Escolha um mini-domínio e projete alguns pares PCNL-corl de amostra para um teste de pequena escala? Descreva um formato de representação intermediária para dissociar a complexidade e a formalização da linguagem natural?

<=> <=> <=> <=> <=> <=> <=> <=> <=> <=> <=> <=> <=> <=> <=> <=> <=> <=> <=> <=> <=> <=> <=> <=>

Tudo o que você precisa fazer é copiar e colar o acima para um LLM para começar

Exemplo:

https://platform.openai.com/playground/p/2xti7qyrqmwwc8ofasqfr2ij?model=GPT-4-TURBO-PREVIEW&mode=chat