Explaining Images of Strategic Behavior for Computational Modeling
I thank those who read and offered comments on my prior post offline. I continue here by talking more narrowly (now that the intellectual background has been surveyed) on specific research issues that I likely will pursue in the near future. Here, I will describe the two “images” of strategic research that are most relevant to what I will be pursuing — the organization of strategic behavior in systems and the organization of strategic behavior in distributed systems.
First, I will describe the concepts of complexity, fiction, and control — strategic behavior is difficult to produce, and the aggregate challenge of strategic behavior stems from elements of conflict that are both complex in the sense of organizing components of a strategic hierarchy as well as dealing with the difficulties inherent in making strategy. I suggest that behavioral organization may be a way to study how this hard task is decomposed and organized in individuals and organizations. Next, I review concepts from computer programming and program design relevant to how complexity and challenge is tackled in the design of programs. Finally, I describe how these notions may translate into “images” of how to study strategy using computational methods.
I: Complexity, Friction, and Control
The philosopher, programmer, and sometime historian Manuel de Landa uses the notions of instability, emergence, and singularities to talk about the evolution of warfare from a computational and complex systems perspective. From this perspective, the craft of warfare lies in the notion of combining materials and elements together to produce higher-level substrates. Notions of hierarchal complexity recur throughout history; combining together different forms of organization and equipment produces tactics and the arrangement of tactical behaviors produces strategy. Clausewitz’s notion of the Trinity also introduces a similar notion through the idea of war’s state at any one period of time as an emergent product of the instabilities caused by the interactions of passion, attempts to impose rational guidance and control, and the play of chance on the battlefield. John Boyd envisioned his famous decision loop as an adaptive system not too dissimilar from John Holland (RIP)’s notion of adaptive behavior and control through population-based evolutionary algorithms, and so on and so forth.
Yet the implication of all of this literature is that organizing and controlling purposeful behavior in a demanding environment is not easy, especially when there is someone else out that will actively counter and thwart that behavior. The notion of “friction” thus pervades all forms of conflict. Clausewitzian friction may be regarded, colloquially, as the embodiment of Ian Malcolm’s “life finds a way” remark in Jurassic Park: essentially, all the things that do not go according to plan. Barry Watts extends and explicates the concept according to five general rules that he correlates to nonlinear dynamics in science:
- Danger’s impact on the ability to think clearly and act effectively in war.
- The effects on thought and action of combat’s demands for exertion.
- Uncertainties and imperfections in the information in which war is obviously based. action in war is unavoidably based.
- Friction in the narrow sense of the internal resistance to effective action stemming from the interactions between the many men and machines making up one’s own forces.
- The play of chance, of good luck and bad, whose consequences combatants can never fully foresee.
Other sources of friction that Watts appends to this basic list include physical and political limits to the usage of force, unpredictability stemming from interaction with enemy forces, and disconnects between ends and means in war. All of them, if added together, add up to an emergent notion of a struggle to exercise control in strategy — the strategic entity must somehow produce meaningful and appropriate actions despite all of the various impediments and problems that stand in the way of doing so. This raises the question: how are we able to act at all?
I argue that two images exist of what is essentially a shared problem: the organzation of strategic behavior. How do individuals and organizations — in their strategic action selection mechanisms — decompose the complexity and difficulty of strategy? First, I will illustrate the problem by surveying how design complexity is handled (in ways relevant to strategists) in computer programming and software design.
II: Computation and Control
Given that all of this theorizing is going towards the purpose of theory-guided simulation, let’s examine this problem rom the perspective of several concepts in computer programming. What are the main tools computer scientists use for decomposing the complexity of engineering software systems? There are many, but those of particular relevance to computational modeling of strategy are hierarchy, modularity, coupling, and non-sequential computation.
Hierarchy defines relations of systems to subsystem, allowing for high-level control over progressively lower levels of abstraction. Modularity allows for different behaviors and concerns to be encapsulated in their own unique closures. As Harold Abelson and Gerald Jay Sussman famously noted in the 1980s, Lisp — a programming language used in much early artificial intelligence and cognitive science research — -is a language built on “stratified design.” To write a Lisp program, the programmer can recursively build levels of a program out of lower-level primitives, with each level of abstraction constituting a low-primitive of a higher level. Additionally, as idiomatic Lisp programs consist of functions with minimal persistent state and interaction with other components, functional modularity can be achieved.
A key linkage between modularity and hierarchy lies in the notion of coupling. To begin what will be an extended explanation leading into another concept, take the notion of a basic controller. A traditional way of viewing systems lies in the notion of a transducer — it takes an input and produces an output. The plant-controller formalism is a useful way of illustrating this:
The goal of this control system is to maintain a reference state value by minimizing the error between the actual state of the system and the desired state. Of course, this is easier said than done. How much are different modules of the system dependent on each other’s inputs and outputs? Imagine we have a series of objects, each of which has state variables that characterize some critical feature of the object at some point in time and behaviors the object can perform.
In object oriented programming, the programmer defines classes as blueprints, with each class template holding standardized behaviors and state variable. Once a particular instance of the class is created, however, the state depends on what happens to the instance object after it is generated. It is possible to create two instances of the exact same class with different states over their lifetimes during the program run. As per the discussion of hierarchy and modularity, this exposes some interesting issues. Assume that we have a top-level controller that issues commands to a set of objects and uses feedback from those objects to make command decisions. Feedback is stored in each object’s state variable. The fact that each module’s state variable, however, may vary in value depending on its own, myopic feedback creates the problem of dealing with the aggregate inputs of each object.
This, however, only models the case in which information flows up from low-level modules to the controller and down from the controller to the modules. What if we assume that the low-level modules can also horizontally change each other’s state variables? It is not hard to see a situation in which this would be the case; assume we code a program where one component requires information processed by the other component to act before receiving a command from the high-level controller?
Loose coupling between components may seem like a solution, but it poses problems of coordination and control. For example, examine what is known as the “Byzantine generals” problem in distributed systems.
Assume a distributed system that must coordinate to do something of value, and secure and reliable communication between components is difficult. The system must find a protocol for negotiating and coming to an agreement as to how to perform the collective action. Another distributed systems problem, the “Dining Philosophers” problem, also revolves around the notion of agreement and coordination between components. If we have a group of philosophers, each of which can only eat when he or she has a left and right fork, and each fork can be held only by one philosopher, how does anyone eat?
A particular aspect of coordination may concern operations on a shared resource. Consider the matter of cache coherence.
In computing, positioning a small amount of high-speed but expensive memory in between the CPU and cheaper but slower main memory can help speed up computations. If you write code in which performance is critical, you will want to exploit the cache any way you can, as the cache works by storing data that the programmer anticipates re-using later. Yet when there are multiple caches operating on a single resource, maintaining coherency between what is stored inside the various caches is critical. Another example can be found in the problem of synchronization:
Assume a shared resource that multiple processes must utilize, but not at the same time. If the programmer does not regulate access to the resource, several things may occur. Each process may “race” to utilize the resource and thus programs that rely on careful scheduling and timing of resource accesses will provide invalid results. Another problem may come when a process hogs the resource, depriving other processes that need of it of the opportunity to execute. If there is a priority attached to when and how processes should acccess the resource, that a high-priority process may be interrupted by a lower-priority process. Still more problems can arise when a process is checking to see if it is ready to execute and in doing so hurting other processes by depriving them of processing time.
You will notice that the prior paragraph revolved around the notion of non-sequential computation. Another expression of modularity lies in splitting tasks among different units of execution that do not execute purely in linear order. However, there is a core distinction — though hazy — between two means of achieving this: concurrency and parallelism:
The term Parallelism refers to techniques to make programs faster by performing several computations in parallel. This requires hardware with multiple processing units. In many cases the sub-computations are of the same structure, but this is not necessary. Graphic computations on a GPU are parallelism. Key problem of parallelism is to reduce data dependencies in order to be able to perform computations on independent computation units with minimal communication between them. To this end it can be even an advantage to do the same computation twice on different units.
The term Concurrency refers to techniques that make program more usable. Concurrency can be implemented and is used a lot on single processing units, nonetheless it may benefit from multiple processing units with respect to speed. If an operating system is called a multi-tasking operating system, this is a synonym for supporting concurrency. If you can load multiple documents simultaneously in the tabs of your browser and you can still open menus and perform more actions, this is concurrency.
Other related notions that differ from classically sequential control flows are event-driven programs in which actions are triggered by external events such as mouse clicks or internal time-ordering within the program or reactive programs that extend the event-driven model. Returning back to our controller at the beginning of this section, whether the controller’s behavior is synchronous or asynchronous matters a great deal:
Event buses or your typical click events are really an asynchronous event stream, on which you can observe and do some side effects. ….. You are able to create data streams of anything, not just from click and hover events. Streams are cheap and ubiquitous, anything can be a stream: variables, user inputs, properties, caches, data structures, etc. For example, imagine your Twitter feed would be a data stream in the same fashion that click events are. You can listen to that stream and react accordingly.
Why does all this matter, though, for strategy you ask? As noted above, the behavioral organization of strategy is a method of reducing complexity and producing actions. It also must be done in real-time, while interacting with a dynamic, partially observable environment and other actors, being both goal-driven in some sense while also reactive to events that occur during the strategic interaction. Finally, it must — as noted earlier, decompose and organize the complexity of strategic functions and behaviors in a way that produces effective actions in the world. Program design issues are one way to look at this, but many of the aformentioned issues reoccur outside of computer engineering.
III: Images of Strategy: Individual and Collective Strategic Computation
In both biological intelligence and a variety of systems, hierarchy and modularity are the key to producing complex behavior. The coupling of system elements is important in everything from neuronal dynamics models in computational neuroscience to theories of complex disasters in sociotechnical systems. Finally, the timing and sequencing of control and action in both individuals and organizations is also critical. Individual and collective strategic computation comprise two distinct “images” that share all of these variables as core elements of their behavioral organization. First, let us return back to the piece “Action Selection for Intelligent Systems” (Brom and Bryson 2006) that I cited in the prior post:
The main problem for action selection is combinatorial complexity. Since all computation takes both time and space (in memory), agents cannot possibly consider every option available to them at every instant in time. Consequently, they must be biased, and constrain their search in some way. For AI, the question of action selection is: what is the best way to constrain this search? For biology and ethology, the question is: how do various types of animals constrain their search? Do all animals use the same approaches? Why do they use the ones they do?
One fundamental question about action selection is whether it is really a problem at all for an agent, or whether it is just a description of an emergent property of an intelligent agent’s behaviour. However, the history of intelligent systems, both artificial (Bryson, 2000) and biological (Prescott, 2007) indicate that building an intelligent system requires some mechanism for action selection. This mechanism may be highly distributed (as in the case of distributed organisms such as social insect colonies or slime moulds) or it may be one or more special-purpose modules [emphasis mine].
To borrow a term of art from Kenneth Waltz, computational research in strategy has two “images” — individual heuristics and perception and distributed computation and control. Due to the nature of what computational modeling can offer as a theory-building device for strategic behavior, its initial focus ought to be formalizing and advancing knowledge about the nature of strategy as control system for adversarial situations. These two distinctive research programs relate to several ideas of how to represent strategy in the previous entry.
As De Landa notes, one response to the generalized problems of friction on the battlefield and the complexity of building, organizing, and controlling combined arms systems over wider and wider distances was to centralize decisionmaking. This allowed for superficially more fine-grained control at the cost of greater difficulty in making effective decisions and hamstringing local initiative. At the other extreme is the notion of a mobile army as a distributed system with very little centralization, which allows for more flexibility at the cost of unpredictability. Of course, as Bryson and Brom observed, no distributed action selection mechanism is fully centralized. Even if all modules run in parallel, resolving conflicts between modules, allocating resources, and sequencing their behavior requires a kind of hierarchy.
However, centralized control merely moved the topic of distribution, modularity, and sequencing inside the mind of the notional represntative agent that stood in for the decisionmaking system in overly centralized systems. The cognitive science theory of “threaded cognition” suggests a similar hierarchal and distributed mechanism to human multi-tasking — certain human tasks may be run in parallel as long as they do not cause a resource conflict. Likewise, the much older theory of plans and the structure of behavior suggested that a pure stimulus-response model of behavior neglected the need for intermediate layer that organized response. Behavior-based robots, for example, have arbitration mechanisms that inhibit behaviors based on priority.
So this presents us with two interesting, if ultimately divergent, ways to look how a entity of interest uses an action selection mechanism to generate and execute strategies.
On one hand, we have a focus — which occupied much of 20th century cognitive science, artificial intelligence, wargaming, and decision-theoretic models — of a focus on (1) the heuristics and perception of a representative agent or abstract central system (2) adaptive feedback and control of a representative agent or abstract central system and (3) simplified mechanisms of either rational behavior or the components that produce rational behavior in a demanding environment relevant to a representative agent or an abstract central system. Often times, as with John Boyd’s OODA Loop, the dividing lines between such levels were blurred.
On the other, we have a notion of action selection for generating strategies as a process computing by a distributed system. This can be viewed as a simple way of realizing Colin Gray’s note that strategy is a process of “dialogue and negotiation.” This kind of work has been seen in work on multi-agent systems, collective cognition, insect biology and animal behavior, organizational theory, and other related fields of inquiry. While it may be tempting to argue that one merely reduces to the other, this is only true in a superficial sense. The way that behavior is structured in a complex agent vs. a complex system differs due to the way in which modularity and hierarchy is represented.
Some may favor one system or the other, personally I believe that both “images” are necessary. By working on adversarial games with complex agents and adversarial games with complex distributed systems, we can gain insights on respective pieces of the puzzle.
Action selection and complex behaviors and heuristics in adversarial games with complex agents can shed light on the cognitive and social elements of strategy relevant simply to how behavior and psychology interfaces with the atomic elements of strategy; after all, procedural reasoning mechanisms in organizations and individuals do have some important similarities. These similarities have never been systematically explored in the context of strategic theory, and assuming a simplified zero-sum representation can draw them out. Furthermore, if we create a population of such agents, each of which engaging in discrete strategic games with each other, we can see what kind of collective strategies arise out of evolutionary pressure from the collective interaction of complex agents with differing strategic behaviors while removing the environmental determinism often baked into the design of such population models.
Additionally, by assuming each strategic context is a discrete interaction between two complex agents, we can shed light on the more realistic (but difficult) case of how strategy is computed by a complex organization engaged in a adversarial game with another complex organization. If the organization has all of the resources and available command and control behaviors of the complex agents in the first scenario, strategy is a method of allocating access to resources and behavioral roles and synchronizing them in time. As with the simpler case, we may simulate how these organizations converge to behavioral organization and configurations over time and within a population of other organizations with their own configurations.
This would combine a standard research strategy in the computational social sciences — — simulating the bottom-up emergence of population trends in a decentralized network of agents — with simplified strategic formalisms (the complexities of which would be parsed out to behavioral modules in a single agent or a collection of agents collaborating together in an organization) and both complex agents or complex systems of agents as the micro units that produce macroscopic results.
Beyond all of the influences and issues I mention in this post, three prominent practical influences on my own work are simple techniques utilized in game AI programming, affordance-based modeling and individual-based agent modeling.
The most basic way to represent behavior computationally in a game is through a way of layering hand-crafted behaviors. One way of doing this is through if-then rules or asynchronous triggers. Another way of doing so lies in finite-state machines or behavior trees, which sequence the organization of behaviors and state-changes in an agent over time. Lastly, another notion that has been directly applied fruitfully for complex agents lies in basic reactive plans, which allow for a limited and biologically realistic form of planning. The reason why such mechanisms are appealing for organizing agent behavior is that they are lightweight and also allow for simple mechanisms of adaptation and learning.
Following the example of my colleague Russell Thomas, I’d like each agent or agent system to be situated in a wargame environment that boasts defined affordances around what kind of actions are possible. Thomas’s own theory and method revolves around the notion of agents as a collection of capabilities that change over time and affordances that link the agent to the environment and define available actions and behaviors. While I am not sure of how much of Thomas’ specific work I will use, his notion of affordances and schemas tracks with prominent work in behavior-based robotics and cognitive science relevant to my research interest.
Lastly, the work of Joanna Bryson and her students in agent-based modeling with complex agents is one of the driving motivations for the computational elements of my work. Most agent-based models have simple agents situated in environments characterized by environmental determinism. Strategy explicitly operates on multiple levels of abstraction — either in the case of a single agent that handles them all or multiple agents that must perform actions while coordinating with other elements of the system. Additionally, the complexities of strategy also mitigate the assumption of environmental determinism’s simple mapping of situations to state changes. Bryson’s theories and architecture defines a fascinating idea of behavior arbitration and control that has wide applicability to social modeling.
Conclusion
As may be seen, the process of modeling, generating, and understanding strategic behavior is complex. This complexity has been tackled through two distinct “images” of strategy — a centralized system or representative agent vs. a distributed system. Both feature issues of behavioral organization, however, as characterized by hierarchy, modularity, coupling, and the timing and order of computations. Currently, I think that the influences (simple programming techniques for game and simulation agents, affordance-based architectures, and individuated agent-based models) I’ve listed are a good starting point methodologically for organizing my simulations, but I will have to see.
