-- use smap and if-then machines to identify and predict next digits from an integer sequence fragment:

-- min and max ngram lenghts for the prediction if-then machines:
min |ngram len> => |3>
max |ngram len> => |9>

-- min and max fragment lengths for id-sequence operator:
min |fragment len> => |3>
max |fragment len> => |3>


-- learn our integer sequences:
fib |0> => |0>
fib |1> => |1>
fib |*> !=> arithmetic( fib minus[1] |_self>, |+>, fib minus[2] |_self>)

fact |0> => |1>
fact |*> !=> arithmetic(|_self>, |*>, fact minus[1] |_self>)

-- provide a literal operator wrapper around the function operator
-- function operators don't get invoked in x.apply_op(context, op), only literal operators do.
is-prime |*> #=> is-prime |_self>

int-seq |count> => sp2seq range(|1>, |100>)
int-seq |fib> => fib sp2seq range(|1>, |30>)
int-seq |fact> => fact sp2seq range(|1>, |15>)
int-seq |primes> => such-that[is-prime] sp2seq range(|1>, |200>)


-- learn what is a digit:
list-of |digits> => |0> + |1> + |2> + |3> + |4> + |5> + |6> + |7> + |8> + |9>
is-digit |*> #=> is-mbr(|_self>, list-of |digits>)
is-integer |*> #=> is-subset(clean split[""] replace[", ", ""] |_self>, list-of |digits>)

-- define a digit encoder (note, it isn't a number encoder, just digits):
-- change the value passed to the Gaussian operator to change width of the Gaussian.
digit-encoder |*> #=> if(is-digit |_self>, Gaussian[0.6] |_self>, |_self>)

-- define an integer encoder, again, may want to change the width of the Gaussian:
integer-encoder |*> #=> if(is-integer |_self>, Gaussian[1] |_self>, |_self>)



-- define the if-then machine create-rule for the id-sequence code:
create-single-rule (*) #=>
    node |label> => |node: > _ node |number> _ |: > _ node |idx>
    int-seq-pattern node |label> => |__self>
    node |idx> => plus[1] node |idx>


-- define the if-then machine create-rule for the predict-next and fuzzy-predict-next code:
create-next-rules (*) #=>
    node |label> => |node: > _ node |number> _ |: > _ node |idx>
    pattern node |label> => sselect[1,-2] |__self>
    fuzzy-pattern node |label> => integer-encoder sselect[1,-2] |__self>
    next-1 node |label> => sselect[-1,-1] |__self>
    node |idx> => plus[1] node |idx>
    --
    node |label> => |node: > _ node |number> _ |: > _ node |idx>
    pattern node |label> => sselect[1,-3] |__self>
    fuzzy-pattern node |label> => integer-encoder sselect[1,-3] |__self>
    next-2 node |label> => sselect[-2,-1] |__self>
    node |idx> => plus[1] node |idx>
    --
    node |label> => |node: > _ node |number> _ |: > _ node |idx>
    pattern node |label> => sselect[1,-4] |__self>
    fuzzy-pattern node |label> => integer-encoder sselect[1,-4] |__self>
    next-3 node |label> => sselect[-3,-1] |__self>
    node |idx> => plus[1] node |idx>
    --
    node |label> => |node: > _ node |number> _ |: > _ node |idx>
    pattern node |label> => sselect[1,-5] |__self>
    fuzzy-pattern node |label> => integer-encoder sselect[1,-5] |__self>
    next-4 node |label> => sselect[-4,-1] |__self>
    node |idx> => plus[1] node |idx>


-- a helper operator:
extract-node-numbers |*> #=> sselect[2,2] ssplit[": "] |_self>

-- define our if-then machine creation operator:
create-if-then-machine (*,*) #=>
    node |number> => |1>
    node |number> => plus[1] clean select[-1,-1] ket-sort extract-node-numbers rel-kets[then] |>
    node |idx> => |1>
    smap(min |ngram len>, max |ngram len>, |__self1>) |__self0>
    node |label> => |node: > _ node |number> _ |: *>
    then node |label> => |__self2>


-- print out start learning message:
|null> => print (| > . |Starting to learn our sequences ... >)

-- now use it to create the next-k if-then machines:
|null> => create-if-then-machine(|op: create-next-rules>, |integer sequence: counting>) int-seq |count>
|null> => create-if-then-machine(|op: create-next-rules>, |integer sequence: fibonacci>) int-seq |fib>
|null> => create-if-then-machine(|op: create-next-rules>, |integer sequence: factorial>) int-seq |fact>
|null> => create-if-then-machine(|op: create-next-rules>, |integer sequence: primes>) int-seq |primes>


-- now create the id sequence if-then machines:
min |ngram len> => |3>
max |ngram len> => |3>
|null> => create-if-then-machine(|op: create-single-rule>, |integer sequence: counting>) int-seq |count>
|null> => create-if-then-machine(|op: create-single-rule>, |integer sequence: fibonacci>) int-seq |fib>
|null> => create-if-then-machine(|op: create-single-rule>, |integer sequence: factorial>) int-seq |fact>
|null> => create-if-then-machine(|op: create-single-rule>, |integer sequence: primes>) int-seq |primes>

-- print out finished learning message:
|null> => print (|Finished learning> __ extract-value to-comma-number how-many rel-kets[*] |> __ |rules.> . | >)


-- define the id-sequence operator:
simm-pattern (*) #=> then drop-below[0.8] similar-input[int-seq-pattern] |_self>
id-sequence |*> #=> smap(min |fragment len>, max |fragment len>, |op: simm-pattern>) ssplit[" "] |_self>


-- define the predict-next operator:
predict-nodes |*> #=> drop-below[0.97] similar-input[pattern] ssplit[" "] |_self>
do-you-know-prediction |*> #=> do-you-know predict-nodes |_self>

predict-next |*> #=>
    the |result> => |#EMPTY#>
    the |result> => predict-nodes |__self>
    print-result the |result>

print-result |#EMPTY#> => |Anomaly, no sequence detected ... >
print-result |*> #=> print-next |_self>


-- define the print-next operators:
print-next-1 |yes> #=> print (extract-value round[1] push-float 100 tmp |var> _ | %     > __ then tmp |var> __ |     pattern:     > _ smerge[" "] pattern tmp |var> _ |      next-1:     > _ smerge[" "] next-1 tmp |var>)
print-next-2 |yes> #=> print (extract-value round[1] push-float 100 tmp |var> _ | %     > __ then tmp |var> __ |     pattern:     > _ smerge[" "] pattern tmp |var> _ |      next-2:     > _ smerge[" "] next-2 tmp |var>)
print-next-3 |yes> #=> print (extract-value round[1] push-float 100 tmp |var> _ | %     > __ then tmp |var> __ |     pattern:     > _ smerge[" "] pattern tmp |var> _ |      next-3:     > _ smerge[" "] next-3 tmp |var>)
print-next-4 |yes> #=> print (extract-value round[1] push-float 100 tmp |var> _ | %     > __ then tmp |var> __ |     pattern:     > _ smerge[" "] pattern tmp |var> _ |      next-4:     > _ smerge[" "] next-4 tmp |var>)


print-next |*> #=>
    tmp |var> => |__self>
    print-next-1 do-you-know next-1 |__self>
    print-next-2 do-you-know next-2 |__self>
    print-next-3 do-you-know next-3 |__self>
    print-next-4 do-you-know next-4 |__self>
    |results>


-- define the fuzzy-predict-next operator:
fuzzy-predict-nodes |*> #=> drop-below[0.5] similar-input[fuzzy-pattern] integer-encoder ssplit[" "] |_self>
do-you-know-fuzzy-prediction |*> #=> do-you-know fuzzy-predict-nodes |_self>

fuzzy-predict-next |*> #=>
    the |result> => |#EMPTY#>
    the |result> => fuzzy-predict-nodes |__self>
    print-result the |result>



print-usage |*> #=>
    print
    print |Usage:>
    print |  Split the input sequence into fragments, and identify which sequence it belongs to:>
    print |    id-sequence ket(1 2 3 4)> 
    print |    id-sequence ket(2 3 5 8)>
    print
    print
    print |  Given a sequence, return matching nodes:>
    print |    predict-nodes ket(2 3 5 8)>
    print
    print |  Given a sequence, predict the next elements:>
    print |    predict-next ket(1 2 3)>
    print |    predict-next ket(1 2 3 4 5)>
    print |    predict-next ket(2 3 5 8)>
    print |    predict-next ket(2 6 24)>
    print |    predict-next ket(2 3 5 7)>
    print |    predict-next ket(9 9 9)>
    print
    print |  Given a sequence, test if it is recognized:>
    print |    do-you-know-prediction ket(2 6 24)>
    print |    do-you-know-prediction ket(9 9 9)>
    print
    print
    print |  Given a sequence, return fuzzy matching nodes:>
    print |    fuzzy-predict-nodes ket(11 12 13 14)>
    print
    print |  Given a sequence, fuzzy-predict the next elements:>
    print |    fuzzy-predict-next ket(2 3 5 7 11)>
    print |    fuzzy-predict-next ket(9 9 9)>
    print
    print |  Given a sequence, test if it is fuzzy-recognized:>
    print |    do-you-know-fuzzy-prediction ket(9 9 9)>
    print


|null> => print-usage |>