|
Hi
JohnK,
Good question. An
example of a nonsimulable model would be the (M,R)-system (the one with the
replication). More generally, any model which contains an impredicative loop (a
closed loop of entailment) would be nonsimulable.
It is also
important to distinguish between models and simulations. Quite often, there
is a tendency in modern science to lump models and simulations together as if
they were of the same ilk. And so what might appear at first blush to be a
"simulable model" may, in fact, be a simulable simulation! Particularly once
both have been converted to computer programs, the difference is hidden
behind-the-scenes in the code, and not seen by those running the programs,
making them difficult to distinguish.
Models possess a
congruence of entailment structure with the object system, whereas a simulation
has no such requirement - the only goal of a simulation is to mimic behavior,
regardless of whether the internal workings of the simulation bear any
resemblance at all to the internal workings of the object system. Another way to
say it is that we can query models in order to answer questions about
why a system behaves as it does; a simulation is only a kind of
curve-fitting, it can perhaps show us how a system will behave, but it
cannot tell anything about us why it behaves that
way.
When a model can
be converted to a program for a Turing machine, and still retain, in that
programmatic form, the same congruence of entailment structure with the object
system (that is, the model will still be in a congruent Modeling Relation with
the object system), then it is a simulable model. Models that fit this
criteria are those that are already predicative - their entailment
structure can be no more elaborate than the entailment structure of a
Turing machine's plodding, next-step, algorithmic hardware.
If the model had a
more elaborate entailment structure than the Turing-machine's hardware (i.e.,
the model contains impredicative loops) then turning the model into a
program would involve coding in some kinds of work-arounds
of the entailment limitations of the Turing-machine, and in the process of
this coding, the model's original entailment structure is altered;
ergo, the resulting program is no longer in a congruent Modeling Relation
with the object system and is no longer a model, but is now just a simulation.
I think this last
paragraph shows how insidiously easily simulations can be inadvertently
created instead of models in computer code: anyone who has done any amount of
programming knows that converting something into code usually involves
plenty of creativity and working around the limits or idiosyncrasies of the
programming language or system involved. This makes it easy to inadvertently
work-around such issues by also changing the original entailment structure in
order to make coding easier, faster, etc. On a pragmatic level this
may appear to be a case of "no harm, no foul" as long as the predictions
still work out correctly, but in a very deep sense, one is then no longer doing
science, they are playing at curve-fitting. I suspect it is this kind of
insidious transition from model to simulation that allows "cooked-out models" to
occur, just because they are no longer models but rather simulations which no
longer bear any necessary correspondence of entailment to the object system
and thereby are free to be altered further in a myriad of ways that have no
necessary correlation to the internal workings of the object
system.
Regards,
Tim
|