decidable logics and flexible point code change interactions

[researchnotes]

Two current issues on my plate:

1. I've been looking at restricted logics as possible languages for describing flexible point effects. These logics seem to all be defined over natural numbers, which is a potentially annoying restriction as it rules out any simulation that uses real numbers. That doesn't rule them out by any means, as we can still define plenty of interesting simulations over natural numbers. (Imagine any operations research model where times are constrained to be integers: Queue lengths are always natural numbers, inventory sizes are always natural numbers, and if time starts at t >= 0, then time is always a natural number as well.) Still, I'm not sure that I ever want to go to a simulation user and say, "Go ahead and tell me what you want the simulation to do differently, but don't use multiplication/division/exponentiation/primeness/etc. as an operator." Seems like a fast-track way to invent a technology that is theoretically sound and never used.
   Anyway, I need to look more at Petri graphs, as they're a much more popular model description framework and yet still decidable, which is what Paul wants. By putting Xinyu on the path of model-checking simulation adaptations, he's already committed to doing some work with behavioral adaptations that are formally described in a decidable language, and I know he'd like to include what I'm doing with that. I'm still torn between
   • requiring formal descriptions,
   • allowing formal descriptions, but not depending on them at all, or
   • going with informal descriptions aimed for processing only by the user, never by the automated system.
   I'm going to keep looking around, and I may weigh all three options in my proposal without selecting any of them.
2. When the code change associated with a flexible point is applied, how do I make sure that other flexible points' code changes are still correct? I expect flexible point code changes to overlap (e.g. the coefficient of friction as a flexible point and the movement algorithm as another flexible point, where the movement algorithm may or may not make use of the coefficient of friction), and so I need to
   • automatically detect objects/variables associated with more than one flexible point, to detect times when code changes may overlap, and
   • hopefully detect what the changes need to be, so that they can more than one flexible point can be safely changed at a time.
   I started out by looking at data-flow analysis tools in compilers, but Spiegel pointed me towards refactoring tools today, which strike me as a much better set of tools to make use of. Data-flow techniques usually assume a simplified intermediate code (like you'd find between the front and back ends of a compiler), but refactoring tools are designed to be applied to the high-level language itself. I'd like to avoid parsing/annotating the syntax tree of the code directly, instead invoking language-independent notions like refactoring so that my technique can be more obviously applied to arbitrary simulation programming languages.