Very simple finite automaton (?)

[kpp9c]

Very simple finite automaton (?)

I am not sure if this is and example of Finite Automaton or a Finite
State Machine or perhaps it is related to a transition table or markov
process. I am not a math person so i am not sure what it is called. I
googled around and got lots of super complicated gobbledegoo all with
knotty regex stuff, but what i want to do is much more simple.

I am trying to use a table (called a transition table? i dunno) to
define a bunch of moves like so:

1 --> 2 5
2 --> 1 4
3 --> 3
4 --> 1
5 --> 4 3

so that i can generate a sequence that, given an initial value, will
continue to grow according to these rules.

So starting with 1, we get:

1
2 5
1 4 4 3
2 5 1 1 3
1 4 4 3 2 5 2 5 3


...... etc.

Essentially, iterating over the last added items to the list, applying
the table, adding those new items to the list, applying the table
again... etc, until the sequence reaches some predetermined number of
iterations and quits.


[ [1], [2, 5], [1, 4] , [4, 3], [2, 5], [1], [1], [3], [1, 4], [4, 3],
[2, 5], [2, 5], [3] ]


First, I would like to know what, precisely, this kind of process is
called so that i can look it up. Many names are suggested but when
googling more names and acronyms show up, maybe there are many names
used for a variety of related things, but I could be curious to know
exactly what this is an instance of. Second, I am not sure how to get
started with the loop (is this an example of recursion?) and how best
to represent the table (dictionary)? If anyone has an example of how
to do this or a suggestion on where to start poking around, that would
be great.

cheers,

kp

macosx, python2.5 & 2.6

 

[Steven D'Aprano]

I am trying to use a table (called a transition table? i dunno) to
define a bunch of moves like so:

1 --> 2 5
2 --> 1 4
3 --> 3
4 --> 1
5 --> 4 3

so that i can generate a sequence that, given an initial value, will
continue to grow according to these rules. ....
First, I would like to know what, precisely, this kind of process is
called so that i can look it up. Many names are suggested but when
googling more names and acronyms show up, maybe there are many names
used for a variety of related things, but I could be curious to know
exactly what this is an instance of.

No idea, sorry

Second, I am not sure how to get
started with the loop (is this an example of recursion?) and how best to
represent the table (dictionary)? If anyone has an example of how to do
this or a suggestion on where to start poking around, that would be
great.

Start with a set of rules:

rules = {1: (2, 5), 2: (1, 4), 3: (3,), 4: (1,), 5: (4, 3)}

There are lots of ways to go from here, possibly including recursion, but
this is the way that feels most natural to me. Create a generator that
applies the rules from some input sequence:

def apply_rules(sequence):
for element in sequence:
# look it up in the global rules
values = rules[element]
# yield each of those in turn
for value in values:
yield value


And now use it to build new lists, replacing the old list each time. Here
it is in use:

data = [1]
for i in range(5):

.... print data
.... gen = apply_rules(data)
.... data = list(gen)
....
[1]
[2, 5]
[1, 4, 4, 3]
[2, 5, 1, 1, 3]
[1, 4, 4, 3, 2, 5, 2, 5, 3][2, 5, 1, 1, 3, 1, 4, 4, 3, 1, 4, 4, 3, 3]

 

[Diez B. Roggisch]

Very simple finite automaton (?)

I am not sure if this is and example of Finite Automaton or a Finite
State Machine or perhaps it is related to a transition table or markov
process. I am not a math person so i am not sure what it is called. I
googled around and got lots of super complicated gobbledegoo all with
knotty regex stuff, but what i want to do is much more simple.

I am trying to use a table (called a transition table? i dunno) to
define a bunch of moves like so:

1 --> 2 5
2 --> 1 4
3 --> 3
4 --> 1
5 --> 4 3

so that i can generate a sequence that, given an initial value, will
continue to grow according to these rules.

So starting with 1, we get:

1
2 5
1 4 4 3
2 5 1 1 3
1 4 4 3 2 5 2 5 3


..... etc.

Essentially, iterating over the last added items to the list, applying
the table, adding those new items to the list, applying the table
again... etc, until the sequence reaches some predetermined number of
iterations and quits.

What you show as example and what you describe here differ - the above
example shows replacements, while you *talk* about adding.

[ [1], [2, 5], [1, 4] , [4, 3], [2, 5], [1], [1], [3], [1, 4], [4, 3],
[2, 5], [2, 5], [3] ]


First, I would like to know what, precisely, this kind of process is
called so that i can look it up. Many names are suggested but when
googling more names and acronyms show up, maybe there are many names
used for a variety of related things, but I could be curious to know
exactly what this is an instance of. Second, I am not sure how to get
started with the loop (is this an example of recursion?) and how best
to represent the table (dictionary)? If anyone has an example of how
to do this or a suggestion on where to start poking around, that would
be great.

It sure isn't a finite automaton. The things it reminds me of are these:

http://en.wikipedia.org/wiki/Context-sensitive_grammar
http://en.wikipedia.org/wiki/L-system

This is under the assumption you mean replacment, not adding.

Diez

 

[MCIPERF]

It seems to that you have a transformational grammar.

Gerry

kpp9c schrieb:

Very simple finite automaton (?)

I am not sure if this is and example of Finite Automaton or a Finite
State Machine or perhaps it is related to a transition table or markov
process. I am not a math person so i am not sure what it is called. I
googled around and got lots of super complicated gobbledegoo all with
knotty regex stuff, but what i want to do is much more simple.

I am trying to use a table (called a transition table? i dunno) to
define a bunch of moves like so:

1 --> 2 5
2 --> 1 4
3 --> 3
4 --> 1
5 --> 4 3

so that i can generate a sequence that, given an initial value, will
continue to grow according to these rules.

So starting with 1, we get:

1
2 5
1 4 4 3
2 5 1 1 3
1 4 4 3 2 5 2 5 3

..... etc.

Essentially, iterating over the last added items to the list, applying
the table, adding those new items to the list, applying the table
again... etc, until the sequence reaches some predetermined number of
iterations and quits.

What you show as example and what you describe here differ - the above
example shows replacements, while you *talk* about adding.

[ [1], [2, 5], [1, 4] , [4, 3], [2, 5], [1], [1], [3], [1, 4], [4, 3],
[2, 5], [2, 5], [3] ]

First, I would like to know what, precisely, this kind of process is
called so that i can look it up. Many names are suggested but when
googling more names and acronyms show up, maybe there are many names
used for a variety of related things, but I could be curious to know
exactly what this is an instance of. Second, I am not sure how to get
started with the loop (is this an example of recursion?) and how best
to represent the table (dictionary)? If anyone has an example of how
to do this or a suggestion on where to start poking around, that would
be great.

It sure isn't a finite automaton. The things it reminds me of are these:

   http://en.wikipedia.org/wiki/Context-sensitive_grammar
   http://en.wikipedia.org/wiki/L-system

This is under the assumption you mean replacment, not adding.

Diez

 

[akonsu]

Very simple finite automaton (?)

1 --> 2 5
2 --> 1 4
3 --> 3
4 --> 1
5 --> 4 3

hello,
this is a graph and you are doing depth first search.
konstantin

 

[akonsu]

hello,
this is a graph and you are doing depth first search.
konstantin

BREADTH first. sorry

 

[duncan smith]

Very simple finite automaton (?)

I am not sure if this is and example of Finite Automaton or a Finite
State Machine or perhaps it is related to a transition table or markov
process. I am not a math person so i am not sure what it is called. I
googled around and got lots of super complicated gobbledegoo all with
knotty regex stuff, but what i want to do is much more simple.

I am trying to use a table (called a transition table? i dunno) to
define a bunch of moves like so:

1 --> 2 5
2 --> 1 4
3 --> 3
4 --> 1
5 --> 4 3

so that i can generate a sequence that, given an initial value, will
continue to grow according to these rules.

So starting with 1, we get:

1
2 5
1 4 4 3
2 5 1 1 3
1 4 4 3 2 5 2 5 3


..... etc.

Essentially, iterating over the last added items to the list, applying
the table, adding those new items to the list, applying the table
again... etc, until the sequence reaches some predetermined number of
iterations and quits.


[ [1], [2, 5], [1, 4] , [4, 3], [2, 5], [1], [1], [3], [1, 4], [4, 3],
[2, 5], [2, 5], [3] ]

[snip]

I'm interested to know what you're then doing with the list. Depending
on that you might want to view it (or implement it) in terms of a
matrix, graph ...

Duncan