/* le_input: a prolog module with predicates to translate from an extended version of Logical English into the Prolog or Taxlog programming languages. Copyright [2021] Initial copyright holders by country: LodgeIT (AU), AORA Law (UK), Bob Kowalski (UK), Miguel Calejo (PT), Jacinto Dávila (VE) Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. Main predicate: text_to_logic(String to be translated, Translation) Main DCG nonterminal: document(Translation) See at the end the predicate le_taxlog_translate to be used from SWISH It assumes an entry with the following structure. One of these expressions: the meta predicates are: the predicates are: the templates are: the timeless predicates are: the event predicates are: the fluents are: the time-varying predicates are: followed by the declarations of all the corresponding predicates mentioned in the knowledge base. Each declarations define a template with the variables and other words required to describe a relevant relation. It is a comma separated list of templates which ends with a period. After that period, one of the following statement introduces the knowledge base: the knowledge base includes: the knowledge base includes: And it is followed by the rules and facts written in Logical English syntax. Each rule must end with a period. Indentation is used to organize the and/or list of conditions by strict observance of one condition per line with a level of indentation that corresponds to each operator and corresponding conditions. Similarly, there may be sections for scenarios and queries, like: -- scenario test2 is: borrower pays an amount to lender on 2015-06-01T00:00:00. -- and -- query one is: for which event: the small business restructure rollover applies to the event. query two is: which tax payer is a party of which event. query three is: A first time is after a second time and the second time is immediately before the first time. -- which can then be used on the new command interface of LE on SWISH (e.g. answer/1 and others querying predicates): ? answer("query one with scenario test"). */ :- module(le_input, [document/3, le_taxlog_translate/4, op(1000,xfy,user:and), % to support querying op(800,fx,user:resolve), % to support querying op(800,fx,user:answer), % to support querying op(850,xfx,user:with), % to support querying op(800,fx,user:show), % to support querying op(850,xfx,user:of), % to support querying op(850,fx,user:'#pred'), % to support scasp op(800,xfx,user:'::'), % to support scasp dictionary/3, meta_dictionary/3, translate_goal_into_LE/2, name_as_atom/2, parsed/0, dump/4, dump/3, dump/2 ]). :- use_module('./tokenize/prolog/tokenize.pl'). :- use_module(library(pengines)). :- use_module('reasoner.pl'). :- use_module(kp_loader). :- use_module(library(prolog_stack)). :- thread_local text_size/1, error_notice/4, dict/3, meta_dict/3, example/2, local_dict/3, local_meta_dict/3, last_nl_parsed/1, kbname/1, happens/2, initiates/3, terminates/3, is_type/1, predicates/1, events/1, fluents/1, metapredicates/1, parsed/0. :- discontiguous statement/3, declaration/4, example/2. % Main clause: text_to_logic(+String,-Clauses) is det % Errors are added to error_notice % text_to_logic/2 text_to_logic(String_, Translation) :- notrace(( % hack to ensure a newline at the end, for the sake of error reporting: ((sub_atom(String_,_,1,0,NL), memberchk(NL,['\n','\r']) ) -> String=String_ ; atom_concat(String_,'\n',String)), tokenize(String, Tokens, [cased(true), spaces(true), numbers(false)]), retractall(last_nl_parsed(_)), asserta(last_nl_parsed(1)), % preparing line counting unpack_tokens(Tokens, UTokens), clean_comments(UTokens, CTokens))), !, %phrase(document(Translation), CTokens). ( phrase(document(Translation), CTokens) -> ( print_message(informational, "Translation: ~w"-[Translation]) ) ; (( print_message(informational, "Translation failed: "-[]), Translation=[], listing(error_notice/4), fail))). % document/3 (or document/1 in dcg) document(Translation, In, Rest) :- (parsed -> retract(parsed); true), phrase(header(Settings), In, AfterHeader), !, %print_message(informational, "Declarations completed: ~w"-[Settings]), phrase(content(Content), AfterHeader, Rest), append(Settings, Content, Translation), !, assertz(parsed). % header parses all the declarations and assert them into memory to be invoked by the rules. % header/3 header(Settings, In, Next) :- length(In, TextSize), % after comments were removed ( phrase(settings(DictEntries, Settings_), In, Next) -> ( member(target(_), Settings_) -> Settings1 = Settings_ ; Settings1 = [target(taxlog)|Settings_] ) % taxlog as default ; (DictEntries = [], Settings1 = [target(taxlog)] ) ), % taxlog as default Settings = [query(null, true), example(null, [])|Settings1], % a hack to stop the loop when query is empty RulesforErrors = % rules for errors that have been statically added [(text_size(TextSize))|Settings], % is text_size being used? % asserting the Settings too! predicates, events and fluents order_templates(DictEntries, OrderedEntries), !, process_types_dict(OrderedEntries, Types), %print_message(informational, Types), append(OrderedEntries, RulesforErrors, SomeRules), append(SomeRules, Types, MRules), assertall(MRules), !. % asserting contextual information header(_, Rest, _) :- asserterror('LE error in the header ', Rest), fail. % Experimental rules for processing types: process_types_dict(Dictionary, Type_entries) :- findall(Word, ( (member(dict([_|GoalElements], Types, _), Dictionary); member(meta_dict([_|GoalElements], Types, _), Dictionary)), member((_Name-Type), Types), process_types_or_names([Type], GoalElements, Types, TypeWords), concat_atom(TypeWords, '_', Word), Word\=''), Templates), setof(is_type(Ty), member(Ty, Templates), Type_entries). % Experimental rules for reordering of templates % order_templates/2 order_templates(NonOrdered, Ordered) :- predsort(compare_templates, NonOrdered, Ordered). compare_templates(<, meta_dict(_,_,_), dict(_,_,_)). compare_templates(=, dict(_,_,T1), dict(_,_,T2)) :- T1 =@= T2. compare_templates(<, dict(_,_,T1), dict(_,_,T2)) :- length(T1, N1), length(T2, N2), N1>N2. compare_templates(<, dict(_,_,T1), dict(_,_,T2)) :- length(T1, N), length(T2, N), template_before(T1, T2). compare_templates(>, Dict1, Dict2) :- not(compare_templates(=, Dict1, Dict2)), not(compare_templates(<, Dict1, Dict2)). compare_templates(=, meta_dict(_,_,T1), meta_dict(_,_,T2)) :- T1 =@= T2. compare_templates(<, meta_dict(_,_,T1), meta_dict(_,_,T2)) :- length(T1, N1), length(T2, N2), N1>N2. compare_templates(<, meta_dict(_,_,T1), meta_dict(_,_,T2)) :- length(T1, N), length(T2, N), template_before(T1, T2). template_before([H1], [H2]) :- H1 =@= H2. template_before([H1|_R1], [H2|_R2]) :- nonvar(H1), var(H2). template_before([H1|_R1], [H2|_R2]) :- H1 @> H2. template_before([H1|R1], [H2|R2]) :- H1=@=H2, template_before(R1, R2). /* --------------------------------------------------------- LE DCGs */ % settings/2 or /4 settings(AllR, AllS) --> spaces_or_newlines(_), declaration(Rules,Setting), settings(RRules, RS), {append(Setting, RS, AllS), append(Rules, RRules, AllR)}, !. settings([], [], Stay, Stay) :- ( phrase(rules_previous(_), Stay, _) ; phrase(scenario_, Stay, _) ; phrase(query_, Stay, _) ), !. % settings ending with the start of the knowledge base or scenarios or queries. settings(_, _, Rest, _) :- asserterror('LE error in the declarations ', Rest), fail. settings([], [], Stay, Stay). % content structure: cuts added to avoid search loop % content/1 or /3 content(T) --> %{print_message(informational, "going for KB:"-[])}, spaces_or_newlines(_), rules_previous(Kbname), %{print_message(informational, "KBName: ~w"-[Kbname])}, kbase_content(S), %{print_message(informational, "KB: ~w"-[S])}, content(R), {append([kbname(Kbname)|S], R, T)}, !. content(T) --> %{print_message(informational, "going for scenario:"-[])}, spaces_or_newlines(_), scenario_content(S), !, %{print_message(informational, "scenario: ~w"-[S])}, content(R), {append(S, R, T)}, !. content(T) --> %{print_message(informational, "going for query:"-[])}, spaces_or_newlines(_), query_content(S), !, content(R), {append(S, R, T)}, !. content([]) --> spaces_or_newlines(_), [], !. content(_, Rest, _) :- asserterror('LE error in the content ', Rest), fail. % kbase_content/1 or /3 kbase_content(T) --> spaces_or_newlines(_), statement(S), kbase_content(R), {append(S, R, T)}, !. kbase_content([]) --> spaces_or_newlines(_), []. kbase_content(_, Rest, _) :- asserterror('LE error in a knowledge base ', Rest), fail. % declaration/2 or /4 % target declaration([], [target(Language)]) --> % one word description for the language: prolog, taxlog spaces(_), [the], spaces(_), [target], spaces(_), [language], spaces(_), [is], spaces(_), colon_or_not_, spaces(_), [Language], spaces(_), period, !. % meta predicates declaration(Rules, [metapredicates(MetaTemplates)]) --> meta_predicate_previous, list_of_meta_predicates_decl(Rules, MetaTemplates), !. %timeless declaration(Rules, [predicates(Templates)]) --> predicate_previous, list_of_predicates_decl(Rules, Templates), !. %events declaration(Rules, [events(EventTypes)]) --> event_predicate_previous, list_of_predicates_decl(Rules, EventTypes), !. %time varying declaration(Rules, [fluents(Fluents)]) --> fluent_predicate_previous, list_of_predicates_decl(Rules, Fluents), !. % declaration(_, _, Rest, _) :- asserterror('LE error in a declaration ', Rest), fail. colon_or_not_ --> [':'], spaces(_). colon_or_not_ --> []. meta_predicate_previous --> spaces(_), [the], spaces(_), [metapredicates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). meta_predicate_previous --> spaces(_), [the], spaces(_), [meta], spaces(_), [predicates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). meta_predicate_previous --> spaces(_), [the], spaces(_), [meta], spaces(_), ['-'], spaces(_), [predicates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). predicate_previous --> spaces(_), [the], spaces(_), [predicates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). predicate_previous --> spaces(_), [the], spaces(_), [templates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). predicate_previous --> spaces(_), [the], spaces(_), [timeless], spaces(_), [predicates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). event_predicate_previous --> spaces(_), [the], spaces(_), [event], spaces(_), [predicates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). fluent_predicate_previous --> spaces(_), [the], spaces(_), [fluents], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). fluent_predicate_previous --> spaces(_), [the], spaces(_), [time], ['-'], [varying], spaces(_), [predicates], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_). % at least one predicate declaration required list_of_predicates_decl([], []) --> spaces_or_newlines(_), next_section, !. list_of_predicates_decl([Ru|Rin], [F|Rout]) --> spaces_or_newlines(_), predicate_decl(Ru,F), comma_or_period, list_of_predicates_decl(Rin, Rout), !. list_of_predicates_decl(_, _, Rest, _) :- asserterror('LE error found in a declaration ', Rest), fail. % at least one predicate declaration required list_of_meta_predicates_decl([], []) --> spaces_or_newlines(_), next_section, !. list_of_meta_predicates_decl([Ru|Rin], [F|Rout]) --> spaces_or_newlines(_), meta_predicate_decl(Ru,F), comma_or_period, list_of_meta_predicates_decl(Rin, Rout). list_of_meta_predicates_decl(_, _, Rest, _) :- asserterror('LE error found in the declaration of a meta template ', Rest), fail. % next_section/2 % a hack to avoid superflous searches format(string(Mess), "~w", [StopHere]), print_message(informational, Message), next_section(StopHere, StopHere) :- phrase(meta_predicate_previous, StopHere, _), !. % format(string(Message), "Next meta predicates", []), print_message(informational, Message). next_section(StopHere, StopHere) :- phrase(predicate_previous, StopHere, _), !. % format(string(Message), "Next predicates", []), print_message(informational, Message). next_section(StopHere, StopHere) :- phrase(event_predicate_previous, StopHere, _), !. % format(string(Message), "Next ecent predicates", []), print_message(informational, Message). next_section(StopHere, StopHere) :- phrase(fluent_predicate_previous, StopHere, _), !. % format(string(Message), "Next fluents", []), print_message(informational, Message). next_section(StopHere, StopHere) :- phrase(rules_previous(_), StopHere, _), !. % format(string(Message), "Next knowledge base", []), print_message(informational, Message). next_section(StopHere, StopHere) :- phrase(scenario_, StopHere, _), !. % format(string(Message), "Next scenario", []), print_message(informational, Message). next_section(StopHere, StopHere) :- phrase(query_, StopHere, _). % format(string(Message), "Next query", []), print_message(informational, Message). % predicate_decl/2 predicate_decl(dict([Predicate|Arguments],TypesAndNames, Template), Relation) --> spaces(_), template_decl(RawTemplate), {build_template(RawTemplate, Predicate, Arguments, TypesAndNames, Template), Relation =.. [Predicate|Arguments]}, !. % we are using this resource of the last clause to record the error and its details % not very useful with loops, of course. % error clause predicate_decl(_, _, Rest, _) :- asserterror('LE error found in a declaration ', Rest), fail. % meta_predicate_decl/2 meta_predicate_decl(meta_dict([Predicate|Arguments],TypesAndNames, Template), Relation) --> spaces(_), template_decl(RawTemplate), {build_template(RawTemplate, Predicate, Arguments, TypesAndNames, Template), Relation =.. [Predicate|Arguments]}. meta_predicate_decl(_, _, Rest, _) :- asserterror('LE error found in a meta template declaration ', Rest), fail. rules_previous(default) --> spaces_or_newlines(_), [the], spaces(_), [rules], spaces(_), [are], spaces(_), [':'], spaces_or_newlines(_), !. rules_previous(KBName) --> spaces_or_newlines(_), [the], spaces(_), ['knowledge'], spaces(_), [base], extract_constant([includes], NameWords), [includes], spaces(_), [':'], !, spaces_or_newlines(_), {name_as_atom(NameWords, KBName)}. rules_previous(default) --> % backward compatibility spaces_or_newlines(_), [the], spaces(_), ['knowledge'], spaces(_), [base], spaces(_), [includes], spaces(_), [':'], spaces_or_newlines(_). % scenario_content/1 or /3 % a scenario description: assuming one example -> one scenario -> one list of facts. scenario_content(Scenario) --> scenario_, extract_constant([is], NameWords), is_colon_, newline, %list_of_facts(Facts), period, !, spaces(_), assumptions_(Assumptions), !, % period is gone {name_as_atom(NameWords, Name), Scenario = [example( Name, [scenario(Assumptions, true)])]}. scenario_content(_, Rest, _) :- asserterror('LE error found around this scenario expression: ', Rest), fail. % query_content/1 or /3 % statement: the different types of statements in a LE text % a query query_content(Query) --> query_, extract_constant([is], NameWords), is_colon_, spaces_or_newlines(_), query_header(Ind0, Map1), conditions(Ind0, Map1, _, Conds), !, period, % period stays! {name_as_atom(NameWords, Name), Query = [query(Name, Conds)]}. query_content(_, Rest, _) :- asserterror('LE error found around this expression: ', Rest), fail. % (holds_at(_149428,_149434) if % (happens_at(_150138,_150144), % initiates_at(_150138,_149428,_150144)), % _150144 before _149434, % not ((terminates_at(_152720,_149428,_152732),_150144 before _152732),_152732 before _149434)) % it becomes the case that % fluent % when % event % if % statement/1 or /3 statement(Statement) --> it_becomes_the_case_that_, spaces_or_newlines(_), literal_([], Map1, holds(Fluent, _)), spaces_or_newlines(_), when_, spaces_or_newlines(_), literal_(Map1, Map2, happens(Event, T)), spaces_or_newlines(_), body_(Body, [map(T, '_change_time')|Map2],_), period, {(Body = [] -> Statement = [if(initiates(Event, Fluent, T), true)]; (Statement = [if(initiates(Event, Fluent, T), Body)]))}, !. % it becomes not the case that % fluent % when % event % if statement(Statement) --> it_becomes_not_the_case_that_, spaces_or_newlines(_), literal_([], Map1, holds(Fluent, _)), spaces_or_newlines(_), when_, spaces_or_newlines(_), literal_(Map1, Map2, happens(Event, T)), spaces_or_newlines(_), body_(Body, [map(T, '_change_time')|Map2],_), period, {(Body = [] -> Statement = [if(terminates(Event, Fluent, T), true)]; (Statement = [if(terminates(Event, Fluent, T), Body)] %, print_message(informational, "~w"-Statement) ))}, !. % it is illegal that % event % if ... statement(Statement) --> it_is_illegal_that_, spaces_or_newlines(_), literal_([], Map1, happens(Event, T)), body_(Body, Map1, _), period, {(Body = [] -> Statement = [if(it_is_illegal(Event, T), true)]; Statement = [if(it_is_illegal(Event, T), Body)])},!. % a fact or a rule statement(Statement) --> currentLine(L), literal_([], Map1, Head), body_(Body, Map1, _), period, {(Body = [] -> Statement = [if(L, Head, true)]; Statement = [if(L, Head, Body)])}. % error statement(_, Rest, _) :- asserterror('LE error found around this statement: ', Rest), fail. list_of_facts([F|R1]) --> literal_([], _,F), rest_list_of_facts(R1). rest_list_of_facts(L1) --> comma, spaces_or_newlines(_), list_of_facts(L1). rest_list_of_facts([]) --> []. % assumptions_/3 or /5 assumptions_([A|R]) --> spaces_or_newlines(_), rule_([], _, A), !, assumptions_(R). assumptions_([]) --> spaces_or_newlines(_), []. rule_(InMap, OutMap, Rule) --> literal_(InMap, Map1, Head), body_(Body, Map1, OutMap), period, %spaces(Ind), condition(Head, Ind, InMap, Map1), body_(Body, Map1, OutMap), period, {(Body = [] -> Rule = (Head :-true); Rule = (Head :- Body))}. rule_(M, M, _, Rest, _) :- asserterror('LE error found in an assumption, near to ', Rest), fail. % no prolog inside LE! %statement([Fact]) --> % spaces(_), prolog_literal_(Fact, [], _), spaces_or_newlines(_), period. % body/3 or /5 body_([], Map, Map) --> spaces_or_newlines(_). body_(Conditions, Map1, MapN) --> newline, spaces(Ind), if_, !, conditions(Ind, Map1, MapN, Conditions), spaces_or_newlines(_). body_(Conditions, Map1, MapN) --> if_, newline_or_nothing, spaces(Ind), conditions(Ind, Map1, MapN, Conditions), spaces_or_newlines(_). newline_or_nothing --> newline. newline_or_nothing --> []. % literal_/3 or /5 % literal_ reads a list of words until it finds one of these: ['\n', if, '.'] % it then tries to match those words against a template in memory (see dict/3 predicate). % The output is then contigent to the type of literal according to the declarations. literal_(Map1, MapN, FinalLiteral) --> % { print_message(informational, 'at time, literal') }, at_time(T, Map1, Map2), comma, possible_instance(PossibleTemplate), {match_template(PossibleTemplate, Map2, MapN, Literal), (fluents(Fluents) -> true; Fluents = []), (events(Events) -> true; Events = []), (lists:member(Literal, Events) -> FinalLiteral = happens(Literal, T) ; (lists:member(Literal, Fluents) -> FinalLiteral = holds(Literal, T) ; FinalLiteral = Literal))}, !. % by default (including builtins) they are timeless! literal_(Map1, MapN, FinalLiteral) --> % { print_message(informational, 'literal, at time') }, possible_instance(PossibleTemplate), comma, at_time(T, Map1, Map2), {match_template(PossibleTemplate, Map2, MapN, Literal), (fluents(Fluents) -> true; Fluents = []), (events(Events) -> true; Events = []), (lists:member(Literal, Events) -> FinalLiteral = happens(Literal, T) ; (lists:member(Literal, Fluents) -> FinalLiteral = holds(Literal, T) ; FinalLiteral = Literal))}, !. % by default (including builtins) they are timeless! literal_(Map1, MapN, FinalLiteral) --> possible_instance(PossibleTemplate), %{ print_message(informational, "~w"-[PossibleTemplate]) }, {match_template(PossibleTemplate, Map1, MapN, Literal), (fluents(Fluents) -> true; Fluents = []), (events(Events) -> true; Events = []), (consult_map(Time, '_change_time', Map1, _MapF) -> T=Time; true), (lists:member(Literal, Events) -> FinalLiteral = happens(Literal, T) ; (lists:member(Literal, Fluents) -> FinalLiteral = holds(Literal, T) ; (FinalLiteral = Literal))) %print_message(informational, "~w with ~w"-[FinalLiteral, MapF]) }, !. % by default (including builtins) they are timeless! % rewritten to use in swish. Fixed! It was a name clash. Apparently "literal" is used somewhere else %literal_(Map1, MapN, Literal, In, Out) :- print_message(informational, ' inside a literal'), % possible_instance(PossibleTemplate, In, Out), print_message(informational, PossibleTemplate), % match_template(PossibleTemplate, Map1, MapN, Literal). % error clause literal_(M, M, _, Rest, _) :- asserterror('LE error found in a literal ', Rest), fail. % conditions/4 or /6 conditions(Ind0, Map1, MapN, Conds) --> list_of_conds_with_ind(Ind0, Map1, MapN, Errors, ListConds), {Errors=[] -> ri(Conds, ListConds); (assert_error_os(Errors), fail)}. % preempty validation of errors conditions(_, Map, Map, _, Rest, _) :- asserterror('LE indentation error ', Rest), fail. % list_of_conds_with_ind/5 % list_of_conds_with_ind(+InitialInd, +InMap, -OutMap, -Errors, -ListOfConds) list_of_conds_with_ind(Ind0, Map1, MapN, [], [Cond|Conditions]) --> condition(Cond, Ind0, Map1, Map2), more_conds(Ind0, Ind0,_, Map2, MapN, Conditions). list_of_conds_with_ind(_, M, M, [error('Error in condition at', LineNumber, Tokens)], [], Rest, _) :- once( nth1(N,Rest,newline(NextLine)) ), LineNumber is NextLine-2, RelevantN is N-1, length(Relevant,RelevantN), append(Relevant,_,Rest), findall(Token, (member(T,Relevant), (T=newline(_) -> Token='\n' ; Token=T)), Tokens). more_conds(Ind0, _, Ind3, Map1, MapN, [ind(Ind2), Op, Cond2|RestMapped]) --> newline, spaces(Ind2), {Ind0 =< Ind2}, % if the new indentation is deeper, it goes on as before. operator(Op), condition(Cond2, Ind2, Map1, Map2), %{print_message(informational, "~w"-[Conditions])}, !, more_conds(Ind0, Ind2, Ind3, Map2, MapN, RestMapped). more_conds(_, Ind, Ind, Map, Map, [], L, L). % three conditions look ahead %more_conds(Ind0, Ind1, Ind4, Map1, MapN, C1, RestMapped, In1, Out) :- % newline(In1, In2), spaces(Ind2, In2, In3), Ind0= % newline, spaces(Ind), {Ind0 =< Ind}, % if the new indentation is deeper, it goes on as before. % operator(Op), condition(Cond2, Ind, Map1, MapN), % {add_cond(Op, Ind1, Ind, Cond, Cond2, Conditions)}, % {print_message(informational, "~w"-[Conditions])}, !. % more_conds(Ind0, Ind1, Ind3, Map1, MapN, Cond, RestMapped) --> % newline, spaces(Ind2), {Ind0 =< Ind2}, % if the new indentation is deeper, it goes on as before. % operator(Op), condition(Cond2, Ind2, Map1, Map2), % {add_cond(Op, Ind1, Ind2, Cond, Cond2, Conditions)}, !, % %{print_message(informational, "~w"-[Conditions])}, !, % more_conds(Ind0, Ind2, Ind3, Map2, MapN, Conditions, RestMapped). % more_conds(_, Ind, Ind, Map, Map, Cond, Cond, Rest, Rest). % this naive definition of term is problematic % term_/4 or /6 term_(StopWords, Term, Map1, MapN) --> (variable(StopWords, Term, Map1, MapN), !); (constant(StopWords, Term, Map1, MapN), !); (list_(Term, Map1, MapN), !). %; (compound_(Term, Map1, MapN), !). % list_/3 or /5 list_(List, Map1, MapN) --> spaces(_), bracket_open_, !, extract_list([']'], List, Map1, MapN), bracket_close. compound_(V1/V2, Map1, MapN) --> term_(['/'], V1, Map1, Map2), ['/'], term_([], V2, Map2, MapN). % event observations %condition(happens(Event), _, Map1, MapN) --> % observe_, literal_(Map1, MapN, Event), !. % condition/4 or /6 % this produces a Taxlog condition with the form: % setof(Owner/Share, is_ultimately_owned_by(Asset,Owner,Share) on Before, SetOfPreviousOwners) % from a set of word such as: % and a record of previous owners is a set of [an owner, a share] % where the asset is ultimately owned by the share with the owner at the previous time condition(FinalExpression, _, Map1, MapN) --> variable([is], Set, Map1, Map2), is_a_set_of_, term_([], Term, Map2, Map3), !, % moved where to the following line newline, spaces(Ind2), where_, conditions(Ind2, Map3, Map4, Goals), modifiers(setof(Term,Goals,Set), Map4, MapN, FinalExpression). % for every a party is a party in the event, it is the case that: condition(FinalExpression, _, Map1, MapN) --> for_all_cases_in_which_, newline, !, spaces(Ind2), conditions(Ind2, Map1, Map2, Conds), spaces_or_newlines(_), it_is_the_case_that_, newline, spaces(Ind3), conditions(Ind3, Map2, Map3, Goals), modifiers(forall(Conds,Goals), Map3, MapN, FinalExpression). % the Value is the sum of each Asset Net such that condition(FinalExpression, _, Map1, MapN) --> variable([is], Value, Map1, Map2), is_the_sum_of_each_, extract_variable([such], [], NameWords, [], _), such_that_, !, { name_predicate(NameWords, Name), update_map(Each, Name, Map2, Map3) }, newline, spaces(Ind), conditions(Ind, Map3, Map4, Conds), modifiers(aggregate_all(sum(Each),Conds,Value), Map4, MapN, FinalExpression). % it is not the case that %condition((pengine_self(M), not(M:Conds)), _, Map1, MapN) --> %condition((true, not(Conds)), _, Map1, MapN) --> condition(not(Conds), _, Map1, MapN) --> %condition(not(Conds), _, Map1, MapN) --> spaces(_), not_, newline, % forget other choices. We know it is a not case spaces(Ind), conditions(Ind, Map1, MapN, Conds), !. condition(Cond, _, Map1, MapN) --> literal_(Map1, MapN, Cond), !. %condition(assert(Prolog), _, Map1, MapN) --> % this_information_, !, prolog_literal_(Prolog, Map1, MapN), has_been_recorded_. % condition(-Cond, ?Ind, +InMap, -OutMap) % builtins have been included as predefined templates in the predef_dict %condition(InfixBuiltIn, _, Map1, MapN) --> % term_(Term, Map1, Map2), spaces_or_newlines(_), builtin_(BuiltIn), % spaces_or_newlines(_), expression_(Expression, Map2, MapN), !, {InfixBuiltIn =.. [BuiltIn, Term, Expression]}. % error clause condition(_, _Ind, Map, Map, Rest, _) :- asserterror('LE error found at a condition ', Rest), fail. % modifiers add reifying predicates to an expression. % modifiers(+MainExpression, +MapIn, -MapOut, -FinalExpression) modifiers(MainExpression, Map1, MapN, on(MainExpression, Var) ) --> newline, spaces(_), at_, variable([], Var, Map1, MapN). % newline before a reifying expression modifiers(MainExpression, Map, Map, MainExpression) --> []. % variable/4 or /6 variable(StopWords, Var, Map1, MapN) --> spaces(_), [Det], {indef_determiner(Det)}, extract_variable(StopWords, [], NameWords, [], _), % <-- CUT! { NameWords\=[], name_predicate(NameWords, Name), update_map(Var, Name, Map1, MapN) }. variable(StopWords, Var, Map1, MapN) --> spaces(_), [Det], {def_determiner(Det)}, extract_variable(StopWords, [], NameWords, [], _), % <-- CUT! { NameWords\=[], name_predicate(NameWords, Name), consult_map(Var, Name, Map1, MapN) }. % allowing for symbolic variables: variable(StopWords, Var, Map1, MapN) --> spaces(_), extract_variable(StopWords, [], NameWords, [], _), { NameWords\=[], name_predicate(NameWords, Name), consult_map(Var, Name, Map1, MapN) }. % constant/4 or /6 constant(StopWords, Constant, Map, Map) --> extract_constant(StopWords, NameWords), { NameWords\=[], name_predicate(NameWords, Constant) }. % deprecated prolog_literal_(Prolog, Map1, MapN) --> predicate_name_(Predicate), parentesis_open_, extract_list([], Arguments, Map1, MapN), parentesis_close_, {Prolog =.. [Predicate|Arguments]}. predicate_name_(Module:Predicate) --> [Module], colon_, extract_constant([], NameWords), { name_predicate(NameWords, Predicate) }, !. predicate_name_(Predicate) --> extract_constant([], NameWords), { name_predicate(NameWords, Predicate) }. at_time(T, Map1, MapN) --> spaces_or_newlines(_), at_, expression_(T, Map1, MapN), spaces_or_newlines(_). spaces(N) --> [' '], !, spaces(M), {N is M + 1}. % todo: reach out for codemirror's configuration https://codemirror.net/doc/manual.html for tabSize spaces(N) --> ['\t'], !, spaces(M), {N is M + 4}. % counting tab as four spaces (default in codemirror) spaces(0) --> []. spaces_or_newlines(N) --> [' '], !, spaces_or_newlines(M), {N is M + 1}. spaces_or_newlines(N) --> ['\t'], !, spaces_or_newlines(M), {N is M + 4}. % counting tab as four spaces. See above spaces_or_newlines(N) --> newline, !, spaces_or_newlines(M), {N is M + 1}. % counting \r as one space spaces_or_newlines(0) --> []. newline --> [newline(_Next)]. one_or_many_newlines --> newline, spaces(_), one_or_many_newlines, !. one_or_many_newlines --> []. if_ --> [if], spaces_or_newlines(_). % so that if can be written many lines away from the rest period --> ['.']. comma --> [',']. colon_ --> [':'], spaces(_). comma_or_period --> period, !. comma_or_period --> comma. and_ --> [and]. or_ --> [or]. not_ --> [it], spaces(_), [is], spaces(_), [not], spaces(_), [the], spaces(_), [case], spaces(_), [that], spaces(_). is_the_sum_of_each_ --> [is], spaces(_), [the], spaces(_), [sum], spaces(_), [of], spaces(_), [each], spaces(_) . is_the_sum_of_each_ --> [is], spaces(_), [the], spaces(_), [every], spaces(_), [of], spaces(_), [each], spaces(_) . such_that_ --> [such], spaces(_), [that], spaces(_). at_ --> [at], spaces(_). minus_ --> ['-'], spaces(_). plus_ --> ['+'], spaces(_). divide_ --> ['/'], spaces(_). times_ --> ['*'], spaces(_). bracket_open_ --> ['['], spaces(_). bracket_close --> [']'], spaces(_). parentesis_open_ --> ['('], spaces(_). parentesis_close_ --> [')'], spaces(_). this_information_ --> [this], spaces(_), [information], spaces(_). has_been_recorded_ --> [has], spaces(_), [been], spaces(_), [recorded], spaces(_). for_all_cases_in_which_ --> spaces_or_newlines(_), [for], spaces(_), [all], spaces(_), [cases], spaces(_), [in], spaces(_), [which], spaces(_). it_is_the_case_that_ --> [it], spaces(_), [is], spaces(_), [the], spaces(_), [case], spaces(_), [that], spaces(_). is_a_set_of_ --> [is], spaces(_), [a], spaces(_), [set], spaces(_), [of], spaces(_). where_ --> [where], spaces(_). scenario_ --> spaces_or_newlines(_), ['Scenario'], !, spaces(_). scenario_ --> spaces_or_newlines(_), [scenario], spaces(_). is_colon_ --> [is], spaces(_), [':'], spaces(_). query_ --> spaces_or_newlines(_), ['Query'], !, spaces(_). query_ --> spaces_or_newlines(_), [query], spaces(_). for_which_ --> [for], spaces(_), [which], spaces(_). query_header(Ind, Map) --> spaces(Ind), for_which_, list_of_vars([], Map), colon_, spaces_or_newlines(_). query_header(0, []) --> []. list_of_vars(Map1, MapN) --> extract_variable([',', and, ':'], [], NameWords, [], _), { name_predicate(NameWords, Name), update_map(_Var, Name, Map1, Map2) }, rest_of_list_of_vars(Map2, MapN). rest_of_list_of_vars(Map1, MapN) --> and_or_comma_, list_of_vars(Map1, MapN). rest_of_list_of_vars(Map, Map) --> []. and_or_comma_ --> [','], spaces(_). and_or_comma_ --> [and], spaces(_). it_becomes_the_case_that_ --> it_, [becomes], spaces(_), [the], spaces(_), [case], spaces(_), [that], spaces(_). it_becomes_not_the_case_that_ --> it_, [becomes], spaces(_), [not], spaces(_), [the], spaces(_), [case], spaces(_), [that], spaces(_). it_becomes_not_the_case_that_ --> it_, [becomes], spaces(_), [no], spaces(_), [longer], spaces(_), [the], spaces(_), [case], spaces(_), [that], spaces(_). when_ --> [when], spaces(_). it_ --> [it], spaces(_), !. it_ --> ['It'], spaces(_). observe_ --> [observe], spaces(_). it_is_illegal_that_ --> it_, [is], spaces(_), [illegal], spaces(_), [that], spaces(_). /* --------------------------------------------------- Supporting code */ % indentation code % ri/2 ri(-Conditions, +IndentedForm). ri(P, L) :- rinden(Q, L), c2p(Q, P). % rinden/2 produces the conditions from the list with the indented form. rinden(Q, List) :- rind(_, _, Q, List). rind(L, I, Q, List) :- rind_and(L, I, Q, List); rind_or(L, I, Q, List). rind_and(100, [], true, []). rind_and(100, [], Cond, [Cond]) :- simple(Cond). rind_and(T, [T|RestT], and(First,Rest), Final) :- combine(NewF, [ind(T), and|RestC], Final), rind(T1, Tr1, First, NewF), T1>T, rind(Tn, Tr, Rest, RestC), append(Tr1, Tr, RestT), right_order_and(Rest, Tn, T). rind_or(100, [], false, []). rind_or(100, [], Cond, [Cond]) :- simple(Cond). rind_or(T, [T|RestT], or(First,Rest), Final) :- combine(NewF, [ind(T), or|RestC], Final), rind(T1, Tr1, First, NewF), T1>T, rind(Tn, Tr, Rest, RestC), append(Tr1, Tr, RestT), right_order_or(Rest, Tn, T). right_order_and(Rest, Tn, T) :- Rest=or(_,_), Tn>T. right_order_and(Rest, Tn, T) :- Rest=and(_,_), Tn=T. right_order_and(Rest, _, _) :- simple(Rest). right_order_or(Rest, Tn, T) :- Rest=and(_,_), Tn>T. right_order_or(Rest, Tn, T) :- Rest=or(_,_), Tn=T. right_order_or(Rest, _, _) :- simple(Rest). combine(F, S, O) :- ( F\=[], S=[ind(_), Op, V], ((Op==and_); (Op==or_)), simple(V), O=F) ; (F=[], O=S). combine([H|T], S, [H|NT]) :- combine(T, S, NT). simple(Cond) :- Cond\=and(_,_), Cond\=or(_,_), Cond\=true, Cond\=false. c2p(true, true). c2p(false, false). c2p(C, C) :- simple(C). c2p(and(A, RestA), (AA, RestAA)) :- c2p(A, AA), c2p(RestA, RestAA). c2p(or(A, RestA), (AA; RestAA)) :- c2p(A, AA), c2p(RestA, RestAA). /* --------------------------------------------------- More Supporting code */ clean_comments([], []) :- !. clean_comments(['%'|Rest], New) :- % like in prolog comments start with % jump_comment(Rest, Next), clean_comments(Next, New). clean_comments([Code|Rest], [Code|New]) :- clean_comments(Rest, New). jump_comment([], []). jump_comment([newline(N)|Rest], [newline(N)|Rest]). % leaving the end of line in place jump_comment([_|R1], R2) :- jump_comment(R1, R2). % template_decl/4 % cuts added to improve efficiency template_decl([], [newline(_)|RestIn], [newline(_)|RestIn]) :- asserterror('LE error: misplaced new line found in a template declaration ', RestIn), !, fail. % cntrl \n should be rejected as part of a template template_decl(RestW, [' '|RestIn], Out) :- !, % skip spaces in template template_decl(RestW, RestIn, Out). template_decl(RestW, ['\t'|RestIn], Out) :- !, % skip cntrl \t in template template_decl(RestW, RestIn, Out). % excluding ends of lines from templates %template_decl(RestW, [newline(_)|RestIn], Out) :- !, % skip cntrl \n in template % template_decl(RestW, RestIn, Out). template_decl([Word|RestW], [Word|RestIn], Out) :- not(lists:member(Word,['.', ','])), % only . and , as boundaries. Beware! template_decl(RestW, RestIn, Out), !. template_decl([], [Word|Rest], [Word|Rest]) :- lists:member(Word,['.', ',']), !. template_decl(_, Rest, _) :- asserterror('LE error found in a template declaration ', Rest), fail. % build_template/5 build_template(RawTemplate, Predicate, Arguments, TypesAndNames, Template) :- build_template_elements(RawTemplate, [], Arguments, TypesAndNames, OtherWords, Template), name_predicate(OtherWords, Predicate). % build_template_elements(+Input, +Previous, -Args, -TypesNames, -OtherWords, -Template) build_template_elements([], _, [], [], [], []) :- !. % a variable signalled by a * build_template_elements(['*', Word|RestOfWords], _Previous, [Var|RestVars], [Name-Type|RestTypes], Others, [Var|RestTemplate]) :- has_pairing_asteriks([Word|RestOfWords]), %(ind_det(Word); ind_det_C(Word)), % Previous \= [is|_], % removing this requirement when * is used determiner(Word), % allows the for variables in templates declarations only extract_variable_template(['*'], [], NameWords, [], TypeWords, RestOfWords, ['*'|NextWords]), !, % <-- it must end with * too name_predicate(NameWords, Name), name_predicate(TypeWords, Type), build_template_elements(NextWords, [], RestVars, RestTypes, Others, RestTemplate). build_template_elements(['*', Word|RestOfWords], _Previous,_, _, _, _) :- not(has_pairing_asteriks([Word|RestOfWords])), !, fail. % produce an error report if asterisks are not paired % a variable not signalled by a * % for backward compatibility \\ DEPRECATED %build_template_elements([Word|RestOfWords], Previous, [Var|RestVars], [Name-Type|RestTypes], Others, [Var|RestTemplate]) :- % (ind_det(Word); ind_det_C(Word)), Previous \= [is|_], % extract_variable(['*'], Var, [], NameWords, TypeWords, RestOfWords, NextWords), !, % <-- CUT! % name_predicate(NameWords, Name), % name_predicate(TypeWords, Type), % build_template_elements(NextWords, [], RestVars, RestTypes, Others, RestTemplate). build_template_elements([Word|RestOfWords], Previous, RestVars, RestTypes, [Word|Others], [Word|RestTemplate]) :- build_template_elements(RestOfWords, [Word|Previous], RestVars, RestTypes, Others, RestTemplate). has_pairing_asteriks(RestOfTemplate) :- findall('*',member('*', RestOfTemplate), Asteriks), length(Asteriks, N), 1 is mod(N, 2). name_predicate(Words, Predicate) :- concat_atom(Words, '_', Predicate). % name_as_atom/2 name_as_atom([Number], Number) :- number(Number), !. name_as_atom([Atom], Number) :- atom_number(Atom, Number), !. name_as_atom(Words, Name) :- numbervars(Words, 1, _, [functor_name('unknown')]), replace_vars(Words, Atoms), list_words_to_codes(Atoms, Codes), replace_ast_a(Codes, CCodes), atom_codes(Name, CCodes). words_to_atom(Words, Name) :- %trace, numbervars(Words, 0, _, [singletons(true)]), list_words_to_codes(Words, Codes), atom_codes(Name, Codes). replace_ast_a([], []) :- !. replace_ast_a([42,32,97|Rest], [42,97|Out]) :- !, replace_final_ast(Rest, Out). replace_ast_a([C|Rest], [C|Out]) :- replace_ast_a(Rest, Out). replace_final_ast([], []) :- !. replace_final_ast([32,42|Rest], [42|Out]) :- !, replace_ast_a(Rest, Out). replace_final_ast([C|Rest], [C|Out]) :- replace_final_ast(Rest, Out). % maps a list of words to a list of corresponding codes % adding an space between words-codes (32). % list_word_to_codes/2 list_words_to_codes([], []). list_words_to_codes([Word|RestW], Out) :- atom_codes(Word, Codes), remove_quotes(Codes, CleanCodes), list_words_to_codes(RestW, Next), (Next=[]-> Out=CleanCodes; append(CleanCodes, [32|Next], Out)), !. remove_quotes([], []) :-!. remove_quotes([39|RestI], RestC) :- remove_quotes(RestI, RestC), !. % quick fix to remove parentesis and numbers too. remove_quotes([40, _, 41|RestI], RestC) :- remove_quotes(RestI, RestC), !. %remove_quotes([41|RestI], RestC) :- remove_quotes(RestI, RestC), !. remove_quotes([C|RestI], [C|RestC]) :- remove_quotes(RestI, RestC). replace_vars([],[]) :- !. replace_vars([A|RI], [A|RO]) :- atom(A), replace_vars(RI,RO), !. replace_vars([W|RI], [A|RO]) :- term_to_atom(W, A), replace_vars(RI,RO). add_cond(and, Ind1, Ind2, Previous, C4, (C; (C3, C4))) :- last_cond(or, Previous, C, C3), % (C; C3) Ind1 < Ind2, !. add_cond(and, Ind1, Ind2, Previous, C4, ((C; C3), C4)) :- last_cond(or, Previous, C, C3), % (C; C3) Ind1 > Ind2, !. add_cond(and,I, I, (C, C3), C4, (C, (C3, C4))) :- !. add_cond(and,_, _, Cond, RestC, (Cond, RestC)) :- !. add_cond(or, Ind1, Ind2, Previous, C4, (C, (C3; C4))) :- last_cond(and, Previous, C, C3), % (C, C3) Ind1 < Ind2, !. add_cond(or, Ind1, Ind2, Previous, C4, ((C, C3); C4)) :- last_cond(and, Previous, C, C3), % (C, C3) Ind1 > Ind2, !. add_cond(or, I, I, (C; C3), C4, (C; (C3; C4))) :- !. add_cond(or, _, _, Cond, RestC, (Cond; RestC)). last_cond(or, (A;B), A, B) :- B\=(_;_), !. last_cond(or, (C;D), (C;R), Last) :- last_cond(or, D, R, Last). last_cond(and, (A,B), A, B) :- B\=(_,_), !. last_cond(and, (C,D), (C,R), Last) :- last_cond(and, D, R, Last). % adjust_op(Ind1, Ind2, PreviousCond, Op1, Cond2, Op2, Rest, RestMapped, Conditions) % from and to and adjust_op(Ind1, Ind2, C1, and, C2, and, C3, ((C1, C2), C3) ) :- Ind1 =< Ind2, !. adjust_op(Ind1, Ind2, C1, and, C2, and, C3, ((C1, C2), C3) ) :- Ind1 > Ind2, !. % from or to ord adjust_op(Ind1, Ind2, C1, or, C2, or, C3, ((C1; C2); C3) ) :- Ind1 =< Ind2, !. adjust_op(Ind1, Ind2, C1, or, C2, or, C3, ((C1; C2); C3) ) :- Ind1 > Ind2, !. % from and to deeper or adjust_op(Ind1, Ind2, C1, and, C2, or, C3, (C1, (C2; C3)) ) :- Ind1 < Ind2, !. % from deeper or to and adjust_op(Ind1, Ind2, C1, or, C2, and, C3, ((C1; C2), C3) ) :- Ind1 > Ind2, !. % from or to deeper and adjust_op(Ind1, Ind2, C1, or, C2, and, C3, (C1; (C2, C3)) ) :- Ind1 < Ind2, !. % from deeper and to or adjust_op(Ind1, Ind2, C1, and, C2, or, C3, ((C1, C2); C3) ) :- Ind1 > Ind2. operator(and, In, Out) :- and_(In, Out). operator(or, In, Out) :- or_(In, Out). % possible_instance/3 % cuts added to improve efficiency % skipping a list possible_instance([], [], []) :- !. possible_instance(Final, ['['|RestIn], Out) :- !, possible_instance_for_lists(List, RestIn, [']'|Next]), possible_instance(RestW, Next, Out), append(['['|List], [']'|RestW], Final). possible_instance(RestW, [' '|RestIn], Out) :- !, % skip spaces in template possible_instance(RestW, RestIn, Out). possible_instance(RestW, ['\t'|RestIn], Out) :- !, % skip tabs in template possible_instance(RestW, RestIn, Out). possible_instance([that|Instance], In, Out) :- % to allow "that" instances to spread over more than one line phrase(spaces_or_newlines(_), In, [that|Rest]), phrase(spaces_or_newlines(_), Rest, Next), !, possible_instance(Instance, Next, Out). possible_instance([Word|RestW], [Word|RestIn], Out) :- %not(lists:member(Word,['\n', if, and, or, '.', ','])), !, not(lists:member(Word,[newline(_), if, '.', ','])), % leaving the comma in as well (for lists and sets we will have to modify this) possible_instance(RestW, RestIn, Out). possible_instance([], [Word|Rest], [Word|Rest]) :- lists:member(Word,[newline(_), if, '.', ',']). % leaving or/and out of this % using [ and ] for list and set only to avoid clashes for commas %possible_instance_for_lists([], [], []) :- !. possible_instance_for_lists([], [']'|Out], [']'|Out]) :- !. possible_instance_for_lists(RestW, [' '|RestIn], Out) :- !, % skip spaces in template possible_instance_for_lists(RestW, RestIn, Out). possible_instance_for_lists(RestW, ['\t'|RestIn], Out) :- !, % skip tabs in template possible_instance_for_lists(RestW, RestIn, Out). possible_instance_for_lists([Word|RestW], [Word|RestIn], Out) :- %not(lists:member(Word,['\n', if, and, or, '.', ','])), !, possible_instance_for_lists(RestW, RestIn, Out). %possible_instance_for_lists([], [Word|Rest], [Word|Rest]) :- % lists:member(Word,[',', newline(_), if, '.']). % leaving or/and out of this % match_template/4 match_template(PossibleLiteral, Map1, MapN, Literal) :- %print_message(informational,'Possible Meta Literal ~w'-[PossibleLiteral]), meta_dictionary(Predicate, _, MetaCandidate), meta_match(MetaCandidate, PossibleLiteral, Map1, MapN, MetaTemplate), !, meta_dictionary(Predicate, _, MetaTemplate), Literal =.. Predicate. match_template(PossibleLiteral, Map1, MapN, Literal) :- %print_message(informational,'Possible Literal ~w'-[PossibleLiteral]), dictionary(Predicate, _, Candidate), match(Candidate, PossibleLiteral, Map1, MapN, Template), !, dictionary(Predicate, _, Template), Literal =.. Predicate. %print_message(informational,'Match!! with ~w'-[Literal]).% !. % meta_match/5 % meta_match(+CandidateTemplate, +PossibleLiteral, +MapIn, -MapOut, -SelectedTemplate) meta_match([], [], Map, Map, []) :- !. meta_match([Word|_LastElement], [Word|PossibleLiteral], Map1, MapN, [Word,Literal]) :- % asuming Element is last in template! Word = that, % that is a reserved word "inside" templates! -> that