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

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

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

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

public class classGenDop {
    // дополнительная обработка вычисляет НОК порядков эл-тов группы
    //
    private static final String TAG = "GRUGRA_DOP_CLASS";
    final static private boolean DISPLAYLOG = false;
    public mAplication mApp;
    private DbHelper dbH;
    static public substitutionS classSubs;
    static public SQLiteDatabase db;

    classGenDop(mAplication mApp_, DbHelper dbH_) {
        mApp = mApp_;
        dbH = dbH_;
        db = DbHelper.db;
        classSubs = mApp.classSubs;
    }

    public int f_transDop() {
        // проверяет на транзитивность группу
        classSylow clSylow = new classSylow();
        clSylow.init(mApp, dbH, 0);
        clSylow.f_createTabCorrection(false, 3);    // строит таблицу tmp_tab_correction

        int j, l, k, ret = 0;
        String coobc;
        List<String> areaTran = new ArrayList();

        mApp.putProt("");
        for (j = 0; j < DbHelper.faktSubsLen; j++) {

            l = dbH.f_getCount("select count(distinct col" + (j + 1) + ")  as ccc from tmp_tab_correction order by 1 asc");
            mApp.putProt("Орбита точки " + (j + 1) + " имеет длину " + l);
            coobc = ""; // обл транзитивности
            dbH.f_getMas("select distinct col" + (j + 1) + " || ' '  as stext from tmp_tab_correction order by 1 asc");
            for (k = 0; k < DbHelper.selectedMas.length; k++) {
                coobc += DbHelper.selectedMas[k];
            }
            if (!areaTran.contains(coobc))
                areaTran.add(coobc);

            if (l < DbHelper.faktSubsLen)
                ret = -1;
        }
        if (ret != 0) {
            mApp.putProt("\nОбласти транзитивности: ");
            for (k = 0; k < areaTran.size(); k++)
                mApp.putProt("    " + areaTran.get(k));
        }

        return ret;

    }

    public void f_nodDop() {
        // вычисляет НОК порядков эл-тов группы

        if (DISPLAYLOG)
            Log.e(TAG, " f_primeDop ");

        String cLen, cLen0 = "9", www;
        int i, pe, iPe, deg, iCl;

        classSubs.f_createPrimeryNumber(5000); // строю простые числа classSubs.arrPrNumber

        List< Integer> arrDegPrime = new ArrayList(); // массив степеней простых чисел из classSubs.arrPrNumber
        for (i = 0; i < classSubs.arrPrNumber.size(); i++)  // создать пусой массив
            arrDegPrime.add(i, 0);

        Cursor curForm = db.rawQuery("select cykl_len  from elements " +
                "  order by cykl_len desc;", null);
        curForm.moveToFirst();
        if (curForm.getCount() > 0) {
            iCl = curForm.getColumnIndex("cykl_len");
            do {
                cLen = curForm.getString(iCl).trim();

                if ( ! cLen.equals(cLen0)) {
                    if (DISPLAYLOG)
                        Log.e(TAG, "f_primeDop cLen = " + cLen + "  cLen0 = " + cLen0);

                    do {    // вычисляю все простые и их степени
                        if (cLen.length() > 0) {

                            i = cLen.indexOf(" ");
                            if ( i > 0) {
                                www = cLen.substring(0, i).trim();
                                cLen = cLen.substring(i).trim();
                            }  else {
                                www = cLen;
                                cLen = "";
                            }

                            classSubs.f_numToPrime(Integer.parseInt(www.trim())); // записывается в sylovPrimeGrupNum, sylovPrimeGrupPower
                            for (i = 0; i < classSubs.sylovPrimeGrupNum.size(); i++) {
                                pe = classSubs.sylovPrimeGrupNum.get(i);
                                deg = classSubs.sylovPrimeGrupPower.get(i);
                                iPe = classSubs.arrPrNumber.indexOf(pe);    // индекс простого
                                if (arrDegPrime.get(iPe) < deg)
                                    arrDegPrime.set(iPe, deg);  // запись степени простого pe

                                if (DISPLAYLOG)
                                    Log.e(TAG, "f_nodDop www = " + www + " pe = " + pe + " deg = " + deg + " iPe =" + iPe + " i=" + i);
                            }


                        } else
                            break;

                    } while (true);
                    cLen0 = cLen;
                }

            } while (curForm.moveToNext());
        }
        curForm.close();

// расчет НОК
        deg = 1;

        for (i = 0; i < arrDegPrime.size(); i++) {
            iPe = arrDegPrime.get(i);
            if (iPe > 0) {
                pe = classSubs.arrPrNumber.get(i);
                deg *= Math.pow((double) pe, (double) iPe);
                if (DISPLAYLOG)
                    Log.e(TAG, "f_nodDop pe = " + pe + " deg = " + deg + " iPe =" + iPe + " i=" + i);
            }
        }

        mApp.putProt("");
        mApp.putProt("НОК элементов группы " + ((int) deg));

    }

    public void f_Im_Dop() {
        /* вычисляет внутренние автоморфизмы и их порядки
           заполняет табл
         auto_centralizer
         auto_normalizer
         */
        if (! dbH.f_testFn()) {
            mApp.putProt("");
            mApp.putProt("Группа Sn для нужного n не сохранена!");
            return;
        }

        int cCentr, cNorm, cAuto, cIso;

        // внутринние автоморфизмы

        cCentr = dbH.f_getCountRow("select _id as ccc from elements where center_num = " + DbHelper.countElements + ";");
        cAuto = DbHelper.countElements / cCentr;

        mApp.putProt("");
        mApp.putProt("Порядок центра группы " + cCentr +
                "\nПорядок группы " + DbHelper.countElements +
                "\nПорядок группы внутренних автооморфизмов " + ((int) cAuto));

        final String sqlD[] = {
                "DELETE from auto_centralizer;",
                "DELETE from auto_normalizer;",

                "insert into auto_centralizer (id_sn) select cid from (\n" +  // центорализатор группы в Sn
                        "select S.id_left cid, count(distinct N1.link_to_elements)\n" +
                        "                        from switchboard_n S, elements_n N1, elements_n N2\n" +
                        "                           where S.id_right = N1.id_true and \n" +
                        "                               S.id_pair = N2.id_true and \n" +
                        "                        not (N1.link_to_elements is NULL) and  not (N2.link_to_elements is NULL) AND \n" +
                        "                        S.id_switch = " + substitutionS.codEdinicy_n + " \n" +
                        "                        GROUP by S.id_left\n" +
                        "                    HAVING count(distinct N1.link_to_elements) = "+ DbHelper.countElements + "\n" +
                        "                        order by S.id_left asc" +
                        " );",

                "insert into auto_normalizer (id_sn) select cid from (\n" +   // нормализатор  группы в Sn
                        "select S.id_left cid, count(distinct N1.link_to_elements) " + // id_pair = (idleft**-1) * idright * idleft
                        "from switchboard_n S, elements_n N1, elements_n N2\n" +
                        "   where S.id_right = N1.id_true and \n" +
                        "  N1.for_n <= " + DbHelper.faktSubsLen + "  and  \n" +
                        "  N2.for_n <= " + DbHelper.faktSubsLen + "  and  \n" +
                        "      S.id_pair = N2.id_true and \n" +
                        "      not N1.link_to_elements  is NULL and  not N2.link_to_elements is NULL\n" +
                        "      GROUP by S.id_left\n" +
                        "      HAVING count(distinct N1.link_to_elements) = " + DbHelper.countElements + "" +
                        "  order by S.id_left asc\n" +
                        "      );",

                "select count(*) as ccc from auto_centralizer; ",
                "select count(*) as ccc from auto_normalizer; ",
                "select count(*) as ccc from elements_a; "
        };

        for (int i = 0; i < 4; i++)
            db.execSQL(sqlD[i]);

        // ищу центорализатор группы в Sn
        cCentr = dbH.f_getCount(sqlD[4]);

        if (cCentr > 0) {
            // нормализатор  группы в Sn
            cNorm = dbH.f_getCount(sqlD[5]);

            cIso = cNorm / cCentr;
            mApp.putProt("Порядок централизатора группы в Sn " + cCentr +
                    "\nПорядок нормализатора группы в Sn " + cNorm +
                    "\nПорядок группы автооморфизмов группы индуцированных внутренними автоморфизмами Sn " + ((int) cIso));
        }
//        Log.e(TAG, "f_Im_Dop  substitutionS.codEdinicy_n = " + substitutionS.codEdinicy_n + "  substitutionS.codEdinicy = " + substitutionS.codEdinicy);

    }

    private void f_SnAutoDpIm(boolean gruppRej){
        /* вызывается из f_perebor()
        находит автоморфизмы порожденные
        gruppRej = true - Im(Sn)
        gruppRej = false - Im(G) - внутренние автоморфизмы группы
 */

//        Log.e(TAG, "f_SnAutoDpIm  gruppRej = " + gruppRej);
        mApp.putProt("Построение автоморфизмов по " + (gruppRej ? "внутренним автоморфизмам Sn" : "внутренним автоморфизмам группы"));
        if (! dbH.f_testFn() && gruppRej) {
            mApp.putProt("Группа Sn для нужного n не построена!");
        }

        final String sqlSn [] = {
                "DELETE from pe_subgroup;",
                "DELETE FROM temp_pe;",
/* lid - id автоморфизма,
  rid - до автоморф
  mid - куда переводит  автоморф
*/
                "select S.id_left as lid, R.link_to_elements as rid, M.link_to_elements as mid,\n" +        //  2 Sn
                        "      R.substitution as Rsub, M.substitution as Msub, R.ciklos Rcikl, M.ciklos Mcikl\n" +
                        "    from switchboard_n S, elements_n R, elements_n M\n" +
                        "      where  R.id_true =  S.id_right and M.id_true = S.id_pair and\n" +
                        "  R.for_n <= " + DbHelper.faktSubsLen + "  and  \n" +
                        "  M.for_n <= " + DbHelper.faktSubsLen + "  and  \n" +
                        "           not R.link_to_elements is NULL and not M.link_to_elements is NULL\n" +
                        "    order by S.id_left  asc, R.link_to_elements  asc, M.link_to_elements asc;",

                "insert into pe_subgroup (list_ids) select distinct list_num from  temp_pe order by 1 asc;",   // 3

                "insert into elements_a (link_to_sn, substitution, name, link_to_group) " +             // 4
                        "select 0, list_ids, '"+ (gruppRej ? "S" : "G") + "' || _id, 0 from pe_subgroup;",

                "update elements_a set (link_to_sn,  ciklos, deg) = ( \n" +  //      5   Sn
                        " select distinct G.id_1, pe, degs  \n" +
                        "   from  temp_pe G \n" +
                        "   where elements_a.substitution = G.list_num " +
                        ");",

                "select S.id_left as lid, R._id as rid, M._id as mid,\n" +  //      6  G
                        "      R.substitution as Rsub, M.substitution as Msub, R.ciklos Rcikl, M.ciklos Mcikl\n" +
                        "    from switchboard S, elements R, elements M\n" +
                        "      where  R._id =  S.id_right and M._id = S.id_pair \n" +
                        "    order by S.id_left  asc, R._id  asc, M._id asc;",


                "update elements_a set  (link_to_group, ciklos, deg) = ( \n" +      // 7 G
                        " select distinct G.id_1, pe, degs  \n" +
                        "   from  temp_pe G \n" +
                        "   where elements_a.substitution = G.list_num " +
                        ");",

                "update elements_a set  (link_to_group) = ( \n" +  //      8   Sn
                        " select distinct N.link_to_elements  \n" +
                        "   from  temp_pe G, elements_n N \n" +
                        "   where elements_a.link_to_group = 0 and elements_a.substitution = G.list_num and " +
                        " G.id_1 = N.id_true " +
                        ");",


        };
        String err = "", lst = "", insSQl, sub;
        int iiL, iiR, iiM, iL, iR, iM, iL0 = 0, j = 0, dgSb = 0;

        if (DISPLAYLOG)
            Log.e(TAG, "f_SnAutoDOop  ");
        try {
            db.execSQL(sqlSn[0]);
            db.execSQL(sqlSn[1]);

            Cursor mCursorDop;
            if (gruppRej)
                mCursorDop = db.rawQuery(sqlSn[2], null);
            else
                mCursorDop = db.rawQuery(sqlSn[6], null);

            if (mCursorDop.moveToFirst()) {
                if (mCursorDop.getCount() > 0) {
                    iiL = mCursorDop.getColumnIndex("lid");
                    iiR = mCursorDop.getColumnIndex("rid");
                    iiM = mCursorDop.getColumnIndex("mid");

                    do {    // формирую подстановку на множестве эл-тов G
                        iL = mCursorDop.getInt(iiL);
                        iR = mCursorDop.getInt(iiR);
                        iM = mCursorDop.getInt(iiM);
                        if (iL != iL0) { //  смена автоморфизма
                            if (iL0 > 0 && j == DbHelper.countElements) {
                                lst = lst.trim();
                                lst = lst.substring(0, lst.length() - 1);
                                lst += "]";
                                int nSub[] = classSubs.f_toArray(lst, DbHelper.countElements); // подстановка в int[]
                                sub = classSubs.f_toIndependentCycle(DbHelper.countElements, nSub);
//                                dgSb = classSubs.f_calculateDeg( true);
                                insSQl = "insert into  temp_pe (id_1, id_2, list_num, pe, degs) " +
                                        " values (" + iL0 + ", " + iR + ", '" + lst + "', '" + sub + "', " + dgSb + ");";
                                if (DISPLAYLOG)
                                    Log.e(TAG, "f_SnAutoDOop iL0 = " + iL0 + "  sub = " + sub + "  lst = " + lst + " gruppRej = " + gruppRej);
                                db.execSQL(insSQl);
                                if (DISPLAYLOG)
                                    Log.e(TAG, "f_SnAutoDpIm insSQl = " + insSQl);
                            }
                            iL0 = iL;
                            lst = "[";
                            j = 0;
                        }
                        lst += iM + ", ";
                        j++;
                        if (myExecutor.MyThread.isCancel || DbHelper.err.length() > 0) {
                            DbHelper.err += "\n Расчет прерван";
                            break;
                        }

                    } while (mCursorDop.moveToNext());
// последняя запись
                    if (iL0 > 0 && j == DbHelper.countElements) {
                        lst = lst.trim();
                        lst = lst.substring(0, lst.length() - 1);
                        lst += "]";
                        int nSub[] = classSubs.f_toArray(lst, DbHelper.countElements); // подстановка в int[]
                        sub = classSubs.f_toIndependentCycle(DbHelper.countElements, nSub);
//                                dgSb = classSubs.f_calculateDeg( true);
                        insSQl = "insert into  temp_pe (id_1, id_2, list_num, pe, degs) " +
                                " values (" + iL0 + ", " + iR + ", '" + lst + "', '" + sub + "', " + dgSb + ");";
                        if (DISPLAYLOG)
                            Log.e(TAG, "f_SnAutoDOop iL0 = " + iL0 + "  sub = " + sub + "  lst = " + lst + " gruppRej = " + gruppRej);
                        db.execSQL(insSQl);
//                        if (DISPLAYLOG)
//                            Log.e(TAG, "f_SnAutoDpIm insSQl = " + insSQl);
                    }
                }
            }
            mCursorDop.close();

            db.execSQL(sqlSn[3]);
            db.execSQL(sqlSn[4]);
            if (gruppRej) {
                db.execSQL(sqlSn[5]);
                db.execSQL(sqlSn[8]);
            } else
                db.execSQL(sqlSn[7]);

            iL0 = dbH.f_getCountRow("select _id from elements_a;");
            mApp.putProt("Всего построено " + (gruppRej ? " автоморфизмов по внутренних автоморфизмов Sn " : "внутренних автоморфизмов G ") + iL0 );


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

    private void f_getObrazDp() {
        // строит  List<String> imObraz - списки образов образующих при внутренних автоморфизмов в виде
        imObraz.clear();
        String sub, mask;
        int m, j;

        Cursor mCursorDpMask = db.rawQuery("select substitution as sub from elements_a;", null);
        if (mCursorDpMask.moveToFirst()) {
            if (mCursorDpMask.getCount() > 0) {
                int iSub = mCursorDpMask.getColumnIndex("sub");

                do {    // формирую подстановку на множестве эл-тов G
                    sub = mCursorDpMask.getString(iSub);
                    int nSub [] = classSubs.f_toArray(sub, DbHelper.countElements); // подстановка в int[]
                    mask = "[";
                    for (j = 0; j < allKuch; j++) {
                        m = nSub[kuchFrom[j] - 1]; // образ ключа j
                        if (j > 0)
                            mask += ", ";
                        mask += m + "";
                    }
                    mask += "]";
                    if (!imObraz.contains(mask))
                        imObraz.add(mask);
                    if (DISPLAYLOG)
                       Log.e(TAG, "f_getObrazDp sub = " + sub + "  mask = " + mask);

                } while (mCursorDpMask.moveToNext());

            }
        }
        mCursorDpMask.close();
    }


    // данные построения автоморфизмов по перебору
    private int kuchSize[],     // размеры куч
            kuchDeg[],  // порядки эл-тов куч
            kuchFrom[],  // id-ы эл-тов образующих
            kuchi[][],  // id-ы куч

    // curInd[i] = тек индексы в kuchi[ kuchLevel ][ curInd[] ] = _id куда переводит автоморф kuchFrom[ kuchLevel ]
            curInd[],   // текущий индеск в массивах:
            kuchLevel = 0,  // номер уровня
            allKuch = 0;    // всего куч
    private List<String> imObraz = new ArrayList(); // списки образов образующих при внутренних автоморфизмов в виде
    private int loadingPBCount = 0; //  установка значения в  ProgressBar loadingPB

    public void f_perebor() {
        // построение автоморф методом перебора
        // вызывается из myExecuter

        // 'SnYes_g' - группа Sn - все автоморфизмы внутренние если n != 6
  /*      if (dbH.f_getCount("select val as ccc  from params where parm = 'SnYes_g';") > 0) {
            if (DbHelper.faktSubsLen != 6) {
                mApp.putProt("Для группы Sn все автоморфизмы внутренние и построены");
                return;
            }
        }
   */
        dbH.f_setVidGr(0, false);

        mApp.activityBuild.loadingPB.setMax(70);
        mApp.activityBuild.loadingPB.setProgress(10);
        mApp.putProt("");
        mApp.putProt("Поиск всех автоморфизмов");
        if (DISPLAYLOG)
            Log.e(TAG, "f_perebor Поиск всех автоморфизмов" );
        db.beginTransaction();
        String rSQL;
        String fiksSql [] = {
                "DELETE FROM temp_pe;",

                "insert into temp_pe (id_1, id_2)\n" +      // здесь будет id_1 - _id, id_2 - порядок класса сопр эл=тов в котором содержится  id_1
                        "  select A.id_subs, count(C.id_subs)\n" +
                        "from pairing_area A, pairing_area C\n" +
                        "where A.class_area = C.class_area\n" +
                        "group by A.id_subs \n" +
                        "order by 1 asc;",

                "select _id as stext from elements where iteration = 0 and not name  LIKE '%^'  order by 1 asc;"
        };
        int k, j;
        db.execSQL("DELETE FROM elements_a;");
        db.execSQL("UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='elements_a';");

        try {
// строю внутренние автоморфизмы
            f_SnAutoDpIm(true);     // Im(Sn)
// если Sn построена не надо строить для G
            k = dbH.f_getCount("select count(*) as ccc from elements_a;");
            if (k == 0)
                f_SnAutoDpIm(false);    // Im(G)

            for (j = 0; j < 2; j++)
                db.execSQL(fiksSql[j]);

            // всего образующих не считая обратных к ним:
            allKuch = dbH.f_getMInt(fiksSql[2]); // "select _id as stext from elements where iteration = 0 and not name  LIKE '%^'  order by 1 asc;"
            if (DISPLAYLOG)
                Log.e(TAG, "f_perebor allKuch =" + allKuch);

            curInd = new int[allKuch];
            kuchDeg = new int[allKuch];
            kuchFrom = new int[allKuch];
            kuchSize = new int[allKuch];
            kuchi = new int[allKuch][];

            // _id
            for (k = 0; k < allKuch; k++) {
                curInd[k] = 0;
                kuchFrom[k] = DbHelper.selectMasInt[k]; // _id
                if (DISPLAYLOG)
                    Log.e(TAG, "f_perebor k = " + k + " kuchFrom = " + kuchFrom[k]);
            }

            f_getObrazDp(); // образы образующих при Im(G)

            loadingPBCount = 1;
            for (k = 0; k < allKuch; k++) {
// deg
                kuchDeg[k] = dbH.f_getCount("select deg as ccc from  elements where _id = " + kuchFrom[k] + ";");
                j = dbH.f_getCount("select id_2 as ccc from temp_pe where id_1 = " + kuchFrom[k] + ";");    // порядок класса

// выбираю возможные образы образующего с учетом порядка эл-та и порядка класса сопряж где может быть образ
                rSQL = "select E._id as stext from elements E, temp_pe T" +
                        "  where E.deg = " + kuchDeg[k] + " and T.id_1 = E._id and T.id_2 = " + j + ";";
//                rSQL = "select E._id as stext from elements E, temp_pe T" +
//                        "  where E.deg = " + kuchDeg[k] + " and T.id_1 = E._id;";
                kuchSize[k] = dbH.f_getMInt(rSQL);
                kuchi[k] = new int[kuchSize[k]];
                loadingPBCount *= kuchSize[k];
                for (j = 0; j < kuchSize[k]; j++)
                    kuchi[k][j] = DbHelper.selectMasInt[j];
                if (DISPLAYLOG)
                    Log.e(TAG, "f_perebor k = " + k + " kuchSize = " + kuchSize[k]  + " kuchDeg = " + kuchDeg[k] + " kuchFrom = " + kuchFrom[k]);
            }

            mApp.activityBuild.loadingPB.setMax(loadingPBCount);
            loadingPBCount = 0;

            for (curInd[0] = 0; curInd[0] < kuchSize[0]; curInd[0]++) {
                kuchLevel = 0;
                for (j = 1; j < allKuch; j++)
                    curInd[j] = 0;

                if (DISPLAYLOG)
                    Log.e(TAG, "f_perebor curInd[0] = " + curInd[0]);

                f_perebNext();  // построение 1 -го автоморфизма если это отображение дает автоморфизм
            }

// перебор выполнен
        } 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();
            mApp.putProt("");
            mApp.putProt("Все автоморфизмы найдены");
            int l = dbH.f_getCountRow("select _id as ccc from elements_a;");
            mApp.putProt("Порядок группы автоморфизмов " + l);
        }
        db.endTransaction();

    }

    private boolean f_perebTest() {
        // построение автоморфизма: если _id не был уже выбран в предыдущих уровнях возвращает false
        for (int j = 0; j < kuchLevel; j++) {
            if (kuchi[j][curInd[j]] == kuchi[kuchLevel][curInd[kuchLevel]])   // _id уже был выбран
                return false;
        }
        return true;
    }

    int skoko = 130000;  // ??????
    private int f_perebNext() {
// собственно перебор путем рекурсии
        int j;

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

        kuchLevel++;    // новый уровень
//        Log.e(TAG, "f_perebNext kuchLevel= "+ kuchLevel );
        mApp.activityBuild.loadingPB.setProgress(loadingPBCount);
        if (kuchLevel < allKuch) {

            for (curInd[kuchLevel] = 0;  curInd[kuchLevel] < kuchSize[kuchLevel]; curInd[kuchLevel]++) {
                for (j = kuchLevel + 1; j < allKuch; j++)
                    curInd[j] = 0;

//                Log.e(TAG, "f_perebNext kuchLevel= "+ kuchLevel + " curInd = " + curInd[kuchLevel] + " f_perebTest() = " + f_perebTest());

                if (skoko > 0) // ?????
                    if (f_perebTest())
                        f_perebNext();
            }

        } else {    // отображение построено: curInd[] - индекси в kuchi[ kuchLevel ][ curInd[] ]
            loadingPBCount++;
// kuchFrom[j] переходит в kuchi[ j ][ curInd[j] ]
            String sub = "[";
            for (j = 0; j < kuchLevel; j++) {
                if (j > 0)
                    sub += ", ";
                sub += kuchi[j][curInd[j]];   // + _id
            }
            sub += "]";
//            Log.e(TAG, "f_perebNext sub = " + sub + "  mask = " + imObraz.contains(sub));

// отобраэение образующих построено
// проверка есть ли это в Im?
            if (! imObraz.contains(sub)) {

//  проверка на гомо и запись в elements_a делает f_testAvtoDp()
                if (f_testAvtoDp() == 0) {
// проверка прошла
                    if (DISPLAYLOG)
                        Log.e(TAG, "f_perebNext найдена sub = " + sub);

                    mApp.putProt(" найден " + sub);

                }
            }
            skoko--;
        }

        kuchLevel--;
        return 1;
    }

    private int f_testAvtoDp() {
// проверка найденного отображения с индексом curInd[i] на автоморфизм (kuchi[i][curInd[i]] - id  образа kuchFrom[i]
//   и запись в elements_a

        int i,  iteration = 1, intRet = 0;
        String nStr = "", name = "", cikls;
        final String sqlStmt [] = {
                "delete from temp_elements;",
                "delete from temp_multiplication_a;",

                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='temp_elements';",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='temp_multiplication_a';",

                "select id as ccc from temp_elements;",     // 4

                "select txt from temp_elements \n" +    //  5 сверка
                        "  where not exists (\n" +
                        "    select _id from elements where substitution = txt)\n" +
                        "\tunion all \n" +
                        "select substitution from elements \n" +
                        "  where not exists (\n" +
                        "    select _id from temp_elements  where substitution = txt);",

                "update temp_multiplication_a set flag_new = " +    //  6
                        "(select id_to from temp_elements where temp_elements.txt = temp_multiplication_a.txt)",

                "delete from temp_multiplication_a where not flag_new = 0;",    //  7

                "select idproiz as ccc from temp_multiplication_a;",    // 8

                "select id_to as ccc from temp_elements;",      // 9

                "select id_from, id_to " +              // 10
                        " from temp_elements order by 1 asc;"
        };

// kuchFrom[j] переходит в kuchi[ j ][ curInd[j] ]
        for (i = 0; i < 4; i++)
            db.execSQL(sqlStmt[i]);

        for (i = 0; i < allKuch; i++) {   // записал образующие образа отображения и исходные _id
            name = dbH.f_getString("select name as stext from elements where _id = " + kuchFrom[i] + ";");
            nStr = "insert into temp_elements (id_from, id_to, txt, name, iteration )" +
                    " select E._id, T._id, T.substitution, '" + name + "', 0 " +
                    " from elements E, elements T where E._id = " + kuchFrom[i] + " and T._id = " + kuchi[i][curInd[i]] + " order by T._id asc;";
            db.execSQL(nStr);
//            if (DISPLAYLOG)
//                Log.d(TAG, "f_testAvtoDp записал образующие i = " + i + " kuchi[i] = " + kuchi[i][curInd[i]]  + " curInd[i] = " + curInd[i]);
        }
//if (nStr.length() > 0)
//    return -1;

        do { // итерации по созданию группы = образ группы при тестируемом отображении
            // ------------------------------------------------------------------------
/*  использую существующую табл умножения temp_multiplication M для нахождения произведений и сразу формирую
   в temp_multiplication_a заношу id_from = id произведения до автоморфизма (temp_multiplication MF)
   и idproiz = id произведения после автоморфизма  (temp_multiplication MT)
    flag_new = 0 - новая подстановка группы, полученная путем отображения нового произведения
            = 0 - подстановка уже есть в temp_elements

выборка произведений
 select  MF.idleft if1, MF.idright if2, MF.idproiz id_f,
 MT.idleft it1, MT.idright it2, MT.idproiz id_t,
EF.name as name_from,  ET.name as name_to,
A.name || B.name  as name_new,
EF.ciklos c_f, ET.ciklos c_t
 from temp_elements A, temp_elements B, elements EF, elements ET,
 temp_multiplication MF, temp_multiplication MT
       where  A.id_fron = MF.idleft and  B.id_fron  = MF.idright and
        A.id_to  = MT.idleft and  B.id_to = MT.idright and
        MF.idproiz = EF."_id"  and MT.idproiz = ET."_id"
        ORDER by A.id_fron asc, B.id_fron asc

 */
            db.execSQL(sqlStmt[1]);     // "delete from temp_multiplication_a;",

            nStr = "insert into temp_multiplication_a (id_from, idleft, idright, idproiz, iteration, name, txt, flag_new) \n" +
                    "select  MF.idproiz, MT.idleft, MT.idright, MT.idproiz, " + iteration + ", A.name || B.name as name,  " +
                    " ET.substitution, 0 \n" +
                    "  from temp_elements A, temp_elements B, elements ET,\n" +
                    " temp_multiplication MF, temp_multiplication MT\n" +
                    "    where  A.id_from = MF.idleft and  B.id_from  = MF.idright and\n" +
                    "        A.id_to  = MT.idleft and  B.id_to = MT.idright and\n" +
                    "        MT.idproiz = ET._id \n" +
                    "      ORDER by A.id_from asc, B.id_from asc;";
            db.execSQL(nStr);

// помечаю существующие в temp_elements подстановки
            db.execSQL(sqlStmt[6]);   /*  "update temp_multiplication_a set flag_new = " +
                    "(select id_to from temp_elements where temp_elements.txt = temp_multiplication_a.txt)";*/
// удаляю существующие в temp_elements
            db.execSQL(sqlStmt[7]);   // delete from temp_multiplication_a where not flag_new = 0;

// появились ли новые эл-ты в результате перемножения ?
            i = dbH.f_getCountRow(sqlStmt[8]);  //  select idproiz as ccc from temp_multiplication_a;
//            if (DISPLAYLOG)
//                Log.d(TAG, "f_testAvtoDp i = " + i + " iteration=" + iteration);

            if (i == 0) // новых подстановок больше нет - выход
                break;

//запись новых подствновок
            nStr = "insert into temp_elements (id_from, id_to, txt, name, iteration )" +
                    " select distinct id_from, idproiz, txt, ' ', iteration " +
                    " from temp_multiplication_a where iteration = " + iteration + ";";
            db.execSQL(nStr); /* "insert into temp_elements (id_from, id_to, txt, name, iteration )" +
                    " select distinct id_from, idproiz, txt, ' ', iteration " +
                    " from temp_multiplication_a where iteration = " + iteration + ";"; */

            i = dbH.f_getCountRow(sqlStmt[9]);    //  select id_to as ccc from temp_elements;
            if (i > DbHelper.countElements) {   // уже плохо
                intRet = 1;
                break;
            }

            iteration++;

        } while (true); // элементы группы построены

        if (intRet == 0) {

            i = dbH.f_getCountRow(sqlStmt[5]);  //  сверка
            if (i == 0) {

// формирую новую подстановку на G - автоморфизм
                Cursor cursorA = db.rawQuery(sqlStmt[10], null); /* "select id_from, id_to " +
                        " from temp_elements order by 1 asc;"; */
                String subs = "[";  // новая подстановка - автоморфизм
                int jf, jt, k = 1,
                        i1 = cursorA.getColumnIndex("id_from"),
                        i2 = cursorA.getColumnIndex("id_to");

                if (cursorA.getCount() > 0) {
                    if (cursorA.moveToFirst()) {
                        do {
                            jf = cursorA.getInt(i1);
                            if (jf != k) {
                                intRet = 1;
                                break;
                            }
                            k++;
                            jt = cursorA.getInt(i2);
                            if (subs.length() > 1)
                                subs += ", ";
                            subs += jt + "";
                        } while (cursorA.moveToNext());
                    }
                }
                cursorA.close();
                if (intRet == 0) {
                    subs += "]";

                }

                int nSub [] = classSubs.f_toArray(subs, DbHelper.countElements); // подстановка в int[]
                cikls = classSubs.f_toIndependentCycle(DbHelper.countElements, nSub);

                name = "";
                for (i = 0; i < allKuch; i++)
                    name += kuchFrom[i] + "->" + kuchi[ i ][ curInd[i] ] + " ";
                // kuchi[ j ][ curInd[j] ]

                nStr = "insert into elements_a (name, substitution, ciklos, link_to_group, link_to_sn) " +
                        " values ('" + name + "', '" + subs +"', '" + cikls + "', 0, 0 ); ";
                db.execSQL(nStr);

//                Log.d(TAG, "f_testAvtoDp subs = " + subs + " k = " + k + " intRet = " + intRet);
                mApp.putProt("Найден автоморфизм: " + subs);
            }
        }
        return intRet;
    }

    public void f_prepareGruppDp() {
        // расчет для группы автоморфизмов

        db.execSQL("update elements_a set iteration = 0, pairing_num = 0, switchboard_num = 0, center_num = 0, primitiv = '', forming = '', parity = 0, nomer_soc = 0, sylow_num = null;");
        dbH.f_setVidGr(1, false);  // построение пруппы автоморфизмов со всеми свойствами
        DbHelper.faktSubsLen = DbHelper.countElements;
        classSubs.f_setEdinica();
        dbH.f_clearDB(1);
//        Log.d(TAG, "f_prepareGruppDp  tableNameEnd = " + mApp.tableNameEnd + " vidWgrup = " + dbH.vidWgrup + " countElements =  " + DbHelper.countElements + " faktSubsLen = " + DbHelper.faktSubsLen);
    }

    public void f_postGruppDp() {
        // завершение расчета для группы автоморфизмов
        int  i = dbH.f_getCountRow("select _id from elements_a;");  //  порядок группы автоморфизмов
        dbH.f_getGroupName();
        db.execSQL("delete from params where parm = 'Автоморфизмы';");
        db.execSQL("insert into params (parm, ind, val, val_txt) values('Автоморфизмы'," + DbHelper.faktSubsLen + ", " + i + ", 'Группа автоморфизмов построена для " + mApp.groupName + "');");
        dbH.f_setVidGr(0, false);
        dbH.f_getParm(0, 0, 0);
        mApp.putProt("Группа автоморфизмов порядка "+ i + " построена");
//        Log.d(TAG, "f_postGruppDp  tableNameEnd = " + mApp.tableNameEnd + " vidWgrup = " + dbH.vidWgrup + " countElements =  " + DbHelper.countElements + " faktSubsLen = " + DbHelper.faktSubsLen);
    }

    //     --------------   ОБРАЗЫ  --------

    public void f_characterDp() {
// автоморфизмы поиск образов

        db.beginTransaction();
        try {
            f_autoGroupDp();   // построение всех автоморфизмов
            f_autoClassDp();    // образы классов
            f_autoCyklDp();    // поиск образы cykl_len
        } catch (Exception e) {
            DbHelper.err += "Error построение образов " + e.getMessage();
            e.printStackTrace();
            Log.e(TAG, "Error f_characterDp  построение образов " + e.getMessage() );
        }
        if (mApp.whatRun != -1 && DbHelper.err.length() == 0)
            db.setTransactionSuccessful();
        db.endTransaction();
    }

    private void f_autoGroupDp() {
        // характеристические (образы нормальныз подгрупп)
        final String sqlCh[] = {
                "delete from temp_pe;",
                "delete from sylov_id;",    // все эл-ты одной норм подгруппы
                "delete from charac_group;",
                "delete from auto_group;",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='auto_group';",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='sylov_id';",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='charac_group';",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='temp_pe';",

                "select distinct num_maim as stext from sub_structure order by 1 asc;"     // 10
        };
        //  характеристические подгруппы
        int j, allNum, iu, k, rowCount = 0 ;
        String ssqqll, sCykl;
        mApp.putProt("");
        mApp.putProt("Поиск характеристическах подгрупп");

        for (j = 0; j < 8; j++)
            db.execSQL(sqlCh[j]);
// теперь  temp_pe.pe =  # полгруппы, id_s = _id до автом, deg = id все возможные послеб id_s - id автоморфизма

        allNum = dbH.f_getMInt(sqlCh[8]);
        for (j = 0; j < allNum; j++) {

            for (k = 0; k < 2; k++)
                db.execSQL(sqlCh[k]);

// для очередной подгруппы DbHelper.selectMasInt[j] заношу degs = номер подгруппы образа
            ssqqll = "INSERT INTO sylov_id (num, id_s) \n" +
                    "   select distinct S.num_maim,  P.id_subs \n" +
                    "     from  pairing_area P, sub_structure S\n" +
                    "      where S.num_subs =  P.class_area and S.num_maim = " + DbHelper.selectMasInt[j] + " \n" +
                    "  order by  S.num_maim asc, P.id_subs asc;";
            db.execSQL(ssqqll);

            ssqqll = "insert INTO temp_pe (pe, id_1, id_2, id_s, list_num) \n" +
                    "   select I.num, I.id_s, substr(F.text_sub, 2 + 5*(I.id_s - 1), 4) id_out, F.id_s, ''  \n" +
                    "    from  sub_scribe_a F, sylov_id I;";
            db.execSQL(ssqqll);

            /*
insert into auto_group (num_in, num_out, porjadok)
select T.pe, S.num_maim, count(T.id_2) ccc
from temp_pe T, pairing_area P, sub_structure S
      where S.num_subs =  P.class_area and
	  T.id_2 = P.id_subs
group by  T.id_s, S.num_maim
having count(T.id_2) = 6
order by  T.id_s, S.num_maim

update auto_group set field_work = (
   select count(P.id_subs)
     from  pairing_area P, sub_structure S
      where S.num_subs =  P.class_area and S.num_maim = auto_group.num_out
)

delete from auto_group
where not field_work = porjadok

             */
            rowCount = dbH.f_getCountRow("select _id from  sylov_id where num = " + DbHelper.selectMasInt[j] + " ;");
            ssqqll = "insert into auto_group (num_in, num_out, porjadok)\n" +   // auto_group - все группы num_out порядка num_in
                    "select distinct T.pe, S.num_maim, count(T.id_2) ccc\n" +
                    "from temp_pe T, pairing_area P, sub_structure S\n" +
                    "      where S.num_subs =  P.class_area and\n" +
                    "\t  T.id_2 = P.id_subs\n" +
                    "group by  T.id_s, S.num_maim\n" +
                    "having count(T.id_2) = " + rowCount + "\n" +
                    "order by  T.id_s, S.num_maim;";
            db.execSQL(ssqqll);

            ssqqll = "update auto_group set field_work = (\n" +     // field_work = порядок подгруппы num_out
                    "   select count(P.id_subs)\n" +
                    "     from  pairing_area P, sub_structure S\n" +
                    "      where S.num_subs =  P.class_area and S.num_maim = auto_group.num_out\n" +
                    ");";
            db.execSQL(ssqqll);

            ssqqll = "delete from auto_group\n" +     // удалить группы не верного порядка
                    "where not field_work = porjadok;";
            db.execSQL(ssqqll);

            ssqqll = "select id_s \n" +     // есть ли id_out  не входящие в num_in
                    "from temp_pe T\n" +
                    "where id_2 not in (\n" +
                    "select id_s from sylov_id\n" +
                    ");";
            iu = dbH.f_getCountRow(ssqqll);

            if (iu == 0) {  // подгруппа характеристическая
                // записываю cykl_len в charac_group

                ssqqll = "select distinct P.cykl_len  as stext \n" +
                        "from  pairing_area P, sub_structure S\n" +
                        "    where S.num_subs =  P.class_area and S.num_maim = " + DbHelper.selectMasInt[j] + ";";
                dbH.f_getMas(ssqqll);
                sCykl = "";
                for (k = 0; k < DbHelper.selectedMas.length; k++) {
                    if (sCykl.length() > 0)
                        sCykl += ", ";
                    sCykl += DbHelper.selectedMas[k];
                }

                db.execSQL("insert into charac_group (num_subs, porjadok, cykl_len) values (" + DbHelper.selectMasInt[j] + ", " + rowCount + ", '" + sCykl +  "');");

                mApp.putProt("подгруппа " + DbHelper.selectMasInt[j] + " порядка " + rowCount + " характеристическая");
                if (myExecutor.MyThread.isCancel || DbHelper.err.length() > 0) {
                    DbHelper.err += "\n Расчет прерван";
                    return;
                }
//                Log.d(TAG, "f_autoGroupDp подгруппа " + DbHelper.selectMasInt[j] + " порядка " + rowCount + " характеристическая");

            } else {
                mApp.putProt("подгруппа " + DbHelper.selectMasInt[j] + " порядка " + rowCount + " не является характеристической");
                Log.d(TAG, "f_autoGroupDp подгруппа " + DbHelper.selectMasInt[j] + " порядка " + rowCount + " не характеристическая");
            }

        }
    }

    private void f_autoClassDp() {
        // образы классов
        final String sqlCh[] = {
                "delete from sylov_id;",
                "delete from charac_class;",
                "delete from auto_class;",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='auto_class';",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='charac_class';",

// образы классы
                "INSERT INTO sylov_id (num, id_s)\n" +                  //  6
                        "  select distinct P.class_area,  P.id_subs \n" +
                        "   from  pairing_area P\n" +
                        " order by  P.class_area asc, P.id_subs asc;",

                "insert INTO auto_class (class_in, id_in, id_out, id_auto, class_out) \n" + // 7
                        "   select I.num, I.id_s, PO.id_subs, F.id_s, ''  \n" +
                        "    from  sub_scribe_a F,\n" +
                        " pairing_area PO, sylov_id I\n" +
                        "    where  PO.id_subs = substr(F.text_sub, 2 + 5*(I.id_s - 1), 4);",

                "UPDATE auto_class set class_out = (\n" +       // 8
                        "  select P.class_area \n" +
                        "    from  pairing_area P\n" +
                        "   where P.id_subs = auto_class.id_out  \n" +
                        ");",

                "insert into charac_class (class_in, class_out, chararter, porjadok, cykl_in, cykl_out)" +     // 9
                        "select distinct T.class_in, T.class_out, 1, count(distinct P.id_subs) as porjadok, ' ', ' ' \n" +
                        "from auto_class T, pairing_area P\n" +
                        "where P.class_area = T.class_in \n" +
                        "GROUP by T.class_in, T.class_out\n" +
                        "order by 1 asc, 2 asc;",

/*
 insert INTO temp_pe (pe, id_1, id_2, id_s, list_num)  = (
   select I,num, I.id_s, PO.id_subs, F.id_s, ''
    from  sub_scribe_a F,
		pairing_area PO, sub_structure SO, sylov_id I
    where SO.num_subs =  PO.class_area and
          PO.id_subs = substr(F.text_sub, 2 + 5*(I.id_s - 1), 4)
 )


UPDATE temp_pe set degs = (
  select S.num_maim
    from  pairing_area P, sub_structure S
   where S.num_subs =  P.class_area and
   P.id_subs = temp_pe.id_2  and
      S.num_maim = 3
)

select distinct degs
from temp_pe
where pe = 3 and not degs = pe

 */
        };
        int j;
        String ssqqll;
        mApp.putProt("");
        mApp.putProt("Поиск образов классов");

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

// проставляю поле chararter - класс неподвижен
        ssqqll = "select distinct class_in, class_out from auto_class where not class_in = class_out;";
        Cursor cursorA = db.rawQuery(ssqqll, null);
        int k1, k2,
                i1 = cursorA.getColumnIndex("class_in"),
                i2 = cursorA.getColumnIndex("class_out");

        if (cursorA.getCount() > 0) {
            if (cursorA.moveToFirst()) {
                do {
                    k1 = cursorA.getInt(i1);
                    k2 = cursorA.getInt(i2);
                    db.execSQL("update charac_class set chararter = 0 where class_in = " + k1 + " or " + " class_in = " + k2 +
                            " or " + " class_out = " + k1 + " or " + " class_out = " + k2 + ";");
//                    Log.d(TAG, "f_autoClassDp cursorA.getCount() = " + cursorA.getCount() + " k1 = " + k1 + " k2 = " + k2);
                } while (cursorA.moveToNext());
            }
        }
        cursorA.close();

// проставляю поле cykl_in, cykl_out
        ssqqll = "select distinct class_area cclas, cykl_len cikl from pairing_area order by 1 asc;";
        cursorA = db.rawQuery(ssqqll, null);
        i1 = cursorA.getColumnIndex("cclas");
        i2 = cursorA.getColumnIndex("cikl");
        String sss = "", cykls = "";
        k2 = -5;
        if (cursorA.getCount() > 0) {
            if (cursorA.moveToFirst()) {
                do {
                    k1 = cursorA.getInt(i1);    // class_area
                    sss = cursorA.getString(i2);    // cykl_len
                    if (k1 != k2) {
                        if (k2 > 0) {
                            db.execSQL("update charac_class set cykl_in = '" + cykls + "' " +
                                    "where class_in = " + k2 + ";");

                            db.execSQL("update charac_class set cykl_out = '" + cykls + "' " +
                                    "where class_out = " + k2 + ";");
                        }
                        k2 = k1;
                        cykls = "";
                    }
                    if (cykls.length() > 0)
                        cykls += ", ";
                    cykls += sss;
//                    Log.d(TAG, "f_autoClassDp cursorA.getCount() = " + cursorA.getCount() + " cykls = " + cykls + " k1 = " + k1 + " k2 = " + k2);
                    if (myExecutor.MyThread.isCancel || DbHelper.err.length() > 0) {
                        DbHelper.err += "\n Расчет прерван";
                        break;
                    }
                } while (cursorA.moveToNext());
            }
        }
        cursorA.close();
        if (cykls.length() > 0) {
            db.execSQL("update charac_class set cykl_in = '" + cykls + "' " +
                    "where class_in = " + k2 + ";");

            db.execSQL("update charac_class set cykl_out = '" + cykls + "' " +
                    "where class_out = " + k2 + ";");
        }

        sss = dbH.f_getString("select count(distinct id_auto) || ' ' as stext  from auto_class \n" +
                "   where not class_in = class_out;");

        mApp.putProt(" " + sss + " автоморфизмов изменили класс сопряженных эл-тов");
    }

    private void f_autoCyklDp () {
        // поиск образы cykl_len

        final String sqlCh[] = {
                "delete from sylov_id;",
                "delete from auto_cykls;",
                "delete from charac_cykls;",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='auto_cykls';",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='charac_cykls';",

//  cykl_len
                "INSERT INTO sylov_id (txt, id_s)\n" +              //  17
                        "  select distinct P.cykl_len,  P._id \n" +
                        "   from  elements P\n" +
                        " order by  P.cykl_len asc, P._id asc;",

                "insert INTO auto_cykls (cykl_in, id_in, id_out, id_auto, cykl_out) \n" +     // 18
                        "   select I.txt, I.id_s, PO._id, F.id_s, ''  \n" +
                        "    from  sub_scribe_a F,\n" +
                        " elements PO, sylov_id I\n" +
                        "    where  PO._id = substr(F.text_sub, 2 + 5*(I.id_s - 1), 4);",

                "UPDATE auto_cykls set cykl_out = (\n" +       //  19
                        "  select P.cykl_len \n" +
                        "    from  elements P\n" +
                        "   where P._id = auto_cykls.id_out  \n" +
                        ");",

                "insert into charac_cykls (cykl_in, cykl_out, chararter, porjadok, classes_in, classes_out)" +     // 20
                        "select distinct T.cykl_in, T.cykl_out, 1, count(distinct P._id) as ccc, '', ''  \n" +
                        "from auto_cykls T, elements P \n" +
                        "where P._id = T.id_out \n" +
                        "GROUP by T.cykl_in, T.cykl_out\n" +
                        "order by 1 asc, 2 asc;",


/*
 insert INTO temp_pe (pe, id_1, id_2, id_s, list_num)  = (
   select I,num, I.id_s, PO.id_subs, F.id_s, ''
    from  sub_scribe_a F,
		pairing_area PO, sub_structure SO, sylov_id I
    where SO.num_subs =  PO.class_area and
          PO.id_subs = substr(F.text_sub, 2 + 5*(I.id_s - 1), 4)
 )


UPDATE temp_pe set degs = (
  select S.num_maim
    from  pairing_area P, sub_structure S
   where S.num_subs =  P.class_area and
   P.id_subs = temp_pe.id_2  and
      S.num_maim = 3
)

select distinct degs
from temp_pe
where pe = 3 and not degs = pe

 */
        };
        int j, i1, i2, k1;
        String ssqqll, cykls;
        mApp.putProt("");
        mApp.putProt("Поиск образов цикловых типов");

        for (j = 0; j < sqlCh.length; j++)
            db.execSQL(sqlCh[j]);
/*                "insert INTO auto_cykls (cykl_in, id_in, id_out, id_auto, cykl_out) \n" +     // 18
                        "   select I.txt, I.id_s, PO._id, F.id_s, ''  \n" +
                        "    from  sub_scribe_a F,\n" +
                        " elements PO, sylov_id I\n" +
                        "    where  PO._id = substr(F.text_sub, 2 + 5*(I.id_s - 1), 4);",
 */
// проставляю поле chararter - класс неподвижен
        ssqqll = "select distinct cykl_in, cykl_out from auto_cykls where not cykl_in = cykl_out;";
        Cursor cursorA = db.rawQuery(ssqqll, null);
        String s1, s2;
        i1 = cursorA.getColumnIndex("cykl_in");
        i2 = cursorA.getColumnIndex("cykl_out");

        if (cursorA.getCount() > 0) {
            if (cursorA.moveToFirst()) {
                do {
                    s1 = cursorA.getString(i1);
                    s2 = cursorA.getString(i2);
//                    Log.e(TAG, " f_autoCyklDp cursorA.getCount() = " + cursorA.getCount() + " s2 = '" + s2 + "' s1 = '" + s1);

                    db.execSQL("update charac_cykls set chararter = 0 where classes_in = '" + s1 + "' or " + " classes_in = '" + s2 +
                            "' or " + " classes_out = '" + s1 + "' or " + " classes_out = '" + s2 + "';");
                } while (cursorA.moveToNext());
            }
        }
        cursorA.close();

// проставляю поле classes_in, classes_out
        ssqqll = "select distinct class_area cclas, cykl_len cikl from pairing_area order by 2 asc;";
        cursorA = db.rawQuery(ssqqll, null);
        i1 = cursorA.getColumnIndex("cclas");
        i2 = cursorA.getColumnIndex("cikl");    // ключ

        k1 = 0;
        s2 = "";
        s1 = "***";
        cykls = "";
        if (cursorA.getCount() > 0) {
            if (cursorA.moveToFirst()) {
                do {
                    k1 = cursorA.getInt(i1);
                    s2 = cursorA.getString(i2);
                    if (s2 == null)
                        s2 = "";

//                    Log.e(TAG, " f_autoCyklDp cursorA.getCount() = " + cursorA.getCount() + " s1.equals(s2) = " + s1.equals(s2) + " s2 = '" + s2 + "' s1 = '" + s1 + "' k1 = " + k1 + " cykls = " + cykls + " null1 = " + (s1 == null) + " null2 = " + (s2 == null));
                    if (!s1.equals(s2)) {
                        if (!s1.equals("***")) {
                            db.execSQL("update charac_cykls set classes_in = '" + cykls + "' " +
                                    "where cykl_in = '" + s1 + "';");

                            db.execSQL("update charac_cykls set classes_out = '" + cykls + "' " +
                                    "where cykl_out = '" + s1 + "';");
                        }   // ""
                        s1 = s2;
                        cykls = "";
                    }
                    if (cykls.length() > 0)
                        cykls += ", ";
                    cykls += k1;
//                    Log.e(TAG, " f_autoCyklDp 2 s1.equals(s2) = " + s1.equals(s2) + " s2 = '" + s2 + "' s1 = '" + s1 + "' k1 = " + k1 + " cykls = " + cykls + " null1 = " + (s1 == null) + " null2 = " + (s2 == null));

                    if (myExecutor.MyThread.isCancel || DbHelper.err.length() > 0) {
                        DbHelper.err += "\n Расчет прерван";
                        break;
                    }
                } while (cursorA.moveToNext());
            }
        }
        cursorA.close();
        if (cykls.length() > 0) {
//            Log.e(TAG, " f_autoCyklDp 3 s1.equals(s2) = " + s1.equals(s2) + " s2 = '" + s2 + "' s1 = '" + s1 + "' k1 = " + k1 + " cykls = " + cykls + " null1 = " + (s1 == null) + " null2 = " + (s2 == null));
            db.execSQL("update charac_cykls set classes_in = '" + cykls + "' " +
                    "where cykl_in = '" + s1 + "';");

            db.execSQL("update charac_cykls set classes_out = '" + cykls + "' " +
                    "where cykl_out = '" + s1 + "';");
        }

//   auto_cykls остается большая таблица, оставляю изменения цикл типа
        //?????    db.execSQL("delete from auto_cykls where cykl_in = cykl_out;");

        j = dbH.f_getCountRow("select distinct id_auto from  auto_cykls where not cykl_in = cykl_out;");
        mApp.putProt(" " + j + " автоморфизмов изменили цикловой тип");
//        Log.e(TAG, " f_autoCyklDp автоморфизмов изменили цикловой тип " + j);
    }

    public void f_autoSylovDp() {
// перемещения силов подгрупп
    /*
    INSERT INTO sylov_id  (num, id_s)
  select distinct S.num, S.id_s
  from  sylov_table S
  order by  S.num asc, S.id_s asc;

 insert INTO temp_pe (pe, id_1, id_2, id_s, list_num)
 select I.num, I.id_s, PO._id o_id, F.id_s f_if, ''
    from  sub_scribe_a F,
		 elements PO, sylov_id I
    where  PO._id = substr(F.text_sub, 2 + 5*(I.id_s - 1), 4)
    order by F.id_s asc, 1 asc, 2 asc

UPDATE temp_pe set list_num = (
  select P.sylow_num
  from  elements P
  where P._id = temp_pe.id_2
  );

insert into auto_sylow (sylow_in, sylow_out, id_auto, pe)
 select distinct T.pe, T.list_num, T.id_s, E.pe
  from temp_pe T, elements E
  where E._id = T.id_a and not id_2 = 5
  order by  T.pe asc, T.list_num asc

          db.beginTransaction();
        try {
            f_autoGroupDp();   // построение всех автоморфизмов
            f_autoClassDp();    // образы классов
            f_autoCyklDp();    // поиск образы cykl_len
            f_autoSylovDp();   // перемещения силов подгрупп



     */

        final String sylSQL[] = {
                "delete from auto_sylow",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='auto_sylow';",
                "delete from charac_sylow",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='charac_sylow';",
                "insert into sylov_id (num, id_s) \n" +      // id_s = порядок группы num
                        "select num, count(distinct id_s)\n" +
                        "from sylov_table\n" +
                        "group by num;"
        };

        String ssqqll;
        int j, allNum;
        db.beginTransaction();
        try {

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

            ssqqll = "select num  as stext from sylov_table order by 1 asc;";
            allNum = dbH.f_getMInt(ssqqll);
            mApp.putProt("");
            mApp.putProt("Образы силовских подгрупп");

            for (j = 0; j < allNum; j++) {

// для очередной подгруппы DbHelper.selectMasInt[j] заношу degs = номер подгруппы образа
                ssqqll = "insert INTO auto_sylow (pe, num_in, id_in, id_out, id_auto, num_out, sylow_in, sylow_out)\n" +
                        "select distinct SI.pe, SI.num, SI.id_s, SO.id_s, F.id_s, SO.num, '', ''  \n" +
                        "  from sylov_table SI, sylov_table SO, sub_scribe_a F \n" +
                        "    where SO.id_s = substr(F.text_sub, 2 + 5*(SI.id_s - 1), 4)\n" +
                        "     and SI.num = " + DbHelper.selectMasInt[j] + "\n" +
                        "     order by SI.pe asc, SI.num asc, SI.id_s asc;";
                db.execSQL(ssqqll);

                db.execSQL("delete from temp_pe");
                ssqqll = "insert into temp_pe (pe, id_1, id_2, id_s, degs)\n" +     // degs = порядок группы num_out
                        "select pe, num_in, id_auto, num_out, count(distinct id_out) nnn\n" +
                        "from auto_sylow\n" +
                        "group by pe, num_in, id_auto, num_out\n" +
                        "order by pe, num_in, id_auto, num_out";
                db.execSQL(ssqqll);

                ssqqll = "delete from temp_pe where not degs = (\n" +   // в  temp_pe осталась одна группа id_s
                        "select sylov_id.id_s \n" +
                        "from sylov_id\n" +
                        "where sylov_id.num = temp_pe.id_s\n" +
                        ");";
                db.execSQL(ssqqll);

                ssqqll = "delete from temp_pe where not degs = (\n" +
                        "select sylov_id.id_s \n" +
                        "from sylov_id\n" +
                        "where sylov_id.num = " + DbHelper.selectMasInt[j] + "\n" +
                        ")";
                db.execSQL(ssqqll);

                ssqqll = "delete from auto_sylow where not num_out = \n" +
                        "(select id_s from temp_pe\n" +
                        "  where temp_pe.pe = auto_sylow.pe and temp_pe.id_1 = auto_sylow.num_in and temp_pe.id_2 = auto_sylow.id_auto and " +
                        " auto_sylow.num_in = " + DbHelper.selectMasInt[j] + "\n" +
                        ");";
                db.execSQL(ssqqll);
//                Log.e(TAG, " f_autoSylovDp j = " + j + " allNum =  " + allNum + " substitutionS.codEdinicy = " + " substitutionS.codEdinicy_n = " + substitutionS.codEdinicy_n + " ssqqll = " + ssqqll);
                mApp.putProt(" подгруппа " + (j + 1) + " из " + allNum);
                if (myExecutor.MyThread.isCancel || DbHelper.err.length() > 0) {
                    DbHelper.err += "\n Расчет прерван";
                    break;
                }
            }

            ssqqll = "update auto_sylow set sylow_in = (\n" +
                    "  select E.sylow_num\n" +
                    " from elements E\n" +
                    "  where auto_sylow.id_in = E._id\n" +
                    "  );";
            db.execSQL(ssqqll);
            ssqqll = "update auto_sylow set sylow_out = (\n" +
                    "  select E.sylow_num\n" +
                    " from elements E\n" +
                    "  where auto_sylow.id_out = E._id\n" +
                    "  );";
            db.execSQL(ssqqll);

            ssqqll = "insert into charac_sylow (pe, num_in, num_out, id_auto) " +
                    "select distinct pe, num_in, num_out, id_auto\n" +
                    "from auto_sylow\n" +
                    "order by pe asc, num_in asc, num_out asc, id_auto asc";
            db.execSQL(ssqqll);


//        db.execSQL("delete from ");
//        db.execSQL(sqlCh[1]);

//            Log.e(TAG, " f_autoSylovDp 9 substitutionS.codEdinicy = " + " substitutionS.codEdinicy_n = " + substitutionS.codEdinicy_n);
            mApp.putProt("Образы силовских подгрупп найдены");
        } catch (Exception e) {
            DbHelper.err += "Error построение образов силовских подгрупп " + e.getMessage();
            e.printStackTrace();
            Log.e(TAG, "Error f_characterDp  построение образов силовских подгрупп " + e.getMessage());
        }
        if (mApp.whatRun != -1 && DbHelper.err.length() == 0)
            db.setTransactionSuccessful();

        db.endTransaction();
    }
}
//--------------------------------