bf_mutator

assign_subASTs(ArgumentTypes, SubASTsTypes, SubASTs, NewSubASTs) :-
    ArgumentTypes = SubASTsTypes,
    !,
    NewSubASTs = SubASTs.

assign_subASTs(ArgumentTypes, SubASTsTypes, SubASTs, NewSubASTs) :-
    length(ArgumentTypes, N),
    length(SubASTs, M),
    M > N,
    !,
    length(ReducedSubASTsTypes, N),
    append(ReducedSubASTsTypes, _, SubASTsTypes),
    ReducedSubASTsTypes = ArgumentTypes,
    length(NewSubASTs, N),
    append(NewSubASTs, _, SubASTs).

assign_subASTs(ArgumentTypes, SubASTsTypes, SubASTs, NewSubASTs) :-
    length(ArgumentTypes, N),
    length(SubASTsTypes, M),
    M < N,
    !,
    append(SubASTsTypes, RemainingArgumentTypes, ArgumentTypes),
    maplist(types_for_generate, RemainingArgumentTypes, TypesForGenerate),
    maplist(generate, TypesForGenerate, GeneratedSubASTs),
    append(SubASTs, GeneratedSubASTs, NewSubASTs).

find_value_in_ast(Value, b(Node,Type,Options), b(Node,Type,Options)) :-
    Node =.. [_, Value],
    !.

find_value_in_ast(Value, b(Expr,_,_), ASTValue) :-
    Expr =.. [_|SubASTs],
    search_through_subasts(Value, SubASTs, ASTValue).

find_values_in_ast([],_,[]).

find_values_in_ast([Value|Values],AST,[ASTValue|ASTValues]) :-
    find_value_in_ast(Value,AST,ASTValue),
    find_values_in_ast(Values,AST,ASTValues).

length_of_avl_or_list(List,Length) :-
    is_list(List),
    length(List,Length).

length_of_avl_or_list(AVLExpr,Length) :-
    AVLExpr =.. [_,AVL],
    is_avl(AVL),
    avl_size(AVL,Length).

mutate(exists(ids,pred), pred, OldAST, b(exists(ListOfIDASTNodes,NewSubAST),pred,Options)) :-
    OldAST = b(_, pred, Options),
    find_identifier_uses(OldAST,[],TempListOfIDNodes),
    % if there are no identifier just insert one instead of backtracking
    (TempListOfIDNodes = []
    -> insert_identifier_to_ast(OldAST,2,NewSubAST),
    find_identifier_uses(NewSubAST,[],ListOfIDNodes)
    ; ListOfIDNodes = TempListOfIDNodes,
    NewSubAST = OldAST),
    find_values_in_ast(ListOfIDNodes,NewSubAST,ListOfIDASTNodes).

mutate(forall(ids,constraints,pred),pred,OldAST, b(forall(ListOfIDASTNodes,IDConstraints,NewSubAST),pred,Options)) :-
    OldAST = b(_, pred, Options),
    find_identifier_uses(OldAST,[],TempListOfIDNodes),
    % if there are no identifier just insert one instead of backtracking
    (TempListOfIDNodes = []
    -> insert_identifier_to_ast(OldAST,2,NewSubAST),
    find_identifier_uses(NewSubAST,[],ListOfIDNodes)
    ; ListOfIDNodes = TempListOfIDNodes,
    NewSubAST = OldAST),
    % set constraints for every identifier (except of boolean, string)
    % defined in prob_ast_identifier.pl
    generate(prob_ast_id_constraints(ListOfIDNodes),IDConstraints),
    find_values_in_ast(ListOfIDNodes,NewSubAST,ListOfIDASTNodes).

mutate(GrammarExpr, GrammarType, b(PrevExpr, Type, Options), b(NewExpr, Type, Options)) :-
    GrammarExpr =.. [Node|ArgumentTypes],
    PrevExpr =.. [PrevNode|SubASTs],
    SubASTs \= [],
    Node \= PrevNode,
    maplist(subAST_type, SubASTs, SubASTsTypes),
    Type = GrammarType,
    assign_subASTs(ArgumentTypes, SubASTsTypes, SubASTs, NewSubASTs),
    NewExpr =.. [Node|NewSubASTs],
    (Node == modulo ->
    SubASTs = [FirstExpr,SecondExpr],
    find_integer_value(FirstExpr,FirstValue),
    FirstValue >= 0,
    find_integer_value(SecondExpr,SecondValue),
    SecondValue > 0;
    true),
    (Node == div ->
    SubASTs = [_,SecondExpr],
    find_integer_value(SecondExpr,Value),
    Value =\= 0;
    true),
    (Node == power_of ->
    SubASTs = [_,SecondExpr],
    find_integer_value(SecondExpr,Value),
    Value > 0;
    true),
    (Node == restrict_tail ->
    SubASTs = [FirstExpr,SecondExpr],
    length_of_avl_or_list(FirstExpr,Length),
    find_integer_value(SecondExpr,Value),
    Length >= Value,
    Value >= 0;
    true),
    (Node == restrict_front ->
    SubASTs = [FirstExpr,SecondExpr],
    length_of_avl_or_list(FirstExpr,Length),
    find_integer_value(SecondExpr,Value),
    Length >= Value,
    Value >= 0;
    true),
    (member(Node,[equal,not_equal]) ->
    NewSubASTs = [FirstSubAST,SecondSubAST],
    subAST_type(FirstSubAST, EqualSubType),
    subAST_type(SecondSubAST, EqualSubType);
    true).

mutate(GrammarExpr, GrammarType, b(Expr, Type, Options), b(NewExpr, Type, Options)) :-
    Expr =.. [Node|SubASTs],
    mutate_subASTs(GrammarExpr, GrammarType, SubASTs, NewSubASTs),
    NewExpr =.. [Node|NewSubASTs].

mutate_subASTs(GrammarExpr, GrammarType, [SubAST|Tail], [NewSubAST|Tail]) :-
    mutate(GrammarExpr, GrammarType, SubAST, NewSubAST).

mutate_subASTs(GrammarExpr, GrammarType, [SubAST|Tail], [SubAST|NewTail]) :-
    mutate_subASTs(GrammarExpr, GrammarType, Tail, NewTail).

search_through_subasts(Value, [SubAST|_], ASTValue) :-
    find_value_in_ast(Value, SubAST, ASTValue),
    !.

search_through_subasts(Value, [_|SubASTs], ASTValue) :-
    search_through_subasts(Value, SubASTs, ASTValue).

subAST_type(b(_, Type, _), Type).

test(equal_on_multiple_places) :-
    findall(Res, mutate(equal(A,A), pred, b(disjunct(b(implication(b(less_equal(b(integer(5),integer,[]),b(integer(6),integer,[])),pred,[]),b(truth,pred,[])),pred,[]),b(greater(b(integer(3),integer,[]),b(minus(b(add(b(integer(3),integer,[]),b(integer(2),integer,[])),integer,[]),b(integer(2),integer,[])),integer,[])),pred,[])),pred, []), Res), FoundAST),
    sort(FoundAST, CompAST),
    sort([b(equal(b(implication(b(less_equal(b(integer(5),integer,[]),b(integer(6),integer,[])),pred,[]),b(truth,pred,[])),pred,[]),b(greater(b(integer(3),integer,[]),b(minus(b(add(b(integer(3),integer,[]),b(integer(2),integer,[])),integer,[]),b(integer(2),integer,[])),integer,[])),pred,[])),pred,[]),b(disjunct(b(equal(b(less_equal(b(integer(5),integer,[]),b(integer(6),integer,[])),pred,[]),b(truth,pred,[])),pred,[]),b(greater(b(integer(3),integer,[]),b(minus(b(add(b(integer(3),integer,[]),b(integer(2),integer,[])),integer,[]),b(integer(2),integer,[])),integer,[])),pred,[])),pred,[]),b(disjunct(b(implication(b(equal(b(integer(5),integer,[]),b(integer(6),integer,[])),pred,[]),b(truth,pred,[])),pred,[]),b(greater(b(integer(3),integer,[]),b(minus(b(add(b(integer(3),integer,[]),b(integer(2),integer,[])),integer,[]),b(integer(2),integer,[])),integer,[])),pred,[])),pred,[]),b(disjunct(b(implication(b(less_equal(b(integer(5),integer,[]),b(integer(6),integer,[])),pred,[]),b(truth,pred,[])),pred,[]),b(equal(b(integer(3),integer,[]),b(minus(b(add(b(integer(3),integer,[]),b(integer(2),integer,[])),integer,[]),b(integer(2),integer,[])),integer,[])),pred,[])),pred,[])], CompAST).

test(simple_root_mutation, [nondet]) :-
    mutate(disjunct(pred,pred), pred, b(conjunct(b(truth,pred,[]),b(falsity,pred,[])),pred,[]), b(disjunct(b(truth,pred,[]),b(falsity,pred,[])),pred,[])).

test(simple_wrong_root_mutation, [fail]) :-
    mutate(less_equal(integer,integer), pred, b(conjunct(b(truth,pred,[]),b(falsity,pred,[])),pred,[]), _).

test(simple_mutation_no_root, set(AST == [b(conjunct(b(disjunct(b(truth,pred,[]), b(falsity,pred,[])),pred,[]),b(falsity,pred,[])),pred,[]), b(disjunct(b(equivalence(b(truth,pred,[]), b(falsity,pred,[])),pred,[]),b(falsity,pred,[])),pred,[])])) :-
    mutate(disjunct(pred,pred), pred, b(conjunct(b(equivalence(b(truth,pred,[]), b(falsity,pred,[])),pred,[]),b(falsity,pred,[])),pred,[]), AST).

test(simple_root_reduce_mutation, [nondet]) :-
    mutate(negation(pred), pred, b(conjunct(b(falsity,pred,[]),b(true,pred,[])),pred,[]), b(negation(b(falsity,pred,[])),pred,[])).

test(simple_root_reduce_mutation_fail, [fail]) :-
    mutate(negation(pred), pred, b(add(b(integer(3),integer,[]),b(integer(2),integer,[])),integer,[]), _).

test(simple_root_generate_pred, [nondet]) :-
    mutate(conjunct(pred,pred), pred, b(negation(b(falsity,pred,[])),pred,[]), b(conjunct(b(falsity,pred,[]),b(_,pred,_)),pred,[])).

test(simple_root_generate_integer, [nondet]) :-
    mutate(add(integer,integer), integer, b(unary_minus(b(integer(3),integer,[])),integer,[]), b(add(b(integer(3),integer,[]),b(_,integer,_)),integer,[])).

test(simple_root_generate_set, [nondet]) :-
    mutate(subset(set(A),set(A)), pred, b(finite(b(set_extension([b(integer(365),integer,[])]),set(integer),[])),pred,[]), b(subset(b(set_extension([b(integer(365),integer,[])]),set(integer),[]),b(_,set(integer),_)),pred,[])).

test(simple_root_generate_seq, [nondet]) :-
    mutate(concat(seq(A),seq(A)), seq(A), b(front(b(value([(int(1),pred_false),(int(2),pred_true)]),seq(boolean),[])),seq(boolean),[]), b(concat(b(value([(int(1),pred_false),(int(2),pred_true)]),seq(boolean),[]),b(_,seq(boolean),_)),seq(boolean),[])).

test(simple_root_generate_seq_2, [nondet]) :-
    mutate(concat(seq(A),seq(A)), seq(A), b(front(b(seq_extension([b(integer(365),integer,[])]),seq(integer),[])),seq(integer),[]), b(concat(b(seq_extension([b(integer(365),integer,[])]),seq(integer),[]),b(_,seq(integer),_)),seq(integer),[])).

test(simple_exists, [nondet]) :-
    generate(prob_ast_pred([noQuantifier]),AST),
    mutate(exists(ids,pred),pred,AST,b(exists(_,_),pred,[_])).

test(simple_forall, [nondet]) :-
    generate(prob_ast_pred([noQuantifier]),AST),
    mutate(forall(ids,constraints,pred),pred,AST,b(forall(_,_,_),pred,[_])).

test_mutator :-
    run_tests(mutator).

types_for_generate(pred, Generate_Expression) :-
    random_member(Generate_Expression, [prob_ast_pred(truth,_), prob_ast_pred(falsity,_)]).

types_for_generate(integer, prob_ast_integer([alph])).

types_for_generate(set(integer), prob_ast_set(integer([alph]))).

types_for_generate(set(boolean), prob_ast_set(boolean([alph]))).

types_for_generate(set(string), prob_ast_set(string([alph]))).

types_for_generate(seq(integer), prob_ast_seq(integer([alph]))).

types_for_generate(seq(boolean), prob_ast_seq(boolean([alph]))).

types_for_generate(seq(string), prob_ast_seq(string([alph]))).