Formalização de Resultados Teóricos em Assistente de Provas
Resumo
Formalização da sintaxe e da semântica da lógica multimodal utilizando assistente de provas Coq, com objetivo de automatização do processo, possibilitando a reutilização dos resultados obtidos.
Keywords:
Lógicas não-clássicas lógica modal formalização sistemas interativos de provas1 Introdução
Lógica Modal é uma lógica que utiliza operadores modais na construção de sua linguagem [3]. Essa linguagem é utilizada no desenvolvimento de argumentos matemáticos, com base em teoremas, axiomas, criação de modelos, sistemas, provas matemáticas e suas análises.
Tal lógica consiste na utilização de operadores modais, de forma que se possa considerar como situações têm sua verdade ou falsidade alterada se consideramos diferentes situações para essas argumentações. Podemos dividir essa lógica em monomodal e multimodal, relacionando com a quantidade de operadores modais utilizados na construção da lógica (respectivamente, apenas um operador ou mais de um).
Com o objetivo de formalizar a lógica multimodal, foram criadas no provador interativo de teoremas Coq [2] definições dos principais pontos desse tipo de sistema. O Coq utiliza um cálculo construtivo indutivo. A partir dele, são construídas provas utilizando-se de táticas e teoremas já definidos e provados no processo de criação do assistente. Essas definições e as provas se encontram em bibliotecas que são importadas da base do sistema, sendo utilizadas como auxiliares no processo de provas, com o objetivo de facilitar e reutilizar os itens que já foram mostrados previamente no assistente. Tal processo de reutilização permite que seja possível também reutilizar o que está sendo criado nesse projeto em outros projetos futuros, similarmente ao que fazemos com as bibliotecas do assistente.
As definições formalizadas neste trabalho são baseadas em [1]. Inicialmente, foi definida a sintaxe, constituída das definições relacionadas a como são formadas as fórmulas. Nesse trabalho, a sintaxe é constituída das definições de fórmula bem formada, forma normal negada para as fórmulas, tamanho de fórmulas bem formadas, igualdade sintática e simplificação de fórmulas. Além disso, foi mostrado que a função de transformação de fórmulas em sua forma normal negada é correta e que nenhuma fórmula possui tamanho zero. Com relação à semântica, foi definida a satisfatibilidade das fórmulas bem formadas em suas versão local.
Todos esses resultados foram mostrados em função da definição da semântica, definida através de estruturas (ou modelos) de Kripke [3], utilizando as definições teóricas de mundo, relações e as funções que relacionam sintaxe e seu significado nesta estrutura.
O objetivo deste trabalho é a verificação da correção dessas definições e funções, mostrando que as transformações aplicadas à sintaxe preservam significaco. Isso tudo deve ser feito de forma automatizada, utilizando a ferramenta de assistente de provas Coq [2].
2 A lógica modal
Os operadores modais são símbolos que dão às sentenças uma qualificação diferente da original, similar à função de advérbios em uma frase, expandindo o significado do que tínhamos inicialmente. Nesse sentido, podemos caracterizá-la como a expansão de lógicas que não consideram essas qualificações, como a clássica.
Essa lógica possui uma sintaxe e uma semântica. Consideramos aqui a lógica multimodal, com um ou mais operadores, sendo eles o de necessidade e seu dual, de possibilidade. Provaremos alguns resultado sobre essas definições na próxima seção.
Definimos sua sintaxe, ou seja, o formato como suas fórmulas devem ser escritas e quais operadores e símbolos utilizaremos. A sintaxe da lógica modal é formada pelo que chamamos de fórmulas bem formadas, s. Primeiramente, definimos o conjunto de proposições
, o conjunto de constantes
e os utilizamos para definir as
s.
Definição 1
Denotamos por true, false
o conjunto de constantes.
Definição 2
Denotamos por o conjunto enumerável de símbolos proposicionais, em que
, com elementos indexados ou não.
Definição 3
Denotamos por agente a um elemento do conjunto , no qual
.
Definição 4
O conjunto das fórmulas bem formadas, s, é dado indutivamente a partir do conjunto
,
e
, conforme segue:
-
•
está em
, se
,
-
•
está em
, se
,
-
•
está em
, se
,
-
•
está em
, se
e a
,
-
•
,
e
estão em
, se
e
s.
Uma das noções que utilizamos é a de tamanho de uma fórmula, que é dado pela soma da quantidade de todos os símbolos proposicionais e operadores lógicos da fórmula, exceto por parênteses.
Definição 5
O tamanho de uma fórmula é definido recursivamente por :
-
•
, se
ou
-
•
-
•
-
•
Utilizamos a Forma Normal Negada (FNN) como uma forma de padronização do formato das fórmulas, com o objetivo de facilitar a leitura de sua sintaxe, além de reduzir os seus operadores somente aos de .
Definição 6
A Forma Normal Negada tem o formato de uma fórmula com seus operadores reduzidos a , aplicado somente a símbolos proposicionais, e aos operadores:
.
Definição 7
A Forma Normal Negada de uma fórmula é dada pela função , na qual
e
:
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
![]() |
Para a semântica, é utilizada a noção de modelos de Kripke [3] para a avaliação das fórmulas. Esses modelos são utilizados na definição da semântica dos operadores modais porque utilizamos a noção de mundo e das relações entre eles para definir a satisfatibilidade das fórmulas, particularmente nas que utilizam os operadores modais.
Definição 8
Um frame é uma tupla , no qual
é um conjunto não-vazio (de mundos possíveis) e cada
é uma relação em
.
Definição 9
Um modelo é uma tupla .
, no qual
é um frame e
é a função de avaliação com relação a esse frame.
Para simplificar notação, no restante do texto nós escrevemos ao invés de
. A semântica é a definição da satisfatibilidade de uma fórmula bem formada, em um determinado modelo, podendo ser ela definida de forma local ou global. Primeiramente, é preciso definir satisfatibilidade de uma fórmula em um mundo.
Definição 10
A relação de satisfatibilidade de uma fórmula na lógica multimodal em um modelo e um mundo
, é dada pela seguinte relação:
-
•
-
•
-
•
se, e somente se,
;
-
•
se e somente se
-
•
se, e somente se,
e
;
-
•
se, e somente se,
ou
;
-
•
se, e somente se,
ou
;
-
•
se, e somente se,
;
-
•
se, e somente se
e
;
Podemos definir a satisfatibilidade localmente, ou seja, em função da existência de pelo menos um mundo em que a fórmula seja satisfeita.
Definição 11
Uma fórmula é satisfatível localmente se, e somente se, existe um modelo
e existe um mundo
tal que
.
A semântica é utilizada para que possamos identificar os significados de cada símbolo da fórmula, tornando possível definições como equivalência entre fórmulas, além de provas de correção e completude, e de consistência para a lógica e o cálculo que escolhermos utilizar.
3 Resultados
Como resultados, obtivemos as formalizações no Coq das definições acima, além de provas sobre a correção da transformação fornecida pelas funções de transformação de em FNN e de equivalência semântica entre elas. A formalização e demais documentos referentes a este projeto podem ser encontrados em http://cic.unb.br/~nalon/#software.
3.1 Sintaxe
Inicialmente, foram definidos os conceitos de conjunto de símbolos proposicionais, \coqdocvarProps, como um conjunto equivalente ao de (já que
é enumerável). Além disso, o conjunto de constantes, \coqdocvarConst, foi definido como contendo os símbolos \coqdocvartt e \coqdocvarff, que correspondem, na linguagem do provador às constantes true e false, respectivamente.
Definition \coqdocvarProps := \coqdocvarnat.\coqdoceol\coqdockwInductive \coqdocvarConst: \coqdockwSet := \coqdocvartt \coqdocvarff.\coqdoceol
Definiu-se uma variável , que foi utilizada para limitar o conunto de agentes. Na definição seguinte, se relaciona um dado agente a um natural, ou seja, faz a relação de que existe um natural equivalente a esse número que está presente no conjunto. Por fim, a última definição dá exatamente a relação de que um agente pode ser transformado em um número natural.
Variable \coqdocvarn : \coqdocvarnat.\coqdoceol
Definition \coqdocvarAgents :=\coqdoceol\coqdocindent1.00em
{\coqdocvara:\coqdocvarnat (\coqdocvara
\coqdocvarn)}.\coqdoceol
Definition \coqdocvarAgents_to_Nat (\coqdocvara:\coqdocvarAgents) : \coqdocvarnat :=\coqdoceol\coqdocnoindent\coqdockwmatch \coqdocvara \coqdockwwith\coqdoceol\coqdocnoindent \coqdocvarexist \coqdocvar_ \coqdocvarm \coqdocvar_
\coqdocvarm\coqdoceol\coqdocnoindent\coqdockwend.\coqdoceol
Coercion \coqdocvarAgents_to_Nat: \coqdocvarAgents >-> \coqdocvarnat.\coqdoceol
A definição de fórmula bem-formada foi feita de forma indutiva, em função do tipo da fórmula, de forma similar à desenvolvida na teoria, como mostrado abaixo. Por exemplo, a linha “\coqdocvarPropsF : \coqdocvarProps \coqdocvarformula” diz que todo símbolo proposicional é uma fórmula. Já a linha “\coqdocvarNot : \coqdocvarformula
\coqdocvarformula” diz que a negação de uma fórmula é uma fórmula. Ou seja, temos que a última parte mostra que temos uma fórmula e as partes anteriores definem do que é formada essa fórmula.
Inductive \coqdocvarformula : \coqdockwType :=\coqdoceol\coqdocindent1.00em
\coqdocvarPropsF : \coqdocvarProps
\coqdocvarformula\coqdoceol\coqdocindent1.00em
\coqdocvarConstF : \coqdocvarConst
\coqdocvarformula\coqdoceol\coqdocindent1.00em
\coqdocvarNot : \coqdocvarformula
\coqdocvarformula\coqdoceol\coqdocindent1.00em
\coqdocvarAnd : \coqdocvarformula
\coqdocvarformula
\coqdocvarformula\coqdoceol\coqdocindent1.00em
\coqdocvarOr : \coqdocvarformula
\coqdocvarformula
\coqdocvarformula\coqdoceol\coqdocindent1.00em
\coqdocvarImp : \coqdocvarformula
\coqdocvarformula
\coqdocvarformula\coqdoceol\coqdocindent1.00em
\coqdocvarBox : \coqdocvarAgents
\coqdocvarformula
\coqdocvarformula\coqdoceol\coqdocindent1.00em
\coqdocvarDiamond : \coqdocvarAgents
\coqdocvarformula
\coqdocvarformula.\coqdoceol
Definimos também a função de tamanho de fórmula, de forma similar a como definimos na teoria, recursivamente, mostrada abaixo. Ela recebe uma fórmula e retorna o seu tamanho. Abaixo, a notação \coqdockwmatch indica que a avaliação do argumento da função é feita por casamento de padrões; o padrão \coqdocvar_ corresponde a todos os não anteriormente especificados.
Fixpoint \coqdocvarsize (\coqdocvarf: \coqdocvarformula) : \coqdocvarnat :=\coqdoceol\coqdocindent1.00em
\coqdockwmatch \coqdocvarf \coqdockwwith\coqdoceol\coqdocindent1.00em
\coqdocvarPropsF \coqdocvarp
1\coqdoceol\coqdocindent1.00em
\coqdocvarConstF \coqdocvar_
1\coqdoceol\coqdocindent1.00em
\coqdocvarNot \coqdocvarg
1 + \coqdocvarsize \coqdocvarg\coqdoceol\coqdocindent1.00em
\coqdocvarAnd \coqdocvarf \coqdocvarg
1 + (\coqdocvarsize \coqdocvarf) + (\coqdocvarsize \coqdocvarg)\coqdoceol\coqdocindent1.00em
\coqdocvarOr \coqdocvarf \coqdocvarg
1 + (\coqdocvarsize \coqdocvarf) + (\coqdocvarsize \coqdocvarg)\coqdoceol\coqdocindent1.00em
\coqdocvarImp \coqdocvarf \coqdocvarg
1 + (\coqdocvarsize \coqdocvarf) + (\coqdocvarsize \coqdocvarg)\coqdoceol\coqdocindent1.00em
\coqdocvarBox \coqdocvara \coqdocvarf
1 + (\coqdocvarsize \coqdocvarf)\coqdoceol\coqdocindent1.00em
\coqdocvarDiamond \coqdocvara \coqdocvarf
1 + (\coqdocvarsize \coqdocvarf)\coqdoceol\coqdocindent1.00em
\coqdockwend.\coqdoceol
Definimos indutivamente a árvore sintática da fórmula, uma construção similar à anterior, mas que cria uma árvore para a formatação da fórmula. A diferença se dá apenas no formato de disposição do conteúdo, mas o objetivo de significado é o mesmo. O primeiro item dessa árvore é uma folha, que é formada de uma fórmula e um número, indicando a profundidade modal dessa folha na árvore. Então, temos os operadores unários e binários, que são formados de uma fórmula e sua profundidade na árvore e um ou dois outros "galhos"da árvore, do mesmo tipo árvore, formando, assim, uma recursão, com um ou dois filhos, respectivamente.
Inductive \coqdocvartree: \coqdockwType :=\coqdoceol\coqdocindent1.00em
\coqdocvarleaf (\coqdocvarf:\coqdocvarformula) (\coqdocvarn:\coqdocvarnat)\coqdoceol\coqdocindent1.00em
\coqdocvarbinary_op (\coqdocvarf:\coqdocvarformula) (\coqdocvarn:\coqdocvarnat) (\coqdocvart1 \coqdocvart2: \coqdocvartree)\coqdoceol\coqdocindent1.00em
\coqdocvarunary_op (\coqdocvarf:\coqdocvarformula) (\coqdocvarn:\coqdocvarnat) (\coqdocvart1: \coqdocvartree).\coqdoceol
Definimos abaixo uma função recursiva de formação dessas árvores, onde os itens de uma fórmula que são indivisíveis, ou seja, o \coqdocvarPropsF e \coqdocvarConstF, são colocados como folhas e o é o número inicial mínimo. Para o operador \coqdocvarNot, fazemos uma recursão na árvore, criando um nó com a fórmula com Not e uma recursão com apenas o elemento interno. Para os casos de \coqdocvarAnd, \coqdocvarOr e \coqdocvarImp, a lógica é similar, porém com dois operadores, e, no caso, dois novos ramos. Nos casos de \coqdocvarBox e \coqdocvarDiamond, fazemos de forma similar ao \coqdocvarNot, porém é adicionado 1 ao valor inicial inicial, pois o nível modal aumenta ao se encontrar uma fórmula modal nessa árvore.
Fixpoint \coqdocvarinsert (\coqdocvarv:\coqdocvarformula) (\coqdocvarn:\coqdocvarnat) : \coqdocvartree :=\coqdoceol\coqdocindent1.00em
\coqdockwmatch \coqdocvarv \coqdockwwith\coqdoceol\coqdocindent1.00em
\coqdocvarPropsF \coqdocvarp
\coqdocvarleaf (\coqdocvarPropsF \coqdocvarp) \coqdocvarn\coqdoceol\coqdocindent1.00em
\coqdocvarConstF \coqdocvarff
\coqdocvarleaf (\coqdocvarConstF \coqdocvarff) \coqdocvarn\coqdoceol\coqdocindent1.00em
\coqdocvarConstF \coqdocvartt
\coqdocvarleaf (\coqdocvarConstF \coqdocvartt) \coqdocvarn\coqdoceol\coqdocindent1.00em
\coqdocvarNot \coqdocvarp
\coqdocvarunary_op (\coqdocvarNot \coqdocvarp) \coqdocvarn (\coqdocvarinsert \coqdocvarp \coqdocvarn)\coqdoceol\coqdocindent1.00em
\coqdocvarAnd \coqdocvarp \coqdocvarq
\coqdocvarbinary_op (\coqdocvarAnd \coqdocvarp \coqdocvarq) \coqdocvarn (\coqdocvarinsert \coqdocvarp \coqdocvarn) (\coqdocvarinsert \coqdocvarq \coqdocvarn)\coqdoceol\coqdocindent1.00em
\coqdocvarOr \coqdocvarp \coqdocvarq
\coqdocvarbinary_op (\coqdocvarOr \coqdocvarp \coqdocvarq) \coqdocvarn (\coqdocvarinsert \coqdocvarp \coqdocvarn) (\coqdocvarinsert \coqdocvarq \coqdocvarn)\coqdoceol\coqdocindent1.00em
\coqdocvarImp \coqdocvarp \coqdocvarq
\coqdocvarbinary_op (\coqdocvarImp \coqdocvarp \coqdocvarq) \coqdocvarn (\coqdocvarinsert \coqdocvarp \coqdocvarn) (\coqdocvarinsert \coqdocvarq \coqdocvarn)\coqdoceol\coqdocindent1.00em
\coqdocvarBox \coqdocvara \coqdocvarp
\coqdocvarunary_op (\coqdocvarBox \coqdocvara \coqdocvarp) \coqdocvarn (\coqdocvarinsert \coqdocvarp (\coqdocvaradd 1 \coqdocvarn))\coqdoceol\coqdocindent1.00em
\coqdocvarDiamond \coqdocvara \coqdocvarp
\coqdocvarunary_op (\coqdocvarDiamond \coqdocvara \coqdocvarp) \coqdocvarn (\coqdocvarinsert \coqdocvarp (\coqdocvaradd 1 \coqdocvarn))\coqdoceol\coqdocindent1.00em
\coqdockwend.\coqdoceol
3.2 Semântica
Nas definições abaixo, extraídas da entrada para o Coq, utilizamos um novo conceito, o conceito de tipos. Um tipo é, basicamente, uma coleção de objetos. No Coq, todos os tipos são habitados, podendo ser interpretados, portanto, como conjuntos não-vazios. O tipo é utilizado para a nossa definição de mundos porque, como visto, o conjunto dos mundos não pode ser vazio na nossa teoria.
Definimos um tipo chamado \coqdocvarW, para representar os mundos da estrutura modal.
Definition \coqdocvarW := \coqdockwType.\coqdoceol
A seguinte definição é a da relação de um agente particular sobre o conjunto de mundos.
Definition \coqdocvarRa (\coqdocvarA:\coqdocvarEnsemble \coqdocvarW) := \coqdocvarAgents \coqdocvarW
\coqdocvarW
\coqdockwProp.\coqdoceol
Definimos um caminho abaixo. Nessa definição, dividimos em um caminho vazio e um caminho com elementos. O vazio define um caminho como sendo uma combinação de que existe uma relação de um mundo \coqdocvarw1 com um mundo \coqdocvarw2. Na segunda parte da definição, temos que um caminho de \coqdocvarw1 para \coqdocvarw2 existe se temos uma relação de \coqdocvarw1 com algum mundo \coqdocvarv e que existe um caminho de \coqdocvarv para \coqdocvarw2. Ou seja, a primeira definição temos uma relação direta de \coqdocvarw1 para \coqdocvarw2 e na segunda temos uma relação com itens intermediários, saindo de \coqdocvarw1 e eventualmente, computando os próximos nós da relação de forma sucessiva, chegando ao final em \coqdocvarw2.
Inductive \coqdocvarPath (\coqdocvarA:\coqdocvarEnsemble \coqdocvarW) (\coqdocvarw1 \coqdocvarw2:\coqdocvarW) (\coqdocvarR:\coqdocvarRa \coqdocvarA) : \coqdockwProp:=\coqdoceol\coqdocindent1.00em
\coqdocvarempty : \coqdockw
\coqdocvara, (\coqdocvarR \coqdocvara (\coqdocvarIn \coqdocvarW \coqdocvarA \coqdocvarw1) (\coqdocvarIn \coqdocvarW \coqdocvarA \coqdocvarw2))
\coqdocvarPath \coqdocvarA \coqdocvarw1 \coqdocvarw2 \coqdocvarR\coqdoceol\coqdocindent1.00em
\coqdocvarapp: \coqdockw
\coqdocvara \coqdocvarv, (\coqdocvarR \coqdocvara (\coqdocvarIn \coqdocvarW \coqdocvarA \coqdocvarw1) (\coqdocvarIn \coqdocvarW \coqdocvarA \coqdocvarv))
(\coqdocvarPath \coqdocvarA \coqdocvarv \coqdocvarw2 \coqdocvarR)
\coqdocvarPath \coqdocvarA \coqdocvarw1 \coqdocvarw2 \coqdocvarR.\coqdoceol
Foram definidas propriedades relacionadas ao resultado de caminho. A primeira delas é sobre relações que sejam acíclicas, ou seja, não podem ser repetidos elementos que já estão no caminho. Na segunda, definimos o que significa um mundo tem pai, ou seja, tem uma conexão acima dele. Na terceira, definimos raiz como sendo um mundo sem ter um pai. Por fim, definimos a unicidade de raiz. Isso define as propriedades necessárias para que depois a definição de modelo em formato de árvore possa ser formalizada.
Definition \coqdocvarRa_acyclic (\coqdocvarA:\coqdocvarEnsemble \coqdocvarW) (\coqdocvarR:\coqdocvarRa \coqdocvarA) := \coqdockw (\coqdocvarw:\coqdocvarW),
\coqdocvarPath \coqdocvarA \coqdocvarw \coqdocvarw \coqdocvarR.\coqdoceol
Definition \coqdocvarhas_parent (\coqdocvarA:\coqdocvarEnsemble \coqdocvarW) (\coqdocvarR:\coqdocvarRa \coqdocvarA) (\coqdocvarw1:\coqdocvarW) := \coqdoctac \coqdocvara \coqdocvarw, \coqdocvarR \coqdocvara (\coqdocvarIn \coqdocvarW \coqdocvarA \coqdocvarw) (\coqdocvarIn \coqdocvarW \coqdocvarA \coqdocvarw1).\coqdoceol
Definition \coqdocvaris_root (\coqdocvarA:\coqdocvarEnsemble \coqdocvarW) (\coqdocvarR:\coqdocvarRa \coqdocvarA) (\coqdocvarw1:\coqdocvarW) := \coqdoctac \coqdocvara \coqdocvarw3, \coqdocvarR \coqdocvara (\coqdocvarIn \coqdocvarW \coqdocvarA \coqdocvarw1) (\coqdocvarIn \coqdocvarW \coqdocvarA \coqdocvarw3)
~(\coqdocvarhas_parent \coqdocvarA \coqdocvarR \coqdocvarw1).\coqdoceol
Definition \coqdocvarunique_root (\coqdocvarA:\coqdocvarEnsemble \coqdocvarW) (\coqdocvarR:\coqdocvarRa \coqdocvarA) := \coqdoctac \coqdocvarw1, (\coqdocvaris_root \coqdocvarA \coqdocvarR \coqdocvarw1)
\coqdockw
\coqdocvara, ~(\coqdocvara = \coqdocvarw1)
~(\coqdocvaris_root \coqdocvarA \coqdocvarR \coqdocvara).\coqdoceol
Definimos, então, um frame, também como um tipo. Nessa definição, utilizamos o conceito de conjunto de mundos \coqdocvarW, definido acima. Além disso, temos \coqdocvarR, um conjunto de relações binárias. Os símbolos % \coqdockwtype indicam que essa construção deve ser considerada pelo assistente de provas também como um tipo. Essa definição diz que temos um \coqdocvarFrame, que é um tipo, no qual temos um conjunto de mundos e um conjunto de relações binárias, tais que as relações são definidas entre dois desses mundos.
Definition \coqdocvarFrame (\coqdocvarA:\coqdocvarEnsemble \coqdocvarW) : \coqdockwType := (\coqdocvarEnsemble \coqdocvarW\coqdocvarRa \coqdocvarA).\coqdoceol
A definição da função de avaliação é feita como na Seção 3.1: dado um mundo \coqdocvarW e um símbolo proposicional (nesse caso, um dos símbolos pertencentes ao conjunto \coqdocvarProps), retorna verdadeiro ou falso (como definidos pelo tipo \coqdocvarbool em Coq).
Definition \coqdocvarpi := \coqdocvarW \coqdocvarProps
\coqdocvarbool.\coqdoceol
Por fim, a definição de modelo é dada pelas triplas ordenadas de mundos, \coqdocvarW, relações, \coqdocvarR, e função de avaliação, \coqdocvarpi:
Definition \coqdocvarModel (\coqdocvarA:\coqdocvarEnsemble \coqdocvarW) : \coqdockwType :=
\coqdocindent1.00em
(\coqdocvarFrame \coqdocvarA \coqdocvarpi) %\coqdockwtype.\coqdoceol
A definição de satisfatibilidade é feita recursivamente para cada formato de fórmula. Para um símbolo proposicional , a função retorna True (respectivamente, False) se a função \coqdocvarpi o avalia para verdadeiro (respectivamente, para falso). No caso de fórmulas complexas, aplica-se recursão. Por exemplo, para a fórmula
, recursão é aplicada às suas subfórmulas
e
. Note na definição abaixo que, na notação do provador, \coqdocvarOr é o operador na linguagem-objeto; o operador
simboliza a operação na metalinguagem.
Fixpoint \coqdocvarsat (\coqdocvarA:\coqdocvarEnsemble \coqdocvarW) (\coqdocvarM:\coqdocvarModel \coqdocvarA) (\coqdocvarw:\coqdocvarW) (\coqdocvarf:\coqdocvarformula): \coqdockwProp :=\coqdoceol\coqdocindent0.50em
\coqdockwlet \coqdocvarR := \coqdocvarsnd(\coqdocvarfst(\coqdocvarM)) \coqdoctacin \coqdoceol\coqdocindent0.50em
\coqdockwlet \coqdocvarpi:= \coqdocvarsnd \coqdocvarM \coqdoctacin\coqdoceol\coqdocindent1.00em
\coqdockwmatch \coqdocvarf \coqdockwwith \coqdoceol\coqdocindent1.00em
\coqdocvarConstF \coqdocvartt
\coqdocvarTrue\coqdoceol\coqdocindent1.00em
\coqdocvarConstF \coqdocvarff
\coqdocvarFalse\coqdoceol\coqdocindent1.00em
\coqdocvarPropsF \coqdocvarp
\coqdockwif (\coqdocvarpi \coqdocvarw \coqdocvarp) \coqdockwthen \coqdocvarTrue \coqdockwelse \coqdocvarFalse\coqdoceol\coqdocindent1.00em
\coqdocvarNot \coqdocvarg
~(\coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw \coqdocvarg)\coqdoceol\coqdocindent1.00em
\coqdocvarAnd \coqdocvarg \coqdocvarh
(\coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw \coqdocvarg)
(\coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw \coqdocvarh)\coqdoceol\coqdocindent1.00em
\coqdocvarOr \coqdocvarg \coqdocvarh
(\coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw \coqdocvarg)
(\coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw \coqdocvarh)\coqdoceol\coqdocindent1.00em
\coqdocvarImp \coqdocvarg \coqdocvarh
~(\coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw \coqdocvarg)
(\coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw \coqdocvarh)\coqdoceol\coqdocindent1.00em
\coqdocvarBox \coqdocvara \coqdocvarg
\coqdockw
\coqdocvarw’:\coqdocvarW, ((\coqdocvarR \coqdocvara) (\coqdocvarIn \coqdocvarW \coqdocvarA \coqdocvarw) (\coqdocvarIn \coqdocvarW \coqdocvarA \coqdocvarw’))
(\coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw’ \coqdocvarg)\coqdoceol\coqdocindent1.00em
\coqdocvarDiamond \coqdocvara \coqdocvarg
\coqdoctac
\coqdocvarw’:\coqdocvarW, ((\coqdocvarR \coqdocvara) (\coqdocvarIn \coqdocvarW \coqdocvarA \coqdocvarw) (\coqdocvarIn \coqdocvarW \coqdocvarA \coqdocvarw’))
(\coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw’ \coqdocvarg)\coqdoceol\coqdocindent1.00em
\coqdockwend.\coqdoceol
A definição de satisfatibilidade local também segue a apresentação da Seção 3.2. Uma fórmula é localmente satisfatível, se existe um modelo e um mundo nesse modelo que satisfaçam a fórmula recebida como entrada.
Definition \coqdocvarlocally_satisfatible (\coqdocvarA:\coqdocvarEnsemble \coqdocvarW) (\coqdocvarf:\coqdocvarformula): \coqdockwProp := \coqdoctac (\coqdocvarM:\coqdocvarModel \coqdocvarA), \coqdoctac
\coqdocvarw:\coqdocvarW, \coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw \coqdocvarf.\coqdoceol
Duas fórmulas são semanticamente equivalentes se sua avaliação é a mesma em todos os modelos e mundos:
Definition \coqdocvareq_semantica (\coqdocvarA:\coqdocvarEnsemble \coqdocvarW) (\coqdocvarf \coqdocvarg : \coqdocvarformula) : \coqdockwProp :=\coqdoceol\coqdocindent1.00em
\coqdockw (\coqdocvarM:\coqdocvarModel \coqdocvarA) (\coqdocvarw:\coqdocvarW), \coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw \coqdocvarf = \coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw \coqdocvarg.\coqdoceol
Definition \coqdocvartree_locally_satisfatible (\coqdocvarA:\coqdocvarEnsemble \coqdocvarW) (\coqdocvarf:\coqdocvarformula): \coqdockwProp := \coqdoctac (\coqdocvarM:\coqdocvarModel \coqdocvarA), \coqdoctac
(\coqdocvarw:\coqdocvarW), \coqdocvarM_tree_like \coqdocvarA \coqdocvarM
\coqdocvaris_root \coqdocvarA (\coqdocvarsnd(\coqdocvarfst \coqdocvarM)) \coqdocvarw
\coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw \coqdocvarf.\coqdoceol
Definition \coqdocvarpointed_model (\coqdocvarA:\coqdocvarEnsemble \coqdocvarW) (\coqdocvarw:\coqdocvarW) (\coqdocvarM:\coqdocvarModel \coqdocvarA) := (\coqdocvarIn \coqdocvarW (\coqdocvarfst (\coqdocvarfst \coqdocvarM)) \coqdocvarw). \coqdocemptyline
3.3 Forma Normal Negada
A função abaixo define fórmulas na Forma Normal Negada (FNN). Tal função recebe uma fórmula em e retorna verdadeiro ou falso, ou seja, se a fórmula está na FNN ou não. Lembrando, o padrão \coqdocvar_ corresponde a todos os não anteriormente especificados. Portanto, quando o operador de negação \coqdocvarNot é aplicado a símbolos proposicionais, a função retorna verdadeiro; aplicado a qualquer outra fórmula, resulta em falso.
Fixpoint \coqdocvaris_NNF (\coqdocvarf:\coqdocvarformula): \coqdockwProp :=\coqdoceol\coqdocindent1.00em
\coqdockwmatch \coqdocvarf \coqdockwwith \coqdoceol\coqdocindent1.00em
\coqdocvarPropsF \coqdocvarp
\coqdocvarTrue\coqdoceol\coqdocindent1.00em
\coqdocvarConstF \coqdocvarff
\coqdocvarTrue\coqdoceol\coqdocindent1.00em
\coqdocvarConstF \coqdocvartt
\coqdocvarTrue\coqdoceol\coqdocindent1.00em
\coqdocvarNot (\coqdocvarPropsF \coqdocvarp)
\coqdocvarTrue\coqdoceol\coqdocindent1.00em
\coqdocvarNot \coqdocvar_
\coqdocvarFalse\coqdoceol\coqdocindent1.00em
\coqdocvarAnd \coqdocvarf \coqdocvarg
(\coqdocvaris_NNF \coqdocvarf )
(\coqdocvaris_NNF \coqdocvarg)\coqdoceol\coqdocindent1.00em
\coqdocvarOr \coqdocvarf \coqdocvarg
(\coqdocvaris_NNF \coqdocvarf )
(\coqdocvaris_NNF \coqdocvarg)\coqdoceol\coqdocindent1.00em
\coqdocvarImp \coqdocvar_ \coqdocvar_
\coqdocvarFalse\coqdoceol\coqdocindent1.00em
\coqdocvarBox \coqdocvara \coqdocvarf
(\coqdocvaris_NNF \coqdocvarf)\coqdoceol\coqdocindent1.00em
\coqdocvarDiamond \coqdocvara \coqdocvarf
(\coqdocvaris_NNF \coqdocvarf)\coqdoceol\coqdocindent1.00em
\coqdockwend.\coqdoceol
Definimos a função indutiva de transformação de uma fórmula em sua FNN no formato abaixo, preservando as características teóricas. A função recebe uma fórmula em como entrada e retorna outra fórmula em
. É importante observar que o Coq só aceita a formalização de funções totais e terminantes. Observa-se da definição abaixo que a função é de fato total. Entretanto, o assistente de prova não consegue encontrar automaticamente as condições de terminação. O motivo é que o resultado da função é aplicado a fórmulas que não são subfórmula da entrada. Por exemplo, da Definição 7, o resultado da aplicação a
é o resultado da recursão sobre
e
. Estas últimas não são subfórmulas de
e, portanto, o assistente não consegue extrair o princípio de indução adequado e provar automaticamente sua terminação. Entretanto, é claramente observável que a recursão ocorre em argumentos de tamanhos menores do que o original. Por isso, esta função foi definida de forma mais geral (utilizando \coqdockwFunction ao invés de \coqdockwFixpoint) e adicionando-se que o cálculo da terminação é feita em relação ao tamanho da fórmula. Isto é expresso pela anotação
na seguinte definição.
Function \coqdocvarNNF (\coqdocvarf:\coqdocvarformula) {\coqdockwmeasure \coqdocvarsize}: \coqdocvarformula :=\coqdoceol\coqdocindent1.00em
\coqdockwmatch \coqdocvarf \coqdockwwith\coqdoceol\coqdocindent1.00em
\coqdocvarPropsF \coqdocvarp
\coqdocvarPropsF \coqdocvarp\coqdoceol\coqdocindent1.00em
\coqdocvarConstF \coqdocvarff
\coqdocvarConstF \coqdocvarff\coqdoceol\coqdocindent1.00em
\coqdocvarConstF \coqdocvartt
\coqdocvarConstF \coqdocvartt\coqdoceol\coqdocindent1.00em
\coqdocvarNot (\coqdocvarPropsF \coqdocvarp)
\coqdocvarNot (\coqdocvarPropsF \coqdocvarp)\coqdoceol\coqdocindent1.00em
\coqdocvarNot (\coqdocvarConstF \coqdocvarff)
\coqdocvarConstF \coqdocvartt\coqdoceol\coqdocindent1.00em
\coqdocvarNot (\coqdocvarConstF \coqdocvartt)
\coqdocvarConstF \coqdocvarff\coqdoceol\coqdocindent1.00em
\coqdocvarNot (\coqdocvarNot \coqdocvarf)
\coqdocvarNNF \coqdocvarf\coqdoceol\coqdocindent1.00em
\coqdocvarNot (\coqdocvarAnd \coqdocvarf \coqdocvarg)
\coqdocvarOr (\coqdocvarNNF (\coqdocvarNot \coqdocvarf)) (\coqdocvarNNF (\coqdocvarNot \coqdocvarg))\coqdoceol\coqdocindent1.00em
\coqdocvarNot (\coqdocvarOr \coqdocvarf \coqdocvarg)
\coqdocvarAnd (\coqdocvarNNF (\coqdocvarNot \coqdocvarf)) (\coqdocvarNNF (\coqdocvarNot \coqdocvarg))\coqdoceol\coqdocindent1.00em
\coqdocvarNot (\coqdocvarImp \coqdocvarf \coqdocvarg)
\coqdocvarAnd (\coqdocvarNNF \coqdocvarf) (\coqdocvarNNF (\coqdocvarNot \coqdocvarg))\coqdoceol\coqdocindent1.00em
\coqdocvarNot (\coqdocvarBox \coqdocvara \coqdocvarf)
\coqdocvarDiamond \coqdocvara (\coqdocvarNNF (\coqdocvarNot \coqdocvarf))\coqdoceol\coqdocindent1.00em
\coqdocvarNot (\coqdocvarDiamond \coqdocvara \coqdocvarf)
\coqdocvarBox \coqdocvara (\coqdocvarNNF (\coqdocvarNot \coqdocvarf)) \coqdoceol\coqdocindent1.00em
\coqdocvarAnd \coqdocvarf \coqdocvarg
\coqdocvarAnd (\coqdocvarNNF \coqdocvarf) (\coqdocvarNNF \coqdocvarg)\coqdoceol\coqdocindent1.00em
\coqdocvarOr \coqdocvarf \coqdocvarg
\coqdocvarOr (\coqdocvarNNF \coqdocvarf) (\coqdocvarNNF \coqdocvarg)\coqdoceol\coqdocindent1.00em
\coqdocvarImp \coqdocvarf \coqdocvarg
\coqdocvarOr (\coqdocvarNNF (\coqdocvarNot \coqdocvarf)) (\coqdocvarNNF \coqdocvarg)\coqdoceol\coqdocindent1.00em
\coqdocvarBox \coqdocvara \coqdocvarf
\coqdocvarBox \coqdocvara (\coqdocvarNNF \coqdocvarf)\coqdoceol\coqdocindent1.00em
\coqdocvarDiamond \coqdocvara \coqdocvarf
\coqdocvarDiamond \coqdocvara (\coqdocvarNNF \coqdocvarf)\coqdoceol\coqdocindent1.00em
\coqdockwend.\coqdoceol
A prova de terminação é feita por indução no tamanho da fórmula, sendo que a maior parte dos casos é obtida automaticamente através de simplificação pelo assistente de prova, utilizando aritmética linear inteira. Para o caso da implicação, foi necessário utilizar fatos sobre desigualde entre inteiros, mas o restante da prova é obtida automaticamente também com o auxílio da implementação dos procedimentos de prova, no Coq, para a aritmética linear inteira.
Além de totalidade e terminação, é essencial que provemos que a função \coqdocvarNNF é correta, isto é, mostrar que o resultado da sua aplicação está, de fato, no formato de FNN. O próximo lema mostra a correção da função:
Theorem \coqdocvarNNF_is_NNF (\coqdocvarf:\coqdocvarformula) : \coqdoceol\coqdocindent1.00em \coqdocvaris_NNF (\coqdocvarNNF \coqdocvarf).\coqdoceol
A prova do teorema acima é feita por indução sobre o resultado da aplicação de (\coqdocvarNNF \coqdocvarf), que se baseia na medida de complexidade (no tamanho da fórmula) dada acima. A prova é obtida automaticamente pelo provador.
O teorema seguinte mostra que a função de transformação de uma fórmula na sua forma normal negada preserva seu valor semântico.
Theorem \coqdocvareq_NNF_f (\coqdocvarA:\coqdocvarEnsemble \coqdocvarW) (\coqdocvarf : \coqdocvarformula) :\coqdoceol\coqdocindent1.00em
\coqdockw (\coqdocvarM:\coqdocvarModel \coqdocvarA) (\coqdocvarw:\coqdocvarW), \coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw \coqdocvarf
\coqdocvarsat \coqdocvarA \coqdocvarM \coqdocvarw (\coqdocvarNNF \coqdocvarf).\coqdoceol
A prova foi feita por indução em (\coqdocvarFNN \coqdocvarf), assim como na prova de terminação da aplicação da função \coqdocvarFNN apresentada na seção anterior. Para os casos-base, isto é constantes, símbolos proposicionais ou negações de símbolos proposicionais, as provas são simples e seguem diretamente da definição de satisfatibilidade para estas fórmulas (porque a fórmula e sua forma normal negada coincidem). A hipótese de indução é de que a propriedade vale para fórmulas de tamanho menor que a fórmula que está sendo analisada. Para fórmulas complexas, são aplicadas as hipóteses e a conclusão segue em cada caso com poucas linhas de prova. Por exemplo, precisamos mostrar que, dados um modelo \coqdocvarM e um mundo \coqdocvarw, o resultado da aplicação de \coqdocvarsat \coqdocvarM \coqdocvarw para a fórmula \coqdocvarNot (\coqdocvarNot \coqdocvarProps \coqdocvarp) é exatamente o mesmo que \coqdocvarsat \coqdocvarM \coqdocvarw (\coqdocvarProps \coqdocvarp), na qual esta última fórmula é o resultado da aplicação \coqdocvarNNF \coqdocvarNot (\coqdocvarNot \coqdocvarProps \coqdocvarp).
4 Conclusão
Neste trabalho, apresentamos uma formalização da lógica multimodal no assistente de provas Coq, baseada em teoremas e definições teóricas. Assim, mostramos ser possível a formalização de conceitos matemáticos teóricos de sintaxe e semântica, relacionados à lógica monomodal na linguagem computacional do assistente de provas. Em um próximo projeto de pesquisa, essa lógica será expandida para a multimodal, completando, assim, essa etapa de formalizações.
Referências
- [1] Cláudia Nalon, Clare Dixon, and Ullrich Hustadt. 2019. Modal Resolution: Proofs, Layers, and Refinements. ACM Trans. Comput. Logic 20, 4, Article 23 (August 2019), 38 pages. \doi10.1145/3331448
- [2] The Coq Proof Assistant, version 8.12.2 (December 2020) \doi10.5281/zenodo.4501022
- [3] Melvin Fitting, Richard L. Mendelsohn: First-Order Modal Logic. Springer Science+Business Media, Dordrecht (1998) \doi10.1007/978-94-011-5292-1