app/src/main/java/com/ea/groupbuilder/DbHelper.java - master - nea/androidGroupBuilder

app/src/main/java/com/ea/groupbuilder/DbHelper.java
2 450 строк155 KB
Группа Автоморфизмов отлажено 23_04_2026
23 апр 2026, 17:08
23 апр 2026, 17:084513276
package com.ea.groupbuilder;

import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.util.Log;

import java.util.ArrayList;
import java.util.List;

import androidx.appcompat.app.AlertDialog;
import android.content.DialogInterface;

public class DbHelper extends SQLiteOpenHelper {
    private static final String TAG = "GRUGRA_DBHELPER";
    final static private boolean DISPLAYLOG = false;  // выдавать отладочную печать в "TAG"
    private static final int DB_VERSION = 8;    //  12.02.2026
    public mAplication mApp;
    static public int faktSubsLen = 0,   // вычисленная фактическая длина множества переставляемых чисел
            faktSubsLen_n = 0,
            faktSnLen = 0,       // >0 - строится Sn для n=faktSnlen - признак построения всей Sn
            saveSnLen = 0;      // n для созданенной ранее Sn

    static public int countElements = 0,   // строк в таблице elements =  порядок группы
            countElements_n = 0,
            countElements_a = 0;
    static public int countSwitch = 0; // порядок коммутанта
    static public int countCentr = 0; // число эл-тов центра, если = countElements - группа абелева

    static private final String DB_NAME = "GroupBuilder.db";

    static public SQLiteDatabase db = null;
    static private DbHelper sInstance; // http://www.androiddesignpatterns.com/2012/05/correctly-managing-your-sqlite-database.html
    static private boolean dbCreate = false; // true  - базу надо создавать
    static public String err = ""; // текст ошибки
    static public substitutionS classSubs;
    static public List<Integer> maxNum; // порядок разобранных в f_ciklToSubs циклов подстановок

    // все образующие подстановки в виде  [x,x,...,x] еще не усеченные до maxSubsLen
    static List<String> arrInitName = new ArrayList<>(); // имена образующих
    static List<String> arrInitSubs = new ArrayList<>();  // образующие подстановки в виде [...,]
    public int vidWgrup = 0;   // vidWgrup = 0 - сама группа, 1 - группа автоморфизмов

    static public DbHelper getInstance(Context context) {
        /* объект д б всегда в одном экземпляре - требует Андроид
         * Это обеспечивает Singleton!
         * You should not initialize your helper object using with new DbHelper(context)! Instead, always use DbHelper.getInstance(context)
         */
        // See this article for more information: http://bit.ly/6LRzfx
        if (sInstance == null) {
            sInstance = new DbHelper(context.getApplicationContext());
            dbCreate = false;   // база создана
        } else {
            dbCreate = true;    // надо создать
        }
        return sInstance;
    }

    public void f_setVidGr(int vidWgrup_, boolean tred) {
   // vidWgrup = 0 - сама группа, 1 - группа автоморфизмов
        vidWgrup = vidWgrup_;
        if (tred) {
            if (mApp.activityBuild != null) {
                if (mApp.activityBuild.spinnerGorA != null) {
                    mApp.activityBuild.spinnerGorA.setSelection(vidWgrup);
                    mApp.activityBuild.invalidateOptionsMenu();
                }
            }
        }

    }

    static public String TblTmpName[],  // массив строк имен таблиц с _n, _a
            tblMainName[]; // массив строк имен таблиц с _n, _a

    public int f_init() {
        // запись в базу всех образующих
        int j, i, countInit = arrInitSubs.size();
        err = "";
        faktSubsLen = 0;    // вычисленная фактическая длина множества переставляемых чисел

        for (j = 0; j < maxNum.size(); j++)
            if (faktSubsLen < maxNum.get(j)) faktSubsLen = maxNum.get(j);
        if (DISPLAYLOG)
            Log.e(TAG, "f_init maxSubsLen = " + faktSubsLen);

        mApp.putProt("Определена степень подстановок: " + faktSubsLen);
        classSubs.f_setEdinica();   // classSubs.Edinica

        // усечение и запись в базу
        List<String> newInitSubs = new ArrayList<>();
        mApp.putProt("Заданы образуюшие подстановки:");
        String oldS, newS;
        String[] arrS;
        for (j = 0; j < arrInitSubs.size(); j++) {
            oldS = arrInitSubs.get(j);  // в виде [...
            arrS = oldS.split(",");
            newS = "";
            for (i = 0; i < faktSubsLen; i++) {
                if (i > 0) newS += ",";
                newS += arrS[i];
            }
            newS += "]";
//            Log.e(TAG, "f_init name= " + arrInitName.get(j) + " newS=" + newS);

            if (newInitSubs.contains(newS))
                mApp.putProt("Подстановка " + newS + " (" + arrInitName.get(j) + ") дублируется среди образующих - не берется в работу");
            else {

// запись в " + DbHelper.elements[vidWgrup] + " f_SubsToBase(String table, String nameS, String txtS, int urov) {
                if (f_SubsToBase(elements[vidWgrup], arrInitName.get(j), newS, 0) < 0) {
                    err += "Заданы одинаковые подстановки";
                    return -1;
                }
                newInitSubs.add(newS);
            }

// обратная подстановка
            String revSubs = classSubs.f_reverseSubstitution(newS),
                    nameRev = arrInitName.get(j) + "^";

//            Log.e(TAG, "f_init Rev nameRev= " + nameRev + " nameRev=" + revSubs);
// проверка: а может она уже есть среди образующих?
            if (newInitSubs.contains(revSubs))
                mApp.putProt("Обратная к " + newS + " (" + arrInitName.get(j) + ") имеется среди образующих");
            else {
                if (f_SubsToBase(elements[vidWgrup], nameRev, revSubs, 0) == 0) {  // если будит дубль - не запишется!
                    mApp.putProt("К образующим добавлена подстановка " + revSubs + " с именем " + nameRev + ", обратная к " + newS + " (" + arrInitName.get(j) + ") для построение графа Кэли");
//                    Log.e(TAG, "f_init К образующим добавлена подстановка " + revSubs + " с именем " + nameRev + ", обратная к " + newS + " (" + arrInitName.get(j) + ") для построение графа Кэли");
                    countInit++;
                }

                newInitSubs.add(revSubs);
            }
        }

        String sqlQuery = "insert into params (parm, ind, val) VALUES ('pointsPerIteration" + (vidWgrup == 0 ? "_g" : "_a") + "', 0, " + countInit + ");";
        db.execSQL(sqlQuery); // ошибок не должно быть !
        //      Log.e(TAG, "f_buildOne pointsPerIteration=" + countInit + " iteracia=0 sqlQuery="+ sqlQuery);

//        sqlQuery = "insert into params (parm, ind, val) VALUES ('FaktSubsLength', 0, " + faktSubsLen + ");";
//        db.execSQL(sqlQuery); // ошибок не должно быть !

        return 0;
    }


    static public long timeStart = 0L;

    static public int curNumSylov = 1, // нумирация силовских подгрупп и общее их число ( сквозная нумирация )
            curNumCommon = 1;   // нумирация общих P подгупп
    static public List<Integer> peSylCreate = new ArrayList<>(),  // простые, для которых построены силовские подгруппы
            peSylNoFound = new ArrayList<>();   // p для которых силовские подгруппы не найдены
    public void f_testKerEpi(int nomPe, String edinicePe) {
        // строит таблицу temp_sylow для ядра при эпиморфизме на группу подстановок на силовских подгруппах",  // 52
        //  edinicePe - образ единичной подстановки
        String sqlTestSel;
        db.execSQL("delete from temp_sylow;");
        db.execSQL("UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='temp_sylow';");

        sqlTestSel = "insert into temp_sylow (idproiz, idleft, idright, pe, num1, num2)\n" +
                "     select  M.idproiz, M.idleft, M.idright, EL.pe, ER.pe, 0\n" +
                "      from " + elements[vidWgrup] + " CL, " + elements[vidWgrup] + " CR, " + temp_multiplication[vidWgrup] + " M,  " + epimorphism[vidWgrup] + " EL, " + epimorphism[vidWgrup] + " ER \n" +
                "      where M.idleft = CL._id and M.idright = CR._id and \n" +
                "   CL._id = EL.id_element and  CR._id = ER.id_element and EL.substitution = '" + edinicePe + "'  and ER.substitution  = '" + edinicePe + "' and \n" +
                "    EL.pe = " + nomPe + " and ER.pe = " + nomPe + ";";
        db.execSQL(sqlTestSel);
        if (DISPLAYLOG)
            Log.e(TAG, "f_testKerEpi nomPe= " + nomPe + " sqlTestSel " + sqlTestSel);
        sqlTestSel = "update temp_sylow set num2 =\n" +
                "(select " + nomPe + " from " + epimorphism[vidWgrup] + " N \n" +
                " where  N.pe = temp_sylow.pe and temp_sylow.idproiz = N.id_element and N.substitution = '" + edinicePe + "'  \n" +
                ") where  temp_sylow.idproiz in\n" +
                "(select K.id_element from " + epimorphism[vidWgrup] + " K" +
                "   where K.pe = " + nomPe + " and K.substitution = '" + edinicePe + "');";
        db.execSQL(sqlTestSel);
        if (DISPLAYLOG)
            Log.e(TAG, "f_testKerEpi sqlTestSel= " + sqlTestSel);

    }

    public static int solvableGroup = 0; // 1 - группа разрешима и все коммутанты созданы, = -1 - НЕ РАЗРЕШИМА
    public static int curKomm = 1; // номер тек расчитанного коммутанта, 1-й расчитывается в f_build_switch()
    public void f_nextKomm() {
        //  искать След коммутант уровня curKomm+1 и при получении увеличить curKomm

        int i, i2 = 0, i3;
        curKomm = f_getCount("select max(switchboard_num) as ccc from " + elements[vidWgrup] + ";");
        if (DISPLAYLOG)
            Log.e(TAG, " f_nextKomm расчитан коммутант уровня curKomm = " + curKomm );

        i3 = f_getCount("select count(*) as ccc from " + elements[vidWgrup] + " where switchboard_num = " + curKomm + ";");
        if (i3 == 1) {
            mApp.putProt("Порядок коммутанта уровня " + curKomm + " равен 1 группа разрешима");
            solvableGroup = 1;
            return;
        }
        do {
            i = f_testCommCreate(curKomm + 1);
            if (DISPLAYLOG)
                Log.e(TAG, " f_nextKomm curKomm = " + curKomm + " solvableGroup ="+ solvableGroup + " итерация =" + i2 + " i = "+ i);
            if (i > 0)
                mApp.putProt("Построение коммутанта уровня "+ (curKomm+1) + ", итерация =" + (++i2) + " новых элементов = "+ i);
            if (i2 > 50) {
                solvableGroup = -1;
                mApp.putProt("Коммутант уровня " + curKomm + " не может быть расчитан!");
                return;
            }
        } while (i > 0);
        curKomm++;

        i2 = f_getCount("select count(*) as ccc from " + elements[vidWgrup] + " where switchboard_num = " + curKomm + ";");
        if (i2 == 1) {
            mApp.putProt("Порядок коммутанта уровня " + curKomm + " равен 1 группа разрешима");
            solvableGroup = 1;
        } else if (i2 == i3) {
            solvableGroup = -1;
            mApp.putProt("Коммутант уровня " + curKomm + " равен коммутанту уровня " + (curKomm - 1) + " группа неразрешима");
        } else
            mApp.putProt("Порядок коммутанта уровня " + curKomm + " равен " + i2);

// записать параметры коммутантов
        db.execSQL(" delete from params where parm = 'solvableGroup" + (vidWgrup == 0 ? "_g" : "_a" ) + "';");
        db.execSQL(" insert into params (parm, val_txt, val, ind) values('solvableGroup" + (vidWgrup == 0 ? "_g" : "_a" ) + "', 'данные коммутантов', " + solvableGroup + ", "+ curKomm + ");");

    }

    public int f_testCommCreate(int levelComm) {
        // заносит все произведения коммутаторов уровня levelComm из elements.switchboard_num = levelComm-1 в temp_sylow
        // и просиаваеляет idproiz    если произведение есть коммутант уровня levelComm
        // возвращает число новых элементов в коммутанте уровня levelComm
        // - пополнение коммутанта

        ContentValues cv_CommCr = new ContentValues();

        String SQL;
        int j;
        int[] subsL = new int[DbHelper.faktSubsLen],    // левая, правая
                subsR = new int[DbHelper.faktSubsLen];
        String txtL, txtR, newTxtMul;
        String[] pods;
        List<Integer> subsMul = new ArrayList<>();
        db.beginTransaction();
        try {
            if (levelComm > 1) {    // для 1-го коммутанта = 2
                db.execSQL(" delete from temp_sylow;");
// заношу _id коммутаторов нового уровня в temp_sylow idleft

                db.execSQL("insert into temp_sylow (idleft, idright) \n" +  // = id_switch, substitution для нового коммутанта
                        "select distinct M._id as id, M.substitution as substitution from " + elements[vidWgrup] + " M, " + switchboard[vidWgrup] + " S\n" +
                        "                         where M._id = S.id_switch and S.id_left in (\n" +
                        "                           select L._id from " + elements[vidWgrup] + " L where L.switchboard_num = " + (levelComm - 1) + ")  and \n" +
                        "                           S.id_right in (\n" +
                        "                           select R._id from " + elements[vidWgrup] + " R where R.switchboard_num = " + (levelComm - 1) + ")");
//  update elements
                db.execSQL("update " + elements[vidWgrup] + " set switchboard_num = " + levelComm + " \n" +
                        "where _id in (\n" +
                        "  select idleft from temp_sylow);");
/*
                SQL = "select distinct M._id as id, M.substitution as substitution from elements M, switchboard S\n" +
                        " where M._id = S.id_switch and S.id_left in (\n" +
                        "   select L._id from elements L where L.switchboard_num = " + (levelComm - 1) + "  and \n" +
                        "   S.id_right in (\n" +
                        "   select R._id from elements R where R.switchboard_num = " + (levelComm - 1) + " )\n";
 */
            }
            SQL = "select M._id as id, M.substitution as substitution from " + elements[vidWgrup] + " M where M.switchboard_num = " + levelComm;

            db.execSQL(" delete from temp_sylow;");
            db.execSQL("UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='temp_sylow';");

            Cursor cursorLeftComm = db.rawQuery(SQL, null),
                    cursorRightComm = db.rawQuery(SQL, null);
            int iL1 = cursorLeftComm.getColumnIndex("id"),
                    iR1 = cursorRightComm.getColumnIndex("id"),
                    iLS = cursorRightComm.getColumnIndex("substitution"),
                    iRS = cursorRightComm.getColumnIndex("substitution");
            int id_L, id_R;
            if (cursorLeftComm.getCount() > 0) {
                if (cursorLeftComm.moveToFirst()) {
                    do {
                        id_L = cursorLeftComm.getInt(iL1); // _id
                        txtL = cursorLeftComm.getString(iLS);
                        txtL = txtL.substring(1, txtL.indexOf("]"));
                        //              Log.e(TAG, "f_testCommCreate l=" + txtL + " name= " + namL + " pos= " + cursorLeftPair.getPosition());
                        pods = txtL.split(","); // массив строковых чисел
                        for (j = 0; j < DbHelper.faktSubsLen; j++)
                            subsL[j] = Integer.parseInt(pods[j].trim());

                        if (cursorRightComm.getCount() > 0) {
                            cursorRightComm.moveToFirst();
                            do {
                                id_R = cursorRightComm.getInt(iR1); // _id
                                txtR = cursorRightComm.getString(iRS);
                                txtR = txtR.substring(1, txtR.indexOf("]"));
    //              Log.e(TAG, "f_testCommCreate l=" + txtR + " name= " + namL + " pos= " + cursorLeftPair.getPosition());
                                pods = txtR.split(","); // массив строковых чисел
                                for (j = 0; j < DbHelper.faktSubsLen; j++)
                                    subsR[j] = Integer.parseInt(pods[j].trim());
// перемножение
//               Log.e(TAG, "f_build_switch r=" + txtR + " name= " + namR + " pos= " + cursorRightPair.getPosition());
                                subsMul.clear();
                                for (j = 0; j < DbHelper.faktSubsLen; j++) {
                                    subsMul.add(subsL[subsR[j] - 1]);   // произведение (L**-1) * R * L
                                }
                                newTxtMul = subsMul.toString();
//                    Log.e(TAG, "f_testCommCreate newTxtMul=" + newTxtMul + " id_L=" + id_L + " id_R= " + id_R );
//                    mApp.putProt("Сопряжение элементов " + namL + " * " + namR + " = " + newTxtPair + " коммутатор =" + newTxtSwitch);

// запись произведения
                                cv_CommCr.put("txt", newTxtMul);
                                cv_CommCr.put("idleft", id_L);
                                cv_CommCr.put("idright", id_R);

                                long row_id = db.insert("temp_sylow", null, cv_CommCr);

                                if (row_id < 0) {
                                    DbHelper.err += "f_testCommCreate Ошибка записи в таблицу temp_sylow " + row_id;
                                    Log.e(TAG, DbHelper.err);
                                }
                                if (DbHelper.err.length() > 0) {
                                    cursorRightComm.close();
                                    cursorLeftComm.close();
                                    return -1;
                                }
                            } while (cursorRightComm.moveToNext());
                        }
                    } while (cursorLeftComm.moveToNext()) ;
                }
            }
            cursorRightComm.close();
            cursorLeftComm.close();

            db.execSQL("UPDATE temp_sylow SET idproiz = (\n" +
                    "select _id from " + elements[vidWgrup] +
                    " where " + elements[vidWgrup] + ".substitution = temp_sylow.txt and " + elements[vidWgrup] + ".switchboard_num = " + levelComm + "\n" +
                    ");");

        } catch (Exception e) {
            Log.e(TAG, "Error f_testCommCreate " + e.getMessage() );
            DbHelper.err += "Error f_testCommCreate " + e.getMessage();
            e.printStackTrace();
        }

        j = f_getCount("select count(*) as ccc from temp_sylow where idproiz is null;");
        if (DISPLAYLOG)
            Log.e(TAG, " f_testCommCreate kolZap=" + j + " levelComm = " + levelComm);
        mApp.putProt("Для коммутанта уровня " + (levelComm - 1) + " найдено элементов не коммутаторов " + j);

        if (j > 0) { // записать номер коммутанта в elements для новых записей
            db.execSQL("UPDATE " + elements[vidWgrup] + " set switchboard_num = " + levelComm + "\n" +
                    "             where " + elements[vidWgrup] + "._id in (\n" +
                    "                    select M._id from " + elements[vidWgrup] + " M, temp_sylow T where T.idproiz is null and T.txt = M.substitution\n" +
                    "              )  and " + elements[vidWgrup] + "._id in ( \n" +
                    "                    select MM._id from " + elements[vidWgrup] + " MM, temp_sylow TT where TT.idproiz is null and TT.txt = MM.substitution\n" +
                    "           );");
        }

        if (mApp.whatRun != -1 && DbHelper.err.length() == 0) {
            db.setTransactionSuccessful();
        }
        db.endTransaction();

        return j;
    }

    public void f_testCommMul(int levelKomm) {
        // заносит все произведения элементов коммутанта уровня >= levelKomm в temp_sylow (отчеты)
        db.execSQL(" delete from temp_sylow;");

        String sqlTestSel = "insert into temp_sylow (idproiz, idleft, idright, pe, num1, num2)\n" +
                "     select  M.idproiz, M.idleft, M.idright, 0, "+ levelKomm + ", 0\n" +
                "      from " + elements[vidWgrup] + " CL, " + elements[vidWgrup] + " CR, " + temp_multiplication[vidWgrup] + " M\n" +
                "        where M.idleft = CL._id and M.idright = CR._id and " +
                "  CL.switchboard_num >= " + levelKomm + " and  CR.switchboard_num >= " + levelKomm + ";";
        db.execSQL(sqlTestSel);
        if (DISPLAYLOG)
            Log.e(TAG, "f_testCommMul levelKomm = " + levelKomm + " sqlTestSel " + sqlTestSel);
        sqlTestSel = "update temp_sylow set num2 =\n" +
                "(select N.switchboard_num from " + elements[vidWgrup] + " N\n" +
                " where  temp_sylow.idproiz = N._id \n" +
                ") where  temp_sylow.idproiz in\n" +
                "(select K._id from " + elements[vidWgrup] + " K);";
        db.execSQL(sqlTestSel);
        if (DISPLAYLOG)
            Log.e(TAG, "f_testCommMul sqlTestSel= " + sqlTestSel);

    }

    public void f_testSylow(int nomSyl) {
        // строит таблицу temp_sylow для силовской подгруппы с номером nomSyl
        String sqlTestSel;
        db.execSQL("delete from temp_sylow;");
        db.execSQL("UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='temp_sylow';");

        sqlTestSel = "insert into temp_sylow (idproiz, idleft, idright, pe, num1, num2)\n" +
                "     select  M.idproiz, M.idleft, M.idright, CL.pe, CL.num, 0\n" +
                "      from " + sylov_table[vidWgrup] + " CL, " + sylov_table[vidWgrup] + " CR, " + temp_multiplication[vidWgrup] + " M\n" +
                "        where M.idleft = CL.id_s and M.idright = CR.id_s and " +
                "  Cl.num = " + nomSyl + " and  CR.num = " + nomSyl + ";";
        db.execSQL(sqlTestSel);
        if (DISPLAYLOG)
            Log.e(TAG, "f_testSylow nomSyl= " + nomSyl + " sqlTestSel " + sqlTestSel);
        sqlTestSel = "update temp_sylow set num2 =\n" +
                "(select N.num from " + sylov_table[vidWgrup] + " N\n" +
                " where  N.pe = temp_sylow.pe and temp_sylow.idproiz = N.id_s and temp_sylow.num1 = N.num\n" +
                ") where  temp_sylow.idproiz in\n" +
                "(select K.id_s from " + sylov_table[vidWgrup] + " K);";
        db.execSQL(sqlTestSel);
        if (DISPLAYLOG)
            Log.e(TAG, "f_testSylow sqlTestSel= " + sqlTestSel);
    }

    public void f_testCommonSylov(int nomPP, boolean pechat, int urov) {
// строит таблицу temp_sylow для общей силовской подгруппы с номером nomPP, urov - уровень общей подгруппы: 1, 2,...
        String sqlTestSel, sqlSTst;
        Cursor curComSylTest;
        db.execSQL("delete from temp_sylow;");
        db.execSQL("UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='temp_sylow';");
        sqlTestSel = "insert into temp_sylow (idproiz, idleft, idright, pe, num1, num2)\n" +
                "     select  M.idproiz, M.idleft, M.idright, CL.pe, CL.nomer1, 0\n" +
                "      from " + sylov_com_grup[vidWgrup] + " CL, " + sylov_com_grup[vidWgrup] + " CR, " + temp_multiplication[vidWgrup] + " M\n" +
                "        where M.idleft = CL.id_s and M.idright = CR.id_s and " +
                " CL.nomer2 = " + urov + " and CR.nomer2 = " + urov + " and " +
                "  Cl.nomer1 = " + nomPP + " and  CR.nomer1 = " + nomPP + ";";
        db.execSQL(sqlTestSel);
        sqlTestSel = "update temp_sylow set num2 =\n" +
                "(select N.nomer1 from " + sylov_com_grup[vidWgrup] + " N\n" +
                " where  N.pe = temp_sylow.pe and temp_sylow.idproiz = N.id_s and temp_sylow.num1 = N.nomer1\n" +
                ") where  temp_sylow.idproiz in\n" +
                "(select K.id_s from " + sylov_com_grup[vidWgrup] + " K);";
        db.execSQL(sqlTestSel);
        if (pechat) {
            sqlSTst = "select num2 from temp_sylow\n" +
                    "    where instr(num2, num1) = 0; ";
            curComSylTest = db.rawQuery(sqlSTst, null);
            curComSylTest.moveToFirst();

            if (DISPLAYLOG)
                Log.e(TAG, "f_testCommonSylov j= " + nomPP + " urov=" + urov + " ошибок " + curComSylTest.getCount());
            if (curComSylTest.getCount() > 0) {
                mApp.putProt("Для общей силовской подгруппы № " + nomPP + " ошибок проверки на умножением " + curComSylTest.getCount());
                curComSylTest.close();
            }
        }
    }


    public int f_SubsToBase(String table, String nameS, String txtS, int urov) {
        // запись подстановки в табл table = elements*
        int iSubs[] = classSubs.f_toArray(txtS, DbHelper.faktSubsLen),
                deg, i;
        String stab = classSubs.f_stab(faktSubsLen, iSubs),
                sSubs = classSubs.f_toIndependentCycle(faktSubsLen, iSubs);   // привел к независимым циклам как у нас должно быть
        deg = classSubs.f_calculateDeg(false);
        String protText = "";
        for (i = 0; i < substitutionS.arrCiklLen.size(); i++)
            protText += substitutionS.arrCiklLen.get(i) + " ";

        ContentValues cv = new ContentValues();
        cv.put("name", nameS);
        cv.put("substitution", txtS);
        cv.put("deg", deg); // порядок элемента
        cv.put("ciklos", sSubs); // подстановка в виде непересекающихся циклов
        cv.put("pairing_num", 0);
        cv.put("switchboard_num", 0);
        cv.put("center_num", 0);
        cv.put("sylow_num", (String) null);
        cv.put("stabilizer", stab);
        cv.put("pe", substitutionS.peInDeg);
        cv.put("iteration", urov);
        long row_id = db.insert(table, null, cv);
        if (row_id < 0) {
            err += "Ошибка записи в таблицу " + table + ",  txtS " + txtS + " " + row_id;
            Log.e(TAG, "Error f_SubsToBase txtS " + txtS + " " + row_id);
            return -1;
        }
        mApp.putProt(nameS + " " + txtS + " в независимых циклах " + sSubs + " длины циклов " + protText + " порядок подстановки " + deg);

        return 0;
    }


    public void f_getGroupName() {
        // получить имя группы из базы  mApp.groupName
        String sqlSel, parm = "";

        db.beginTransaction();
        try {
            sqlSel = "select val_txt from params where parm = 'GroupName_g';"; // восстановить

            Cursor cursorCount = db.rawQuery(sqlSel, null);
            if (cursorCount.getCount() > 0) {
                if (cursorCount.moveToFirst()) {
                    int k = cursorCount.getColumnIndex("val_txt");
                    if (k >= 0) {
                        do {
                            parm = cursorCount.getString(k);
                        } while (cursorCount.moveToNext());
                    }
                }
            }
            cursorCount.close();

        } catch (Exception e) {
            Log.e(TAG, "Error f_getGroupName " + e.getMessage() );
            err += "Error f_getGroupName " + e.getMessage();
            mApp.curExeption = e;
        }

        try {
            saveSnLen = 0;
            sqlSel = "select ind from params where parm = 'saveSnLen';"; // восстановить
            Cursor cursorCount = db.rawQuery(sqlSel, null);
            if (cursorCount.getCount() > 0) {
                if (cursorCount.moveToFirst()) {
                    int k = cursorCount.getColumnIndex("ind");
                    if (k >= 0) {
                        do {
                            saveSnLen = cursorCount.getInt(k);
                        } while (cursorCount.moveToNext());
                    }
                }
            }
            cursorCount.close();

        } catch (Exception e) {
            Log.e(TAG, "Error f_getGroupName " + e.getMessage() );
            err += "Error f_getGroupName " + e.getMessage();
            mApp.curExeption = e;
        }
        if (mApp.whatRun != -1 && err.length() == 0) {
            db.setTransactionSuccessful();
        }
        db.endTransaction();

        mApp.groupName = parm;
        if (err.length() > 0)
            mApp.f_messError(2,"f_getGroupName", true);
    }

    public boolean f_testFn() { // ?????
        // выход = true - есть сохраненная Sn (флаг Sn не доступен в меню окон если Sn не сохранена)
        String sqlTest = " " + f_getCount("select max(class_area) as ccc from pairing_area_n;");  // max класс в Sn, если она есть
        if (sqlTest != null)
            if (sqlTest.length() > 0)
                if (Integer.parseInt(sqlTest.trim()) != 0) {
                    f_getParm(0, 0, 1);
                    return DbHelper.faktSubsLen <= DbHelper.faktSubsLen_n;
                }
        return false;
    }

    public void f_getParm(int grph, int numActivity, int snFlg) {
        // grph = 1 - считать arrModeLineName в kelyActivity, 0 - из canvas, GrupActivity, образующие не читать
        // numActivity - # откуда вызвана функция
        // snFlg = 0 - восстановить параметры построенной группы G
        // snFlg = 1 - восстановить параметры Sn как параметры группы
        // mApp.tableNameEnd == "_a" - восстановить параметры группы автоморв как параметры группы
        int pe, i;

        substitutionS.sylovPrimeGrupNum.clear(); // порядки сил подгрупп в соответствии с pe в sylovPower
        substitutionS.sylovPower.clear();    // порядки силовских подгрупп соотвественно и после расчета при графе
        substitutionS.sylovGraphNomer.clear(); //  номера силовских подгрупп соотвественно только после расчета  при графе
        substitutionS.sylovOrderPe.clear();      // простые числа: 2, 2, 2, 3, 3 соответственно номерам силовских подгрупп в sylovGraphNomer
        substitutionS.epiEdinica.clear();
        substitutionS.epiPe.clear();    //  P по которым созданы эпиморфизмы (где p=подгрупп > 1) по возрастанию без повторения

        substitutionS.sylovPrimeGrupNum_n.clear(); // порядки сил подгрупп в соответствии с pe в sylovPower
        substitutionS.sylovPower_n.clear();    // порядки силовских подгрупп соотвественно и после расчета при графе
        substitutionS.sylovGraphNomer_n.clear(); //  номера силовских подгрупп соотвественно только после расчета  при графе
        substitutionS.sylovOrderPe_n.clear();      // простые числа: 2, 2, 2, 3, 3 соответственно номерам силовских подгрупп в sylovGraphNomer
        substitutionS.epiEdinica_n.clear();
        substitutionS.epiPe_n.clear();    //  P по которым созданы эпиморфизмы (где p=подгрупп > 1) по возрастанию без повторения

        db.beginTransaction();
        try {
            String parm, sqlSel;

            countElements_n = f_getCount("select count(_id) as ccc from elements_n;");
            countElements_a = f_getCount("select count(_id) as ccc from elements_a;");
            countElements = f_getCount("select count(_id) as ccc from elements; ");
            substitutionS.codEdinicy_a = f_getCount("select _id as ccc from elements_a where deg = 0;");

            sqlSel = "select parm, val_txt, val, ind from params order by parm asc, ind asc;"; // восстановить сохраненные данные

            Cursor cursorCount = db.rawQuery(sqlSel, null);
            if (cursorCount.getCount() > 0) {
                if (cursorCount.moveToFirst()) {
                    int k = cursorCount.getColumnIndex("val_txt"),
                            kp = cursorCount.getColumnIndex("parm"),
                            ki = cursorCount.getColumnIndex("ind"),
                            kv = cursorCount.getColumnIndex("val");
                    if (k >= 0) {
                        if (cursorCount.getCount() > 0) {
                            if (cursorCount.moveToFirst()) {
                                do {
                                    parm = cursorCount.getString(kp);
//    Log.e(TAG, "f_getParm parm = " + parm + " ind = " + cursorCount.getInt(ki) + " val = " + (cursorCount.getString(kv) == null ? "null" : cursorCount.getString(kv)) );
                                    if (parm.equals("Edinica_n")) {
                                        substitutionS.codEdinicy_n = cursorCount.getInt(ki);    // код единицы
                                        substitutionS.Edinica_n = cursorCount.getString(k);
                                    }
                                    if (parm.equals("solvableGroup_n")) { // параметры эпиморфизмов на подстановки сил подгрупп
                                        curKomm = cursorCount.getInt(ki);  // № расчитанного коммутанта
                                        solvableGroup = cursorCount.getInt(kv);  //  = 1; - группа разрешима, все посчитано
                                    }

                                    if (parm.equals("socGrupCount_n")) {
                                        substitutionS.nomSocSub = cursorCount.getInt(kv);  // число подгрупп цоколя  + 1
                                        substitutionS.sel2Multiplier = cursorCount.getString(k);
                                    }

                                    if (parm.equals("faktSubsLen_n")) {
                                        faktSubsLen_n = cursorCount.getInt(ki);
//                                        Log.e(TAG, "DBH f_getParm faktSubsLen_n = " + faktSubsLen_n );
                                    }
                                    if (parm.equals("sylovPrimeGrupNum_n")) // простые числа
                                        substitutionS.sylovPrimeGrupNum_n.add(cursorCount.getInt(kv));

                                    if (parm.equals("EpiMorfizm_n")) { // параметры эпиморфизмов на подстановки сил подгрупп
                                        substitutionS.epiPe_n.add(cursorCount.getInt(ki));  // pe
                                        substitutionS.epiEdinica.add(cursorCount.getString(k));
                                    }
                                    if (vidWgrup == 0) {
                                        if (parm.equals("Edinica_g")) {
                                            substitutionS.codEdinicy = cursorCount.getInt(ki);    // код единицы
                                            substitutionS.Edinica = cursorCount.getString(k);
                                        }
                                        if (parm.equals("solvableGroup_g")) { // параметры эпиморфизмов на подстановки сил подгрупп
                                            curKomm = cursorCount.getInt(ki);  // № расчитанного коммутанта
                                            solvableGroup = cursorCount.getInt(kv);  //  = 1; - группа разрешима, все посчитано
                                        }

                                        if (parm.equals("socGrupCount_g")) {
                                            substitutionS.nomSocSub = cursorCount.getInt(kv);  // число подгрупп цоколя  + 1
                                            substitutionS.sel2Multiplier = cursorCount.getString(k);
                                        }

                                        if (parm.equals("faktSubsLen_g")) {
                                            faktSubsLen = cursorCount.getInt(ki);
//                                        Log.e(TAG, "DBH f_getParm faktSubsLen  = " + faktSubsLen );
                                        }

                                        if (parm.equals("curNumSylov_g"))
                                            curNumSylov = cursorCount.getInt(kv);

                                        if (parm.equals("sylovPrimeGrupNum_g")) // простые числа
                                            substitutionS.sylovPrimeGrupNum.add(cursorCount.getInt(kv));

                                        if (parm.equals("EpiMorfizmg_g")) { // параметры эпиморфизмов на подстановки сил подгрупп
                                            substitutionS.epiPe.add(cursorCount.getInt(ki));  // pe
                                            substitutionS.epiEdinica.add(cursorCount.getString(k));
                                        }
                                    } else {    //  if (vidWgrup == 0)
                                        if (parm.equals("Edinica_a")) {
                                            substitutionS.codEdinicy = cursorCount.getInt(ki);    // код единицы
                                            substitutionS.Edinica = cursorCount.getString(k);
                                        }
                                        if (parm.equals("solvableGroup_a")) { // параметры эпиморфизмов на подстановки сил подгрупп
                                            curKomm = cursorCount.getInt(ki);  // № расчитанного коммутанта
                                            solvableGroup = cursorCount.getInt(kv);  //  = 1; - группа разрешима, все посчитано
                                        }

                                        if (parm.equals("socGrupCount_a")) {
                                            substitutionS.nomSocSub = cursorCount.getInt(kv);  // число подгрупп цоколя  + 1
                                            substitutionS.sel2Multiplier = cursorCount.getString(k);
                                        }

                                        if (parm.equals("faktSubsLen_a")) {
                                            faktSubsLen = cursorCount.getInt(ki);
                                        }

                                        if (parm.equals("curNumSylov_a"))
                                            curNumSylov = cursorCount.getInt(kv);

                                        if (parm.equals("sylovPrimeGrupNum_a")) // простые числа
                                            substitutionS.sylovPrimeGrupNum.add(cursorCount.getInt(kv));

                                        if (parm.equals("EpiMorfizmg_a")) { // параметры эпиморфизмов на подстановки сил подгрупп
                                            substitutionS.epiPe.add(cursorCount.getInt(ki));  // pe
                                            substitutionS.epiEdinica.add(cursorCount.getString(k));
                                        }
                                    }
                                } while (cursorCount.moveToNext());
                            } else
                                mApp.putProt("Не определены общие параметры группы среди сохраненных параметров");
                        }
                    }
                    cursorCount.close();
                }
            }

            int ind, ind1, m;
/*
            // считываю порядки элементов в
            allOrder.clear();   // порядок эл-та
            if (snFlg)
                sqlSel = "select deg, count(*) as chislo from elements_n group by deg order by deg asc; ";
            else
                sqlSel = "select deg, count(*) as chislo from elements group by deg order by deg asc; ";

            cursorCount = db.rawQuery(sqlSel, null);
            ind = cursorCount.getColumnIndex("deg");

            if (cursorCount.getCount() > 0) {
                if (cursorCount.moveToFirst()) {
                    do {
                        m = cursorCount.getInt(ind);
                        allOrder.add(m);
                    } while (cursorCount.moveToNext());
                }
            }
            cursorCount.close();
*/

// порядки сил подгрупп  substitutionS.sylovPrimeGrupNum по pe  в соответствии с pe в sylovPower
/* можно считать из params: силовские подгруппы по простым дл pe
        "insert into params (parm, ind, val, val_txt) " +
                "select 'sylovcount', pe, count(_id), num from sylov_table " +
                "group by pe, num; ",
*/

            if (vidWgrup == 0) {
                String pref = "";
                for (int iq = 0; iq < 2; iq++) {
                    if (iq > 0)
                        pref = "_n";

                    for (i = 0; i < (iq == 0 ? substitutionS.sylovPrimeGrupNum.size() : substitutionS.sylovPrimeGrupNum_n.size()); i++) {
                        pe = (iq == 0 ? substitutionS.sylovPrimeGrupNum : substitutionS.sylovPrimeGrupNum_n).get(i);
                        sqlSel = "select count(_id) as xxx, num from sylov_table" + pref + " where pe = " + pe + " group by num order by num asc; ";

                        cursorCount = db.rawQuery(sqlSel, null);
                        ind = cursorCount.getColumnIndex("xxx");
                        ind1 = cursorCount.getColumnIndex("num");
                        if (cursorCount.getCount() > 0) {
                            if (cursorCount.moveToFirst()) {
                                do {
                                    (iq == 0 ? substitutionS.sylovPower : substitutionS.sylovPower_n).add(cursorCount.getInt(ind));
                                    m = cursorCount.getInt(ind1);
                                    (iq == 0 ? substitutionS.sylovGraphNomer : substitutionS.sylovGraphNomer_n).add(m);
                                    (iq == 0 ? substitutionS.sylovOrderPe : substitutionS.sylovOrderPe_n).add(pe);
                                } while (cursorCount.moveToNext());
                            }
                        }
                        cursorCount.close();

                    }
                }
            } else { // if (vidWgrup == 0)

                for (i = 0; i < substitutionS.sylovPrimeGrupNum.size(); i++) {
                    pe = substitutionS.sylovPrimeGrupNum.get(i);

                    sqlSel = "select count(_id) as xxx, num from sylov_table_a where pe = " + pe + " group by num order by num asc; ";

                    cursorCount = db.rawQuery(sqlSel, null);
                    ind = cursorCount.getColumnIndex("xxx");
                    ind1 = cursorCount.getColumnIndex("num");
                    if (cursorCount.getCount() > 0) {
                        if (cursorCount.moveToFirst()) {
                            do {
                                substitutionS.sylovPower.add(cursorCount.getInt(ind));
                                m = cursorCount.getInt(ind1);
                                substitutionS.sylovGraphNomer.add(m);
                                substitutionS.sylovOrderPe.add(pe);
                            } while (cursorCount.moveToNext());
                        }
                    }
                }
                cursorCount.close();
            }


            if (grph == 1) {    // для графов выбрать образующие группы в allName

                allName.clear();

                sqlSel = "select _id, name || ' ' || ciklos name from elements" + ( snFlg == 1 ? "_n" : mApp.tableNameEnd ) + "  where  iteration = 0; ";
                cursorCount = db.rawQuery(sqlSel, null);
                int iL2 = cursorCount.getColumnIndex("name");
                ind1 = cursorCount.getColumnIndex("_id");
                String namL;
                if (cursorCount.getCount() == 0) {
                    if (countElements_n > 0 || countElements > 0) {
                        err += "Не заданы образующие группы ";
                        Log.e(TAG, "f_getParm Не заданы образующие группы snFlg = " + snFlg + " vidWgrup = " + vidWgrup + " tableNameEnd = " + mApp.tableNameEnd);
                    }
                } else {
//                    Log.e(TAG, "onCreate число элементов группы = " + cursorCount.getCount());

                    if (cursorCount.moveToFirst()) {
                        do {
                            namL = cursorCount.getString(iL2);
                            ind = cursorCount.getInt(ind1);
                            allName.add(ind + " " + namL);

//                Log.e(TAG, "onCreate l=" + namL + " name= " + namL + " pos= " + cursorCount.getPosition());
                        } while (cursorCount.moveToNext());
                    }
                }
                cursorCount.close();
            }


        } catch (Exception e) {
            mApp.curExeption = e;
            err += "Error f_getGroupName " + e.getMessage();
            Log.e(TAG, "Error f_getParm " + e.getMessage() );
        }

        if (mApp.whatRun != -1 && err.length() == 0) {
            db.setTransactionSuccessful();
        }
        db.endTransaction();

        if (mApp.tableNameEnd.equals("_a")) {
            faktSubsLen =  countElements;
            countElements = countElements_a;
        } else if (mApp.tableNameEnd.equals("_n")) {
            countElements = countElements_n;
        }
  //      Log.i(TAG, "f_getParm  tableNameEnd = " + mApp.tableNameEnd + " vidWgrup = " + vidWgrup + " snFlg = " + snFlg + " countElements =  " + countElements + " faktSubsLen = " + faktSubsLen);

        if (err.length() > 0)
            mApp.f_messError(numActivity,"f_getParm", true);
    }


    //   ГРАФЫ
    public List<String> allName = new ArrayList(); // id + " " + name - имена образующих для ребер графа Кели

    public void f_print_short(String txt, short[] mas) {
//
        Log.d("GRAPH", txt + " len=" + mas.length + " mas= ");
//        for (int i = 0; i < 7; i++)
        for (int i = 0; i < mas.length; i++)
            Log.d("GRAPH", " i=" + i + "  ind=" + mas[i] );
    }

    public void f_print_float(String txt, float[] mas) {
//
        Log.d("GRAPH", txt + " len=" + mas.length + " mas= ");
        for (int i = 0; i < mas.length / 3; i++)
//        for (int i = 0; i < 7; i++)
            Log.d("GRAPH", " i=" + i + "  x=" + mas[3 * i] + " y=" + mas[3 * i + 1] + " z=" + mas[3 * i + 2]);
    }


    /*    Это dbH.commonColorTextCount = 6, - общие функции для spinnerColor для ModeActivityGrupp
    потом идут peColorTextCount строк (peColorTextCount =  число сторок для простых pe в substitutionS.sylovPrimeGrupNum.get(i))
        Выделить все силовские подгруппы для простого " + substitutionS.sylovPrimeGrupNum.get(i)

   еще sylovColorTextCount строк (sylovColorTextCount = число строк для силов подгрупп  в substitutionS.sylovGraphNomer.get(i))
        Выделить силовскую подгруппу с номером " +  + substitutionS.sylovGraphNomer.get(i);

   и еще peColorTextCount строк
        Выделить общую погруппу силовских подгрупп для простого " + substitutionS.sylovPrimeGrupNum.get(i);
 */

    static public int kakGraphBuild = 1; // Построение графа Кэли, kak = 1 -  по итерациям, 3 - по силовским подгруппам


    public void f_addition() {
        // вложить группу постановками на своем множестве, заполнить табл addition - регулярное представление

        int idL, idR0 = 1, idR = 0, idP, ind = 1;

        int aNum[] = new int[countElements]; // исходная строка [1,2,...]

        try {
            db.beginTransaction();
            db.execSQL("delete from addition;");
            db.execSQL("UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='addition';");

// на все элементы группы
            Cursor cursorA = db.rawQuery("select distinct idleft, idright, idproiz " +
                    "from " + temp_multiplication[vidWgrup] + " " +
                    "order by idright asc, idleft asc; ", null);
            int iL1 = cursorA.getColumnIndex("idleft"),
                    iL2 = cursorA.getColumnIndex("idright"),
                    iL3 = cursorA.getColumnIndex("idproiz");

            if (cursorA.moveToFirst()) {
                do {
                    idL = cursorA.getInt(iL1);
                    idR = cursorA.getInt(iL2);
                    idP = cursorA.getInt(iL3);
                    if (idR != idR0) {
                        f_addzapis(idR0, aNum, countElements);
                        idR0 = idR;
                        ind = 1;
                    }
//                    if (ind != idL)
//                        Log.e(TAG, "f_addition ERROR ind= " + ind + " != idL= " + idL + " idL=" + idR);

                    aNum[idL - 1] = idP;
//                    if (DISPLAYLOG)
//                        Log.e(TAG, "f_addition ind= " + ind + " idL=" + idL + " idR= " + idR + " idP= " + idP);
                    ind++;
                } while (cursorA.moveToNext());
            }
            f_addzapis(idR, aNum, countElements);
            cursorA.close();

        } catch (Exception e) {
            Log.e(TAG, "Error f_addition " + e.getMessage());
            mApp.curExeption = e;
            err += "Error f_addition " + e.getMessage();
        }
        if (mApp.whatRun != -1 && err.length() == 0) {
            db.setTransactionSuccessful();
        }
        db.endTransaction();
        if (err.length() > 0)
            mApp.f_messError(0,"f_addition", false);
        else
            mApp.putProt("Регулярное представление построено (группа вложена в группу подстановок на " + countElements + " элементах)");

    }

    private void f_addzapis(int id, int[] masAdd, int cElem) {
        // массив masAdd преобразовать в цикли и записать в addition

        String newTxt = "";
        int j;
        if (cElem < 121) {  // в текстовый вид вывожу только для порядка группы < 121
            for (j = 0; j < masAdd.length; j++) {
                if (j > 0)
                    newTxt += ",";
                newTxt += (" " + masAdd[j]);
            }
            newTxt = "[" + newTxt + "]";
        }

        String stab = classSubs.f_stab(cElem, masAdd),
                cykles = classSubs.f_toIndependentCycle(cElem, masAdd),
                lCyklos = "";

        for (j = 0; j < substitutionS.arrCiklLen.size(); j++)
            lCyklos += " " + substitutionS.arrCiklLen.get(j);
        int dgSb = classSubs.f_calculateDeg(false);
        String sqlAdd = "insert into addition (main_id, cykl, clength, deg, parity, stabilizer, substitution) values ( " + id + ", '"
                + cykles + "', '" + lCyklos + "', " + dgSb + ", " + substitutionS.parity + ", '" + stab + "', '" + newTxt +"');";
        if (DISPLAYLOG)
            Log.e(TAG, "f_addzapis id= " + id + " cykles=" + cykles + " lCyklos= " + lCyklos + " dgSb= " + dgSb + " cElem= "+ cElem + " newTxt = "+ newTxt + " sqlAdd= " + sqlAdd);
        db.execSQL(sqlAdd);
    }
    // f_calculateDeg
    static public String selectedMas[]; // массив, возвращаемый f_getMas()
    static public int selectMasInt[]; // массив, возвращаемый f_getMInt()

    static public int f_getMInt(String selStr) {
        // выбор массива int[]
        // выдает массив selectMasInt по selStr вида  "select distinct num as stext from ...
        int valInt;
        List<Integer> val = new ArrayList();
        try {
            db.beginTransaction();
            Cursor cursorA = db.rawQuery(selStr, null);
            int iL1 = cursorA.getColumnIndex("stext");

            if (cursorA.moveToFirst()) {
                do {
                    valInt = cursorA.getInt(iL1); // выражение вида p = 2 № 4
                    val.add(valInt);
//                    Log.e(TAG, "f_getMInt i =" + iL1 + " val = " + valInt + " " + selStr);
                } while (cursorA.moveToNext());
            }
            cursorA.close();
        } catch (Exception e) {
            err += "Error f_getMInt " + e.getMessage();
            e.printStackTrace();
        }
        if (err.length() == 0) {
            db.setTransactionSuccessful();
        }
        db.endTransaction();
        selectMasInt = new int[val.size()];
        for (int k = 0; k < val.size(); k++) {
            selectMasInt[k] = val.get(k);
//            Log.e(TAG, "f_getMInt k = " + k + " selectMasInt = " + selectMasInt[k] + " " + selectMasInt.length);
        }

        return val.size();
    }

    static public int f_getMas(String selStr) {
        // выдает массив selectedMas по selStr вида  "select distinct 'p = '||pe|| ' № ' || num as stext from ...
        String valStr;
        List<String> val = new ArrayList();
        selectedMas = new String[] {""};
        try {
            db.beginTransaction();
            Cursor cursorA = db.rawQuery(selStr, null);
            int iL1 = cursorA.getColumnIndex("stext");

            if (cursorA.moveToFirst()) {
                do {
                    valStr = cursorA.getString(iL1); // выражение вида p = 2 № 4
                    val.add(valStr);
                } while (cursorA.moveToNext());
            }
            cursorA.close();
        } catch (Exception e) {
            err += "Error f_getMas " + e.getMessage();
            e.printStackTrace();
        }
        if (err.length() == 0) {
            db.setTransactionSuccessful();
        }
        db.endTransaction();
        selectedMas = new String[val.size()];
        selectedMas = val.toArray(selectedMas);
//    Log.e(TAG, "f_getMas = " + selectedMas.length);

        return val.size();
    }


    public String f_getString(String selStr) {
        // выдает 1 строку selectedMas по selStr вида  "select distinct as stext from ...
        String valStr = "";
            Cursor cursorGetStrA = db.rawQuery(selStr, null);
            int iL1 = cursorGetStrA.getColumnIndex("stext");

        if (cursorGetStrA.moveToFirst()) {
            if (cursorGetStrA.getCount() > 0) {
               valStr = cursorGetStrA.getString(iL1); // выражение вида p = 2 № 4
                }
            }
            cursorGetStrA.close();
        //    Log.e(TAG, "f_getString = " + selectedMas[0] + " " + selectedMas.length);

        return valStr;
    }


    public int f_getCount(String SQL) {
        // выдает число вернутое SQL, аргумент SQL = select xxx as ccc from .... или 0
        int rtn = 0;
        Cursor mCursorGC = db.rawQuery(SQL, null);

        if (mCursorGC.moveToFirst()) {
            if (mCursorGC.getCount() > 0) {
                int iL4 = mCursorGC.getColumnIndex("ccc");
                rtn = mCursorGC.getInt(iL4);
//                Log.e(TAG, "f_getCount i =" + iL4 + " val = " + rtn + " " + SQL);
            }
        }
        mCursorGC.close();
        return rtn;
    }

    public int f_getCountRow(String SQL) {
        // выдает getCount() SQL, аргумент SQL = select xxx from .... или 0

        Cursor cursorCeck = db.rawQuery(SQL, null);
        int j = cursorCeck.getCount(); // число найденных элементов
        cursorCeck.close();
        return j;
    }

    final private List<Integer> pe_Dist = new ArrayList<>();    // все простые по одному экземпляру
    final private List<Integer> pe_Common = new ArrayList<>();    // все простые по одному экземпляру для sylov_com_grup

    public List<Integer> f_getPeDistinct(boolean snFlag) {
        // возвращает pe_Dist = список простых

        int i, i1;
        if (snFlag)
            i1 = f_getMas("select distinct ' '||pe as stext from sylov_table_n order by 1 asc;");
        else
            i1 = f_getMas("select distinct ' '||pe as stext from " + sylov_table[vidWgrup] + " order by 1 asc;");

        pe_Dist.clear();
        for (i = 0; i < i1; i++)
            pe_Dist.add(Integer.parseInt(selectedMas[i].trim()));

        return pe_Dist;
    }

    public List<Integer> f_getPeCommon(int uroven, boolean snFlag) {
        // возвращает
        // уровня uroven, snFlag = true - выбор для Sn

        int i, i1;
        if (snFlag)
            i1 = f_getMas("select distinct ' '||pe as stext from sylov_com_grup_n where nomer2 = " + uroven + " order by 1 asc;");
        else
            i1 = f_getMas("select distinct ' '||pe as stext from " + sylov_com_grup[vidWgrup] + " where nomer2 = " + uroven + " order by 1 asc;");

        pe_Common.clear();

        for (i = 0; i < i1; i++)
            pe_Common.add(Integer.parseInt(selectedMas[i].trim()));

        return pe_Common;
    }

    // извлечение данных из subgrups
    static String selectGrupGrid = "",   // выбор из таблицы subgrups грид
            selectGrupSum = "";  // выбор из таблицы subgrups итога
    static public List<String> grupZag = new ArrayList<>(), // залоговки для грид без id_element
            grupRow = new ArrayList<>(); // реквизиты строк для грид без id_element
    public synchronized void f_buildSelectSubgrups(int sylowGrChislo, boolean itogYes, boolean sortCod, boolean snFlg) {
        // строит selectGrupGrid, selectGrupSum, grupZag из таблицы subgrups или subgrups_n
        // sylowGrChislo - число  подгрупп в выборке
        // itogYes = true - добавить колонку: count(*) as ccc
        //          false - добавить колонку: _id
        // sortCod = true - добавить сортировку по всем колонкам, иначе сортировка по классу и Id
        // class_area выбирается только при sortCod = false !!!
        // snFlg = true - строить для таблицы subgrups_n

        // для коммутанта вместо 1 пишется номер коммутанта: 1, 2, 3 !!!!

        if (DISPLAYLOG)
            Log.e(TAG, "f_buildSelectSubgrups  sylowGrChislo= " + sylowGrChislo + " snFlg= "+ snFlg);

        int i, i1, i2;
        String ss, qq;
        List<Integer> peDist = f_getPeDistinct(snFlg);    // все простые по одному экземпляру

        selectGrupGrid = "select id_element as id_element, flag_parity as flag_parity, flag_commutant as flag_commutant, ";
        selectGrupSum = "select sum(flag_parity) as flag_parity, sum(flag_commutant) as flag_commutant, ";
        grupZag.clear();
        grupRow.clear();
        if (itogYes) {
            grupZag.add("Вся группа");    // действует только на selectGrupSum
            grupRow.add("ccc");
        } else {
            grupZag.add("Id элемента");    // действует только на selectGrupGrid
            grupRow.add("_id");
        }
        grupZag.add("Четные подстановки");
        grupZag.add("Коммутант");

        grupRow.add("flag_parity");
        grupRow.add("flag_commutant");

        for (i = 0; i < Math.min(faktSubsLen, sylowGrChislo); i++) {
            selectGrupGrid += "flag_stab_" + (i + 1) + " as flag_stab_" + (i + 1) + ",\n"; // 1 - стабилизатор для i+1
            selectGrupSum += "sum(flag_stab_" + (i + 1) + ") as flag_stab_" + (i + 1) + ",\n"; // 1 - стабилизатор для i+1
            grupZag.add("Стабилизатор точки " + (i + 1));
            grupRow.add("flag_stab_" + (i + 1));
        }
        if (DISPLAYLOG)
            Log.e(TAG, "peDist size= " + peDist.size());
        for (i = 0; i < substitutionS.epiPe.size(); i++) {    // цикл P
            selectGrupGrid += "flag_ker_" + substitutionS.epiPe.get(i) + " as flag_ker_" + substitutionS.epiPe.get(i) + ",\n"; // 1 - принадлежит ядру эпиморфизма на силовскую подгруппу peDist.get(i-1)
            selectGrupSum += "sum(flag_ker_" + substitutionS.epiPe.get(i) + ") as flag_ker_" + substitutionS.epiPe.get(i) + ",\n";
            grupZag.add("Ядро эпи-зма на силов подг-пу P = " + substitutionS.epiPe.get(i));
            grupRow.add("flag_ker_" + substitutionS.epiPe.get(i));
        }

        for (i = 0; i < peDist.size(); i++) {    // цикл P
            if (snFlg)
                i2 = f_getMas("select distinct 'n = '||num as stext from sylov_table_n where pe = " + peDist.get(i) + " order by 1 asc;");
            else
                i2 = f_getMas("select distinct 'n = '||num as stext from sylov_table" + mApp.tableNameEnd + " where pe = " + peDist.get(i) + " order by 1 asc;");
            for (i1 = 0; i1 < i2; i1++) {   // цикл по сил подгруппам
                if (i1 < sylowGrChislo) {
                    ss = selectedMas[i1].substring(4);
                    qq = "_" + peDist.get(i) + "_" + ss;
                    selectGrupGrid += "flag_sylow" + qq +
                            " as flag_sylow" +  qq + ", \n";   // 1 - принадлежит силовской подгруппе № N для P= peDist.get(i-1)

                    selectGrupSum += "sum(flag_sylow" + qq + ") " +
                            " as flag_sylow" + qq + ", \n";
                    grupZag.add("Силов подг-па для P = " + peDist.get(i) + " № " + ss);
                    grupRow.add("flag_sylow" + qq);


//                    ss = "selectGrupGrid = " + selectGrupGrid.length() + "selectGrupSum = " + selectGrupSum.length() +
//                            " grupZag=" + grupZag.size() + " grupRow=" + grupRow.size();
//           Log.e(TAG, "sylowGrChislo = " + sylowGrChislo + " i= "+ i + " i1= "+ i1 + " i2= "+ i2 + " " + ss +" qq=" + qq) ;
                }
            }
            if (DISPLAYLOG)
                Log.e(TAG, "peDist i= " + i + " p=" + peDist.get(i));

        }
        // общие силов подгр
        List<Integer> peCom1 = f_getPeCommon(1, snFlg);    // уровня 1
        List<Integer> peCom2 = f_getPeCommon(2, snFlg);    // уровня 2

        for (i = 0; i < peCom1.size(); i++) { //  общие силовские подгруппы  уровня 1
            if (snFlg)
                i2 = f_getMas("select distinct 'n = '||nomer1 as stext from sylov_com_grup_n where pe = " + peCom1.get(i) + " and nomer2 = 1 order by 1;");
            else
                i2 = f_getMas("select distinct 'n = '||nomer1 as stext from sylov_com_grup" + mApp.tableNameEnd + " where pe = " + peCom1.get(i) + " and nomer2 = 1 order by 1;");
            for (i1 = 0; i1 < i2; i1++) {
                if (i1 < sylowGrChislo) {
                    ss = selectedMas[i1].substring(4);
                    qq = "_" + peCom1.get(i) + "_" + ss;
                    selectGrupGrid += "flag_Comm1" + qq +
                            " as flag_Comm1" + qq + ", \n";

                    selectGrupSum += "sum(flag_Comm1" + qq + ") " +
                            " as flag_Comm1" + qq + ", \n";
                    grupZag.add("Общая силов подг-па для P = " + peCom1.get(i) + " № " + ss + " уровня 1 ");
                    grupRow.add("flag_Comm1" + qq);
                }
            }
        }

        for (i = 0; i < peCom2.size(); i++) { //  общие силовские подгруппы  уровня 2
            if (snFlg)
                i2 = f_getMas("select distinct 'n = '||nomer1 as stext from sylov_com_grup_n where pe = " + peCom2.get(i) + " and nomer2 = 2 order by 1;");
            else
                i2 = f_getMas("select distinct 'n = '||nomer1 as stext from sylov_com_grup" + mApp.tableNameEnd + " where pe = " + peCom2.get(i) + " and nomer2 = 2 order by 1;");
            for (i1 = 0; i1 < i2; i1++) {
                if (i1 < sylowGrChislo) {
                    ss = selectedMas[i1].substring(4);
                    qq = "_" + peCom2.get(i) + "_" + ss;
                    selectGrupGrid += "flag_Comm2" + qq +
                            " as flag_Comm2" + qq + ", \n";

                    selectGrupSum += "sum(flag_Comm2" + qq + ") " +
                            " as flag_Comm2" + qq + ", \n";
                    grupZag.add("Общая силов подг-па для P = " + peCom2.get(i) + " № " + ss + " уровня 2");
                    grupRow.add("flag_Comm2" + qq);
                }
            }
        }

        selectGrupGrid += " id_element as _id";
        selectGrupSum += " 0 as _id";
        if (itogYes) {
            selectGrupGrid += ", 1 as ccc ";
            selectGrupSum += ", count(*) as ccc ";
        }
        selectGrupGrid += ", flag_zentr as flag_zentr ";
        selectGrupSum += ",  sum(flag_zentr) as flag_zentr ";
        grupZag.add("Центр");
        grupRow.add("flag_zentr");

        if (substitutionS.nomSocSub > 0) {
            for (i = 0; i < substitutionS.nomSocSub -1; i++) {
                selectGrupGrid += ", flag_soc_" + (i + 1) + " as flag_soc_" + (i + 1) +" ";
                selectGrupSum += ",  sum(flag_soc_" + (i + 1) + " ) as flag_soc_" + (i + 1) + " ";
                grupZag.add("Подгруппа цоколя № " + (i+1));
                grupRow.add("flag_soc_" + (i + 1));
            }
            selectGrupGrid += ", flag_socol as flag_socol ";
            selectGrupSum += ",  sum(flag_socol) as flag_socol  ";
            grupZag.add("Цоколь");
            grupRow.add("flag_socol");
        }

        if (sortCod) {
            if (snFlg) {
                selectGrupGrid += "  from subgrups_n order by ";
                selectGrupSum += "  from subgrups_n order by ";
            } else {
                selectGrupGrid += "  from subgrups" + mApp.tableNameEnd + " order by ";
                selectGrupSum += "  from subgrups" + mApp.tableNameEnd + " order by ";
            }
            for (i = 1; i < grupRow.size(); i++) {  // сортировка в SQL
                if (i > 1) {
                    selectGrupGrid += ",";
                    selectGrupSum += ",";
                }
                selectGrupGrid += " " + (i + 1) + " desc ";
                selectGrupSum += " " + (i + 1) + " desc ";
            }
        } else {
// CREATE TABLE pairing_area (_id	INTEGER  primary key autoincrement, class_area INTEGER,   num INTEGER,   id_subs  INTEGER NOT NULL, cykl_len TEXT)
            if (snFlg) {
                selectGrupGrid += ", P.class_area as class_area from subgrups_n, pairing_area_n P where subgrups_n.id_element = P.id_subs order by P.class_area asc, subgrups_n.id_element asc  ";
                selectGrupSum += " from subgrups_n ";
            } else {
                selectGrupGrid += ", P.class_area as class_area from subgrups" + mApp.tableNameEnd + ", pairing_area" + mApp.tableNameEnd + " P where subgrups" + mApp.tableNameEnd + ".id_element = P.id_subs order by P.class_area asc, subgrups" + mApp.tableNameEnd + ".id_element asc  ";
                selectGrupSum += " from subgrups" + mApp.tableNameEnd + " ";
            }
        }
        selectGrupGrid += ";";
        selectGrupSum += ";";

        if (DISPLAYLOG) {
            Log.e(TAG, "f_buildSelectSubgrups selectGrupGrid=" + selectGrupGrid);
            Log.e(TAG, "f_buildSelectSubgrups selectGrupSum=" + selectGrupSum);
       }
        /* selectGrupSum=select sum(flag_parity) as flag_parity, sum(flag_commutant) as flag_commutant, sum(flag_stab_1) as flag_stab_1,
                                                                                                    sum(flag_stab_2) as flag_stab_2,
                                                                                                    sum(flag_stab_3) as flag_stab_3,
                                                                                                    sum(flag_stab_4) as flag_stab_4,
                                                                                                    sum(flag_stab_5) as flag_stab_5,
                                                                                                    sum(flag_stab_6) as flag_stab_6,
                                                                                                    sum(flag_stab_7) as flag_stab_7,
                                                                                                    sum(flag_stab_8) as flag_stab_8,
                                                                                                    sum(flag_ker_1) as flag_ker_1,
                                                                                                    sum(flag_ker_2) as flag_ker_2,
                                                                                                    sum(flag_ker_3) as flag_ker_3,
                                                                                                    sum(flag_sylow_1_7)  as flag_sylow_1_7,
                                                                              sum(flag_sylow_1_8)  as flag_sylow_1_8,
                                                                                                    sum(flag_sylow_1_9)  as flag_sylow_1_9,
                                                                                                    sum(flag_sylow_2_22)  as flag_sylow_2_22,
                                                                                                    sum(flag_sylow_2_23)  as flag_sylow_2_23,
                                                                                                    sum(flag_sylow_2_24)  as flag_sylow_2_24,
                                                                                                    sum(flag_sylow_3_1)  as flag_sylow_3_1,
                                                                                                    sum(flag_sylow_3_2)  as flag_sylow_3_2,
                                                                                                    sum(flag_sylow_3_3)  as flag_sylow_3_3,
                                                                                                    sum(flag_Comm1_1_1)  as flag_Comm1_1_1,
                                                                                                    sum(flag_Comm1_1_10)  as flag_Comm1_1_10,
                                                                                                    sum(flag_Comm1_1_11)  as flag_Comm1_1_11,
                                                                                                    sum(flag_Comm1_2_16)  as flag_Comm1_2_16,
                                                                                                     0 as _id, count(*) as ccc ,  sum(flag_zentr) as flag_zentr ,  sum(flag_soc_1 ) as flag_soc_1 ,  sum(flag_soc_2 ) as flag_soc_2 ,  sum(flag_socol) as flag_socol from subgrups  order by  2 desc , 3 desc , 4 desc , 5 desc , 6 desc , 7 desc , 8 desc , 9 desc , 10 desc , 11 desc , 12 desc , 13 desc , 14 desc , 15 desc , 16 desc , 17 desc , 18 desc , 19 desc , 20 desc , 21 desc , 22 desc , 23 desc , 24 desc , 25 desc , 26 desc , 27 desc , 28 desc , 29 desc , 30 desc , 31 desc ;

         */
    }




    @Override
    public synchronized void close() {
        if (DISPLAYLOG)
            Log.d(TAG, "close ");
        dbCreate = true; // надо создавать
        if (db != null)
            db.close();
        super.close();

    }

    public void f_clearDB(int vidWgrup) {
        // очистить базу для новой группы

        //        Log.e(TAG, "f_clearDB");
        int j;
        if (vidWgrup == 0) { //  новая группа
            for (j = 0; j < TblTmpName.length; j++) {
                if (! TblTmpName[j].equals("params")) {
                    db.execSQL("DELETE FROM " + TblTmpName[j] + ";");
                    db.execSQL("UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='" + TblTmpName[j] + "';");
//                    Log.e(TAG, "f_clearDB DELETE FROM " + TblTmpName[j] + "  новая группа");
                }
            }
            for (j = 0; j < tblMainName.length; j++) {  // elements_a, elements чищу
                db.execSQL("DELETE FROM " + tblMainName[j] + ";");
                db.execSQL("UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='" + tblMainName[j] + "';");
//                Log.e(TAG, "f_clearDB DELETE FROM " + TblTmpName[j] + "  новая группа");
            }
        } else {    // новая группа автоморфизмов
            for (j = 0; j < TblTmpName.length; j++) {
                if (!TblTmpName[j].equals("params") &&
//                        !TblTmpName[j].equals("elements") &&
                        !TblTmpName[j].equals("elements_a") &&
                        !TblTmpName[j].equals("auto_centralizer") &&
                        !TblTmpName[j].equals("auto_normalizer")) {
                    db.execSQL("DELETE FROM " + TblTmpName[j] + ";");
                    db.execSQL("UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='" + TblTmpName[j] + "';");
//                    Log.e(TAG, "f_clearDB DELETE FROM " + TblTmpName[j] + "  новая группа автоморфизмов");
                }
            }
        }

        arrInitName.clear();
        arrInitSubs.clear();
        maxNum.clear();
    }

//  создание
//================================

    @Override
    public void onCreate(SQLiteDatabase db) {
        // вызывается при первом создании базы данных
        if (DISPLAYLOG)
            Log.e(TAG, "onCreate dbCreate=" + dbCreate);
        if (dbCreate) {
            return;
        }

        for (String s : TblTmpName) {
            db.execSQL("DROP TABLE IF EXISTS " + s);
            if (DISPLAYLOG)
                Log.d(TAG, "onCreate DROP TABLE  " + s);
        }

        for (String s : tblMainName) {
            db.execSQL("DROP TABLE IF EXISTS " + s);
            db.execSQL("DROP TABLE IF EXISTS " + s + "_n");
            if (DISPLAYLOG)
                Log.d(TAG, "onCreate DROP TABLE  " + s + " _n");
        }

//        tblMainName =  mApp.getResources().getStringArray(R.array.tableMain); // массив строк имен таблиц с _n, _a

        final String str1[] = {

//   tmp_tab_correction -  таблица создается всегда в classForResearch.f_resech()
//   а заполняется по меню Доп расчеты -> Покомпонентная сумма

// soc_tmp : колонка ki - соответствует классу i,  num = номер норм подгр-пы

                "create table IF NOT EXISTS sylov_common_n" + // общие эл-ты в силовских подгруппах - количество силовских подгрупп для общего элемента
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe	INTEGER," +
                        "id_s  INTEGER NOT NULL, " +   // все подстановки силовской подгруппы
                        "count_id INTEGER, " +
                        "parity INTEGER " + // количество силовских подгрупп для общего элемента id_s для подгруппы четных подстановок
                        "); ",

                "create table IF NOT EXISTS sub_scribe" + // text_sub есть substitution каждые 5 колонок занимает 1 переставляемая единица
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_s  INTEGER NOT NULL, " +   //
                        "text_sub TEXT" +
                        "); ",

                "create table IF NOT EXISTS sub_scribe_a" + // text_sub есть substitution каждые 5 колонок занимает 1 переставляемая единица
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_s  INTEGER NOT NULL, " +   //
                        "text_sub TEXT" +
                        "); ",

                "create table IF NOT EXISTS sub_scribe_n" + // text_sub есть substitution каждые 5 колонок занимает 1 переставляемая единица
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_s  INTEGER NOT NULL, " +   //
                        "text_sub TEXT" +
                        "); ",

                "create table IF NOT EXISTS charac_group" + // только  характаристические подгруппы
                        " (_id INTEGER primary key autoincrement,  " +
                        "num_subs INTEGER NOT NULL, " +   // номер характер подгруппы
                        "porjadok INTEGER, " +        // порядок
                        "cykl_len TEXT" +
                        "); ",

                "create table IF NOT EXISTS charac_class" + // образы классов и характаристические классы
                        " (_id INTEGER primary key autoincrement,  " +
                        "class_in INTEGER NOT NULL, " +   // номер класса
                        "class_out INTEGER NOT NULL, " +   // номер образа  класса
                        "chararter INTEGER, " +   // 1 - номер не изменился
                        "porjadok INTEGER, " +    // порядок класса
                        "cykl_in TEXT, " +     // цикл типы класса
                        "cykl_out TEXT " +
                        "); ",

                "create table IF NOT EXISTS charac_cykls " + // образы cykl_len и характаристические cykl_len
                        " (_id INTEGER primary key autoincrement,  " +
                        "cykl_in TEXT NOT NULL, " +   // цикл тип
                        "cykl_out TEXT NOT NULL, " +   // номер его образа
                        "chararter INTEGER, " +   // 1 - номер не изменился
                        "porjadok INTEGER, " +    // число эл-тов этого цикл типа
                        "classes_in TEXT, " +    // классы этого цикл типа
                        "classes_out TEXT" +     // классы этого цикл типа
                        "); ",

                "create table IF NOT EXISTS charac_sylow" + // характаристические подгруппы
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe INTEGER NOT NULL, " +
                        "num_in INTEGER NOT NULL, " +   // номер сил подгруппы
                        "num_out INTEGER NOT NULL, " +  // номер образа
                        "id_auto INTEGER" +        // id автоморфизма
                        "); ",


// таблицы auto  содержат id автоморфизма и поэтому большие

                "create table IF NOT EXISTS auto_cykls " + // изменения cykl_len  при автоморфизмах
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_in INTEGER, " +    // id G до автом
                        "id_out INTEGER, " +    // id G после автом
                        "id_auto INTEGER, " +    // id автоморфизма
                        "cykl_in TEXT NOT NULL, " +   // номер класса
                        "cykl_out TEXT NOT NULL " +   // номер образа  класса
                        "); ",

                "create table IF NOT EXISTS auto_sylow " + // отображение силовских подгрупп при автоморфизмах
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe INTEGER, " +
                        "id_in INTEGER, " +
                        "id_out INTEGER, " +
                        "id_auto INTEGER, " +    // id автоморфизма
                        "num_in INTEGER, " +   // номер подгруппы
                        "num_out INTEGER, " +  // номер образа
                        "sylow_in TEXT,  " +   // номер подгруппы
                        "sylow_out" +   // номер образа
                        "); ",

                "CREATE INDEX IF NOT EXISTS index_auto_sylow " +
                        "  ON auto_sylow (num_out ASC ); ",

                "create table IF NOT EXISTS auto_group " + // отображение нормальных подгрупп при автоморфизмах
                        " (_id INTEGER primary key autoincrement,  " +
                        "num_in INTEGER NOT NULL, " +   // номер
                        "num_out INTEGER NOT NULL, " +   // номер
                        "field_work TEXT, " +        // порядок num_out
                        "porjadok INTEGER" +        // порядок
                        "); ",

                "create table IF NOT EXISTS auto_class " + // отображение нормальных подгрупп при автоморфизмах
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_in INTEGER, " +
                        "id_out INTEGER, " +
                        "id_auto INTEGER, " +    // id автоморфизма
                        "class_in INTEGER,  " +   // номер класса
                        "class_out INTEGER" +   // номер образа
                        "); ",


                "create table IF NOT EXISTS elements_n (" +    // все элементы группы
                        "_id	INTEGER  primary key autoincrement, " +  // код элемента
                        "id_true INTEGER  NOT NULL, " +    // истинный _id
                        "name	TEXT," +         // название элемента или его выражение через образующие
                        "substitution TEXT NOT NULL," +    // подстановка
                        "ciklos TEXT," +       // подстановка в виде непересекающихся циклов
                        "deg INTEGER, " +         // степень элемента
                        "pairing_num INTEGER, " +     // номер группы сопряженных элементов
                        "sylow_num TEXT, " +     // номера силовских подгруппы в которые входит этот элемент
                        "primitiv TEXT, " +       // null, а если это степень другого эл-та = степень (для цикл сил подгрупп)
                        "forming TEXT, " +       // образующий, который в степни primitiv есть этот элемент
                        "switchboard_num INTEGER, " + // 0, если это элемент коммутанта =1
                        "center_num INTEGER, " +   // порядок централизатора
                        "stabilizer TEXT," +       // номера чисел 1,2,3,..., для которых подстановка является стабилизатором
                        "cykl_len TEXT," +       // цикловой тип подстановки
                        "pe INTEGER, " + // если порядок элемента степень простого = это простое p иначе 0
                        "iteration	INTEGER NOT NULL," +
                        "parity INTEGER, " + // если подстановка четная = 0, иначе 1
                        "nomer_soc INTEGER" +
                        "," + // дополнительные поля:
                        "for_n  INTEGER, " + // подстановки для 1,... for_n
                        "link_to_elements INTEGER " + // id в elements
                        "); ",

                "create table IF NOT EXISTS elements_a (" +    // все элементы группы автоморфизмов
                        "_id INTEGER  primary key autoincrement, " + // истинный _id автоморфизм
                        "name	TEXT," +         // название элемента или его выражение через образующие
                        "substitution TEXT," +    // подстановка
                        "ciklos TEXT," +       // подстановка в виде непересекающихся циклов
                        "deg INTEGER, " +         // степень элемента
                        "pairing_num INTEGER, " +     // номер группы сопряженных элементов
                        "sylow_num TEXT, " +     // номера силовских подгруппы в которые входит этот элемент
                        "primitiv TEXT, " +       // null, а если это степень другого эл-та = степень (для цикл сил подгрупп)
                        "forming TEXT, " +       // образующий, который в степни primitiv есть этот элемент
                        "switchboard_num INTEGER, " + // 0, если это элемент коммутанта =1
                        "center_num INTEGER, " +   // порядок централизатора
                        "stabilizer TEXT," +       // номера чисел 1,2,3,..., для которых подстановка является стабилизатором
                        "cykl_len TEXT," +       // цикловой тип подстановки
                        "pe INTEGER, " + // если порядок элемента степень простого = это простое p иначе 0
                        "iteration	INTEGER," +
                        "parity INTEGER, " + // если подстановка четная = 0, иначе 1
                        "nomer_soc INTEGER, " +
               // дополнительные поля:
                        "link_to_group INTEGER, " + // id в elements если внутренний автоморфизм группы
                        "link_to_sn INTEGER " + // id в elements_n  если внутренний автоморфизм Sn
                        "); ",

                "create table IF NOT EXISTS temp_multiplication_n " + // таблица произведений (умножения)
                        " (_id INTEGER primary key autoincrement,  " +
                        " idproiz INTEGER,  " +  // код элемента - произведения
                        " idleft INTEGER NOT NULL, idright INTEGER NOT NULL," +
                        " name	TEXT," +         // название элемента или его выражение через образующие
                        " name_old	TEXT," +      // название элемента из elements,если полученный элемент уже есть в таблице elements
                        " txt TEXT  NOT NULL," +
                        "iteration	INTEGER, " +
                        "deg INTEGER " +      // степень элемента
                        "); ",

                "create table IF NOT EXISTS sylov_table_n " + // все построенные  силовские подгруппы
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe	INTEGER," +
                        "num  INTEGER, " +  // номер подгруппы, сквозая нумирация по всем pe
                        "num_resech INTEGER, " +  // номер подгруппы в sylov_table
                        "id_main  INTEGER NOT NULL, " +  // порождающая подстановка
                        "id_s  INTEGER NOT NULL, " +   // все подстановки силовской подгруппы
                        "id_resech INTEGER, " +    // _id подстановки в в sylov_table
                        "effort INTEGER, " + // число итераций при просеивании сил подгруппы
                        "parity INTEGER, " + // если подстановка четная = 0, иначе 1
                " norm_nomer integer);", // временный номер норм поднруппы

                "create table IF NOT EXISTS sylov_com_grup_n (" +    //  общие подгруппы силовских подгрупп (1 строка на элемент подгруппы)
                        "_id	INTEGER  primary key autoincrement, " +
                        "pe INTEGER NOT NULL, " +
                        "sylow_zag	TEXT NOT NULL, " + // кучка подгрупп
                        "id_s integer NOT NULL," + //  код элемента
                        " nomer1 integer, " +  // № подгруппы, сквозая нумирация по всем pe и уровням
                        " nomer2 integer, " + // уровень вложенности
                " norm_nomer integer);", // временный номер норм поднруппы

                "create table IF NOT EXISTS sylow_attachments_n " + // табл вложения p-под неибольшего порядка
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe	INTEGER, " +
                        "main_lelel INTEGER NOT NULL, " +  // уровень программы
                        "mail_num INTEGER NOT NULL, " + // номер программы
                        "att_level INTEGER, " +         // уровень подпрограммы
                        "att_num INTEGER, " +         // номер подпрограммы
                        "att_order INTEGER, " +    // порядок подпрограммы
                        "att_index INTEGER " +       // индекс подгруппы
                        "); ",

                "create table IF NOT EXISTS pairing_area_n (" + // области сопр элементов когда сопряжение делается одним эл-том id_imagine над другими id_subs
                        "_id	INTEGER  primary key autoincrement, " +
                        "class_area INTEGER,   " +  // код класса сопряженных элементов
                        "num INTEGER,   " +  // № подгруппы цоколя
                        "id_subs  INTEGER NOT NULL, " +  // _id элементов класса
                        "cykl_len TEXT, " +       // цикловой тип подстановки
                        "dubl INTEGER " +  //  = 1 - класс соответствует некоторому порядку элемета другого класс с dubl = 0
                        ");",

                "create table IF NOT EXISTS epimorphism_n " + // таблица эпиморфизма на группы подстановок сил подгрупп
// записи могут повторяться
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_element INTEGER NOT NULL,  " +  // код элемента = _id elements
                        "id_obraz INTEGER, " +          // id образа, заполняется только для уникального элемента образа (Они повторяются согласно смежным классам по ядру)
                        "pe	INTEGER NOT NULL, " +
                        "substitution TEXT NOT NULL," +
                        "ciklos TEXT, " +
                        "cykl_len TEXT, " +
                        "deg INTEGER, " +
                        "adjacent INTEGER" +  // № смежного класса
                        "); ",

                "create table IF NOT EXISTS addition (" +    // все элементы группы вложенные по теореме Кэли
                        "_id	INTEGER  primary key autoincrement, " +
                        "main_id INTEGER NOT NULL, " +  // код элемента
                        "clength	TEXT, " +   // цикл тип новой подст-ки
                        "substitution TEXT, " +
                        "deg	integer," +
                        "cykl	TEXT," +
                        "stabilizer TEXT," +       // номера чисел 1,2,3,..., для которых подстановка является стабилизатором
                        "parity integer);",

                "create table IF NOT EXISTS addition_n (" +    // все элементы группы вложенные по теореме Кэли
                        "_id	INTEGER  primary key autoincrement, " +
                        "main_id INTEGER NOT NULL, " +  // код элемента
                        "clength	TEXT, " +   // цикл тип новой подст-ки
                        "substitution TEXT, " +
                        "deg	integer," +
                        "cykl	TEXT," +
                        "stabilizer TEXT," +       // номера чисел 1,2,3,..., для которых подстановка является стабилизатором
                        "parity integer);",

                "create table IF NOT EXISTS sylov_com_grup (" +    //  общие подгруппы силовских подгрупп (1 строка на элемент подгруппы)
// строится в classSylow.f_buildCommonSubs()
                        "_id	INTEGER  primary key autoincrement, " +
                        "pe INTEGER NOT NULL, " +
                        "sylow_zag	TEXT NOT NULL, " + // кучка подгрупп
                        "id_s integer NOT NULL," + //  код элемента
                        " nomer1 integer, " +  // № подгруппы, сквозая нумирация по всем pe и уровням
                        " nomer2 integer, " + // уровень вложенности
                        " norm_nomer integer);", // временный номер норм поднруппы

                "create table IF NOT EXISTS sylov_com_grup_a (" +    //  общие подгруппы силовских подгрупп (1 строка на элемент подгруппы)
// строится в classSylow.f_buildCommonSubs()
                        "_id	INTEGER  primary key autoincrement, " +
                        "pe INTEGER NOT NULL, " +
                        "sylow_zag	TEXT NOT NULL, " + // кучка подгрупп
                        "id_s integer NOT NULL," + //  код элемента
                        " nomer1 integer, " +  // № подгруппы, сквозая нумирация по всем pe и уровням
                        " nomer2 integer, " + // уровень вложенности
                        " norm_nomer integer);", // временный номер норм поднруппы

                "create table IF NOT EXISTS params " + // параметры расчета
                        " (_id INTEGER primary key autoincrement,  " +
                        " parm TEXT NOT NULL, " +
                        "ind	INTEGER," +
                        " val INTEGER, " +
                        " val_txt TEXT " +
                        "); ",

                "create table IF NOT EXISTS sylov_common" + // общие эл-ты в силовских подгруппах - количество силовских подгрупп для общего элемента
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe	INTEGER," +
                        "id_s  INTEGER NOT NULL, " +   // все подстановки силовской подгруппы
                        "count_id INTEGER, " +
                        "parity INTEGER " + // количество силовских подгрупп для общего элемента id_s для подгруппы четных подстановок
                        "); ",

                "create table IF NOT EXISTS sylov_common_a" + // общие эл-ты в силовских подгруппах - количество силовских подгрупп для общего элемента
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe	INTEGER," +
                        "id_s  INTEGER NOT NULL, " +   // все подстановки силовской подгруппы
                        "count_id INTEGER, " +
                        "parity INTEGER " + // количество силовских подгрупп для общего элемента id_s для подгруппы четных подстановок
                        "); ",

                "create table IF NOT EXISTS sylov_table " + // все построенные  силовские подгруппы
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe	INTEGER," +
                        "num  INTEGER, " +  // номер подгруппы, сквозая нумирация по всем pe
                        "id_main  INTEGER NOT NULL, " +  // порождающая подстановка
                        "id_s  INTEGER NOT NULL, " +   // все подстановки силовской подгруппы
                        "effort INTEGER, " + // число итераций при просеивании сил подгруппы
                        "parity INTEGER, " + // если подстановка четная = 0, иначе 1
                        " norm_nomer integer);", // временный номер норм поднруппы

                "create table IF NOT EXISTS sylov_table_a " + // все построенные  силовские подгруппы
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe	INTEGER," +
                        "num  INTEGER, " +  // номер подгруппы, сквозая нумирация по всем pe
                        "id_main  INTEGER NOT NULL, " +  // порождающая подстановка
                        "id_s  INTEGER NOT NULL, " +   // все подстановки силовской подгруппы
                        "effort INTEGER, " + // число итераций при просеивании сил подгруппы
                        "parity INTEGER, " + // если подстановка четная = 0, иначе 1
                        " norm_nomer integer);", // временный номер норм поднруппы

                "CREATE INDEX IF NOT EXISTS index_sylov_table " +
                        "  ON sylov_table (num ASC ); ",

                "create table IF NOT EXISTS sylov_id " +    // накопительная табоица для отсеивания силов подгрупп и цоколя
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_s  INTEGER NOT NULL, " +
                        "num  INTEGER," +
                        "txt  TEXT, " +
                        "txt1  TEXT" +
                        "); ",

                "create table IF NOT EXISTS sylov_cykl " +   // табоица силов подгрупп, порожденных 1-м элементом, только в f_createCykles
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe  INTEGER NOT NULL, " + // peDeg
                        "forming INTEGER NOT NULL,  " + // // id исходной подстановки
                        "txt  TEXT NOT NULL, " + // subsDed - текст подстановки
                        "deg  INTEGER, " + //  степень исходной подстановки
                        "silovnum  INTEGER, " + // # сил подгруппы
                        "id_subs INTEGER " + // id ждя степени (txt)
                        "); ",

                "create table IF NOT EXISTS sylow_attachments " + // табл вложения p-под неибольшего порядка
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe	INTEGER, " +
                        "main_lelel INTEGER NOT NULL, " +  // уровень программы
                        "mail_num INTEGER NOT NULL, " + // номер программы
                        "att_level INTEGER, " +         // уровень подпрограммы
                        "att_num INTEGER, " +         // номер подпрограммы
                        "att_order INTEGER, " +    // порядок подпрограммы
                        "att_index INTEGER " +       // индекс подгруппы
                        "); ",

                "create table IF NOT EXISTS sylow_attachments_a " + // табл вложения p-под неибольшего порядка
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe	INTEGER, " +
                        "main_lelel INTEGER NOT NULL, " +  // уровень программы
                        "mail_num INTEGER NOT NULL, " + // номер программы
                        "att_level INTEGER, " +         // уровень подпрограммы
                        "att_num INTEGER, " +         // номер подпрограммы
                        "att_order INTEGER, " +    // порядок подпрограммы
                        "att_index INTEGER " +       // индекс подгруппы
                        "); ",

                "create table IF NOT EXISTS  sylow_conj\n" +  //  элементы, сопрягающие подгруппы Силова
                        "         (_id INTEGER primary key autoincrement,\n" +
                        "        pe\tINTEGER,\n" +
                        "        num1  INTEGER NOT NULL,\n" +   // № сил подгр
                        "        num2  INTEGER NOT NULL,\n" +     // № сопряж
                        "        id_conj  INTEGER,\n" +     // id - эл-та сопряжения
                        "        id_reverse  INTEGER,\n" +  // id обратного эл та
                        "        count_element  INTEGER);\n",   // порядок сил подгруппы

                "create table IF NOT EXISTS  sylow_conj_a\n" +  //  элементы, сопрягающие подгруппы Силова
                        "         (_id INTEGER primary key autoincrement,\n" +
                        "        pe\tINTEGER,\n" +
                        "        num1  INTEGER NOT NULL,\n" +   // № сил подгр
                        "        num2  INTEGER NOT NULL,\n" +     // № сопряж
                        "        id_conj  INTEGER,\n" +     // id - эл-та сопряжения
                        "        id_reverse  INTEGER,\n" +  // id обратного эл та
                        "        count_element  INTEGER);\n",   // порядок сил подгруппы

                "create table IF NOT EXISTS  sylow_conj_n\n" +  //  элементы, сопрягающие подгруппы Силова
                        "         (_id INTEGER primary key autoincrement,\n" +
                        "        pe\tINTEGER,\n" +
                        "        num1  INTEGER NOT NULL,\n" +   // № сил подгр
                        "        num2  INTEGER NOT NULL,\n" +     // № сопряж
                        "        id_conj  INTEGER,\n" +     // id - эл-та сопряжения
                        "        id_reverse  INTEGER,\n" +  // id обратного эл та
                        "        count_element  INTEGER);\n",   // порядок сил подгруппы

                "create table IF NOT EXISTS  sylow_tmp_conj\n" +  //  аналог sylow_conj с пернумированными номерами подгрупп
                        "  (_id INTEGER primary key autoincrement,\n" +
                        "        pe INTEGER,\n" +               //  pe из sylow_conj соответствует типу сил подгрупп в основной группе, не зависит от pe гомоморфизма
                        "        num1  INTEGER NOT NULL,\n" +   // № 1 сил подгруппы
                        "        num_old1  INTEGER NOT NULL,\n" +  // ее старый номер
                        "        num2  INTEGER NOT NULL,\n" +    // № 2 сил подгруппы
                        "        num_old2  INTEGER NOT NULL,\n" +  // ее старый номер
                        "        id_conj  INTEGER);",

                "create table IF NOT EXISTS inputpods (" +   // заданные образующие и обратные к ним
                        "_id	INTEGER  primary key autoincrement, " +
                        "name	TEXT," +
                        "substitution TEXT NOT NULL," +
                        "iteration	INTEGER NOT NULL," +
                        "rever INTEGER " +       // 1 - есть оборатная иначе 0
                        ");",

                "create table IF NOT EXISTS inputpods_n (" +   // заданные образующие и обратные к ним
                        "_id	INTEGER  primary key autoincrement, " +
                        "name	TEXT," +
                        "substitution TEXT NOT NULL," +
                        "iteration	INTEGER NOT NULL," +
                        "rever INTEGER" +       // 1 - есть оборатная иначе 0
                        ");",

                "create table IF NOT EXISTS centralizer (" + // Централизаторы представителей классов сопряженных элементов
                        // ( когда сопряжение делается одного эл-та id_imagine другими id_subs)
                        "_id	INTEGER  primary key autoincrement, " +
                        "class_pair INTEGER,   " +  // код класса сопряженных элементов
                        "id_imagine  INTEGER, " +    // id подстановки - представителя класса сопряж эл-тов
                        "id_subs  INTEGER NOT NULL " +  // эл-нт централизатора для этого эл=та
                        ");",

                "create table IF NOT EXISTS centralizer_a (" + // Централизаторы представителей классов сопряженных элементов
                        // ( когда сопряжение делается одного эл-та id_imagine другими id_subs)
                        "_id	INTEGER  primary key autoincrement, " +
                        "class_pair INTEGER,   " +  // код класса сопряженных элементов
                        "id_imagine  INTEGER, " +    // id подстановки - представителя класса сопряж эл-тов
                        "id_subs  INTEGER NOT NULL " +  // эл-нт централизатора для этого эл=та
                        ");",

                "create table IF NOT EXISTS centralizer_n (" + // Централизаторы представителей классов сопряженных элементов
                        // ( когда сопряжение делается одного эл-та id_imagine другими id_subs)
                        "_id	INTEGER  primary key autoincrement, " +
                        "class_pair INTEGER,   " +  // код класса сопряженных элементов
                        "id_imagine  INTEGER, " +    // id подстановки - представителя класса сопряж эл-тов
                        "id_subs  INTEGER NOT NULL " +  // эл-нт централизатора для этого эл=та
                        ");",

                "create table IF NOT EXISTS elements (" +    // все элементы группы
                        "_id	INTEGER  primary key autoincrement, " +  // код элемента
                        "name	TEXT," +         // название элемента или его выражение через образующие
                        "substitution TEXT NOT NULL," +    // подстановка
                        "ciklos TEXT," +       // подстановка в виде непересекающихся циклов
                        "deg INTEGER, " +         // степень элемента
                        "pairing_num INTEGER, " +     // номер класса сопряженных элементов
                        "sylow_num TEXT, " +     // номера силовских подгруппы в которые входит этот элемент
                        "primitiv TEXT, " +       // null, а если это степень другого эл-та = степень (для цикл сил подгрупп)
                        "forming TEXT, " +       // образующий, который в степни primitiv есть этот элемент
                        "switchboard_num INTEGER, " + // 0, если это элемент коммутанта =1
                        "center_num INTEGER, " +   // порядок централизатора
                        "stabilizer TEXT," +       // номера чисел 1,2,3,..., для которых подстановка является стабилизатором
                        "cykl_len TEXT," +       // цикловой тип подстановки
                        "pe INTEGER, " + // если порядок элемента степень простого = это простое p иначе 0
                        "iteration	INTEGER NOT NULL," +
                        "parity INTEGER, " + // если подстановка четная = 0, иначе 1
                        "nomer_soc INTEGER); ", // > 0 элемент цоколя


                "create table IF NOT EXISTS switchboard " + // коммутаторы и сопряж элементы
                        " (_id INTEGER primary key autoincrement,  " +
                        " id_switch INTEGER,   " +  // код элемента - коммутатора
                        " id_pair INTEGER,   " +  // код сопряженного элемента = (idleft**-1) * idright * idleft
                        " id_left INTEGER NOT NULL," +
                        " id_right INTEGER NOT NULL, " +
                        " txt_pair TEXT," +
                        " txt_switch TEXT,  " +
                        " work_field INTEGER   " +  // work_field = 0 - id_left и id_right  четные подстановки, иначе 1
                        "); ",

                "create table IF NOT EXISTS switchboard_a " + // коммутаторы и сопряж элементы
                        " (_id INTEGER primary key autoincrement,  " +
                        " id_switch INTEGER,   " +  // код элемента - коммутатора
                        " id_pair INTEGER,   " +  // код сопряженного элемента = (idleft**-1) * idright * idleft
                        " id_left INTEGER NOT NULL," +
                        " id_right INTEGER NOT NULL, " +
                        " txt_pair TEXT," +
                        " txt_switch TEXT,  " +
                        " work_field INTEGER   " +  // work_field = 0 - id_left и id_right  четные подстановки, иначе 1
                        "); ",

                "create table IF NOT EXISTS switchboard_n " + // коммутаторы и сопряж элементы
                        " (_id INTEGER primary key autoincrement,  " +
                        " id_switch INTEGER,   " +  // код элемента - коммутатора
                        " id_pair INTEGER,   " +  // код сопряженного элемента id_pair = (idleft**-1) * idright * idleft
                        " id_left INTEGER NOT NULL," +
                        " id_right INTEGER NOT NULL, " +
                        " txt_pair TEXT," +
                        " txt_switch TEXT,  " +
                        " work_field INTEGER   " +  // work_field = 0 - id_left и id_right  четные подстановки, иначе 1
                        "); ",

                "create table IF NOT EXISTS normalizer " + // нормализатор сил подгр
                        " (_id INTEGER primary key autoincrement,  " +
                        " pe INTEGER NOT NULL,   " +
                        " id_s INTEGER  NOT NULL, " +
                        " num INTEGER" +
                        "); ",

                "create table IF NOT EXISTS normalizer_a " + // нормализатор сил подгр
                        " (_id INTEGER primary key autoincrement,  " +
                        " pe INTEGER NOT NULL,   " +
                        " id_s INTEGER  NOT NULL, " +
                        " num INTEGER" +
                        "); ",

                "create table IF NOT EXISTS normalizer_n " + // нормализатор сил подгр
                        " (_id INTEGER primary key autoincrement,  " +
                        " pe INTEGER NOT NULL,   " +
                        " id_s INTEGER  NOT NULL, " +
                        " num INTEGER" +
                        "); ",

                "create table IF NOT EXISTS exponent " + // экспоненты
                        " (_id INTEGER primary key autoincrement,  " +
                        " pe INTEGER,   " +
                        " val_exp INTEGER" +
                        "); ",

                "create table IF NOT EXISTS exponent_a " + // экспоненты
                        " (_id INTEGER primary key autoincrement,  " +
                        " pe INTEGER,   " +
                        " val_exp INTEGER" +
                        "); ",

                "create table IF NOT EXISTS exponent_n " + // экспоненты
                        " (_id INTEGER primary key autoincrement,  " +
                        " pe INTEGER,   " +
                        " val_exp INTEGER" +
                        "); ",

                "create table IF NOT EXISTS generators_element " + // табл образующих группы по степеням P
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_s INTEGER NOT NULL, " +  // Id
                        " sylow_num text, " +
                        "pe INTEGER" +  // pe
                        "); ",
                "create table IF NOT EXISTS generators_element_n " + // табл образующих группы по степеням P для Sn
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_s INTEGER NOT NULL, " +  // Id
                        " sylow_num text, " +
                        "pe INTEGER" +  // pe
                        "); ",
                "create table IF NOT EXISTS generators_test " + // табл проверки построенной группы по генераторам на совпадение группы с исходной
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_s INTEGER NOT NULL,  " +  // Id
                        "ciklos TEXT,  " +  //
                        "substitution TEXT  " +  // Id
                        "); ",

                "create table IF NOT EXISTS temp_pe " + // табл умножения для pe и др - рабочая таблица в разных случаях
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe	INTEGER, " +
                        "id_1 INTEGER NOT NULL, " +  // код элемента = 1 множителя  (newLevel при поиске наибольших подгрупп)
                        "id_2 INTEGER NOT NULL, " + // код элемента = 2 множителя  (0 при поиске наибольших подгрупп)
                        "id_s INTEGER, " +         // код произведения  - (при поиске наибольших подгрупп)
                        "degs INTEGER, " +         // порядок  произведения
                        "center_num INTEGER, " +    // порядок централизатора
                        "list_num  TEXT " + // перечень подгрупп при поиске наибольших подгрупп
                        "); ",

                "create table IF NOT EXISTS temp_auto " + // рабочая табл modeActivitySize
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe	INTEGER, " +
                        "id_1 INTEGER NOT NULL, " +  // код элемента = 1 множителя  (newLevel при поиске наибольших подгрупп)
                        "id_2 INTEGER NOT NULL " + // код элемента = 2 множителя  (0 при поиске наибольших подгрупп)
                        "); ",

                "create table IF NOT EXISTS temp_prim " + // 8. 5 Структура силовской подгруппы
                        // образующие  P/ [P,P], степени этих образуюших по модулю коммунатна подгруппы!!!
// "Поиск нормализаторов силовских подгрупп
                        " (_id INTEGER primary key autoincrement,  " +
                        " pe INTEGER NOT NULL,   " +
                        " deg  INTEGER, " +     // степень id_2  (id_2 ** deg = 1) или 0, если id_1 = 0
                        " id_1  INTEGER, " +    // idL
                        " id_2  INTEGER, " +    // idM = idL * id
                        " id_s  INTEGER, " +    //  id = исходный элемент, все степени которого ищем
                        " ndeg INTEGER, " +     // id_s в этой степни есть id_2 :  id_2 = id_s ** ndeg
                        "switchboard_num INTEGER, " + // признак коммутанта p-группы для id_2 = idM
                        "switchboard_s INTEGER, " + // признак коммутанта p-группы для id_s
                        " sylow_num text, " +
                        " list_num  TEXT   " +
                        "); ",


                "create table IF NOT EXISTS temp_multiplication " + // таблица произведений (умножения)
                        " (_id INTEGER primary key autoincrement,  " +
                        " idproiz INTEGER,  " +  // код элемента - произведения
                        " idleft INTEGER NOT NULL, idright INTEGER NOT NULL," +
                        " name	TEXT," +         // название элемента или его выражение через образующие
                        " name_old	TEXT," +      // название элемента из elements,если полученный элемент уже есть в таблице elements
                        " txt TEXT  NOT NULL," +
                        "iteration	INTEGER, " +
                        "deg INTEGER " +      // степень элемента
                        "); ",

                "create table IF NOT EXISTS temp_multiplication_a " + // таблица произведений (умножения) автоморфизмов
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_from INTEGER," + //  id произведения до автоморфизма
                        " idproiz INTEGER,  " +  // код элемента - произведения после автоморфизма
                        " idleft INTEGER NOT NULL, " + //  после автоморфизма
                        " idright INTEGER NOT NULL," + //  после автоморфизма
                        " flag_new INTEGER," + //  0 - новая подстановка иначе уже есть она в temp_elements
                        " name	TEXT," +         // новое вычисленное имя
                        " name_old	TEXT," +      // название элемента из elements,если полученный элемент уже есть в таблице elements
                        " txt TEXT, " +  // []  - подстановка после автоморфизма
                        " iteration	INTEGER, " +
                        " deg INTEGER " +      // степень элемента
                        "); ",


                "create table IF NOT EXISTS accordance " + // таблица соответствия номеров силовских подгрупп при эпиморфизма на группы подстановок сил подгрупп
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe INTEGER NOT NULL,  " +  // P силовской подгруппы
                        "num_old INTEGER NOT NULL,  " + // старый номер силовской подгруппы
                        "num INTEGER); ",              // новый (в образе)

                "create table IF NOT EXISTS accordance_a " + // таблица соответствия номеров силовских подгрупп при эпиморфизма на группы подстановок сил подгрупп
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe INTEGER NOT NULL,  " +  // P силовской подгруппы
                        "num_old INTEGER NOT NULL,  " + // старый номер силовской подгруппы
                        "num INTEGER); ",              // новый (в образе)

                "create table IF NOT EXISTS accordance_n " + // таблица соответствия номеров силовских подгрупп при эпиморфизма на группы подстановок сил подгрупп
                        " (_id INTEGER primary key autoincrement,  " +
                        "pe INTEGER NOT NULL,  " +  // P силовской подгруппы
                        "num_old INTEGER NOT NULL,  " + // старый номер силовской подгруппы
                        "num INTEGER); ",              // новый (в образе)

                "create table IF NOT EXISTS soc_list " + // таблица состава нормальных подгрупп
                        " (_id INTEGER primary key autoincrement,  " +
                        "nrow   INTEGER,  " +       // уровень вложенности подгруппы
                        "ncol   INTEGER,  " +       // колонка
                        "num INTEGER,  " +           // № подгруппы цоколя
                        "dubl_flag INTEGER,  " +   // =1 - дублируется
                        "comm_level INTEGER,  " +    // уровент коммутанта
                        "soc_level INTEGER,  " +     // = 1 -  весь цоколь
                        "centr_flag INTEGER,  " +    //  = 1 центр
                        "even_flag INTEGER,  " +           // =1 -четные подстановки
                        "sylow_num INTEGER,  " +          // # - силовской подгруппы или общей р-подгруппы
                        "connon_sylow INTEGER,  " +       // 2-й # - общей силовской подгруппы
                        "summa_num INTEGER,  " +          // # - слагаемых, если группа разлагается в прямуб сумму
                        "epi_pe INTEGER,  " +          // # - подгруппы-ядра при эпиморфизме на подстановках своих сил подгрупп
                        "num_klass INTEGER NOT NULL,  " + // номер основного класс = номер подгруппы
                        "count_klass INTEGER NOT NULL,  " + // число классов
                        "deg INTEGER NOT NULL,  " +         // порядок подгруппы
                        "sostav text," +                    // состав <пробел><№ класса><,>
                        "sostav_type text," +               // состав <пробел><цикл тип><,>
                        "sostav_count text); ",             // состав <пробел>< порядок класса><,>

                "create table IF NOT EXISTS soc_list_a " + // таблица состава нормальных подгрупп
                        " (_id INTEGER primary key autoincrement,  " +
                        "nrow   INTEGER,  " +       // уровень вложенности подгруппы
                        "ncol   INTEGER,  " +       // колонка
                        "num INTEGER,  " +           // № подгруппы цоколя
                        "dubl_flag INTEGER,  " +   // =1 - дублируется
                        "comm_level INTEGER,  " +    // уровент коммутанта
                        "soc_level INTEGER,  " +     // = 1 -  весь цоколь
                        "centr_flag INTEGER,  " +    //  = 1 центр
                        "even_flag INTEGER,  " +           // =1 -четные подстановки
                        "sylow_num INTEGER,  " +          // # - силовской подгруппы или общей р-подгруппы
                        "connon_sylow INTEGER,  " +       // 2-й # - общей силовской подгруппы
                        "summa_num INTEGER,  " +          // # - слагаемых, если группа разлагается в прямуб сумму
                        "epi_pe INTEGER,  " +          // # - подгруппы-ядра при эпиморфизме на подстановках своих сил подгрупп
                        "num_klass INTEGER NOT NULL,  " + // номер основного класс = номер подгруппы
                        "count_klass INTEGER NOT NULL,  " + // число классов
                        "deg INTEGER NOT NULL,  " +         // порядок подгруппы
                        "sostav text," +                    // состав <пробел><№ класса><,>
                        "sostav_type text," +               // состав <пробел><цикл тип><,>
                        "sostav_count text); ",             // состав <пробел>< порядок класса><,>

                "create table IF NOT EXISTS soc_list_n " + // таблица состава нормальных подгрупп
                        " (_id INTEGER primary key autoincrement,  " +
                        "nrow   INTEGER,  " +       // уровень вложенности подгруппы
                        "ncol   INTEGER,  " +       // колонка
                        "num INTEGER,  " +           // № подгруппы цоколя
                        "dubl_flag INTEGER,  " +   // =1 - дублируется
                        "comm_level INTEGER,  " +    // уровент коммутанта
                        "soc_level INTEGER,  " +     // = 1 -  весь цоколь
                        "centr_flag INTEGER,  " +    //  = 1 центр
                        "even_flag INTEGER,  " +           // =1 -четные подстановки
                        "sylow_num INTEGER,  " +          // # - силовской подгруппы или общей р-подгруппы
                        "connon_sylow INTEGER,  " +       // 2-й # - общей силовской подгруппы
                        "summa_num INTEGER,  " +          // # - слагаемых, если группа разлагается в прямуб сумму
                        "epi_pe INTEGER,  " +          // # - подгруппы-ядра при эпиморфизме на подстановках своих сил подгрупп
                        "num_klass INTEGER NOT NULL,  " + // номер основного класс = номер подгруппы
                        "count_klass INTEGER NOT NULL,  " + // число классов
                        "deg INTEGER NOT NULL,  " +         // порядок подгруппы
                        "sostav text," +                    // состав <пробел><№ класса><,>
                        "sostav_type text," +               // состав <пробел><цикл тип><,>
                        "sostav_count text); ",             // состав <пробел>< порядок класса><,>

                "create table IF NOT EXISTS soc_subs " + // таблица поиска цоколя, рабочая таблица
                        " (_id INTEGER primary key autoincrement,  " +
                        "num_maim INTEGER NOT NULL,  " + // номер основного класс
                        "num_subs INTEGER NOT NULL);  ",  // номер класса подгруппы

                "create table IF NOT EXISTS soc_subs_a " + // таблица поиска цоколя, рабочая таблица
                        " (_id INTEGER primary key autoincrement,  " +
                        "num_maim INTEGER NOT NULL,  " + // номер основного класс
                        "num_subs INTEGER NOT NULL);  ",  // номер класса подгруппы

                "create table IF NOT EXISTS soc_subs_n " + // таблица поиска цоколя, рабочая таблица
                        " (_id INTEGER primary key autoincrement,  " +
                        "num_maim INTEGER NOT NULL,  " + // номер основного класс
                        "num_subs INTEGER NOT NULL);  ",  // номер класса подгруппы


                "create table IF NOT EXISTS sub_summa " + // таблица слагаемых когда группа есть сумма подгрупп
                        " (_id INTEGER primary key autoincrement,  " +
                        "iter INTEGER NOT NULL,  " + // номер класса
                        "option INTEGER NOT NULL,  " + // номер класса
                        "num_maim INTEGER NOT NULL,  " + // номер класса
                        "num_subs INTEGER NOT NULL,  " + // номер класса
                        "deg INTEGER );  ",  // порядок подгруппы

                "create table IF NOT EXISTS sub_summa_a " + // таблица слагаемых когда группа есть сумма подгрупп
                        " (_id INTEGER primary key autoincrement,  " +
                        "iter INTEGER NOT NULL,  " + // номер класса
                        "option INTEGER NOT NULL,  " + // номер класса
                        "num_maim INTEGER NOT NULL,  " + // номер класса
                        "num_subs INTEGER NOT NULL,  " + // номер класса
                        "deg INTEGER );  ",  // порядок подгруппы

                "create table IF NOT EXISTS sub_summa_n " + // таблица слагаемых когда группа есть сумма подгрупп
                        " (_id INTEGER primary key autoincrement,  " +
                        "iter INTEGER NOT NULL,  " + // номер класса
                        "option INTEGER NOT NULL,  " + // номер класса
                        "num_maim INTEGER NOT NULL,  " + // номер класса
                        "num_subs INTEGER NOT NULL,  " + // номер класса
                        "deg INTEGER );  ",  // порядок подгруппы

                "create table IF NOT EXISTS epimorphism " + // таблица эпиморфизма на группы подстановок сил подгрупп
// записи могут повторяться
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_element INTEGER NOT NULL,  " +  // код элемента = _id elements
                        "id_obraz INTEGER, " +          // id образа, заполняется только для уникального элемента образа (Они повторяются согласно смежным классам по ядру)
                        "pe	INTEGER NOT NULL, " +
                        "substitution TEXT NOT NULL," +
                        "ciklos TEXT, " +
                        "cykl_len TEXT, " +
                        "deg INTEGER, " +
                        "adjacent INTEGER" +  // № смежного класса
                        "); ",

                "create table IF NOT EXISTS epimorphism_a " + // таблица эпиморфизма на группы подстановок сил подгрупп
// записи могут повторяться
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_element INTEGER NOT NULL,  " +  // код элемента = _id elements
                        "id_obraz INTEGER, " +          // id образа, заполняется только для уникального элемента образа (Они повторяются согласно смежным классам по ядру)
                        "pe	INTEGER NOT NULL, " +
                        "substitution TEXT NOT NULL," +
                        "ciklos TEXT, " +
                        "cykl_len TEXT, " +
                        "deg INTEGER, " +
                        "adjacent INTEGER" +  // № смежного класса
                        "); ",

                "create table IF NOT EXISTS ratios " +  // соотношения между элементами
                        " (_id INTEGER primary key autoincrement,  " +
                        " text_ratios TEXT  NOT NULL, " +
                        "iteration	INTEGER NOT NULL" +
                        "); ",


                // централизаторы каждого элемента, в какой класс сопряж эл-тов входит
                "create table IF NOT EXISTS centers " +   // id элемента и порядок централизатора этого эл-та
                        " (_id INTEGER primary key autoincrement,  " +
                        "pairing_num INTEGER, " +     // номер группы сопряженных элементов, для центра = 1
                        " id_subs INTEGER  NOT NULL, " + // // id элемента
                        " count_permutation INTEGER, " + // число перестановочных элементов для _id  (порядок централизатора этого эл-та)
                        " count_pairing INTEGER " + // число элементов орбиты  (порядок класса сопр эл-тов)
                        "); ",

                "create table IF NOT EXISTS centers_a " +   // id элемента и порядок централизатора этого эл-та
                        " (_id INTEGER primary key autoincrement,  " +
                        "pairing_num INTEGER, " +     // номер группы сопряженных элементов, для центра = 1
                        " id_subs INTEGER  NOT NULL, " + // // id элемента
                        " count_permutation INTEGER, " + // число перестановочных элементов для _id  (порядок централизатора этого эл-та)
                        " count_pairing INTEGER " + // число элементов орбиты  (порядок класса сопр эл-тов)
                        "); ",

                "create table IF NOT EXISTS pairing_area (" + //классы сопр эл-тов с id эл-тов
                        "_id	INTEGER  primary key autoincrement, " +
                        "class_area INTEGER,   " +  // код класса сопряженных элементов
                        "num INTEGER,   " +  // № подгруппы
                        "id_subs  INTEGER NOT NULL, " +  // _id элементов класса
                        "cykl_len TEXT, " +       // цикловой тип подстановки
                        "dubl INTEGER " +  //  = 1 - класс соответствует некоторому порядку элемета другого класс с dubl = 0
                        ");",

                "create table IF NOT EXISTS pairing_area_a (" + // классы сопр эл-тов с id эл-тов
                        "_id	INTEGER  primary key autoincrement, " +
                        "class_area INTEGER,   " +  // код класса сопряженных элементов
                        "num INTEGER,   " +  // № подгруппы
                        "id_subs  INTEGER NOT NULL, " +  // _id элементов класса
                        "cykl_len TEXT, " +       // цикловой тип подстановки
                        "dubl INTEGER " +  //  = 1 - класс соответствует некоторому порядку элемета другого класс с dubl = 0
                        ");",

                "create table IF NOT EXISTS pe_subgroup (" + // подгруппы p-элементов для вычисления силовских подгрупп
                        "_id	INTEGER  primary key autoincrement, " +
                        "pe INTEGER,   " +  // код класса сопряженных элементов
                        "num INTEGER,   " +  // № подгруппы
                        "count_element INTEGER, " +  // порядок подгруппы
                        "list_ids TEXT);",  // упорядоченный списоу id подстановок подгруппы

                "create table IF NOT EXISTS auto_centralizer (" + // централизатор G в Sn
                        "_id	INTEGER  primary key autoincrement, " +
                        "id_sn INTEGER); ",  // код Sn

                "create table IF NOT EXISTS auto_normalizer (" + // нормализатор G в Sn
                        "_id	INTEGER  primary key autoincrement, " +
                        "id_sn INTEGER); ",  // код Sn

                "create table IF NOT EXISTS auto_normalizer_a (" + // нормализатор G в Sn
                        "_id	INTEGER  primary key autoincrement, " +
                        "id_sn INTEGER); ",  // код Sn


                "create table IF NOT EXISTS pairing_multiplications (" + // таблица умножения классов без объединения центров
                        "_id	INTEGER  primary key autoincrement, " +
                        "class_a INTEGER,   " +  // код класса сопряженных элементов 1
                        "class_b INTEGER,   " +  // код класса сопряженных элементов 2
                        "class_m INTEGER   " +  // код класса сопряженных элементов произведения
                        ");",

                "create table IF NOT EXISTS normal_subgroup " + // таблица вложений найденных нормальных подгрупп (дерево, обходится рекурсивно)
                        " (_id INTEGER primary key autoincrement,  " +
                        "num_maim INTEGER NOT NULL,  " + // номер основного класс
                        "order_main  INTEGER,  " +
                        "num_sub INTEGER NOT NULL, "+  // номер класса подгруппы
                        "order_sub  INTEGER);  ",

                "create table IF NOT EXISTS normal_subgroup_a " + // таблица вложений найденных нормальных подгрупп (дерево, обходится рекурсивно)
                        " (_id INTEGER primary key autoincrement,  " +
                        "num_maim INTEGER NOT NULL,  " + // номер основного класс
                        "order_main  INTEGER,  " +
                        "num_sub INTEGER NOT NULL, "+  // номер класса подгруппы
                        "order_sub  INTEGER);  ",

                "create table IF NOT EXISTS normal_subgroup_n " + // таблица вложений найденных нормальных подгрупп (дерево, обходится рекурсивно)
                        " (_id INTEGER primary key autoincrement,  " +
                        "num_maim INTEGER NOT NULL,  " + // номер основного класс
                        "order_main  INTEGER,  " +
                        "num_sub INTEGER NOT NULL, "+  // номер класса подгруппы
                        "order_sub  INTEGER);  ",

                "create table IF NOT EXISTS normal_connect " + // таблица дополнительных вложений найденных нормальных подгрупп после формированиясвязей для всех уровней
                        " (_id INTEGER primary key autoincrement,  " +
                        "num1 INTEGER NOT NULL,  " + // номер первой подгруппы
                        "num2 INTEGER NOT NULL,  " + // номер второй
                        "num_common INTEGER NOT NULL,  " + // номер общей
                        "count_class INTEGER,  " +  // всего общих классов не считай 1-го
                        "sostav text); ",           // состав общей подгруппы <пробел><№ класса><,>

                "create table IF NOT EXISTS sub_structure " + // таблица всех нормальных подгрупп
                        " (_id INTEGER primary key autoincrement,  " +
                        "num_maim INTEGER NOT NULL,  " + // номер основного класс
                        "num_subs INTEGER NOT NULL, " +   // номер класса подгруппы
                        "deg INTEGER );  ",  // порядок подгруппы

                "create table IF NOT EXISTS sub_structure_a " + // таблица всех нормальных подгрупп
                        " (_id INTEGER primary key autoincrement,  " +
                        "num_maim INTEGER NOT NULL,  " + // номер основного класс
                        "num_subs INTEGER NOT NULL, " +   // номер класса подгруппы
                        "deg INTEGER );  ",  // порядок подгруппы

                "create table IF NOT EXISTS sub_structure_n " + // таблица всех нормальных подгрупп
                        " (_id INTEGER primary key autoincrement,  " +
                        "num_maim INTEGER NOT NULL,  " + // номер основного класс
                        "num_subs INTEGER NOT NULL, " +   // номер класса подгруппы
                        "deg INTEGER );  ",  // порядок подгруппы

                "create table IF NOT EXISTS points " +  // точки графа кэли
                        " (_id INTEGER primary key autoincrement,  " +
                        " id_element INTEGER  NOT NULL, " + // _id элемента группы -1
                        "iteration	INTEGER NOT NULL," +
                        "point_num TEXT," + //
                        "kluch TEXT, " +    // ключ раскраски точки
                        "xp	REAL," +
                        "yp	REAL," +
                        "zp	REAL, " +
                        "ind_point INTEGER, " + // индекс точки в valDataRect
                        "nomer INTEGER, " +
                        "npp INTEGER " +
                        "); ",

                "create table IF NOT EXISTS lines " +   // линии графа кэли
                        " (_id INTEGER primary key autoincrement,  " +
                        " id_1 INTEGER  NOT NULL, " +   // id - начальная точка
                        " id_2 INTEGER  NOT NULL, " +   // id - конечная точка
                        " name	TEXT," +               // название элемента образующего для которого делается эта линия
                        "id_start INTEGER, " + // id элемента образующего для которого делается эта линия
                        "ind1 INTEGER, " +   // индекс в valDataRect нач точки
                        "ind2 INTEGER, " +    // индекс в valDataRect кон точки
                        "color INTEGER, " +    // номер цвета
                        "nomer INTEGER, " +
                        "npp INTEGER " +
                        "); ",

// рабочие таблицы
                "create table IF NOT EXISTS temp_elements (" + // рабочая таблица для построения индесков точек графа (f_graphGetPointsIndex) и изоморфизмов
                        "_id	INTEGER  primary key autoincrement, " +  // код элемента
                        "id INTEGER," + //  id точки
                        "id_from INTEGER," + //  id до автоморфизма
                        "id_to INTEGER," + //  id после автоморфизма
                        "txt TEXT, " +  // []  - подстановка после автоморфизма
                        "iteration	INTEGER, " +
                        "name TEXT" +   // новое вычисленное имя
                        ");",

                "create table IF NOT EXISTS temp_sylow " + // рабочая таблица произведений (умножения) для проверки сил подгруппы, построение норм подгрупп и др
                        " (_id INTEGER primary key autoincrement,  " +
                        " idproiz INTEGER,  " +  // код элемента - произведения
                        " idleft INTEGER NOT NULL, " +
                        "idright INTEGER NOT NULL," +
                        "pe	INTEGER, " +
                        "num1 INTEGER, " +         // № сил подгруппы сомножителей
                        "num2 INTEGER, " +         // № сил подгруппы произведения
                        "txt TEXT " +
                        "); ",

                "create table IF NOT EXISTS prime_number (" + // простые числа f_createPrimeryNumber
                        "_id	INTEGER  primary key autoincrement, " +
                        "number INTEGER" + // простое число
                        ");",


                "CREATE UNIQUE INDEX IF NOT EXISTS index_element " +
                        "  ON elements (substitution ASC ); ",

                "CREATE UNIQUE INDEX IF NOT EXISTS index_element_a " +
                        "  ON elements_a (substitution ASC ); ",

                "CREATE INDEX IF NOT EXISTS index_multiplication2 " +
                        "  ON temp_multiplication (iteration ASC, idproiz ASC ); "

        };

        for (String s : str1) {
            db.execSQL(s);
            if (DISPLAYLOG)
                Log.d(TAG, "onCreate  " + s);
        }
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // вызывается при модификации базы данных
        if (DISPLAYLOG)
            Log.d(TAG, "onUpgrade oldVersion=" + oldVersion + " newVersion=" + newVersion);

        if (oldVersion != newVersion) {
            AlertDialog.Builder builder = new AlertDialog.Builder(mApp.activityMain);
            builder.setTitle("Версия базы изменилась!");
            builder.setMessage("При продолжении данные Вашей базы будут уничтожены! Приложение надо перезапустить!");
            builder.setPositiveButton("Продолжить", new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int id) {
                    f_dropTables();
                    mApp.activityMain.finish();
                }
            });
            builder.setNegativeButton("Отказаться", new DialogInterface.OnClickListener() {
                public void onClick(DialogInterface dialog, int id) {
                    mApp.activityMain.finish();
                }
            });
            builder.setCancelable(true);
            builder.create();
            builder.show();
        } else {
            f_dropTables();
        }
    }

    final static String temp_multiplication[] = {"temp_multiplication", "temp_multiplication_a"},
            elements[] = {"elements", "elements_a"},
            centers[] = {"centers", "centers_a"},
            centralizer[] = {"centralizer", "centralizer_a"},
            sylov_table[] = {"sylov_table", "sylov_table_a"},
            sylov_com_grup[] = {"sylov_com_grup", "sylov_com_grup_a"},
            normalizer[] = {"normalizer", "normalizer_a"},
            exponent[] = {"exponent", "exponent_a"},
            sylov_common[] = {"sylov_common", "sylov_common_a"},
            pairing_area[] = {"pairing_area", "pairing_area_a"},
            sub_structure[] = {"sub_structure", "sub_structure_a"},
            soc_list[] = {"soc_list", "soc_list_a"},
            soc_subs[] = {"soc_subs", "soc_subs_a"},
            normal_subgroup[] = {"normal_subgroup", "normal_subgroup_a"},
            sylow_attachments[] = {"sylow_attachments", "sylow_attachments_a"},
            sylow_conj[] = {"sylow_conj", "sylow_conj_a"},
            switchboard[] = {"switchboard", "switchboard_a"},
            subgrups[] = {"subgrups", "subgrups_a"},
            accordance[] = {"accordance", "accordance_a"},
            epimorphism[] = {"epimorphism", "epimorphism_a"},
            sub_summa[] = {"sub_summa", "sub_summa_a"},
            sub_scribe[] = {"sub_scribe", "sub_scribe_a"};



    private void f_dropTables() {
        // удалить все таблицы - модификация базы
        if (DISPLAYLOG)
            Log.d(TAG, "f_dropTables dbCreate=" + dbCreate);

        int j;
        for (j=0; j < TblTmpName.length; j++)
            db.execSQL("DROP TABLE IF EXISTS " + TblTmpName[j] + ";");

        for (j=0; j < tblMainName.length; j++) {
            db.execSQL("DROP TABLE IF EXISTS " + tblMainName[j] + ";");
            db.execSQL("DROP TABLE IF EXISTS " + tblMainName[j] + "_n;");
        }

        dbCreate = false;
        mApp.groupName = "";

        onCreate(db);
    }

    public DbHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);  // база в памяти, eсли DB_NAME = null
        if (DISPLAYLOG) {
            Log.d(TAG, "DbHelper context  " );
        }
    }


    public void f_SwitchToSocList() {
// заносит колонку comm_level в soc_list
        int i = 1;
        String ss1;
        do {
            ss1 = f_getListSubgr("select distinct P.class_area as num from " + elements[vidWgrup] + "  E, " + pairing_area[vidWgrup] + "  P " + //  выбираю группу четных подстановок
                    " where  E._id = P.id_subs and E.switchboard_num >= "+ i + //  "  and not pairing_num = 1 " +
                    "  order by P.class_area asc;");
            db.execSQL("update " + soc_list[vidWgrup] + " set comm_level = "+ i + " where sostav = '" + ss1 + "'; ");
            if (DISPLAYLOG)
                Log.e(TAG, "f_soc switchboard_num i="+ i + " ss1='" + ss1 + "'");
            i++;
        } while (ss1.length() > 1);
    }

    public String f_getListSubgr(String SqlList) {
// по SqlList типа  "select pairing_num as num from elements
// where  switchboard_num > 0 and not pairing_num = 1"
// возвращает список pairing_num по которому можно найти малую норм подгруппу в soc_list
        String lst = " ";
        int indKl, kls;

        Cursor curNextSoc = db.rawQuery(SqlList, null);
        curNextSoc.moveToFirst();
        if (curNextSoc.getCount() > 0) {
            indKl = curNextSoc.getColumnIndex("num");
            do {
                kls = curNextSoc.getInt(indKl);
                lst +=  " " + kls + ", ";
            } while (curNextSoc.moveToNext());
        }
        curNextSoc.close();
        if (DISPLAYLOG)
            Log.e(TAG, "f_soc lst "+ lst + " SqlList= " + SqlList);
        return lst;
    }
}

//-------------------------