我正在研究在python（2.7.5版本）中实现的模态逻辑tableau解算器。 所以我已经有了一个将输入字符串转换为tableau格式的函数：
输入：
~p ^ q
解析：
['and',('not', 'p'), 'q']
已应用解析和Alpha规则：
[('not', 'p'), 'q']
现在，我处理了交叉，双重否定等alpha公式。 我现在遇到的问题是 beta公式，例如Union。
对于Union公式，我需要编写一个函数，将一个列表拆分为两个列表，例如：
输入：
('and', 's', ('or', (not,'r'), 'q'))
输出：
1st list ('s',('not','r'))
2nd list ('s','q')
我可以轻松地执行一次，但是如何递归扫描公式并生成这些列表，以便稍后我可以扫描它们并验证它们是否已关闭？
这样做的最终目标是创建一个画面求解器，它生成一个模型图或返回一个公式不可满足的答案。
答案 0 :(得分：2)
这是一个非常有趣的项目:)。我现在正在谈论模态逻辑。
我首先建议您使用InToHyLo输入格式，这在现有解算器中非常标准。
InToHyLo格式如下：
file ::= ['begin'] dml ['end']
fml ::= '(' fml ')' (* parentheses *)
| '1' | 'true' | 'True' | 'TRUE' (* truth *)
| '0' | 'false' | 'False' | 'FALSE' (* falsehood *)
| '~' fml | '-' fml (* negation *)
| '<>' fml | '<' id '>' fml (* diamonds *)
| '[]' fml | '[' id ']' fml (* boxes *)
| fml '&' fml (* conjunction *)
| fml '|' fml (* disjunction *)
| fml '->' fml (* implication *)
| fml '<->' fml (* equivalence *)
| id (* prop. var. *)
where identifiers (id) are arbitrary nonempty alphanumeric sequences: (['A'-'Z' 'a'-'z' '0'-'9']+)
简化公式的解析并专注于真正的问题：解决实例。我建议你使用像flex/bison这样的现有解析器。
通过互联网查找您的问题，（我远不是Python的专家）看起来像“http://pyparsing.wikispaces.com”库是解析的参考。
之后，只需使用Bison，您的文件就会被完全解析。
这是我的Bison文件（在解决方案C ++中使用Flex / Bison）：
/*
*
* Compile with bison.
*/
/*** Code inserted at the begin of the file. ***/
%{
#include <stdlib.h>
#include <list>
#include "Formula.h"
// yylex exists
extern int yylex();
extern char yytext[];
void yyerror(char *msg);
%}
/*** Bison declarations ***/
%union
{
bool bval;
operator_t opval;
char *sval;
TermPtr *term;
}
%token LROUND RROUND
%left IFF
%left IMP
%left OR
%left AND
%right DIAMOND
%right BOX
%right NOT
%token VALUE
%token IDENTIFIER
%type<bval> VALUE
%type<sval> IDENTIFIER
%type<term> Formula BooleanValue BooleanFormula ModalFormula PropositionalVariable UnaryFormula
%type<opval> BinaryBoolOperator UnaryBoolOperator ModalOperator
%start Start
%%
Start:
| Formula { (Formula::getFormula()).setRoot(*$1); }
;
Formula: BooleanFormula { $$ = $1; }
| ModalFormula { $$ = $1; }
| UnaryFormula { $$ = $1; }
| LROUND Formula RROUND { $$ = $2; }
;
BooleanValue: VALUE { $$ = new TermPtr( (Term*) new BooleanValue($1) ); }
;
PropositionalVariable: IDENTIFIER { $$ = new TermPtr( (Term*) new PropositionalVar($1) ); }
;
BooleanFormula: Formula BinaryBoolOperator Formula {
$$ = new TermPtr( (Term*) new BooleanOp(*$1, *$3, $2) ); /* can be (A OR B) or (A AND B) */
delete($3);
delete($1);
}
| Formula IMP Formula {
($1)->Negate();
$$ = new TermPtr( (Term*) new BooleanOp(*$1, *$3, O_OR) ); /* A -> B can be written : (¬A v B) */
delete($3);
delete($1);
}
| PropositionalVariable IFF PropositionalVariable {
PropositionalVar *Copy1 = new PropositionalVar( *((PropositionalVar*)$1->getPtr()) );
PropositionalVar *Copy3 = new PropositionalVar( *((PropositionalVar*)$3->getPtr()) );
TermPtr Negated1( (Term*)Copy1, $1->isNegated() );
TermPtr Negated3( (Term*)Copy3, $3->isNegated() );
Negated1.Negate();
Negated3.Negate();
TermPtr Or1( (Term*) new BooleanOp(Negated1, *$3, O_OR) ); /* Or1 = (¬A v B) */
TermPtr Or2( (Term*) new BooleanOp(Negated3, *$1, O_OR) ); /* Or2 = (¬B v A) */
$$ = new TermPtr( (Term*) new BooleanOp(Or1, Or2, O_AND) ); /* We add : (Or1 AND OrB) */
delete($3);
delete($1);
}
;
ModalFormula: ModalOperator LROUND Formula RROUND {
$$ = new TermPtr( (Term*) new ModalOp(*$3, $1) );
delete($3);
}
|
ModalOperator ModalFormula {
$$ = new TermPtr( (Term*) new ModalOp(*$2, $1) );
delete($2);
}
|
ModalOperator UnaryFormula {
$$ = new TermPtr( (Term*) new ModalOp(*$2, $1) );
delete($2);
}
;
UnaryFormula: BooleanValue { $$ = $1; }
| PropositionalVariable { $$ = $1; }
|
UnaryBoolOperator UnaryFormula {
if ($1 == O_NOT) {
($2)->Negate();
}
$$ = $2;
}
|
UnaryBoolOperator ModalFormula {
if ($1 == O_NOT) {
($2)->Negate();
}
$$ = $2;
}
|
UnaryBoolOperator LROUND Formula RROUND {
if ($1 == O_NOT) {
($3)->Negate();
}
$$ = $3;
}
;
ModalOperator: BOX { $$ = O_BOX; }
| DIAMOND { $$ = O_DIAMOND; }
;
BinaryBoolOperator: AND { $$ = O_AND; }
| OR { $$ = O_OR; }
;
UnaryBoolOperator: NOT { $$ = O_NOT; }
;
/*** Code inserted at the and of the file ***/
%%
void yyerror(char *msg)
{
printf("PARSER: %s", msg);
if (yytext[0] != 0)
printf(" near token '%s'\n", yytext);
else
printf("\n");
exit(-1);
}
通过调整它，你将能够完全和递归地解析模态逻辑公式:)。
如果稍后，您想要将您的求解器挑战现有的画面求解器（例如Spartacus）。不要忘记这些解决方案几乎一直都在，回答一个最大的开放Tableau，所以如果你想找到解决方案的Kripke模型，它们肯定会更快;）
我希望我设法帮助你解决问题，我希望不那么理论化，但遗憾的是我没有掌握python：/。
希望你的求解者能做到最好;
最诚挚的问候。
如果你接受我使用InToHyLo的提议，我最近在Kripke模型的Checker上使用了模态逻辑K.你可以在这里找到：http://www.cril.univ-artois.fr/~montmirail/mdk-verifier/
最近发表于PAAR'2016：
检查模态逻辑的Kripke模型K ，Jean-Marie Lagniez，Daniel Le Berre，Tiago de Lima和Valentin Montmirail，第五届自动推理实用方面研讨会论文集（PAAR 2016） ）
答案 1 :(得分：1)
这个问题已经对我最初的问题有一个选定的答案。如果有人对多种不同模型逻辑的完整实现感兴趣，请阅读我的report here。它包含许多细节，因此您不会迷路。
可以在我的github repo here中找到解析器本身（Python）的实现。 代码的文档不是最好的，但是如果你理解了理论，你应该很容易找到它，我希望:)。