Proceedings of the 34th Chinese Control Conference

July 28-30, 2015, Hangzhou, China

C2 Entity Agent Modeling Based on OOFPN Approach

WU Chenghai1,2*, LI Xiong3, PU Wei3
1. School of Aeronautics and Astronautics, University of Electronic Science and Technology of China, Chengdu 611731, China
2. Beijing Institute of Special Vehicle, Beijing 100072, China
E-mail: zjsbswch@126.com
3. Department of Command and Administration, Academy of Armored Force Engineering, Beijing 100072, China
E-mail: lixiong2609@126.com, zgyzhxpw@126.com

Abstract: Multi-agent-based modeling plays an important role in analyze the behaviors of warfare platform entities. In order to
assist designers in the early stages of multi-agent-based simulation model development, Object Oriented Fuzzy Petri Net
(OOFPN) technique is used in this paper to bridge the gap between the formal modeling and the system refinement in command
& control (C2) entity agent modeling. Firstly, tactical battlefield simulation structure is proposed and C2 entity agent model is
designed. During the distributed design processes, OOFPN modeling theory and approach is presented. Lastly, the OOFPN
model of C2 entity agent is validated in the implemented simulation demonstration system.
Key Words: Command & Control, Modeling, Agent, Object Oriented Fuzzy Petri Net

issues underlying knowledge representation and reasoning

1 Introduction
The concept of agent [1], [2] is being now broadly used
not only as a model for computer programming units
displaying a certain kind of characteristics but also in a more
abstract and general way, as a new metaphor for the analysis,
specification and implementation of complex software
systems. The multi-agent approach is an important field of
the distributed artificial intelligence. The multi-agent
systems, set of agents interacting in a common environment
to achieve their own goals, are particularly adapted to
provide responsive and robust solutions to complex
problems. This concept helps modeling system constituted
by autonomous agents to act rationally. Multi-agent systems
architecture is more suitable to simulate and solve problems
for which centralized control is difficult or impossible [3].
In modern wars, commanders should see at first glance
the whole situations through various kinds of devices as the
fight progresses, and command promptly as soon as some
situations occur according to collected, processed and
mixed information. Therefore, the need of building the fast
and exact command & control (C2) model and simulation
system has come to the fore. In the military model and
simulation system, a C2 platform (e.g., a C2 vehicle) can
perform various actions including collecting and analyzing
battlefield situations information. Thus, we can view a C2
platform as a C2 entity and set up a mapping from it to a C2
entity agent. In fact, each C2 entity agent can communicate
with other agents and this creates a bond among them. This
results in the modification of the organizational knowledge,
which forms a C2 loop on battlefield.
The key to C2 entity agent modeling is the design of its
knowledge reasoning system, which is the basic and actively
researched area of agent technology. There are important
*
This work is supported by the Doctoral Program Foundation of State
Education Ministry of China under Grant 20130185110023, Beijing
Natural Science Foundation under Grant 9142017 and Equipment Projects
of PLA.
*Corresponding author.
that have not yet been adequately addressed. As any other
conventional modeling techniques, Petri nets can present
some features that can be appealing in many contexts within
the model development process. The ability of easily
modeling concurrency and synchronization aspects, the
intuitive graphic notation, the formal semantics that
supports powerful analysis capabilities and the availability
of several supporting tools make Petri nets an appealing tool
in many situations [4]-[5]. In a complicated expert reasoning
system, it is inefficient for commonly fuzzy production rules
to depict the vague and modified knowledge. Fuzzy Petri
nets are more accurate for dynamic knowledge proposition
in describing expert knowledge [6]. In the study of
intelligent systems, the field of fuzzy Petri nets emerged as a
way of providing an interesting way of knowledge
representation and rule-based decision-making [6]-[11].
However, despite these advantages in modeling domains,
ordinary Petri nets including fuzzy Petri nets can not
represent the dynamic structure, subsystem and how they
communicate each other for a C2 agent. Knowledge
classification and process of knowledge updating frequently
in a C2 entity agent give a challenge in C2 entity agent
modeling based on ordinary Petri nets including fuzzy Petri
nets.
Object-oriented systems analysis meets the needs of both
theoreticians and practitioners by providing tunable
formalism. An object-orient software model is sufficiently
expressive if it provides modeling components for
describing objects, classes of objects, generalization and
aggregation hierarchies, relationships among objects, object
behavior, object interactions, and constraints.
Object-oriented methodology provides a complete set of
modeling components for describing these fundamental
object-oriented concepts [12]. Therefore, we can choose
object-oriented methodology as a tool for modeling and
analysis C2 entity agent when using fuzzy Petri nets. In this
paper, the formal bottom-up modeling method called Object

1935
Oriented Fuzzy Petri Net (OOFPN) modeling method is
used to analyze a C2 entity agent model.
2 Problem Statement
2.1 C2 and C2 Entity
C2 entity is a concept that incorporates explicit modeling
of tactical battlefield C2 in virtual simulation (see Fig. 1). It
is based on three fundamental ideas.
(1) C2 can be represented in terms of the interactions and
behaviors of C2 entities. There is a close match between the
real-world C2 process and the entity paradigm. The physical
instantiation of C2 on the battlespace can be viewed more
directly as interactions among autonomous decision-making
entities. The effects of a C2 entity decision process are
communicated to other C2 entities in the chain of command
through message exchanges across the battlespace, and
eventually result in action by platform-level battlefield
entities.
(2) The C2 process is an information flow process among
C entities. Individual C2 entities (e.g., company team
2 factors such as unit cohesion and external factors such as
command vehicles and battalion command station) work
together through the exchange of information. This includes
standard interactions such as operations orders, time-driven
information such as status reports and situationally triggered
exchanges such as spot reports and fragmentary orders.
(3) The C2 entity approach to information flow supports a
faithful representation of real world communications.
Virtual command decision makers will have access to
information about the world through several channels: their
own direct sensations of the world through their own virtual
view port (or system sensors) as well as information
reported to them other entities. This access to information is
intended to mirror the information available to an actual
battlefield command platform.
Battalion Red and
Company
C2 Entity Small Unit Blue Forces
C2 Entity 2
C Entity Entities
Simulation Infrastructure
Fig. 1. Tactical battlefield simulation structure
2.2 C2 Entity Agent
A key characteristic of complex military simulation
system is a large number of non-homogeneous agents. In
our platform-level tactical battlefield simulation model,
there are five classes of agents that make up each opponent’s
chain-of-command to include battalion, company, small unit
C2 entity agents, and Red and Blue Forces entity agents, as
shown in Fig. 1. Agents within the same class have unique
characteristics such as experience and unit cohesion, so no
two agents are exactly alike. In addition, agents following
the same decision path, may take different amounts of time
to complete the same tasks. This is accomplished by running
each agent as a separate thread of execution or
mini-program.
All C2 entity agents follow the same generic decision
cycle, however, various agents take different amounts of
1936
time to complete their process. For example, the battalion C2
entity agent’s decision process is approximately 10 times
that of the small ground units at the start of the simulation.
The decision process response time changes as the
simulation progresses. The C2 entity agents begin each
decision cycle by observing. In the observe phase, the C2
entity agents take in raw data, as well as direction/messages
from other agents. In the next phase, orient, the C2 entity
agents synthesize the raw data from the observe phase into
information. Also during the orient phase, the C2 entity
agents determine their available resources. Knowing the
situation and the resources available, the C2 entity agents
move into the decide phase. In this phase, the agents select
from a number of alternatives based on the results of the
orient phase. The final phase is act. In this phase, the C2
entity agents execute their chosen alternative.
All C2 entity agents continue to repeat their decision cycle
until one opponent achieves its objective of demolishing the
other opponent’s command center. The speed at which an
agent moves through its decision cycle is driven by internal
resources available. As resources are destroyed by the
adversary and become more scarce, decision cycle time
degradation accelerates. Our model also incorporates
battlespace uncertainty. The uncertainty is added by
returning intelligence data to the C2 entity agents that may
be different from the actual values. In addition, the decision
cycle delay incorporates the impact of acting on old
information. These general details apply to all entity agents,
however, each entity agent class has a unique C2 loop.
A C2 agent is a computerized autonomous entity that is
able to act locally in response to stimuli from the
environment or to communication with other agents. During
the simulation, a C2 agent and other entity agent can
exchange messages with each other. This allows the
developer to experiment various interconnection topologies.
Knowledge reasoning system is the key to realize its
functions, as shown in Fig. 2.
Environment
Commu- Other
Percepti- Entity
nication Agents
on
Internal State
Base
Reasoning Knowledge
Base
Action
Fig. 2. A C2 entity agent model
We can give a formal description for its working process
as following:
Step 1: Produce belief. We assume that a certain C2 entity
agent’s belief base is *. *t means its belief set in the time t
and Bt(x) means that this agent believes x. The belief can be
made up of this agent’s understanding to its tasks structure
which includes diverse coordination relationships such as
the boss-secretary relationship when a battalion C2 entity
agent commands the company C2 entity agents.
Step 2: Schedule for agent action. The C2 entity agent
chooses rules according to a certain probability, carries out
task choice and order sorting, and produces an intention
structure based on its belief, goal, capability and knowledge.
The schedule produced includes a series of methods and
their inchoative times, which can be defined as S ˙
{<M1,t1>ˈ<M2,t2>ˈ…ˈ<Mn,tn>}.
Step 3: Take action. After producing its intention
structure, by a broadcast mode the C2 entity agent declares
task T (such as scouting No.1 target, detecting the enemy
force situation) or gives commitment to the relative other
agents. The methods used usually are: C[Do(T,q)]——the
C2 entity agent would carry out task T and when Q(T,t)>q it
would finish the task; C[DL(T,q,tdl)]——this agent would
carry out task T and when [Q(T,t)>q]š[tdtdl] it would finish
the task.
Step 4: Update belief. The C2 entity agent is intelligent, so
it can update its belief base and schedule for its action again
according to the changed situations after it has carried out
relevant action. When the agent obtains new information
about itself or the battlefield environment, it begins to
update its belief. For example, agent A’s renewing belief
process can be expressed as: *Am:*A‰\(x,A,t) _ (xE)
š(\(x,A,t) *A).
Step 5: Update rules. The C2 entity agent modifies its
rules’ intensity or adaptability according to the result from
Step 4, and if it is necessary, it can create the new rules
through the exchange mechanism Oc:IuIo IuI or the
mutation mechanism OM:IuI in Genetic Algorithm.
Step 6: Return to Step 1.
OOFPN presents an adaptive and flexible framework
based on the integration between object-oriented systems
analysis technique as a graph based modeling language and
Petri nets as a rule based modeling language. Petri nets
technique is a powerful instrument for modeling, analyzing,
and simulating dynamic systems with concurrent and
non-deterministic behavior. Object-oriented methodology
supports the representation and integration of static system
properties from a function and data perspective [13]. The
framework is useful for flexible and dynamic C2 entity agent
modeling, which has the following correspondence with real
world:
·Objects and relations: An OOFPN is defined on a
collection of elements comprising constants, variables, net
elements (places and transitions), class elements (object nets,
method nets, synchronous ports, and message selectors),
classes, object identifiers, and method net instance
identifiers.
·Fuzzy production rules: An OOFPN has its initial class
and initial object identifier, as well. The so-called universe
of an OOFPN contains tuples of constants, classes, and
object identifiers. Based on this formalism, knowledge in a
C2 entity agent can be described by weighted fuzzy
production rules.
·Concurrency and conflict: An OOFPN supports gradual
progress on C2 entity agent modeling software requirement
with formal representation from actor, data views, control
flow and data flow. The incomplete specifications are
encapsulated in nodes with hierarchical presentation to
1937
support forward and backward traces [13]. Concurrency and
conflict occurred in an OOFPN can be represented by the
above formalism.
·Logic causality: The structures of ordinary Petri nets
including fuzzy Petri nets preserve causality, thereby an
OOFPN model of C2 entity agent preserves the correct logic
relations.
·Knowledge learning: Based on the encapsulation concept
of object-oriented methodology, the learning unit scope is
defined to enhance the reusability under the global scope, in
which the design of presentation, learning items, and the
weight of corresponding concepts are encapsulated in the
learning unit object, and the sequencing controls of a
learning activity are explicitly represented as a directed
graph to enhance the understandability, where the vertices
are these learning unit objects and the edges are associated
with the sequencing control rules [14]. Thereby, An OOFPN
model of C2 entity agent does not affect the learning
capability of ordinary Petri nets including fuzzy Petri nets.
3 Theory of OOFPN
A C2 entity agent uses fuzzy concepts for making decision
to take action of C2 on battlefield. Actually, a C2 agent
executes a decision-making behavior and a sequence of data
sensed. Local structures are extracted by principal
component analysis, and a global map is build by integrating
them using their knowledge system. By the above analysis
we can set up a control and reasoning mechanism based on
the knowledge system (see Fig. 3). Here a behavior can be
described by a reactive rule: IF sensing condition THEN
action, where a sensing condition can be directly checked on
sensed values and an action can be executed by command
signals. Thus, in order to represent the various fuzzy
processes of a C2 agent, we can use formulation of fuzzy
production rules for OOFPN modeling, as in the above
form.
C2 Entity Agent
Data Knowledge System
Sensed IF sensing condition 1 THEN action 1
Execution
IF sensing condition 2 THEN action 2
IF sensing condition 3 THEN action 3
…
Fig. 3. Control and reasoning mechanism of a C2 agent
In order to study the weighted fuzzy production rules
reasoning, we often need to consider those rules whose
consequences are represented by two or more propositions
connected by “AND” or “OR”. To enhance the
representation capability of those fuzzy inference rules, the
relative degree of importance of each proposition in the
antecedent contributing to the consequent needs to be
considered. Here we use weighted fuzzy production rule. Its
general forms can be defined as following:
A conjunctive rule:
IF a1 AND a 2 AND ... AND a n THEN c ,
Th (t ) O , W O (t , p ) P , W I ( p i , t ) wi , i 1, 2,..., n
A disjunctive rule:
IF a1 OR a 2 OR ... OR a n THEN c,
Th (t i ) Oi , WO (t i , p ) P i , WI ( p i , t i ) wi , i 1,2,..., n
In these rules, wi (i=1,2…,n) represents respectively the
weight of weighted fuzzy production rule.
When the conjunctive rule and disjunctive rule are
transformed to fuzzy Petri nets, they can be shown as Fig. 4.
Ȝ1 Ȝ1
w1
a1 w1 a2 ȝ1
Ȝ2 Ȝ2
w2 ȝ w2 ȝ2
a2 c a2
… … ȝn
wn
Ȝn
Ȝn wn
an
an
Fig. 4. Fuzzy Petri net of the conjunctive rule (left) and fuzzy Petri
net of the isjunctive rule (right)
The aims of OOFPN modeling are not only to analyze the
logic structure, i.e., process-oriented, but also to find the
objects in the knowledge system regardless of the system
running rules. From the view of object-oriented aspect, a
system is composed of objects and their interconnected
relations. According to this view, we can define an OOFPN
as a 2-tuple:
OOFPN (O, R)
where:
O {O1 , O2 ,..., OK } is the set of finite objects, and Oi
(i=1,2…,k) is an object is described by a colored Petri net;
R is the set of communicating relations between objects that
are described by common message places between object
subnets.
An object subnet can be defined as a 9-tuple with the
structure
Oi (Pi , Ti , Di , I i , Oi ,Di , Ei , Thi ,Wi )
where:
Pi {pi1 , pi 2 ,..., pin } represents the set of places;
Ti {t i1 , t i 2 ,..., t im } represents the set of transitions;
Di {di1 , di2 ,...,din} represents the set of propositions;
I i (Oi ) : Ti o Pi f is the input (output) function which
defines a mapping from transitions to bags of places;
D i : Pi o [0,1] is the association function which assigns
a real value between 0 to 1 to each place;
E i : Pi o Di is the bijective mapping between the
proposition and place label for each node;
TH i : Ti o [0,1] is the function which assigns a
threshold value Ȝik from 0 to 1 to transition tik;
Wi WIi ‰ WOi , where:
WIi I i o [0,1] and WOi : Oi o [0,1] , are sets of input
weights and output weights which assign weights to all the
arcs [15].
Generally, the object-oriented approach mainly extends
the concept of data abstraction through inheritance, that is
higher level abstract data types (objects) transfer some of
their functionality to those at lower levels. An OOFPN, as a
particular fuzzy Petri net, is an integrated formalism that
consists of several sub-structures (object subnets), adopts
features of object-oriented paradigm, and achieves coupling
of the objects by a control and reasoning mechanism. Thus,
an OOFPN model of C2 entity agent represents the
intelligent behaviors of the C2 entity.
OOFPN approach has extended Petri nets supporting
object-oriented modeling and temporal fuzzy learning based
on hierarchical object-oriented nets and fuzzy Petri nets.
The focus is adaptation according to object-oriented nets
concepts of cooperation objects for supporting synchronous
and asynchronous communications and the temporal fuzzy
c learning. These two diagrams have been chosen because
they are the most commonly used in modeling multi-agent
system and describing agent control and reasoning ability.
That is to say, they can be used to model and illustrate both
the structural and dynamic aspects in multi-agent-based
modeling. OOFPN can describe the differences, the
relationships and the transitions between different objects
clearly, and reflect the coupling and the emergence of
systems. It also also can be regarded as a conceptual and
practical artificial intelligence tool for the integration of
multi-agent system into the mainstream practice of software
development [16].
4 Approach and Application
4.1 Modeling Steps
Based on the theory of OOFPN technology, we can
present the modeling steps with OOFPN, by which a
military modeling and simulation technology researcher can
develop an OOFPN model of C2 entity agents. These steps
are an abstract and theoretical summary on OOFPN
modeling approach, which can provide a good direction for
the researchers who designs the multi-agent-based C2
entities simulation system.
Step 1: Describe the real world, i.e., define the scope of
the domain according to the military domain experts, such as
warfare platforms organization, interaction behaviors
including operation on a certain terrain. By this step, the
relevant objects of the discourse world and their mutual
relationships are identified.
Step 2: Define and analyze tactical tasks by
characterization on C2 entities and their tasks. By this step,
knowledge resources of the knowledge reasoning system in
a C2 entity agent can be obtained, and the object classes can
be hierarchically classified.
Step 3: Map out the operational plans and schemes to
shape a common thread tying together instances that are
needed for a C2 event. This common thread is usually
expressed as C2 agents interaction dynamics of each
encapsulated object in these hierarchies.
Step 4: Descript the object behavior and the
communication between objects, develop object subnets,
and set up a mapping from the production rules to the
OOFPN subnets according to the above research on
mapping.
Step 5: Connect all the subnets that have common places
to obtain an OOFPN geometric structure of the OOFPN.
Step 6: According to the current state, set data to Į, ȕ, Th,
W. Then develop the simulation system and perform warfare
simulation based on the OOFPN model.
1938
 Through this process, the domain models, architectures, IF P21 AND C12 OR P22 AND C31 THEN C 21
and system are set up to accomplish the goals: model
IF P23 AND C13 THEN C 22
interoperability, reduced software duplication, system
extensibility, and simulation composition. For control knowledge, the weighted fuzzy production
In a C2 entity agent which is actually a complicated rule ī3 is:
system, to develop several hierarchies is usually necessary IF P31 OR P32 THEN C 31
for the knowledge reasoning system. Between these In these rules, each proposition and each consequence has
hierarchies, a more detailed net is represented by a respective signification. For example, P11 means enhancing
condensed transition of its higher level. For example, when the utility value of reconnaissance resources to 0.8; P12
one entity wants to find out the distribution of the enemy means extending the reconnaissance zone to A1 region, i.e.
artillery in A region, it should extend the reconnaissance extending the scouting front to 120 kilometers; P13 means
zone. Thereby, the reconnaissance zone extending needs the enhancing the velocity of scouting advance to 35 km/h; and
task be allocated renewedly. C11 means fulfilling a certain reconnaissance task
(discovering and tracking No.1 target) ahead of schedule to
4.2 Study Case 40 minutes.
According to the results of military analysis, the C2 Therefore, after setting appropriate data to Į, ȕ, Th, W
system actions include: according to the military experiences, we can set up the
·Collecting information and intelligence (including OOFPN model for the knowledge reasoning system in a C2
intercommunicating, reporting to a superior C2 entity, vehicle agent, which can be shown as Fig. 5.
awaiting superior orders);
Domain Knowledge System
·Carrying out data fusion and synthetically processing
battlefield intelligence (such as sorting intelligence, P12 P13
filtrating intelligence, analyzing situation, making decision, P11 C13
C11 C12
producing schemes, saving and updating information);
·Controlling force (such as notifying reconnaissance
requirements, notifying targets information, allocating P31
P21
C31 C21
combat tasks and adjusting combat tasks). P32
C22
According to the analysis, we can classify the information P22
P23
Control Knowledge
or knowledge in a C2 entity agent’s knowledge reasoning System Reasoning Knowledge System
system into three types: C2 domain knowledge, reasoning
knowledge and control knowledge. Fig. 5. OOFPN model
Domain knowledge is used to describe task framework.
For example, the task of an intelligence reconnaissance Here we take Visual C++ as the programming language
scheme can be described as a aggregation with subtasks for implementing the simulation demonstration system. In
reconnaissance target, reconnaissance zone and this simulation software, we can run the designed C2 entity
reconnaissance occasion [2]: agents in the Red and Blue agents federation. The
task (‘a warfare scheme’, ‘a reconnaissance scheme’) administration agents and service agents can be aggregated
subtask (‘reconnaissance target’, ‘reconnaissance zone’, into the “White” federation. Thus, the intelligent and
‘reconnaissance occasion’) dynamic interaction actions of these entity agents are
Reasoning knowledge consists of a series of reasoning administrated by the “White agents”.
rules, which are used to reason out a C2 entity agent’s The segmental program of the simulation demonstration
communications, collaboration, decision making and task system can be expressed as follows:
class distributed warfare
administration. Its general form can be expressed as: simulation_multiagent
IF subtask (‘task’, ‘subtask’) AND state (‘subtask’, started) {
THEN state (‘task’, started) private:
Control knowledge connects C2 domain knowledge and int iWarfare_Result;/*the results of
reasoning knowledge, by which a C2 entity agent can warfare, which can be obtained from
transform information obtained to domain knowledge after military simulation*/
logistic reasoning. Its general form can be expressed as: Command_and_Control_Agent*Target;/*the
IF scheme (conditions, conclusion) AND all_true enemy entity agent, i.e., the target of
(conditions) this warfare platform*/
THEN add (conclusions) …
int iState;/*the state of this warfare
For domain knowledge, the weighted fuzzy production
platform */
rules ī1 include: public:
IF P11 AND C31 THEN C11 VgObject warfareplatformmodel;/*The
IF P12 AND C11 THEN C12 two-dimension geometrical model of this
warfare platform*/
IF P13 OR C12 THEN C13 VgFx*fx;/*environment vision*/
For reasoning knowledge, the weighted fuzzy production AwSound*soundfx;/*sound made*/
rules ī2 include: Awtactics*tacticsfx;/*tactics
designed*/

1939
 … represent subnets model for each object, because of the
public:
Warfareplatform_Agent();/*the
constructive functions for this warfare
platform entity*/
…
Void Message();/*the functions of
messages bulletin*/
Void Superior();/*the functions of
superior agent*/
Void Action();/*the functions of action
simulation of this warfare agent*/
int State_Transition();/*the functions
of state transition of this warfare agent,
which presents a dynamic model*/
private:
… Vehicle, IJCSNS International Journal of Computer Science
} and Network Security, 2009, 9(11): 322-330.
The simulation demonstration system that we set up can
be illustrated by Fig. 6. Fig. 6 presents the dynamic and
real-time situation information during multi-agent-based
simulation. By this system, one can find out easily a certain
agent’s real-time state information.
Fig. 6. Simulation demonstration system
In the multi-agent-based simulation system of
platform-level battlefield entities on information battlefield,
the result obtained by our OOFPN model is accordant with
the real intelligence reconnaissance situation. Thus the
feasibility and efficiency of our model are proved by the fact.
Of course, when there exists no accordance it needs to be
checked and the emphases should be placed on the concept
model (e.g. communication relations).
5 Conclusion
Distributed, collaborative agents are promising to play an
important role in multi-agent systems applications including
C2 entity modeling. Because Petri nets can model the
communication relations well, they are widely used to
model multi-agent systems for analysis, simulation, and
control. OOFPN technique reflects the dynamic behavior of
the system and the development of the system state through
state transition. We developed a C2 entity agent model based
on OOFPN approach to meet the knowledge classification
and the knowledge updating frequently in a C2 entity agent.
It consists essentially of the networked meta-systems that
1940
advantage of dividing a complex knowledge reasoning
system into several function subsystems. The
multi-agent-based simulation system development shows
that this OOFPN approach can make agent modeling
become easier and more available.
References
[1] Zhongzhi Shi, Intelligent Agents and Their Applications.
Beijing: Science Press (2000).
[2] Xiong Li, Zhiming Dong. Platform-Level Distributed
Warfare Model Based on Multi-Agent System Framework.
Defence Science Journal, 2012, 62(3): 180-186.
[3] Ali Y., Jalal S., Hamid G., Mohamed L.: Intelligent Energy
Management Based on Multi-agent Approach in a Hybrid
[4] Giovanni Denaro, Mauro Pezze. Petri Nets and Software
Engineering, ACPN 2003, LNCS 3098, (2004)439-466.
[5] Tzafestas S. G., Capkovic F.: Petri Net-based Approach to
Synthesis of Intelligent Control Systems for DEDS.
Computer-Assisted Management and Control of
Manufacturing Systems, 3(1997) 523–533.
[6] Zipeng Zhang, Shuqing Wang, Xiaohui Yuan. Advanced
Self-adaptation Learning and Inference Techniques for
Fuzzy Petri Net Expert System Units, LNCS 5855,
(2009)487-496.
[7] Burcin Bostan-Korpeoglu, Adnan Yazici. A fuzzy Petri Net
Model for Intelligent Databases, Data & Knowledge
Engineering, 2007, 62(2): 219–247.
[8] M. Koriem.: A Fuzzy Petri Net Tool for Modeling and
Verification of Knowledge-Based Systems. The Computer
Journal, 3(2000) 206–223.
[9] Lee J., Liu K. F. R., Chiang W. L.: A fuzzy Petri Net-based
Expert System and Its Application to Damage Assessment of
Bridges. IEEE Trans. Syst., Man Cybernetics-Part B:
Cybernetics, 3(1999) 350–370.
[10] Ming-Hu Ha, Yan Li, Xiao-Feng Wang. Fuzzy Knowledge
Representation and Reasoning Using a Generalized Fuzzy
Petri Net and a Similarity Measure, Soft Computing, 2007,
11(4):323-327.
[11] Jia Lixin, Xun Junyi, Ru Feng.: Fuzzy Petri Net Based
Formalized Reasoning Algorithm with Applications. Chinese
Journal of Xi’an Jiaotong University, 12(2003): 1263–1266.
[12] Stephen W. C., David W. E., Scott N. W.: Tunable
Formalism in Object-oriented Systems Analysis: Meeting the
Needs of both Theoreticians and Practitioners. OOPSLA’92
Conference Proceedings, (1992).
[13] Bassam Atieh R., Sai Peck L.: Change Management in
Business Process Modeling Based on Object Oriented Petri
Net, World Academy of Science, Engineering and
Technology, 50(2009)12-17.
[14] Lin, H.-Y., Tseng, S.-S., Weng, J.-F., Su, J.-M.: Design and
Implementation of an Object Oriented Learning Activity
System. Educational Technology & Society, 2009, 12(3):
248-265.
[15] Xiaoou. Li, Wen Yu and F. Lara-Rosano: Dynamic
Knowledge Inference and Learning under Adaptive Fuzzy
Petri Net Framework. IEEE Trans. Syst., Man
Cybernetics-Part C: Applications and Reviews, 4(2000)
442–450.
[16] Hua Xu, Peifa Jia. A Fuzzy Timed Object-Oriented Petri Net
for Multi-Agent Systems, LNCS 5264, (2008)210-219.