Введение

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

Поэтому знакомство со стратегиями, позволяющими избежать банкротство в условиях конкуренции, хотя бы на самом начальном уровне безусловно полезно. Кроме того, популярность Python растёт, и реализация задач экономической оптимизации на этом языке так же поспособствует их популярности.

Постановка задачи

Рассмотрим модель поведения на рынке двух конкурирующих фирм, выпускающих аналогичный товар в объемах х и у, пользующийся неограниченным спросом [1]. Построим следующие две функции для цены и издержек.

Листинг построения графиков функций цены и издержек

# -*- coding: utf8 -*-    
import numpy as np
import matplotlib.pyplot as plt
a=10
def f(q): Функция цены от объёма товара
         return a*np.e**(-0.5*q**2)
def h(q): #Функция издержек от объёма товара
         return np.sqrt(q)
plt.figure()
q= np.arange(0, 2.01, 0.1)#Массив значений аргумента
plt.title(r'$y=f(q)$') #Заголовок в формате TeX
plt.ylabel(r'$f(q)$') #Метка по оси y в формате TeX
plt.xlabel(r'$q$') #Метка по оси x в формате TeX
plt.grid(True) #Сетка
plt.plot(q,f(q)) #Построение графика
plt.figure()
plt.title(r'$y=h(q)$') #Заголовок в формате TeX
plt.ylabel(r'$h(q)$') #Метка по оси y в формате TeX
plt.xlabel(r'$q$') #Метка по оси x в формате TeX
plt.grid(True) #Сетка
plt.plot(q,h(q)) #Построение графика
plt.show() #Показать график

График зависимости цены от объёма продаваемого товара

График зависимости издержек от объёма продаваемого товара

Цена на предлагаемый товар характеризуется убывающей функцией f(q) от объема продаваемого товара q = х+у. Издержки издержки производства одинаковы для обеих фирм и представляют собой возрастающую функцию h1(x) = h2(x) = h(x).

Поведенческие характеристики двух конкурирующих фирм на рынке

В приведенных условиях прибыль каждой фирмы определится следующими функциями:
L1(x,y)=x*f(x+y)-h(x) L2(x,y)=y*f(x+y)-h(y)

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

А. Пусть будет игра с нулевой суммой с выигрышем первого игрока:
L1(x,y)=x*f(x+y)-h(x)

Цель второго игрока — минимизировать прибыль первой фирмы для ее разорения, т.е. необходимо найти:
maxmin L(x,y)= maxmin x*f(x+y)-h(x)
x y x y

Сведем игру к матричной, представив стратегии обоих игроков в дискретном виде: xi=i*x1, yj=j*h2, i,j=0..N. Ее решение приведено в следующем листинге:

Листинг программы - стратегия поведения А

# -*- coding: utf8 -*-
import pylab
from mpl_toolkits.mplot3d import Axes3D
import numpy as np
xmax=1;ymax=1;N=20; h1=xmax/N;h2=ymax/N# Параметры модели
def L1(x,y):# Функция прибыли первой фирмы
         return 10*x*np.e**(-0.5*(x+y)**2)-np.sqrt(x)
def L2(x,y):# Функция прибыли второй фирмы
        return  10*y*np.e**(-0.5*(x+y)**2)-np.sqrt(y)
def fi(a,b):# Функция определения индекса списка
         for w in range(0,len(a)+1):
                  if a[w]==b:
                           return w         
L= np.zeros([N+1,N+1])# Создания матрицы прибылей
for i in range(0,N+1):
         for j in range(0,N+1):
             L[i,j]=L1(i*h1,j*h2)  
A=[];e=[]
rows, cols = L.shape
for i in range(rows):
         e=[]
         for j in range(cols):
                  e.append(L[i,j])               
         A.append(min(e))
a=max(A);ia=fi(A,a);xa=ia*h1# Итоги работы первой фирмы
B=[];e=[]
rows, cols = L.shape
for j in range(cols):
         e=[]
         for i in range(rows):
                  e.append(L[i,j])               
         B.append(max(e))        
b=min(B);ib=fi(B,b);yb=ib*h2# Итоги работы второй фирмы
p1=round(L1(xa,yb),3)
print("Прибыль первой фирмы -"+str(p1))
p2=round(L2(xa,yb),3)
print("Прибыль второй фирмы -"+str(p2))
def makeData_L1 ():# Поверхность прибыль- z, объёмы закупок - x,y для первой фирмы
         x=[h1*i for i in np.arange(0,N+1)]
         y=[h2*i for i in np.arange(0,N+1)]
         x,y= np.meshgrid(x, y)
         z=[]
         for i in range(0,N+1):
                  z.append(L1(x[i],y[i]))
         return x, y, z
fig = pylab.figure()
axes = Axes3D(fig)
x, y, z = makeData_L1()
axes.plot_surface(x, y, z)
def makeData_L2 ():# Поверхность прибыль- z объёмы закупок- x,y для второй фирмы
         x=[h1*i for i in np.arange(0,N+1)]
         y=[h2*i for i in np.arange(0,N+1)]
         x,y= np.meshgrid(x, y)
         z=[]
         for i in range(0,N+1):
                  z.append(L2(x[i],y[i]))
         return x, y, z
fig = pylab.figure()
axes = Axes3D(fig)
x, y, z = makeData_L2()
axes.plot_surface(x, y, z)
pylab.show()

Результаты работы программы:
Прибыль первой фирмы -0.916
Прибыль второй фирмы -2.247

Поверхность прибыль- z, объёмы закупок — x,y для первой фирмы

Поверхность прибыль- z, объёмы закупок — x,y для второй фирмы

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

B. Если первого игрока не устраивает подобная ситуация, он может также поставить своей целью разорение второго игрока. Если они меняются местами, то в силу симметрии функций оптимальная стратегия первого игрока становится оптимальной для второго игрока, и наоборот. Если же каждый стремится разорить конкурента, он должен максимизировать выпуск своего товара.

Листинг программы - стратегия поведения B

# -*- coding: utf8 -*-
import pylab
import numpy as np
xmax=1;ymax=1;N=20; h1=xmax/N;h2=ymax/N
def L1(x,y):
         return 10*x*np.e**(-0.5*(x+y)**2)-np.sqrt(x)
print("Прибыль каждого при стратегии В -"+str(round(L1(xmax,ymax),3)))

Результат работы программы
Прибыль каждого при стратегии В -0.353
При стратегии B каждый из участников рынка получит прибыль в размере L1 = 0,353, что меньше для каждого игрока, чем в случае А.

C. Если конкуренты смогут договориться о разделе рынка, то они могут достичь наиболее выгодного для каждого из них результата с прибылью 2,236 единиц, как показано в следующем листинге программы на Python.

Листинг программы - стратегия поведения С

# -*- coding: utf8 -*-
import matplotlib.pyplot as plt
import numpy as np
xmax=1;ymax=1;N=20; h1=xmax/N;h2=ymax/N
def L1(x,y):
         return 10*x*np.e**(-0.5*(x+y)**2)-np.sqrt(x)
z=[L1(i*h1,i*h1)for i in np.arange(0,N+1)]
x=[h1*i for i in np.arange(0,N+1)]
xopt=x[z.index(max(z))]
print("Объём товара каждой фирмы при котором достигается -"+str(xopt))
print("Прибыль каждой фирмы -"+str(round(max(z),3)))
plt.title('Зависимость прибыли от объёма товара для стратегии С')
plt.grid(True)
plt.plot(x,z) 
plt.show()

Результат работы программы:
Объём товара каждой фирмы при котором достигается -0.45
Прибыль каждой фирмы -2.331

Вывод

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

Всем спасибо за внимание!

Ссылки

1. Оптимизация экономических систем. примеры и алгоритмы в среде mathcad.

Игровая модель поведения на рынке двух конкурирующих фирм на Python