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

app/src/main/java/com/ea/groupbuilder/classNormSub.java
1 286 строк76 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 classNormSub {
// продолжение построения
    private static final String TAG = "GRUGRA_NORM";
    final static private boolean DISPLAYLOG = false;

    public mAplication mApp;
    private DbHelper dbH;
    private int vidWgrup = 0;   // vidWgrup = 0 - сама группа, 1 - группа автоморфизмов
    static public substitutionS classSubs;
    static public SQLiteDatabase db;

    public void init(mAplication mApp_, DbHelper dbH_, int vidWgrup_ ) {
        mApp  = mApp_;
        dbH = dbH_;
        db = DbHelper.db;
        classSubs = mApp.classSubs;
        vidWgrup = vidWgrup_;
//        Log.e(TAG, "classNormSub.init vidWgrup= " + vidWgrup);
    }

    static private int maxSoprClass, // число найденных подгрупп
                addCount = 0;   // добавлено подгрупп

    public void  f_soc() {
        //  искать цоколь, заполняю поле nomer_soc в sylov_com_grup

        int iu, iw, idSoc;
        String selStr, ss1, ss2 = "";
        final String sqlDel[] = {
                "delete from sylov_id;",    // здесь будут все Id программ цоколя
                "delete from temp_sylow;",
                "delete from temp_pe;",
                "delete from " + DbHelper.pairing_area[vidWgrup] + ";",
                "delete from " + DbHelper.sub_structure[vidWgrup] + ";",
                "delete from " + DbHelper.soc_list[vidWgrup] + ";",    // 5
                "delete from pairing_multiplications;",
                "delete from " + DbHelper.sub_summa[vidWgrup] + ";", // 7
                "delete from " + DbHelper.soc_subs[vidWgrup] + ";",    // 8
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='" + DbHelper.soc_subs[vidWgrup] + "';",  // 9
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='temp_pe';",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='" + DbHelper.soc_list[vidWgrup] + "';",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='" + DbHelper.sub_structure[vidWgrup] + "';",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='sylov_id';",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='temp_sylow';",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='" + DbHelper.pairing_area[vidWgrup] + "';",
                "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='pairing_multiplications';",
        };

        for (iu = 1; iu < sqlDel.length; iu++)
            db.execSQL(sqlDel[iu]);

        substitutionS.nomSocSub = 1;

        final String sqlDo[] = {
// pairing_area -  все эл-ты по классам без объединения центра
// sub_structure - таблица всех нормальных подгрупп
// soc_list - таблица состава нормальных подгрупп
// normal_connect - таблица дополнительных вложений найденных нормальных подгрупп после формированиясвязей для всех уровней

                "insert into " + DbHelper.pairing_area[vidWgrup] + " (dubl, class_area, id_subs )\n" +
                        "  select  0, pairing_num, _id  from " + DbHelper.elements[vidWgrup] + " where pairing_num = 1 order by _id asc;",
                "select  _id, cykl_len  from " + DbHelper.elements[vidWgrup] + " where pairing_num = 1 and not _id = " + substitutionS.codEdinicy + " order by _id asc;",
                "insert into " + DbHelper.pairing_area[vidWgrup] + " (dubl, class_area, id_subs, cykl_len)\n" +    // 0
                        "  select 0, pairing_num, _id, cykl_len  from " + DbHelper.elements[vidWgrup] + " where not pairing_num = 1;",
                "insert into pairing_multiplications (class_a, class_b, class_m)\n" +
                        "  select distinct P1.class_area as klass1, P2.class_area as klass2, P0.class_area as klass0\n" +
                        " from " + DbHelper.pairing_area[vidWgrup] + " P1, " + DbHelper.sub_structure[vidWgrup] + " S1, " + DbHelper.pairing_area[vidWgrup] + " P2, " + DbHelper.sub_structure[vidWgrup] + " S2, " + DbHelper.pairing_area[vidWgrup] + " P0, \n" +
                        "    " + DbHelper.temp_multiplication[vidWgrup] + " M \n" +
                        " where P1.class_area = S1.num_subs and P2.class_area = S2.num_subs and \n" +
                        "    P1.id_subs = M.idleft and P2.id_subs = M.idright AND M.idproiz = P0.id_subs and  \n" +
                        "    S1.num_maim = S2.num_maim \n" +
                        " order by klass2 asc, klass1 asc, klass0 asc;",    //  3
                "select max(idright) as ccc  from temp_sylow where idproiz isnull;",    // 4
                "DROP TABLE IF EXISTS soc_tmp;",    // 5
                "insert into " + DbHelper.sub_structure[vidWgrup] + " (num_maim, num_subs, deg) select idright, idleft, pe from temp_sylow;",   // 6
                "delete from " + DbHelper.sub_structure[vidWgrup] + " where num_maim in (\n" +
                        "  select num_klass from " + DbHelper.soc_list[vidWgrup] + " where dubl_flag > 0);",   // 7
                "select count(*) as ccc  from " + DbHelper.soc_list[vidWgrup] + " where not dubl_flag = 1;",   // 8
                "select distinct P.class_area as num from " + DbHelper.elements[vidWgrup] + "  E, " + DbHelper.pairing_area[vidWgrup] + " P  " + // выбираю группу четных подстановок
                        " where  E._id = P.id_subs and E.parity = 0  " + // and not pairing_num = 1
                        "order by P.class_area asc;",       // 9
                "select count(*) as ccc from " + DbHelper.soc_list[vidWgrup] + " where centr_flag > 0; ",  // 10
                "delete from  " + DbHelper.soc_list[vidWgrup] + " where  centr_flag > 0 and num_klass >= 1000;",    // 11
                "update " + DbHelper.soc_list[vidWgrup] + " set summa_num = (\n" +
                        "  select S.num_maim from " + DbHelper.sub_summa[vidWgrup] + " S\n" +
                        "    where  num_klass = S.num_subs \n" +
                        ") where " + DbHelper.soc_list[vidWgrup] + ".num_klass in (\n" +
                        "  select num_subs from " + DbHelper.sub_summa[vidWgrup] + "\n" +
                        "  );",          //  12
                "select num_klass as num1, count_klass as ccc\n" + // выбираю самую наибольшую по числу классов подгруппу
                        "  from " + DbHelper.soc_list[vidWgrup] + " \n" +
                        "  where deg < "+ DbHelper.countElements + " and not dubl_flag = 1 \n" +    // всю группу не беру
                        "order by count_klass asc;",     //  13
                "select distinct M.num_maim as num from " + DbHelper.normal_subgroup[vidWgrup] + " M \n" +
                        " where M.num_maim not in (select P.num_sub from " + DbHelper.normal_subgroup[vidWgrup] + " P);",   // 14
                "select num_klass as kls  from " + DbHelper.soc_list[vidWgrup] + "\n" +
                        " where dubl_flag = 0 and nrow = 0 order by num_klass;",     //  15
                "select max(nrow) as ccc from " + DbHelper.soc_list[vidWgrup] + " where dubl_flag = 0;",        // 16
        };

// 1. готовлю pairing_area и в ней class_area - все классы без объединения центра
//--------------
        addCount = 0;
        maxSoprClass = dbH.f_getCount("select max(pairing_num) as ccc  from " + DbHelper.elements[vidWgrup] + ";");  // 51
// записываю в pairing_area  центр - каждый эл-нт не = 1 - отдельный класс
        db.execSQL(sqlDo[0]);
        /* "insert into pairing_area (class_area, id_subs)\n" +
                        "        select  pairing_num, _id  from elements where pairing_num = 1 order by _id asc;",
         */

        Cursor cur1Soc = db.rawQuery(sqlDo[1], null);   //     "select  _id, cykl_len  from elements where pairing_num = 1 and not _id = " + substitutionS.codEdinicy + " order by _id asc;",
        cur1Soc.moveToFirst();
        if (cur1Soc.getCount() > 0) {
            int indCCC = cur1Soc.getColumnIndex("_id");
            iw = cur1Soc.getColumnIndex("cykl_len");
            do {
                idSoc = cur1Soc.getInt(indCCC);   // _id
                ss1 = cur1Soc.getString(iw);
                selStr = "update " + DbHelper.pairing_area[vidWgrup] +
                        " set  class_area = " + (++maxSoprClass) + ", cykl_len= '" + ss1 + "' where  id_subs = " + idSoc + ";";
                db.execSQL(selStr);
            } while (cur1Soc.moveToNext());
        }
        cur1Soc.close();


// центр переписал с новыми pairing_area, хотя его можно обработать отдельно быстрее
// maxKl - всего классов

/*  заношу новые номера классов для центра
        db.execSQL("update elements set pairing_num = (\n" +
                "    select P.class_area from pairing_area P where elements._id = P.id_subs)\n" +
                "    where elements._id in (\n" +
                "        select M.id_subs from pairing_area M);");
*/

        db.execSQL(sqlDo[2]);
        /*                  "insert into pairing_area (class_area, id_subs, cykl_len)\n" +    // 0
                        "   select  pairing_num, _id, cykl_len  from elements where not pairing_num = 1;",  */

/*
// вычисление всех степеней для эл-тов простого порядка
        classDop = new classGenDop(mApp, dbH);
        classDop.f_primeDop();  // в  табл deg_ids id ы циклов для простых pe
*/

// заполняю  pairing_multiplications - таблица умножения классов без объединения центров

        int countInvSub = 0; // Число найденных нормальных подгрупп для классов (с повторением и всей группой ?)

// 2. pairing_area построена заполнение  temp_sylow = новая найденная нормальная подгруппа
//--------------
        for (iu = 1; iu <= maxSoprClass; iu++)
            countInvSub += f_buildNormalForKlass(iu);

// 3.  строю табл soc_tmp с maxSoprClass колонками и туда переношу temp_sylow
// (idleft, idright, num1, num2) = (№ класса в подгруппе, № класса порождающего подгр, э-тов класса в подгр, эл-тов ккласса во всей группе для контроля, что весь класс вошел в подгруппу иначе она не может быть нормальной
//--------------

        maxSoprClass = dbH.f_getCount(sqlDo[4]);    // "select max(idright) as ccc  from temp_sylow where idproiz isnull;",
        selStr = "";
        for (iu = 1; iu <= maxSoprClass; iu++)
            selStr += "k" + iu + " INTEGER,\n";

        selStr = "create table IF NOT EXISTS soc_tmp " +    // колонка ki - соответствует классу i
                " (_id INTEGER primary key autoincrement,  " +
                selStr +
                "count_klass INTEGER,  num INTEGER not null);";
//        mApp.putProt("Длина SQL создания таблицы классов нормальных подгрупп " + selStr.length() );

        if (DISPLAYLOG)
            Log.e(TAG, "f_soc len= " + selStr.length() + "  selStr=" + selStr);
        db.execSQL(sqlDo[5]);   //  "DROP TABLE IF EXISTS soc_tmp;",    // 5
        db.execSQL(selStr);     // создание soc_tmp

        db.execSQL(sqlDel[0]); // "delete from sylov_id;"
// для найденных норм подгрупп заношу по temp_sylow в soc_list текстовый вид состава подгрупп  заполняю soc_tmp
// ниже придется еще раз перестроить soc_tmp и soc_list
        f_socList();

        f_socAddition(); // 2a. дополнить temp_sylow некоторыми группами (силовские, центр, коммутант)

        db.execSQL(sqlDo[6]); // "insert into sub_structure (num_maim, num_subs, deg) select idright, idleft, pe from temp_sylow;"
// sub_structure = состав найденных подгрупп с повторением,они могут пересекаться

        if (DISPLAYLOG)
            Log.d(TAG, "f_soc  Число найденных нормальных подгрупп, построенных по классам для классов "+ countInvSub + " (с повторением и всей группой)" );

        db.execSQL(sqlDo[3]);
        /*             "insert into pairing_multiplications (class_a, class_b, class_m)\n" +
                        "   select distinct P1.class_area as klass1, P2.class_area as klass2, P0.class_area as klass0\n" +
                        " from pairing_area P1, sub_structure S1, pairing_area P2, sub_structure S2, pairing_area P0, \n" +
                        "    temp_multiplication M \n" +
                        " where P1.class_area = S1.num_subs and P2.class_area = S2.num_subs and \n" +
                        "    P1.id_subs = M.idleft and P2.id_subs = M.idright AND M.idproiz = P0.id_subs and  \n" +
                        "    S1.num_maim = S2.num_maim \n" +
                        " order by klass2 asc, klass1 asc, klass0 asc;",    //  3 */



// 4. заполняю таблицу soc_list - состав норм подгрупп,  заполняю soc_tmp, проставляю dubl_flag:
//--------------
        db.execSQL(sqlDel[5]);  // "delete from soc_list;"
        db.execSQL(sqlDel[0]);  // "delete from sylov_id;"

        // заношу по temp_sylow в soc_list текстовый вид состава подгрупп  заполняю soc_tmp
        f_socList();

        do {
// удалит дублируемые подгруппы
            db.execSQL(sqlDo[7]);  // "delete from " + DbHelper.sub_structure[vidWgrup] + " where num_maim in (\n" +
//                          "  select num_klass from soc_list where dubl_flag > 0);"
            iu = f_socPoisk(); // поиск разных новых подгрупп (пересечений построенных)
        } while (iu > 0);


// 5.  ищу мин подгруппы (которые не имеют в себе норм подгрупп) = подгруппы цоколя
//--------------

        List<Integer> arrNomDel = new ArrayList();
        db.execSQL(sqlDel[7]);      // "delete from sub_summa;"
        db.execSQL(sqlDel[8]);      // "delete from soc_subs;"
        db.execSQL(sqlDel[9]);  // "UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='soc_subs';"

        countInvSub = dbH.f_getCount(sqlDo[8]);     // "select count(*) as ccc  from soc_list where not dubl_flag = 1;"
        mApp.putProt("\nЧисло найденных нормальных подгрупп построенных по классам "+ countInvSub );

// поиск  подпрограмм цоколя использует f_socFind()
        f_ciklSocFind();
// (idleft, idright, num1, num2) = (№ класса в подгруппе, № класса порождающего подгр, э-тов класса в подгр,
// эл-тов класса во всей группе для контроля, что весь класс вошел в подгруппу иначе она не может быть нормальной


// 6.  проверка группы на прямую сумму подгрупп, строю select  вида:
//--------------
        f_socSumma(0, DbHelper.countElements, 0);

/*
        if (arrNomDel.size() > 0) {
            mApp.putProt("ГРУППА И ЕЕ ПОДГРУППЫ РАСКЛАДЫВАЮТСЯ В ПРЯМОЕ ПРОИЗВЕДЕНИЕ СВОИХ ПОДГРУПП : ");
            for (iu = 0; iu < arrNomDel.size(); iu++)
                mApp.putProt("  ПОДГРУППA " + arrNomDel.get(iu));
        }
*/
        arrNomDel.clear();
// 7.  заношу в soc_list флажки:
//--------------

// группа четных подстановок
        ss1 = dbH.f_getListSubgr( "select distinct P.class_area as num from " + DbHelper.elements[vidWgrup] + "  E, " + DbHelper.pairing_area[vidWgrup] + " P  " + // выбираю группу четных подстановок
                " where  E._id = P.id_subs and E.parity = 0  " + // and not pairing_num = 1
                "order by P.class_area asc;");
        db.execSQL("update " + DbHelper.soc_list[vidWgrup] + " set even_flag = 1 where sostav = '" + ss1 + "'; ");
        if (DISPLAYLOG)
            Log.e(TAG, "f_soc  четных подстановок  ss1='" + ss1 + "' " );

        dbH.f_SwitchToSocList();

// цоколь
        ss1 = dbH.f_getListSubgr("select distinct P.class_area as num from " + DbHelper.elements[vidWgrup] + "  E, " + DbHelper.pairing_area[vidWgrup] + " P " + // выбираю группу четных подстановок
                " where  E._id = P.id_subs and E.nomer_soc > 0 " + //  and not pairing_num = 1
                "order by P.class_area asc;");
        db.execSQL("update " + DbHelper.soc_list[vidWgrup] + " set soc_level = 1 where sostav = '" + ss1 + "'; ");
        if (DISPLAYLOG)
            Log.e(TAG, "f_soc цоколь  ss1='" + ss1 + "' " );

// центр
        ss1 = dbH.f_getListSubgr("select distinct P.class_area as num from " + DbHelper.elements[vidWgrup] + " E, " + DbHelper.pairing_area[vidWgrup] + " P\n" +
                "   where E._id = P.id_subs and E.center_num = "+ DbHelper.countElements +"\n" +
                "    order by class_area asc;");
        db.execSQL("update " + DbHelper.soc_list[vidWgrup] + " set centr_flag = 1 where sostav = '" + ss1 + "'; ");
        if (DISPLAYLOG)
            Log.e(TAG, "f_soc центр  ss1='" + ss1 + "' " );

// силов подгруппы, общ силов подгруппы
        if (sylNum.size() > 0 )
            for (iu = 0; iu < sylNum.size(); iu ++) { //
                db.execSQL("update " + DbHelper.soc_list[vidWgrup] + " set sylow_num = " + sylNum.get(iu) + ", connon_sylow = " + sylSubNum.get(iu) +
                        "  where num_klass = " + factSylNum.get(iu) + ";");

  // запись в табл p_подгрупп номеров норм подгрупп для норм p-подгрупп
                if (sylSubNum.get(iu) > 0)
                    db.execSQL("update " + DbHelper.sylov_com_grup[vidWgrup] + " set norm_nomer = " + factSylNum.get(iu) +
                            "  where nomer1 = " + sylNum.get(iu) + " and nomer2 = " + sylSubNum.get(iu) + ";");
                else
                    db.execSQL("update  " + DbHelper.sylov_table[vidWgrup] + "  set norm_nomer = " + factSylNum.get(iu) +
                            "  where num = " + sylNum.get(iu) + ";");

                if (DISPLAYLOG)
                    Log.e(TAG, "f_soc силов подгруппы  num_klass = "+ factSylNum.get(iu) + " sylow_num= " + sylNum.get(iu) + " sylSubNum = " + sylSubNum.get(iu));
            }

        // удалить строку для центра, если она дублируется
        iu = dbH.f_getCount(sqlDo[10]);     // "select count(*) as ccc from soc_list where centr_flag > 0; "
        if (iu > 1)
            db.execSQL(sqlDo[11]);      // "delete from  soc_list where  centr_flag > 0 and num_klass >= 1000;"


// # - слагаемых, если группа разлагается в прямуб сумму

        db.execSQL(sqlDo[12]);      /* "update soc_list set summa_num = (\n" +
                "  select S.num_maim from sub_summa S\n" +
                "    where  num_klass = S.num_subs \n" +
                ") where soc_list.num_klass in (\n" +
                "  select num_subs from sub_summa\n" +
                "  );" */
        if (DISPLAYLOG)
            Log.e(TAG, "f_soc # - слагаемых  ");

        // строю коммутанты до 4-го уровня
        for (iu = 0; iu < 2; iu++) {
            if (DbHelper.solvableGroup == 0)
                dbH.f_nextKomm();
            else
                break;
        }
        dbH.f_SwitchToSocList();    // пополнить колонку коммутанта


// 8. строю вложенность норм подгрупп таблица normal_subgroup
//--------------
        cur1Soc = db.rawQuery(sqlDo[13], null);     /*  "select num_klass as num1, count_klass as ccc\n" + // выбираю самую наибольшую по числу классов подгруппу
                "  from soc_list \n" +
                "  where deg < "+ DbHelper.countElements + " and not dubl_flag = 1 \n" +    // всю группу не беру
                "order by count_klass asc;" */
// SQL выбора наименьшей подгруппы, содержащей pId
        ss1 = "select num as ccc from (\n" +
                " select  A.num as num, A.count_klass as klass, L.count_klass, L.deg\n" +
                " from soc_tmp A, soc_tmp F, " + DbHelper.soc_list[vidWgrup] + " L\n" +
                " where  L.num_klass = A.num and not F.num = A.num and not L.dubl_flag = 1 and \n" +
                "   A.num not in (\n" +
                "     select num_sub from " + DbHelper.normal_subgroup[vidWgrup] + "\n" +
                "      )\n";
        for (iu = 2; iu <= maxSoprClass; iu++)
            ss1 += " and ((F.k" + iu + " = 1 and A.k" + iu + " = 1) or F.k" + iu + " isNull)\n";
        if (DISPLAYLOG)
            Log.e(TAG, "f_soc длина SQL " + ss1.length() );
//        mApp.putProt("Длина SQL поиска вложенности нормальных подгрупп " + ss1.length() );

 /* selStr =  A - уже выбранные подгруппы, F - что проверяю, сортировка по числу классов и порядку подгруппы
select num as ccc from (
 select  A.num as num, A.count_klass as klass, L.count_klass, L.deg
 from soc_tmp A, soc_tmp F, soc_list L
 where  L.num_klass = A.num and not F.num = A.num and
   A.num not in (
     select num_sub from normal_subgroup
      )
 and ((F.k2 = 1 and A.k2 = 1) or F.k2 isNull)
 and ((F.k3 = 1 and A.k3 = 1) or F.k3 isNull)
 and ((F.k4 = 1 and A.k4 = 1) or F.k4 isNull)
 and ((F.k5 = 1 and A.k5 = 1) or F.k5 isNull)
 and ((F.k6 = 1 and A.k6 = 1) or F.k6 isNull)
and  ((F.k7 = 1 and A.k7 = 1) or F.k7 isNull)
and  ((F.k8 = 1 and A.k8 = 1) or F.k8 isNull)
and  ((F.k9 = 1 and A.k9 = 1) or F.k9 isNull)
and  ((F.k10 = 1 and A.k10 = 1) or F.k10 isNull)
and  ((F.k11 = 1 and A.k11 = 1) or F.k11 isNull)
and  ((F.k12 = 1 and A.k12 = 1) or F.k12 isNull)
and  ((F.k13 = 1 and A.k13 = 1) or F.k13 isNull)
and  ((F.k14 = 1 and A.k14 = 1) or F.k14 isNull)
and  ((F.k15 = 1 and A.k15 = 1) or F.k15 isNull)
   and F.num = 4
order by L.count_klass asc, L.deg asc
) limit 1;
 */
        int row = 0, iiP, pId;
        cur1Soc.moveToFirst();
        if (cur1Soc.getCount() > 0) {
            iiP = cur1Soc.getColumnIndex("num1");
            do {
                pId = cur1Soc.getInt(iiP);
                ss2 = ss1 +  " and F.num = "+ pId + "\n" +  //  код подгруппы куда входит pId
                        "order by L.count_klass asc, L.deg asc\n" +
                        ") limit 1;";
                iu = dbH.f_getCount(ss2);
//                Log.e(TAG, "f_soc вложенность pId =  " + pId + " i= " + iu + " mNumKlass="+ mNumKlass + " " + ss2);
                if (iu > 0 ) {
// есть ли для этой подгруппы большая в soc_tmp, куда она входит
                    db.execSQL("insert into " + DbHelper.normal_subgroup[vidWgrup] + " (num_maim, num_sub, order_main, order_sub)\n" +
                            "  select " + iu + ", " + pId + ", M.deg, S.deg from " + DbHelper.soc_list[vidWgrup] + " M, " + DbHelper.soc_list[vidWgrup] + " S\n" +
                            "     where M.num_klass = " + iu + " and S.num_klass = " + pId + ";");

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

// 9. расстановка уровней, выбираю самые большие подгруппы
//--------------
        cur1Soc = db.rawQuery(sqlDo[14], null);     /* "select distinct M.num_maim as num from normal_subgroup M \n" +
                " where M.num_maim not in (select P.num_sub from normal_subgroup P);"  */

        cur1Soc.moveToFirst();
        if (cur1Soc.getCount() > 0) {
            iiP = cur1Soc.getColumnIndex("num");
            do {
                pId = cur1Soc.getInt(iiP);
                ss2 = "update " + DbHelper.soc_list[vidWgrup] + " set nrow = "+ row + " where num_klass = "+ pId + ";";
                if (DISPLAYLOG)
                    Log.e(TAG, "f_soc уровни 0 pId =  " + pId + " row= " + row +  " " + ss2);
// есть ли для этой подгруппы большая в soc_tmp, куда она входит
                db.execSQL(ss2);
                f_socNextItem(row + 1, pId);
            } while (cur1Soc.moveToNext());
        }
        cur1Soc.close();

// проставить ncol в soc_list для nrow = 0
        cur1Soc = db.rawQuery(sqlDo[15], null);     /* "select num_klass as kls  from soc_list\n" +
                " where dubl_flag = 0 and nrow = 0 order by num_klass;"  */

        arrNomDel.clear();
        cur1Soc.moveToFirst();
        if (cur1Soc.getCount() > 0) {
            iiP = cur1Soc.getColumnIndex("kls");
            do {
                pId = cur1Soc.getInt(iiP);
                arrNomDel.add(pId);
            } while (cur1Soc.moveToNext());
        }
        cur1Soc.close();
        for (iu = 0; iu < arrNomDel.size(); iu++ ) {
            ss2 = "update " + DbHelper.soc_list[vidWgrup] + " set ncol = " + (iu + 1) + " where num_klass = " + arrNomDel.get(iu) + ";";
            db.execSQL(ss2);
        }

// проставить ncol в soc_list для nrow > 0
        iw = dbH.f_getCount(sqlDo[16]);     // "select max(nrow) as ccc from soc_list where dubl_flag = 0;"
        if (DISPLAYLOG)
            Log.e(TAG, "f_soc iw =  " + iw );

        for (row = 1; row <= iw; row++){

            cur1Soc = db.rawQuery("select L.num_klass as klas, M.num_klass hKls, M.ncol \n" +
                    "from " + DbHelper.soc_list[vidWgrup] + " L, " + DbHelper.soc_list[vidWgrup] + " M, " + DbHelper.normal_subgroup[vidWgrup] + " N \n" +
                    "where L.dubl_flag = 0 and L.num_klass = N.num_sub and \n" +
                    "    N.num_maim = M.num_klass and L.nrow = "+ row + "\n" +
                    "    order by M.ncol asc;", null);

            arrNomDel.clear();
            cur1Soc.moveToFirst();
            if (cur1Soc.getCount() > 0) {
                iiP = cur1Soc.getColumnIndex("klas");
                do {
                    pId = cur1Soc.getInt(iiP);
                    if (DISPLAYLOG)
                        Log.e(TAG, "f_soc iw =  " + iw + " pId= " + pId );
                    arrNomDel.add(pId);
                } while (cur1Soc.moveToNext());
            }
            cur1Soc.close();
            for (iu = 0; iu < arrNomDel.size(); iu++) {
                ss2 = "update " + DbHelper.soc_list[vidWgrup] + " set ncol = " + (iu + 1) + " where num_klass = " + arrNomDel.get(iu) + ";";
                db.execSQL(ss2);
            }
        }

    }

    private void f_socSumma(int grNum, int countElements, int iter) {
        // попытка разложения подгруппы порядка countElements с номером grNum (м б = 0) в прямую сумму
        // при удаче номера подгрупп заносятся в arrNomFind

        int mId, pId, iiM, iiP, iu, iw, cc1, cc2;
/*
        if (DbHelper.countElements == DbHelper.countCentr) {
//   абелева группа
            int k, mm, nnn;
            if(grNum == 0) { // вся группа
                for (k = 0; k < substitutionS.sylovPrimeGrupNum.size(); k++) {
                    mm = dbH.f_getCount("select count(distinct num) as ccc from sylov_table where pe = " + substitutionS.sylovPrimeGrupNum.get(k) + ";");
                    if (mm == 1) {  // 1 подгруппа
                        nnn = dbH.f_getCount("select count(*) as ccc from sylov_table where pe = " + substitutionS.sylovPrimeGrupNum.get(k) + ";"); // порядок подгруппы
                        db.execSQL("insert into sub_summa (num_maim, num_subs, deg, iter, option) values (0, " + sylNum.get(k) + " , " + nnn + ", 0, 0);");
                        Log.e(TAG, "f_socSumma  pe= " + substitutionS.sylovPrimeGrupNum.get(k) + "  порядок подгруппы =  " + nnn);
                        mApp.putProt("ГРУППА " + grNum + " ЕСТЬ ПРЯМОЕ ПРОИЗВЕДЕНИЕ СВОИХ СИЛОВСКИХ ПОДГРУПП P= " + substitutionS.sylovPrimeGrupNum.get(k) + "  порядок подгруппы =  " + nnn);
                    }
                }
            }
            return;
        }
*/
        String sqL, ss,   xStr = "";
        boolean yy;

        if(grNum == 0) { // вся группа - все классы
            for (iu = 2; iu <= maxSoprClass; iu++) {
                if (xStr.length() > 0)
                    xStr += " and ";
                xStr += "(A.k" + iu + " ISNULL or B.k" + iu + " ISNULL)";
            }
        }  else {
            sqL = "select num_subs || '' as stext" +
                    " from " + DbHelper.sub_structure[vidWgrup] + " " +
                    " where  num_maim = " + grNum + ";";
            dbH.f_getMas(sqL); // selectedMas[] = все классы группы grNum

            for (iu = 0; iu < DbHelper.selectedMas.length; iu++) {   // классы самой подгруппы
                ss = DbHelper.selectedMas[iu];
                if (! ss.equals("1")) {
                    if (xStr.length() > 0)
                        xStr += " and ";
                    xStr += "(A.k" + ss + " ISNULL or B.k" + ss + " ISNULL)";
                }
            }
            for (iu = 2; iu <= maxSoprClass; iu++) {    // исключить подгруппы, не входящие в разлагаемую группу
                yy = true;  // iu не входит в подгруппу которую разлагаю
                for (iw = 0; iw < DbHelper.selectedMas.length; iw++ )
                    if (Integer.parseInt(DbHelper.selectedMas[iw].trim()) == iu) {
                        yy = false;
                        break;
                    }
                if (yy)
                    xStr += " and A.k" + iu + " ISNULL and B.k" + iu + " ISNULL";
            }
        }
        if (xStr.length() > 0)
            xStr += " and ";

        sqL = "select A.num as num1, B.num as num2 " +
                " from soc_tmp A, soc_tmp B, " + DbHelper.soc_list[vidWgrup] + " LA,  " + DbHelper.soc_list[vidWgrup] + " LB" +
                " where  " + xStr + " \n" +
                "A.num < B.num and A.count_klass > 1 and B.count_klass > 1 and A.num = LA.num_klass and B.num = LB.num_klass and \n" +
        "  (LA.deg * LB.deg) = " + countElements + ";";
        if (DISPLAYLOG)
            Log.e(TAG, "f_socSumma grNum= " + grNum + "  len= " + sqL.length() + "  sqL =  " + sqL);
//        mApp.putProt("ГРУППА "+ grNum + " длина SQL поиска разложения в прямое произведение = " + sqL.length());

/*
CREATE TABLE sub_structure  (_id INTEGER primary key autoincrement,  num_maim INTEGER NOT NULL,  num_subs INTEGER NOT NULL, deg INTEGER )
        iu = dbH.f_getCount("select count(*) as ccc from sub_summa where num_maim = " + grNum + ";" );
        Log.e(TAG, "f_socSumma grNum="+ grNum + " countElements =  " + countElements + " iter="+ iter + " iu=" + iu);

        if (iu > 0)
            return;


        sqL ="select a.num_klass as num1, b.num_klass as num2, a.deg as deg1, b.deg as deg2 \n" +
                        "                from soc_list a,  soc_list b\n" +
                        "                where  a.dubl_flag = 0 and b.dubl_flag = 0 and\n" +
                        "                 a.num_klass > 1 and\n" +
                        "                 a.num_klass < b.num_klass and\n" +
                        "                       (a.deg * b.deg) = " + countElements + "  \n" +
                        "  and (a.num_klass, b.num_klass) not in (\n" +
                        " select distinct a.num_klass as num1, b.num_klass as num2\n" +
                        "                from soc_list a,  soc_list b, sub_structure at, sub_structure bt\n" +
                        "                where at.num_maim =  a.num_klass and bt.num_maim =  b.num_klass and\n" +
                        "                 a.dubl_flag = 0 and b.dubl_flag = 0 and\n" +
                        "                 a.num_klass > 1 and\n" +
                        "                 a.num_klass < b.num_klass and\n" +
                        "                 (at.num_subs  > 1 and at.num_subs = bt.num_subs ) and\n" +
                        "                       (a.deg * b.deg) = " + countElements + "\n" +
                        ")  and b.num_klass not in (\n" +
                "    select num_subs from sub_summa\n" +
                "                        );";
*/
        if (DbHelper.countElements == countElements )
            substitutionS.sel2Multiplier = sqL;

        Cursor cur1Soc = db.rawQuery(sqL, null);

        cur1Soc.moveToFirst();
        if (cur1Soc.getCount() > 0) {
            iiM = cur1Soc.getColumnIndex("num1");
            iiP = cur1Soc.getColumnIndex("num2");
            do {
                mId = cur1Soc.getInt(iiM);
                pId = cur1Soc.getInt(iiP);
                cc1 = dbH.f_getCount("select count(P.id_subs) as ccc from " + DbHelper.sub_structure[vidWgrup] + " S, " + DbHelper.pairing_area[vidWgrup] + " P" +
                        " where S.num_maim = " + mId + " and S.num_subs = P.class_area;"); // порядок подгруппы
                cc2 = dbH.f_getCount("select count(P.id_subs) as ccc from " + DbHelper.sub_structure[vidWgrup] + " S, " + DbHelper.pairing_area[vidWgrup] + " P" +
                        " where S.num_maim = " + pId + " and S.num_subs = P.class_area;"); // порядок подгруппы
                db.execSQL("insert into " + DbHelper.sub_summa[vidWgrup] + " (num_maim, num_subs, deg, iter, option) values (" + grNum + ", " + mId + ", " + cc1 + ", " + iter + ", 0);");
                db.execSQL("insert into " + DbHelper.sub_summa[vidWgrup] + " (num_maim, num_subs, deg, iter, option) values (" + grNum + ", " + pId + ", " + cc2 + ", " + iter + ", 0);");

                if (DISPLAYLOG)
                    Log.d(TAG, "f_socSumma ГРУППА " + grNum + " порядка " + countElements + " ЕСТЬ ПРЯМОЕ ПРОИЗВЕДЕНИЕ СВОИХ ПОДГРУПП С КЛАССАМИ: " + mId + " x " + pId + " порядков " + cc1 + " и " + cc2 ); // + " sqL="+sqL);

                f_socSumma(mId, cc1, iter + 1); // продолжить разложение
                f_socSumma(pId, cc2, iter + 1);
                mApp.putProt("ГРУППА " + grNum + " ЕСТЬ ПРЯМОЕ ПРОИЗВЕДЕНИЕ СВОИХ ПОДГРУПП №: " + mId + " x " + pId + " порядков " + cc1 + " и " + cc2 );

                break;

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


    private void f_socNextItem(int uroven, int numKlas) {
        // обрабатывает дерево все подгруппы, входящие в подгруппу numKlas уровня uroven

        Cursor curNextSoc = db.rawQuery("select distinct M.num_sub as num from " + DbHelper.normal_subgroup[vidWgrup] + " M \n" +
                " where M.num_maim = " + numKlas + ";", null);
        int indKl, nKlsaa;
        String ss3;

        curNextSoc.moveToFirst();
        if (curNextSoc.getCount() > 0) {
            indKl = curNextSoc.getColumnIndex("num");
            do {
                nKlsaa = curNextSoc.getInt(indKl);
                ss3 = "update " + DbHelper.soc_list[vidWgrup] + " set nrow = "+ uroven + " where num_klass = "+ nKlsaa + ";";
                if (DISPLAYLOG)
                    Log.e(TAG, "f_socNextItem уровни "+ numKlas + " ->  " + nKlsaa + " row= " + uroven +  " " + ss3);
// есть ли для этой подгруппы большая в soc_tmp, куда она входит
                db.execSQL(ss3);
                f_socNextItem(uroven + 1, nKlsaa);
            } while (curNextSoc.moveToNext());
        }
        curNextSoc.close();
    }

    private void  f_socFind(int mKlass, int cntKl, List<String> aNomDubl, List<Integer> aNomDel) {
// поиск - обработать подгпруппу с номером (класса) mKlass
// в soc_list и pairing_area заносит substitutionS.nomSocSub - № подгруппы цоколя
// substitutionS.nomSocSub  найденные подгруппы
// soc_subs - рабочая таблица
        int i;
        String selStr,   xStr = " where not num = " + mKlass;
        for (i = 1; i <= maxSoprClass; i++)
            if (!aNomDel.contains(i))
                xStr += " and k" + i + " ISNULL";

        selStr = "select count(*) as ccc from soc_tmp \n " + xStr + " and count_klass > 1 and count_klass < " + cntKl + " and num > 1;";

//        Log.e(TAG, "f_socFind i=" + i + " arrNomDel="+ aNomDel.size() + " mId_="+ mKlass + "  selStr=" + selStr);

        i = dbH.f_getCount(selStr);    //  число подгрупп, куда входит mId
        if (DISPLAYLOG)
            Log.e(TAG, "f_socFind mKlass= " + mKlass + " #= " + substitutionS.nomSocSub + " maxSoprClass= " + maxSoprClass + " cntKl=" + cntKl + " i="+ i + " xStr="+ xStr);
        if (i == 0) {

            xStr = dbH.f_getString("select sostav as stext from " + DbHelper.soc_list[vidWgrup] + " where num_klass = " + mKlass + " limit 1; ");

            if (DISPLAYLOG)
                Log.e(TAG, "f_socFind  i=" + i + " Найдена =" + mKlass + " sostav = "+ xStr);
            if (!aNomDubl.contains(xStr)) {
                selStr = "insert into " + DbHelper.soc_subs[vidWgrup] + " (num_maim, num_subs) " +
                        "select " + mKlass + " , idleft from temp_sylow where idright = " + mKlass + ";";
                db.execSQL(selStr);

                i = dbH.f_getCount("select count(*) as ccc from " + DbHelper.pairing_area[vidWgrup] + " where class_area in (\n" +
                        " select num_subs from " + DbHelper.soc_subs[vidWgrup] + " where num_maim = " + mKlass + ");");
                if (i > 1) { // 1-ца здесь не должна  учитываться

                    selStr = "update " + DbHelper.soc_list[vidWgrup] + " set num =  " + substitutionS.nomSocSub + " where num_klass = " + mKlass + ";";
                    db.execSQL(selStr);
                    selStr = "update " + DbHelper.pairing_area[vidWgrup] + " set num =  " + (substitutionS.nomSocSub++) + " where class_area in (\n" +
                            " select num_subs from " + DbHelper.soc_subs[vidWgrup] + " where num_maim = " + mKlass + ");";
                    db.execSQL(selStr);

                    mApp.putProt("Подгруппа " + mKlass + " будет подгруппой цоколя порядка " + i + " или войдет в нее");
                    if (DISPLAYLOG)
                        Log.e(TAG, "f_socFind  i=" + i + " Найдена =" + mKlass + " sostav = " + xStr + "  порядка " + i);
                }
                aNomDubl.add(xStr); // состав
            }
        }
    }

    private int f_buildNormalForKlass(int kUrov) {
/* для класса с порядковым номером = kUrov строит минимальную нормальную подгруппу, содержащую этот класс
     в temp_sylow дописывает все уровни подгрупп и kUrov - накопление нормальных подгрупп построенных по классам
     Выход = число найденных норм подгр (обычно 1)
*/
        if (DISPLAYLOG)
            Log.e(TAG, "f_buildNormalForKlass  kUrov=" + kUrov);
        final String ss[] = {"delete from sylov_id;",     // 0
// запись эл-тов класса в sylov_id
                "insert into sylov_id (num, id_s) select " + kUrov + ", id_subs  from " + DbHelper.pairing_area[vidWgrup] + " where class_area = " + kUrov + ";",    // 1

                "delete from temp_pe;",             // 2
// id произведение эл-тов класса
                "insert into temp_pe (id_1, id_2, center_num)\n" +      // 3
                        "     select DISTINCT M.idproiz, M.idproiz, E.class_area " +
                        "      from " + DbHelper.temp_multiplication[vidWgrup] + " M, sylov_id A, sylov_id B, " + DbHelper.pairing_area[vidWgrup] + " E\n" +
                        "        where M.idleft = A.id_s and M.idright = B.id_s  and \n" +
                        "          E.id_subs = M.idproiz and  M.idproiz not in (\n" +
                        "    select X.id_s from sylov_id X);",

                "select count(*) as ccc from temp_pe; ",                 // 4
// перезапись в sylov_id
                "insert into sylov_id (num, id_s) select distinct center_num, id_1 from temp_pe; ",   // 5
// в temp_sylow  idleft = # класса, num1 = число эл-тов класс в подгруппе
                "insert into temp_sylow (idleft, idright, num1, num2)\n" +              // 6
                        "    select distinct num, "+ kUrov + ", count(id_s), 0 from sylov_id group by num order by num asc;",

// в temp_sylow  idleft = # класса, num1 = число эл-тов класс в подгруппе, num2 - всего эл-тов в классе
                "update temp_sylow set num2 = (\n" +                     // 7 num2 = число эл-тов класса всего
                        "  select count(P.id_subs) from " + DbHelper.pairing_area[vidWgrup] + " P\n" +
                        "    where  P.class_area = temp_sylow.idleft)\n",

                "select count(*)  as ccc from temp_sylow where not num1 = num2;",    // 8

                "select count(*)  as ccc from sylov_id;",    // 9

                "delete from temp_sylow where idright = "+ kUrov + ";"      // 10 удалить, если подгруппа не нормальна

        };

        int nnn, ip, cPGr = 0;  // число нормальных подгрупп
        // из pairing_area заношу в sylov_id текущий класс
        db.execSQL(ss[0]);  // delete from sylov_id
       db.execSQL(ss[1]);  // insert into sylov_id (num, id_s) select " + kUrov + ", id_subs  from " + DbHelper.pairing_area[vidWgrup] + " where class_area = " + kUrov + ";
        do {
            db.execSQL(ss[2]);  // delete from temp_pe
            db.execSQL(ss[3]);  //  into temp_pe новые эл-ты со своим № класса
            nnn = dbH.f_getCount(ss[4]);    //  sylov_id - все эл-ты новой подгруппы
//            Log.e(TAG, "f_buildNormalForKlass всего новых эл-тов подгр цоколя " + nnn + " " +  ss[4]);
            if (nnn == 0)
                break;
            db.execSQL( ss[5]);  //  into sylov_id - пополнить новыми эл-тами
        } while (true);

// строю список классов полученной подгруппы
        db.execSQL( ss[6]);  //  into temp_sylow
        db.execSQL( ss[7]);  //  num2 = число эл-тов класса всего
// в temp_sylow:
// (idleft, idright, num1, num2) = (№ класса в подгруппе, № класса порождающего подгр, э-тов класса в подгр, эл-тов ккласса во всей группе для контроля, что весь класс вошел в подгруппу иначе она не может быть нормальной

        ip = dbH.f_getCount(ss[9]);    //  порядок подгруппы
        db.execSQL( "update temp_sylow set pe = " + ip + " where idright = " + kUrov + ";"); // pe =  порядок подгруппы

        nnn = dbH.f_getCount(ss[8]);    // select count(*)  as ccc from temp_sylow  если не 0 - не нормальная подгруппа
        if (nnn != 0) {
            db.execSQL( ss[10]);  //  delete from temp_sylow
            mApp.putProt("Подгруппа порядка " + ip + " для класса "+ kUrov + " не является НОРМАЛЬНОЙ!");
//                Log.e(TAG, "f_buildNormalForKlass  kUrov=" + kUrov + " подгруппа не нормальна nnn = " + nnn);
        } else {
            if (DISPLAYLOG)
                Log.e(TAG, "f_buildNormalForKlass  kUrov=" + kUrov + " порядок подгруппы = " + ip);
            cPGr++;
        }

        return cPGr;
    }

    final private static List<Integer> sylNum = new ArrayList<>(), // в соответствии с factSylNum  soc_list.sylow_num
            factSylNum = new ArrayList<>(),     // // soc_list.num_klass
            sylSubNum = new ArrayList<>();   // soc_list.connon_sylow

    private void f_socAddition() {
// 2a. дополнить некоторыми группами (силовские, центр, коммутант)
// дополнить temp_sylow:
// (idleft, idright, num1, num2) = (№ класса в подгруппе, № класса порождающего подгр, классов в подгр, эл-тов ккласса во всей группе для контроля, что весь класс вошел в подгруппу иначе она не может быть нормальной
// pe =  порядок подгруппы

    int k, mm;
    String ssql = "";
/* // Число силовских подгрупп по простым
 select pe, count(distinct num) as ccc0, 0 as ccc2 from sylov_table \n" +
                        "\tgroup by pe
                "select _id  from elements where center_num = "+ DbHelper.countElements + " order by ciklos asc;";
*/
        sylNum.clear();
        factSylNum.clear();
        sylSubNum.clear();
//  idproiz > 0 - строка (idleft) не является классом

        k = dbH.f_getCount("select max(colvo) as ccc from (\n" +   // мах порядок найденных подгрупп
                "select S.num_maim, count(P.id_subs) as colvo\n" +
                "from  " + DbHelper.pairing_area[vidWgrup] + " P, " + DbHelper.sub_structure[vidWgrup] + " S\n" +
                "where P.class_area =  S.num_subs\n" +
                "group by S.num_maim\n" +
                ");");
        if (k < DbHelper.countElements ) {  // добавить всю группу как подгруппу
            addCount++;
            mm = dbH.f_getCount("select count(distinct E.class_area) as ccc from " + DbHelper.pairing_area[vidWgrup] + " E;"); // классов всего
            ssql = "insert into temp_sylow (idleft, idright, num1, num2, pe, idproiz) "+
                    "select distinct P.class_area as clas, "+ (1000 + addCount) +", " + mm + " as num1, " +  mm + ", "  +
                        DbHelper.countElements + " as pe, "+ (1000 + addCount) +
            " from  " + DbHelper.pairing_area[vidWgrup] + " P;";
            db.execSQL( ssql);
            if (DISPLAYLOG)
                Log.e(TAG, "f_socAddition  добавить всю группу " + DbHelper.countCentr + "  "+  DbHelper.countElements  + " addCount="+ (1000 + addCount));
        }


// Центр группы для неабелевой группы
        if (DbHelper.countElements != DbHelper.countCentr) {  // не абелева
// дополнить temp_sylow:
// (idleft, idright, num1, num2) = (№ класса в подгруппе, № класса порождающего подгр, э-тов класса в подгр, эл-тов класса во всей группе для контроля, что весь класс вошел в подгруппу иначе она не может быть нормальной
            addCount++;

            // число  классов в центре
            k = dbH.f_getCount("select count(distinct P.class_area) as ccc from " + DbHelper.elements[vidWgrup] + " E, " + DbHelper.pairing_area[vidWgrup] + " P\n" +
                    "  where E.center_num = " + DbHelper.countElements + " and E._id = P.id_subs; ");    //  классов в подгруппе
            ssql = "insert into temp_sylow (idleft, idright, num1, num2, pe, idproiz) "+
                    "  select distinct P.class_area, " + (1000 + addCount) + ", " + k + " as n1, " + k + " as n2, " + DbHelper.countCentr + " as pe,  " + (10000 + addCount) +
                    "  from " + DbHelper.elements[vidWgrup] + " E, " + DbHelper.pairing_area[vidWgrup] + " P\n" +
                    "  where E.center_num = " + DbHelper.countElements + " and E._id = P.id_subs\n" +
                    "   order by P.class_area asc;";
            db.execSQL( ssql);
            if (DISPLAYLOG)
                Log.e(TAG, "f_socAddition  Центр группы " + DbHelper.countCentr + "  из "+  DbHelper.countElements  + " addCount="+ (1000 + addCount));
        }


// силовские подгр, общие силов подгр
//  поиск нормальных подгрупп среди p-подгрупп
        String sssql[] = {
                "delete from temp_pe;",
//        запись числа элементов по классам сопр эл-тов для p-подгрупп
                "insert into temp_pe (pe, id_1, id_2, id_s,  degs, center_num, list_num) " +
                        "  select distinct M.pe, Y.nomer1 id_1, Y.nomer2 id_2, count(*) id_s, 0 degs, P.class_area, Y.sylow_zag " +
                            "    from  " + DbHelper.elements[vidWgrup] + " M, " + DbHelper.pairing_area[vidWgrup] + " P, " + DbHelper.sylov_com_grup[vidWgrup] + " Y "+
                        "     where M._id = P.id_subs and Y.id_s = M._id "+
                        "      group by M.pe, Y.nomer1, Y.nomer2, P.class_area, Y.sylow_zag;",

                "insert into temp_pe (pe, id_1, id_2, id_s,  degs, center_num, list_num) " +
                        "  select distinct M.pe, Y.num id_1, 0 id_2, count(*) id_s, 0 degs, P.class_area, '' " +
                        "    from  " + DbHelper.elements[vidWgrup] + " M, " + DbHelper.pairing_area[vidWgrup] + " P, " + DbHelper.sylov_table[vidWgrup] + "  Y "+
                        "     where M._id = P.id_subs and Y.id_s = M._id "+
                        "      group by M.pe, Y.num, P.class_area;",

//     запись числа элементов по классам сопр эл-тов для полного класса
                "update temp_pe set degs = ( "+
                        "        select count(*) from  " + DbHelper.pairing_area[vidWgrup] + " P "+
                        "where P.class_area = temp_pe.center_num "+
                        "group by P.class_area" +
                        "  );",
// поссле этих SQL в  temp_pe есть норм подгруппа, если для нее id_s = degs для всех ее классов

                "delete from lines;",
// запись подгрупп не являющихся нормальными (есть не полный класс сопр эл-тов)
                "insert into lines  (id_1, id_2, npp, nomer)\n" +
                        "  select distinct id_1, id_2, pe, 0 from temp_pe\n" +
                        "  where not id_s = degs;",
// удалить подгруппы не являющихся нормальными
                "delete from temp_pe\n" +
                        "  where (id_1, id_2) in (\n" +
                        "   select id_1, id_2 from lines\n" +
                        "   );",
// id_2 = 0 - сил подгруппа
                "select pe, id_1, id_2, center_num from temp_pe order by id_1 asc, id_2 asc, center_num asc "};

        for (int i = 0; i < sssql.length - 1; i++) {
            db.execSQL(sssql[i]);
            if (DISPLAYLOG)
                Log.e(TAG, "f_socAddition  sssql[i] =  " + sssql[i]);
        }

        String sss = "";

        Cursor curSylCommPe = db.rawQuery(sssql[sssql.length - 1], null);
        curSylCommPe.moveToFirst();
        if (curSylCommPe.getCount() > 0) {
            int indI1 = curSylCommPe.getColumnIndex("id_1"),
                indI2 = curSylCommPe.getColumnIndex("id_2"),
                indPe = curSylCommPe.getColumnIndex("pe"),
                indCn = curSylCommPe.getColumnIndex("center_num"),
                n10 = -1, n20 = -1, n1, n2, pe, center_num;

            do {
                n1 = curSylCommPe.getInt(indI1);
                n2 = curSylCommPe.getInt(indI2);
                pe = curSylCommPe.getInt(indPe);
                center_num = curSylCommPe.getInt(indCn);
                if (DISPLAYLOG)
                   Log.e(TAG, "f_socAddition  pe= " + pe + " nomer1=" + n1  + " nomer2="+ n2 + " center_num = "+ center_num + " sss = " + sss );

                if (n10 != n1 || n20 != n2) {
                    if (n10 > 0)
                        f_socAddGroup(pe, n10, n20, sss);
                    n10 = n1;
                    n20 = n2;
                    sss = " ";    // ключ поиска в soc_list
                }
                sss += " " + center_num + ", ";
            } while (curSylCommPe.moveToNext());
            if (n10 > 0)
                f_socAddGroup(pe, n10, n20, sss);

        }
        curSylCommPe.close();

    }

    private void f_socAddGroup(int pe0, int n10, int n20, String sss) {
        // обработка найденной р-подгруппы, которая нормальна, pe0 не всегда верно и не используется
        int k, nnn, mm;
        String ssql;

        // ищу k = num_klass - номер подгруппы если она есть ?
        k = dbH.f_getCount("select num_klass as ccc from " + DbHelper.soc_list[vidWgrup] + " where sostav = '" + sss + "';");
        if (k > 0) { // есть погруппа, ее номер  = k
            if (n20 > 0) {    // уровень р подгрупп
                ssql = "update " + DbHelper.sylov_com_grup[vidWgrup] + "  set norm_nomer = " + k + " where nomer1 = " + n10 + " and nomer2 = " + n20 + ";";
            } else {
                ssql = "update " + DbHelper.sylov_table[vidWgrup] + " set norm_nomer = " + k + " where nomer1 = " + n10 + ";";
            }
            factSylNum.add(k);  // soc_list.num_klass
            sylNum.add(n10);    // soc_list.num_klass
            sylSubNum.add(n20); // soc_list.connon_sylow

            if (DISPLAYLOG)
                Log.e(TAG, "f_socAddGroup find  pe= " + pe0 + " n10 = " + n10 + " n20 = " + n20 + " sss = " + sss + " sql= \n" + ssql);
        } else {
// найденная р-подгруппа есть новая нормальная подгруппа
            addCount++;
            if (n20 > 0) {    // уровень р подгрупп
                ssql = "select count(*) as ccc from " + DbHelper.sylov_com_grup[vidWgrup] + " where  nomer1 = " + n10 + " and nomer2 = " + n20 + ";";
                nnn = dbH.f_getCount(ssql); // порядок подгруппы
                if (DISPLAYLOG)
                    Log.e(TAG, "f_socAddGroup nnn = " + nnn+ " " + ssql);
                ssql = "select count(distinct E.class_area) as ccc from " + DbHelper.pairing_area[vidWgrup] + " E, " + DbHelper.sylov_com_grup[vidWgrup] + " P\n" +
                        "  where E.id_subs = P.id_s and P.nomer1 = " + n10 + " and P.nomer2 = " + n20 + ";";
                mm = dbH.f_getCount(ssql);   //   классов в подгруппе
                if (DISPLAYLOG)
                    Log.e(TAG, "f_socAddGroup mm = " + mm + " " + ssql);
/* temp_sylow здесь:
idleft      - pairing_area.class_area - код класса сопр эл-тов
idright     - номер подгруппы = soc_list.num_klass = порядковый номер класса сопр эл-тов
num1        - классов в подгруппе
num2        = число эл-тов класса всего, здесь = num1
pe          - порядок подгруппы
idproiz     = soc_list.num_klass
 */

                ssql = "insert into temp_sylow (idleft, idright, num1, num2, pe, idproiz) " +
                        "  select distinct E.class_area, " + (1000 + addCount) + ", " + mm + " as n1, " + mm + " as n2, " + nnn + " as pe, " + (10000 + addCount) +
                        " from " + DbHelper.pairing_area[vidWgrup] + " E, " + DbHelper.sylov_com_grup[vidWgrup] + " P\n" +
                        "  where P.nomer1 = " + n10 + " and P.nomer2 = " + n20 + "\n" +
                        "   order by E.class_area asc;";
            } else {
                nnn = dbH.f_getCount("select count(*) as ccc from sylov_table where num = " + n10 + ";"); // порядок подгруппы
                mm = dbH.f_getCount("select count(distinct E.class_area) as ccc from " + DbHelper.pairing_area[vidWgrup] + " E, sylov_table P\n" +
                        "  where E.id_subs = P.id_s and P.num = " + n10 + ";");    //   классов в подгруппе
                ssql = "insert into temp_sylow (idleft, idright, num1, num2, pe, idproiz) " +
                        "  select distinct E.class_area, " + (1000 + addCount) + ", " + mm + " as n1, " + mm + " as n2, " + nnn + " as pe, " + (10000 + addCount) +
                        " from " + DbHelper.pairing_area[vidWgrup] + " E, " + DbHelper.sylov_table[vidWgrup] + " P\n" +
                        "  where P.num = " + n10 + "\n" +
                        "   order by E.class_area asc;";
            }
            db.execSQL(ssql);
            factSylNum.add((10000 + addCount));  // soc_list.sylow_num
            sylNum.add(n10);    // num_klass
            sylSubNum.add(n20);
            if (DISPLAYLOG)
                Log.e(TAG, "f_socAddGroup add  pe= " + pe0 + " n10 = " + n10 + " n20 = " + n20 + " sss = " + sss + " классов в подгруппе =  " + mm + "  порядок подгруппы =  " + nnn + " #= " + (1000 + addCount) + " sql= \n" + ssql);

        }
    }


    private void f_socList() {
        // заношу в soc_list текстовый вид состава подгрупп  заполняю soc_tmp
        int mainId, mainId_ = 0, pId, iiM, iiP, deg = 0, iiDeg, cntKl = 0, iii;
        String xStr = " ", sost = "", sost_ = ";", selStr;

        String sqlVibor = "select idright as mid, idleft as pid, pe as deg " +
                " from temp_sylow T\n" +
                " order by idright asc, idleft asc; ";

        Cursor cur1Soc = db.rawQuery(sqlVibor, null);
        if (DISPLAYLOG)
            Log.e(TAG, "f_socList  sqlVibor= " + sqlVibor);
/*
idright = # норм подгруппы

  select T.idright as mid, T.idleft as pid, T.pe as deg,  P.cykl_len as cykl
from temp_sylow T, pairing_area P
   where P.class_area = T.idleft
    order by T.idright asc, T.idleft asc

        //  idproiz > 0 - строка (idleft) не является классом
*/
        db.execSQL("delete from " + DbHelper.soc_list[vidWgrup] + ";");
        db.execSQL("delete from soc_tmp;");

        cur1Soc.moveToFirst();
        if (cur1Soc.getCount() > 0) {
            iiM = cur1Soc.getColumnIndex("mid");
            iiDeg = cur1Soc.getColumnIndex("deg");
            iiP = cur1Soc.getColumnIndex("pid");
            do {
                mainId = cur1Soc.getInt(iiM);
                pId = cur1Soc.getInt(iiP);
                if (mainId != mainId_) {
                    if (mainId_ > 0) { // записать строку
                        selStr = "insert into  " + DbHelper.soc_list[vidWgrup] + " (num_klass, sostav, count_klass, deg, dubl_flag)" +
                                " values (" + mainId_ + ", '" + xStr + "', " + cntKl + "," + deg + ", 0);";
                        db.execSQL(selStr);

                        selStr = "insert into  soc_tmp (num, count_klass " + sost_;
                        selStr +=  ") values (" + mainId_  + ", " + cntKl + " " + sost + ");";
                        db.execSQL(selStr);
                    }
                    mainId_ = mainId;
                    xStr = " ";
                    cntKl = 0;
                    sost = sost_ = "";
                    deg = cur1Soc.getInt(iiDeg);    // число классов
                }
                xStr += " " + pId + ", ";
                cntKl++;
                sost_ += ", k" + pId;
                sost += ", 1";

            } while (cur1Soc.moveToNext());
            selStr = "insert into  " + DbHelper.soc_list[vidWgrup] + " (num_klass, sostav, count_klass, deg, dubl_flag) values (" + mainId + ", '" + xStr + "', " + cntKl + "," + deg + ", 0);";
            db.execSQL(selStr);
            selStr = "insert into  soc_tmp (num, count_klass " + sost_ + ") values (" + mainId + ", " + cntKl + " " + sost + ");";
            db.execSQL(selStr);
        }
        cur1Soc.close();

        // заполняю sostav_type -   состав <пробел><цикл тип><,>
        //  sostav_count    -   состав <пробел>< порядок класса><,>
   /*
select  P.class_area as class_area, P.cykl_len as cykl, count(distinct P.id_subs) as ccc
 from  pairing_area P
   where instr('  1,  13, ', ' '|| P.class_area || ',') > 0
   group by  P.cykl_len, P.class_area
    order by P.class_area asc, P.cykl_len asc

select S.num_klass num_klass, S.sostav sostav, P.class_area as class_area, P.cykl_len as cykl, count(distinct P.id_subs) as ccc
 from pairing_area P, soc_list S
   where instr(S.sostav, ' '|| P.class_area || ',') > 0
   group by S.num_klass, P.cykl_len, P.class_area, S.sostav
    order by S.num_klass asc, P.class_area asc, P.cykl_len asc

    */

        sqlVibor = "select S.num_klass num_klass, S.sostav sostav, P.class_area as class_area, P.cykl_len as cykl, count(distinct P.id_subs) as ccc\n" +
                " from " + DbHelper.pairing_area[vidWgrup] + " P, " + DbHelper.soc_list[vidWgrup] + " S\n" +
                "   where instr(S.sostav, ' '|| P.class_area || ',') > 0\n" +
                "   group by S.num_klass, P.cykl_len, P.class_area, S.sostav \n" +
                "    order by S.num_klass asc, P.class_area asc, P.cykl_len asc;";
        cur1Soc = db.rawQuery(sqlVibor, null);
        if (DISPLAYLOG)
            Log.e(TAG, "f_socList  sqlVibor= " + sqlVibor);

        cur1Soc.moveToFirst();
        if (cur1Soc.getCount() > 0) {
            iiM = cur1Soc.getColumnIndex("num_klass");
            iiDeg = cur1Soc.getColumnIndex("class_area");
            iiP = cur1Soc.getColumnIndex("cykl");
            cntKl = cur1Soc.getColumnIndex("ccc");
            mainId_ = -1;
            do {
                mainId = cur1Soc.getInt(iiM);   // num_klass
                if (mainId != mainId_) {
                    if (mainId_ > 0) { // записать строку
                        selStr = "update " + DbHelper.soc_list[vidWgrup] + " set sostav_type = '"+ sost +"', sostav_count = '" +  xStr + "' where num_klass = "+ mainId_ + ";";
                        db.execSQL(selStr);
                    }
                    mainId_ = mainId;
                    xStr = sost = "";
                }
                pId = cur1Soc.getInt(iiDeg);    // class_area
                selStr = cur1Soc.getString(iiP);    // cykl_len
                if (selStr == null) selStr = "";
                deg = cur1Soc.getInt(cntKl);    // число эл-тов в классе
                xStr += pId + "-" + deg + ", ";
                sost += pId + "-" + selStr + ", ";

            } while (cur1Soc.moveToNext());
        }
        if (mainId_ > 0) { // записать строку
            selStr = "update " + DbHelper.soc_list[vidWgrup] + " set sostav_type = '"+ sost +"', sostav_count = '" +  xStr + "' where num_klass = "+ mainId_ + ";";
            db.execSQL(selStr);
        }
        cur1Soc.close();

        // проставляю dubl_flag
        List<Integer> arrNomDel = new ArrayList();
        sost_ = ";";
        cur1Soc = db.rawQuery("select U.num_klass as klass, U.sostav as sostav from " + DbHelper.soc_list[vidWgrup] + " U\n" +
                "  order by U.sostav asc;", null); //
        cur1Soc.moveToFirst();
        if (cur1Soc.getCount() > 0) {
            iiM = cur1Soc.getColumnIndex("klass");
            iiP = cur1Soc.getColumnIndex("sostav");
            do {
                mainId = cur1Soc.getInt(iiM);
                sost = cur1Soc.getString(iiP);
                if (sost.equals(sost_)) {
                    arrNomDel.add(mainId);
                }
                sost_ = sost;
            } while (cur1Soc.moveToNext());
        }
        cur1Soc.close();
        for (iii = 0; iii < arrNomDel.size(); iii++)
            db.execSQL("update " + DbHelper.soc_list[vidWgrup] + " set dubl_flag = 1 where num_klass = " + arrNomDel.get(iii) + ";");

//        db.execSQL("update soc_list set sylow_num = (" +
//                "select  where num_klass = " + arrNomDel.get(iii) + ";");
    }


    private void f_ciklSocFind() {
// поиск  подпрограмм цоколя использует f_socFind()
// (idleft, idright, num1, num2) = (№ класса в подгруппе, № класса порождающего подгр, э-тов класса в подгр, эл-тов класса во всей группе для контроля, что весь класс вошел в подгруппу иначе она не может быть нормальной
//
        List<String> arrNomDubl = new ArrayList();  //  состав образующих классов проверить чтобы не повиторялись
        List<Integer> arrNomDel = new ArrayList();
        if (DISPLAYLOG)
            Log.e(TAG, "f_ciklSocFind maxSoprClass = " + maxSoprClass + " nomSocSub= " + substitutionS.nomSocSub );

        String selStr;
        int iiM, iiP, m_Id = 0, p_Id, m_Id_Old = -10, cntKl = 0, iShag;
        Cursor cur1Soc = db.rawQuery("select T.idright as mid, T.idleft as pid, T.idproiz as count from temp_sylow T\n" +
                "  order by T.idproiz asc, T.idright asc, T.idleft asc;", null);

        cur1Soc.moveToFirst();
        if (cur1Soc.getCount() > 0) {
            iiM = cur1Soc.getColumnIndex("mid");
            iiP = cur1Soc.getColumnIndex("pid");
            do {
                m_Id = cur1Soc.getInt(iiM);
                p_Id = cur1Soc.getInt(iiP);
                if (m_Id != m_Id_Old) {
                    if (m_Id_Old > 0)  // обработать подгпруппу
                        f_socFind(m_Id_Old, cntKl, arrNomDubl, arrNomDel);

                    cntKl = 0;
                    arrNomDel.clear();  // список классов
                    m_Id_Old = m_Id;
                }
                cntKl++;
                arrNomDel.add(p_Id);

            } while (cur1Soc.moveToNext());
        }
        cur1Soc.close();
        f_socFind(m_Id, cntKl, arrNomDubl, arrNomDel);

        iShag = 0;
        do {
// строю произведения подгрупп цоколя
// select A.id_subs from pairing_area A, soc_subs S, soc_list L where A.class_area = S.num_subs and S.num_maim  = L.num_klass and l.num = 2

// в temp_sylow:
// (idleft, idright, num1, num2) = (№ класса в подгруппе, № класса порождающего подгр, э-тов класса в подгр, эл-тов ккласса во всей группе для контроля, что весь класс вошел в подгруппу иначе она не может быть нормальной
            db.execSQL("delete from temp_pe;");
            selStr = "insert into temp_pe (id_1, id_2)\n" +      // 3
                    "     select DISTINCT M.idproiz, " + iShag + " from " + DbHelper.temp_multiplication[vidWgrup] + " M, " + DbHelper.pairing_area[vidWgrup] + " A, " + DbHelper.pairing_area[vidWgrup] + " B\n" +
                    "        where M.idleft = A.id_subs and M.idright = B.id_subs  and \n" +
                    "          not A.num isnull and not B.num isnull and M.idproiz in (\n" + // можно упростить
                    "    select X.id_subs from " + DbHelper.pairing_area[vidWgrup] + " X where X.num isnull);";
            db.execSQL(selStr);

            iiM = dbH.f_getCount("select count(*) as ccc from temp_pe;");
            if (DISPLAYLOG)
                Log.e(TAG, "f_ciklSocFind maxSoprClass= " + maxSoprClass + " nomSocSub= " + substitutionS.nomSocSub + " iiM= " + iiM + " selStr=" + selStr);
            if (iiM == 0)
                break;

// записать номер +1 в элементы произведения
            selStr = "update " + DbHelper.pairing_area[vidWgrup] + " set num = " + substitutionS.nomSocSub + " where num isNull and id_subs in (" +
                    " select id_1 from temp_pe);";
            db.execSQL(selStr);
            iShag++;

            if (DISPLAYLOG)
                Log.e(TAG, "f_soc i= " + iShag + " nomSocSub= " + substitutionS.nomSocSub + " iiM= " + iiM + " selStr=" + selStr);
            if (iShag > 50)
                break;
        } while (true);

// проверю, что подгруппа

        // всего колонок k1, k2,...

        selStr = "select count( M.idproiz) as ccc " +
                " from " + DbHelper.temp_multiplication[vidWgrup] + " M, " + DbHelper.pairing_area[vidWgrup] + " A, " + DbHelper.pairing_area[vidWgrup] + " B\n" +
                "        where M.idleft = A.id_subs and M.idright = B.id_subs  and \n" +
                "         not A.num isnull and not B.num isnull and  M.idproiz in (\n" + // можно упростить
                "    select X.id_subs from " + DbHelper.pairing_area[vidWgrup] + " X where  X.num isnull);";
        iShag = dbH.f_getCount(selStr);
        if (iShag > 0) {
            mApp.putProt("ОШИБКА: не построен цоколь " + iShag + " ошибок");
            Log.e(TAG, "f_soc  ОШИБКА: не построен цоколь " + iShag + " ошибок");
        } else {
            selStr = "update " + DbHelper.elements[vidWgrup] + " set nomer_soc = (" +
                    "  select num from " + DbHelper.pairing_area[vidWgrup] + " where id_subs = " + DbHelper.elements[vidWgrup] + "._id);";
            iShag = dbH.f_getCount("select count(*) as ccc from " + DbHelper.pairing_area[vidWgrup] + " where not num isnull");
            db.execSQL(selStr);

            mApp.putProt("Построен цоколь порядка " + iShag);
        }
    }

    private int  f_socPoisk() {
/* поиск разных новых подгрупп (пересечений построенных n1 n2), запись их в soc_list, sub_structure
   заполняет таблицу normal_connect - таблица дополнительных вложений найденных нормальных подгрупп после формирования связей для всех уровней
    sub_structure - таблица всех нормальных подгрупп

CREATE TABLE temp_pe  (_id INTEGER primary key autoincrement,  pe	INTEGER, id_1 INTEGER NOT NULL, id_2 INTEGER NOT NULL, id_s INTEGER, degs INTEGER, center_num INTEGER, list_num  TEXT )
CREATE TABLE pairing_area (_id	INTEGER  primary key autoincrement, class_area INTEGER,   num INTEGER,   id_subs  INTEGER NOT NULL )
*/
        int iiN1, iiN2, iiK, n1, n2, n10 = -1, n20 = -1, klas, jj, cntKl = 0, itNum0,
            itNum = dbH.f_getCount("select max(class_area) as ccc from " + DbHelper.pairing_area[vidWgrup] + ";") + 1; // номер новой подгр

        itNum0 = itNum;
        db.execSQL("delete from temp_pe;");
        db.execSQL("delete from normal_connect;");
        db.execSQL("UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME='normal_connect';");

// id_1, id_2 = номера подгрупп, pe = их класс пересечения, 1 не выбирается
        String sqlP = "insert into temp_pe (id_1, id_2, pe)\n" +
                "select distinct S.num_maim as n1, T.num_maim as n2,  P.class_area\n" +
                "    from  " + DbHelper.pairing_area[vidWgrup] + " P, " + DbHelper.pairing_area[vidWgrup] + " Q, " + DbHelper.sub_structure[vidWgrup] + " S, " + DbHelper.sub_structure[vidWgrup] + " T,\n" +
                "         " + DbHelper.soc_list[vidWgrup] + " LP, " + DbHelper.soc_list[vidWgrup] + " LQ\n" +
                "      where S.num_subs =  P.class_area and T.num_subs =  Q.class_area and\n" +
                "       P.id_subs =  Q.id_subs and\n" +
                "       LP.num_klass = S.num_maim and LQ.num_klass = T.num_maim and\n" +
                "       LP.dubl_flag = 0 and LQ.dubl_flag = 0 and\n" +
                "      S.num_maim <  T.num_maim and not P.id_subs = " + substitutionS.codEdinicy + "\n" +
                "      order by S.num_maim asc, T.num_maim asc;";
        db.execSQL(sqlP);

//        Log.d(TAG, "f_socPoisk itNum = " + itNum);

        String  sost = "";
        Cursor cur1Soc = db.rawQuery("select id_1 as n1, id_2 as n2, pe as kls from temp_pe T\n" +
                " order by id_1 asc, id_1 asc; ", null);
        cur1Soc.moveToFirst();
        if (cur1Soc.getCount() > 0) {
            iiN1 = cur1Soc.getColumnIndex("n1");
            iiN2 = cur1Soc.getColumnIndex("n2");
            iiK = cur1Soc.getColumnIndex("kls");
            do {
                n1 = cur1Soc.getInt(iiN1);
                n2 = cur1Soc.getInt(iiN2);
                klas = cur1Soc.getInt(iiK);
                if (n1 != n10 || n2 != n20) {
                    if (n10 > 0 && n20 > 0) {

// выбираю номера обшей подгруппы для n10, n20 = dbh.selectedMas[]
                        db.execSQL("insert into normal_connect (num1, num2, num_common, count_class, sostav) " +
                                "select " + n10 + ", " + n20 + ", num_klass, " + cntKl + ", '" + sost + "' " +
                                " from " + DbHelper.soc_list[vidWgrup] + " where sostav = '" + sost + "' and dubl_flag = 0; ");

                        if (DISPLAYLOG) {
                            dbH.f_getMas("select ' ' || num_klass as stext from " + DbHelper.soc_list[vidWgrup] + " where sostav = '" + sost + "' and dubl_flag = 0; ");
                            for (jj = 0; jj < DbHelper.selectedMas.length; jj++)
                                  Log.e(TAG, "f_socPoisk  jj=" + jj + " подгруппа = " + DbHelper.selectedMas[jj] + " n=" + n10 + " " + n20 + " cntKl=" + cntKl + " sost='" + sost + "'");
                        }
                        jj = dbH.f_getCount("select count(*) as ccc from " + DbHelper.soc_list[vidWgrup] + " where sostav = '" + sost + "'; ");
                        if (DISPLAYLOG)
                            Log.e(TAG, "f_socPoisk  jj="+ jj+ " new " + itNum + " n=" + n10  + " " + n20 + " cntKl="+ cntKl + " sost=" + sost );
                        if (jj == 0) { // новая подгруппа
                            itNum++;
                            if (DISPLAYLOG)
                                Log.e(TAG, "f_socPoisk новая подгруппа new = " + itNum + " пересечение n1=" + n10 + " n2=" + n20 + " классов " + cntKl + " состав '" + sost + "'");
                        }
                    }
                    n10 = n1;
                    n20 = n2;
                    cntKl = 0;
                    sost = "  1, ";
                }
                sost += " " + klas + ", ";
                cntKl++;

            } while (cur1Soc.moveToNext());
            if (n1 > 0 && n2 > 0) { // последняя запись в normal_connect
                db.execSQL("insert into normal_connect (num1, num2, num_common, count_class, sostav) " +
                        "select " + n1 + ", " + n2 + ", num_klass, " + cntKl + ", '" + sost + "' " +
                        " from " + DbHelper.soc_list[vidWgrup] + " where sostav = '" + sost + "' and dubl_flag = 0; ");
//                Log.e(TAG, "f_socPoisk normal_connect sost = " + sost + " n1=" + n1 + " n2=" + n2 + " классов " + cntKl );
            }
      }
        cur1Soc.close();

        Log.d(TAG, "f_socPoisk  еще может быть найдено "+ (itNum - itNum0) + " нормальных подгрупп");

        return 0;
    }


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