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

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

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

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.List;

public class classBuild {
    // построение группы
    private static final String TAG = "GRUGRA_BUILD_CLASS";
    final static private boolean DISPLAYLOG = false;
    public mAplication mApp;
    private DbHelper dbH;
    static public substitutionS classSubs;
    static public SQLiteDatabase db;
    final static private List<Integer> arrConjug = new ArrayList();  // порядки классов сопряженных элементов
    final static private List<Integer> arrConjugNum = new ArrayList();  // номера классов сопряженных элементов
    static private List<Integer> subsSwitch, //  результат - подстановка коммутатор
            subsPair;  // результат - сопряженная подстановка = (idleft**-1) * idright * idleft
    private int vidWgrup = 0; // vidWgrup = 0 - сама группа, 1 - группа автоморфизмов

    public void init(mAplication mApp_, DbHelper dbH_, int vidWgrup_ ) {
        mApp  = mApp_;
        dbH = dbH_;
        db = DbHelper.db;
        classSubs = mApp.classSubs;
        vidWgrup = vidWgrup_;
        arrConjug.clear();
        arrConjugNum.clear();
//        Log.d(TAG,  "init mApp.whatRun="+ mApp.whatRun + " vidWgrup = " + vidWgrup);

        subsSwitch = new ArrayList(DbHelper.faktSubsLen); //  результат - подстановка коммутатор
        subsPair = new ArrayList(DbHelper.faktSubsLen);
    }

    public int f_createGrupp() {
        // начало построения группы
         // записать в базу
        // для автоморфизмов не выполняется !
        int k;
        dbH.f_clearDB(vidWgrup);

        String name = "", subs = "";
        for (k = 0; k < substitutionS.newSubsMas.size(); k++) {
            name = substitutionS.newSubsMas.get(k).name;
            subs = substitutionS.newSubsMas.get(k).textSubsr;
//            Log.d(TAG,  "f_createGrupp  vidWgrup = " + vidWgrup + " name = " + name + " subs = " + subs);
            classSubs.f_ciklToSubs(name, subs);
        }

        classSubs.f_createPrimeryNumber(5000);

        dbH.f_setVidGr(0, false);

        if (dbH.f_init() < 0) { // запись в базу всех образующих
            mApp.putProt("Ошибка: " + DbHelper.err + " Нажмите 'отменить'");
            return -1;
        }
        f_build();

        // запись в inputpods
        if (vidWgrup == 0) {
            db.execSQL("insert into inputpods (name, substitution, iteration, rever) \n" +
                    "select name, substitution, 0, _id\n" +
                    " from elements \n" +
                    "  where iteration = 0 " +
                    " order by _id asc;");
        }
        if (DbHelper.err.length() > 0) {
            mApp.putProt("Ошибка: " + DbHelper.err + " Нажмите 'отменить'");
            return -1;
        }
//        Log.d(TAG,  " mApp.whatRun="+ mApp.whatRun);

        return 0;
    }



    public void f_build() {
        // цикл итераций для построения всех подстановок группы
        int iter = 1, rez, i, k;

        DbHelper.timeStart = (new Date()).getTime();
        mApp.putProt("");
        if (vidWgrup  == 0)
            mApp.putProt("Построение группы");
        else
            mApp.putProt("Получение свойств группы автоморфизмов");

//        Log.d(TAG,  " f_build vidWgrup = "+ vidWgrup);

        db.beginTransaction();
        db.execSQL("DELETE FROM " + DbHelper.temp_multiplication[vidWgrup] + ";");

        do {
            rez = f_buildOne(iter++);
            if (rez < 0) {
                db.endTransaction(); // db.setTransactionSuccessful(); - не выдавать - откат транзакции
                return;
            }
            //          if (iter >2 ) return;
        } while (rez > 0); // элементы группы построены

        if (mApp.whatRun != -1 && DbHelper.err.length() == 0) {
            if (vidWgrup == 0)
                f_buildRatios();
        } else {
            db.endTransaction(); // db.setTransactionSuccessful(); - не выдавать - откат транзакции
            return;
        }

        String sqlQuery, chto;
        if (DbHelper.err.length() == 0) {
            DbHelper.countElements = dbH.f_getCount("select count(_id) as ccc from " + DbHelper.elements[vidWgrup] + "; ");
            mApp.putProt("Группа создана");
            mApp.putProt("Порядок группы  " + DbHelper.countElements + " степень группы " + DbHelper.faktSubsLen);

// сохранить единицу
            sqlQuery = "insert into params (parm, ind, val, val_txt) select 'Edinica" + ((vidWgrup == 0) ? "_g" : "_a") + "', _id, 0, substitution " +
                    " from " + DbHelper.elements[vidWgrup] + " where substitution = '" + substitutionS.Edinica + "' ;";
            db.execSQL(sqlQuery); // ошибок не должно быть !


            // вывожу порядки стабилизатора точек i (stabilizer)
            for (i = 0; i < DbHelper.faktSubsLen; i++) {
                if (i + 1 < DbHelper.faktSubsLen)
                    chto = (i + 1) + ",";
                else
                    chto = (i + 1) + "]";
                k = substitutionS.Edinica.indexOf(chto) + 1;    // в substr позиция начинается с 1
                sqlQuery = "select substitution from " + DbHelper.elements[vidWgrup]   +
                        " where substr(substitution, " + k + ", " + chto.length() + ") = '" + chto + "'; ";

                Cursor cursorStab = db.rawQuery(sqlQuery, null);
                k = cursorStab.getCount();
//                Log.e(TAG, "f_build select=" + sqlQuery + " k=" + k);
                mApp.putProt("Порядок стабилизатора точки " + (i + 1) + " равен " + k);
                cursorStab.close();
            }
        }

        if (mApp.whatRun != -1 && DbHelper.err.length() == 0)
            db.setTransactionSuccessful();
        db.endTransaction();
        //     long dTime = (new Date()).getTime() - DbHelper.timeStart;

    }

    public int f_buildOne(int iteracia) {
        // итерация, транзакция распространяется на 1 итерацию!

        int countNewElement = 0; // число новых элементов группы созданных на текущей итерации
        mApp.putProt("Итерация " + iteracia);

        f_buildTmp(iteracia);
/* temp_multiplication сформирована, ее данные заношу в elements - если там нет такой подстановки (2)
если есть
 1) ее _id заношу в temp_multiplication
 3) после пополнения elements снова _id новых произведение из elements заношу в temp_multiplication
  */
        //       if (iteracia >=2)
        //           return 0;
        if (mApp.whatRun == -1 | DbHelper.err.length() > 0)
            return -1;

        final String sqlExec[] = {

                "UPDATE " + DbHelper.temp_multiplication[vidWgrup] +     // (1) помечаю в temp_multiplication существующие в elements элементы
                        " SET idproiz = (SELECT " + DbHelper.elements[vidWgrup] + "._id " +
                        " FROM " + DbHelper.elements[vidWgrup] +
                        " WHERE " + DbHelper.elements[vidWgrup] + ".substitution = " + DbHelper.temp_multiplication[vidWgrup] + ".txt) " +
                        " WHERE " + DbHelper.temp_multiplication[vidWgrup] + ".iteration = " + iteracia + " and " + DbHelper.temp_multiplication[vidWgrup] + ".txt in (select E.substitution from " + DbHelper.elements[vidWgrup] + " E);",

                "UPDATE " + DbHelper.temp_multiplication[vidWgrup] +  // (1) помечаю в temp_multiplication существующие в elements элементы
                        " SET name_old = (SELECT name " +
                        " FROM " + DbHelper.elements[vidWgrup] + " " +
                        " WHERE " + DbHelper.elements[vidWgrup] + "._id = " + DbHelper.temp_multiplication[vidWgrup] + ".idproiz) " +
                        " where " + DbHelper.temp_multiplication[vidWgrup] + ".iteration = " + iteracia + " and " + DbHelper.temp_multiplication[vidWgrup] + ".idproiz = (select E._id from " + DbHelper.elements[vidWgrup] + " E);",

// (2) пополняю elements новыми, полученными в результате перемножения существующих
// записи в temp_multiplication могут повторяться поэтому distinct null обязательно!
                "INSERT into  " + DbHelper.elements[vidWgrup] + " (name, substitution, deg, iteration, pairing_num, switchboard_num, center_num, forming, primitiv) " +
                        "SELECT distinct null, txt, deg, " + iteracia + ", 0, 0, 0, '', '' from " + DbHelper.temp_multiplication[vidWgrup] +
                        " where  " + DbHelper.temp_multiplication[vidWgrup] + ".iteration = " + iteracia + " and " + DbHelper.temp_multiplication[vidWgrup] + ".idproiz = 0; "
        };

        for (String value : sqlExec) {
            if (DISPLAYLOG)
                Log.d(TAG, "f_buildOne " + value + " iteracia=" + iteracia);
            db.execSQL(value); // ошибок не должно быть !
        }

        // теперь определяю countNewElement =  число новых элементов группы созданных на текущей итерации
        String sqlQuery = "select distinct txt from " + DbHelper.temp_multiplication[vidWgrup] + " where iteration = " + iteracia + " and idproiz = 0; ";
        Cursor cursorRecCount = db.rawQuery(sqlQuery, null);
        countNewElement = cursorRecCount.getCount();
        cursorRecCount.close();
        mApp.putProt("Число новых элементов группы созданных на текущей итерации № " + iteracia + " = " + countNewElement);
        sqlQuery = "insert into params (parm, ind, val) VALUES ('pointsPerIteration" + ( vidWgrup == 0 ? "_g" : "_a") + "', " + iteracia + ", " + countNewElement + ");";
        db.execSQL(sqlQuery); // ошибок не должно быть !
        //      Log.e(TAG, "f_buildOne countNewElement=" + countNewElement + " iteracia=" + iteracia + " sqlQuery=" + sqlQuery);

// после пополнения таблицы элементов заполнить temp_multiplication
        final String sqlExecPost[] = {

                "UPDATE " + DbHelper.temp_multiplication[vidWgrup] +   // тоже что (1) помечаю в temp_multiplication существующие в elements элементы
                        " SET idproiz = (SELECT " + DbHelper.elements[vidWgrup] + "._id " +
                        " FROM " + DbHelper.elements[vidWgrup] + " " +
                        " WHERE " + DbHelper.elements[vidWgrup] + ".substitution = " + DbHelper.temp_multiplication[vidWgrup] + ".txt) " +
                        " WHERE " + DbHelper.temp_multiplication[vidWgrup] + ".iteration = " + iteracia + " and " + DbHelper.temp_multiplication[vidWgrup] + ".txt in (select E.substitution from " + DbHelper.elements[vidWgrup] + " E);",

                "UPDATE " + DbHelper.elements[vidWgrup] + " set name = (select name from " + DbHelper.temp_multiplication[vidWgrup] +
                        " where  " + DbHelper.elements[vidWgrup] + "._id = " + DbHelper.temp_multiplication[vidWgrup] + ".idproiz) " +
                        " where " + DbHelper.elements[vidWgrup] + ".name isNull and iteration = " + iteracia + " and " +
                        "  " + DbHelper.elements[vidWgrup] + "._id in (select T.idproiz from " + DbHelper.temp_multiplication[vidWgrup] + " T); ",
        };

        for (String s : sqlExecPost) {
            if (DISPLAYLOG)
                Log.d(TAG, "f_buildOne " + s + " iteracia=" + iteracia);
            db.execSQL(s); // ошибок не должно быть !
        }

//        Log.e(TAG, "Error f_buildOne formirovat=" + formirovat);

        return countNewElement;

    }

    private void f_buildTmp(int iteracia) {
        // запись в таблицу temp_multiplication всех произведений элементов из elements

        int subsSpepen = DbHelper.faktSubsLen;
        int[] subsL = new int[subsSpepen],    // левая, правая
                subsR = new int[subsSpepen];
        List<Integer> subsNew = new ArrayList(subsSpepen); //  и результат - подстановки

        String nStr = null;
        final String SQLSelect = "select _id, name, substitution, iteration " +
                " from " + DbHelper.elements[vidWgrup] + ";";

        ContentValues cv = new ContentValues();
        Cursor cursorLeft = db.rawQuery(SQLSelect, null),
                cursorRight = db.rawQuery(SQLSelect, null);

        int iL1 = cursorLeft.getColumnIndex("_id"), idL, j, idR, iterationL, iterationR,
                iL2 = cursorLeft.getColumnIndex("name"),
                iL3 = cursorLeft.getColumnIndex("substitution"),
                iL4 = cursorLeft.getColumnIndex("iteration"),
                iR1 = cursorRight.getColumnIndex("_id"),
                iR2 = cursorRight.getColumnIndex("name"),
                iR3 = cursorRight.getColumnIndex("substitution"),
                iR4 = cursorRight.getColumnIndex("iteration");
        String txtL, txtR, namL, namR, newTxt;
        String pods[];
        if (cursorLeft.getCount() == 0) {
            DbHelper.err += "Не заданы образующие группы (f_buildTmp)";
            return;
        } else {
            if (DISPLAYLOG)
                Log.d(TAG, "f_buildTmp число элементов группы = " + cursorLeft.getCount() + " iteracia=" + iteracia);
        }

        if (cursorLeft.moveToFirst()) {
            do {
                idL = cursorLeft.getInt(iL1); // _id
                namL = cursorLeft.getString(iL2);
                iterationL = cursorLeft.getInt(iL4);
                txtL = cursorLeft.getString(iL3);
                txtL = txtL.substring(1, txtL.indexOf("]"));
//                Log.e(TAG, "f_buildTmp l=" + txtL + " name= " + namL + " pos= " + cursorLeft.getPosition());
                pods = txtL.split(","); // массив строковых чисел цикла
                for (j = 0; j < subsSpepen; j++)
                    subsL[j] = Integer.parseInt(pods[j].trim());
//                Log.d(TAG, "f_buildTmp vidWgrup = " +  vidWgrup  + " iteracia = " + iteracia +
//                        " subsL ="+ subsL.length + " subsSpepen =" + subsSpepen + " SQLSelect=" + SQLSelect);

                cursorRight.moveToFirst();
                do {
                    idR = cursorRight.getInt(iR1); // _id
                    namR = cursorRight.getString(iR2);
                    iterationR = cursorRight.getInt(iR4);
                    if (!(iterationL < iteracia - 1 & iterationR < iteracia - 1)) {

//                    Log.e(TAG, "f_buildTmp iterationL=" + iterationL + " iterationR= " + iterationR + " iteration= " + iteracia + " name="+ namL + " "+ namR);
                        txtR = cursorRight.getString(iR3);
                        txtR = txtR.substring(1, txtR.indexOf("]"));
// перемножение
                        pods = txtR.split(","); // массив строковых чисел цикла
                        for (j = 0; j < subsSpepen; j++)
                            subsR[j] = Integer.parseInt(pods[j].trim());

//                    Log.e(TAG, "f_buildTmp r=" + txtR + " name= " + namR + " pos= " + cursorRight.getPosition());
                        subsNew.clear();
                        for (j = 0; j < subsSpepen; j++)
                            subsNew.add(subsR[subsL[j] - 1]);   // произведение L * R
                        newTxt = subsNew.toString();    // substitution новой подстановки
//                       Log.e(TAG, "f_buildTmp N=" + newTxt + " namel= " + namL +  " namer= " + namR +  " nameM= " + (namL + namR));
//               mApp.putProt("Произведение элементов " + namL + " * " + namR + " = " + newTxt);

// запись произведения, с cv быстрее

    //                        nStr = "insert into temp_multiplication (idleft, idright, idproiz, deg, iteration, name, name_old, txt) " +
    //                                " values (" + idL + ", " + idR + ", 0, 0, " + iteracia + ", '" + (namL + namR) + "', null, '" + newTxt + "');";
    //                        db.execSQL(nStr);


                        cv.put("idleft", idL);
                        cv.put("idright", idR);
                        cv.put("idproiz", 0);
                        cv.put("deg", 0);
                        cv.put("iteration", iteracia);
                        cv.put("name", (namL + namR));
                        cv.put("name_old", nStr);   // null
                        cv.put("txt", newTxt);

                        long row_id = db.insert(DbHelper.temp_multiplication[vidWgrup], null, cv);

                        if (row_id < 0) {
                            DbHelper.err += "Ошибка записи в таблицу " + DbHelper.temp_multiplication[vidWgrup] + " " + row_id;
                            Log.e(TAG, DbHelper.err);
                        }


                        if (mApp.whatRun == -1 | DbHelper.err.length() > 0) {
                            cursorLeft.close();
                            cursorRight.close();
                            return;
                        }
                    }
                } while (cursorRight.moveToNext());
                if (myExecutor.MyThread.isCancel || DbHelper.err.length() > 0) {
                    DbHelper.err += "\n Расчет прерван";
                    break;
                }
            } while (cursorLeft.moveToNext());
        }
        cursorLeft.close();
        cursorRight.close();
    }

    private void f_buildRatios() {
        //  запись соотношений между образующими в таблицу ratios

        ContentValues cv = new ContentValues();

        mApp.putProt("Определение соотношений между образующими");
        final String colR[] = {"name", "idproiz", "name_old", "iteration"};
        Cursor cursorRatios = db.query(DbHelper.temp_multiplication[vidWgrup], colR, null, null, null, null, "idproiz");
        int idproiz, idproiz_old = -1, nomIteracia = 0,
                i_id = cursorRatios.getColumnIndex("idproiz"),
                iOld = cursorRatios.getColumnIndex("name_old"),
                iIter = cursorRatios.getColumnIndex("iteration"),
                iName = cursorRatios.getColumnIndex("name");
        String newTxt = "", namR, nameElem;
//        Log.e(TAG, "f_buildRatios число строк таблицы умножения = " + cursorRatios.getCount());
        mApp.putProt("Число строк таблицы умножения = " + cursorRatios.getCount());

        cursorRatios.moveToFirst();
        while (cursorRatios.moveToNext()) {
            idproiz = cursorRatios.getInt(i_id);
            namR = cursorRatios.getString(iName);
            nameElem = cursorRatios.getString(iOld);
            nomIteracia = cursorRatios.getInt(iIter);
            if (nameElem == null) nameElem = "";
            if (nameElem.length() > 0) {    // записать соотношение name_old = namR
                cv.put("text_ratios", nameElem + " = " + namR);
                cv.put("iteration", nomIteracia);
//                Log.e(TAG, "f_buildRatios  cv.put=" + nameElem + " = " + namR + " pos= " + cursorRatios.getPosition() + " итерация " + nomIteracia);
                long row_id = db.insert("ratios", null, cv);
                if (row_id < 0) {
                    DbHelper.err += "Ошибка 1 записи в таблицу text_ratios " + nameElem + " = " + namR + " " + row_id;
                    Log.e(TAG, DbHelper.err);
                }
            }
//            Log.e(TAG, "f_buildRatios idproiz=" + idproiz + " idproiz_old=" + idproiz_old + " newTxt=" + newTxt + " namR=" + namR);
            if (idproiz == idproiz_old) {
                newTxt += " = " + namR;
//                Log.e(TAG, "f_buildRatios ===  newTxt=" + newTxt);
            } else {
//                Log.e(TAG, "f_buildRatios +++  newTxt=" + newTxt);
                if (newTxt.indexOf("=") > 0) {
// записать соотношение
                    cv.put("text_ratios", newTxt);
                    cv.put("iteration", nomIteracia);
//                    Log.e(TAG, "f_buildRatios  cv.put=" + newTxt + " namR=" + namR + "  idproiz_old=" + idproiz_old + " idproiz=" + idproiz + " pos= " + cursorRatios.getPosition() + " итерация " + nomIteracia);
                    long row_id = db.insert("ratios", null, cv);
                    if (row_id < 0) {
                        DbHelper.err += "Ошибка 2 записи в таблицу text_ratios " + newTxt + " " + row_id;
                        Log.e(TAG, DbHelper.err);
                    }
                }
                newTxt = namR;
                idproiz_old = idproiz;
            }
            if (mApp.whatRun == -1 | DbHelper.err.length() > 0) {
                cursorRatios.close();
                return;
            }
        }
        cursorRatios.close();

        if (newTxt.indexOf("=") > 0) {
            cv.put("text_ratios", newTxt);
            cv.put("iteration", nomIteracia);
//            Log.e(TAG, "f_buildRatios END " + idproiz + " idproiz_old=" + idproiz_old + " newTxt=" + newTxt + " итерация " + nomIteracia);
            long row_id = db.insert("ratios", null, cv);
            if (row_id < 0) {
                DbHelper.err += "Ошибка 3 записи в таблицу text_ratios " + newTxt + " " + row_id;
                Log.e(TAG, DbHelper.err);
            }
        }
    }


    public void f_build_switch() {
        // запись в таблицу switchboard всех коммутаторов и сопряженных элеметов из elements

        int[] subsL = new int[DbHelper.faktSubsLen],    // левая, правая
                subsR = new int[DbHelper.faktSubsLen];
        int[] subsLM = new int[DbHelper.faktSubsLen],    // левая, правая в -1 степени
                subsRM = new int[DbHelper.faktSubsLen];

        final String colM[] = {"_id", "name", "substitution"};
        int j;
        DecimalFormat DecFormat = new DecimalFormat(" 0000");
        ContentValues cv_Pair = new ContentValues();
        DbHelper.curKomm = 1;
        DbHelper.solvableGroup = 0;
        final String sqlEcec[] = {
                "delete from " + DbHelper.switchboard[vidWgrup] + ";",
                "delete from " + DbHelper.sub_scribe[vidWgrup] + ";",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='" + DbHelper.sub_scribe[vidWgrup] + "';"
        };

        db.beginTransaction();
        for (j = 0; j < sqlEcec.length; j++)
            db.execSQL(sqlEcec[j]);

        try {
            Cursor cursorLeftPair = db.query(DbHelper.elements[vidWgrup], colM, null, null, null, null, null),
                    cursorRightPair = db.query(DbHelper.elements[vidWgrup], colM, null, null, null, null, null);
            int iL1 = cursorLeftPair.getColumnIndex("_id"), idL, idR,
                    iL3 = cursorLeftPair.getColumnIndex("substitution"),
                    iR1 = cursorRightPair.getColumnIndex("_id"),
                    iR3 = cursorRightPair.getColumnIndex("substitution");
            String txtL, txtR, newTxtSwitch, newTxtPair, textSub = "";
            String pods[];
            if (cursorLeftPair.getCount() == 0) {
                DbHelper.err += "Не заданы образующие группы (f_buildTmp)";
                return;
            }
            mApp.putProt("");
            mApp.putProt("Построение коммутанта ");

            if (cursorLeftPair.moveToFirst()) {
                do {
                    idL = cursorLeftPair.getInt(iL1); // _id
                    txtL = cursorLeftPair.getString(iL3);
                    txtL = txtL.substring(1, txtL.indexOf("]"));
                    //              Log.e(TAG, "f_buildTmp l=" + txtL + " name= " + namL + " pos= " + cursorLeftPair.getPosition());
                    pods = txtL.split(","); // массив строковых чисел цикла
                    for (j = 0; j < DbHelper.faktSubsLen; j++)
                        subsL[j] = Integer.parseInt(pods[j].trim());
                    for (j = 0; j < DbHelper.faktSubsLen; j++)
                        subsLM[subsL[j] - 1] = j + 1;   // обратная подстановка к subsL

//  таблица text_sub - для применения автоморфизмов
                    if (mApp.rejGiga == 0) {
                        textSub = "";
                        for (j = 0; j < DbHelper.faktSubsLen; j++)
                            textSub += DecFormat.format(subsL[j]);
//                    Log.d(TAG, "f_build_switch id = " + idL + " txtL= " + txtL + " textSub =  " + textSub);
                        db.execSQL("insert into " + DbHelper.sub_scribe[vidWgrup] + " (id_s, text_sub) values (" + idL + ", '" + textSub + "') ;");
                    }
                    cursorRightPair.moveToFirst();
                    do {
                        idR = cursorRightPair.getInt(iR1); // _id
                        txtR = cursorRightPair.getString(iR3);
                        txtR = txtR.substring(1, txtR.indexOf("]"));
// перемножение
                        pods = txtR.split(","); // массив строковых чисел цикла
                        for (j = 0; j < DbHelper.faktSubsLen; j++)
                            subsR[j] = Integer.parseInt(pods[j].trim());
                        for (j = 0; j < DbHelper.faktSubsLen; j++)
                            subsRM[subsR[j] - 1] = j + 1;   // обратная подстановка

                        //               Log.e(TAG, "f_build_switch r=" + txtR + " name= " + namR + " pos= " + cursorRightPair.getPosition());
                        subsSwitch.clear();
                        subsPair.clear();
// код сопряженного элемента = (idleft**-1) * idright * idleft
                        for (j = 0; j < DbHelper.faktSubsLen; j++) {
                            subsPair.add(subsL[subsR[subsLM[j] - 1] - 1]);   // произведение (L**-1) * R * L
                        }
//  коммутатор = (R**-1) * (L**-1) * R * L
                        for (j = 0; j < DbHelper.faktSubsLen; j++)
                            subsSwitch.add(subsPair.get(subsRM[j] - 1));   // произведение (R **-1) * (сопряженная к R)

                        newTxtSwitch = subsSwitch.toString();
                        newTxtPair = subsPair.toString();
//                                            Log.e(TAG, "f_build_switch Switch=" + newTxtSwitch + " Pair=" + newTxtPair + " L= " + namL + " R= " + namR);
//                    mApp.putProt("Сопряжение элементов " + namL + " * " + namR + " = " + newTxtPair + " коммутатор =" + newTxtSwitch);

// запись произведения

                        cv_Pair.put("id_switch", 0);
                        cv_Pair.put("id_pair", 0);
                        cv_Pair.put("id_left", idL);
                        cv_Pair.put("id_right", idR);
                        cv_Pair.put("txt_pair", newTxtPair);
                        cv_Pair.put("txt_switch", newTxtSwitch);

                        long row_id = db.insert(DbHelper.switchboard[vidWgrup], null, cv_Pair);

                        if (row_id < 0) {
                            DbHelper.err += "Ошибка записи в таблицу " + DbHelper.switchboard[vidWgrup] + " " + row_id;
                            Log.e(TAG, DbHelper.err);
                        }
                        if (mApp.whatRun == -1 | DbHelper.err.length() > 0) {
                            cursorRightPair.close();
                            cursorLeftPair.close();
                            DbHelper.err += "\n Расчет прерван";
                            break;
                        }
                    } while (cursorRightPair.moveToNext());
                } while (cursorLeftPair.moveToNext());
            }
            cursorRightPair.close();
            cursorLeftPair.close();

            final String sqlExec[] = {
                    "UPDATE " + DbHelper.switchboard[vidWgrup] +
                            " SET id_switch = (SELECT " + DbHelper.elements[vidWgrup] + "._id " +
                            " FROM " + DbHelper.elements[vidWgrup]  +
                            " WHERE " + DbHelper.elements[vidWgrup] + ".substitution = " + DbHelper.switchboard[vidWgrup] + ".txt_switch) " +
                            " WHERE " + DbHelper.switchboard[vidWgrup] + ".txt_switch in (select E.substitution from " + DbHelper.elements[vidWgrup] + " E);",

                    "UPDATE " + DbHelper.switchboard[vidWgrup] +
                            " SET id_pair = (SELECT " + DbHelper.elements[vidWgrup] + "._id " +
                            " FROM " + DbHelper.elements[vidWgrup]  +
                            " WHERE "+ DbHelper.elements[vidWgrup] + ".substitution = " + DbHelper.switchboard[vidWgrup] + ".txt_pair) " +
                            " WHERE " + DbHelper.switchboard[vidWgrup] + ".txt_pair in (select E.substitution from " + DbHelper.elements[vidWgrup] + " E);",


                    "UPDATE " + DbHelper.elements[vidWgrup] + " SET switchboard_num = 1 " +
                            " WHERE " + DbHelper.elements[vidWgrup] + "._id in (select W.id_switch from " + DbHelper.switchboard[vidWgrup] + " W);",

            };

            for (j = 0; j < sqlExec.length; j++) {
                //         Log.e(TAG, "f_buildOne " + sqlExec[j]);
                db.execSQL(sqlExec[j]); // ошибок не должно быть !
            }

            DbHelper.countSwitch = dbH.f_getCount("select count(name) as ccc from " + DbHelper.elements[vidWgrup] + " where switchboard_num > 0;");
            //       Log.e(TAG, "f_buildOne countSw = " + DbHelper.countSwitch);
            mApp.putProt("Всего коммутаторов в группе " + DbHelper.countSwitch);
            if (DbHelper.countSwitch == DbHelper.countElements)
                mApp.putProt("ГРУППА НЕРАЗРЕШИМА");
            if (DbHelper.countSwitch == 1)
                mApp.putProt("ГРУППА АБЕЛЕВА");

            j = dbH.f_getCount("select max(deg) as ccc from " + DbHelper.elements[vidWgrup] + ";");
            if (j == DbHelper.countElements) {
                mApp.putProt("ГРУППА ЦИКЛИЧЕСКАЯ");
            }


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


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


        int i2 = 0;
        do {
            j = dbH.f_testCommCreate(DbHelper.curKomm + 1);
            if (DISPLAYLOG)
                Log.e(TAG, " f_nextKomm curKomm = " + DbHelper.curKomm + " solvableGroup ="+ DbHelper.solvableGroup + " итерация =" + i2 + " j = "+ j);
            if (j > 0)
                mApp.putProt("Построение коммутанта, итерация =" + (++i2) + " новых элементов = "+ j);
            if (i2 > 50) {
                DbHelper.solvableGroup = -1;
                mApp.putProt("Коммутант уровня не может быть расчитан!");
                return;
            }
        } while (j > 0);

    }

    public void f_createCykles() {
        // Разложение на непересекающиеся циклы, вычисляет степени элементов,...

        mApp.putProt("");
        mApp.putProt("Разложение на непересекающиеся циклы");

        // все степени подстановки (всех подстановок и всех pe) которая должна быть образующей циклической группы силова сохраняю в табл sylov_cykl

        int subsCykl[] = new int[DbHelper.faktSubsLen];
        int[] subs0, subs1;
        int i;
        String txt, txt0, cykles, stab, sqlUpdate, lCyklos, newTxt;
        List<Integer> podsListText = new ArrayList<>(DbHelper.faktSubsLen); // для построения [...]
        String podsCykl[];
        boolean yy;

        classSubs.f_createPrimeryNumber(DbHelper.countElements); // строю простые числа
        classSubs.f_numToPrime(DbHelper.countElements);   // для порядка группы и центра

        mApp.putProt("Порядок группы состоит из простых:");
        for (i = 0; i < substitutionS.sylovPrimeGrupNum.size(); i++)
            mApp.putProt(" " + substitutionS.sylovPrimeGrupNum.get(i) + " в степени " + substitutionS.sylovPrimeGrupPower.get(i));

        if (substitutionS.sylovPrimeGrupNum.size() == 1)
            mApp.putProt("Группа есть р-группа для простого р = " + substitutionS.sylovPrimeGrupNum.get(0));

        mApp.putProt("Порядок центра группы = " + DbHelper.countCentr);

// вычисляю порядки силовских подгрупп classSubs.sylovPower
        int dgPe = 0, pe, indPrim;
        substitutionS.sylovPower.clear();
        for (i = 0; i < substitutionS.sylovPrimeGrupNum.size(); i++) {
            pe = substitutionS.sylovPrimeGrupNum.get(i);
            dgPe = 1;  // ПОРЯДОК СИЛОВСКОЙ ПОДГРУППЫ
            for (indPrim = 0; indPrim < substitutionS.sylovPrimeGrupPower.get(i); indPrim++)
                dgPe *= pe;   // степень pe в порядке группы
            substitutionS.sylovPower.add(dgPe);
        }

        DbHelper.curNumSylov = 1;    // нумирация силовских подгрупп
        DbHelper.peSylCreate.clear();  // простые, для которых построены силовские подгруппы
        DbHelper.peSylNoFound.clear();  // простые, для которых не построены силовские подгруппы

        db.beginTransaction();
        try {
            Cursor cursorCykles = db.rawQuery("select distinct M.idleft as idleft, E.substitution as txt " +
                    "from " + DbHelper.temp_multiplication[vidWgrup] + " M, " + DbHelper.elements[vidWgrup] + " E where M.idleft = E._id; ", null);
            int iL1 = cursorCykles.getColumnIndex("idleft"), j, id, dgSb,
                    iL2 = cursorCykles.getColumnIndex("txt"); // substitution

            db.execSQL("delete from " + DbHelper.sylov_table[vidWgrup] + ";");
            db.execSQL("delete from sylov_cykl;");

            if (cursorCykles.moveToFirst()) {
                do {
                    id = cursorCykles.getInt(iL1); // _id
                    txt = txt0 = cursorCykles.getString(iL2);   // substitution
                    txt = txt.substring(1, txt.indexOf("]"));
                    podsCykl = txt.split(","); // массив строковых чисел цикла
                    for (j = 0; j < DbHelper.faktSubsLen; j++)
                        subsCykl[j] = Integer.parseInt(podsCykl[j].trim());

                    subs0 = Arrays.copyOf(subsCykl, DbHelper.faktSubsLen);
                    stab = classSubs.f_stab(DbHelper.faktSubsLen, subsCykl);
                    cykles = classSubs.f_toIndependentCycle(DbHelper.faktSubsLen, subsCykl);

                    lCyklos = "";
                    for (j = 0; j < substitutionS.arrCiklLen.size(); j++)
                        lCyklos += " " + substitutionS.arrCiklLen.get(j);
                    dgSb = classSubs.f_calculateDeg( true);

                    yy = false; // подстановка не для сохранения силовской подгруппы

                    if (DbHelper.countElements != DbHelper.countCentr)
                        if (dgSb != 0) {
                            i = substitutionS.sylovPrimeGrupNum.indexOf(substitutionS.peInDeg); // индекс pe
                            if (i >= 0) {
                                dgPe = substitutionS.sylovPower.get(i); // степень сил подгруппы
                                if (dgPe == dgSb) { // если порядок эл-та = порядку сил подгруппы - элемент есть образующий сил подгруппы
                                    if (DISPLAYLOG)
                                        Log.e(TAG, "f_createCykles +++ =" + txt0 + " cykles=" + cykles + " degSb= " + dgSb + " degPe=" + dgPe + " curNumSylov= " + DbHelper.curNumSylov + " id=" + id);
                                    yy = true;
                                }
                            }
                        }

                    if (yy) {
// подстановка subs = образующая силовской подгруппы - вычисляю ее степени
                        sqlUpdate = "insert into sylov_cykl (pe, forming, txt, deg, silovnum, id_subs) " +
                                "select  " + substitutionS.peInDeg + ", " + id + ", '" + txt0 + "', 1, " + DbHelper.curNumSylov + ", _id " +
                                "from " + DbHelper.elements[vidWgrup] + " where substitution = '" + txt0 + "';";
                        db.execSQL(sqlUpdate);

                        subs1 = Arrays.copyOf(subs0, DbHelper.faktSubsLen);
                        for (i = 1; i < dgSb; i++) {
// запоминаю все степени этой подстановки
                            subs0 = classSubs.f_mnoj(subs0, subs1);
                            podsListText.clear();
                            for (j = 0; j < DbHelper.faktSubsLen; j++)
                                podsListText.add(subs0[j]);
                            newTxt = podsListText.toString();   // текстовый вид степени i+1
                            if (DISPLAYLOG)
                                Log.e(TAG, "f_createCykles =" + txt + " cykles=" + cykles + " degSb= " + dgSb + " curNumSylov= " + DbHelper.curNumSylov + " newTxt=" + newTxt + " i=" + i + " id=" + id);
                            sqlUpdate = "insert into sylov_cykl (pe, forming, txt, deg, silovnum, id_subs) " +
                                    "select  " + substitutionS.peInDeg + ", " + id + ", '" + newTxt + "', " + (i + 1) + ", " + DbHelper.curNumSylov + ", _id " +
                                    "from " + DbHelper.elements[vidWgrup] + " where substitution = '" + newTxt + "';";
                            db.execSQL(sqlUpdate);
                        } // все степени в sylov_cykl записаны

// проверить на дублирование подгруппы в sylov_cykl
                        for (i = 0; i < DbHelper.curNumSylov; i++) {
                            sqlUpdate = "select id_subs from sylov_cykl where silovnum = " + DbHelper.curNumSylov +
                                    " INTERSECT " +
                                    "select id_subs from sylov_cykl where silovnum = " + i + "; ";
                            Cursor cursorTest = db.rawQuery(sqlUpdate, null);
                            if (cursorTest.moveToFirst()) {
                                if (cursorTest.getCount() == dgPe) { // есть точно такая же подгруппа
                                    db.execSQL("delete from  sylov_cykl where silovnum = " + DbHelper.curNumSylov + "; ");
                                    if (DISPLAYLOG)
                                        Log.e(TAG, "f_createCykles дублирует " + txt0 + " cykles=" + cykles + " degSb= " + dgSb + " curNumSylov= " + DbHelper.curNumSylov + " id=" + id);
                                    yy = false;
                                    break;
                                }
                            }
                            cursorTest.close();
                        }
                    }
                    if (yy) {
                        if (DISPLAYLOG) {
                            Log.e(TAG, "f_createCykles найдена " + txt0 + " cykles=" + cykles + " degSb= " + dgSb + " curNumSylov= " + DbHelper.curNumSylov + " id=" + id);
                            mApp.putProt("Подстановка " + txt0 + ", Id=" + id + " порядка " + dgSb + " взята за образующий элемент циклической подгруппы силова для простого " + substitutionS.peInDeg + " с номером " + DbHelper.curNumSylov);
                        }

                        if (!DbHelper.peSylCreate.contains(substitutionS.peInDeg))
                            DbHelper.peSylCreate.add(substitutionS.peInDeg);

                        DbHelper.curNumSylov++;
                    }

                    sqlUpdate = "update " + DbHelper.elements[vidWgrup] + " set ciklos = '" + cykles + "', deg = " + dgSb + ", parity=" + substitutionS.parity +
                            ", stabilizer = '" + stab + "', pe = " + substitutionS.peInDeg + ", cykl_len = '" + lCyklos + "'  where _id = " + id;
                    db.execSQL(sqlUpdate); // ошибок не должно быть !
                    if (myExecutor.MyThread.isCancel || DbHelper.err.length() > 0) {
                        DbHelper.err += "\n Расчет прерван";
                        break;
                    }

                } while (cursorCykles.moveToNext());
            }

            cursorCykles.close();

            // записать все найденные силов подгруппы из sylov_cykl в sylov_table
            sqlUpdate = "insert into " + DbHelper.sylov_table[vidWgrup] + " ( pe, num, id_main, id_s) " +
                    " select pe, silovnum, forming, id_subs from sylov_cykl; ";
            db.execSQL(sqlUpdate); // ошибок не должно быть !

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

        if (mApp.whatRun != -1 && DbHelper.err.length() == 0) {
            db.setTransactionSuccessful();
        }
        db.endTransaction();
        mApp.putProt("Разложение на непересекающиеся циклы выполнено, найдено " + (DbHelper.curNumSylov - 1) + " силовских подгрупп");
    }

    public void f_build_centr() {
        // Определение центра
        // если для элемента А коммутаторы его со всеми элементами = 1 - это элемент центра

        final String SQLStr[] = {
// id элемента и порядок централизатора этого эл-та
                "delete from " + DbHelper.centers[vidWgrup] + ";",

                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='" + DbHelper.centers[vidWgrup] + "';",

                "insert into " + DbHelper.centers[vidWgrup] + " (id_subs, count_permutation) " +
                        "select id_left, count(id_right) from " + DbHelper.switchboard[vidWgrup] + " where txt_switch = '" + substitutionS.Edinica + "' " +
                        "group by id_left  order by id_left asc; ",

                "update " + DbHelper.elements[vidWgrup] + " set center_num = " +
                        "(select " + DbHelper.centers[vidWgrup] + ".count_permutation from " + DbHelper.centers[vidWgrup] +
                        " where " + DbHelper.centers[vidWgrup] + ".id_subs = " + DbHelper.elements[vidWgrup] + "._id); ",

                "update " + DbHelper.elements[vidWgrup] + " set pairing_num = 1 " + // установить для центра одну группу сопряж элементов = 1
                        "where  center_num = " + DbHelper.countElements + "; "
        };
        mApp.putProt("");
        mApp.putProt("Построение центра ");
        db.beginTransaction();
        try {
            for (String s : SQLStr) {
                db.execSQL(s);
            }

            DbHelper.countCentr = dbH.f_getCount("select count(*) as ccc from " + DbHelper.centers[vidWgrup] +
                    " where count_permutation = " + DbHelper.countElements);
            substitutionS.codEdinicy = dbH.f_getCount("select _id as ccc from " + DbHelper.elements[vidWgrup] + " where substitution = '" + substitutionS.Edinica + "'; ");

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

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

        if (DbHelper.countCentr == DbHelper.countElements)
            mApp.putProt("ГРУППА АБЕЛЕВА, Id единицы " + substitutionS.codEdinicy);
        else
            mApp.putProt("Порядок центра = " + DbHelper.countCentr + ", Id единицы " + substitutionS.codEdinicy);
    }

    public void f_build_conjugate() {
        // Построение классов сопряженных элементов,
        // должна выполняться после построения центра !!!
        // заполняет таблицу централизаторов centralizer
        mApp.putProt("");
        mApp.putProt("Построение классов сопряженных элементов");
        String sqlUpdate = "", sCiklos = "",
                sqlSel = "select W.id_right as id_right, W.id_pair as id_pair, E.ciklos as ciklos  " +
                        "from " + DbHelper.switchboard[vidWgrup] + " W, " + DbHelper.elements[vidWgrup] + " E" +
                        "  where E._id = W.id_right and E.pairing_num = 0 order by id_right asc; ";
        int idMain, countClassConj, indCyk, curNum, jj;
        boolean snYes = false; // true - брать номера классов из Sn
        int classNomer = 2; // номер класса сопряженных элементовю 1 - для всего центра!

        if (substitutionS.punktSn != 1) { // строится не Sn
            sqlUpdate = " " + dbH.f_getCount("select max(class_area) as ccc from pairing_area_n;");  // max класс в Sn, если она есть
//            Log.e(TAG, "f_build_conjugate classNomer=" + classNomer);
        }
        if (sqlUpdate.length() > 0)
            if (Integer.parseInt(sqlUpdate.trim()) != 0) {
                classNomer = 1 + Integer.parseInt(sqlUpdate.trim()); // доступные номера классов
                snYes = true;
            }
        arrConjug.clear();
        arrConjugNum.clear();

        db.beginTransaction();
        try {

            sqlUpdate = "update " + DbHelper.centers[vidWgrup] + " set pairing_num = 1; "; // для центра номер класса сопр эл-тов = 1
            db.execSQL(sqlUpdate); // ошибок не должно быть !

            do {
                Cursor cursorConj = db.rawQuery(sqlSel, null);
                int indMain = cursorConj.getColumnIndex("id_right");
                indCyk = cursorConj.getColumnIndex("ciklos");

                if (cursorConj.getCount() == 0) {
                    cursorConj.close();
                    break;
                }
                cursorConj.moveToFirst();
                idMain = cursorConj.getInt(indMain);
                sCiklos = cursorConj.getString(indCyk); // циклы
                cursorConj.close();

                curNum = 0; // определяю номер класса желательно совпадающий с Sn
                if (snYes && vidWgrup == 0) {
                    sqlUpdate = " " + dbH.f_getCount("select P.class_area as ccc from pairing_area_n P, elements_n E\n" +
                            "  where  P.id_subs = E.id_true and E.ciklos = '" + sCiklos + "';");
                    if (Integer.parseInt(sqlUpdate.trim()) != 0)
                        curNum = Integer.parseInt(sqlUpdate.trim());
                }
                if (curNum > 0) {   // номер может быть уже занят
                    for (jj = 0; jj < arrConjugNum.size(); jj++)
                        if (arrConjugNum.get(jj) == curNum)
                            curNum = 0; // номер уже мспользовался
                }
                if (curNum == 0)
                    curNum = classNomer++;
                arrConjugNum.add(curNum);
//                Log.e(TAG, "f_build_conjugate idMain=" + idMain + " sCiklos=" + sCiklos + " classNomer=" + classNomer + " curNum = " + curNum + " snYes = " + snYes);

                // проставляю pairing_num
                sqlUpdate = "update " + DbHelper.elements[vidWgrup] + " set pairing_num = " + curNum +
                        "  where " + DbHelper.elements[vidWgrup] + "._id in (select distinct E.id_pair from " + DbHelper.switchboard[vidWgrup] + " E " +
                        " where E.id_right = " + idMain + ");";
                db.execSQL(sqlUpdate); // ошибок не должно быть !
//              Log.e(TAG, "f_build_conjugate sqlUpdate=" + sqlUpdate);

                Cursor cursorConjCount = db.rawQuery("select _id from " + DbHelper.elements[vidWgrup] + " where pairing_num = " + curNum + "; ", null);
                countClassConj = cursorConjCount.getCount();
                cursorConjCount.close();

                // запись в  centers
                sqlUpdate = "update " + DbHelper.centers[vidWgrup] + " set pairing_num = " + curNum + ", count_pairing = " + countClassConj +
                        "  where " + DbHelper.centers[vidWgrup] + ".id_subs in (select distinct E.id_pair from " + DbHelper.switchboard[vidWgrup] + " E where E.id_right = " + idMain + ");";
                db.execSQL(sqlUpdate); // ошибок не должно быть !
//              Log.e(TAG, "f_build_conjugate sqlUpdate=" + sqlUpdate);

                if (myExecutor.MyThread.isCancel || DbHelper.err.length() > 0) {
                    DbHelper.err += "\n Расчет прерван";
                    break;
                }

            } while (true);

            sqlSel = "select pairing_num, count(name) as ccc from " + DbHelper.elements[vidWgrup] + " GROUP BY pairing_num order by pairing_num asc; ";

            Cursor cursorCountConj = db.rawQuery(sqlSel, null);
            int indNum = cursorCountConj.getColumnIndex("pairing_num"),
                    count,
                    indCcc = cursorCountConj.getColumnIndex("ccc");
            if (cursorCountConj.getCount() > 0) {

                if (cursorCountConj.moveToFirst()) {
                    arrConjugNum.clear();
                    do {
                        count = cursorCountConj.getInt(indNum);
                        arrConjugNum.add(count);
                        count = cursorCountConj.getInt(indCcc);
                        arrConjug.add(count);
                        //                Log.e(TAG, "f_buildTmp pairing_num=" + pairing_num + " count= " + count);
                    } while (cursorCountConj.moveToNext());
                }
            }
            cursorCountConj.close();

            // число нечетных подстановок:
            count = dbH.f_getCount("select count(name) as ccc from " + DbHelper.elements[vidWgrup] + " where parity > 0; ");
            count = DbHelper.countElements - count;
            if (DbHelper.countElements == count)
                mApp.putProt("Порядок подгруппы четных подстановок " + count + " равен порядку группы: группа состоит из четных подстановок");
            else if (DbHelper.countElements / 2 != count)
                mApp.putProt("Порядок подгруппы четных подстановок " + count + ", порядок группы " + DbHelper.countElements);
            else
                mApp.putProt("Индекс подгруппы четных подстановок  равен 2, порядок группы " + DbHelper.countElements + ". Порядок подгруппы четных подстановок " + count);

            if (DISPLAYLOG)
                Log.d(TAG, "f_buildTmp Число четных подстановок в группе " + count + ",  порядок группы " + DbHelper.countElements);

            // заполняет таблицу централизаторов centralizer
            // записываю только для 1-го представителя смежного класса его централизатор в табдицу centralizer
            sqlSel = "delete from "+ DbHelper.centralizer[vidWgrup] + ";";
            db.execSQL(sqlSel);

            sqlSel = "select E.pairing_num as pnum, M.id_left as idl, M.id_right as idr from " + DbHelper.elements[vidWgrup] + " E, " + DbHelper.switchboard[vidWgrup] + " M " +
                    "where M.txt_switch = '" + substitutionS.Edinica + "' and E._id = M.id_left " +
                    "order by E.pairing_num, M.id_left; ";

            Cursor cursorCentr = db.rawQuery(sqlSel, null);
            indNum = cursorCentr.getColumnIndex("pnum");
            int indL = cursorCentr.getColumnIndex("idl"),
                    indR = cursorCentr.getColumnIndex("idr");
            String sqlInsertCen;
            if (cursorCentr.getCount() > 0) {

                int idl, idl0 = 0, idr, num0 = 0, num;
                if (cursorCentr.moveToFirst()) {
                    do {
                        num = cursorCentr.getInt(indNum);
                        if (num != num0) {
                            num0 = num;
                            idl0 = cursorCentr.getInt(indL);
                        }
                        idl = cursorCentr.getInt(indL);
                        if (idl == idl0) {
                            idr = cursorCentr.getInt(indR);
                            sqlInsertCen = "insert into "+ DbHelper.centralizer[vidWgrup] + " (class_pair, id_imagine, id_subs) VALUES " +
                                    " (" + num0 + ", " + idl + ", " + idr + "); ";
//                        Log.e(TAG, "f_build_conjugate pairing_num=" + num0 + " id= " + idl + " idr=" + idr + " " +sqlInsertCen);
                            db.execSQL(sqlInsertCen); // ошибок не должно быть !
                        }


                    } while (cursorCentr.moveToNext());
                }
            }
            cursorCentr.close();
        } catch (Exception e) {
            Log.e(TAG, "Error f_build_conjugate " + e.getMessage() + " " + e.fillInStackTrace() + " " + e.getStackTrace());
            DbHelper.err += "Error f_build_conjugate " + e.getMessage() + " " + e.getStackTrace();
            e.printStackTrace();
        }

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

        for (int j = 0; j < arrConjug.size(); j++) {
            if (j == 0)
                mApp.putProt("Класс сопряженных элементов № " + arrConjugNum.get(j) + " содержит " + arrConjug.get(j) + " элементов (всесь центр группы)");
            else {
                sqlUpdate = dbH.f_getString("select distinct cykl_len as stext from " + DbHelper.elements[vidWgrup] + " where pairing_num = " + arrConjugNum.get(j) + " limit 1;");
                if (sqlUpdate.length() == 0)
                    sqlUpdate = "";
                mApp.putProt("Класс сопряженных элементов № " + arrConjugNum.get(j) + " ("+ sqlUpdate + ") содержит " + arrConjug.get(j) + " элементов");
//            Log.e(TAG, "f_buildTmp Класс сопряженных элементов № " + arrConjugNum.get(j) + " содержит " + arrConjug.get(j) + " элементов");
            }
        }
    }

}
//-------------------------------