Государственное общеобразовательное учреждение Высшего профессионального

образования

«Санкт-Петербургский государственный политехнический университет».

—

Институт информационных технологий и управления

Кафедра измерительных информационных технологий

Работа допущена к защите

Заведующей кафедрой

д.т.н., проф.

_______________Г.Ф. Малыхина

"____"______________ 2014 г.

МАГИСТЕРСКАЯ ДИССЕРТАЦИЯ

Применение элементов теории игр в задаче

обеспечения безопасности в условиях

неопределенности

по программе 230100.68.08 Безопасность и защита информации

Выполнил

студент гр. 60835/11

Научный руководитель

доцент, к. т. н

Королёв М.М.

Семенов К.К.

Санкт-Петербург

2014 г

РЕФЕРАТ

Магистерская диссертация состоит из: 94 с., 22 рис., 1 табл., 22 источ-

ников и 2 приложений.

ТЕОРИЯ ИГР, МОДЕЛЬ ШТАКЕЛЬБЕРГА, БАЙЕСОВСКИЕ ИГРЫ,

ИНТЕРВАЛЬНАЯ АРИФМЕТИКА, АФФИННАЯ АРИФМЕТИКА

Магистерская диссертация посвящена исследованию возможностей ком-

бинирования интервальной и аффинной арифметик с методами теории

игр для решения проблемы обеспечения безопасности объекта в условиях

неопределённости относительно мотивов и действий злоумышленника. Рас-

сматриваются различные подходы к построению теоретико-игровой модели

действий злоумышленника с использованием интервальной арифметики для

оценки количества ресурсов, необходимых для обеспечения безопасности

объекта.

2

ABSTRACT

Master dissertation consists of: 94 pages, 22 figures, 1 tables, 22 biblio items

and 2 appendixes.

GAME THEORY, STACKELBERG MODELS, BAYESIAN GAMES,

INTERVAL ARITHMETIC, AFFINE ARITHMETIC

Master’s thesis is devoted to studying the possibilities and advantages of

combining interval and affine arithmetic methods with game theory for solving

the problem of ensuring the safety in the face of uncertainty about the motives

and actions of the attacker. Different approaches are considered to construct

game-theoretic model of the attacker using interval arithmetics to estimate the

amount of resources needed to ensure the safety of the object.

3

СОДЕРЖАНИЕ

Стр.

Введение . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

ГЛАВА 1 Теоретико-игровой подход к решению задачи обеспече-

ния безопасности. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.1 Модель Штакельберга . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91.2 Нормальная и компактная форма игры. . . . . . . . . . . . . . . . . . . . . . . 111.3 Алгоритм ERASER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121.4 Интервальный подход . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131.5 Вероятностная модель неопределённости выигрыша ата-

кующего . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151.6 Выводы . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

ГЛАВА 2 МОДЕЛЬ БЕЗОПАСНОСТИ .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182.1 Точечный алгоритм . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 182.2 Программная модель . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232.3 Выводы . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

ГЛАВА 3 БИБЛИОТЕКА ДЛЯ ИНТЕРВАЛЬНЫХ ВЫЧИСЛЕ-

НИЙ .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273.1 Интервальные вычисления. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27

3.1.1 Общий интерфейс объектов . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 273.1.2 Интервальная арифметика. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

3.2 Аффинная арифметика . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303.2.1 Конструктор . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 323.2.2 Внешняя оценка и конвертация в интервал . . . . . . . . . . . . . 333.2.3 Сложение и вычитание . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 343.2.4 Нелинейные операции . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36

3.3 Метод имитационного моделирования (Монте-Карло) . . . . 393.4 Сравнение . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403.5 Выводы . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

ГЛАВА 4 СРАВНЕНИЕ ИНТЕРВАЛЬНЫХ ПОДХОДОВ ДЛЯ

РЕШЕНИЯ ЗАДАЧИ ОБЕСПЕЧЕНИЯ БЕЗОПАСНОСТИ .. . . . . 454.1 Тестирование базового алгоритма . . . . . . . . . . . . . . . . . . . . . . . . . . . . 464.2 Оценка времени выполнения . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494.3 Оценка ресурсов . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52

4

4.4 Оценка ширины интервала неопределённости . . . . . . . . . . . . . . 534.5 Оценка интервального ответа . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 574.6 Выводы . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59

Заключение . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60Список рисунков . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62Список литературы . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 63Приложение А КОД ПРОГРАММНОГО ПРОДУКТА . . . . . . . . . . . . . 66

А.1 Классы для представления теоретико-игровой модели . . . . 66А.2 Классы для работы с интервальными значениями. . . . . . . . . . 71А.3 Алгоритмы для решения теоретико-игровых задач. . . . . . . . . 84А.4 Класс для обработки интервальных значений. . . . . . . . . . . . . . . 88А.5 Дискретная оценка интервальных значений . . . . . . . . . . . . . . . . . 92

Приложение Б Диаграмма классов интервальных вычислений . . . 94

5

ВВЕДЕНИЕ

Современное развитие информационных технологий позволяет осу-

ществлять математическое моделирование задач, связанных с обеспечением

безопасности на технических объектах и объектах стратегического значе-

ния. Расчеты, связанные с противодействием терроризму, требуют разработ-

ки специальных математических моделей, которые могут быть построены

на основе положений теории игр.

Ключевым результатом таких расчетов на практике является ответ на

вопрос, каким образом следует распределить имеющиеся ресурсы для до-

стижения наибольшей степени безопасности при работе объекта и соот-

ветственно минимальных рисков от внешних угроз. Теория игр позволяет

получить такой ответ при соблюдении определенных начальных условий и

предположений.

На сегодняшний день теория игр используется во многих системах

обеспечения безопасности на крупных объектах, например, таких как си-

стема LAX [1], применяемая в международном аэропорту Лос-Анджелеса.

Теоретико-игровые модели, которые используются в этих системах, позво-

ляют сориентировать поведение полиции при возможных действиях зло-

умышленников на основе доступной статистической информации и инфор-

мации другого рода [2].

Обзор существующей литературы позволяет судить о росте публикаций

в последние годы, связанныx с применением теории игр в задачах обеспе-

чения безопасности (как теоретического плана, так и касающихся практи-

ческого применения разработанных математических моделей). Обобщая со-

держание большинства работ, можно сделать вывод, что данная область зна-

ния переживает в данный момент процесс становления и выработки клас-

сической теории. Многие вопросы данной области открыты, их решение

требует выполнения специальных исследований.

Применение теории игр не исчерпывается задачами обеспечения инфор-

мационной безопасности. Существует большое количество самых разных

областей, в которых методы данной теории с успехом применяются. Важ-

6

нейшим вопросом при использовании теории игр является агрегация и фор-

мализация исходных данных при постановке задачи и учет вновь появляю-

щейся информации. С ростом информационной инфраструктуры человече-

ство получает всё больше данных для обработки. Благодаря современным

способам обработки этих данных появляются новые возможности по при-

менению теории игр в тех областях, в которых раньше её применение было

невозможно [4,5] . Очевидно, что для эффективной адаптации методов тео-

рии игр необходимо появление новых моделей, учитывающих специфику

новых данных.

Отдельным вопросом для теоретико-игровых моделей обеспечения без-

опасности является распределение ресурсов. К примеру, полиция может

иметь ограниченное количество персонала для формирования патрулей,

организации контрольно-пропускных пунктов и проведения выборочных

обысков. Также могут существовать другие дефицитные ресурсы, такие как

собаки для осмотра багажа на предмет незаконных предметов и камеры без-

опасности. Одним из основных вопросов, который поднимается в рамках за-

дачи теории игр, является оптимальное распределение подобных ресурсов

для защиты от широкого спектра потенциальных угроз. При этом необхо-

димо учитывать тот факт, что злоумышленник может собрать информацию

о мерах безопасности и планировать более эффективное нападение. Пред-

сказуемость в распределении ресурсов может стать большой проблемой и

значительно снизить эффективность использованных ресурсов.

Часто возникают ситуации, когда необходимо обеспечить защиту целей

от нескольких угроз одновременно [9]. К примеру, в случае обеспечения

безопасности метрополитена разумно рассматривать несколько возможных

угроз: возможность безбилетного проезда, возможность кражи или иници-

ации беспорядка и возможность террористического акта. Учитывая столь

разнообразный набор угроз, выбор стратегии безопасности является серьёз-

ной проблемой, так как ни одна возможная стратегия распределения ресур-

сов не может свести к минимуму угрозу для всех типов злоумышленников.

Уменьшение вероятности угрозы одного вида может привести к увеличе-

нию вероятности угрозы другого вида и наоборот. При этом попытка уста-

новления тех или иных метрик для последующего сравнения потенциаль-

7

ного урона от угроз поднимает сложные этические проблемы: достаточно

сложно сравнить безопасность жизни пассажира с уроном, который понесёт

метрополитен в случае безбилетного проезда.

Важным фактором использования теории игр для моделирования реаль-

ных ситуаций является тот факт, что модели требуют очень точной ин-

формации о возможностях и предпочтениях игроков [6, 7] . На практике

эти модели строятся с использованием информации, которую предостав-

ляют эксперты в предметной области, обладающие знаниями о ресурсах,

доступных для защиты, рисков безопасности, уязвимости возможных целей

и мотивации нападающих [13]. При этом часто существует высокая степень

неопределённости, связанная с неполнотой информации, используемой для

построения модели [14]. К примеру нельзя точно оценить, какой именно вы-

игрыш получит террорист при успешной атаке той или иной цели, но при

этом может быть ясно, какие цели являются более предпочтительными для

злоумышленника. Это означает, что невозможно дать точные значения выиг-

рыша для различных сценариев развития ситуации при моделировании игр

безопасности [15]. В данной работе предлагается рассмотреть интерваль-

ный подход оценки действий злоумышленника и осуществляется попытка

расширить и улучшить его с помощью методов аффинной арифметики.

Все эмпирические данные априори неточны . Эта неточность обязатель-

но должна учитываться при принятии решений, тем более в такой области,

как обеспечение безопасности, поскольку ее неучет приводит к неконтро-

лируемому изменения вероятности совершить ошибку при принятии реше-

ния. На практике, однако, сведения о неточности используемых данных во

внимание принимаются редко. Одной из целей данной работы является рас-

смотрение способов учета такой неточности при принятии решений в тео-

рии игр.

8

ГЛАВА 1

Теоретико-игровой подход к решению задачи обеспечения

безопасности

В данном разделе диссертации рассмотрены вопросы использования

теоретико-игрового подхода в задаче обеспечения безопасности. Разобраны

его основные положения. Приведено традиционное математическое описа-

ние модели теории игр

1.1 Модель Штакельберга

Для моделирования ситуаций, которые возникают в задачах обеспече-

ния безопасности, удобно использовать модель Штакельберга [16, 17]. Как

правило, теоретико-игровые модели рассматривают поведение двух игро-

ков: предполагаемого атакующего, желающего завладеть теми или иными

целями, и защищающегося, стремящегося эти цели обезопасить. Зачастую,

стратегия защищающегося известна атакующему заранее и не является тай-

ной: предполагается, что злоумышленник может предварительно провести

наблюдения поведения защитника [18]. При создании модели необходимо

учитывать это обстоятельство. Модель Штакельберга предлагает следую-

щую иерархию игроков: первым о своей стратегии объявляет игрок 1, по-

сле этого стратегию выбирает игрок 2. Первый игрок называется лидером,

второй - ведомым.

На основе модели Штакельберга строится модель игры для решения

задач безопасности. В рамках данной модели рассматривают двух игроков

[6]:

1. Θ0 - защищающийся, выступает в роли лидера.

2. Ψ0 - атакующий, выступает в роли ведомого.

Защитник занимается охраной набора целей от атак злоумышленника. Обо-

значим набор целей как

𝑇 = 𝑡1, ....𝑡𝑛.

9

Для защиты целей защитник использует ограниченный набор ресурсов. Ко-

личество доступных ресурсов обозначим за 𝑚. Будем считать что все ресур-

сы идентичны и могут быть использованы для защиты любой выбранной

цели. Предполагается, что стратегия атакующего 𝜎𝜓 заключается в выборе

ровно одной цели из 𝑇 . Каждая из стратегий защищающегося 𝜎𝜃 заключа-

ется в выборе подмножества целей 𝑇 , которые защищающийся выбрал для

распределения ресурсов. Для представления возможных стратегии защища-

ющегося введём понятие вектора покрытия целей: набор вероятностей 𝑐𝑖,

что цель 𝑡𝑖 будет защищена по крайней мере с помощью одного ресур-

са. Эти вероятности для каждой цели 𝑡𝑖 ∈ 𝑇 обозначаются как 𝑐𝑖, причём𝑛∑𝑖=1

𝑐𝑖 = 𝑚. Общий вектор вероятности обозначим как 𝐶:

𝐶 = (𝑐1, 𝑐2...𝑐𝑛)|(0 < 𝑐𝑖 ≤ 1,∑𝑡𝑖∈𝑇

𝑐𝑖 ≤ 𝑚)

Рассмотрим взаимодействие атакующего и защищающегося в рамках моде-

ли Штакельберга. Защищающийся выбирает стратегию 𝛿Θ, которая является

совокупностью вероятностей на области стратегий из∑

Θ. Атакующий, оце-

нив стратегию защитника 𝛿Θ, выбирает стратегию из∑

Ψ, дающую ему мак-

симально возможный выигрыш. Каждая стратегия атакующего представля-

ет собой набор значений 𝐴 = 𝑎𝑡𝑖, где 𝑎𝑖 – вероятность выбора i-й цели для

атаки. Как правило, предполагается, что атакующий выбирает ровно одну

цель для атаки и атакует её с вероятностью 1.

Возможный выигрыш для каждой стороны зависит от того, какие из це-

лей атакуются, и какие из них защищены. Например, при атаке на цель 𝑡

защищающийся получит выигрыш 𝑈𝑢Θ(𝑡),если цель не защищена, и 𝑈 𝑐

Θ(𝑡)

в случае, если цель под охраной. Выигрыши для атакующего 𝜔 из мно-

жества моделей злоумышленников Ω можно обозначить как 𝑈𝑢Ψ(𝑡, 𝜔) для

незащищённой цели и 𝑈 𝑐Ψ(𝑡, 𝜔) для защищённой. Будем считать атаку на

незащищённую цель удачной, а атаку на защищённую цель неудачной.

10

Ожидаемый полный выигрыш защитника для заданного вектора покры-

тия 𝐶 и стратегии атакующего A вычисляется как

𝑈𝜔(𝐶,𝐴) =∑𝑡𝑖∈𝑇

𝑎𝑡 · (𝑐𝑖 · 𝑈 𝑐Ω(𝑡𝑖) + (1− 𝑐𝑖)𝑈

𝑢Ω(𝑡𝑖)) (1.1)

Для заданной цели 𝑡 средний выигрыш защитника можно вычислить как

𝑈𝜔(𝐶, 𝑡𝑖) = 𝑐𝑖 · 𝑈 𝑐Ω(𝑡𝑖) + (1− 𝑐𝑖)𝑈

𝑢Ω(𝑡𝑖) (1.2)

Также определим понятие вектора атаки, который содержит все цели,

при атаке на которые выигрыш злоумышленника будет достигать макси-

мального значения при заданном векторе покрытия целей 𝐶:

Γ(𝐶) = 𝑡𝑖 : 𝑈Ψ(𝑡, 𝐶) ≥ 𝑈Ψ(𝑡𝑖, 𝐶)∀𝑡𝑖 ∈ 𝑇 (1.3)

1.2 Нормальная и компактная форма игры

В теории игр, игра в нормальной форме состоит из множества игроков и

множества чистых стратегий каждого игрока [10]. Вышеизложенная модель

может быть также представлена в развёрнутой форме [9]. Вектор атакующе-

го A напрямую приводится к виду чистых стратегий атакующего, с одной

стратегией на цель. Для защитника, каждое возможное распределение ре-

сурсов между целями соотносится с одной чистой стратегией в нормальной

форме. В нормальной форме мы получим(𝑛𝑚

)стратегий распределения ре-

сурсов при 𝑛 целях и 𝑚 ресурсах. Для случая двух ресурсов и четырёх

целей получим:

𝛿1,2Ω + 𝛿1,3

Ω + 𝛿1,4Ω = 𝑐1

𝛿1,2Ω + 𝛿2,3

Ω + 𝛿2,4Ω = 𝑐2

𝛿1,3Ω + 𝛿2,3

Ω + 𝛿3,4Ω = 𝑐3

𝛿1,4Ω + 𝛿2,4

Ω + 𝛿3,4Ω = 𝑐4

11

В этом примере 𝛿𝑖,𝑗Ω определяет вероятность выбора чистой стратегии по-

крытия целей 𝑖 и 𝑗.

Сравнивая количество возможных стратегий, можно прийти к выводу,

что представление модели в компактной форме значительно снижает коли-

чество рассматриваемых стратегий, и, как результат, уменьшает количество

необходимых вычислений. В статье [11] рассматривается построение алго-

ритма DOBBS, который использует в качестве основы нормальную форму

игры. Подход, изложенный в [8], использует компактную форму для реше-

ния тех же задач.

1.3 Алгоритм ERASER

В качестве примера алгоритма для определения вектора покрытия в вы-

шеизложенной модели можно рассмотреть алгоритм ERASER [8]. Алгоритм

использует подход смешанного целочисленного программирования и его

математическая модель представлена ниже:

(ERASER)

max 𝑑

такое, что ∀𝑡 ∈ 𝑇 𝑎𝑡 ∈ 0, 1 (1.4)∑𝑡∈𝑇

𝑎𝑡 = 1 (1.5)

𝑐𝑡 ∈ [0, 1] (1.6)∑𝑡∈𝑇

𝑐𝑡 ≤ 𝑚 (1.7)

𝑑− 𝑈Ω(𝑡, 𝐶) ≤ (1− 𝑎𝑡) * 𝑍(1.8)

0 ≤ 𝑘 − 𝑈Ψ(𝑡, 𝐶) ≤ (1− 𝑎𝑡) * 𝑍(1.9)

Ставится цель максимизации выигрыша защищающегося 𝑑. Ограниче-

ния 1.4 и 1.5 определяют то, что атакующий выбирает ровно одну цель с

12

вероятностью 1. Уравнение 1.6 задаёт условие, определяющее что покры-

тие каждой цели лежит в интервале от 0 до 1. Уравнение 1.7 ограничивает

возможное количество выделяемых ресурсов величиной m. Уравнение 1.8

определяет ожидаемый выигрыш защитника в зависимости от выбранной

в 𝐴 цели. При этом для цели, подвергающейся нападению, накладывается

ограничение сверху от 𝑈(𝑡, 𝐶). Уравнение 1.9 определяет стратегию атакую-

щего. Первая часть условия говорит о том, что 𝑘−𝑈Ψ(𝑡, 𝐶) ≥ 0, в результате

𝑘 должно быть не меньше, чем размер выигрыша при атаке любой цели из

𝑇 . Вторая часть условия определяет 𝑘 − 𝑈Ψ(𝑡, 𝐶) ≤ (1− 𝑎𝑡) * 𝑍 для каждой

атакованной цели в A. Если атакующий вектор содержит не оптимальную

цель для атаки, это условие не будет выполнено. Взятые вместе, 1.8 и 1.9

означают, что 𝐶 и 𝐴 взаимосвязаны при любом оптимальном решении.

1.4 Интервальный подход

Интервальный подход позволяет расширить вышеизложенную модель

[6]. Мы будем предполагать, что значения выигрышей атакующего и за-

щищающегося лежат в некотором интервале и скорректируем модель, учи-

тывая это обстоятельство. При этом мы учитываем, что и атакующий, и

защищающийся знают точные значения своих выигрышей для каждой си-

туации. Необходимость в интервальной оценке выигрышей защищающего-

ся отсутствует, так как его стратегия является известной атакующему. Бу-

дем считать, что значение 𝑈𝑢Ψ(𝑡) лежит в неком интервале между 𝑈𝑢,𝑚𝑖𝑛

Ψ (𝑡)

и 𝑈𝑢,𝑚𝑎𝑥Ψ (𝑡), а значение 𝑈 𝑐

Ψ(𝑡) находится в интервале между 𝑈 𝑐,𝑚𝑖𝑛Ψ (𝑡) и

𝑈 𝑐,𝑚𝑎𝑥Ψ (𝑡). Защищающийся не знает ни точного значения 𝑈Ψ(𝑡), ни его рас-

пределения. Задача сводится к нахождению такого вектора 𝐶, который мак-

симизирует выигрыш защитника в худшем возможном случае. Для каждой

цели 𝑡𝑖 атакующий имеет диапазон возможных выигрышей:

𝜐𝑚𝑎𝑥(𝑡𝑖) = 𝑐𝑖 * 𝑈 𝑐,𝑚𝑎𝑥Ψ (𝑡𝑖) + (1− 𝑐𝑖) * 𝑈𝑢,𝑚𝑎𝑥

Ψ (𝑡𝑖) (1.10)

𝜐𝑚𝑖𝑛(𝑡𝑖) = 𝑐𝑖 * 𝑈 𝑐,𝑚𝑖𝑛Ψ (𝑡𝑖) + (1− 𝑐𝑖) * 𝑈𝑢,𝑚𝑖𝑛

Ψ (𝑡𝑖) (1.11)

13

Минимальный выигрыш, который может себе гарантировать атакую-

щий, можно представить как максимальное значение из минимальных зна-

чений 𝜐. Обозначим это значение как R:

𝑅 = max𝑡𝑖

𝜐𝑚𝑖𝑛(𝑡𝑖).

Любая цель 𝑡𝑖 с максимальным предполагаемым значением 𝜐𝑚𝑎𝑥(𝑡𝑖) ≥ 𝑅

может быть лучшей целью для атаки. Обозначим набор возможных целей

атакующего как Λ(𝐶), определяемый следующим образом:

Λ(𝐶) = 𝑡𝑖 : 𝜐𝑚𝑎𝑥(𝑡𝑖) ≥ 𝑅 (1.12)

Тогда ожидаемый выигрыш защищающегося составит:

𝑑𝑖 = 𝑐𝑖 * 𝑈 𝑐Θ(𝑡𝑖) + (1− 𝑐𝑖) * 𝑈𝑢

Θ(𝑡𝑖) (1.13)

Задача защищающегося - выбор стратегии С, максимизирующей худший

выигрыш для всех целей:

max𝐶

( min𝑡𝑖∈Λ(𝐶)

𝑑𝑖) (1.14)

Стоит отметить, что максимальная возможная выгода защитника моно-

тонно растёт с ростом доступных ресурсов 𝑚. Мы можем рассматривать

задачу поиска оптимальной стратегии защитника как бинарный поиск в

пространстве его ожидаемых выигрышей. На каждой итерации мы будем

оценивать возможность достижения предполагаемого размера выигрыша,

учитывая количество доступных ресурсов. В случае, когда предполагаемое

значение недостижимо, максимальный возможный выигрыш будет меньше

или равен выбранному размеру выигрыша. Если предполагаемый выигрыш

возможно получить, максимальный выигрыш больше или равен выбранно-

му размеру. Используя этот подход, можно оценить максимальный выигрыш

с заданным параметром ошибки. Для реализации этого алгоритма, необхо-

димо оценить возможность получения того или иного выигрыша 𝐷* защит-

ником. Так как мы анализируем худшие ситуации, мы должны гарантиро-

вать что защитник получит как минимум 𝐷* для любых значений выигрыша

14

атакующего на выбранном интервале значений возможного выигрыша. Для

этого должно выполняться одно из двух условий для каждой цели:

1. Цель находится в списке возможных целей Λ(𝐶), однако ожидаемый

выигрыш защитника как минимум 𝐷*.

2. Цель не находится в списке возможных целей Λ(𝐶).

Оценим минимальный уровень покрытия 𝑐𝑖 для каждой цели:

𝑐1𝑖 = max

(0, 1− 𝐷* − 𝑈𝑢

Θ(𝑡)

𝑈 𝑐Θ(𝑡)− 𝑈 𝑐

Θ(𝑡)

)(1.15)

Для каждой цели рассчитываем значение 𝑅 и значение 𝑐1𝑖 . Для каждой

цели мы также можем оценить минимальный уровень покрытия 𝑐2𝑖 , который

необходим, чтобы цель не оказалась в списке возможных целей Λ(𝐶):

𝑐2𝑖 = max

(0, 1− 𝑅− 𝑈𝑢,𝑚𝑎𝑥

Ψ (𝑡)

𝑈 𝑐,𝑚𝑎𝑥Ψ (𝑡)− 𝑈 𝑐,𝑚𝑎𝑥

Ψ (𝑡)

)(1.16)

Суммируя значения 𝑐1𝑖 для целей из Λ и 𝑐2

𝑖 для остальных целей, мы

получим минимальное необходимое покрытие для получения выигрыша 𝐷*.

1.5 Вероятностная модель неопределённости выигрыша атакую-

щего

В случаях, когда существует неопределённость относительно типа ата-

кующего, необходимо внести корректировки в рассматриваемую математи-

ческую модель. Как и раньше, в игре предполагается наличие двух игроков:

защитника Θ и атакующего Ψ. Рассматривается набор целей 𝑇 = 𝑡1, ...𝑡𝑖,которые защищает защитник, и набор ресурсов 𝑅 = 𝑟1, ..., 𝑟𝑚, которые за-

щитник может использовать для защиты целей [7]. Для начала установим

состояние равновесия для атакующего и защищающегося.

𝜎*Ψ(𝐶, 𝜔) = 𝑎𝑟𝑔 max𝑡∈𝑇

(𝑐𝑡 * 𝑈 𝑐Ψ(𝑡, 𝜔) + (1− 𝑐𝑡) * 𝑈𝑢

Ψ(𝑡, 𝜔)) (1.17)

Для определения состояния равновесия защитника мы определим функцию

атаки 𝐴(𝐶) = (𝛼𝑡(𝐶))𝑡∈𝑇 которая возвращает вероятности 𝛼𝑡(𝐶) того, что

15

каждая цель 𝑡 ∈ 𝑇 будет атакована при заданном распределении типа атаку-

ющего и вектора покрытия 𝐶:

𝛼𝑡(𝐶) =

∫𝜔∈Ω

𝑃𝑏(𝜔)1𝑡(𝜎*Ψ(𝐶, 𝜔))𝑑𝜔, (1.18)

где 1𝑡(𝜎*Ψ(𝐶, 𝜔)) - функция-индикатор, которая возвращает 0, если 𝑡 =

𝜎*Ψ(𝐶, 𝜔) и 0 в остальных случаях. Для заданной функции реакции атаку-

ющего 𝐴(·) и набора всех возможных векторов покрытия защитника 𝐶,

равновесное состояние для защитника может быть достигнуто при исполь-

зовании смешанной стратегии 𝛿*Θ = 𝐶*

𝛿*Θ = 𝑎𝑟𝑔 max𝐶

∑𝑡∈𝑇

𝛼𝑡(𝐶)(𝑐𝑡 * 𝑈 𝑐Θ(𝑡) + (1− 𝑐𝑡) * 𝑈𝑢

Θ(𝑡)) (1.19)

Предполагается, что возможно бесконечное число разных типов атаку-

ющего, и вычисление выражения (1.19) невозможно напрямую. Чтобы раз-

решить эту проблему, мы заменим каждый выигрыш в основной модели

вероятностным распределением возможных выигрышей. Для каждой цели

𝑡 ∈ 𝑇 мы заменим значения 𝑈 𝑐Ψ(𝑡, 𝜔), 𝑈𝑢

Ψ(𝑡, 𝜔) для всех 𝜔 ∈ Ω двумя функ-

циями распределения:

𝑓 𝑐Ψ(𝑡, 𝑟) =

∫𝜔∈Ω

𝑃𝑏(𝜔)𝑈 𝑐Ψ(𝑡, 𝜔)𝑑𝜔, (1.20)

𝑓𝑢Ψ(𝑡, 𝑟) =

∫𝜔∈Ω

𝑃𝑏(𝜔)𝑈𝑢Ψ(𝑡, 𝜔)𝑑𝜔, (1.21)

которые отражают ожидания защитника о выигрыше атакующего. К при-

меру, защищающийся предполагает, что с вероятностью 𝑓 𝑐Ψ(𝑡, 𝑟) атакующий

получит выигрыш 𝑟 при атаке цели 𝑡, когда цель защищена. Подобный под-

ход позволяет экспертам выражать неопределённость по поводу выигрышей

в игровой модели, основываясь на их собственной оценке или на основании

полученных данных. Представим альтернативную формулу для выражения

функции реакции атакующего. Для некоторого вектора 𝐶 пусть 𝑋𝑡(𝐶) - слу-

чайное значение, которое отражает ожидаемый выигрыш атакующего при

16

атаке цели 𝑡 при заданном 𝐶. Тогда для каждой цели 𝑡 ∈ 𝑇 верно:

𝑎𝑡(𝐶) = 𝑃𝑏[𝑋𝑡(𝐶)] > 𝑋 ′𝑡 для всех 𝑡′ ∈ 𝑇 ∖ 𝑡, (1.22)

так как атакующий действует рационально. Методы решения построенной

модели приводятся в [7].

1.6 Выводы

В данной главе были рассмотрены существующие подходы к постро-

ению теоретико-игровой модели и алгоритмы, позволяющие находить оп-

тимальные решения в задачах обеспечения безопасности. В целом мож-

но заключить, что рассмотренные подходы сводятся к следующим матема-

тическим задачам: к задаче целочисленного линейного программирования

[9, 11], к задаче динамического программирования, к задачам оптимизации

по сложным множествам [12]. Отдельно стоит вопрос описания типов зло-

умышленников. Чаще всего используют дискретное множество возможных

типов злоумышленников, но существуют попытки в Байесовском подходе

использовать и континуальное множество возможных типов атакующего

[7]. Можно сделать вывод, что чем сложнее используемая модель и чем

сложнее структура используемой эмпирической информации, тем сложнее

те методы оптимизации, которые позволяют получить решение. Как показы-

вают экспериментальные вычисления [6], методы, основанные на нормаль-

ной форме игры значительно уступают в скорости работы и неприменимы

к задачам с большим количеством защищаемых целей и ресурсов.

17

ГЛАВА 2

МОДЕЛЬ БЕЗОПАСНОСТИ

2.1 Точечный алгоритм

В рассматриваемой задаче обеспечения безопасности основным вопро-

сом является вопрос распределения ресурсов между целями и оценка об-

щего числа ресурсов, необходимых для эффективной защиты объектов. Об-

зор литературы свидетельствует о том, что многие исследователи задаются

вопросом неточности исходных данных. При этом стоит отметить, что ис-

следователи по-разному относятся к вопросу, какие именно данные стоит

считать неточными. В данной главе мы рассмотрим возможность модифи-

кации теоретико-игровой модели Штакельберга для работы с интервальной

арифметикой.

Мы рассмотим модификацию подхода, изложенного в главе 1.4. Зна-

чения выигрышей атакующего для незащищённой цели 𝑈𝑢𝜓(𝑡) и для

защищённой цели 𝑈 𝑐𝜓(𝑡) лежат в интервалах [𝑈𝑢,𝑚𝑖𝑛

𝜓 (𝑡);𝑈𝑢,𝑚𝑎𝑥𝜓 (𝑡)] и

[𝑈 𝑐,𝑚𝑖𝑛𝜓 (𝑡);𝑈 𝑐,𝑚𝑎𝑥

𝜓 (𝑡)]. Цель защитника – распределить ресурсы таким обра-

зом, чтобы максимизировать свой выигрыш в худшем возможном случае.

𝜐(𝑡𝑖) = 𝑐𝑖 * 𝑈 𝑐Ψ(𝑡𝑖) + (1− 𝑐𝑖) * 𝑈𝑢

Ψ(𝑡𝑖) (2.1)

Выигрыш, который может себе гарантировать атакующий, лежит в од-

ном из интервалов множества 𝑅, которое определяется следующим образом:

пусть 𝜐(𝑡𝑖) такой интервал [𝑥𝑡,𝑖, 𝑦𝑡,𝑖], что 𝑦𝑡,𝑖 = max(𝑦𝑡,𝑛)∀𝑡 ∈ 𝑇 . Тогда любой

интервал, для которого выполняется 𝑦𝑡 ∈ [𝑥𝑡,𝑖, 𝑦𝑡,𝑖] принадлежит R. Любая

цель 𝑡𝑖 с значением 𝜐𝑚𝑎𝑥(𝑡𝑖) ≥ 𝑅 может быть лучшей целью для атаки.

Обозначим набор возможных целей атакующего как Λ(𝐶), определяемый

следующим образом:

Λ(𝐶) = 𝑡𝑖 : 𝜐(𝑡𝑖) ≥ 𝑅 (2.2)

Тогда ожидаемый выигрыш защищающегося:

𝑑𝑖 = 𝑐𝑖 * 𝑈 𝑐Θ(𝑡𝑖) + (1− 𝑐𝑖) * 𝑈𝑢

Θ(𝑡𝑖) (2.3)

18

Задача защищающегося - выбор стратегии С, максимизирующей худший

выигрыш для всех целей:

max𝐶

( min𝑡𝑖∈Λ(𝐶)

𝑑𝑖) (2.4)

В рамках исследования влияния неопределённости относительно выиг-

рыша атакующего на результаты работы существующих алгоритмов, пред-

ставленных в [6], реализован алгоритм, позволяющий получать значения

вектора покрытия C и выигрыша защищающегося 𝑈Θ(𝐶) для заданных зна-

чений 𝑈Θ и 𝑈Ψ. Основная идея состоит в том, что мы можем реализовать

алгоритм, получающий ответ для исходных данных, представленных веще-

ственными числами. Затем мы переопределили арифметические операции,

используемые в алгоритме, для работы с интервальными данными. В ре-

зультате мы получили программу, успешно решающую представленную за-

дачу в условиях неопределенности исходных данных. Стоит отметить, что

с таким подходом мы можем вносить неопределённость в любые исходные

данные алгоритма.

Как и раньше, исходим из того предположения, что атакующий выби-

рает ровно одну цель для атаки. Так как мы предполагаем, что атакующий

действует разумно, он выбирает цель с максимальным значением 𝑈Ψ(𝐶).

Тогда, если для какой-то цели 𝑡𝑖 значение 𝑈 𝑐Ψ(𝑡𝑖) меньше, чем максималь-

ное значение 𝑈𝑢Ψ(𝑡)∀𝑡 ∈ 𝑇 , в независимости от вектора покрытия 𝐶 можно

сделать вывод, что данная цель не выбрана атакующим:

𝑡𝑖 : 𝑈 𝑐Ψ(𝑡𝑖) < max

∀𝑡∈𝑇(𝑈𝑢

Ψ(𝑡)⇒ 𝑡𝑖 /∈ Λ(𝐶) (2.5)

Основываясь на этом допущении, мы можем сократить список рассматри-

ваемых целей. Логично предположить, что так как атакующий в принципе

не заинтересован в атаке этих целей, выделять под них ресурсы нецелесо-

образно.

В основе предлагаемого алгоритма лежит алгоритм ISG, описанный в

[6]. Для начала мы оцениваем границы интервала возможных выигрышей

защитника. В качестве нижней границы выступает минимальное значение

из возможных значений 𝑈𝑢Θ. Мы рассматриваем задачу поиска оптимальной

стратегии защитника как бинарный поиск в пространстве его ожидаемых

19

выигрышей. Значение 𝑒𝑟𝑟𝑜𝑟 содержит допустимую погрешность при опре-

делении значения итогового выигрыша защитника. На каждой итерации мы

оцениваем возможность достижения предполагаемого размера выигрыша,

учитывая количество доступных ресурсов. В случае достижимости выиг-

рыша, мы сужаем границы поиска до найденного значения и переходим к

следующей итерации. Последовательность операций, приводящая к нахож-

дению наибольшего значения выигрыша защитника приведена в алгоритме

1.

Algorithm 1 SG алгоритм

1: for all 𝑡𝑖 ∈ 𝑇 do2: 𝑐𝑖 ← 03: end for4: 𝑚𝑎𝑥𝑃𝑎𝑦𝑜𝑓𝑓 ← 05: 𝑚𝑖𝑛𝑃𝑎𝑦𝑜𝑓𝑓 ← min𝑡𝑖∈𝑇 (𝑈𝑢

Θ(𝑡𝑖))6: 𝑒𝑟𝑟𝑜𝑟 ← 𝑣𝑎𝑙𝑢𝑒7: while 𝑚𝑎𝑥𝑃𝑎𝑦𝑜𝑓𝑓 −𝑚𝑖𝑛𝑃𝑎𝑦𝑜𝑓𝑓 ≤ 𝑒𝑟𝑟𝑜𝑟 do8: 𝑚𝑖𝑑𝑝𝑜𝑖𝑛𝑡← (𝑚𝑎𝑥𝑃𝑎𝑦𝑜𝑓𝑓 −𝑚𝑖𝑛𝑃𝑎𝑦𝑜𝑓𝑓)/2;9: if FEASIBILITYCHECK(𝑚𝑖𝑑𝑝𝑜𝑖𝑛𝑡,𝑚,𝐶) then

10: 𝑚𝑖𝑛𝑃𝑎𝑦𝑜𝑓𝑓 ← 𝑚𝑖𝑑𝑝𝑜𝑖𝑛𝑡11: else12: 𝑚𝑎𝑥𝑃𝑎𝑦𝑜𝑓𝑓 ← 𝑚𝑖𝑑𝑝𝑜𝑖𝑛𝑡13: end if14: end while

Алгоритм 2 оценивает возможность достижения того или иного выигры-

ша 𝐷 защитником. Для каждой цели мы оцениваем минимальное значение

𝑐𝑖, необходимое для получения выигрыша размером в 𝐷 в случае атаки 𝑖-й

цели. На следующем этапе работы алгоритма мы рассматриваем каждую

цель как предполагаемую цель для злоумышленника. В случае, если 𝑐𝑖 > 1,

при атаке данной цели мы не сможем гарантировать достижение выигрыша

𝐷, так что в качестве предполагаемых целей мы рассматриваем только те

цели, чьи полученные значения 𝑐𝑖 лежат в интервале [0, 1].

Значение 𝑅 равно размеру выигрыша атакующего для остальных целей,

необходимого для того, чтобы злоумышленник предпочёл выбранную цель.

Для вычисления этого значения мы оцениваем выигрыш атакующего в слу-

чае атаки выбранной цели и вычитаем из него значение 𝜉, отображающее

20

Algorithm 2 feasibilityCheck

1: for all 𝑡𝑖 ∈ 𝑇 do2: 𝑐1

𝑖 ← max(

0, 1− 𝐷*−𝑈𝑢Θ(𝑡)

𝑈 𝑐Θ(𝑡)−𝑈 𝑐

Θ(𝑡)

)3: end for4: for all 𝑡𝑖 ∈ 𝑇 do5: 𝑡𝑜𝑡𝑎𝑙𝐶𝑜𝑣 ← 𝑐1

𝑖

6: 𝑐𝑖 ← 𝑐𝑖,17: if 𝑐𝑖 > 1 then8: GOTO next 𝑡𝑖9: end if

10: 𝑅← (𝑐𝑖,1 * 𝑈 𝑐,𝑚𝑖𝑛Ψ (𝑡𝑖)) + (1− 𝑐𝑖,1) * 𝑈𝑢,𝑚𝑖𝑛

Ψ (𝑡𝑖)− 𝜉11: for all 𝑡𝑗 ∈ 𝑇 ∖ 𝑡𝑖 do12: 𝑐𝑗,2 = GETCOVERAGEFORCHANGEPRIORITYTARGET(𝑅, 𝑡𝑗)13: 𝑚𝑖𝑛𝐶𝑜𝑣 ← min(𝑐𝑗,1, 𝑐𝑗,1)14: if 𝑚𝑖𝑛𝐶𝑜𝑣 < 0 ‖ 𝑚𝑖𝑛𝐶𝑜𝑣 > 1 then15: GOTO next 𝑡𝑖16: end if17: 𝑡𝑜𝑡𝑎𝑙𝐶𝑜𝑣 ← 𝑡𝑜𝑡𝑎𝑙𝐶𝑜𝑣 + 𝑚𝑖𝑛𝐶𝑜𝑣18: 𝑐𝑗 ← 𝑚𝑖𝑛𝐶𝑜𝑣19: if 𝑡𝑜𝑡𝑎𝑙𝐶𝑜𝑣 ≥ 𝑚 then20: return TRUE, 𝐶21: end if22: end for23: end for24: return FALSE

21

разницу в выигрышах, необходимую для смены приоритета цели:

𝑅 = (𝑐𝑖,1 * 𝑈 𝑐,𝑚𝑖𝑛Ψ (𝑡𝑖)) + (1− 𝑐𝑖,1) * 𝑈𝑢,𝑚𝑖𝑛

Ψ (𝑡𝑖)− 𝜉. (2.6)

Значение 𝑐2 отражает количество ресурсов, которые необходимо выде-

лить, чтобы злоумышленник сменил приоритет атаки с цели 𝑡𝑗 на цель 𝑡𝑖

и вычисляется с помощью алгоритма 3. Заметим, что в случае, когда 𝑅

принимает значение, меньшее чем 𝑈𝑢Ψ(𝑡), увеличение покрытия для цели

𝑡𝑗 не может повлиять на действия атакующего. Также, в случае, когда 𝑅

принимает значение, большее чем 𝑈 𝑐Ψ(𝑡), цель не требует дополнительного

покрытия, так как атакующий всегда предпочтёт цель 𝑡𝑖 цели 𝑡𝑗. В случаях,

когда 𝑅 лежит в интервале [𝑈 𝑐Ψ(𝑡), 𝑈𝑢

Ψ(𝑡)] необходимый размер покрытия мы

можем вычислить по формуле (1.16).

Algorithm 3 getCoverageForChangePriorityTarget

1: if R<Uua(t) then2: 𝑐← 23: return4: end if5: if R>Uca(t) then6: 𝑐← 07: return8: end if9: 𝑐𝑖 ← max

(0, 1− 𝑅−𝑈𝑢,𝑚𝑎𝑥

Ψ (𝑡)𝑈𝑢,𝑚𝑎𝑥Ψ (𝑡)−𝑈 𝑐,𝑚𝑎𝑥

Ψ (𝑡)

)10: return

Итоговый размер покрытия для 𝑖-й цели мы получаем как минимальное

значение min (𝑐𝑖,1, 𝑐𝑖,2). В случае, когда покрытие для 𝑖-й цели превышает

1, мы не можем гарантировать, что злоумышленник будет атаковать цель

𝑡𝑖 и переходим к рассмотрению следующей цели. Просуммировав значения

𝑐𝑗 для всех целей, мы получим общий размер покрытия, необходимый для

достижения необходимого выигрыша защитника. В случае, если эта сумма

не превышает количество выделенных ресурсов 𝑚, мы приходим к выводу,

что выбранное значение выигрыша достижимо.

Предложенный алгоритм позволяет найти распределение ресурсов по

целям и оценить общее количество ресурсов, необходимых для достиже-

22

ния максимального выигрыша защищающегося. Как было сказано ранее,

алгоритм основан на алгоритме ISG. Приведённые в [6] тесты показывают

высокую скорость работы алгоритмов подобного рода. Интервальная ариф-

метика и расширяющая её аффинная арифметика требует намного больше

операций для выполнения. Поэтому особенно важно, чтобы в основе вы-

числений лежал быстрый алгоритм оценки теоретико-игровой модели.

2.2 Программная модель

Для реализации данного проекта используется среда разработки 𝑀𝑎𝑡𝑙𝑎𝑏.

𝑀𝑎𝑡𝑙𝑎𝑏 отлично подходит для решения задач технических вычислений. Осо-

бенно стоит отметить широкие возможности для визуализации получаемых

данных, что особенно актуально для анализа результатов. В рамках языка

поддерживается концепция объектно-ориентированного программирования,

которая активно используется в данной работе.

При решении задачи обработки данных в первую очередь необходимо

решить вопрос организации хранения информации. 𝑀𝑎𝑡𝑙𝑎𝑏 позволяет хра-

нить данные в виде .mat файлов. Этот подход достаточно удобен в случае,

когда данные вводятся пользователем непосредственно в графическом ин-

терфейсе пользователя или когда данные получаются в результате выполне-

ния той или иной подпрограммы.

Следующий код иллюстрирует процесс создания тестовых данных:

1 info='Производственный склад';2 so=SecurityObject(info);3 t1=Target( 10, 5, 25, 29, 'Склад сырья');4 t2=Target( 15, 9, 18, 24, 'Склад материалов');5 t3=Target( 20, 14, 16, 43, 'Склад полуфабрикатов');6 t4=Target( 25, 19, 14, 40, 'Склад заготовок');7 t5=Target( 30, 23, 20, 45, 'Склад деталей');8 t6=Target( 34, 29, 22, 35, 'Склад сборочных единиц');9 t7=Target( 41, 33, 18, 30, 'Производственное помещение');

10 t8=Target( 45, 38, 10, 27, 'Склад готовой продукции');11 t9=Target( 51, 42, 8, 26, 'Склад отходов производства');12 targets=[t1,t2,t3,t4,t5,t6, t7, t8, t9 ];13 so=so.addTargets(targets);14 savefile ='storage.mat';

23

15 save( savefile ,"so");

Класс Target отвечает за хранение информации о защищаемой цели.

Поля класса содержат в себе информацию о выигрышах защищающего-

ся и атакующего, а также дополнительную информацию о цели. Класс

SecurityObject является представлением объекта безопасности и содержит

в себе все цели, которые могут быть целями для атаки злоумышленника.

Ниже представлен конструктор класса 𝐺𝑎𝑚𝑒𝑀𝑜𝑑𝑒𝑙. Этот класс отвеча-

ет за подготовку данных для различных алгоритмов. Язык 𝑀𝑎𝑡𝑙𝑎𝑏 является

динамически типизируемым, поэтому тип входного аргумента проверяется

в теле конструктора. В зависимости от типа аргумента выбирается способ

инициализации объекта класса. В данном случае поддерживаются 3 спосо-

ба создания объекта: из объекта класса SecurityObject, с помощью передачи

пути к файлу, из которого производится загрузка данных, и с помощью ге-

нерации случайных данных заданного размера. Последний способ добавлен

из соображений сравнительного тестирования работы различных алгорит-

мов.

1 function model=GameModel(arg)2 if nargin==13 val_class=class(arg);4 if strcmp(val_class,"SecurityObject") % Загрузка из SecurityObject5 model.info=arg.info;6 model=model.addTargets(arg.targets);7 for i=1:length(model.targets)8 model.coverageVector=[model.coverageVector,Interval(0,0)];9 end

10 return;11 end12 if strcmp(val_class,"char") % Загрузка из файла13 so=load(arg);14 model.info=so.info;15 model=model.addTargets(so.targets);16 for i=1:length(model.targets)17 model.coverageVector=[model.coverageVector,Interval(0,0)];18 end19 return;20 end21 if strcmp(val_class,"double") % Генерация данных заданного размера.22 mod= generateRandomModel(model,arg);

24

23 return;24 end25 end26 if nargin == 0 % Генерируем случайный набор данных.27 model= generateRandomModel(model,15);28 return29 end30 end

Данные о выигрышах атакующего и защищающегося хранятся в виде

массива объектов класса 𝐼𝑛𝑡𝑒𝑟𝑣𝑎𝑙. Описание класса 𝐼𝑛𝑡𝑒𝑟𝑣𝑎𝑙, а также дру-

гих классов для интервальных вычислений можно найти в главе 3. Класс

𝐺𝑎𝑚𝑒𝑀𝑜𝑑𝑒𝑙 обладает набором функций для конвертации исходных данных

в различные форматы. В рамках данной работы предусмотрена подготовка

данных для вычислений с интервальной арифметикой, аффинной арифме-

тикой и с вычислениями методом Монте-Карло. Помимо этого предусмот-

рена возможность конвертации данных для алгоритма 𝐼𝑆𝐺, с описанием

которого можно ознакомиться в работе [6]. Ниже приведена функции для

преобразования исходной модели для аффинных вычислений:

1 function affine_model = prepareForAffine(model)2 affine_model=prepare(model, @AffineForm);3 end4

5 function prepared_model=prepare(model, funct)6 prepared_model.targets=model.targets;7 prepared_model.Uud=Utils.foreach(funct,model.defenderUncoveredPayoffs);8 prepared_model.Ucd=Utils.foreach(funct,model.defenderCoveredPayoffs);9 prepared_model.Uua=Utils.foreach(funct,model.attackerUncoveredPayoffs);

10 prepared_model.Uca=Utils.foreach(funct,model.attackerCoveredPayoffs);11 prepared_model.coverageVector=Utils.foreach(funct,model.coverageVector);12 end

В функции 𝑝𝑟𝑒𝑝𝑎𝑟𝑒 используется функционал класса 𝑈𝑡𝑖𝑙𝑠. Данный

класс содержит в себе набор утильных статических функций для работы

с массивами интервалов. В данном случае используется функция 𝑓𝑜𝑟𝑒𝑎𝑐ℎ,

применяющая функцию к каждому элементу массива и выдающая на вы-

ходе массив результатов. Для подготовки данных для аффинных вычисле-

ний, в функцию 𝑝𝑟𝑒𝑝𝑎𝑟𝑒 передаётся конструктор класса @𝐴𝑓𝑓𝑖𝑛𝑒𝐹𝑜𝑟𝑚. В

25

результате все данные преобразуются в объекты класса 𝐴𝑓𝑓𝑖𝑛𝑒𝐹𝑜𝑟𝑚, кото-

рые поддерживают функционал аффинной арифметики.

2.3 Выводы

В данной главе мы рассмотрели способы построения алгоритмов реше-

ния теоретико-игровых моделей в условиях неопределённости, а также раз-

работали программное обеспечение для хранения и подготовки данных для

последующих вычислений. Объектно-ориентированный подход, использо-

ванный при разработке программы, позволяет изолировать различные части

процесса обработки данных, что ведёт к уменьшению зависимости между

различными модулями программного продукта. Подобных подход позволя-

ет легко изменять часть кода без вреда для остального функционала про-

граммы и способствует повторному использованию программного кода.

26

ГЛАВА 3

БИБЛИОТЕКА ДЛЯ ИНТЕРВАЛЬНЫХ ВЫЧИСЛЕНИЙ

3.1 Интервальные вычисления

Одним из способов учитывать неточность относительно намерений зло-

умышленника является использование интервального подхода при оцен-

ке его возможного выигрыша. Предлагается расширить стандартную

теоретико-игровую модель путем представления выигрышей атакующего и

защищающегося в интервальном виде. Для этого используются методы ин-

тервальной арифметики. Переход от моделирования точных ситуаций, не

предполагающих неточность исходных данных, к моделированию игровых

ситуаций в условиях неопределенности может быть математически форма-

лизован как аналитическое продолжение функций, к вычислению значений

которых сводятся расчеты в рамках теоретико-игровой модели. С точки зре-

ния практической реализации использование этого подхода сводится к пе-

реопределению арифметических операций и математических примитивов в

рамках интервальной арифметики. Результатами подобной комбинации ин-

тервального подхода и теоретико-игровой модели являются более обосно-

ванные сведения об оптимальной стратегии защищающегося.

3.1.1 Общий интерфейс объектов

Язык программирования 𝑀𝑎𝑡𝑙𝑎𝑏 предоставляет широкие возможности

для математических вычислений. В данной работе рассмотрен подход к вы-

числениям, основанный на полиморфизме функций. Реализованы классы

объектов, в которых переопределены основные математические операции,

благодаря чему становится возможным использование одних и тех же алго-

ритмов решения теоретико-игровых задач при разных подходах к исходным

данным. В данной главе рассматривается методы построения таких классов

для интервальной и аффинной арифметики.

Для эффективной работы теоретико-игровых алгоритмов, интерфейс

объектов должен содержать следующие функции:

27

1. plus() - сложение двух объектов

2. minus() - вычитание объекта из другого объекта

3. mtimes() - умножение объекта на другой объект

4. mrdivide() - деление объекта на другой объект

5. max() - нахождение максимума двух объектов

6. min() - нахождение минимума двух объектов

7. lt() - сравнение: менее чем

8. gt() - сравнение: более чем

9. le() - нестрогое сравнение: менее чем или равно

10. ge() - нестрогое сравнение: более чем или равно

Рисунок 3.1: Обобщённый интерфейс объектов

В целях облегчения работы с объектами, представляющими собой раз-

ные интерпретации понятия интервала, необходимо определить основные

функции, позволяющие обеспечить взаимодействие с объектом как с интер-

валом:

1. hiBound() - верхняя граница интервала

2. lowBound() - нижняя граница интервала

28

3. midPoint() - середина интервала

4. radius() - радиус интервала

5. convertToInterval() - преобразование в объект класса Interval

Рисунок 3.2: Интерфейс для взаимодействия с объектами,интерпретирующие инервальное значение

3.1.2 Интервальная арифметика

Одним из способов учитывать неточность относительно намерений зло-

умышленника является использование интервального подхода при оцен-

ке его возможного выигрыша. Интервальный подход позволяет расширить

стандартную модель Штакельберга, которая используется для построения

теоретико-игровых моделей. Операции над интервалами проводятся следу-

ющим образом [19]:

1. [𝑥1, 𝑦1] + [𝑥2, 𝑦2] = [𝑥1 + 𝑥2, 𝑦1 + 𝑦2]

2. [𝑥1, 𝑦1]− [𝑥2, 𝑦2] = [𝑥1 − 𝑦2, 𝑦1 − 𝑥2]

3. [𝑥1, 𝑦1]× [𝑥2, 𝑦2] = [min(𝑥1 × 𝑥2, 𝑥1 × 𝑦2, 𝑦1 × 𝑥2, 𝑦1 × 𝑦2),

max(𝑥1 × 𝑥2, 𝑥1 × 𝑦2, 𝑦1 × 𝑥2, 𝑦1 × 𝑦2)]

4. [𝑥1, 𝑦1]/[𝑥2, 𝑦2] = [min(𝑥1/𝑥2, 𝑥1/𝑦2, 𝑦1/𝑥2, 𝑦1/𝑦2),

max(𝑥1/𝑥2, 𝑥1/𝑦2, 𝑦1/𝑥2, 𝑦1/𝑦2)]

5. min [𝑥1, 𝑦1], [𝑥2, 𝑦2] = [min (𝑥1, 𝑥2),min (𝑦1, 𝑦2)]

6. max [𝑥1, 𝑦1], [𝑥2, 𝑦2] = [max (𝑥1, 𝑥2),max (𝑦1, 𝑦2)]

29

Рисунок 3.3: Класс Interval

Для реализации функционала интервальных вычислений разработан

класс Interval. Объекты класса Interval являются представлением математи-

ческого понятия интервала в рамках парадигмы объектно-ориентированного

программирования. Поля класса imin и imax хранят в себе численные зна-

чения верхней и нижней границ интервала соответственно. Класс поддер-

живает интерфейсы, описанные в 3.1.1. С исходным кодом класса можно

ознакомиться в приложении.

3.2 Аффинная арифметика

Переопределив примитивные арифметические операции в рамках интер-

вальных вычислений, мы автоматически сможем вычислять все функции,

которые могут быть получены комбинацией этих операций. К несчастью,

методы интервальной арифметики в результате вычислений часто получают

интервал намного шире интервала возможных значений вычисляемой функ-

ции, вызванного неточностью исходных данных расчета. Можно рассмот-

реть следующий пример: разность 𝑥 − 𝑥 при использовании интервальной

30

арифметики 𝑥 ∈ [2 · · · 5] равна [2−3 · · · 5−2] = [−3 · · ·+3] - вместо интервала

[0 · · · 0], который является тем интервалом, который следовало бы ожидать

в качестве результата. В случае, когда интервалы в вычислениях выражают

значения промежуточных переменных, полученных вычислениями с одни-

ми и теми же исходными данными, не все комбинации сочетания значений

в интервалах-операндах будут возможны и реальный интервал значений мо-

жет получиться меньше интервала, полученного с помощью интервальной

арифметики. Подобная проблема известна как ’проблема зависимости’ [20].

Рисунок 3.4: Класс AffineForm

Аффинная арифметика позволяет отчасти решить проблему зависимости

интервалов [21]. В случае интервальной арифметики неизвестная величина

представляется в виде интервала. В аффинной арифметике вводится поня-

тие аффинной формы , которая представляется в виде многочлена следу-

ющего вида:

= 𝑥0 + 𝑥1𝜖1 + 𝑥2𝜖2 + · · ·+ 𝑥𝑛𝜖𝑛,

где коэффициенты 𝑥𝑖 – это числа с плавающей точкой, а 𝜖𝑖 - символьные

вещественные переменные, чьи значения лежат в интервале [−1, 1].

31

Класс AffineForm (рисунок 3.4) представлен в приложении. Как и в слу-

чае класса Interval, он поддерживает интерфейсы, описанные в 3.1.1. Класс

имеет следующие поля

1. mean - центр аффинной формы

2. values - коэффициенты 𝑥𝑖 при вещественных переменных 𝜖

3. variables - индексы вещественных переменных 𝜖

Каждому значению из массива values соответствует значение из массива

variables. Оба массива предполагаются равными по длине. Также, для эф-

фективной работы алгоритмов оба массива всегда отсортированы по воз-

растанию индексов вещественных переменных.

Для сортировки после операций, которые изменяют порядок элементов

в массиве, реализована следующая статическая функция:

1 function affine =sortVariables(aff)2 affine =aff;3 values=affine.values ;4 variables=affine. variables ;5 if (isempty(values) || isempty(variables))6 return7 end8 sorted=sortrows([values; variables ],2);9 affine .values=sorted (1,:);

10 affine . variables=sorted (2,:);11 end

3.2.1 Конструктор

Конструктор класса принимает в качестве аргумента объект класса. В

случае, если на вход подан интервал [𝑥, 𝑦], аффинная форма примет вид

=𝑥 + 𝑦

2+

𝑦 − 𝑥

2𝜖𝑘 (3.1)

где 𝜖𝑘 символ шума [21]. В соответствии с этой формулой создаётся объ-

ект класса со значением 𝑚𝑒𝑎𝑛, равным 𝑥+𝑦2 , массивом единичной длинны

32

𝑣𝑎𝑙𝑢𝑒𝑠 со значением 𝑦−𝑥2 и с массивом 𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠, содержащим индекс веще-

ственной переменной 𝜖𝑘. Значение 𝑚𝑒𝑎𝑛 является центром исходного ин-

тервала и часто называется медианой аффинной формы.

Статическая функция getNewVarName() генерирует индекс для новой ве-

щественной переменной.

1 function var_name=getNewVarName()2 persistent p;3 if isempty(p)4 p=0;5 end6 var_name=p;7 p=p+1;8 end

В случае, когда на вход в качестве аргумента попадает вещественное

число, создаётся аффинная форма с пустыми массивами 𝑣𝑎𝑙𝑢𝑒𝑠 и 𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠

и значением 𝑚𝑒𝑎𝑛, равным входному аргументу.

3.2.2 Внешняя оценка и конвертация в интервал

Пусть дана аффинная форма = 𝑥0 + 𝑥1 * 𝜖1 + 𝑥2 * 𝜖2 + · · ·+ 𝑥𝑛 * 𝜖𝑛. Для

любых значений 𝜖 ∈ [−1, 1] значения будут лежать в интервале

[𝑚𝑖𝑛,𝑚𝑎𝑥] = [𝑥0 −𝑛∑𝑖=0

|𝑥𝑖|, 𝑥0 +𝑛∑𝑖=0

|𝑥𝑖|] (3.2)

По этой формуле и будем проводить внешнюю оценку аффин-

ной формы [22]. Для реализации этого функционала написана функция

convertToInterval:

1 function interval=convertToInterval(obj)2 sumArr=sum(abs(obj.values));3 interval=Interval(obj.mean−sumArr,obj.mean+sumArr);4 end

33

3.2.3 Сложение и вычитание

Операции над аффинными формами можно разбить на два вида: линей-

ные и нелинейные. К линейным операциям относят те операции, результат

которых можно представить в виде линейной суммы аффинных форм аргу-

ментов. Для аффинных форм и 𝑦

= 𝑥0 + 𝑥1𝜖𝑥,1 + 𝑥2𝜖𝑥,2 + · · ·+ 𝑥𝑛𝜖𝑥,𝑛,

𝑦 = 𝑦0 + 𝑦1𝜖𝑦,1 + 𝑦2𝜖𝑦,2 + · · ·+ 𝑦𝑛𝜖𝑦,𝑛.

в качестве примера линейных операций можно привести сумму и разность

аффинных форм:

+ 𝑦 = (𝑥0 + 𝑦0) +

(𝑛∑𝑖=1

𝑥𝑛𝜖𝑥,𝑛

)+

(𝑛∑𝑖=1

𝑦𝑛𝜖𝑦,𝑛

)

− 𝑦 = (𝑥0 − 𝑦0) +

(𝑛∑𝑖=1

𝑥𝑛𝜖𝑥,𝑛

)−

(𝑛∑𝑖=1

𝑦𝑛𝜖𝑦,𝑛

)

Функции сложения и вычитания в алгоритмическом плане практически

идентичны и отличаются лишь арифметической операцией, которая прово-

дится между членами аффинных форм.

Алгоритм 4 иллюстрирует реализованный алгоритм построение масси-

вов, соответствующих аффинной форме результата операции. Во временные

переменные помещаются значения размеров массивов значений аффинных

форм. Медиана результирующей аффинной формы получается при переда-

че целевой функции медиан аффинных форм X и Y в качестве аргументов.

Максимальное количество элементов в массиве значений результирующей

аффинной формы не превосходит суммы количества элементов в аффинных

формах X и Y. Перед входом в цикл, который итерирует индекс результи-

рующего массива, мы определяем две переменные: xCount и yCount. Эти

переменные отражают элементы массивов X и Y, участвующие в сравнении

на текущей итерации.

34

Algorithm 4 Объединение аффинных форм

1: procedure AFFINE MERGE(𝑋, 𝑌, 𝑓𝑢𝑛𝑐𝑡)2: 𝑥𝑆𝑖𝑧𝑒← 𝑙𝑒𝑛𝑔𝑡ℎ(𝑋.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠)3: 𝑦𝑆𝑖𝑧𝑒← 𝑙𝑒𝑛𝑔𝑡ℎ(𝑌.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠)4: 𝑣𝑎𝑙𝑆𝑖𝑧𝑒← 𝑥𝑆𝑖𝑧𝑒 + 𝑦𝑆𝑖𝑧𝑒5: 𝑚𝑒𝑎𝑛← 𝑓𝑢𝑛𝑐𝑡(𝑋.𝑚𝑒𝑎𝑛, 𝑌.𝑚𝑒𝑎𝑛);6: 𝑥𝐶𝑜𝑢𝑛𝑡← 07: 𝑦𝐶𝑜𝑢𝑛𝑡← 08: for all 𝑖 = 0→ 𝑣𝑎𝑙𝑆𝑖𝑧𝑒 do9: if 𝑥𝐶𝑜𝑢𝑛𝑡 ≥ 𝑥𝑆𝑖𝑧𝑒 then

10: 𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠← 𝑌.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠(𝑦𝐶𝑜𝑢𝑛𝑡 : 𝑒𝑛𝑑)11: 𝑣𝑎𝑙𝑢𝑒𝑠← 𝑌.𝑣𝑎𝑙𝑢𝑒𝑠(𝑦𝐶𝑜𝑢𝑛𝑡 : 𝑒𝑛𝑑)12: return13: end if14: if 𝑦𝐶𝑜𝑢𝑛𝑡 ≥ 𝑦𝑆𝑖𝑧𝑒 then15: 𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠← 𝑋.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠(𝑥𝐶𝑜𝑢𝑛𝑡 : 𝑒𝑛𝑑)16: 𝑣𝑎𝑙𝑢𝑒𝑠← 𝑋.𝑣𝑎𝑙𝑢𝑒𝑠(𝑥𝐶𝑜𝑢𝑛𝑡 : 𝑒𝑛𝑑)17: return18: end if19: if 𝑋.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠(𝑥𝐶𝑜𝑢𝑛𝑡) < 𝑌.𝑣𝑎𝑙𝑖𝑎𝑏𝑙𝑒𝑠(𝑦𝐶𝑜𝑢𝑛𝑡) then20: 𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠← 𝑋.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠(𝑥𝐶𝑜𝑢𝑛𝑡)21: 𝑣𝑎𝑙𝑢𝑒𝑠← 𝑋.𝑣𝑎𝑙𝑢𝑒𝑠(𝑥𝐶𝑜𝑢𝑛𝑡)22: 𝑥𝐶𝑜𝑢𝑛𝑡 = 𝑥𝐶𝑜𝑢𝑛𝑡 + 123: continue24: end if25: if X.variables(xCount) > Y.valiables(yCount) then26: 𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠← 𝑌.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠(𝑦𝐶𝑜𝑢𝑛𝑡)27: 𝑣𝑎𝑙𝑢𝑒𝑠← 𝑦.𝑣𝑎𝑙𝑢𝑒𝑠(𝑦𝐶𝑜𝑢𝑛𝑡)28: 𝑦𝐶𝑜𝑢𝑛𝑡 = 𝑦𝐶𝑜𝑢𝑛𝑡 + 129: continue30: end if31: if X.variables(xCount) == Y.valiables(yCount) then32: 𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠← 𝑌.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠(𝑦𝐶𝑜𝑢𝑛𝑡)33: 𝑣𝑎𝑙𝑢𝑒𝑠← 𝑓𝑢𝑛𝑐𝑡(𝑋.𝑣𝑎𝑙𝑢𝑒𝑠(𝑥𝐶𝑜𝑢𝑛𝑡), 𝑌.𝑣𝑎𝑙𝑢𝑒𝑠(𝑦𝐶𝑜𝑢𝑛𝑡))34: 𝑥𝐶𝑜𝑢𝑛𝑡 = 𝑥𝐶𝑜𝑢𝑛𝑡 + 135: 𝑦𝐶𝑜𝑢𝑛𝑡 = 𝑦𝐶𝑜𝑢𝑛𝑡 + 136: continue37: end if38: end for39: end procedure

35

На каждой итерации цикла мы делаем проверку значений xCount и

yCount. В случае если значение одной из этих переменных превзошло об-

щее количество элементов в соответствующем массиве, мы делаем вывод,

что все элементы этого массива обработаны, и помещаем необработанные

элементы второго массива в конец результирующего массива элементов зна-

чений аффинной формы и осуществляем выход из цикла.

Основная идея предложенного алгоритма - сохранение отсортированно-

го порядка элементов массива индексов вещественных переменных аффин-

ной формы. Мы сравниваем текущие значения индексов массивов X и Y. В

случае если они не равны, мы помещаем в результирующий массив значе-

ние меньшее из двух элементов и увеличиваем счётчик соответствующего

массива. В случае равенства элементов массива мы приходим к выводу, что

обе аффинные формы содержат переменные с одинаковыми индексами. В

этом случае в массив значений результирующей аффинной формы мы по-

мещаем результат выполнения целевой функции над значениями форм X и

Y. После этого мы увеличиваем оба счётчика xCount и yCount.

Результатом работы данного алгоритма будет аффинная форма, пред-

ставляющая собой объединение двух аффинных форм по заданной функ-

ции. На базе этой функции мы можем без особых проблем реализовать

операции сложения и вычитания:

1 function r=plus(X,Y)2 r=merge(X,Y,@plus);3 end4 function r=minus(X,Y)5 r=merge(X,Y,@minus);6 end

3.2.4 Нелинейные операции

Операции простого алгебраического умножения и деления не являются

линейными. Например, в случае умножения двух аффинных форм получаем

следующее соотношение:

36

× 𝑦 = 𝑥0𝑦0 + 𝑥0

𝑛∑𝑖=0

(𝑦𝑖𝜖𝑦,𝑖) + 𝑦0

𝑛∑𝑖=0

(𝑥𝑖𝜖𝑥,𝑖) +𝑛∑𝑖=0

𝑛∑𝑗=0

(𝑥𝑖𝑦𝑖𝜖𝑥,𝑖𝜖𝑦,𝑗)

Так как член∑𝑛

𝑖=0

∑𝑛𝑗=0(𝑥𝑖𝑦𝑖𝜖𝑥,𝑖𝜖𝑦,𝑗) не представим в виде линейной сум-

мы исходных элементов аффинных форм, необходимо ввести новую пере-

менную 𝜖𝑘:

× 𝑦 = 𝑥0𝑦0 + 𝑥0

𝑛∑𝑖=0

(𝑦𝑖𝜖𝑦,𝑖) + 𝑦0

𝑛∑𝑖=0

(𝑥𝑖𝜖𝑥,𝑖) + 𝑧𝑘𝜖𝑘

где 𝑧𝑘 - верхняя оценка ошибки аппроксимации.

|𝑧𝑘| ≥ |𝑛∑𝑖=0

𝑛∑𝑗=0

(𝑥𝑖𝑦𝑖𝜖𝑥,𝑖𝜖𝑦,𝑗)|, 𝑒𝑖, 𝑒𝑗 ∈ [−1, 1]

Алгоритм умножения двух аффинных форм представлен в 5. Во времен-

ные переменные xSize и ySize мы помещаем длины массивов значений вход-

ных форм X и Y. Медиану результирующей формы мы получаем как умно-

жение медиан X и Y. Создаётся временная аффинная форма для каждого

входного аргумента. Медианой каждой формы выступает медиана исходной

формы. Массив индексов заполняем индексами каждой из форм. Массив

значений заполняется произведением соответствующего значения исходной

формы и значением медианы другой формы. После подготовки временных

аффинных форм производится их сложение в соответствии с алгоритмом,

описанным в предыдущей главе. В результирующей аффинной форме мас-

сив значений будет соответствовать формуле 𝑥0

∑𝑛𝑖=0(𝑦𝑖𝜖𝑦,𝑖)+𝑦0

∑𝑛𝑖=0(𝑥𝑖𝜖𝑥,𝑖).

Для завершения операции умножения необходимо произвести добавление

новых переменных 𝜖𝑘. Для этого элементы массивов значений форм X и Y

попарно перемножаются друг с другом. Для каждого полученного значения

генерируется новый индекс переменной. Результаты помещаются в конец

массивов итоговой формы.

37

Algorithm 5 Умножение аффинных форм

1: procedure AFFINEMULTIPLICATION(𝑋, 𝑌 )2: 𝑥𝑆𝑖𝑧𝑒← 𝑙𝑒𝑛𝑔𝑡ℎ(𝑋.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠)3: 𝑦𝑆𝑖𝑧𝑒← 𝑙𝑒𝑛𝑔𝑡ℎ(𝑌.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠)4: 𝑣𝑎𝑙𝑆𝑖𝑧𝑒← 𝑥𝑆𝑖𝑧𝑒 + 𝑦𝑆𝑖𝑧𝑒5: 𝑚𝑒𝑎𝑛← 𝑋.𝑚𝑒𝑎𝑛× 𝑌.𝑚𝑒𝑎𝑛6: 𝑡𝑚𝑝𝑋.𝑚𝑒𝑎𝑛← 𝑋.𝑚𝑒𝑎𝑛7: 𝑡𝑚𝑝𝑋.𝑣𝑎𝑙𝑢𝑒𝑠← 𝑒𝑚𝑝𝑡𝑦8: 𝑡𝑚𝑝𝑋.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠← 𝑋.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠9: 𝑡𝑚𝑝𝑌.𝑚𝑒𝑎𝑛← 𝑌.𝑚𝑒𝑎𝑛

10: 𝑡𝑚𝑝𝑌.𝑣𝑎𝑙𝑢𝑒𝑠← 𝑒𝑚𝑝𝑡𝑦11: 𝑡𝑚𝑝𝑌.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠← 𝑌.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠12: for all 𝑣𝑎𝑙 ∈ 𝑡𝑚𝑝𝑋.𝑣𝑎𝑙𝑢𝑒𝑠 do13: 𝑡𝑚𝑝𝑋.𝑣𝑎𝑙𝑢𝑒𝑠← 𝑣𝑎𝑙 * 𝑌.𝑚𝑒𝑎𝑛14: end for15: for all 𝑣𝑎𝑙 ∈ 𝑡𝑚𝑝𝑌.𝑣𝑎𝑙𝑢𝑒𝑠 do16: 𝑡𝑚𝑝𝑌.𝑣𝑎𝑙𝑢𝑒𝑠← 𝑣𝑎𝑙 *𝑋.𝑚𝑒𝑎𝑛17: end for18: 𝑡𝑚𝑝𝑍 ← 𝑡𝑚𝑝𝑋 + 𝑡𝑚𝑝𝑌19: 𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠← 𝑡𝑚𝑝𝑍.𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠20: 𝑣𝑎𝑙𝑢𝑒𝑠← 𝑡𝑚𝑝𝑍.𝑣𝑎𝑙𝑢𝑒𝑠21: for all 𝑖 = 0→ 𝑥𝑆𝑖𝑧𝑒 do22: for all 𝑗 = 0→ 𝑦𝑆𝑖𝑧𝑒 do23: 𝑣𝑎𝑟𝑖𝑎𝑏𝑙𝑒𝑠← 𝜖𝑛𝑒𝑤24: 𝑣𝑎𝑙𝑢𝑒𝑠← 𝑋.𝑣𝑎𝑙𝑢𝑒𝑠(𝑖)× 𝑌.𝑣𝑎𝑙𝑢𝑒𝑠(𝑗)25: end for26: end for27: return28: end procedure

38

В результате мы получаем аффинную форму, являющуюся произведени-

ем двух аффинных форм. Заметим, что результирующая форма сохранила

отсортированный порядок массива индексов.

3.3 Метод имитационного моделирования (Монте-Карло)

Для оценки работы разработанных классов добавлен класс для интер-

вальных вычислений методом Монте-Карло. Для заданного интервала мы

случайно генерируем 𝑁 точек из этого интервала, которые хранятся в мас-

сиве points. Генерация происходит по равномерному закону распределения

извлекаемых из интервала точек. Арифметические операции проводятся

непосредственно с элементами массива, и результат выполнения сохраня-

ется в массив нового объекта. Реализация интерфейса 𝐼𝑛𝑡𝑒𝑟𝑉 𝑎𝑙𝑢𝑒 пред-

ставлена ниже:

1 function interval=convertToInterval(obj,name)2 interval=Interval(obj.lowBound, obj.hiBound);3 end4

5 function res = hiBound(obj)6 res=max(obj.points);7 end8

9 function res = lowBound(obj)10 res=min(obj.points);11 end12

13 function res = midPoint(obj)14 res=median(obj.points);15 end16

17 function res = radius(obj)18 hi=obj.hiBound;19 lo=obj.lowBound;20 res=(hi−lo)/2;21 end

39

3.4 Сравнение

Для проведения сравнительного аналитического тестирования разрабо-

танных классов работы с интервалами написана функция для визуализации

результатов выполнения интервальных вычислений. Выполнено сравнение

операций над четырьмя интервалами:

1. 𝑥1 = [2; 5]

2. 𝑥2 = [3; 7]

3. 𝑥3 = [1; 8]

4. 𝑥4 = [6; 12]

Рисунки 3.5 – 3.9 иллюстрируют результат выполнения различных функ-

ций над этими интервалами. На оси абсцисс отложен номер соответствую-

Рисунок 3.5: Сравнение интервальных вычислений: простая функция 1.

40

Рисунок 3.6: Сравнение интервальных вычислений: простая функция 2.

Рисунок 3.7: Сравнение интервальных вычислений: сложная функция 1.

41

щего значения массива значений алгоритма Монте-Карло. На оси ординат -

результат выполнения функции.

На рисунке 3.5 можно увидеть, что в случае, когда интервалы, участвую-

щие в вычислениях, появляются там лишь однажды, аффинная арифметика

может оказаться менее эффективной, чем классическая интервальная. Ри-

сунки 3.7, 3.8 иллюстрируют сужение интервала результата аффинных вы-

числений по сравнению с результатом интервальной арифметики. Аффин-

ная арифметика демонстрирует свою эффективность с увеличением числа

зависимостей между интервальными значениями. Это заметно на рисунке

3.9: интервал, полученный в результате аффинных вычислений, почти вдвое

уже, чем результат интервальных вычислений. Прежде всего это связано с

тем, что в рассмотренном примере используется большое количество слож-

ных операций над одними и теми же интервальными значениями.

Рисунок 3.8: Сравнение интервальных вычислений: сложная функция 2.

42

3.5 Выводы

В данной главе описана разработанная библиотека для аффинных и ин-

тервальных вычислений. Проведено сравнение работы различных инстру-

ментов интервального анализа. Аффинная арифметика показывает большую

эффективность в случаях большого количества коррелированных интерва-

лов, участвующих в вычислениях. Стоит учитывать тот факт, что в слу-

чае большого количества нелинейных операций эффективность аффинной

арифметики будет зависеть от реализации этих операций. Существует боль-

шое количество способов аппроксимировать значения для коэффициентов

результатов нелинейных операций. Помимо этого стоит отметить что вы-

числения с аффинными формами могут быть достаточно медленными. Ко-

личество переменных в аффинной форме напрямую зависит от количества

операндов, участвовавших в вычислениях. При превышении определённого

порога целесообразно задуматься об использовании метода Монте-Карло,

Рисунок 3.9: Сравнение интервальных вычислений: сложная функция 3.

43

как более эффективном для оценки интервальных значений. Однако, стоит

учитывать, что метод Монте-Карло, в отличии от методов интервального

анализа, не гарантирует внешнюю оценку результирующей функции. Вы-

бирать метод для вычислений необходимо учитывая специфику задачи и

требования к итоговым результатам.

44

ГЛАВА 4

СРАВНЕНИЕ ИНТЕРВАЛЬНЫХ ПОДХОДОВ ДЛЯ РЕШЕНИЯ

ЗАДАЧИ ОБЕСПЕЧЕНИЯ БЕЗОПАСНОСТИ

В главе 2 мы рассмотрели построение алгоритма решения задачи оценки

распределения ресурсов для задач обеспечения безопасности объектов. В

главе 3 описанны методики адаптации этого алгоритма для интервальных

вычислений. В данной главе проведено сравнение разработанных подходов

к вычислениям в условиях неопределённости.

Будем рассматривать задачу обеспечения безопасности производствен-

ного склада. Выделим основные возможные цели злоумышленника:

1. Склад сырья

2. Склад материалов

3. Склад полуфабрикатов

4. Склад заготовок

5. Склад деталей

6. Склад сборочных единиц

7. Производственное помещение

8. Склад готовой продукции

9. Склад отходов производства

Распределение предполагаемых выигрышей атакуюшего и защищающе-

гося представлено в таблице 4.1.

45

𝑈 𝑐Θ 𝑈𝑢

Θ 𝑈 𝑐Ψ 𝑈𝑢

Ψ

1. Склад сырья 10 5 [24.2; 25.8] [28.2; 29.8]

2. Склад материалов 15 9 [16.8; 19.2] [22.8; 25.2]

3. Склад полуфабрикатов 20 14 [10.6; 21.4] [37.6; 48.4]

4. Склад заготовок 25 19 [8.8; 19.2] [34.8; 45.2]

5. Склад деталей 30 23 [15; 25] [40; 50]

6. Склад сборочных единиц 34 29 [19.4; 24.6] [32.4; 37.6]

7. Производственное помещение 41 33 [15.6; 20.4] [27.6; 32.4]

8. Склад готовой продукции 45 38 [6.6; 13.4] [23.6; 30.4]

9. Склад отходов производства 51 42 [4.4; 11.6] [22.4; 29.6]

Таблица 4.1: Распределение выигрышей атакующего и защищающегося.

В качестве входных значений для разработанных алгоритмов мы исполь-

зуем набор данных, сохранённых в формате *.mat. Процесс создания соот-

ветствующего файла представленн в разделе 2.2.

4.1 Тестирование базового алгоритма

Рассмотрим специфику работы разработанного алгоритма на приведён-

ном выше примере. Мы будем изменять количество выделенных для по-

крытия ресурсов и рассмотрим динамику предлагаемого алгоритмом рас-

пределения. На рисунке 4.1 изображено три графика, отображающие рас-

пределение покрытия между целями при различном максимальном значе-

нии доступных ресурсов. Значения, полученные методами интервального

анализа и аффинной арифметики, представлены на рисунке в виде интерва-

лов неопределённости. Результаты работы интервальных алгоритмов срав-

ниваются с значениями, полученными в результате работы ISG алгоритма,

описанного в [6].

На рисунке 4.2 можно увидеть, как перераспределяется покрытие между

целями с ростом количества доступных ресурсов. При достижении опреде-

лённого количества доступных ресурсов можно заметить, как смещается

приоритетная цель для атакующего с цели шесть на цель семь. Выбор при-

46

Рисунок 4.1: Распределение ресурсов для m=[2,3]

оритетной цели атакующим во многом зависит от того, какой ожидается

выигрыш защитника. Зависимость гарантированного выигрыша защищаю-

щегося от количества ресурсов приведена на рисунке 4.3. Резкие перепады

выигрыша связаны с появлением возможности более эффективно использо-

вать имеющиеся ресурсы и обеспечить атаку на цель, приносящую защи-

щающемуся больший выигрыш. Так как различные интервальные подхо-

ды могут гарантировать различный выигрыш защитника для одного и того

же максимального количества ресурсов, решения, предлагаемые алгоритма-

ми, могут отличаться достаточно сильно. На графике видно, что переход

к другой предполагаемой цели происходит с меньшими ресурсозатратами

при использовании метода Монте-Карло. Алгоритм ISG подтверждает свою

эффективность и даёт результаты, очень близкие к методу Монте-Карло.

47

Рисунок 4.2: Распределение ресурсов для m=[3,4]

Методы аффинной арифметики заметно эффективнее классического интер-

вального подхода, который предлагает решения, требующие большего коли-

чества ресурсов для достижения того же размера выигрыша.

На рисунке 4.4 произведено сравнение работы аффинной арифметики

и алгоритма Монте-Карло. Как мы видим, результирующая ширина интер-

валов результата алгоритма аффинной арифметики шире интервалов, полу-

ченных методом Монте-Карло. Это согласуется с выводами, сделанными в

главе 3.

48

Рисунок 4.3: Выигрыш защитника при различных значениях количествадоступных ресурсов

4.2 Оценка времени выполнения

Верхняя оценка асимптотической сложности для алгоритма ISG рав-

на 𝑂(𝑛2 log 1𝜖 ), где 𝜖 значение допустимой ошибки при бинарном поиске.

Сложность вычисления значения функции 𝑓𝑒𝑎𝑠𝑖𝑏𝑖𝑙𝑖𝑡𝑦𝐶ℎ𝑒𝑐𝑘, оценивается

как 𝑂(𝑛2).

Исходный алгоритм, используемый для интервальных вычислений в

данной работе имеет ту же оценку вычислительной сложности. В качестве

операндов арифметических операций используются классы, представляю-

щие интервальные значения. В случае интервальной арифметики каждая

примитивная операция исходного алгоритма соответствует константному

количеству операций с границами интервального значения. Из этого можно

49

Рисунок 4.4: Распределение ресурсов, сравнение Монте-Карло иАффинной арифметики

сделать вывод, что вычислительная сложность алгоритма в случае исполь-

зования интервальных значений для отображения неопределённости исход-

ных данных равна 𝑂(𝑛2 log 1𝜖 ).

В аффинной арифметике количество операций зависит от количества ве-

щественных переменных, используемых для представления аффинной фор-

мы. С ростом количества целей в теоретико-игровой модели пропорцио-

нально растёт количество переменных, участвующих в вычислениях. Реа-

лизованный алгоритм умножения аффинных форм требует 𝑂(𝑛2) операций

для получения результата. Исходя из этих фактов, общая оценка для алго-

ритма, основанного на аффинной арифметике, составляет 𝑂(𝑛4 log 1𝜖 ) для

худшего случая.

Подход Монте-Карло предполагает вычисления для набора значений,

взятых из заданного интервала. Для каждой операции исходного алгорит-

50

Рисунок 4.5: Зависимость скорости работы алгоритмов от количестваисходных целей

ма будет производится 𝑂(𝑘) операций, где 𝑘 - количество элементов в мас-

сиве значений Монте-Карло. Вычислительная сложность алгоритма Монте-

Карло равна 𝑂(𝑘 * 𝑛2 log 1𝜖 ).

Проведём сравнительную оценку времени выполнения различных алго-

ритмов. Мы будем использовать уже реализованный в классе GameModel

генератор случайных исходных данных. Для каждого значения t, отражаю-

щего общее количество целей, мы будем генерировать n игровых моделей

соответствующей длины. С помощью встроенных функций языка 𝑀𝑎𝑡𝑙𝑎𝑏

𝑡𝑖𝑐 и 𝑡𝑜𝑐 оцениваем скорость выполнения каждого алгоритма и высчитыва-

ем среднее значение для заданного 𝑡. В результате мы получим зависимость

скорости выполнения алгоритма от количества целей 𝑡, подлежащих защите.

На рисунке 4.5 можно увидеть, что скорость работы алгоритмов аффинной

арифметики сравнима по скорости с подходом монте-карло. Классические

51

Рисунок 4.6: Оценка скорости работы ISG алгоритма

интервальные вычисления выполняются заметно быстрее. Для большого ко-

личества целей алгоритм ISG выполняется в разы быстрее представленных

подходов. На рисунке 4.6 можно увидеть зависимость скорости работы это-

го алгоритма от количества целей.

4.3 Оценка ресурсов

Функция feasibilityCheck исходного алгоритма производит поиск перво-

го удачного решения, удовлетворяющего заявленному количеству выигры-

ша 𝐷*. Модифицируем эту функцию, чтобы мы могли получать решение,

ресурсозатраты которого минимальны. Для этого для каждого предполага-

емого значения выигрыша будем получать все возможные распределения

ресурсов, которые удовлетворяют условиям достижения этого значения. Из

52

полученного набора решений будем выбирать ответ с минимальной суммой

ресурсозатрат. В результате мы получаем аппарат для оценки минимального

количества ресурсов, необходимого для достижения определённого выигры-

ша.

Проведём следующий анализ. Вместо поиска максимального достижи-

мого значения 𝐷 оценим динамику роста необходимых ресурсов от предпо-

лагаемого выигрыша 𝐷. Подобный анализ может быть полезен в случаях,

когда общее количество ресурсов, выделяемое для защиты целей потен-

циально не ограничено, и при этом существует методика оценки стоимо-

сти выделяемых ресурсов. К примеру, общая стоимость найма ещё одного

охранника вполне может быть выражена в денежном эквиваленте. В этом

случае целесообразно рассматривать исходную задачу не как задачу макси-

мизации значения выигрыша атакующего 𝐷 при ограниченном количестве

ресурсов, а как задачу оценки значения Γ:

Γ = 𝑚𝑎𝑥(𝐷𝑖 − 𝑓(𝑚)), (4.1)

где 𝑓(𝑚) - функция, преобразующая количество ресурсов в их стоимость.

Рисунок 4.7 отображает интервальные значения необходимого количества

ресурсов для достижения заданного выигрыша защитника.

4.4 Оценка ширины интервала неопределённости

В случае, когда алгоритм работает с вырожденными интервалами, ре-

зультатом вычислений также является вырожденный интервал. Оценим, как

меняются результаты работы алгоритмов в зависимости от ширины интер-

вала неопределённости. Мы будем брать одни и те же данные теоретико-

игровой модели и расширять интервал значений выигрыша атакующего для

ряда целей. Для иллюстрации зависимости распределения ресурсов от ин-

тервала неопределённости рассмотрим два примера.

Различия между интервалами значений выигрыша атакующего при раз-

личных уровнях неопределённости можно наблюдать на рисунке 4.8. Мож-

53

Рисунок 4.7: Необходимое количество ресурсов для достижения заданныхзначений выигрыша защитника.

но заметить, что степень неопределённости данных напрямую влияет на

результирующее распределение ресурсов.

На рисунке 4.9 можно наблюдать зависимость необходимого количества

ресурсов для успешного покрытия целей от ширины интервала неопреде-

лённости при заданном выигрыше защищающегося . Как и следовало ожи-

дать, при увеличении неопределённости растёт оценка количества необхо-

димых ресурсов. Для оценки ширины интервальных значений введена эв-

рестическая оценка уровня неопределённости, основанная на расстоянии

между границами интервальных значений. При достижении уровня неопре-

делённости 0.12 методы интервальной арифметики уже не находят решение,

удовлетворяющее заданному уровню выигрыша защитника. Для аффинной

арифметики это происходит при уровне неопределённости 0.16, для мето-

54

Рисунок 4.8: Выигрышы атакующего для набора целей при различномуровне неопределённости исходных данных.

да Монте-Карло при уровне 0.28. Подобное поведение связано с шириной

интервалов, получаемых в ходе вычислений. Ввиду того, что интервалы,

получаемые в результате интервальной арифметики, шире остальных, да-

же при небольшом уровне неопределённости исходных данных становится

невозможным достижение заданного уровня выигрыша.

Проверим, как зависит ожидаемый выигрыш защитника с увеличением

интервала неопределённости. На рисунке 4.10 можно наблюдать, как пада-

ет ожидаемый выигрыш защищающегося с увеличением неопределённости

относительно действий атакующего.

Как уже было замечено, разработанный подход позволяет вносить ин-

тервальную неопределённость в разные части исходной модели. Бывают

случаи, когда выигрыш защищающегося в случае успешной атаки злоумыш-

55

Рисунок 4.9: Зависимость интервалов необходимого количества ресурсовдля достижения заданного выигрыша защищающегося

ленника также не определён. Выигрыш защищающегося также, как и выиг-

рыш атакующего представляет из себя некоторое оценочное значение, ко-

торое также может быть неточным. Использование интервалов для оценки

выигрыша защищающегося вполне обоснована, если мы хотим учитывать

эту неточность и способны оценить эти значения в интервальном виде. Сто-

ит отметить, что в соответствии с выводами, сделанными в главе 3, увели-

чение количества интервальных значений в исходных данных увеличивает

результирующий интервал оценки необходимого количества ресурсов и уве-

личивает оценочный выигрыш защищающегося.

При построении модели особенное внимание следует уделить точности

оценки выигрыша атакующего. Представленные алгоритмы позволяют про-

изводить оценку выигрыша защищающегося даже при большой степени

56

Рисунок 4.10: Зависимость выигрыша защитника от уровнянеопределённости в условиях огнариченных ресурсов.

неточности исходных данных. Однако, стоит учитывать, что величина га-

рантированного выигрыша при этом падает.

4.5 Оценка интервального ответа

Результаты, которые получаются в результате работы интервальной

арифметики также представляют из себя интервальные значения. Подобные

результаты удобны для аналитических целей и последующих интервальных

вычислений. Однако, в рамках задачи принятия решения необходимо осу-

ществлять итоговую оценку интервального решения. Интервальные алго-

57

ритмы решения теоретико-игровых задач были бы неполными без методики

избавления от неопределённости в результатах анализа.

Для того, чтобы получить дискретные значения для распределений ре-

сурсов между целями, воспользуемся методом максимина. Мы будем оцени-

вать выигрыш атакующего для каждой цели при граничных значениях по-

крытия. Оценив максимальное значение выигрыша атакующего для каждого

значения покрытия, мы выберем минимальное, удовлетворяющее условиям

достижения заданного значения выигрыша. Функция для получения дис-

кретной оценки распределения ресурсов на основании интервальных значе-

ний приведена в приложении А.5.

Рисунок 4.11: Оценка интервальных результатов.

58

На рисунке 4.11 можно увидеть оценку необходимого покрытия каждой

цели в сравнении с исходными интервальными значениями. Можно уви-

деть, что в большинстве случаев значение соответствует верхней границе

интервального значения.

4.6 Выводы

В условиях недостатка информации относительно намерений злоумыш-

ленника целесообразно прибегнуть к интервальному представлению дан-

ных при построении теоретико-игровой модели. Рассмотренные подходы

к интервальным вычислениям позволяют оценивать распределение ресур-

сов между целями в условиях неопределённости. Очевидным недостатком

представленных подходов в сравнении с методами оценки, предлагаемы-

ми в тематической литературе, является сравнительно медленная скорость

выполнения. Это связано с дополнительными вычислениями, которые необ-

ходимы для получения ответа в интервальном виде. Результат работы пред-

ложенных алгоритмов напрямую зависит от уровня неточности исходных

данных. При высоком значении ширины исходных интервалов ожидаемо

растёт ширина интервальных оценок распределения ресурсов. Ширина ин-

тервальных оценок также зависит от используемого для вычислений метода.

59

ЗАКЛЮЧЕНИЕ

Ввиду отсутсвия свободно распространяемых библиотек для аффинных

вычислений для языка 𝑀𝑎𝑡𝑙𝑎𝑏 было принято решение о самостоятельной

разработке необходимого пакета расширений. Разработано программное

обеспечение для интервального анализа теоретико-игровых моделей, поз-

воляющее моделировать практически значимые ситуации обеспечения без-

опасности. Создана библиотека для интервальных вычислений (классиче-

ская интервальная арифметика, аффинная арифметика, интервальная оцен-

ка методом Монте-Карло). Применение объектно-ориентированного подхо-

да и единого интерфейса доступа к интервальным значениям позволяет эф-

фективно использовать разработанные классы в разнообразных теоретико-

игровых задачах.

Все исходные данные теоретико-игровой модели имеют числовую при-

роду и выражены некоторым точным значением. Зачастую, информации как

о выигрыше защитника, так и о выигрыше защищающегося бывает недо-

статочно для построения точной модели. Во многих ситуациях нет ни ин-

формации о точных значениях, ни о приблизительном законе распределения

этих значений. Поэтому, целесообразно использовать формализацию возни-

кающей неопределённости в виде интервалов. Для других подходов к опи-

санию неопределённости может не быть необходимой информации.

Тематические алгоритмы вычислений в условиях неопределённости ра-

ботают только для конкретной теоретико-игровой модели и не позволяют

перенести их результаты на другие случаи. Рассмотренный подход обла-

дает определённой универсальностью и может быть применен для разных

задач и моделей без необходимости их перестройки. Проверка разработан-

ных методов анализа теоретико-игровых моделей на ряде примеров по-

казала возможность прикладного использования разработанной методики.

Предложеный подход к решению задачи распределения ресурсов в условиях

неопределённости позволяет учитывать неопределённость практически лю-

бых исходных данных и производить как интервальную, так и дискретную

оценку распределения доступных ресурсов между объектами безопасности.

60

Сравнительный анализ предложенных подходов подтвердил эффективность

аффинной арифметики для интервальной оценки в условиях неточности

исходных данных. К преимуществам классического интервального анали-

за можно отнести сравнительно высокую скорость выполнения.

Благодаря применению интервального подхода появилась возможность

делать более обоснованные выводы о минимально необходимом числе ре-

сурсов, необходимых для защиты целей, а так же о максимальном числе

ресурсов, сверх которого прироста выигрыша для защищающегося боль-

ше нет. Последний тезис подтвержден примерами расчетов для различных

задач обеспечения безопасности в рамках теоретико-игровых моделей.

61

Список рисунков

3.1 Обобщённый интерфейс объектов . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283.2 Интерфейс для взаимодействия с объектами, интерпретирую-

щие инервальное значение. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293.3 Класс Interval . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303.4 Класс AffineForm. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313.5 Сравнение интервальных вычислений: простая функция 1. . . . . 403.6 Сравнение интервальных вычислений: простая функция 2. . . . . 413.7 Сравнение интервальных вычислений: сложная функция 1. . . . . 413.8 Сравнение интервальных вычислений: сложная функция 2. . . . . 423.9 Сравнение интервальных вычислений: сложная функция 3. . . . . 43

4.1 Распределение ресурсов для m=[2,3] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 474.2 Распределение ресурсов для m=[3,4] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484.3 Выигрыш защитника при различных значениях количества

доступных ресурсов . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 494.4 Распределение ресурсов, сравнение Монте-Карло и Аффин-

ной арифметики . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 504.5 Зависимость скорости работы алгоритмов от количества ис-

ходных целей . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 514.6 Оценка скорости работы ISG алгоритма . . . . . . . . . . . . . . . . . . . . . . . . . . . 524.7 Необходимое количество ресурсов для достижения заданных

значений выигрыша защитника. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 544.8 Выигрышы атакующего для набора целей при различном

уровне неопределённости исходных данных. . . . . . . . . . . . . . . . . . . . . . 554.9 Зависимость интервалов необходимого количества ресурсов

для достижения заданного выигрыша защищающегося . . . . . . . . . 564.10 Зависимость выигрыша защитника от уровня неопределённо-

сти в условиях огнариченных ресурсов. . . . . . . . . . . . . . . . . . . . . . . . . . . . 574.11 Оценка интервальных результатов. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58Б.1 UML диаграмма классов для интервальных вычислений . . . . . . . 94

62

Список литературы

1. Pita J. et al. Deployed ARMOR protection: the application of a game theoretic

model for security at the Los Angeles International Airport //Proceedings of

the 7th international joint conference on Autonomous agents and multiagent

systems: industrial track. – International Foundation for Autonomous Agents

and Multiagent Systems, 2008. – С. 125-132. .

2. Shieh E. et al. PROTECT: A deployed game theoretic system to protect the

ports of the United States //Proceedings of the 11th International Conference

on Autonomous Agents and Multiagent Systems-Volume 1. – International

Foundation for Autonomous Agents and Multiagent Systems, 2012. – pp. 13-20.

3. Sunaga T. Theory of an interval algebra and its application to numerical

analysis //Japan Journal of Industrial and Applied Mathematics. – 2009. – Т.

26. – . 2. – С. 125-143..

4. Nguyen K. C., Alpcan T., Basar T. Security games with incomplete

information //Communications, 2009. ICC’09. IEEE International Conference

on. – IEEE, 2009. – С. 1-6. .

5. Alpcan T., Basar T. A game theoretic approach to decision and analysis in

network intrusion detection //Decision and Control, 2003. Proceedings. 42nd

IEEE Conference on. – IEEE, 2003. – Т. 3. – С. 2595-2600..

6. Kiekintveld C., Islam T., Kreinovich V. Security games with interval

uncertainty //Proceedings of the 2013 international conference on Autonomous

agents and multi-agent systems. – International Foundation for Autonomous

Agents and Multiagent Systems, 2013. – С. 231-238..

7. Kiekintveld C., Marecki J., Tambe M. Approximation methods for infinite

bayesian stackelberg games: Modeling distributional payoff uncertainty //The

10th International Conference on Autonomous Agents and Multiagent Systems-

Volume 3. – International Foundation for Autonomous Agents and Multiagent

Systems, 2011. – С. 1005-1012.

8. Kiekintveld C. et al. Computing optimal randomized resource allocations for

massive security games //Proceedings of The 8th International Conference

63

on Autonomous Agents and Multiagent Systems-Volume 1. – International

Foundation for Autonomous Agents and Multiagent Systems, 2009. – С. 689-

696.

9. Brown M. et al. Multi-objective optimization for security games //Proceedings

of the 11th International Conference on Autonomous Agents and Multiagent

Systems-Volume 2. – International Foundation for Autonomous Agents and

Multiagent Systems, 2012. – С. 863-870.

10. Петросян Л. А., Зенкевич Н. А., Семина Е. А. Теория игр: Учебное посо-

бие для университетов //М.: Высшая школа. – 1998.

11. Paruchuri P. et al. Playing games for security: an efficient exact algorithm

for solving Bayesian Stackelberg games //Proceedings of the 7th international

joint conference on Autonomous agents and multiagent systems-Volume 2.

– International Foundation for Autonomous Agents and Multiagent Systems,

2008. – С. 895-902.

12. Kearns M. J., Ortiz L. E. Algorithms for Interdependent Security Games

//NIPS. – 2003.

13. Grossklags J., Christin N., Chuang J. Secure or insure?: a game-theoretic

analysis of information security games //Proceedings of the 17th international

conference on World Wide Web. – ACM, 2008. – С. 209-218.

14. Johnson B. et al. Uncertainty in interdependent security games //Decision

and Game Theory for Security. – Springer Berlin Heidelberg, 2010. – С. 234-

244.

15. An B. et al. Guards and protect: Next generation applications of security

games //ACM SIGecom Exchanges. – 2011. – Т. 10. – . 1. – С. 31-34.

16. M. Simaan and J.B. Cruz, Jr. On the Stackelberg Strategy in Nonzero-Sum

Games, Journal of Optimization Theory and Applications, Vol. 11, No. 5, May

1973, pp. 533-555

17. Шагин, В. Л. Теория игр с экономическими приложениями. Учебное

пособие. — М., ГУ-ВШЭ, 2003.

64

18. Корепанов В. О., Шумов В. В. Распределение пограничных ресурсов с

использованием равновесия Штакельберга //электронное научное издание

альманах пространство и время. – 2013. – Т. 3. – . 1.

19. Шарый С. П. Конечномерный интервальный анализ //Новосибирск: Из-

дательство «XYZ. – 2010.

20. Hansen E. R. Computing zeros of functions using generalized interval

arithmetic //Interval Computations. – 1993. – Т. 3. – С. 3-28.

21. Stolfi J., De Figueiredo L. H. An introduction to affine arithmetic. – 2003.

22. Ахмеров Р. Р. Использование аффинной арифметики для внутреннего

оценивания областей значений функций //Современные проблемы приклад-

ной математики и механики: теория, эксперимент и практика. Между-

народная конференция, посвященная. – 2001.

65

КОД ПРОГРАММНОГО ПРОДУКТА

А.1 Классы для представления теоретико-игровой модели

1 classdef GameModel2 %Класс для репрезентации теоретикоигровой- модели.3 properties4 targets %Набор целей5 defenderCoveredPayoffs %Выигрыш защитника для защищённой цели6 defenderUncoveredPayoffs %Выигрыш защитника для незащищённой

цели7 attackerCoveredPayoffs %Выигрыш атакующего для защищённой цели8 attackerUncoveredPayoffs %Выигрыш атакующего для незащищённой

цели9 coverageVector %Вектор покрытия целей

10 resources %Количество ресурсов11 info %Дополнительная информация12 end13

14 methods15

16 %Конструктор класса17 function model=GameModel(arg)18 if nargin==119 val_class=class(arg);20 %Создание объекта на базе данных из SecurityObject21 if strcmp(val_class,SecurityObject)22 model.info=arg.info;23 model=model.addTargets(arg.targets);24 for i=1:length(model.targets)25 model.coverageVector=[model.coverageVector,

Interval(0,0)];26 end27 return;28 end29 %Загрузка данных из файла30 if strcmp(val_class,char)31 so=load(arg);32 model.info=so.info;33 model=model.addTargets(so.targets);34 for i=1:length(model.targets)35 model.coverageVector=[model.coverageVector,

Interval(0,0)];36 end37 return;38 end39 %Генерация случайной теоретикоигровой- модели заданного

размера40 if strcmp(val_class,double)

66

41 if arg==042 model.targets=Target.empty;43 model.defenderCoveredPayoffs= Interval.empty;44 model.defenderUncoveredPayoffs=Interval.empty;45 model.attackerCoveredPayoffs=Interval.empty;46 model.attackerUncoveredPayoffs=Interval.empty;47 model.coverageVector=Interval.empty;48 return;49 end50 mod= generateRandomModel(model,arg);51 model.targets=mod.targets;52 model.defenderCoveredPayoffs= mod.

defenderCoveredPayoffs;53 model.defenderUncoveredPayoffs=mod.

defenderUncoveredPayoffs;54 model.attackerCoveredPayoffs=mod.

attackerCoveredPayoffs;55 model.attackerUncoveredPayoffs=mod.

attackerUncoveredPayoffs;56 model.coverageVector=mod.coverageVector;57 return;58 end59 return;60 end61

62 %Генерация случайной теоретикоигровой- модели размером в 20целей.

63 if nargin == 064 mod= generateRandomModel(model,20);65 model.targets=mod.targets;66 model.defenderCoveredPayoffs= mod.defenderCoveredPayoffs;67 model.defenderUncoveredPayoffs=mod.defenderUncoveredPayoffs

;68 model.attackerCoveredPayoffs=mod.attackerCoveredPayoffs;69 model.attackerUncoveredPayoffs=mod.attackerUncoveredPayoffs

;70 model.coverageVector=mod.coverageVector;71 return72 end73 end74

75 %Добавление целей в модель76 function obj=addTargets(obj,targets)77 obj.targets=targets;78 for i=1:length(targets)79 target=targets(i);80 obj.defenderCoveredPayoffs= [obj.defenderCoveredPayoffs,

Interval(target.defenderCoveredPayoff)];81 obj.defenderUncoveredPayoffs=[obj.defenderUncoveredPayoffs,

Interval(target.defenderUncoveredPayoff)];82 obj.attackerCoveredPayoffs=[obj.attackerCoveredPayoffs,

Interval(target.attackerCoveredPayoff)];83 obj.attackerUncoveredPayoffs=[obj.attackerUncoveredPayoffs,

Interval(target.attackerUncoveredPayoff)];84 end85 end86

87 %Генерация случайной модели заданного размера

67

88 function model=generateRandomModel(obj,N)89 uncertaintyLevel=0.3;90 Ud1=-rand(1,N)*100;91 Ud2=-rand(1,N)*100;92

93 Ucd=max(Ud1(1,:),Ud2(1,:));94 Uud=min(Ud1(1,:),Ud2(1,:));95

96

97 Ua1=rand(1,N)*50;98 Ua2=rand(1,N)*50;99

100 Uca=max(Ua1(1,:),Ua2(1,:));101 Uua=min(Ua1(1,:),Ua2(1,:));102

103 Dist=Uca-Uua;104

105 uncertaintyCoef=Dist*uncertaintyLevel;106

107 uncertU=rand(1,N).*uncertaintyCoef;108 uncertC=rand(1,N).*uncertaintyCoef;109

110

111 UuaMax=Uua+uncertU+50;112 UuaMin=Uua-uncertU+50;113

114 UcaMax=Uca+uncertC+50;115 UcaMin=Uca-uncertC+50;116

117 model.targets=1:N;118

119

120 for i=1:N121 model.defenderCoveredPayoffs(i)=Interval(Ucd(i),Ucd(i),

strcat(edc,num2str(i)));122 model.defenderUncoveredPayoffs(i)=Interval(Uud(i),Uud(i),

strcat(edu,num2str(i)));123 model.attackerCoveredPayoffs(i)=Interval(UcaMin(i),UcaMax(i),

strcat(eac,num2str(i)));124 model.attackerUncoveredPayoffs(i)=Interval(UuaMin(i),UuaMax(i

), strcat(eau,num2str(i)));125 model.coverageVector(i)=Interval(0,0,strcat(cov,num2str(i)));126 end127

128

129

130 end131

132

133

134 %Подготовка данных для ISG алгоритма135 function isg_model = prepareForIsg(model)136 isg_model.targets=model.targets;137 isg_model.Uud =Utils.convertToArray(model.defenderUncoveredPayoffs,

min);138 isg_model.Ucd =Utils.convertToArray(model.defenderCoveredPayoffs,

min);

68

139 isg_model.UuaMin=Utils.convertToArray(model.attackerUncoveredPayoffs,min);

140 isg_model.UuaMax=Utils.convertToArray(model.attackerUncoveredPayoffs,max);

141 isg_model.UcaMin=Utils.convertToArray(model.attackerCoveredPayoffs,min);

142 isg_model.UcaMax=Utils.convertToArray(model.attackerCoveredPayoffs,max);

143 isg_model.coverageVector=zeros(1,length(model.targets));144 end145

146 %Подготовка данных для интервальных вычислений147 function interval_sg_model=prepareForIntervalSg(model)148 interval_sg_model.targets=model.targets;149 interval_sg_model.Uud =model.defenderUncoveredPayoffs;150 interval_sg_model.Ucd=model.defenderCoveredPayoffs;151 interval_sg_model.Uua=model.attackerUncoveredPayoffs;152 interval_sg_model.Uca=model.attackerCoveredPayoffs;153 interval_sg_model.coverageVector=model.coverageVector;154 end155

156 %Подготовка для SG алгоритма157 function doted_model = prepareForDeterm(model)158 doted_model=prepare(model,@mean);159 end160 %Подготовка для алгоритма МонтеКарло-161 function monte_model = prepareForMonte(model)162 monte_model=prepare(model, @MonteCarloInter);163 end164

165 %Подготовка для Аффинной арифметики166 function affine_model = prepareForAffine(model)167 affine_model=prepare(model, @AffineForm);168 end169

170 %Функция для подготовки данных по заданной функции171 function prepared_model=prepare(model, funct)172 prepared_model.targets=model.targets;173 prepared_model.Uud=Utils.foreach(funct,model.defenderUncoveredPayoffs

);174 prepared_model.Ucd=Utils.foreach(funct,model.defenderCoveredPayoffs

);175 prepared_model.Uua=Utils.foreach(funct,model.attackerUncoveredPayoffs

);176 prepared_model.Uca=Utils.foreach(funct,model.attackerCoveredPayoffs);177 prepared_model.coverageVector=Utils.foreach(funct,model.

coverageVector);178 end179

180

181 end182

183 end

1 classdef Target2 %Класс для представления цели, объекта защиты защищающегося.

69

3

4 properties5 defenderCoveredPayoff %% Выигрыш защитника для защищённой цели6 defenderUncoveredPayoff %% Выигрыш защитника для незащищённой цели7 attackerCoveredPayoff %% Выигрыш атакующего для защищённой цели8 attackerUncoveredPayoff %% Выигрыш атакующего для незащищённой цели9 info %% Дополнительная информация

10 end11

12 methods13

14 %Конструктор класса15 function trgt=Target(defPCov,defPUnc,atPCov, atPUnc, info)16 trgt.defenderCoveredPayoff=defPCov;17 trgt.defenderUncoveredPayoff=defPUnc;18 trgt.attackerCoveredPayoff=atPCov;19 trgt.attackerUncoveredPayoff=atPUnc;20 trgt.info=info;21 end22 end23

24 end

1 classdef SecurityObject2 %Класс для хранения данных о объекте безопасности3 properties4 info %Общая информация5 targets %Набор целей объекты( защиты).6

7 end8

9 methods10

11 %Конструктор класса12 function so=SecurityObject(info, targets)13 %Создаем пустой экземпляр класса14 if nargin==015 so.gameInfo=;16 so.targets=Target.empty;17 return18 end19

20 %Создаём объект с текстовым описанием21 if nargin==122 so.info=info;23 so.targets=Target.empty;24 end25

26 %Создаём объект с текстовым описанием и набором целей27 if nargin==228 so.info=info;29 so.targets=targets;30 end31 end32

33 %Функция для добавления целей.

70

34 function obj=addTargets(obj,t)35 obj.targets=[obj.targets,t];36 end37 end38

39 end

А.2 Классы для работы с интервальными значениями

1 classdef Interval2 %Класс для интервальных вычислений3

4 properties5 imin % Нижняя граница интервального значения6 imax % Верхняя граница интервального значения7 name % Описание8 end9

10 methods11

12 %Конструктор класса13 function interval=Interval(imin, imax, name)14 if nargin==015 return16 end17 if nargin==118 %Создание вырожденного интервала из числа19 if strcmp(class(imin),double)20 interval.imin=imin;21 interval.imax=imin;22 return23 end24 %Возвращаем интервал, если на вход подан интервал25 if strcmp(class(imin),Interval)26 interval=imin;27 return28 end29 end30

31 %Создаём интервал с заданными границами32 if nargin==233 interval.imin=imin;34 interval.imax=imax;35 return36 end37

38 %Создаём интервал с заданными границами и описанием39 if nargin==340 interval.imin=imin;41 interval.imax=imax;42 interval.name=name;43 return44 end

71

45 end46

47 %Середина интервала48 function r=mean(obj)49 r=(obj.imin+obj.imax)/2;50 end51

52 %Радиус интервала53 function r=radius(obj)54 r=(obj.imax-obj.imin)/2;55 end56

57 %Нижняя граница58 function res=lowBound(obj)59 res=obj.imin;60 end61 %Верхняя граница62 function res=hiBound(obj)63 res=obj.imax;64 end65

66 %Сложение интервалов67 function r=plus(X,Y)68 X=Interval.prepare(X);69 Y=Interval.prepare(Y);70 a=X.imin;b=X.imax; c=Y.imin; d=Y.imax;71 r=Interval(a+c,b+d);72 end73

74 %Вычитание интервалов75 function r=minus(X,Y)76 X=Interval.prepare(X);77 Y=Interval.prepare(Y);78 a=X.imin;b=X.imax; c=Y.imin; d=Y.imax;79 r=Interval(a-d,b-c);80 end81

82 %Умножение интервалов83 function r=mtimes(X,Y)84 X=Interval.prepare(X);85 Y=Interval.prepare(Y);86 a=X.imin;b=X.imax; c=Y.imin; d=Y.imax;87 r=Interval(min([a*c,a*d,b*c,b*d]),max([a*c,a*d,b*c,b*d]));88

89 end90

91 %Деление интервалов92 function r=mrdivide(X,Y)93 X=Interval.prepare(X);94 Y=Interval.prepare(Y);95 a=X.imin;b=X.imax; c=Y.imin; d=Y.imax;96 r=Interval(min([a/c,a/d,b/c,b/d]),max([a/c,a/d,b/c,b/d]));97 end98

99 %Определение максимального значения из двух интервалов100 function r=max(X,Y)101 X=Interval.prepare(X);102 Y=Interval.prepare(Y);

72

103 if(X>=Y)104 r=X;105 return;106 end107 if(X<=Y)108 r=Y;109 return;110 end111 a=X.imin;b=X.imax; c=Y.imin; d=Y.imax;112 r=Interval(max(a,c), max(b,d));113 end114

115 %Определение минимального значения из двух интервалов116 function r=min(X,Y)117 X=Interval.prepare(X);118 Y=Interval.prepare(Y);119 if(X>=Y)120 r=Y;121 return;122 end123 if(X<=Y)124 r=X;125 return;126 end127

128 X=Interval.prepare(X);129 Y=Interval.prepare(Y);130 a=X.imin;b=X.imax; c=Y.imin; d=Y.imax;131 r=Interval(min(a,c), min(b,d));132 end133

134 %Сравнение интервалов: <135 function C=lt(X,Y)136 X=Interval.prepare(X);137 Y=Interval.prepare(Y);138 a=X.imin;b=X.imax; c=Y.imin; d=Y.imax;139 if b<c140 C=1;141 return;142 end143 C=0;144 end145 %Сравнение интервалов: >146 function C=gt(X,Y)147 X=Interval.prepare(X);148 Y=Interval.prepare(Y);149 a=X.imin;b=X.imax; c=Y.imin; d=Y.imax;150 if a>d151 C=1;152 return;153 end154 C=0;155 end156

157 %Сравнение интервалов: <=158 function C=le(X,Y)159 X=Interval.prepare(X);160 Y=Interval.prepare(Y);

73

161 a=X.imin;b=X.imax; c=Y.imin; d=Y.imax;162 if b<=c163 C=1;164 return;165 end166 C=0;167 end168

169 %Сравнение интервалов: >=170 function C=ge(X,Y)171 X=Interval.prepare(X);172 Y=Interval.prepare(Y);173 a=X.imin;b=X.imax; c=Y.imin; d=Y.imax;174 if a>=d175 C=1;176 return;177 end178 C=0;179 end180

181 %Функция для получения середины интервального значения182 function res=midPoint(obj)183 res=(obj.imax+obj.imin)/2;184 end185

186

187 %Конвертация в аффинную форму188 function affine=convertToAffine(int)189 affine=AffineForm(int);190 end191

192 %Конвертация в интервал193 function inter=convertToInterval(obj)194 inter=obj;195 inter.name=inter;196 end197

198 end199

200

201 methods (Static)202

203 %Функция для конвертации в массив значений204 function arr=convertToArray(intArray, mode)205

206 if nargin==0207 return208 end209 if nargin==1210 mode=min;211 end212 val_class=class(intArray);213 if strcmp(val_class,double)214 arr=intArray;215 return;216 end217 size=length(intArray);218 arr=zeros(1,size);

74

219 for i=1:size220 if(strcmp(mode,min)==1)221 arr(i)=intArray(i).imin;222 else223 arr(i)=intArray(i).imax;224 end225 end226 end227

228 %Нахождение минимального значения из массива интервалов229 function ret=minValue(intArray)230 val_class=class(intArray);231 if strcmp(val_class,Interval)232 arr=Interval.convertToArray(intArray,min);233 ret=min(arr);234 end235

236 end237

238 %Конвертация в интервальное значение различных данных239 function inter=prepare(value)240 val_class=class(value);241 if strcmp(val_class,Interval)242 inter=value;243 return244 end245 if strcmp(val_class,MonteCarloInter)246 inter=value.convertToInterval;247 return248 end249 if strcmp(val_class,double)250 inter=Interval(value, value, num2str(value));251 return252 end253 if strcmp(val_class,AffineForm)254 inter=value.convertToInterval;255 return256 end257

258

259 end260

261

262 end263

264

265 end

1 classdef AffineForm2 %Класс для аффинных вычислений3

4 properties5 mean %Середина аффинной формы6 values %Массив значений7 variables %Массив индексов вещественных переменных8 end

75

9

10 properties ( Constant )11 var_index = 0; %Начальный индекс для вещественных переменных12 end13

14 methods15

16 %Конструктор класса17 function affineForm=AffineForm(value)18 %Создание пустой аффинной формы19 if nargin==020 affineForm.mean=0;21 affineForm.values=[];22 affineForm.variables=[];23 return;24 end25 val_class=class(value);26 if strcmp(val_class,AffineForm)27 affineForm=value;28 return29 end30 %Конвертация интервала в аффинную форму31 if strcmp(val_class,Interval)32 affineForm.mean=(value.imax+value.imin)/2;33 affineForm.values=(value.imax-value.imin)/2;34 affineForm.variables=AffineForm.getNewVarName();35

36 return37 end38 %Конвертация числового значения в аффинную форму39 if strcmp(val_class,double)40 affineForm.mean=value;41 affineForm.values=[];42 affineForm.variables=[];43 return44 end45 affineForm.mean=0;46 affineForm.values=[];47 affineForm.variables=[];48 end49

50 %Нахождение середины аффинной формы51 function res=midPoint(obj)52 res=obj.mean;53 end54

55 %Нижняя граница аффинной формы56 function res=lowBound(obj)57 inter=obj.convertToInterval;58 res=inter.imin;59 end60 %Верхняя граница аффинной формы61 function res=hiBound(obj)62 inter=obj.convertToInterval;63 res=inter.imax;64 end65 %Радиус аффинной формы66 function r=radius(obj)

76

67 inter=obj.convertToInterval;68 r=(inter.imax-inter.imin)/2;69 end70

71 %Слияние аффинных форм72 function r=merge(X,Y,funct)73 if isempty(X)74 X=AffineForm(0);75 end76 if isempty(Y)77 Y=AffineForm(0);78 end79 X=AffineForm(X);Y=AffineForm(Y);80 xSize=length(X.variables);81 ySize=length(Y.variables);82 if(xSize~=length(X.values))83 if isempty(X.values)84 X.values=0;85 end86 end87 if(ySize~=length(Y.values))88 if isempty(Y.values)89 Y.values=0;90 end91 end92 valSize=xSize+ySize;93 r=AffineForm(funct(X.mean,Y.mean));94 xCount=1;95 yCount=1;96 for i=1:valSize97 if(xCount>xSize)98 r.variables=[r.variables, Y.variables(yCount:end)];99 r.values=[r.values, Y.values(yCount:end)];

100 return101 end102 if(yCount>ySize)103 r.variables=[r.variables, X.variables(xCount:end)];104 r.values=[r.values, X.values(xCount:end)];105 return106 end107

108 if(X.variables(xCount)<Y.variables(yCount))109 r.variables(i)=X.variables(xCount);110 r.values(i)=X.values(xCount);111 xCount=xCount+1;112 continue113 end114 if(Y.variables(yCount)<X.variables(xCount))115

116 r.variables(i)=Y.variables(yCount);117 r.values(i)=Y.values(yCount);118 yCount=yCount+1;119 continue120 end121 if(Y.variables(yCount)==X.variables(xCount))122 r.variables(i)=X.variables(xCount);123 r.values(i)=funct(X.values(xCount),Y.values(yCount));124 xCount=xCount+1;

77

125 yCount=yCount+1;126 continue127 end128 end129 end130

131 %Операция сложения132 function r=plus(X,Y)133 r=merge(X,Y,@plus);134 end135 %Операция вычитания136 function r=minus(X,Y)137 r=merge(X,Y,@minus);138 end139 %Умножение аффинных форм140 function r=mtimes(X,Y)141 X=AffineForm(X);Y=AffineForm(Y);142 if isempty(X)143 X=AffineForm(0);144 end145 if isempty(Y)146 Y=AffineForm(0);147 end148 xSize=length(X.variables);149 ySize=length(Y.variables);150 valSize=xSize+ySize;151 r=AffineForm(X.mean*Y.mean);152 newVariables=[];153 newValues=[];154 for i=1:xSize155 for j=1:ySize156 newVariables(i+j-1)=AffineForm.getNewVarName();157 newValues(i+j-1)=X.values(i)*Y.values(j);158 end159 end160 tX=X;161 tX.values=X.values.*Y.mean;162 tY=Y;163 tY.values=Y.values.*X.mean;164 tZ=tX+tY;165 r.variables=[tZ.variables, newVariables];166 r.values =[tZ.values, newValues];167

168 r=AffineForm.sortVariables(r);169 end170 %Деление аффинных форм171 function r=mrdivide(X,Y)172 X=AffineForm(X);Y=AffineForm(Y);173 r=X*inv(Y);174 end175 %Инверсия (1/x) аффинной формы176 function affine=inv(X)177 X=AffineForm(X);178 xInterval=X.convertToInterval();179 a=xInterval.imin;180 b=xInterval.imax;181

182 t1=abs(a);

78

183 t2=abs(b);184

185 a=min(t1, t2);186 b=max(t1, t2);187

188 alpha=-1/(b*b);189 l = (1/a)-alpha*a;190 h = 2/b;191 t1=abs(l);192 t2=abs(h);193 tmp=Interval(min(t1, t2),max(t1, t2));194 radius=tmp.radius;195 dzeta=tmp.mean;196 if X.convertToInterval.imin<0197 dzeta=-dzeta;198 end199 affine=AffineForm.addApproximationError(X,alpha,dzeta,radius);200 end201

202 %Нахождение максимума из двух аффинных форм203 function r=max(X,Y)204 X=AffineForm(X);Y=AffineForm(Y);205 iX=X.convertToInterval(first);206 iY=Y.convertToInterval(second);207 iMax=max(iX,iY);208 if strcmp(iMax.name,iX.name)209 r=X;210 return211 end212 if strcmp(iMax.name,iY.name)213 r=Y;214 return215 end216 r=AffineForm(iMax);217 end218 %Нахождение минимума из двух аффинных форм219 function r=min(X,Y)220 X=AffineForm(X);Y=AffineForm(Y);221 iX=X.convertToInterval(first);222 iY=Y.convertToInterval(second);223 iMax=min(iX,iY);224 if strcmp(iMax.name,iX.name)225 r=X;226 return227 end228 if strcmp(iMax.name,iY.name)229 r=Y;230 return231 end232 r=AffineForm(iMax);233 end234

235

236 %Сравнение аффинных форм: <237 function C=lt(X,Y)238 X=AffineForm(X);Y=AffineForm(Y);239 iX=X.convertToInterval(first);240 iY=Y.convertToInterval(second);

79

241 C=lt(iX,iY);242 end243 %Сравнение аффинных форм: >244 function C=gt(X,Y)245 X=AffineForm(X);Y=AffineForm(Y);246 iX=X.convertToInterval(first);247 iY=Y.convertToInterval(second);248 C=gt(iX,iY);249 end250 %Сравнение аффинных форм: <=251 function C=le(X,Y)252 X=AffineForm(X);Y=AffineForm(Y);253 iX=X.convertToInterval(first);254 iY=Y.convertToInterval(second);255 C=le(iX,iY);256 end257 %Сравнение аффинных форм: >=258 function C=ge(X,Y)259 X=AffineForm(X);Y=AffineForm(Y);260 iX=X.convertToInterval(first);261 iY=Y.convertToInterval(second);262 C=ge(iX,iY);263 end264 %Конвертация в интервал265 function interval=convertToInterval(obj,name)266 if nargin==1 % Used when objects are loaded from disk267 name=affine;268 end269 sumArr=sum(abs(obj.values));270 interval=Interval(obj.mean-sumArr,obj.mean+sumArr, name);271 end272

273 %Конвертация в аффинную форму интервалов и дискретных значений.274 function aff=prepareAffine(value)275 val_class=class(value);276 if strcmp(val_class,Interval)277 aff=AffineForm(value);278 return279 end280 if strcmp(val_class,double)281 aff=AffineForm(value);282 return283 end284 end285 %Отображение в консоли286 function display(obj)287 int=obj.convertToInterval;288 int289 end290 end291

292 methods (Static)293 %Получение индекса для новой вещественной переменной294 function var_name=getNewVarName()295 persistent p;296 if isempty(p)297 p=0;298 end

80

299 var_name=p;300 p=p+1;301 end302 %Сортировка массива индексов303 function affine=sortVariables(aff)304 affine=aff;305 values=affine.values;306 variables=affine.variables;307 if(isempty(values) || isempty(variables))308 return309 end310 sorted=sortrows([values;variables],2);311 affine.values=sorted(1,:);312 affine.variables=sorted(2,:);313 end314 %Добавление ошибки аппорксимации.315 function aff = addApproximationError(affine, aplha, dzeta, delta)316 aff=AffineForm();317 aff.mean=aplha*affine.mean+dzeta;318 aff.values=[affine.values*aplha,delta];319 aff.variables=[affine.variables,AffineForm.getNewVarName()];320 end321 end322

323 end

1 classdef MonteCarloInter2 %Класс для вычислений с помощью метода МонтеКарло-3 properties4 points %Массив значений5 end6

7 properties ( Constant )8 pointsSize=10000; %Количество точек9 end

10

11 methods12

13 %Конструктор класса.14 function monte=MonteCarloInter(value)15 if nargin==016 monte.points=[];17 return;18 end19 val_class=class(value);20 if strcmp(val_class,MonteCarloInter)21 monte=value;22 return23 end24 %Конвертация аффинной формы в класс монтекарло-25 if strcmp(val_class,AffineForm)26 monte=MonteCarloInter(value.convertToInterval);27 return28 end29 %Конвертация интервального значения в класс монтекарло-30 if strcmp(val_class,Interval)

81

31 diff=value.imax-value.imin;32 monte.points=rand(1,MonteCarloInter.pointsSize).*diff+

value.imin;33 return34 end35 %Конвертация дискретного значения в класс монтекарло-36 if strcmp(val_class,double)37 monte.points=ones(1,MonteCarloInter.pointsSize) * value;38 return39 end40

41 end42

43

44 %Операция сложения45 function r=plus(X,Y)46 r=MonteCarloInter();47 X=MonteCarloInter(X);Y=MonteCarloInter(Y);48 r.points=X.points+Y.points;49 end50 %Операция вычитания51 function r=minus(X,Y)52 r=MonteCarloInter();53 X=MonteCarloInter(X);Y=MonteCarloInter(Y);54 r.points=X.points-Y.points;55 end56 %Операция умножения57 function r=mtimes(X,Y)58 r=MonteCarloInter();59 X=MonteCarloInter(X);Y=MonteCarloInter(Y);60 r.points=X.points.*Y.points;61 end62 %Операция деления63 function r=mrdivide(X,Y)64 r=MonteCarloInter();65 X=MonteCarloInter(X);Y=MonteCarloInter(Y);66 r.points=X.points./Y.points;67 end68

69

70 %Нахождение максимального значения из двух интервалов71 function r=max(X,Y)72 r=MonteCarloInter();73 X=MonteCarloInter(X);Y=MonteCarloInter(Y);74 r.points=arrayfun(@max,X.points,Y.points);75 end76 %Нахождение минимального значения из двух интервалов77 function r=min(X,Y)78 r=MonteCarloInter();79 X=MonteCarloInter(X);Y=MonteCarloInter(Y);80 r.points=arrayfun(@min,X.points,Y.points);81 end82

83

84 %Сравнение интервалов: <85 function C=lt(X,Y)86 X=MonteCarloInter(X);Y=MonteCarloInter(Y);87 iX=X.convertToInterval(first);

82

88 iY=Y.convertToInterval(second);89 C=lt(iX,iY);90 end91 %Сравнение интервалов: >92 function C=gt(X,Y)93 X=MonteCarloInter(X);Y=MonteCarloInter(Y);94 iX=X.convertToInterval(first);95 iY=Y.convertToInterval(second);96 C=gt(iX,iY);97 end98 %Сравнение интервалов: <=99 function C=le(X,Y)

100 X=MonteCarloInter(X);Y=MonteCarloInter(Y);101 iX=X.convertToInterval(first);102 iY=Y.convertToInterval(second);103 C=le(iX,iY);104 end105 %Сравнение интервалов: >=106 function C=ge(X,Y)107 X=MonteCarloInter(X);Y=MonteCarloInter(Y);108 iX=X.convertToInterval(first);109 iY=Y.convertToInterval(second);110 C=ge(iX,iY);111 end112 %Конвертация в интервал113 function interval=convertToInterval(obj,name)114 interval=Interval(obj.lowBound, obj.hiBound,monte);115 end116 %Верхняя граница117 function res = hiBound(obj)118 res=max(obj.points);119 end120 %Нижняя граница121 function res = lowBound(obj)122 res=min(obj.points);123 end124 %Середина интервала125 function res = midPoint(obj)126 res=median(obj.points);127 end128 %Радиус интервала129 function res = radius(obj)130 hi=obj.hiBound;131 lo=obj.lowBound;132 res=(hi-lo)/2;133 end134 %Отображение интервала135 function display(obj)136 int=obj.convertToInterval;137 int138 end139

140 end141

142 methods (Static)143

144 end145

83

146 end

А.3 Алгоритмы для решения теоретико-игровых задач

1 %Алгоритм ISG: поиск распределения ресурсов в условиях ограниченных2 %ресурсов.3 function [finalC, finalPayoff, finCov] = calcISG(gameModel, m)4 finCov=m;5 targets=gameModel.targets; %Цели6 Uud =gameModel.Uud; %Выигрыш защитника для незащищённой цели7 Ucd =gameModel.Ucd; %Выигрыш защитника для защищённой цели8 UuaMin =gameModel.UuaMin; %Нижняя граница выигрыша атакующего для

незащищённой цели9 UuaMax =gameModel.UuaMax; %Верхняя граница выигрыша атакующего для

незащищённой цели10 UcaMin =gameModel.UcaMin; %Нижняя граница выигрыша атакующего для

защищённой цели11 UcaMax =gameModel.UcaMax; %Верхняя граница выигрыша атакующего для

защищённой цели12 Tsize=length(targets); %Количество целей13 C=zeros(Tsize,1);14 maxPayoff=max(Ucd); %Максимальный возможный выигрыш защитника15 minPayoff=min(Uud); %Минимальный возможный выигрыш защитника16 e=0.1; %Допустимая ошибка алгоритма дихитомии17 while (maxPayoff-minPayoff)>e18 midPoint=maxPayoff+(minPayoff-maxPayoff)/2; %Вычисляем центр

интервала19 [ret,C, totalCov]=feasibilityCheck(midPoint,m,C); %Проверяем

достижимость этого значения20 if strcmp(ret,true) %В случае достижимости заданного

значения выигрыша21 minPayoff=midPoint; %Сужаем интервал поиска22 finalPayoff=midPoint; %Сохраняем полученное значение

выигрыша23 finalC=C; %Сохраняем полученное значение

покрытия24 finCov=totalCov; %Сохраняем полученное значение суммы

необходимых ресурсов25 else26 maxPayoff=midPoint; %Сужаем интервал поиска27 end28 end29

30 %Функция для нахождения распределения ресурсов для заданного31 %значения выигрыша защитника32 function [ret,C, finCov]=feasibilityCheck(midPoint,m,C)33 c1=zeros(1,Tsize);34 for t=1:Tsize35 %Оцениваем покрытие для каждой цели, необходимое для получения36 %заданного выигрыша37 c1(t)= get_c1(t);38 end39 %Рассматриваем каждую цель как потенциальную цель для атаки

84

40 for t=1:Tsize41 totalCov=c1(t);42 C(t)=c1(t);43 if C(t)>144 continue45 end46 %Получаем выигрыш атакующего для выбранной цели47 R=get_R(c1(t),t);48 %Рассматриваем остальные цели49 for tj=1:Tsize50 if(t==tj)51 continue52 end53 %Оцениваем количество ресурсов для смены приоритета атаки54 %на цель i.55 c2=get_c2(R,tj);56 c3=get_c3(R,tj);57 %Оцениваем минимальное покрытие для iй- цели.58 minCov=max([c3,min(c1(tj),c2)]);59 if minCov<0 || minCov>160 break61 end62 %Добавляем покрытие к сумме необходимых ресурсов.63 totalCov=totalCov+minCov;64 C(tj)=minCov;65 end66 %В случае если общее необходимое количество ресурсов не67 %превышает ограничение по ресурсам68 if (minCov>=0 && minCov<=1) && totalCov<=m69 %Возвращаем ответ70 ret=true;71 finCov=totalCov;72 return73 end74 end75 finCov=m;76 ret=false;77 return78

79

80 function c1=get_c1(t)81 cash=(midPoint-Uud(t))/(Ucd(t)-Uud(t));82 c1=max([0,cash]);83 end84 function c2=get_c2(R,t)85 upBound=max(UuaMax(t),UcaMax(t));86 lowBound=min(UuaMax(t),UcaMax(t));87 if R<lowBound88 c2=2;89 return;90 end91

92 if R>upBound93 c2=0;94 return;95 end96 cash=(R-UuaMax(t))/(UcaMax(t)-UuaMax(t));97 c2=max([0,cash]);

85

98 end99 function c3=get_c3(R,t)

100 upBound=max(UuaMin(t),UcaMin(t));101 lowBound=min(UuaMin(t),UcaMin(t));102 if R<lowBound103 c3=2;104 return;105 end106

107 if R>upBound108 c3=0;109 return;110 end111 cash=(R-UuaMin(t))/(UcaMin(t)-UuaMin(t));112 c3=max([0,cash]);113 end114 function R=get_R(c1,t)115 R=(c1*UcaMin(t))+((1-c1)*UuaMin(t)-e);116 end117 end118 end

1 %Алгоритм SG: поиск распределения ресурсов в условиях ограниченных2 %ресурсов.3 function [finalC, finalPayoff, finalCov] = calcSG(gameModel, m)4 targets=gameModel.targets; %Цели5 Uud =gameModel.Uud; %Выигрыш защитника для незащищённой цели6 Ucd =gameModel.Ucd; %Выигрыш защитника для защищённой цели7 Uua =gameModel.Uua; %Выигрыш атакующего для незащищённой

цели8 Uca =gameModel.Uca; %Выигрыш атакующего для защищённой цели9 C =gameModel.coverageVector;

10

11 finalPayoff=0;12 finalC=[];13 e=0.1; %Допустимая ошибка алгоритма дихитомии14 Tsize=length(targets);15 maxPayoff=Utils.maxValue(Ucd); %Максимальный возможный выигрыш

защитника16 minPayoff=Utils.minValue(Uud); %Минимальный возможный выигрыш

защитника17 while (maxPayoff-minPayoff)>e18 midPoint=maxPayoff+(minPayoff-maxPayoff)/2; %Вычисляем центр

интервала19 [ret,C,totalCov]=feasibilityCheck(midPoint,m,C); %Проверяем

достижимость этого значения20 if strcmp(ret,true) %В случае достижимости заданного

значения выигрыша21 minPayoff=midPoint; %Сужаем интервал поиска22 finalPayoff=midPoint; %Сохраняем полученное значение

выигрыша23 finalC=C; %Сохраняем полученное значение

покрытия24 finalCov=totalCov; %Сохраняем полученное значение суммы

необходимых ресурсов25 else

86

26 maxPayoff=midPoint; %Сужаем интервал поиска27 end28 end29

30

31 %Функция для нахождения распределения ресурсов для заданного32 %значения выигрыша защитника33 function [ret,C, totalCov]=feasibilityCheck(midPoint,m,C)34 Tsize=length(C);35 e=0.1;36 totalCovs=[];37 for t=1:Tsize38 %Оцениваем покрытие для каждой цели, необходимое для получения39 %заданного выигрыша40 c1(t)= get_c1(t);41 end42 %Рассматриваем каждую цель как потенциальную цель для атаки43 for t=1:Tsize44 totalCov=c1(t);45 C(t)=c1(t);46 if C(t)>147 continue48 end49 %Получаем выигрыш атакующего для выбранной цели50 R=get_R(c1(t),t);51 %Рассматриваем остальные цели52 for tj=1:Tsize53 if(t==tj)54 continue55 end56 %Оцениваем количество ресурсов для смены приоритета атаки57 %на цель i.58 c2=get_c2(R,tj);59 %Оцениваем минимальное покрытие для iй- цели.60 minCov=min(c1(tj),c2);61 if Utils.ine(minCov,Interval(0,1))==0;62 break63 end64 %Добавляем покрытие к сумме необходимых ресурсов.65 totalCov=totalCov+minCov;66 C(tj)=minCov;67 end68 %В случае если общее необходимое количество ресурсов не69 %превышает ограничение по ресурсам70 if (Utils.ine(minCov,Interval(0,1))) && totalCov<=m71 %Возвращаем ответ72 ret=true;73 return74 end75 end76 ret=false;77 return78

79 function c1=get_c1(t)80 cash=(midPoint-Uud(t))/(Ucd(t)-Uud(t));81 c1=max(cash,0);82 end83 function c2=get_c2(R,t)

87

84 upBound=max(Uua(t),Uca(t));85 lowBound=min(Uua(t),Uca(t));86 if R<lowBound87 c2=2;88 return;89 end90

91 if R>upBound92 c2=0;93 return;94 end95 cash=(R-Uua(t))/(Uca(t)-Uua(t));96 c2=max(cash,0);97 end98 function R=get_R(c1,t)99 R=(c1*Uca(t))+((1-c1)*Uua(t)-e);

100 end101 end102 end

А.4 Класс для обработки интервальных значений

1 classdef Utils2 %Класс с набором функций для работы с интервальными значениями3

4 properties5

6 end7

8 methods9

10

11

12

13 end14

15 methods (Static)16 %Конвертация массива интервалов в массив дискретных чисел17 function arr=convertToArray(intArray, mode)18 if nargin==019 return20 end21 if nargin==122 mode=min;23 end24 size=length(intArray);25 arr=zeros(1,size);26 for i=1:size27 val_class=class(intArray(i));28 if strcmp(val_class,double)29 arr=intArray;30 return;31 end

88

32

33 if strcmp(val_class,Interval)34 if length(intArray(i).imin)~=length(arr(i))35 intArray(i)=Interval(0,0,);36 end37 if(strcmp(mode,min))38 arr(i)=intArray(i).imin;39 end40 if(strcmp(mode,max))41 arr(i)=intArray(i).imax;42 end43 if(strcmp(mode,middle))44 arr(i)=abs(intArray(i).imin+(intArray(i).imax-intArray(i).imin)

/2);45 end46 if(strcmp(mode,random))47 arr(i)=getRandomFromInterval(intArray(i));48 end49 end50

51 if strcmp(val_class,AffineForm)52 interv=intArray(i).convertToInterval;53 if length(interv.imin)~=length(arr(i))54 interv=Interval(0,0,);55 end56 if(strcmp(mode,min))57 arr(i)=interv.imin;58 end59 if(strcmp(mode,max))60 arr(i)=interv.imax;61 end62 if(strcmp(mode,random))63 arr(i)=Utils.getRandomFromInterval(interv);64 end65 end66 end67

68

69

70

71 end72

73 %Получение случайного значения из заданного интервала74 function ret=getRandomFromInterval(interval)75 size= length(interval.imin);76 diff=interval.imax-interval.imin;77 ret=rand(1,size).*diff+interval.imin;78 end79

80 %Получение минимального значения из массива интервалов81 function ret=minValue(intArray)82 ret=min(Utils.foreach(@lowBound,intArray));83 end84 %Получение максимального значения из массива интервалов85 function ret=maxValue(intArray)86 ret=max(Utils.foreach(@hiBound,intArray));87 end88 %Проверка принадлежности величины X интервалу Y

89

89 function C=in(X,Y)90 val_class=class(Y);91 if strcmp(val_class,Interval)92 X=Interval.prepare(X);93 if X.imax<Y.imax && X.imin>Y.imin94 C=1;95 return;96 end97 end98 C=0;99 end

100 %Проверка принадлежности величины X интервалу Y101 function C=ine(X,Y)102 val_class=class(Y);103 if strcmp(val_class,Interval)104 X=Interval.prepare(X);105 if X.imax<=Y.imax && X.imin>=Y.imin106 C=1;107 return;108 end109 end110 C=0;111 end112

113 %Конвертация массива интервалов в массив Аффинных форм114 function affineArr=convertToAffineArray(intArray)115 if nargin==0116 affineArr=[];117 return118 end119 size=length(intArray);120 affineArr=AffineForm.empty;121 for i=1:size122 affineArr(i)=AffineForm(intArray(i));123 end124 end125 %Конвертация массива интервалов в массив интервалов МонтеКарло-126 function affineArr=convertToMonteArray(intArray)127 if nargin==0128 affineArr=[];129 return130 end131 size=length(intArray);132 affineArr=MonteCarloInter.empty;133 for i=1:size134 affineArr(i)=MonteCarloInter(intArray(i));135 end136 end137

138 %Функция для применения заданной функции к каждому значению139 %массива интервальных значений140 function arr=foreach(funct,intArray)141 if nargin<=1142 arr=[];143 return144 end145 size=length(intArray);146 for i=1:size

90

147 arr(i)=funct(intArray(i));148 end149 end150 %Отображение массива интервальных значений151 function displayInt(intArray)152 size=length(intArray);153 for i=1:size154 intArray(i).display;155 end156 end157 %функция reduce158 function answer=reduce(funct, objectArray)159 arrSize=objectArray.length;160 first=objectArray(1);161 for i=2:arrSize162 second=objectArray(i);163 answer=funct(first,second);164 first=answer;165 end166 end167

168 %Функция для внесения неопределённости в интервальные значения.169 function newModel=setUncertainty(model, level, mod)170 if nargin==2171 mod=attacker;172 end173 newModel=GameModel(0);174 newModel.targets=model.targets;175 newModel.coverageVector=model.coverageVector;176 newModel.resources=model.resources;177 newModel.info=model.info;178 for j=1:length(model.targets)179 [covD, uncovD]=setLevel(model.defenderCoveredPayoffs(j),model.

defenderUncoveredPayoffs(j), level);180 [covA, uncovA]=setLevel(model.attackerCoveredPayoffs(j),model.

attackerUncoveredPayoffs(j), level);181 if strcmp(mod,attacker)182 newModel.attackerCoveredPayoffs=[newModel.

attackerCoveredPayoffs,covA];183 newModel.attackerUncoveredPayoffs=[newModel.

attackerUncoveredPayoffs,uncovA];184 newModel.defenderCoveredPayoffs=[newModel.

defenderCoveredPayoffs,model.defenderCoveredPayoffs(j)];185 newModel.defenderUncoveredPayoffs=[newModel.

defenderUncoveredPayoffs,model.defenderUncoveredPayoffs(j)];186 end187 if strcmp(mod,defender)188 newModel.attackerCoveredPayoffs=[newModel.

attackerCoveredPayoffs,model.attackerCoveredPayoffs(j)];189 newModel.attackerUncoveredPayoffs=[newModel.

attackerUncoveredPayoffs,model.attackerUncoveredPayoffs(j)];190 newModel.defenderCoveredPayoffs=[newModel.

defenderCoveredPayoffs,covD];191 newModel.defenderUncoveredPayoffs=[newModel.

defenderUncoveredPayoffs,uncovD];192 end193 if strcmp(mod,all)

91

194 newModel.attackerCoveredPayoffs=[newModel.attackerCoveredPayoffs,covA];

195 newModel.attackerUncoveredPayoffs=[newModel.attackerUncoveredPayoffs,uncovA];

196 newModel.defenderCoveredPayoffs=[newModel.defenderCoveredPayoffs,covD];

197 newModel.defenderUncoveredPayoffs=[newModel.defenderUncoveredPayoffs,uncovD];

198 end199 end200 return201

202 function [cov,uncov]=setLevel(covered, uncovered, level)203 diff=abs(covered.mean-uncovered.mean);204 cov=Interval(covered.mean-diff*level,covered.mean+diff*level);205 uncov=Interval(uncovered.mean-diff*level,uncovered.mean+diff*

level);206 end207 end208

209

210 end211

212

213 end

А.5 Дискретная оценка интервальных значений

1 %Функция для оценки дискретных значений заданного интервального2 %рапределения ресурсов.3 function [finalCarr,totalCov]=getDiscreteAnswer(gameModel, CovArr,

selectedTarget, defPayoff)4 finalCarr=[];5 sTCov=CovArr(selectedTarget);6 selectedTargetPayoff=sTCov*gameModel.Uca(selectedTarget).lowBound+(1-

sTCov)*gameModel.Uua(selectedTarget).lowBound;7 for i=1:length(CovArr)8 if i==selectedTarget9 finalCarr(i)=sTCov.hiBound;

10 continue;11 end12 minCov(i)=CovArr(i).lowBound;13 maxCov(i)=CovArr(i).hiBound;14 %Возможные значения выигрыша атакующего при минимальном значении15 %покрытия для заданной цели16 minCovAttPayoffMax(i)=minCov(i)*gameModel.Uca(i).hiBound+(1-minCov(i))*

gameModel.Uua(i).hiBound;17 minCovAttPayoffMin(i)=minCov(i)*gameModel.Uca(i).lowBound+(1-minCov(i))

*gameModel.Uua(i).lowBound;18 minCovAttPayoff=max(minCovAttPayoffMax(i),minCovAttPayoffMin(i));19 %Возможные значения выигрыша атакующего при максимальном значении20 %покрытия для заданной цели

92

21 maxCovAttPayoffMax(i)=maxCov(i)*gameModel.Uca(i).hiBound+(1-maxCov(i))*gameModel.Uua(i).hiBound;

22 maxCovAttPayoffMin(i)=maxCov(i)*gameModel.Uca(i).lowBound+(1-maxCov(i))*gameModel.Uua(i).lowBound;

23 maxCovAttPayoff=max(maxCovAttPayoffMax(i),maxCovAttPayoffMin(i));24 %Возможные значения выигрыша защищающегося25 selectedTargetDeffPayoffMin=minCov(i)*gameModel.Ucd(i).hiBound+(1-

minCov(i))*gameModel.Uud(i).hiBound;26 selectedTargetDeffPayoffMax=maxCov(i)*gameModel.Ucd(i).hiBound+(1-

maxCov(i))*gameModel.Uud(i).hiBound;27 %Выбор минимально возможного уровня покрытия28 if(defPayoff<=selectedTargetDeffPayoffMin || minCovAttPayoff<

selectedTargetPayoff)29 finalCarr(i)=CovArr(i).lowBound;30 continue;31 end32 if(defPayoff<=selectedTargetDeffPayoffMax || maxCovAttPayoff<

selectedTargetPayoff)33 finalCarr(i)=CovArr(i).hiBound;34 continue;35 end36

37 %Оценка покрытия в случае, если граничные значения покрытия для38 %цели не прошли отбор.39 getMinC1=(defPayoff-gameModel.Uud(i).lowBound)/(gameModel.Ucd(i).

lowBound-gameModel.Uud(i).lowBound);40 getMinC1=max(getMinC1,0);41 getMaxC1=(defPayoff-gameModel.Uud(i).hiBound)/(gameModel.Ucd(i).

hiBound-gameModel.Uud(i).hiBound);42 getMaxC1=max(getMaxC1,0);43 getMinC2=(selectedTargetPayoff-gameModel.Uua(i).lowBound)/(

gameModel.Uca(i).lowBound-gameModel.Uua(i).lowBound);44 getMinC2=max(getMinC2,0);45 getMaxC2=(selectedTargetPayoff-gameModel.Uua(i).hiBound)/(gameModel

.Uca(i).hiBound-gameModel.Uua(i).hiBound);46 getMaxC2=max(getMaxC2,0);47 fC=min(max(getMinC1,getMaxC1),max(getMinC2,getMaxC2));48 if isa(fC,Interval) || isa(fC,MonteCarloInter) || isa(fC,

AffineForm)49 fC=fC.hiBound;50 end51 if Utils.ine(fC,Interval(0,1))52 finalCarr(i)=fC;53 continue;54 end55 finalCarr(i)=intmax;56 end57

58 totalCov=sum(finalCarr);59 end

93

ДИАГРАММА КЛАССОВ ИНТЕРВАЛЬНЫХ ВЫЧИСЛЕНИЙ

Рису

нок

Б.1

:U

ML

диаг

рам

ма

клас

сов

для

инте

рвал

ьны

хвы

числ

ений

94