Prolog 中是否可以进行自适应解析？
Is adaptive parsing possible in Prolog?
我正在尝试在 Prolog 中编写一个 adaptive parser：换句话说，一个可以在运行时修改自己的解析规则的解析器。
为此，我需要在运行时生成新的谓词，但我不确定这是否可行。是否可以编写一个带有这样一个列表的谓词：
generate_dcg_rule([A," is greater than ",B]).
...然后生成一个像这样的新谓词？
expr(A," is greater than ",B) -->
symbol(A)," is greater than ",symbol(B).
是的，这很容易实现。
Prolog 是一种非常动态的语言，您可以在运行时断言任意子句，例如使用 assertz/1。
您可以使用通常用于执行此操作的 Prolog 术语扩展机制将 DCG 规则扩展为普通 Prolog 规则。
例如，使用expand_term/2:
?- expand_term((expr(A," is greater than ",B) -->
symbol(A)," is greater than ",symbol(B)), Clause).
Clause = (expr(A, [' ', i, s, ' ', g, r, e|...], B, _G242, _G253):-symbol(A, _G242, _G264), _G264=[' ', i, s, ' ', g|...], symbol(B, _G275, _G253)).
您可以使用 assertz/1:
断言此类子句
?- expand_term((Head --> Body), Clause), assertz(Clause).
请注意，我在此示例中使用 double_quotes 设置为 chars，即使用：
:- set_prolog_flag(double_quotes, chars).
在你的源文件中。无论如何，这是个好主意。
另请注意，我假设您已经找到一种方法将您在 generate_dcg_rule/1 示例中给出的列表转换为实际的 DCG。对于此翻译，我宁愿推荐像 list_dcg/2 这样的谓词，它以声明方式描述此类列表和 DCG 规则之间的 关系 。优点很明显：例如，您可以 test 这种关系与测试用例等交互。对于您的具体示例，定义此关系的一个子句可能类似于：
list_dcg([A,Ls,B], DCG) :-
Ls = "is greater than ",
DCG = (expr(A, Ls, B) --> symbol(A), Ls, symbol(B)).
我将此推广到您的其他用例作为练习。总的来说，动态断言此类子句的一种方法是：
?- list_dcg(List, DCG), expand_term(DCG, Clause), assertz(Clause).
请注意我们如何从此类示例中的 Prolog homoiconic 性质中获益：Prolog 规则 和 DCG 规则具有 Prolog [=] 的自然表示44=]项，我们可以简单地将它们写下来并像目标中的任何其他项一样对它们进行推理。
我编写了一个自适应解析器，可以将英语短语转换为数学表达式。您可以使用自己的翻译规则轻松扩展它，因此它可以用于创建可扩展的自然语言用户界面。
这是一种可能的输入：
(A squared) times (b squared) equals c to the power of 3 times the product of 5 and 6
这是它的输出：
(A * A) * (b * b) = c ^ 3 * 5 * 6
程序的实现如下所示：
:- initialization(main).
:- set_prolog_flag(double_quotes, chars). % This is for SWI 7+ to revert to the prior interpretation of quoted strings.
%This is an adaptive parser for SWI-Prolog.
main :-
%Type any kind of input here to see the output! The input must be compatible with the grammar that is defined below.
Input = "(A squared) times (b squared) equals c to the power of 3 times the product of 5 and 6",
iterated_translate(Input,Output), writeln(Input), writeln(Output), writeln('\n'), writeln('\n').
%The grammar is defined here. The variables must be uppercase letters.
%The input in each translation rule is followed by its output.
theList(TheList) :-
%You can easily extend this parser by adding more rules to this list.
TheList =
[['A to the power of B',
'A ^ B'],
%The next transformation is the final output of 'A to the power of B'.
['A ^ B',
'A ^ B'],
['A * B',
'A * B'],
['the product of A and B',
'A times B'],
['A squared',
'the product of A and A'],
['A times B',
'A * B'],
['A = B',
'A = B'],
['A equals B', 'A = B']].
%This is the end of the grammar. The rest of the translator is implemented below.
output_expr(Lang,[Input,[A,B]]) -->
{
theList(TheList),
list_to_output__(TheList,TheList1,[A,B]),
member([Input,Output],
TheList1)
},
input_to_output_(Lang,Input,Output).
atom_is_upper(N) :-
atom_chars(N, [L]),
char_type(L, upper).
atom_is_var(Names_to_vars,Atom,Var) :-
atom(Atom),atom_is_upper(Atom),member([Atom,Var],Names_to_vars).
list_to_output__([],[],_) :- true.
list_to_output__([Start1|Rest1],[Start2|Rest2],Vars) :-
list_to_output_(Start1,Start2,Vars),list_to_output__(Rest1,Rest2,Vars).
list_to_output_([A1_,B1_],[A2,B2],Vars) :- atomic_list_concat(A1,' ',A1_),atomic_list_concat(B1,' ',B1_),list_to_output(A1,A2,Vars),list_to_output(B1,B2,Vars).
list_to_output([],[],_) :- true.
list_to_output([Start1|Rest1],[Start2|Rest2],[A,B]) :-
(Start1='A'->Start2=A;Start1='B'-> Start2=B;Start1=Start2),list_to_output(Rest1,Rest2,[A,B]).
list_to_grammar_(Lang,Start,Rest) -->
{(Start = [A])->(Rest = []->Start1 = expr(Lang,A);Start1 = parentheses_expr(Lang,A));atom_chars(Start,Start1)},Start1.
list_to_grammar(Lang,[Start]) -->
list_to_grammar_(Lang,Start,[]).
list_to_grammar(Lang,[Start|Rest]) -->
list_to_grammar_(Lang,Start,Rest),ws_,list_to_grammar(Lang,Rest).
a_number([A,B]) -->
(a__number(A), ".", a__number(B)).
a_number(A) -->
a__number(A).
a__number([L|Ls]) --> digit(L), a__number_r(Ls).
a__number_r([L|Ls]) --> digit(L), a__number_r(Ls).
a__number_r([]) --> [].
digit(Let) --> [Let], { code_type(Let, digit) }.
symbol([L|Ls]) --> letter(L), symbol_r(Ls).
symbol_r([L|Ls]) --> letter(L), symbol_r(Ls).
symbol_r([]) --> [].
letter(Let) --> [Let], { code_type(Let, alpha) }.
ws --> "";((" ";"\n"),ws).
ws_ --> (" ";"\n"),ws.
input_to_output(Lang,A,B) -->
{Lang = input} ->
A;
{Lang=output} ->
B.
input_to_output_(Lang,A,B) -->
{A_=list_to_grammar(Lang,A),B_=list_to_grammar(Lang,B)},input_to_output(Lang,A_,B_).
parentheses_expr(Lang,["(",A,")"]) -->
("(",(expr(Lang,A)),")").
parentheses_expr(_,symbol(A)) -->
symbol(A).
parentheses_expr(_,a_number(A)) -->
a_number(A).
expr(Lang,A) -->
parentheses_expr(Lang,A);output_expr(Lang,A).
translate(Input1,Output1) :-
phrase(output_expr(input,Ls),Input1),
phrase(output_expr(output,Ls),Output1).
iterated_translate(Input1, Output2) :-
%Keep translating until the input is the same as the output.
translate(Input1,Output1),
(Input1=Output1, Output1 = Output2;iterated_translate(Output1,Output2)).
基于此示例，我编写了另一个具有自然语言用户界面的 adaptive grammar system。
我正在尝试在 Prolog 中编写一个 adaptive parser：换句话说，一个可以在运行时修改自己的解析规则的解析器。
为此，我需要在运行时生成新的谓词，但我不确定这是否可行。是否可以编写一个带有这样一个列表的谓词：
generate_dcg_rule([A," is greater than ",B]).
...然后生成一个像这样的新谓词？
expr(A," is greater than ",B) -->
symbol(A)," is greater than ",symbol(B).
是的，这很容易实现。
Prolog 是一种非常动态的语言，您可以在运行时断言任意子句，例如使用 assertz/1。
您可以使用通常用于执行此操作的 Prolog 术语扩展机制将 DCG 规则扩展为普通 Prolog 规则。
例如，使用expand_term/2:
?- expand_term((expr(A," is greater than ",B) -->
symbol(A)," is greater than ",symbol(B)), Clause).
Clause = (expr(A, [' ', i, s, ' ', g, r, e|...], B, _G242, _G253):-symbol(A, _G242, _G264), _G264=[' ', i, s, ' ', g|...], symbol(B, _G275, _G253)).
您可以使用 assertz/1:
?- expand_term((Head --> Body), Clause), assertz(Clause).
请注意，我在此示例中使用 double_quotes 设置为 chars，即使用：
:- set_prolog_flag(double_quotes, chars).
在你的源文件中。无论如何，这是个好主意。
另请注意，我假设您已经找到一种方法将您在 generate_dcg_rule/1 示例中给出的列表转换为实际的 DCG。对于此翻译，我宁愿推荐像 list_dcg/2 这样的谓词，它以声明方式描述此类列表和 DCG 规则之间的 关系 。优点很明显：例如，您可以 test 这种关系与测试用例等交互。对于您的具体示例，定义此关系的一个子句可能类似于：
list_dcg([A,Ls,B], DCG) :-
Ls = "is greater than ",
DCG = (expr(A, Ls, B) --> symbol(A), Ls, symbol(B)).
我将此推广到您的其他用例作为练习。总的来说，动态断言此类子句的一种方法是：
?- list_dcg(List, DCG), expand_term(DCG, Clause), assertz(Clause).
请注意我们如何从此类示例中的 Prolog homoiconic 性质中获益：Prolog 规则 和 DCG 规则具有 Prolog [=] 的自然表示44=]项，我们可以简单地将它们写下来并像目标中的任何其他项一样对它们进行推理。
我编写了一个自适应解析器，可以将英语短语转换为数学表达式。您可以使用自己的翻译规则轻松扩展它，因此它可以用于创建可扩展的自然语言用户界面。
这是一种可能的输入：
(A squared) times (b squared) equals c to the power of 3 times the product of 5 and 6
这是它的输出：
(A * A) * (b * b) = c ^ 3 * 5 * 6
程序的实现如下所示：
:- initialization(main).
:- set_prolog_flag(double_quotes, chars). % This is for SWI 7+ to revert to the prior interpretation of quoted strings.
%This is an adaptive parser for SWI-Prolog.
main :-
%Type any kind of input here to see the output! The input must be compatible with the grammar that is defined below.
Input = "(A squared) times (b squared) equals c to the power of 3 times the product of 5 and 6",
iterated_translate(Input,Output), writeln(Input), writeln(Output), writeln('\n'), writeln('\n').
%The grammar is defined here. The variables must be uppercase letters.
%The input in each translation rule is followed by its output.
theList(TheList) :-
%You can easily extend this parser by adding more rules to this list.
TheList =
[['A to the power of B',
'A ^ B'],
%The next transformation is the final output of 'A to the power of B'.
['A ^ B',
'A ^ B'],
['A * B',
'A * B'],
['the product of A and B',
'A times B'],
['A squared',
'the product of A and A'],
['A times B',
'A * B'],
['A = B',
'A = B'],
['A equals B', 'A = B']].
%This is the end of the grammar. The rest of the translator is implemented below.
output_expr(Lang,[Input,[A,B]]) -->
{
theList(TheList),
list_to_output__(TheList,TheList1,[A,B]),
member([Input,Output],
TheList1)
},
input_to_output_(Lang,Input,Output).
atom_is_upper(N) :-
atom_chars(N, [L]),
char_type(L, upper).
atom_is_var(Names_to_vars,Atom,Var) :-
atom(Atom),atom_is_upper(Atom),member([Atom,Var],Names_to_vars).
list_to_output__([],[],_) :- true.
list_to_output__([Start1|Rest1],[Start2|Rest2],Vars) :-
list_to_output_(Start1,Start2,Vars),list_to_output__(Rest1,Rest2,Vars).
list_to_output_([A1_,B1_],[A2,B2],Vars) :- atomic_list_concat(A1,' ',A1_),atomic_list_concat(B1,' ',B1_),list_to_output(A1,A2,Vars),list_to_output(B1,B2,Vars).
list_to_output([],[],_) :- true.
list_to_output([Start1|Rest1],[Start2|Rest2],[A,B]) :-
(Start1='A'->Start2=A;Start1='B'-> Start2=B;Start1=Start2),list_to_output(Rest1,Rest2,[A,B]).
list_to_grammar_(Lang,Start,Rest) -->
{(Start = [A])->(Rest = []->Start1 = expr(Lang,A);Start1 = parentheses_expr(Lang,A));atom_chars(Start,Start1)},Start1.
list_to_grammar(Lang,[Start]) -->
list_to_grammar_(Lang,Start,[]).
list_to_grammar(Lang,[Start|Rest]) -->
list_to_grammar_(Lang,Start,Rest),ws_,list_to_grammar(Lang,Rest).
a_number([A,B]) -->
(a__number(A), ".", a__number(B)).
a_number(A) -->
a__number(A).
a__number([L|Ls]) --> digit(L), a__number_r(Ls).
a__number_r([L|Ls]) --> digit(L), a__number_r(Ls).
a__number_r([]) --> [].
digit(Let) --> [Let], { code_type(Let, digit) }.
symbol([L|Ls]) --> letter(L), symbol_r(Ls).
symbol_r([L|Ls]) --> letter(L), symbol_r(Ls).
symbol_r([]) --> [].
letter(Let) --> [Let], { code_type(Let, alpha) }.
ws --> "";((" ";"\n"),ws).
ws_ --> (" ";"\n"),ws.
input_to_output(Lang,A,B) -->
{Lang = input} ->
A;
{Lang=output} ->
B.
input_to_output_(Lang,A,B) -->
{A_=list_to_grammar(Lang,A),B_=list_to_grammar(Lang,B)},input_to_output(Lang,A_,B_).
parentheses_expr(Lang,["(",A,")"]) -->
("(",(expr(Lang,A)),")").
parentheses_expr(_,symbol(A)) -->
symbol(A).
parentheses_expr(_,a_number(A)) -->
a_number(A).
expr(Lang,A) -->
parentheses_expr(Lang,A);output_expr(Lang,A).
translate(Input1,Output1) :-
phrase(output_expr(input,Ls),Input1),
phrase(output_expr(output,Ls),Output1).
iterated_translate(Input1, Output2) :-
%Keep translating until the input is the same as the output.
translate(Input1,Output1),
(Input1=Output1, Output1 = Output2;iterated_translate(Output1,Output2)).
基于此示例，我编写了另一个具有自然语言用户界面的 adaptive grammar system。