Memetic Index
Introduction
I've been trying for weeks to write down all of the transitions possible in the Triangular Baseball System. I've been drawing transition diagrams, and I've made some breakthroughs, but it's still proving a bit unwieldy to make sure I'm not missing any transitions.
My approach has been to start with each of the terminal states, S0 (no one on base, BasesOpen), S1 (man on first, OnFirst), S2 (man on second, OnSecond), and S3 (bases loaded, Loaded) and follow them through all of the possible transitions until each branch ends with another terminal state. This has proven much more fruitful than trying to delineate all of the transitions between any two terminal states, for instance (which was my previous strategy). It's hard to check that all transitions have been written down, and it's a bit unwieldy doing it with a transition diagram as the point of departure, in terms of drawing it and fitting everything in.
In the end what I found is that writing down all of the deployment descriptors, focusing on the deployments of "the field" as being immunomemetic and/or alliance deployments which enable other deployments, to be away of exhausting the possibilities. Then once I had all the internal states I needed, I could create the transition matrix sets and diagrams. Consistent with experience so far, starting from the deployment descriptors seems to be the most fruitful and clear-cut way to go.
My motivation is to demonstrate that it is possible to exhaustively map the Transition Matrix Set (2) for a simple, well-understood system, and to show what that looks like. The next step is to apply it to less well-understood systems, specifically my other project of Chess as a memetic model of two societies in conflict (3).
The Deployment Descriptor Approach
An insight I had recently is that the equal sign is relevant in deployment descriptors, and is different to the "=>" symbol which I have been using. StateA.memelist! => StateB refers to deploying a bunch of memes, memelist!, while in state StateA results in transition to StateB. I have also been using just memelist! => StateB in cases where the current state is implied, or memelist! is perhaps a kind of shorthand, or uses parameters or lists [ agentX,meme1!, meme2!,..., memeN! ] which may have only local meanings. However, if all memes and starting and ending states are fully specified, StateA.memelist! is equivalent to StateB, so I can write StateA.memelist! = StateB. We could even posit notation such as StateA = StateB.(-memelist!) or (StateB - StateA) = memelist! It's unclear how useful such things might be at this point, however.
Transitions from S0 (BasesOpen)
Here's what a transition diagram looks like for all plays starting from BasesOpen (S0).
fig. 0.1. State Transition Diagram for S0 (BasesOpen) |
Here are the deployment descriptors for all paths starting from BasesOpen (S0) and proceeding to a terminal state.
(1) BasesOpen.hit!batter.first! => A "No one on base, batter runs to first"
(2) A.field.first!batter.out! => BasesOpen "batter out on first"
(3) A.field.second!batter.safe!(first) => OnFirst "ball at second, batter stops at first"
(4) A.batter.second! => B "batter passes first and is clear to go to second"
(5) B.field.second!batter.out! => BasesOpen "batter tagged out at second"
(6) B.field.home!batter.safe!(second) => OnSecond "ball at home, batter stops at second"
(7) B.batter.home! => C "batter runs for home"
(8) C.field.home!batter.out! => BasesOpen "ball thrown home, batter tagged out"
(9) C.batter.safe!(home) => BasesOpen "batter scores a run"
fig 0.2. Deployment Descriptors Starting from BasesOpen (S0)
The point here is that at every state there is an opportunity for the fielding team to take action. BasesOpen (S0) is the simplest state, only one runner, nobody on base yet. The fielding team can throw the ball to any of the bases, or effectively be "in the process," giving the runners a chance to move freely.
There are a couple of ways to think about this. In steps (4), (7), and (9), the batter is taking action, deploying a meme without the fielding team doing anything. We could imagine saying that the fielding teams is in fact deploying a meme, that is, "an error," or field.error! or (9) C.field.error!batter.safe!(home). We can also notice that in all the other deployments, that is, where the field is doing something, it looks like an immunomemetic deployment or an alliance deployment where the action of the batting team is compelled or enabled by the fielding team. Here we note again that immunomemetic notation and alliance notation are homologous. The sociological implications of this may be far-reaching, but that may be for another time.
To be clear, states A, B, and C are "transitional states." The game cannot stop at those states--they must continue on to a terminal state. They are not really "compelled states," per se (1), but the immunomemetic and alliance deployments, that is, the combined memetic deployments, such as (8) C.field.home!batter.out! do represent a compelled state, that is, one where one agent has no choice but to deploy a given meme (or set of memes). A "long form" could look like:
(8) C.field.home! => C-Hidden.batter.out! => BasesOpen
So we see how the batter has no freedom of choice, and that this is part and parcel of an immunomemetic deployment (or an alliance deployment), and thus we employ the immunomemetic notation of combined memes. We'll discuss how this looks in terms of the Transition Matrix Subset for S0 (BasesOpen) below.
The idea is that if the fielding team does not get the ball to any relevant positions, either forcing the runner out or forcing him to stay put, such as (2) and (3), the runner is then free to exercise whatever other options there may be, e.g., keep running, as in (4). This is essentially just another compelled state where the runner has an open base coming up next, and thus has nothing better to do than to run for it, even though he may get tagged out in the end.
Here's the Transition Matrix Subset for S0 (BasesOpen). I call it a "subset" because it is not a complete representation of all state transitions of the triangular baseball system, but only those that begin at the S0 state. Elaborating a set of matrices for all four start states, S0, S1, S2, S3, and then renaming the states in each of those matrix sets to SO-A, SO-B, and so forth, would constitute a complete Transition Matrix Set for the Triangular Baseball Memeplex.
S0 | agents | ||
---|---|---|---|
field | batter | ||
m e m e s |
hit!first! | A |
A | agents | ||
---|---|---|---|
field | batter | ||
m e m e s |
first! | batter.out! => BasesOpen | |
second! | batter.safe!(first) => OnFirst | B | |
home! | |||
safe!( ) | |||
out! |
B | agents | ||
---|---|---|---|
field | batter | ||
m e m e s |
first! | ||
second! | batter.out! => BasesOpen | ||
home! | batter.safe!(second) => OnSecond | C | |
safe!( ) | |||
out! |
C | agents | ||
---|---|---|---|
field | batter | ||
m e m e s |
first! | ||
second! | |||
home! | batter.out! => BasesOpen | ||
safe!( ) | BasesOpen | ||
out! |
A Note on Compelled States and Transition Matrixes
The classic image of a transition matrix in a transition matrix set, or a transition diagram or deployment descriptor is StartState.agent1.meme1! => NewState. If we look at matrix C in the BasesOpen transition matrix subset (fig. 0.3.) we see that when the batter deploys safe! we go to BasesOpen, i.e., the only entry in that node in the matrix is the state itself. However, when the field deploys home!, the batter is out before the system ends up in BasesOpen. In other words, the batter is forced to deploy out! This is by definition a compelled state, i.e., the batter has no choice in deploying it. In that sense we have a shorthand. We could just as well depict a different version of Matrix C, C' and add another matrix, C'' where all that goes on is that the batter has to deploy out! and so we'd call that a compelled state matrix. In a state transition diagram that would be a "cloud" with only one arrow coming in and only one going out, i.e., no choice.
C' | agents | ||
---|---|---|---|
field | batter | ||
m e m e s |
first! | ||
second! | |||
home! | C'' | ||
safe!( ) | BasesOpen | ||
out! |
C'' | agents | ||
---|---|---|---|
field | batter | ||
m e m e s |
first! | ||
second! | |||
home! | |||
safe!( ) | |||
out! | BasesOpen |
Here we see how we have an extra matrix in which nothing interesting happens except that the batter always gets out and the system proceeds to BasesOpen. This is a compelled state matrix for that reason. Note that the probability weighting on the single entry in the compelled state matix is, obviously, 100%. It's the only thing that can possibly happen. The original configuration of Matrix C (figs. 0.2. and 0.3.) is a "shorthand". As a computational representation of the system, fig. 03.1. is probably a better, more consistent way to go.
Transitions from OnFirst (S1)
Carrying on from the foregoing, we try a more complex example. Here we have two runners, so two agents making somewhat independent decisions. Here we see how if the field gets one runner out, the other is effectively guaranteed to be safe somewhere else.
Deployment Descriptors for S1 (OnFirst)
OnFirst.hit!batter.first! => A
A.field.first!first.safe!(first)batter.out! => OnFirst
A.field.second!first.safe!(first).batter.out! => OnFirst
A.first.second! => B
"batter running to first, first base runs to second"
B.field.first!batter.out!first.home! => C
B.field.second!first.out!batter.safe!(first) => OnFirst
B.field.home!first.safe!(second) => C1
B.first.home! => D
"batter out, first running towards home"
C.field.home!first.out! => BasesOpen
C.first.safe!(home) => BasesOpen
"first safe at second, batter still running to first"
C1.batter.safe!(first) => Loaded
C1.field.first!batter.out! => OnSecond
"batter still running towards first, first running to home"
D.field.first!batter.out!first.safe!(home) => BasesOpen
D.field.second!batter.safe!(first)first.safe!(home) => OnFirst
D.field.home!first.out!batter.second! => E "runner is compelled by open base"
D.first.safe!(home)batter.second! => E
"first base runner out/safe, batter rounding second"
E.field.second!batter.out! => BasesOpen
E.field.home!batter.safe!(second) => OnSecond
E.batter.home! => F
"batter running for home"
F.field.home!batter.out! => BasesOpen
F.batter.safe!(home) => BasesOpen
fig. 1.1. Deployment Descriptors for S1
fig. 1.2. Transition diagram for S1 |
Transition Matrix (sub)Set for S1
S1 | agents | ||
---|---|---|---|
field | batter | ||
m e m e s |
hit!first! | A |
A | agents | |||
---|---|---|---|---|
field | batter | first | ||
m e m e s |
first! | first.safe!(first)batter.out! => OnFirst | ||
second! | first.safe(first).batter.out! => OnFirst | B | ||
home! | ||||
safe!( ) | ||||
out! |
B | agents | |||
---|---|---|---|---|
field | batter | first | ||
m e m e s |
first! | batter.out!first.home! => C | ||
second! | first.out!batter.safe!(first) => OnFirst | |||
home! | first.safe!(second) => C1 | D | ||
safe!( ) | ||||
out! |
C | agents | |||
---|---|---|---|---|
field | batter | first | ||
m e m e s |
first! | |||
second! | ||||
home! | first.out! => BasesOpen | |||
safe!( ) | (home) BasesOpen | |||
out! |
C1 | agents | |||
---|---|---|---|---|
field | batter | first | ||
m e m e s |
first! | batter.out! => OnSecond | ||
second! | ||||
home! | ||||
safe!( ) | (first) Loaded | |||
out! |
D | agents | |||
---|---|---|---|---|
field | batter | first | ||
ba e m e s |
first! | batter.out!first.safe!(home) => BasesOpen | ||
second! | batter.safe!(first)first.safe!(home) => OnFirst | |||
home! | first.out!batter.second! => E | |||
safe!( ) | (home) batter.second! => E | |||
out! |
E | agents | |||
---|---|---|---|---|
field | batter | first | ||
m e m e s |
first! | |||
second! | batter.out! => BasesOpen | |||
home! | batter.safe!(second) => OnSecond | F | ||
safe!( ) | ||||
out! |
F | agents | |||
---|---|---|---|---|
field | batter | first | ||
m e m e s |
first! | |||
second! | ||||
home! | batter.out! => BasesOpen | |||
safe!( ) | (home) BasesOpen | |||
out! |
Transitions from OnSecond (S2)
The Deployment Descriptor List for OnSecond
The first thing that happens is that the batter gets a good hit and starts running to first base, which is unoccupied, hence no forced out this time. I need to make sure I can get back to all states, including S1 (OnFirst). Except for S0, all states can make it to all other states.A1.batter.second! => A2
A2.field.second!batter.out! => B
C.field.first!batter.out! => OnSecond
fig. 2.2. Transition Diagram for S2 (OnSecond) |
The Transition Matrix Set for OnSecond (S2)
S2 | agents | ||
---|---|---|---|
field | batter | ||
m e m e s |
hit!first! | A |
A | agents | |||
---|---|---|---|---|
field | batter | second | ||
m e m e s |
first! | batter.out!second.home! => B | ||
second! | second.safe!(second) => C | |||
home! | second.safe!(second) => C | A1 | ||
safe!( ) | ||||
out! |
A1 | agents | |||
---|---|---|---|---|
field | batter | second | ||
m e m e s |
first! | batter.out! => B | ||
second! | batter.safe!(first) => E | A2 | ||
home! | ||||
safe!( ) | ||||
out! |
A2 | agents | |||
---|---|---|---|---|
field | batter | second | ||
m e m e s |
first! | |||
second! | batter.out! => B | |||
home! | second.out!batter.safe!(second) => OnSecond | |||
safe!( ) | (home) batter.home! => D | |||
out! |
B | agents | |||
---|---|---|---|---|
field | batter | second | ||
m e m e s |
first! | |||
second! | ||||
home! | second.out! => BasesOpen | |||
safe!( ) | (home) BasesOpen | |||
out! |
C | agents | |||
---|---|---|---|---|
field | batter | second | ||
m e m e s |
first! | batter.out! => OnSecond | ||
second! | ||||
home! | ||||
safe!( ) | (first) Loaded | |||
out! |
D | agents | |||
---|---|---|---|---|
field | batter | second | ||
m e m e s |
first! | |||
second! | ||||
home! | batter.out!=> BasesOpen | |||
safe!( ) | (home) BasesOpen | |||
out! |
E | agents | |||
---|---|---|---|---|
field | batter | second | ||
m e m e s |
first! | |||
second! | ||||
home! | second.out!=> BasesOpen | |||
safe!( ) | (home) BasesOpen | |||
out! |
S3 | agents | ||
---|---|---|---|
field | batter | ||
m e m e s |
hit!first! | A |
A | agents | ||||
---|---|---|---|---|---|
field | batter | first | second | ||
m e m e s |
first! | batter.out!second.home! => B | |||
second! | second.safe!(second)first.safe!(first)batter.out! => Loaded | ||||
home! | second.safe!(second)first.safe!(first)batter.out! => Loaded | A1 | |||
safe!( ) | |||||
out! |
A1 | agents | ||||
---|---|---|---|---|---|
field | batter | first | second | ||
m e m e s |
first! | batter.out!first.safe!(first)second.safe!(home) => OnFirst | |||
second! | first.safe!(first)batter.out!second.safe!(home) => OnFirst | ||||
home! | first.safe!(second)batter.safe!(first) => Loaded | ||||
safe!( ) | (home) first..second! => A2 | ||||
out! |
A2 | agents | ||||
---|---|---|---|---|---|
field | batter | first | second | ||
m e m e s |
first! | batter.out!(first.home! => E | |||
second! | first.out!batter.safe!(first) => OnFirst | ||||
home! | first.safe!(second)batter.safe!(first) => Loaded | batter.second! => C | |||
safe!( ) | |||||
out! |
B | agents | ||||
---|---|---|---|---|---|
field | batter | first | second | ||
m e m e s |
first! | first.safe!(first)second.safe!(home) => OnFirst | |||
second! | first.safe!(first)second.safe!(home) => OnFirst | ||||
home! | second.out!first.second! => D | ||||
safe!( ) | (home) first.second! => D | ||||
out! |
C | agents | ||||
---|---|---|---|---|---|
field | batter | first | second | ||
m e m e s |
first! | ||||
second! | first.safe!(home)batter.out! => BasesOpen | ||||
home! | first.out!batter.safe!(second) => OnSecond | ||||
safe!( ) | (home) batter.home! => F | ||||
out! |
D | agents | ||||
---|---|---|---|---|---|
field | batter | first | second | ||
m e m e s |
first! | ||||
second! | first.out! => BasesOpen | ||||
home! | first.safe!(second) => OnSecond | E | |||
safe!( ) | |||||
out! |
E | agents | ||||
---|---|---|---|---|---|
field | batter | first | second | ||
m e m e s |
first! | ||||
second! | |||||
home! | first.out! => BasesOpen | ||||
safe!( ) | (home) BasesOpen | ||||
out! |
F | agents | ||||
---|---|---|---|---|---|
field | batter | first | second | ||
m e m e s |
first! | ||||
second! | |||||
home! | batter.out! => BasesOpen | ||||
safe!( ) | (home) BasesOpen | ||||
out! |
Summary, Conclusions, and Future Work
_______________________________
FOOTNOTES
(1) See glossary for discussion of transitional, virtual, hidden, and compelled states.
(2) The Transition Matrix Set is a property object of a memeplex that describes how the memes and agents in the memeplex cause transitions between the various states of said memeplex. In this essay, I'm attacking the Transition Matrix Subsets of the triangle baseball memeplex, that is, I'm starting from each of the four states -- S0, BasesOpen; S1, OnFirst; S2, OnSecond; and S3, Loaded -- and following each series of transition states pertinent to the given subset through to one of the other terminal states.
(3) I want to use the game of chess as a model for two societies, read, memeplexes, in competition. Chess is a familiar system to many people, with a variety of pieces which could be used as the anchors for a heterogeneous collection of deployment opportunities, memetic nexuses (4), and so forth. One idea is to be able to "download" a given memeplex into one side or the other, and see how it plays out against another memeplex.
(4) I am also considering the term "memetic hub" for memetic nexus, since it may be more accessible.