The document discusses using Petri nets to model military processes and battles. It provides examples of using Petri nets to represent a chess game, a duel between two sides, and battles with different parameters like units with single or multiple weapons, fire concentration, and groups of units. Petri nets allow modeling the dependencies and parallel processes involved in military simulations and planning. The document concludes with using a simple game model and Petri net to evaluate the expected damage from different forces in an air defense scenario.

1. System Petri Nets – Tool for
modelling Military Processes
David Gulua 11.09.2003

2. Some Publications
• Conner, W.R. Automated Petri Net Modeling of Military Operations. Proceedings of
the IEEE National Aerospace and Electronics Conference: NAECON. 1990, Dayton,
OH, USA; Vol. 2, pages 624-627. New York, NY, USA: IEEE, 1990.
• R. J. Staker Military Information Operations Analysis Using Influence
Diagrams And Coloured Petri Nets Information Technology Division
Electronics and Surveillance Research Laboratory
• Stuart Lumsden, Brice Mitchell, Lin Zhang Modelling Operational Level Planning
Processes with Coloured Petri Nets. Submission to the 7th International Command and
Control Research and Technology Symposium
• Y. Meiller and P. Fabiani Planning with Petri nets RJCIA'2000
• P. Fabiani and Y. Meiller Combining game theory and classical planning In
AIPS'2000 (Artificial Intelligence Planning Systems), Breckenridge, Colorado, USA, 14
- 17 April 2000.
• Ghalwash, A.Z.; Ligomenides, P.A.; Newcomb, R.W. Multilayered Petri-Nets for
Distributed Decision Making. In: AFIPS Conf. Proc. Vol. 56: 1987 National Computer
Conference, pages 257-263. Reston: AFIPS Press, 1987.

3. Example – Chess Game
White’s turn
Black’s turn
White’s move
Black’s move
Check-mate
Stale-mate
No check-mate
No stale-mate
Stale-mate
Check-mate
White’s win
Black’s win
Draw
No check-mate
No stale-mate

4. Duel
•The main difference from Chess Game: Duell is
Real-Time, moves are mostly not sequential, but
parallel
•Sides shoot each other at same time (2 parallel
processes)

5. Duel – Elementary Petri Net
A Ready
to Shoot
B Ready
to Shoot
Unexact Shoot
Exact
Shoot
Exact
Shoot
A Ready for
next Duell
B Ready for
next Duell
Unexact Shoot
End of duel

6. Duel – System Petri Net
(a,b)
b damaged
a damaged
a and b damaged
(a,b)
(a,b)
(a,b)
(a,b)
b
a
(a,b)
No damages
Ready for
next duel
Shooting
round
sorts A-Unit, B-Unit
const a: A-Unit
const b: B-Unit

7. Battle – No fire concentration (Set of duels)
• Every Unit can fight with only one Unit of enemy, before one of them
is damaged
• After damaging enemy‘s unit, survived unit switches to other enemy
• Number of Units plays no role

8. Battle – No Fire Concentration (cont.)
sorts A-Unit, B-Unit
const A: set of A-Unit
const B: set of B-Unit
var x: A-Unit
var y: B-Unit
B-Unit damaged
A-Unit damaged
Both A-Unit and B-
Unit damaged
(x,y)
(x,y)
(x,y)
(x,y)
y
x
A, B
Pairing
x,y (x,y)
(x,y)
Shooting
round
No damages

9. Battle - No Fire Concentration (example)
sorts A-Unit, B-Unit
const A: set of A-Unit
const B: set of B-Unit
var x: A-Unit
var y: B-Unit
(a1, b3)
a2
B-Unit damaged
A-Unit damaged
Both A-Unit and B-
Unit damaged
(x,y)
(x,y)
(x,y)
(x,y)
y
x
A, B
„Pairing“
x,y (x,y)
A-Unit Prapares
for next duel
y
x
y
x
(x,y) No damaged
B-Unit Prapares
for next duel
Start: A = {a1, a2, a3, a4}, B = {b1,b2,b3} 2 active pairs: (x,y) = (a1,b3), (x,z) = (a2,b2)
Current step of Battle – remaining units : A = {a1, a2, a3, a4}, B = {b1,b3}

10. Battle – Fire Concentration
• Every Unit can fight with all Units of enemy
• Number of Units plays decisive role

11. Battle – Fire Concentration (cont.)
B-Unit damaged
A-Unit damaged
No damage
x
x
y
x,y
x
A, B
sorts A-Unit, B-Unit
const A: set of A-Unit
const B: set of B-Unit
var x: A-Unit
var y: B-Unit
No damage
y
y
x y
y,x y
x
A-Unit shoots
to B-Unit
B-Unit shoots
to A-Unit
• Shooting time ignored (result of shooting is known
immediately)
Damaged A-
Units
Damaged B-
Units
y
x

12. Battle – Fire Concentration (cont.)
• Shooting time is taken into account (result of shooting is known after some time)
• It is possible to shoot to same opponnent from several weapons in (almost) same
time
B-Unit damaged
A-Unit damaged
No damage
x
X,y
(Y,x)
A, B
sorts A-Unit, B-Unit
const A: set of A-Unit
const B: set of B-Unit
var x: A-Unit
var X: set of A-Unit
var y: B-Unit
var Y: set of B-Unit
No damage
(X,y)
(X,y)
X (X,y)
Y,x Y
A-Unit shoots
to B-Unit
B-Unit shoots
to A-Unit
Damaged A-
Units
Damaged B-
Units
y
x
y
(Y,x)
(Y,x)

13. Battle – Fire Concentration (example)
A = {a1, a2, a3, a4}, B = {b1,b2,b3}
X = {a1,a2}, (X,y) = (a1,a2,b1); Y = {b2}, (Y,x) = (b2,a1)
B-Unit damaged
A-Unit damaged
No damage
x
X,y
(Y,x)
A, B
sorts A-Unit, B-Unit
const A: set of A-Unit
const B: set of B-Unit
var x: A-Unit
var X: set of A-Unit
var y: B-Unit
var Y: set of B-Unit
No damage
(a1,a2,
b1)
(X,y)
(X,y)
X (X,y)
(b2,a1)
Y,x Y
A-Unit shoots
to B-Unit
B-Unit shoots
to A-Unit
Damaged A-
Units
Damaged B-
Units
y
x
y
(Y,x)
(Y,x)

14. Battle: One Unit with Several Weapons
• Single weapon can damage single weapon at Unit
or whole unit. The last case means end of battle

15. Battle: One Unit with Several Weapons (cont.)
B damaged
A damaged
No damage
x
X,y
(Y,x)
A, B
sorts A-Weapon,
B-Weapon
const A: set of A-Weapon
const B: set of B-Weapon
var x: A-Weapon
var X: set of A-Weapon
var y: B-Weapon
var Y: set of B-Weapon
No damage
(X,y)
(X,y)
X (X,y)
Y,x Y
A-Weapon shoots
to B-weapon
B-Weapon shoots
to A-Weapon
Damaged A-
Weapons
Damaged B-
Weapons
y
x
y
(Y,x)
B-weapon damaged
A-weapon damaged
(Y,x)
X,B End of
Battle
Y,A
End of
Battle

16. Real Battle: Units with Several Weapons and
Units with Single Weapons
•Every unit has a predefined goals (dependencies between units must be defined)

17. Battle: Units with Several Weapons and units with Single Weapons (cont.)
No damage
X
X,Y
(Y,X)
A, B
sorts A-Weapon,
B-Weapon
const A: set of A-Weapon
const B: set of B-Weapon
var X: set of A-Weapon
var Y: set of B-Weapon
No damage
(X,Y)
(X,Y)
X (X,Y)
Y,X Y
Fire A-B
Fire B-A
Damaged A-
Weapons
Damaged B-
Weapons
Y
X
Y
(Y,X)
B-weapon damaged
A-weapon damaged
(Y,X)

18. Models of Battle with Additional Parameters
Unit Parameters
•Number of shoots per time unit (or time of 1 shoot)
•Number of bombs
•Probability of Damage of opponnent’s unit
Battle Parameters
•Number and composition of units
•Conditions to finish the battle
Nessesary Extension: Timed Petri Nets

19. Duel
• Sides shoot each other at different times
• m,n - Number of Bombs
• t_a, t_b – delay time before shooting
sorts A-Unit, B-Unit
const a: A-Unit
const b: B-Unit
var m : N
var n : N
a,m
a,m
Unexact
Exact
Unexact
Exact
a,m-1
a,m
b,n-1
b,n
b,n
Shoot b,n
b,n b,n
a,m Shoot
a,m a,m
a ready for
next duel
b ready for
next duel
a,m
b,n
a damaged
b damaged
<t_a>
<t_b>

20. Groups
• Every early model („duell“, „battle“) describes one Process,
but real combat is a set of Processes and they have various
dependencies
• Examples of additional Processes:
– Complementation of Units
– Change of weather conditions, which can change such parameters, as
probability of damage of enemy
– And much more…
• More comfortable for modelling is to define „Group of
Units“

21. Simple Group
Consists of the following parameters:
• Number of Units
• Efficiency of fire (number of damaged enemys per time
unit or one shooting session). Depends on probability of
damage and in some cases, on speed of shooting

22. Planning, Decision Making
Example: Anti Air defence
350 Fighters
530 Bombers
360 rockets
Damage
probability – 0,6
Damage
probability – 0,2

23. Game Model (example)
B1 B2
A 270 296
Mathematical expectation of damaged Bombers in conflict:
Fighters vs Bombers
243
)
)
6
,
0
1
(
1
(
*
530 53
530
360


 
Mathematical expectation of damaged Bombers in conflict:
Rockets vs Bomber
Mathematical expectation of damaged Bombers in conflict:
Fighter and rockets vs Bomber
53
)
)
2
,
0
1
(
1
(
*
530 530
350



270
)
)
2
,
0
1
(
)
6
,
0
1
(
1
(
*
530 530
350
530
360




According to this results, simple game 1x2:

24. System Petri net for Game 1x2
B,1
A
B,2
B,1
A
C1
C2
C1=>C2
Sorts: A-Group, B-Group
const A : A-Group
const B : B-Group
const C1 : N
const C2 : N
C1>C2
C1
C2
C1
C2
A
B,1,C1
B,2,C2
B,2