Self-Organizing Modeling and Simulation Structures

brewerobstructionIA et Robotique

7 nov. 2013 (il y a 7 années et 11 mois)

285 vue(s)

Copyright 2008 Society of Photo
Optical Instrumentation Engineers.

This paper was published in Proceedings of Defense + Security Conference and is made available as an

electronic reprint with permission of SPIE. One print or electronic copy may be made for

personal use only.

Systematic or multiple reproduction, distribution to multiple locations via electronic or other means, duplication
of any material in this paper for a fee or for commercial purposes, or modification of the content of the paper
are prohi

Organizing Modeling and Simulation Structures

Jim Brander

Interactive Engineering, Sydney, Australia


The modeling of adversarial intent is compared with another area requiring the modeling of human intent

representation of kn
owledge in a contract. The symmetry of the parties to a contract is used as an analog of the
symmetry required to model hostile parties, where each attempts to predict the actions of the other. The dynamic
construction of undirected, self
extensible struc
tures using associative patterns is described. New methods of constraint
reasoning are introduced to allow it to direct the construction of new structure and to allow free structures to crawl over
other structures to modify them or to link structures toget
her. The close integration of existence and time with logic and
the use of relations on relations in a multi
layered active structure allow the system to be very much closer both to the
reality and the intent about which it must infer.



structure, active structure, human intent, dynamic construction, active map, diffuse operator,



Prediction of adversarial intent under Effects Based Outcomes (EBO) is a difficult problem. We will initially try to show
that it is even
more difficult than the methods currently used to address it can manage, then show that it is a symmetrical

each adversary is attempting to predict what the other will do, while neither adversary can be certain of what
they see, because of confus
ion, camouflage or deception. Current methods of intent inferencing

assume that the problem
can be decomposed into modular components, that directed structures can be used, and that distancing the inferencing
from the problem is acceptable. We will attemp
t to show that each of these techniques greatly reduces what can be
achieved in modeling adversarial intent.


Modular Construction

The advantages put forward for modularization of a framework for handling adversarial intent is that the problem
becomes more
manageable and that complexity is avoided or reduced. We would argue the opposite

modularization destroys any complex cognitive problem, or transforms it into a different problem that is easier to solve,
but irrelevant to the original problem. With
adversarial intent, the goals dictate the actions, and the outcome of the
actions reshape the goals

the problem is all of a piece and needs to be handled as such. What is disturbing is that people
will modularize a cognitive problem to suit a simple form
alism, then regress to the modularization, so that they no longer
think about the problem in a general way (or in the way that a general must).The problem is undoubtedly complex, but
its very complexity is why it is worth solving synergistically and holist
ically. We can use structures that compute their
own phasing, that have minimum opacity, that are undirected, that have the activity internalized


Directed Structures

Methods that use direction, such as algorithms or rules or artificial neural networks (ANN
s) or Bayesian networks,
assume that using a knowledge structure in a particular direction is appropriate for a cognitive problem at this level. We

*; phone +612 9371 0187;

will argue that a system should be allowed to phase itself, and should also be allowed to choose the directi
on in which it
uses its knowledge structure. That is, the knowledge structure is initially undirected as to purpose, and can be used for
any purpose merely by redirecting the flow of information in it, the redirection occurring at any operator in the same
structure. A directed structure needed a conscious choice before the specific problem was seen. It eliminates the
possibility of the system being opportunistic and reasoning about its own reasoning. An undirected structure that can
direct itself depending
on what it finds is exponentially more adaptable than a directed structure.



Distanced Inferencing

Both reality and human intent are a tangle of relations on relations, of existential and propositional and temporal logic. If

we choose to transform this co
mplexity into a narrow formalism that allows a system to make simple calculations free of
any context, we should expect that the system will have little insight into the meaning of the calculation it has performed

we have distanced the system and program
med its inferencing. If, instead, we try to model the situation closely and
with fidelity, we should expect a much denser and more complex model, but also a model which is capable of layering
its analysis to higher levels that are more useful to its users.

We will describe a system which attempts to model what it
finds accurately and precisely, without transformation into any simpler formalism.



We wish to predict the intent of an adversary based on their actions or lack of action

we will call the

two sides Red and
Blue. Some of the Red actions will be based on their perceptions of Blue actions and intent. If we are to model the Red
side, we also need to model the Blue side

not just what Blue tells us about their actions and intent, but also the
confusion down the Blue chain of command, and how the resulting actions are perceived by the Red side. We end up
with several systems

we have the battlefield itself, providing the fog, and two adversarial systems, each of which has a
memory, goals and be
liefs, observes its environment, formulates plans and takes actions. Goals, in particular, are likely
to change as the engagement proceeds. We will assume there is sophistication on both sides, so either side may use
deception or delay, or assume the other

side is doing so. We will also assume that either side may develop plans that start
“in the air” and develop into well
based plans, rather than being plans that are logical extensions of an existing situation.
We cannot assume an event
based system, with
an action on one side leading to a response on the other. We will require
processing to proceed in parallel, with interaction only through degradation of assets, the response to actions, or the lack
of response.

Symmetry requires us to model two autonomous

systems, constrained by a third, the battlefield. Within that constraint,
either of the systems can take any action within their capability, a capability that can be varying drastically with time.



We will begin a simulation with belief stru
ctures for both adversaries. We should expect that each adversary will learn
something from the tactics employed by the other. This may include needing to revise their belief structure. It would be
of advantage if the initial belief structure could be mod
ified during the simulation

that the initial belief structure appear
to be made out of the same stuff as anything learnt during the simulation. If all of the knowledge structures are made of
the same stuff, and go down to an atomic level of operation, ea
ch adversary will possess the property of self

We will use an analog, of a system automatically reading contracts. Initially, this may sound a very long way away from
the battlefield. We will draw out the similarities, and show the methods requ
ired in what seems a much simpler domain.
We will attempt to show that the problem is everywhere the same

anywhere that the human cognitive apparatus is
involved and operating near its capacity requires certain properties for its modeling and simulation.

If those properties
are lacking, the modeling will be crude and failure can be shown to be certain in domains requiring accuracy and
precision. In domains requiring only a predictive outcome, we may not be able to quantify the error, but should expect
formance to be poor.



There are other areas where human intent is involved, but few where it is formalized to the point where assessment can
be made of the accuracy of modeling. One of those areas is contracts between parties, where the con
tract formalizes the
intent of the parties, often over a long period of time. A contract is written between two cooperating parties and is

intended to be unambiguous. The parties trade constraints

“If you do this, I will do this”. Terms are defined in th

the equivalent of shared beliefs. It may sound easy in comparison with predicting the intent of a hostile
adversary, but the writer of the contract assumes the document is to be read by another human and structures it

In our work
ing with contracts, it has become obvious how dense the logical and relational structures are if they are
modeled with fidelity, with hundreds of thousands of structural elements needed to represent the many layers of
interaction. While contracts need to b
e clear and unambiguous, we do not presume that making decisions on the
battlefield is a thousand times simpler than contracting for the supply of goods, so either we are putting too much into
representing the relational structures in a contract, or too mu
ch is being left out in representing the decision structures in
a typical military DSS. We will consider the reasons why it may be the latter

either the sheer tedium of building the
necessary structures by hand, or the inability to construct decision str
uctures dynamically. We will show how we can
paint new logical structure as need be as we move into new areas, in the manner of a flight simulator scene.



Sentences in a contract can run to hundreds of words, providing enormous diversity in what c
an be expressed, a diversity
far greater than one might encounter on a battlefield. Countering that, the contract containing the sentences is nominally
unambiguous, whereas the limited diversity on the battlefield is cloaked in camouflage and deception. Th
e contract may
be unambiguous when read in its entirety, but much of it cannot be resolved immediately as it is read. The writer is using
a single thread to weave a tapestry

here a broad sweep, there a pointillist detail, until finally the tapestry is fi
nished and
one can stand back and see the coherent whole. During the process, many things are left hanging and need to be resolved
at some later time, so ambiguity needs to be accommodated and carried forward.

The diversity of a sentence is handled by set
ting up an initial base structure that contains every possible meaning, and
then pruning the alternatives at every level as new structure is erected on the base, using adjacency, grammar, relations,
collocations, values, constraint reasoning

anything tha
t can be used to convert overwhelming diversity into one or a
few meanings, and doing it altogether in any order, opportunistically and synergistically. This is the principal argument
against modularization

that it destroys the synergism of knowledge, wh
ere any piece may contribute at any time.


Dynamic Construction

: Synergistic structure building

pattern matching builds structure and builds relational structure at the same time,
the relational structure potentially pr
oviding properties for pattern matching

We can have a pre
existing structure that represents all possibilities, we can assemble a structure to represent what
occurs, or we can allow the structure to assemble itself. The first is clearly impossible for sent
ences, and is only suitable
for simple problems within the reach of an algorithm or rules. The second requires that we know how to assemble the
pieces to match any situation, now and in the future

we have an omniscient constructor. The third approach has

implemented. Pattern structures

thousands of them

are associatively linked. A node in the base structure representing
the current situation becomes active, the system searches for a pattern that can link to that node, finding one, it searches

other nodes that would complete the pattern match. If it finds them, it clones the pattern structure to link the nodes.
The head node of that new piece of structure becomes active and the process continues. As the recognition structure is
built, the syste
m also builds a relational and logical structure as concomitants of the recognition structure. The relational
structure being built may supply properties to the head node, altering the course of pattern matching. Much more
happens during the building proce

we may use a pattern structure to recognize a pattern and change it to something
else, or add a new property to a head node, or cut out some irrelevant pattern. We can use dynamic construction to break
the bounds of incremental extension from a base b
y building relational structure in the air and only linking it to other
structure when we can see it clearly

we can recognize something which can act as the seed of a plan. Unconstrained

growth in all directions would rapidly lead to exhaustion of resour

we can use constraint reasoning to control the
dynamic construction.


Constraint Reasoning

We are interested in probabilistic outcomes, while constraint reasoning deals in absolutes. Still, we should be able to
eliminate many impossible plans using i
t. We need to be careful here

an adversary may very well be following a plan
that is impossible, and we should recognize the plan and exploit it, rather than dismissing it. On the other hand, some of
the most brilliant battle plans are those that seemed
impossible to everyone else at the time (and still seem impossible
today). Constraint reasoning can seem very fussy, with its requirement that the solution lie wholly within the well
problem space. The fog of war is inimical to well
posed problems. W
e extend constraint reasoning so it can be used to
guide dynamic construction to find solutions well outside the initial problem space. We will need the ability for a free
structure to crawl over another, when we are building structures “in the air”. Cons
traint reasoning can be used to provide
guidance for such a free structure.


Analogy Breakdown

Analysing a sentence within a discourse should result in one meaning emerging, or several meanings that need to be
carried forward and disambiguated later. The on
e meaning paradigm is driven by the requirement that only one grammar
pattern should match

if more than one pattern matches, none is built and other means, such as outlining, are called on
to proceed further (outlining attempts to see “above the fray”, t
o take a long range view of the parsing structure). The
rule that only one pattern should match is not useful for prediction in a battle

several plans may be being executed in
parallel, with some plans inconsistent with others, or the plan is evolving.

: Comparison between reading contracts and adversarial intent


Reading Contract

Adversarial Intent








Unambiguous document

Camouflage and Deception




Things traded



Level of detail





We will introduce the basic elements of active structure

and point out some of its characteristics. Then we will introduce
the extensions

necessary to fully repres
ent relations, and use examples to show their relevance to human intent.

Active structure is made up of nodes, operators, links within computer memory, all using a common structural element.
All dynamic information exists in the links, or in complex messa
ge structures accessible from the links. Nodes can be
variables or operators. Variables maintain conformity of state in all their links, operators use changing information in one
of their links to change information in any or all of their links, and links
maintain information and propagate it
throughout the structure. Information flow in the links is notionally undirected, with information flowing in whichever
direction is appropriate for the semantics of the operator. Change of state in a link connected to

an operator indicates that
the operator should be given control to respond to the change, and in this way change of state within the structure
controls phasing of further activity within the structure. This relatively simple formalism holds for simple rel
ations like

A + B = C

where the operators are the plus and the equals, and the nodes are the numeric variables, A, B, C and the head of the
spine (not explicit in equation). The spine is used to link statements in a model into a discourse (all the stateme
nts at this

level are ANDed together), and provide them with a logical state (or the spine receive one, as all of the structure is

shows a diagrammatic representation of the structure (the diagram is a direct
representation of the
machinery, not just a conceptual map for us to understand the operation of an algorithm). In this case the operators
maintain consistency on their links according to their simple semantics (a PLUS operator is not necessarily limited t
three links, nor is the EQUALS), and the variables maintain consistency among all their links. The structure shows the
link between logic and numbers at the EQUALS operator, and the structure is propagating ranges of numbers ( ranges do
not rely on pre
xisting sets at nodes, à la constraint solving
, but are dynamically created message structures) in a
direction determined by the logical state of the information (the directions shown by the arrows in the diagram are
dynamically determined, the structure
itself represents knowledge about a relation among objects and is undirected).

There are several aspects that should be noted, if we are to use this structure as a component of a larger model. The
structure needs to be complete in itself, because there i
s nothing else outside it to give it meaning. People would
normally rearrange an equation or inequation to make a different variable an output. There is no rearrangement required
here, the directions of information flow change in accordance with the semant
ics of the operators in responding to input.
If we took away the value of C and gave a value to B, it should be clear what would happen. Similarly, if we took away
the true state from the spine, and gave a value to B that was not A

C, a false state would

propagate out of the EQUALS.
Or if we put a false state down into the EQUALS, the equation becomes an inequation. While it has every possible use,
the structure itself is invariant. This property makes modeling very simple

a structure can be built witho
ut thought as to
how it is to be used, then used as a component in a larger structure

a structure which can be decided on later, or even
built automatically, and about which the modeler need not know or care how it is to be used. Undirectedness also mak
constraint reasoning within the model much more powerful

it is performed at the level of an operator, not a statement,
so many more inferences are available

inferences that would be submerged in an assemblage of different operators.
Undirectedness a
llows a set of objects to flow into an operator, the operator change it, and the new set flow out on the
same link. There is often communication between centres of activity at some distance from each other in a constraint
reasoning model, with information
flowing back and forth. It is usually not desirous for tentative information to escape
the cognitive core (a single numerical relation does not look much like a cognitive core, but thousands of them, mixed
and linked with logic, can perform more impressive
ly), so there are simple means for fencing the area until resolution is

: Structure representing A + B = C

The structure is based on connections, with nothing occurring outside of the structure. Connection imp
oses an iron
discipline, but it needs to be weakened under some circumstances, as we will show.

A small static model is all very well, but how to make it suitable for dynamic problems? Some operators are capable of
adding or changing connections, so the st
ructure can be self
modifiable. The simple A = SUM(List) statement
demonstrates a seemingly trivial dynamism. When the list (another variable) becomes known, an operator, implicit in the
statement but explicit in the structure, takes the members of the lis
t and connects them to the PLUS. As soon as a
connection occurs, states flow across the connection in whichever direction is relevant. The PLUS operator then operates
in the same undirected way as it would in a static structure, either adding the members o
f the list to give A, or finding the
value of a member of the list if A is already known, or pruning ranges, or producing an inconsistency if the numbers do
not agree or a range becomes null. A change in the value of the list undoes the construction and ki
lls any values found

from the list members. Locating structural dynamism in operators dedicated to the purpose simplifies the operation of the
structure. Special purpose operators can represent the behavior of an activity in a project model, or book resour
ces, or
store distributions for stochastic information.

Changes in structure elements can be stored, so the structure can hypothesize

it can change values and revert to them,
or it can build castles in the air

new variables, operators, links, complex
messages, whatever is necessary

and destroy
them again (the structure metaphor makes it somewhat like undoing scaffolding). Understanding why an inconsistency
has occurred in a constraint reasoning problem, forcing a backtrack, can be difficult. Here, th
e inconsistency will occur at
the level of an operator, with the states viewable around the operator. This small example should make it clear how
numeric values and ranges can slosh about in a structure, but it may not be obvious what logical states do, s
o the next
example is of a simple logical structure, as shown in
: The structure representing IF A + B = C THEN D + E = F

It may appear that a rather ordinary IF...THEN... has been introduced, but it has slightly more sub
tlety (and far more
detail). Firstly, the antecedent and consequent are of exactly the same form as shown in the previous figure, with just the
direction of flow of logical states changed. Secondly, it uses an implication operator, which behaves exactly as

implication should. That is, modus tollens works. Why bother making it precisely how propositional logic works? This
form of logic is an attempt to describe how we reason (it is not complete, but we will come to that), so representing it
exactly m
ay have some benefit, in the same way as the system does not need to rearrange equations. The obvious benefit
is it is possible to validate, at the strategic level, decision structures that operate at the tactical level. The consequent

be made false, t
he antecedent will go false, or the true state from the spine can be removed, the consequent made false,
the antecedent made true, and the implication will now produce a false on its control pin (there is an obvious analogy
with microcircuits, but these op
erators would make very strange microcircuits, with their undirectedness and their ability
to add connections

the latch between a processor and its memory can be conceptualized as undirected, and it certainly
changes connections, but in a fixed manner, w
ith no resources to build new connections). In other words, the logical
structure models exactly how you might think about the system, even if you don’t bother with the arcane terms of logical
reasoning (it is trying to model your cognitive behavior, you s
hould not need to model its cognitive behavior). We have
described logic and numbers, and mentioned lists. The structure is self
modifiable, so objects can be created and
destroyed (all the referencing structure, such as variable indexing, is made out of t
he same structure, so the reference is
destroyed when the variable is destroyed, or the system backtracks from its construction). What may not be obvious so
far is that the basic tools of programming

the fetch and store cycle, or the For or the While loo
p, or that bane of
structural formalisms

a = a + 1, can also be created from operators embedded in the structure

operators which are
setting and propagating states, rather than a pointer jumping to instructions in code. We make no apologies for them
ing less efficient in a structural formalism

an empty For loop is about a thousand times slower

as the ease of
modeling with undirected structure and the combinatorial power of constraint reasoning overwhelms the initial speed
advantage of programmed c

: The structure representing IF A + B = C THEN D + E = F

We would say the initially undirected structure represents knowledge, which can be used any way around it is needed,
when it is needed. Rules and other direct
ed structures such as ANNs may be useful for getting the message into and out
of the cognitive core, but inside that core they are too limited in what they can do

they are a directed traverse of a
knowledge structure, which means one had to already know
the purpose to choose the direction. Why is that important?

if each connection in the structure only carries half the information of which it should be capable (implication and
EQUALS can be used at least three ways around), not many connections are need
ed before the system is severely
impoverished in what it can do. As logical models grow in size, it can become a daunting task to maintain coherence, so
having the model contribute to maintaining its own coherence either allows faster construction or more
complete models.

The structure we have described so far is suitable for largely static models which can be built by hand, by entering
statements which are converted into structure, or by direct editing of the structure. Extensibility and undirectedness
ns that very large models can be assembled, using contributions of structure, and the contributions can, to a large
degree, be self
assembling. If they do not self assemble, they can be stitched together with undirected logical thread,
implanting any trans
formations necessary. However, a largely static model demands a largely static problem, or one
changing quite slowly. A defense project may fit that bill, but the battlefield does not. Let’s jump to something a little
more dynamic. But first we have to mak
e some changes to the components. Here is a statement:

He thought he needed to exercise the option to extend the term of the loan.

We have gone from a simple statement like A + B = C, comprised of logical and numeric variables and clearly defined,
l operators, to something very different. Now we have relations on relations (“needed to exercise”), we have
relations that actually do things rather than just provide logical control or calculate numbers (“exercise the option”), ther
is existential contr

the option may only exist in a time window, or not at all if the loan is in breach, the person doing
the thinking may not have the authority to exercise the option. The example is outside of military space, but does show
how quickly things can get com
plicated. We could try to write rules for every which way around this thing could be
used, but we would grow tired or bored, and we would still have to tolerate a considerable loss of meaning, because we
need to be at the particular relation with all its s
tates to make the right inference, not be pushed away by many little
statements attempting to turn simultaneous existential, logical and temporal control on layered relations into a simpler
formalism. It is easier to represent all the pieces accurately, th
en put them together and have the more complex behavior
emerge from the assembly. For that, we need to extend the structure we have described so far.




We will show that the techniques developed for modeling of the structure of

dense technical text are relevant for the area
of modeling and simulation of human intent. In modeling of the knowledge structure of dense text, one is interested in
accuracy and precision, rather than speed. The massive detail the techniques require may
seem prohibitive for an agile
system. The detail provides a context, but most of it remains quiescent during dynamic activation of the model, so the
model can react swiftly to local changes in state

it can provide a fast reflex arc

and yet is still cap
able of changing
itself as the context changes.

Modeling outside of a person’s head can take two paths

we can use a clever person to crush a complex problem into a
simple formalism with as little damage to the knowledge structure as possible (and hope t
hey have predicted any future
use, and taken it into account in the crushing), or use a sufficiently complex formalism that the cleverness required is
within the capacity of a computer, the modeling process can be done automatically and the knowledge struc
ture is fully
preserved, thus allowing for adaptation to ny future use. When confronted with large slabs of text to be handled
repeatedly, only the second path seems feasible. We will assume in the descriptions of the techniques that they are
intended for
largely dynamic models. The changes to the simple form include:


Logical and Existential Control

In the simple form, logical operators, like AND, can manipulate Bayesian logical states, but do not have a separate
logical control. An operator like EQUALS, w
hich spans the logical and numerical networks, could be described as
having a logical control, but exercising it changes the inferences that can be made in the numerical network, and values
in the numerical network can be used to compute the state of the l
ogical connection. The logical connection to EQUALS
also carries an existential state

if the state is false, the operator is inactive. The spectrum of “He didn’t run” through
“He probably ran” to “He did run” has a different meaning to the logical connec
tion of an EQUALS

it is the
probability of occurrence of a relation event (propositional logic takes the true of when an event is occurring, and turns it

into a context
free logical state

we need to change it back to a contextful state by linking it to

its source relation). We
provide all relations with a logical control to describe this probability, and a time attribute to indicate when the logical
state is true. We need more. There is a spectrum of possibility too

“He can’t run” through “He possibly

can run” to “He
can run”. We provide all relations with an existential control to describe this possibility, and they inherit a time attribut
to allow the possibility to be under temporal control. The relation operator maintains a logical relation betwee
n the
logical and the existential state

the logical state cannot be more true than the existential state (the probability of an
event cannot exceed its possibility). For many relations, the existential connection can be stubbed true, the logical control

going true being adequate to represent reality. In planning models, it is usually necessary to compute existence, and have
that affect the probability of occurrence

“it is possible over this range, it is probable over this smaller range”. If the
need for

existential computation occurs only once in a model, it can be brought into propositional logic and rather
clumsily linked to the rest of the model while maintaining undirectedness, but calculate it in a hundred places and it is
easier to do so in its own

logical world. It would be tedious to require two different types of logical connective to handle
the two types of logic

natural language sees no need to handle them differently. The logical connectives in the structure
allow the two kinds of logical st
ate to be freely mixed.


Relations as Objects

The simple form active structure had a firm distinction between variables and operators, although there were occasional
situations where an operators seemed to need to be a variable too. Mostly, the operators co
uld be simple and universal,
like PLUS. For relations, we need to abandon that dichotomy. We have an inheritance structure for objects. It is easy to
conceptualize relations as objects, so they can inherit properties too.

: Relation with head node, parameters and existential and logical connections

Many of the things we see as objects are closer to relations than objects. If you think about your car, it seems real
enough, but if you took away the assembly relation that ho
lds it together, you would have a pile of spare parts. A
contract may look like a piece of paper, but it is also a relation among people with legal force

the piece of paper on
which it is written is a physical attribute of the contract, no more. We give
the relation a head object, the logical and
existential connections mentioned above, we provide orientation of the parameters, and end up with the relation shown in

To make use of this new object, we create relation prot
otypes, with parameters which also inherit properties. The extra
complexity in the object should allow us to model complex situations, but it comes at a cost

we will no longer be able
to build large models by hand using simple analytic statements, as we
have considerably increased the density of
interconnection. Many relations are more complex than this ditransitive one

we have causative (causation relations
need careful fitting together, to discriminate among contributory, sufficient, catalytic, and in
dependent causes), clausal
(to think opens a parallel universe, and the relation must provide both existential and logical control over that universe),
but their complexity is what allows us to model intention. The greater sophistication of the base model
elements means
the modeler has to think more, sometimes quite hard, to get the meaning right, but the model will do very much more as
a result.


Computable Inheritance

There is an inheritance structure, but it is woven into the total structure and is made o
f the same stuff as all the rest. As
new objects are created, they are instantiated off the existing structure, so the structure is continuously extensible from
the root. Relations such as To Be, To Mean and To Contain introduced into the structure must be

respected in
determining inheritance, along with their temporal controls. For efficiency, most of the inheritance structure is built from
simple form operators, such as INVOCATIONS and MEMBERS and MEANING (the initial parts of the model may not
need multi
ple meanings, but dynamically created objects probably will). All the simple form operators are under logical
control, and can be switched according to context. Special purpose operators such as NOCHILD allow assertion of no
inheritance from an object high
er in the hierarchy to one lower. In sweeping through the structure, a parent may be found
before the connection forbidding inheritance from that parent, so finding parents can be a multi
pass process. Other
operators control which properties are inherited

for apportionment

cases such as “Part of the ship is on fire”. The
inheritance structure is heavily used for consistency checking, and the actual point of inheritance connection for an
object may move as more is discovered about an object.


Object Groups

In a model describing the dynamic interaction of objects, groups of objects are forming and splitting all the time. This is
another way in which inheritance becomes dynamic. Objects can inherit properties from the group, or vice versa,
depending on what j
oins the group together. Relations can also form into object groups, and relations can have object
groups as parameters

“Jack and Jill” is one such group, “running and jumping” is another. Object groups allow a more
precise description of the behavior of


if we split up the group and describe the behavior of individual members,
we lose meaning

we assume that “Jack and Jill went up the hill” together.


Relations on Relations

We use relations on relations all the time in speech and writing. If we
build models without this facility, we have to
accept that the meaning of the model will be impoverished, and must be compensated for by interpretation of the model’s
behavior, with the result that the model loses its most useful property, a means of accur
ately exploring the dynamics of a
situation. With relations as objects, and relations having existential and logical control, we can come much closer to an
accurate description of behavior characterized by relations on relations, and we need be much less c
lever in twisting a
simple formalism to capture complex behavior. We all know intuitively how relations fit together in text, so it comes as a
bit of a shock to have to actually connect the parameters of layered relations.

: Relation on relation

Joe thought John had used a satellite phone to call Fred

temporal elements not shown


Active Maps

Most of model building can seem like continuous extension from a core, but not always. When there is a base, it is
relatively eas
y to have pattern structures which can recognise a situation and clone their structure to encompass it.
Sometimes instead, islands of knowledge are created in a dynamic model, islands that need to be integrated into the rest
of the model or linked with oth
er islands, until we can see where the archipelago should fit relevant to the continent of
the base model. Building out from a base is easy compared with building structure while pirouetting in the air. The
modeler brings a skill here that we liken to an o
ctopus, swimming to the site, orienting itself to the local context,
grasping the loose ends and tying them together. If it must be done beyond the reach of the modeler, we need to set up
structures that can do this for us automatically (the paradigm of th
e connected, undirected structure is starting to break
down). We use structures that we call active maps for this purpose. An active map arrives on the scene, orients itself by
crawling over the structure, determines using dynamic constraint reasoning whet
her it is relevant to the things needing to
be connected, then actualizes (actualization is making manifest the structure that is inherited, so it can be given specific
states or values) or builds structure, or merges or changes objects. If an inconsistenc
y occurs at any point, the active map
backtracks, undoing any built structure, and withdraws.


Diffuse Operators

A relation may have the start, finish or duration of its existential or logical connections controlled by inheritance, by
direct assertion, by c
onstraint from other relations, or by current time. The fine level of detail we are using for temporal
control could turn a large model into a hugely intricate clockwork contraption, making it unmanageable. To avoid this,
where time elements are not explic
it we use diffuse operators

operators which are built on demand, find and gather up
their inputs, calculate as necessary, then provide outputs wherever appropriate. Diffuse operators weaken the direct
connection paradigm, but could be described as exploi
ting inherited behavior or implicit connection.


Extensions to Constraint Reasoning

Simple form active structure already used constraint reasoning

at the level of operators, could prune objects, could use
logical combinations of constraints by propagatin
g logical states during the reasoning process (A > 5 OR B < 7), could
switch constraints between consequent and antecedent, and allowed backtrack on structure building. However, there was
an assumption that the constraint structure existed before constrain
t reasoning began, not that it would be erected during
the process, or it would need to run up, down and across inheritance and relational structures while pruning alternatives.
Active maps use a mixture of constraint reasoning, actualization of inherited
structure and building of structure, while

also merging or replacing objects, providing active structural manipulation, which may occur during the constraint
reasoning. Constraints can apply to inheritable properties, so there may no longer be a direct AND
ing, and may apply in
either direction along the attribute chain

find the object of which this is an attribute, then find another attribute of that
object, then match the value of that attribute to this value, handling any necessary change of unit in the

meantime. A
constraint might apply to the attribute of another parameter of a relation operating on the object, so the map is essentially

a free structure and must be capable of crawling across any sort of structure to reach its target. The active map is

objects, not values, so the numeric operators in the map accumulate objects which match the values (for the constraint A
> 5 in a map, the variable A is a free numeric variable holding a set of value objects). Direct calculation, where that is
uired, can be had by pushing the value of each value object into a decision network, checking for inconsistency and
pruning the set of value objects that way).

Conventional constraint reasoning assumes that all the possible alternatives are initially pres
ent (the answer lies within
the well
posed question), and pruning proceeds until an acceptable set of objects is left. This is acceptable in static
structure, but may not be a wise policy in dynamically constructed structure, the alternatives given out too

freely causing
mischief in unexpected places. A detachable pattern recognition structure is used to allow the addition of a property to a
node when a particular local structure is detected, the property then being pruned or appearing in the solution.

: Dynamic construction from Problem Space to Solution

The fussiness of constraint reasoning, the need for the posing of the problem to be so complete that it includes the answer
before reasoning begins, has been removed. Har
d problems need to be worked on before it can be seen what resources
need to be assembled and what compromises need to be made

an adversarial intent model needs equal facility at all
stages of the planning process. The combination of dynamic structure bu
ilding guided by constraint reasoning as shown

allows controlled expansion of the problem space and a much more constructive approach to problem


Structural Tricks

The undirected structural metaphor we are usin
g allows a few tricks. If we run into the situation where the single
processor prevents parallel operation of processes, and one process must wait on the other, we can’t rely on the process
being retriggered by whatever started it. We can throw a connectio
n to a node in the process on which we must wait, and
allow a state to come through that connection to awaken the dormant operator

we can use connections in the structure
to allow close interweaving of structure building.

Sooner or later the adversarial

intent model will have to deal with multiple threats. We suggest that the place to make
decisions about prioritization of threat is not in a stack of procedures, but in grounded structure, where consequences can
be hypothesized about, the structures repre
senting the threats can see each other, and a structure can be built on top of
them that resolves the decision. Dynamic structure building provides a broader focus in comparison to a static algorithm
or rule.


Static versus Dynamic

DSS models using static
decision structures to generate stereotyped decisions can be viewed as reliable, but in a hostile
situation, the enemy being able to predict your next move is not good. A model built to read text is at the other extreme

it must build new structure to rep
resent what it sees for the first time, and it must be reliable. The techniques developed
to handle this situation

pattern structures cloning themselves and expanding from a base towards a goal, the building of
scaffolding to support the new structure as

it forms, active maps building islands in the sky

these techniques are
relevant to models which do not need the extreme capability of reading text, but should still display a dynamic response
to the new situations they encounter.




e Materiel Contract

The adversarial intent model is intended to deduce the adversary’s plan from their actions. A typical plan might have
been conceived months before, be changed to suit emerging circumstances and put into practice over a few days or
. Perhaps we should look more carefully at our own planning processes before embarking on something as difficult
as that. A defense contract represents the creation, development and execution of a plan over a much longer time. It
demonstrates the weaknesse
s of the existing planning process, where the plan is segmented because the technology to
support an holistic plan does not exist.

If we look at the phases, we have

Strategic Planning

Requirements Elicitation

RFP and bid evaluation

Project /Program and Co
ntract Management


: Timeline of complex planning task

The what and the why are laid down in the first two phases, compromise is made on the how and how much in the third
phase, and the when is added in the four
th. If only it were that simple. The phases often interact quite strongly, with it
being discovered that what was thought possible is not, or at least within the budget, which may vitiate the usefulness of
the project product (this sounds very like a battl
e plan). The basis of the plan should project forward, to illuminate what
follows, and reality should project back, to bring reality to wishful thinking. What seems necessary is to develop an
holistic plan that connects everything and stays operational ove
r the life of the task, but the strategist talks about
projection of air superiority (the why), the designer talks about rate of climb (the what), the budgeteer talks about dollars

(how much), the project manager talks about activities and the first batch
in three years time (the when), and the
manufacturer complains about quality problems with the new composite (the how).

A plan is needed that can stitch all these things together, rather than maintain it in a segmented form. Each submodel is
easy enough,
it is the effective stitching together that is difficult, unless they use a common formalism.

The similarities with determining an adversary’s plan is that a common formalism is needed from conception to
execution, together with the ability to link the ex
ecution phase back to the conception phase, so that changes forced on
the execution by exigencies can be seen through the lens of the adversary’s intent.


Keeping the Adversarial Intent Model Up to Date

If we slowly build a large and complex adversarial int
ent model by hand, it is likely to be out of date when it is used, and
it can have little local context. If we fall back on a rapidly built, simple model, we can expect problems in its operation,
or at least a much heavier involvement by its users in overr
iding or augmenting the meager analysis it provides. The
extensions to active structure we have described were intended to handle the reading of technical text and creation of the
knowledge structure described by the text. One option that presents itself i
s that large parts of the knowledge structure
are created directly from strategy documents for both adversaries which are maintained in free text. Maintenance in this

form should ensure timeliness of content, and it allows people at all levels to more easi
ly see and comment on the
strategies. The knowledge structure, derivable from lengthy documents in no more than a few hours, is augmented with
local knowledge and becomes the adversarial intent model. The more transparent form would engender more revisions
but they would be visible textual revisions, transparent to all, rather than the opaque structures or code in use now.

The use of knowledge in such a model sounds like it would be slow to respond in a dynamic battle field situation. If the
problem is tri
vial, then a knowledge structure is either unnecessary or wasteful. As the problem increases in complexity,
there comes a point where an algorithmic or any other directed approach fails for lack of subtle phasing control, or blows
up from combinatorial exp
losion, or is forced to do things so crudely to avoid it that the output is worthless

the point
where a cognitive application using undirected techniques takes over from an application representing a pre
reflex arc from input to output. A know
ledge structure carries a great deal of context with it

most of the context
remains quiescent in a situation requiring rapid response

only the parts that are needed are brought into action. A
person can use the DSS to simulate a situation and see what
it does, but they can also use the context to see why, and
they can think about the strategy being used and play with it. The strategy is not a few context
free rules, but layered
relations involving many influences, and capable of dynamic construction to
handle novel situations

the reason we
have emphasized dynamic construction while describing the extensions to active structure.



We have used an analogous application handling human intention to show the benefits that undirected, self
structure capable of self
extension through dynamic construction could provide to an adversarial intent model. The
structure is intended to represent knowledge, and be activated internally. While in the main talking about an undirected
and connected struct
ure paradigm, we have highlighted where such a paradigm comes under stress, and described
approaches within the spirit of the paradigm that may be taken to handle those cases

structures that crawl over other
structures to alter them. The level of modelin
g detail we are suggesting militates against creation of sufficiently densely
connected models by a single hand. The undirected structure lends itself to stitching together many contributions, or to
automated construction using self



. Santos Jr, A Cognitive Architecture for Adversary Intent Inferencing: Structure of Knowledge and Computation,
Proceedings of the SPIE 17

Annual International Symposium on Aerospace/Defense Sensing and Controls: AeroSense
2003, Orlando, FL, 2003


ction to Active Structure,


Extensions to Active Structure, Operation/extension_to_active_structure.htm


Y. Cras, A Review of Industrial Constraint Solving Tools, AI Intelligence, Oxford, 1993.


J. Brander,
Multi Modal Me
thods of Information Transmission


AAAI Spring Symposium 1998.