misc: if-then machine

if-then machine:
    description:
        if-then machine
        a simplified model of a neuron
        the general idea is that each "neuron" has a collection of sequences
        and if any of them match the input, that "neuron" triggers, and activates its' "then" rule
        the output rule doesn't have to be just a literal ket/superposition/sequence
        it could also be a stored rule, and perform any desired function
        the coefficients of the output superposition are multiplied by the similarity of the input with the matched pattern
        if more than one pattern on an if-then machine matches, the coefficient could be larger than 1
        if this is not desired, you could for example use "clean" or "sigmoid-min[1]"
        the eventual goal is to have many layers of if-then machines processing some given input

    examples:
        -- the structure of a single if-then machine:
        pattern |node: 1: 1> => seq1
        pattern |node: 1: 2> => seq2
        ...
        pattern |node: 1: n> => seqn
        then |node: 1: *> => output-sp


        -- let's define an abstract example:
        -- basically detect small fragments of the alphabet
        -- either in superposition or in sequence form
        pattern |node: 1: 1> => split |abc>
        pattern |node: 1: 2> => ssplit |abc>
        then |node: 1: *> => |found: abc>

        pattern |node: 2: 1> => split |uv>
        pattern |node: 2: 2> => ssplit |uv>
        then |node: 2: *> => |found: uv>

        pattern |node: 3: 1> => split |xyz>
        pattern |node: 3: 2> => ssplit |xyz>
        then |node: 3: *> => |found: xyz>

        -- now define the back-end operator:
        -- the drop-below[0.5] is to remove matches with less than 50% similarity
        if-then (*) #=> then drop-below[0.5] similar-input[pattern] |__self>


        -- now take a quick look at what we know:
        sa: dump
            ------------------------------------------
            |context> => |Global context>

            pattern |node: 1: 1> => |a> + |b> + |c>
            pattern |node: 1: 2> => |a> . |b> . |c>
            then |node: 1: *> => |found: abc>

            pattern |node: 2: 1> => |u> + |v>
            pattern |node: 2: 2> => |u> . |v>
            then |node: 2: *> => |found: uv>

            pattern |node: 3: 1> => |x> + |y> + |z>
            pattern |node: 3: 2> => |x> . |y> . |z>
            then |node: 3: *> => |found: xyz>

            if-then (*) #=> then drop-below[0.5] similar-input[pattern]|__self>
            ------------------------------------------


        -- now some examples:
        -- let's input xyz as a superposition:
        if-then split |xyz>
            |found: xyz>

        -- now as a sequence:
        if-then ssplit |xyz>
            |found: xyz>

        -- once again, this time input uv as a superposition:
        if-then split |uv>
            |found: uv>

        -- now as a sequence:
        if-then ssplit |uv>
            |found: uv>


        -- now matching partial superpositions and sequences:
        if-then split |bc>
            0.666667|found: abc>

        if-then ssplit |ab>
            0.666667|found: abc>

    see also:
        similar-input, strict-similar-input, equal-input, drop-below, identify-and-predict-integer-sequence-fragments.sw3