Машина Тьюринга, как модель автоматных программ

Машина Тьюринга, как модель автоматных программ

1. Введение

Программирование нуждается в новых универсальных алгоритмических моделях, а аппаратные средства реализуют алгоритмы не только в другой форме, но и на базе другой алгоритмической модели — автоматной. Заимствование технологии из сферы разработки аппаратных средств ключевая идея автоматного программирования. Однако синтез цифровых устройств отличается от программирования. Но, заимствуя модель, с одной стороны, ее не желательно существенно изменять, а, с другой стороны, нельзя не учитывать уже существующую теорию и практику программирования.

Далее мы рассмотрим SWITCH-технологию проектирования автоматных программ, в которой с подобными процессами сталкиваешься сплошь и рядом. С одной стороны, она так изменила модель конечного автомата, что фактически вывела ее за рамки теории автоматов. А, с другой стороны, вводит в программирование понятия, которые с трудом воспринимаются программистами, а, порой, просто являются лишними, т.к. существуют более привычные аналоги из теории программ и практики программирования.

За основу обсуждения проблем автоматного программирования возьмем недавнюю лекцию Шалыто А.А. [1] и его «программные» статьи к определению парадигмы автоматного программирования [2, 3].

1. Автоматизированные объекты, схемы программ

В лекции достижением автоматного программирования объявлено введение в него понятия автоматизированных объектов управления, заимствованное из теории автоматического управления (ТАУ). Но, напомним, что в ТАУ рассматривают не столько объекты, а системы, среди которых выделяют следующие [4]:



Исходя из этого, правильнее было бы говорить о системах автоматического управления (САУ). Теперь посмотрим на типовую функциональную схему САУ, показанную рис. 1. Если ленту машины Тьюринга считать объектом управления, то исполнительными устройствами (ИсУ) будут элементы МТ, реализующие изменение содержимого ленты и передвигающие головку, а измерительными устройствами (ИзУ) — элементы, читающие информацию с ленты.


Рис.1. Функциональная схема САУ

Но зачем обращаться к ТАУ, если есть более близкая к программированию практика проектирования вычислительных систем, в которой операционные устройства (ОУ), к которым, безусловно, относится и МТ, рассматриваются в виде комбинации операционного (ОА) и управляющего (УА) автоматов. И это ближе к тому, к чему мы в конечном итоге стремимся — обоснованию мощности автоматного программирования. На рис. 2 представлен скрин текста из монографии Майорова С.А., Новикова Г.И. Структура электронных вычислительных машин [5], в которой вопросы проектирования ОУ рассмотрены весьма детально.


Рис.2. Концепция управляющего и операционного автоматов

Но, если сравнивать теорию проектирования ЭВМ и теорию программ, то между ними прослеживается явная структурная аналогия. В теории программирования модель любой программы на структурном уровне можно представить, как схему программы S = (M, A, C), где M – множество элементов памяти, A – множество операторов, C – управление [10]. Следуя этому подходу, любую программу машины Тьюринга также можно определить как схему программы, в которой множество M представлено ячейками ленты, множество операторов – действиями МТ, связанными 1) с анализом ячеек, 2) изменением символов в ячейках ленты и 3) перемещением головки.

Таким образом понятие схемы программы полностью аналогично рассмотренной концепции операционного и управляющего автоматов, где моделью УА является модель рассматриваемого далее структурного конечного автомата (СКА), а ОА «является структурой для выполнения действий над информацией». При этом ОА включает элементы хранения данных (выше – это память) и блоки для обработки информации, реализующих вычисление логических условий и реализацию тех или иных действий (выше – множество операторов).

Из сказанного можно понять, что лента лишь условно может считаться объектом управления для МТ. Хотя бы потому, что устройство управления машины Тьюринга не имеет к ней прямого доступа, т.к. все операции с ячейками реализуют опосредован-но блоки ОА. Кроме того, как представляется, не очень привычно или, если не сказать, странно считать целью управления программы, как системы управления, объект, представляющий собой память (ленту).
Таким образом, для формального определения машины Тьюринга, а в ее контексте места для модели конечного автомата, достаточно понятий теории программ. Теперь, в отличие от весьма расплывчатого определения автоматных программ, данного в рамках SWITCH-технологии, можно сказать, что автоматной программой считается программа, имеющая управление в форме модели конечного автомата.

Какая при этом будет сама программа – с простым или сложным поведением, какова ее «разновидность» – с логическим управлением, «с явным выделением состояний» и т.д. и т.п. не имеет абсолютно значения. Главное – вид управления. Остальные же элементы программы могут определяться в широких пределах – от простейших, как, например, у машины Тьюринга, до самых сложных – любых форм операторов, функций и структур данных языков программирования – ассемблера, языка высокого уровня и т.п.

Можно также вспомнить, что машину Тьюринга уже давно принято считать авто-матом [6] или уж, в крайнем случае, его простым расширением [7]. Но необходимо понимать, что это за автомат, что это за расширение, и эквивалентны ли они моделям классических конечных автоматов. Попробуем это как раз и уточнить.

2. Тьюрингово программирование в среде автоматного программирования

На рис. 3 показан автомат для МТ функции инкремента из монографии [8]. По форме это явно не программа для МТ, но уже и не классический конечный автомат. На рис. 4 приведен граф классического структурного конечного автомата (СКА) и его реализация в среде ВКПа (среда визуально-компонентного автоматного программирования на языке С++ в рамках библиотеки Qt и среды Qt Creator), реализующего тот же самый алгоритм блока управления (БУ) МТ.


Рис.3. Увеличение числа на единицу с помощью машины Тьюринга


Рис.4 Модель программы инкремента для МТ в форме СКА

Можно видеть, что структурный автомат имеет четыре входных и пять выходных каналов. Каждый из этих каналов связан с одноименной ему программной функцией – предикатом или действием. Здесь предикаты – функции без параметров, возвращающие булевское значение в зависимости от значения обозреваемой ими ячейки ленты, а действия – функции без параметров, выполняющие то или иной действие по изменению ячейки ленты и передвижению головки машины Тьюринга.

Данный СКА имеет то же множество состояний, что и автомат на рис.3. При этом кроме собственно автоматного отображения, представленного СКА, он реализует еще два отображения – отображение множества предикатов (x1, …, xM) на множество одноименных входных каналов автомата, и множество выходных каналов автомата на множество одноименных действий – y1, …, yN. Например, предикат x3 вернет значение true (значение 1 для одноименного входного сигнала), если в текущей ячейке будет символ 1, а действие y4, которое будет запущено, когда одноименный выходной сигнал автомата примет значение 1, будет соответствовать перемещение головки влево (L) и т.д. и т.п.

Обратим внимание, что СКА не управляет напрямую лентой, а реализует [дополнительные] отображения, связывая сигналы автомата с функциями, определяющими множество операций машины Тьюринга. Это еще раз убеждает, что нет необходимости вводить понятие автоматизированного объекта управления в ситуации, когда достаточно «старомодного», но математически строго понятия отображение.

Сравнивая автоматы на рис. 3 и рис. 4, можно видеть, что СКА не использует команду «*» (см. рис. 1). В подобной ситуации ему достаточно не выдавать сигнал, связанный с данной командой. Кроме того, два и более сигналов (как входных, так и выходных) на одном переходе параллельны. Поэтому, когда возникает конфликт доступа к общим объектам (например, необходимо изменить ячейку и переместить головку) используется соглашение: действия на одном переходе исполняются последовательно в порядке следования их номеров, т.е. действие с большим номером выполняется после действия с меньшим номером. Это соглашение не распространяется на предикаты, т.к. они не изменяют ленту. Так мы делаем автомат более компактным и наглядным (не на-до вводить промежуточные состояния).

В процессе тестирования программы инкремента были выявлены ситуации, когда в процессе работы МТ могут возникнуть проблемы. Во-первых, реальная лента не бесконечна и выход за ее пределы может вызвать «крах» программы. Во-вторых, нужно обязательно указывать начальное положение головки. Без этого, если, например, число находится в произвольном месте ленты, а начальное состояние головки слева от числа и напротив пробела, то головка сразу начнет движение влево. Далее она может выйти за границы ленты, вызвав «крах» программы, или, переместившись, на шаг влево запишет в ячейку 1 и, зависнув, завершит «успешно» работу. Или, если число содержит во всех разрядах 1 и записано с начала ленты, то заключительная попытка переноса 1 в старший разряд вызовет тот же самый «крах».

2.1. Объектная реализация МТ на языке С++

Рассмотрим объектную программную реализацию машины Тьюринга на языке C++ в среде ВКПа, реализующую любую программу для МТ, в том числе и программу вычисления инкремента.

С этой целью создан базовый класс, представляющий любую машину Тьюринга, который и наследуют программные объекты, реализующие ту или иную программу МТ. Данный базовый представлен на листинге 1, а программа, реализующая задачу инкремента, на листинге 2.

Листинг 1. Программная реализация базового класса МТ

#include "lfsaappl.h"
class FTuringMashine : public LFsaAppl
{
public:
    FTuringMashine(string strNam, CVarFsaLibrary *pCVFL, LArc* pTBL);
protected:
    int x15(); int x16();
    void y14(); void y15(); void y16(); void y17();
    QString strSrc;             // исходное состояние ленты
    QString strTape;            // лента
    QString strHead;            // головка
    int nIndexHead{0};          // индекс головки
    bool bRestart{false};       // признак рестарта
    int nHeadPosition{0};       // текущее положение головки
};

#include "stdafx.h"
#include "FTuringMashine.h"
FTuringMashine::FTuringMashine(string strNam, CVarFsaLibrary *pCVFL, LArc* pTBL):
    LFsaAppl(pTBL, strNam, nullptr, pCVFL)
{
    nHeadPosition = 0;
    strHead = "________________________________________";
    nIndexHead = nHeadPosition;
}
//==============================================================
// ПРЕДИКАТЫ
// пустой символ?
int FTuringMashine::x15() { return strTape[nIndexHead] == '#'; }
// рестарт?
int FTuringMashine::x16() { return bRestart; }
//==============================================================
// ДЕЙСТВИЯ
// записать пустой символ на ленту
void FTuringMashine::y14() { strTape[nIndexHead] = '#'; }
// головка сместить вправо (нарастить индекс)
void FTuringMashine::y15() { nIndexHead++; }
// головка сместить влево (уменьшить индекс)
void FTuringMashine::y16() { nIndexHead--; }
// установить в исходное состояние
void FTuringMashine::y17() {
    strTape = strSrc; nIndexHead = 0;
    bRestart = false;
    nIndexHead = nHeadPosition;
}

Листинг 2. Программа инкремента для машины Тьюринга

#include "FTuringMashine.h"
class FTIncrement : public FTuringMashine
{
public:
    LFsaAppl* Create(CVarFSA *pCVF) { 
	Q_UNUSED(pCVF)return new FTIncrement(nameFsa, pCVarFsaLibrary); 
    }
    FTIncrement(string strNam, CVarFsaLibrary *pCVFL);
protected:
    int x1(); int x2(); int x3();
    void y1(); void y2();
};

#include "FTIncrement.h"
static LArc TBL_TIncrement[] = {
// см. Н. Поликарпова, А. Шалыто Автоматное программирование, 2-е издание, 2011 г.,
// стр.17-18
//===== функция переходов МТ (см. Ю.Г. Карпов Теория автоматов, - СПб.: Питер, 2003. - 208 с.) ==============
//     f(Пп,^` `) = (Пп,`*`,R)
//     f(Пп,` `)  = (Оп,` `,L)
//     f(Оп,`1`)  = (Оп,`0`,L)
//     f(Оп,` `)  = (К,`1`,R)
//     f(Оп,`0`)  = (К,`1`,R)
//=========================================
	LArc("Прямой проход",   "Прямой проход",   "^x1", "y15"),    	
	LArc("Прямой проход",	 "Обратный проход", "x1",  "y16"),    	
	LArc("Обратный проход", "Обратный проход", "x2",  "y2y16"),    	
	LArc("Обратный проход", "Конец",           "x1",  "y1"),
	LArc("Обратный проход", "Конец",           "x3",  "y1"),
	LArc("Конец",           "Прямой проход",   "x16", "y17"),
	LArc()
};

FTIncrement::FTIncrement(string strNam, CVarFsaLibrary *pCVFL):
    FTuringMashine(strNam, pCVFL, TBL_TIncrement)
{
    strSrc = "11011110011111 ";
    strTape = strSrc;
}
// ПРЕДИКАТЫ
int FTIncrement::x1() { return strTape[nIndexHead] == ' '; }
int FTIncrement::x2() { return strTape[nIndexHead] == '1'; }
int FTIncrement::x3() { return strTape[nIndexHead] == '0'; }
// ДЕЙСТВИЯ
void FTIncrement::y1() { strTape[nIndexHead] = '1'; }
void FTIncrement::y2() { strTape[nIndexHead] = '0'; }

2.2. Примеры программ для МТ с реализацией на С++

Рассмотрим пример программы для МТ, которая «выступает как акцептор языка, т.е. она может распознавать язык» из [9]. Ее функция переходов представлена на рис. 5, а эквивалентный ей автомат в форме СКА на рис. 6.

δ(1, a) = (2, x, R)		δ(1, y) = (4, y, R)
δ(2, a) = (2, a, R)		δ(2, y) = (2, y, R)
δ(2, b) = (3, y, L)		δ(3, y) = (3, y, L)
δ(3, a) = (3, a, R)		δ(3, x) = (1, x, R)
δ(4, y) = (4, a, R)		δ(4, #) = (F, #, L)

Рис. 5. Функция переходов машины Тьюринга, распознающая язык {anbn: n≥1}


Рис. 6. Граф СКА машины Тьюринга, распознающей язык {anbn: n≥1}

Блок управления МТ в форме СКА имеет 6 входных и 7 выходных каналов. Про-грамма акцептора включает также соответствующее им число предикатов и действий, которые представлены на рисунке справа от графа автомата. Реализация программы на С++ в среде ВКПа представлена на листинге 3.

Листинг 3. Программа для машины Тьюринга, распознающей язык {anbn: n≥1}

#include "FTuringMashine.h"

extern LArc TBL_TAcceptor[];
class FTAcceptor : public FTuringMashine
{
public:
    LFsaAppl* Create(CVarFSA *pCVF) { Q_UNUSED(pCVF)return new FTAcceptor(nameFsa, pCVarFsaLibrary); }
    FTAcceptor(string strNam, CVarFsaLibrary *pCVFL, LArc* pTB = TBL_TAcceptor);
protected:
    int x1(); int x2(); int x3(); int x4();
    void y1(); void y2(); void y3(); void y18();
    int nState{1};
friend class CDlgTAcceptor;
};

#include "stdafx.h"
#include "FTAcceptor.h"

LArc TBL_TAcceptor[] = {
// см. Дж.Maкконнелла Анализ алгоритмов. Активный обучающий подход. 2013 г.,
// Машина Тьюринга как акцептор языка, стр.304
//===== функция переходов МТ ==============
//     f(1,a) = (2,x,R)   f(1,y) = (4,y,R)
//     f(2,a) = (2,x,R)   f(2,y) = (2,y,R)
//     f(2,b) = (2,x,R)   f(3,y) = (3,y,L)
//     f(3,a) = (3,a,R)   f(3,x) = (1,x,R)
//     f(4,y) = (4,a,R)   f(4,#) = (F,#,L)
//=========================================
    LArc("1",		"2","x1",	"y1y15"),	// 1,a,2,x,R
    LArc("1",		"4","x3",	"y15"),		// 1,y,4,R
    LArc("2",		"2","x1",	"y15"),		// 2,a,2,R
    LArc("2",		"3","x2",	"y2y16"),	// 2,b,3,y,L
    LArc("2",		"2","x3",	"y15"),		// 2,y,2,R
    LArc("3",		"3","x1",	"y16"),		// 3,a,3,L
    LArc("3",		"3","x3",	"y16"),		// 3,y,3,L
    LArc("3",		"1","x4",	"y15"),		// 3,x,1,R
    LArc("4",		"4","x3",	"y2y15"),	// 4,y,4,a,R
    LArc("4",		"F","x15",	"-"),		// 4,#,F,-,-
    LArc("F",		"1","x16",	"y17"),     //
    LArc("1",		"1","x16",	"y17"),     //
    LArc("2",		"1","x16",	"y17"),     //
    LArc("3",		"1","x16",	"y17"),     //
    LArc("4",		"1","x16",	"y17"),     //
//    LArc("1",		"1","--",	"y18"),	    //
    LArc()
};

FTAcceptor::FTAcceptor(string strNam, CVarFsaLibrary *pCVFL, LArc* pTB):
    FTuringMashine(strNam, pCVFL, pTB)
{
    strSrc = "aaaaaaaaaabbbbbbbbbb#";
    strTape = strSrc;
}

int FTAcceptor::x1() { return strTape[nIndexHead] == 'a'; }
int FTAcceptor::x2() { return strTape[nIndexHead] == 'b'; }
int FTAcceptor::x3() { return strTape[nIndexHead] == 'y'; }
int FTAcceptor::x4() { return strTape[nIndexHead] == 'x'; }

void FTAcceptor::y1() { strTape[nIndexHead] = 'x'; }
void FTAcceptor::y2() { strTape[nIndexHead] = 'y'; }
void FTAcceptor::y3() { strTape[nIndexHead] = 'a'; }
void FTAcceptor::y18() {
    switch(nState) {
    case 1:
        if (x1()) { nState = 2; y1(); y5(); break; }
        if (x3()) { nState = 4; y5();  break; }
        break;
    case 2:
        if (x1()) { nState = 2; y5(); break; }
        if (x2()) { nState = 3; y2();y6(); break; }
        if (x3()) { nState = 2; y5(); break; }
        break;
    case 3:
        if (x1()) { nState = 3; y6(); break; }
        if (x3()) { nState = 3; y6(); break; }
        if (x4()) { nState = 1; y5(); break; }
        break;
    case 4:
        if (x3()) { nState = 4; y2(); y5(); break; }
        if (x5()) { nState = 5; break; }
        break;
    case 5:
        if (x6()) { y7(); nState = 1; break; }
        break;
    }
}

На листинге 3 действие y18 представляет вариант программы для МТ в соответствии с подходом SWITCH-технологии. В рамках реализации автоматного программирования среды ВКПа в этом случае вместо автомата на рис. 6 необходимо будет реализовать автомат с одним состоянием, который выдает в цикле сигнал y18. Ему соответствует закомментированная строка таблицы переходов на листинге 3. Для работы автомата по типу SWICH необходимо снять комментарий с данной строки, а остальные строки закомментировать.

Рассмотрим еще один пример программы для машины Тьюринга из [7], где МТ определяется, как «весьма простое расширение модели конечного автомата». В этом случае программа для машины Тьюринга представляет собой конечный список пятерок частично-определенной функции переходов и выходов δ: S×XS×X×Г.

Программа для МТ, находящая наибольший общий делитель (НОД) двух чисел, показана на рис. 7. Эквивалентный ей граф СКА представлен на рис. 8. Заметим, что и здесь не используются команда перезаписи символов. Реализация на С++ представлен листингом 4.


Рис. 7. Граф переходов машины Тьюринга, вычисляющей НОД двух чисел, и несколько ее конфигураций при обработке пары чисел <4, 6>


Рис. 8. Граф СКА, эквивалентный графу на рис. 7

Листинг 4. Программа для машины Тьюринга нахождения НОД двух чисел

#include "FTuringMashine.h"

class FTGrCmDiv: public FTuringMashine
{
public:
    LFsaAppl* Create(CVarFSA *pCVF) { Q_UNUSED(pCVF)return new FTGrCmDiv(nameFsa, pCVarFsaLibrary); }
    FTGrCmDiv(string strNam, CVarFsaLibrary *pCVFL);
protected:
    int x1(); int x2(); int x3(); int x4();
    void y1(); void y2(); void y3(); void y17();
};

#include "FTGrCmDiv.h"
static LArc TBL_TGrCmDiv[] = {
//===== программа МТ нахождения НОД (Greatest Common Divider) ==============
// см. Ю.Г. Карпов Теория автоматов, - СПб.: Питер, 2003. - 208 с.
// стр.194
// см. Трахтенброт Б.А. Алгоритмы и вычислительные автоматы. М.: Советское радио, 1974, - 200с.
// стр.76, 84-87
    LArc("s","s","x1",	"y16"),		//
    LArc("s","s","x2",	"y16"),		//
    LArc("s","p","x3",	"y1"),		//
    LArc("s","r","x15",	"y15"),		//
    LArc("p","p","x1",	"y15"),		//
    LArc("p","p","x2",	"y15"),		//
    LArc("p","s","x3",	"y2"),		//
    LArc("p","q","x15",	"y16"),		//
    LArc("q","q","x1",	"y3y16"),	//
    LArc("q","q","x2",	"y14y16"),	//
    LArc("q","s","x3",	"y15"),		//
    LArc("q","s","x15",	"y15"),		//
    LArc("r","r","x1",	"y14y15"),	//
    LArc("r","r","x2",	"y3y15"),	//
    LArc("r","s","x3",	"y16"),		//
    LArc("r","!","x15",	"--"),		//
    LArc("!","s","x16",	"y17"),		//
    LArc()
};

FTGrCmDiv::FTGrCmDiv(string strNam, CVarFsaLibrary *pCVFL):
    FTuringMashine(strNam, pCVFL, TBL_TGrCmDiv)
{
    nHeadPosition = 4;
    strSrc = "#1111111111## ";
    strTape = strSrc;
    nIndexHead = nHeadPosition;
}

int FTGrCmDiv::x1() { return strTape[nIndexHead] == 'a'; }
int FTGrCmDiv::x2() { return strTape[nIndexHead] == 'b'; }
int FTGrCmDiv::x3() { return strTape[nIndexHead] == '1'; }
int FTGrCmDiv::x4() { return strTape[nIndexHead] == '#'; }

void FTGrCmDiv::y1() { strTape[nIndexHead] = 'a'; }
void FTGrCmDiv::y2() { strTape[nIndexHead] = 'b'; }
void FTGrCmDiv::y3() { strTape[nIndexHead] = '1'; }
void FTGrCmDiv::y17() {
    strTape = strSrc; nIndexHead = 4;
    bRestart = false;
    nIndexHead = nHeadPosition;
}

В заключение еще одна программа для МТ от разработчиков SWITH-технологии, рассмотренная в статье [11], где приведена задача распознавание скобок в двух варианта. Один в форме автомата Мили, второй – смешанный автомат (соответственно на рис. 9 и рис. 11). Соответствующие им структурные автоматы приведены на рис. 10 и рис. 12. Реализацию программы на С++ демонстрирует листинг 5.


Рис. 9. Распознавание скобок произвольной глубины. Граф переходов Мили


Рис. 10. Распознавание скобок произвольной глубины. Граф СКА Мили


Рис. 11. Распознавание скобок произвольной глубины. Граф переходов смешанного автомата


Рис. 12. Распознавание скобок произвольной глубины. Граф СКА переходов сме-шанного автомата

Листинг 5. Программа для машины Тьюринга распознавания вложенности скобок

#include "../FTuringMashine.h"

class FTListing2 : public FTuringMashine
{
public:
    void MooreAction();
    LFsaAppl* Create(CVarFSA *pCVF) { Q_UNUSED(pCVF)return new FTListing2(nameFsa, pCVarFsaLibrary); }
    FTListing2(string strNam, CVarFsaLibrary *pCVFL);
protected:
    int x1(); int x2(); int x3(); int x4();
    void y1(); void y2(); void y3(); void y4(); void y5();
    int i{0};
};

#include "FTListing2.h"

static LArc TBL_TListing2[] = {
// см. Туккель Н.И., Шалыто А.А. От Тьюрингова программирования к автоматному, МирПК, №2, С.144-149
//===== функция переходов МТ (см. Ю.Г. Карпов Теория автоматов, - СПб.: Питер, 2003. - 208 с.) ==============
//     f(Пп,^` `) = (Пп,`*`,R)
//     f(Пп,` `)  = (Оп,` `,L)
//     f(Оп,`1`)  = (Оп,`0`,L)
//     f(Оп,` `)  = (К,`1`,R)
//     f(Оп,`0`)  = (К,`1`,R)
//=========================================
/*
// Мили
    LArc("0",		"1",    "x2",	"y2"),	// '(';движение вправо
    LArc("0",		"3",    "x3",	"--"),	// '(';
    LArc("1",		"1",  "x2",     "y2"),	// '(';движение вправо
    LArc("1",		"1",  "x3",     "y3"),	// ')';движение влево
    LArc("1",		"3",  "^x1x4",	"--"),	// i!=0;' '; Отвергнуть
    LArc("1",		"3",  "x1x3",	"--"),	// i==0;')'; Отвергнуть
    LArc("1",		"2",  "x1x4",	"--"),	// i==0;' '; Допустить
    LArc("2",		"0",  "x16",    "y17"),	// bRestart; перезапуск
    LArc("3",		"0",  "x16",    "y17"),	// bRestart; перезапуск
*/
//*
// Смешанный автомат Мили-Мура
    LArc("0",		"1",  "x2",     "y2"),		// '('
    LArc("0",		"3",  "x3",     "--"),		// ')'
    LArc("1",		"1",  "x2",     "y2"),		//'(';движение вправо
    LArc("1",		"1",  "x3",     "y3"),		// ')';движение влево
    LArc("1",		"2",  "x1x4",	"--"),      // i==0;' ';
    LArc("1",		"3",  "^x1x4",	"--"),		// i!=0;' ';
    LArc("1",		"3",  "x1x3",	"--"),		// i==0;')';
    LArc("2",		"0",  "x16",    "y17"),     // bRestart; перезапуск
    LArc("3",		"0",  "x16",    "y17"),     // bRestart; перезапуск
//*/
    LArc()
};

FTListing2::FTListing2(string strNam, CVarFsaLibrary *pCVFL):
    FTuringMashine(strNam, pCVFL, TBL_TListing2)
{
    strSrc = "(()()) ";
    strTape = strSrc;
}
// ПРЕДИКАТЫ
int FTListing2::x1() { return i == 0; }
int FTListing2::x2() { return strTape[nIndexHead] == '('; }     //
int FTListing2::x3() { return strTape[nIndexHead] == ')'; }     //
int FTListing2::x4() { return strTape[nIndexHead] == ' '; }     //
// ДЕЙСТВИЯ
void FTListing2::y1() { i = 0; }                    // z1_0
void FTListing2::y2() { i++; }                      // z1_1
void FTListing2::y3() { i--; }                      // z1_2
void FTListing2::y4() { strTape = "допустить"; }    // z2_0
void FTListing2::y5() { strTape = "отвергнуть"; }   // z2_1

void FTListing2::MooreAction()
{
    string strState = FGetState();
    if (strState=="0")	{ y1(); }           // сброс счетчика
    else if (strState=="1")	{ y15(); }      // сдвиг головки влево
    else if (strState=="2")	{ y4(); }       // Допустить
    else if (strState=="3")	{ y5(); }       // Отвергнуть
}

Поскольку автомат на рис. 12 отказался работать, то было решено перейти к автомату на рис. 9. Эквивалентный ему автомат в форме СКА, показан на рис. 10. Правда, формально это тоже смешанный автомат, у которого от первой реализации (рис. 12) был оставлен сигнал при состоянии «0» и сигнал y15 при состоянии «1». Первый необходим при начальной установке, а сигнал y15 реализует смещение головки вправо в целях чтения очередного символа ленты. В остальном СКА соответствует автомату Мили на рис. 9.

После того, как автомат на рис. 10 был успешно протестирован, вернулись к автомату на рис. 11. И стало понятно, что у него лишним является сигнал z1_1 при состоянии «1»(у автомата на рис. 12 это сигнал y2). Проблема в том, что он, обнаружив «левую скобку», наращивает счетчик на две единица, а при обнаружении «левой скобки» не изменяет его совсем. Так, при обнаружении «левой скобки» он вызывается дважды – один раз на петле,, помеченной x2/y2, а второй раз при входе в состояние. А при обнаружении «правой скобки» счетчик сначала на петле уменьшается, а затем при входе в состояние увеличивается.

Причина такой работы управления МТ, в неверной трактовке авторами функционирования автомата типа Мура. Видимо, они полагают, что сигнал при состоянии у автомата Мура исполняется только при входе в это состояние (см. переход из состояния «0» в «1»), а на самом деле он выдается всякий раз при входе в это состояние. В том числе и при переходе по петле. Таким образом, мы имеет дело не с ошибкой (кто не ошибался?), а с более серьезной проблемой — неверной трактовкой в рамках SWITH-технологии функционирования автоматов типа Мура. Тестирование эквивалентной модели это и показало.

3. Заключение

Подводя итог, можно сказать, что нет формальных отличий тьюрингового программирования от автоматного, т.к. машина Тьюринга – это абстрактная модель автоматных программ. Просто в последнем случае используется более широкий набор операторов и структур данных (памяти). Теперь можно уверенно ответить и на вопрос, чем отличается машина Поста, как модель обычных программ, от машины Тьюринга — модели автоматных программ. Моделью управления и лишь только ею, т.к. остальное – память и операторы могут быть одними и теми же.
Следовательно, обычное программирование отличается от программирования автоматного только одним – моделью управления. Таким образом, пока для реализации автоматов используются обычные операторы управления типа switch и им подобные нельзя, строго говоря, такое программирование считать автоматным. Это может быть имитация автоматов с утратой их определенных свойств и не более того.

Итак, давая определение понятий автоматной программы и автоматного программирования, говорить надо не об «автоматизированных объектах управления», а о программах и только программах, имеющих управление в форме классического конечного автомата.
И еще интересный факт, на который хотелось бы обратить внимание. В начале 2000-х годов, авторы озвучили свое понимание автоматного программирования на широкую аудиторию. Их статьи по поводу абстрактных машин были напечатаны в журнале «Мир ПК» №2 за 2002 г. [11, 12, 13]. Можно утверждать, что годы на убеждения сторон не повлияли. Хотя, возможно, это отражает только степень их уверенности в выбранных решениях.

Например, в «новую лекцию по автоматному программированию» Шалыто А.А. по сравнению с предыдущей «лекцией со слайдами» (десятилетней давности) добавлено лишь видео примера на базе «автоматного пакета» Stateflow. Казалось бы, это подтверждает правоту идей Шалыто А.А., т.к. то, что не удалось реализовать в рамках UniMod (проект, похоже, «заморожен»), воплотили разработчики Stateflow. И, наверное, не так уж важно кто это сделал…

Однако, на момент публикации упомянутых статей авторам SWITCH-технологии уже была известна критика в ее адрес. Это не было тайной, т.к. с ней можно было ознакомиться на сайте SoftCraft [14]. На нем же были созданы разделы, посвященные автоматному программированию вообще и SWITH-технологии и КА-технологии в частности. Позиции авторов обсуждались на форуме сайта (он был на тот момент открыт). Но все так и остались при своем мнении.

Итоги на текущий момент таковы. Критика, высказанная в отношении SWITH-технологии когда-то давно, актуальна и на текущий момент. Она же относится и к пакету Stateflow. В SWITH-технологии как не было, так и нет четкого определения автоматного программирования, не изменился подход к реализации автоматов, сама модель не является классической, нет модели параллельных вычислений и т.д. и т.п. Без устранения этих проблем подобное автоматное программирование в лучшем случае претендует на достаточно ограниченную роль.

Причины отмеченных выше проблем довольно ясны: игнорируется теория программ, забыта теория автоматов, хотя о самих автоматах и об их замечательных свойствах сказано много хороших и правильных слов. Но по факту это другие автоматы. Автор убежден в сомнительности непродуманных попыток создавать оригинальные модели. Речь о синхронных, реактивных и других моделях. Они могут быть удобны при решении узкого класса задач и не более того. Но серьезнее то, что они выпадают из теории автоматов, не имея при этом собственной теории. А модель вне теории беспомощна, а потому фактически бессмысленна.