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

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

import android.util.Log;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/*
f_primeConj

f_numToPrime
insert into params (parm, val_txt, val, ind)  values ('SnYes_g'

 gap> H:= AllAutomorphisms(G);
[ [ (4,5), (1,2), (1,3) ] -> [ (4,5), (1,2), (1,3) ],
  [ (4,5), (1,2), (1,3) ] -> [ (4,5), (1,3), (1,2) ],
  [ (4,5), (1,2), (1,3) ] -> [ (4,5), (1,2)(4,5), (1,3)(4,5) ],
  [ (4,5), (1,2), (1,3) ] -> [ (4,5), (1,3)(4,5), (1,2)(4,5) ],
  [ (4,5), (1,2), (1,3) ] -> [ (4,5), (2,3), (1,3) ],
  [ (4,5), (1,2), (1,3) ] -> [ (4,5), (1,3), (2,3) ],
  [ (4,5), (1,2), (1,3) ] -> [ (4,5), (2,3)(4,5), (1,3)(4,5) ],
  [ (4,5), (1,2), (1,3) ] -> [ (4,5), (1,3)(4,5), (2,3)(4,5) ],
  [ (4,5), (1,2), (1,3) ] -> [ (4,5), (2,3), (1,2) ],
  [ (4,5), (1,2), (1,3) ] -> [ (4,5), (1,2), (2,3) ],
  [ (4,5), (1,2), (1,3) ] -> [ (4,5), (2,3)(4,5), (1,2)(4,5) ],
  [ (4,5), (1,2), (1,3) ] -> [ (4,5), (1,2)(4,5), (2,3)(4,5) ] ]

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

    // curInd[i] = тек индексы в kuchi[ kuchLevel ][ curInd[] ] = _id куда переводит автоморф kuchFrom[ kuchLevel ]
            curInd[],
            kuchLevel = 0,  // номер уровня
            allKuch = 0;    // всего куч

accordance ???


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


                "create table IF NOT EXISTS temp_elements (" + // рабочая таблица для построения индесков точек графа (f_graphGetPointsIndex) и изоморфизмов
                        "_id	INTEGER  primary key autoincrement, " +  // код элемента
                        "id INTEGER," + //  id точки
                        "id_from INTEGER," + //  id до автоморфизма
                        "id_to INTEGER," + //  id после автоморфизма
                        "txt TEXT, " +  // []  - подстановка после автоморфизма
                        "iteration INTEGER, " +
                        "name TEXT" +   // новое вычисленное имя
                        ");",
Построение группы
                "create table IF NOT EXISTS temp_multiplication_a " + // таблица произведений (умножения) автоморфизмов
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_from INTEGER," + //  id произведения до автоморфизма
                        " idproiz INTEGER,  " +  // код элемента - произведения после автоморфизма
                        " idleft INTEGER NOT NULL, " + //  после автоморфизма
                        " idright INTEGER NOT NULL," + //  после автоморфизма
                        " flag_new INTEGER," + //  0 - новая подстановка иначе уже есть она в temp_elements
                        " name	TEXT," +         // новое вычисленное имя
                        " txt TEXT, " +  // []  - подстановка после автоморфизма
                        " iteration	INTEGER " +
                        "); ",
" + DbHelper.temp_multiplication[vidWgrup] + "
" + DbHelper.elements[vidWgrup] + "
" + DbHelper.normalizer[vidWgrup] + "
" + DbHelper.exponent[vidWgrup] + "
" + DbHelper.pairing_area[vidWgrup] + "
" + DbHelper.sylow_attachments[vidWgrup] + "
" + DbHelper.accordance[vidWgrup] + "
" + DbHelper.epimorphism[vidWgrup] + "

mApp.tableNameEnd
countElements_a


select  distinct  N.num
 from sylov_table N
  where N.num not in(
    select SI.num
        from  sylov_table SI, pairing_area PI,
             sylov_table SO, pairing_area PO, sub_scribe_a F
        where SI.id_s = PI.id_subs and SO.id_s = PO.id_subs and
           SO.id_s = substr(F.text_sub, 2 + 5*(SI.id_s - 1), 4) and
            not SI.num = SO.num
			)

 select distinct P.id_subs as _id,  P.num as num, S.num_maim as num_maim,
     E.ciklos as ciklos, P.class_area as class_area
   from  pairing_area P, sub_structure S, elements E
   where S.num_subs =  P.class_area and E._id = P.id_subs and
      S.num_maim = 3
       order by  S.num_maim asc, P.id_subs asc;



харктерист подгр
select distinct S.num_maim
 from  pairing_area P, sub_structure S
  where S.num_subs =  P.class_area and S.num_maim not in(
   select SI.num_maim as num_maim
    from  pairing_area PI, sub_structure SI, sub_scribe_a F,
		pairing_area PO, sub_structure SO
    where SI.num_subs =  PI.class_area and
        SO.num_subs =  PO.class_area and
          PO.id_subs = substr(F.text_sub, 2 + 5*(PI.id_subs - 1), 4) and
         not  SI.num_maim = SO.num_maim
)

   select SI.num_maim, SO.num_maim, F.text_sub
    from  pairing_area PI, sub_structure SI, sub_scribe_a F,
		pairing_area PO, sub_structure SO
    where SI.num_subs =  PI.class_area and
        SO.num_subs =  PO.class_area and
          PO.id_subs = substr(F.text_sub, 2 + 5*(PI.id_subs - 1), 4) and
         not  SI.num_maim = SO.num_maim




select distinct P.id_subs as _id,  P.num as num, S.num_maim as num_maim,\n" +
      E.ciklos as ciklos, E.sylow_num as sylow_num, E.center_num as center_num,  E.stabilizer as stabilizer,
       E.switchboard_num as switchboard_num,  E.substitution as substitution, E.deg as deg, P.class_area as class_area
    from  pairing_area P, sub_structure S, elements E
    where S.num_subs =  P.class_area and E._id = P.id_subs
     and S.num_maim = " + nomerPodgrup[0]
      order by  S.num_maim asc, P.id_subs asc;


select E._id, substr(F.text_sub, 2 + 5*(E._id - 1), 4), E.ciklos, A.ciklos, F.text_sub, 2 + 5*(E._id - 1) iii
from  elements E, elements_a A,  sub_scribe_a F
where F.id_s = A._id and A._id = 1

выбор сил подгруппы
select S.num, E.sylow_num, E._id, E.ciklos
 from elements E, sylov_table S
  where S.id_s = E._id
    S.num = 4
            " 9. 9  Нормализатор группы в Sn",    // 112
            " 9.11  Образы классов группы",    // 113
            " 9.12  Образы цикловых типов группы",   // 114
            " 9.13  Изменения цикловых типов группы при автоморфизмах",   // 115
            " 9. 8  Порядки подгрупп неподвижных элементов автоморфизмов", // 116




образ elements E (E._id) приотображении A._id = 1
select E._id, substr(F.text_sub, 2 + 5*(E._id - 1), 4), E.ciklos, A.ciklos, F.text_sub, 2 + 5*(E._id - 1) iii
from  elements E, elements_a A,  sub_scribe_a F
where F.id_s = A._id and A._id = 1

select E._id, substr(F.text_sub, 2 + 5*(E._id - 1), 4), E.ciklos, O._id oid, O.ciklos ociklos,
from  elements E, elements O, elements_a A,  sub_scribe_a F
where F.id_s = A._id and O._id = substr(F.text_sub, 2 + 5*(E._id - 1), 4) and  A._id = 1

select E._id, substr(F.text_sub, 2 + 5*(E._id - 1), 4) new_id, E.ciklos old_ciklos, O._id new_id, O.ciklos new_ciklos, A.ciklos aciklos
from  elements E, elements O, elements_a A,  sub_scribe_a F
where F.id_s = A._id and O._id = substr(F.text_sub, 2 + 5*(E._id - 1), 4) and  E._id = 1

select E._id,  E.ciklos old_ciklos, O._id new_id, O.ciklos new_ciklos, A.ciklos aciklos
from  elements E, elements O, elements_a A,  sub_scribe_a F
where F.id_s = A._id and O._id = substr(F.text_sub, 2 + 5*(E._id - 1), 4) and  E._id = 1

select A._id, A.ciklos aciklos, E._id old_id, O._id new_id, E.ciklos old_ciklos, O.ciklos new_ciklos,
E.pairing_num old_pairing, O.pairing_num new_pairing, E.cykl_len old_cykl_len, O.cykl_len new_cykl,
E.substitution old_s, O.substitution new_s, A.link_to_group, A.name
from  elements E, elements O, elements_a A,  sub_scribe_a F
where F.id_s = A._id and O._id = substr(F.text_sub, 2 + 5*(E._id - 1), 4) AND
 A._id = 4
 order by A._id asc, E._id asc



                "create table IF NOT EXISTS sub_scribe_n" + // text_sub есть substitution каждые 5 колонок занимает 1 переставляемая единица
                        " (_id INTEGER primary key autoincrement,  " +
                        "id_s  INTEGER NOT NULL, " +   //
                        "text_sub TEXT" +
                        "); ",
выбор норм подгруппы
select distinct P.id_subs as _id,  P.num as num, S.num_maim as num_maim,\n" +
      E.ciklos as ciklos, E.sylow_num as sylow_num, E.center_num as center_num,  E.stabilizer as stabilizer,
       E.switchboard_num as switchboard_num,  E.substitution as substitution, E.deg as deg, P.class_area as class_area
    from  pairing_area P, sub_structure S, elements E
    where S.num_subs =  P.class_area and E._id = P.id_subs
     and S.num_maim = " + nomerPodgrup[0]
      order by  S.num_maim asc, P.id_subs asc;
!!!!!
f_outOtl
action_grupp_vec    Доп расчеты"
        itemDpRas.setEnabled(mApp.tableNameEnd == "");


        db.execSQL("insert into params (parm, ind, val, val_txt) values('Автоморфизмы'," + DbHelper.faktSubsLen + ", " + i + ", 'Группа автоморфизмов построена для " + mApp.groupName + "');");

//  8. 3. Элементы порядки которых  = экспоненте",  //  97
            "select E._id _id, E.pe pe,  E.ciklos ciklos, E.deg deg, E.cykl_len cykl_len, E.sylow_num sylow_num, P.class_area as pairing_num, E.name as namee\n" +
                    "    from elements E, exponent Q, pairing_area P\n" +
                    "  where E.pe = Q.pe and E.deg = Q.val_exp and P.id_subs = E._id\n" +
                    "  order by E.pe asc, E.cykl_len asc;",
// 107 9. 4  Изменение циклового типа при автоморфизмах",    // 107
mApp.tableNameEnd ==

select  P.id_subs, P.num, P.id_subs
        from  pairing_area P, sub_structure S
       where  S.num_subs = P.class_area and
            S.num_maim = 5


   <string-array name="tableTmp">
        <item>sylov_cykl</item>
        <item>sylov_id</item>
        <item>sylow_tmp_conj</item>
        <item>pe_subgroup</item>
        <item>charac_group</item>
        <item>charac_class</item>
        <item>charac_cykls</item>
        <item>charac_sylow</item>
        <item>auto_cykls</item>
        <item>auto_class</item>
        <item>auto_group</item>
        <item>auto_sylow</item>
        <item>lines</item>
        <item>points</item>
        <item>pairing_multiplications</item>
        <item>normal_connect</item>
        <item>temp_sylow</item>
        <item>temp_pe</item>
        <item>temp_prim</item>
        <item>params</item>
        <item>generators_element</item>
        <item>generators_test</item>
        <item>auto_centralizer</item>
        <item>auto_normalizer</item>
        <item>normal_subgroup_a</item>
        <item>soc_subs_a</item>
        <item>soc_list_a</item>
        <item>elements_a</item>
        <item>sub_structure_a</item>
        <item>pairing_area_a</item>
        <item>sylov_common_a</item>
        <item>sylow_attachments_a</item>
        <item>exponent_a</item>
        <item>normalizer_a</item>
        <item>sylov_com_grup_a</item>
        <item>sylow_conj_a</item>
        <item>sylov_table_a</item>
        <item>centralizer_a</item>
        <item>centers_a</item>
        <item>epimorphism_a</item>
        <item>switchboard_a</item>
        <item>sub_summa_a</item>
        <item>sub_scribe_a</item>
        <item>temp_multiplication_a</item>
    </string-array>

    <string-array name="tableMain">
        <item>accordance</item>
        <item>soc_list</item>
        <item>sub_structure</item>
        <item>soc_subs</item>
        <item>epimorphism</item>
        <item>sylov_com_grup</item>
        <item>addition</item>
        <item>sylov_common</item>
        <item>sylow_conj</item>
        <item>sylow_attachments</item>
        <item>pairing_area</item>
        <item>sylov_table</item>
        <item>centralizer</item>
        <item>normal_subgroup</item>
        <item>exponent</item>
        <item>normalizer</item>
        <item>switchboard</item>
        <item>temp_multiplication</item>
        <item>sub_summa</item>
        <item>sub_scribe</item>
        <item>inputpods</item>
        <item>elements</item>
    </string-array>



gap>
765 — ID группы Матье M10 в библиотеке SmallGroup системы GAP.
primitiv
     select e1._id, e2._id
     from  elements e1, elements e2, switchboard M
     where M.id_switch = 10 and
	    M.id_left = e1._id and
		e2._id = M.id_right and
	   e1.deg * e2.deg = 8 AND
	   e1.pe =  2  and e2.pe =  2 AND
	   e1.sylow_num is null and e2.sylow_num is null
         order by e1.deg asc, e2.deg desc;  новое: группа диэдра для любого n  и циклическая  для любого n
--------------------------------------
транзитивность

Для абалевых силовских подгрупп их общие подгруппы не ищутся
------------------------------------

TblTmpName[]
tblMainName[]

сопряжение = подстановка на носителе
ratios  addition

faktSubsLen
FaktSubsLength
select L._id as _id, L.substitution as substitutionl, L.ciklos as ciklosL, R._id as rid, M._id as mid,  R.ciklos as ciklosR, M.ciklos as ciklosM, R.substitution as substitutionr, M.substitution as substitutionm,
      M.pairing_num as pairing_numm
   from switchboard S, elements L, elements R, elements M
    where L._id = S.id_left and R._id = S.id_right and M._id = S.id_pair
	  and S.id_left = 4
	order by S.id_right asc, S.id_pair asc ;
select id_left as lid, id_right as rid, id_pair as mid
     from switchboard
        order by id_left  asc, id_right  asc, id_pair asc;
select count(_id) as xxx, num from sylov_tabl
subgrups_n создается отдельно







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


сопряженные с группой в Sn подгруппы
select distinct E.id_true, E.ciklos, EE.id_true, EE.ciklos, EE.link_to_elements, R._id, R.ciklos,
  S.id_left, S.id_right, S.id_pair
  from elements_n E, switchboard_n S, elements_n EE, elements R
     where E.id_true = S.id_left and
            S.id_pair = EE.id_true and  S.id_right =  R._id
    order by 3 asc, 2 asc

select count(distinct idsopr) from (
select distinct E.id_true, E.ciklos, EE.id_true idsopr, EE.ciklos, EE.link_to_elements, R._id, R.ciklos,
  S.id_left, S.id_right, S.id_pair
  from elements_n E, switchboard_n S, elements_n EE, elements R
     where E.id_true = S.id_left and
            S.id_pair = EE.id_true and  S.id_right =  R._id
    )

			  and EE.ciklos = '(1,2)(3,5)'



f_socPoisk
insert into temp_pe (id_1, id_2, pe)
                select distinct S.num_maim as n1, T.num_maim as n2,  P.class_area
                    from  pairing_area P, pairing_area Q, sub_structure S, sub_structure T,
                         soc_list LP, soc_list LQ
                      where S.num_subs =  P.class_area and T.num_subs =  Q.class_area and
                       P.id_subs =  Q.id_subs and
                       LP.num_klass = S.num_maim and LQ.num_klass = T.num_maim and
                       LP.dubl_flag = 0 and LQ.dubl_flag = 0 and
                      S.num_maim <  T.num_maim and not P.id_subs = 7
                      order by S.num_maim asc, T.num_maim asc;
еще может быть найдено  forming

CREATE TABLE elements (_id	INTEGER  primary key autoincrement, name	TEXT,substitution TEXT NOT NULL,ciklos TEXT,deg INTEGER, pairing_num INTEGER, sylow_num TEXT, primitiv TEXT, forming TEXT, switchboard_num INTEGER, center_num INTEGER, stabilizer TEXT,cykl_len TEXT,pe INTEGER, iteration	INTEGER NOT NULL,parity INTEGER, nomer_soc INTEGER)
select substr(substitution, 2, instr(substitution, ',') - 2),instr(substitution, ','),  substitution, _id from elements


gap> G:=Group([(1,2,4,5),  (1,4,2,5)]);
Group([ (1,2,4,5), (1,4,2,5) ])
gap> IdGroup(G);
[ 24, 12 ]
gap> IsomorphismPermGroup(G);
IdentityMapping( Group([ (1,2,4,5), (1,4,2,5) ]) )
gap> G:=SmallGroup(24,12);
<pc group of size 24 with 4 generators>
gap> IsomorphismPermGroup(G);
[ f1, f2, f3, f4 ] -> [ (2,3), (2,3,4), (1,2)(3,4), (1,3)(2,4) ]

lineFlg

Порядок стабилизатора точ


 and N.for_n <= " + DbHelper.faktSubsLen + "\n" +
       ugolFi[j] = acos( axisX[0][j] * wKoeff[0][j]);

                     SQL =             "select distinct P.id_subs as _id,  P.num as num, S.num_maim as num_maim,\n" +
                            "        E.ciklos as ciklos, E.sylow_num as sylow_num, E.center_num as center_num,  E.stabilizer as stabilizer,\n" +
                            "        E.switchboard_num as switchboard_num,  E.substitution as substitution, E.deg as deg, P.class_area as class_area\n" +
                            "    from  pairing_area P, sub_structure S, elements E\n" +
                            "      where S.num_subs =  P.class_area and E._id = P.id_subs\n" +
                            " and S.num_maim = " + nomerPodgrup[0] + "\n" +
                            "      order by  S.num_maim asc, P.id_subs asc;";

                SelText = "select distinct '№ '|| num_maim  as stext from sub_structure order by stext asc;";




select  count(pairing_num) kkk,  cykl_len from (
select distinct  P.class_area as pairing_num, M.cykl_len as cykl_len
         from  elements M,  pairing_area P
        where  M._id = P.id_subs
		 )
		 		 GROUP by cykl_len
				 HAVING kkk > 1
 order by cykl_len asc, pairing_num;

сил подгруппы Sn
n=3  2-3  3-1
n=4  8-3  3-4
n=5 8-15  3-10  5-6
n=6 16-45  9-10   5-36













выбор сил подгрупп из Sn для k <= n

select S.pe, S.num,  E.ciklos, E.sylow_num, E.stabilizer
from elements E, sylov_table S
where S.id_s = E._id and S.num = 37 and instr(E.ciklos, '6') = 0 and instr(E.ciklos, '5') = 0
order by E.stabilizer asc


CREATE TABLE elements (_id	INTEGER  primary key autoincrement, name	TEXT,substitution TEXT NOT NULL,ciklos TEXT,deg INTEGER, pairing_num INTEGER, sylow_num TEXT, primitiv TEXT, forming TEXT, switchboard_num INTEGER, center_num INTEGER, stabilizer TEXT,cykl_len TEXT,pe INTEGER, iteration	INTEGER NOT NULL,parity INTEGER, nomer_soc INTEGER)
CREATE TABLE sylov_table  (_id INTEGER primary key autoincrement,  pe	INTEGER,num  INTEGER, id_main  INTEGER NOT NULL, id_s  INTEGER NOT NULL, effort INTEGER, parity INTEGER,  norm_nomer integer)

snFlg > 0 ? "id_true" : "_id"  id Sn или подгруппы когда флаг snFlg = 0

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





select idleft
 from switchboard
  where id_pair and idright

норм подгруппа
==========================
select 'Id= ' || M._id || '   ' || M.substitution || '   ' || M.ciklos  as stext
      from elements M, pairing_area P, sub_structure S20
      where M._id = P.id_subs  and S20.num_subs = P.class_area and
                 (S20.num_maim = 14)


select distinct ' ' || num_main from sub_structure
  order by num_main asc

                       " norm_nomer integer);", // временный номер норм поднруппы


update sylov_com_grup set norm_nomer = 1
  where sylov_com_grup.id_s in (
   select M._id
   from  elements M, pairing_area P, sub_structure S20
      where M._id = P.id_subs  and S20.num_subs = P.class_area and
                 S20.num_maim = 14
  )


select nn1, nn2 ss from (
    select S.nomer1 as nn1, S.nomer2 as nn2, sum(S.norm_nomer) ss
        from sylov_com_grup s
        group by S.nomer1, S.nomer2
       union all
    select S.num as nn1, 0 as nn2, sum(S.norm_nomer) ss
        from sylov_table s
        group by S.num
    )


delete from temp_pe;
=================================
  поиск нормальных подгрупп среди p-подгрупп

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  elements M, pairing_area P, sylov_com_grup 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

запись числа элементов по классам сопр эл-тов для полного класса
update temp_pe set (degs, list_num) = (
   select count(*), P.class_area from  pairing_area P
        where P.class_area = temp_pe.center_num
        group by P.class_area
   )


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

удалить подгруппы не являющихся нормальными
delete from temp_pe
  where (id_1, id_2) in (
   select id_1, id_2 from lines
   )

   final private static List<Integer> sylNum = new ArrayList<>(), // в соответствии с factSylNum найденные номера сил подгрупп
            factSylNum = new ArrayList<>(),     // настояший номер сил водгруппы
            sylSubNum = new ArrayList<>(), // в соответствии с factSubNum найденные номера общ сил подгрупп
            factSubNum = new ArrayList<>();     // настояший номер общ сил водгруппы

            factSylNum.add(k);  // soc_list.num_klass
            sylNum.add(n10);    // soc_list.sylow_num
            sylSubNum.add(n20); // soc_list.connon_sylow


delete from temp_pe;
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, 0 id_s, 0 degs, P.class_area, Y.sylow_zag
           from  elements M, pairing_area P, sylov_com_grup Y
            where M._id = P.id_subs and Y.id_s = M._id


 select distinct M.pe, Y.nomer1 id_1, Y.nomer2 id_2, 0 id_s, S20.num_maim degs, P.class_area, Y.sylow_zag
           from  elements M, pairing_area P, sub_structure S20, sylov_com_grup Y
            where M._id = P.id_subs  and S20.num_subs = P.class_area and
            Y.id_s = M._id





общая  p подгруппа
=============================
select 'Id= ' || M._id || ' ' || M.substitution || ' ' || M.ciklos  as stext
        from elements M, sylov_com_grup S
        where S.id_s = M._id  and S.nomer1 = 16 and S.nomer2 = 2

подгруппа силова  № 16
======================
select 'Id= ' || M._id || '   ' || M.substitution || '   ' || M.ciklos as stext
        from elements M, sylov_table S
        where S.id_s = M._id  and S.num = 16



центр силовсеой подгруппы
------------------------------
select distinct W.id_left, E.ciklos, count( distinct W.id_pair) sss
 from switchboard W, sylov_table S1, Elements E
   where W.id_pair = W.id_right and W.id_right = S1.id_s and S1.num = 5 AND
	 W.id_left = E._id
  group by W.id_left, E.ciklos
   having sss = 16
  order by E.ciklos



центр класса
------------------------------
select distinct W.id_left, E.ciklos, count( distinct W.id_pair) sss
 from switchboard W, Elements EM, Elements E
   where W.id_pair = W.id_right and W.id_right = EM._id and EM.pairing_num = 5 AND
	 W.id_left = E._id
  group by W.id_left, E.ciklos
   having sss = 3
  order by E.ciklos



select distinct  W.id_left, E.ciklos, count( distinct W.id_pair) sss
  from switchboard W, sylov_table S1 Elements E
     where W.id_pair = W.id_right and W.id_right = S1.id_s and S1.num = 3 AND
	 W.id_left = E._id
     group by  W.id_left, E.ciklos
	 HAVING sss = 8
 order by E.ciklos


update switchboard set work_field = 0;

update switchboard set work_field = (
  select S.id_s from sylov_table S where switchboard.id_left = S.id_s and S.num = 3
 )


  g:=SmallGroup(486,12);
 iso:=IsomorphismPermGroup(g);
g:=SmallGroup(166,1);
Image(iso, g.1);

размер подс
101 таблица temp_prim - структура силовской подгруппы
---------------------------------------------------------
select id_1  idl, id_s idmain, id_2 iditog, class0, classM, pe,  syl_g, syl_0,
 degn,  degg,  deg0,
  sw_g, sw_0,  sw_s,
   ciklos0, ciklosM, lystm, forming0  from (
  select id_1, id_s, id_2, P.class_area class0, null classM, G.pe, G.sylow_num syl_g, E.sylow_num syl_0,
   G.ndeg degn, G.deg degg, E.deg deg0,
   G.switchboard_num sw_g, E.switchboard_num sw_0, G.switchboard_s sw_s,
   E.ciklos ciklos0, null ciklosM, G.list_num lystm, E.forming forming0
 from temp_prim G, elements E, pairing_area P
   where E._id = G.id_s  and P.id_subs = E._id and G.id_2 = 0
  union all
select id_1, id_s, id_2, P.class_area class0, PM.class_area classM, G.pe, G.sylow_num syl_g, E.sylow_num syl_0,
G.ndeg degn, G.deg degg, E.deg deg0,
 G.switchboard_num sw_g, E.switchboard_num sw_0, G.switchboard_s sw_s,
  E.ciklos ciklos0, M.ciklos ciklosM, G.list_num lystm, E.forming forming0
 from temp_prim G, elements E, elements M, pairing_area P, pairing_area PM
   where E._id = G.id_s  and P.id_subs = E._id and PM.id_subs = M._id and M._id = G.id_2
) where syl_g = '023'
   order by id_s asc, id_1 asc, id_2 asc, syl_g asc

    and G.switchboard_num = 0

100 коммутант силовской подгруппы
select distinct M.sylow_num sylow_num, M.pe pe, M._id  _id, PM.class_area class, M.ciklos ciklos, M.cykl_len cl, M.deg deg, M.switchboard_num switch
      from switchboard S, elements L, elements R, elements M, pairing_area PM
         where L._id = S.id_left and R._id = S.id_right and M._id = S.id_switch and
          PM.id_subs = M._id and
          L.sylow_num = R.sylow_num and R.sylow_num = '023'
		 order by PM.class_area asc, M.deg asc,  M.cykl_len asc

select distinct M.sylow_num sylow_num, M.pe pe, M._id  _id, PM.class_area class, M.ciklos ciklos, M.cykl_len cl, M.deg deg, M.switchboard_num switch
      from switchboard S, elements M, pairing_area PM
         where S.id_left in (
            select L._id from elements L where L.sylow_num = '017'
         ) and S.id_right in (
            select R._id from elements R where R.sylow_num = '017'
         ) and M._id = S.id_switch and
          PM.id_subs = M._id
		 order by PM.class_area asc, M.deg asc,  M.cykl_len asc

гомоморфизм
select idleft, idright, idproiz,  ciklos, E.deg, forming, length(ciklos) lll  from elements E, temp_multiplication
  where E.pe > 0 and E._id = idleft
  order by E.deg desc, forming asc, length(ciklos) desc, idright asc, idleft asc;

insert into switch_prim (pe, sylow_num, id_switch, id_pair, id_left, id_right)
  select 3, 4, id_switch, id_pair, id_left, id_right
  from switchboard S, elements A, elements B
  where A._id = S.id_left and B._id = id_right and A.pe = 3 and B.pe = 3
Общая подгр

select id_switch as ccc from switchboard S, elements A,  elements B
  where S.id_left = A._id and S.id_right = B._id and
  A.pe = 2 and B.pe = 2 and id_switch = 118


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 temp_prim  (_id INTEGER primary key autoincrement,   pe INTEGER NOT NULL,    deg  INTEGER,  id_1  INTEGER,  id_2  INTEGER,  id_s  INTEGER,  ndeg INTEGER, switchboard_num INTEGER, switchboard_s INTEGER,  sylow_num text,  list_num  TEXT   )
CREATE TABLE sylov_id  (_id INTEGER primary key autoincrement,  id_s  INTEGER NOT NULL, num  INTEGER)
CREATE TABLE soc_tmp  (_id INTEGER primary key autoincrement,  k1 INTEGER,
k2 INTEGER,
k3 INTEGER,
k4 INTEGER,
k5 INTEGER,
k6 INTEGER,
k7 INTEGER,
k8 INTEGER,
k9 INTEGER,
k10 INTEGER,
k11 INTEGER,
k12 INTEGER,
k13 INTEGER,
count_klass INTEGER,  num INTEGER not null)

4  считаю число эл-тов в каждой подгруппе

insert into soc_tmp (k1, k2, num )
      select distinct T.id_1, T.id_2, sum(degs)
        from temp_pe T
        group by T.id_1, T.id_2
        order by T.id_1 asc, T.id_2 asc

3  выбираю классы для каждой возможной подгруппы с кол-вом эл-тов в каждом классе degs
insert into temp_pe (id_1, id_2, pe, degs )
      select distinct T.id_1, T.id_2, S.class_area, count( distinct S.id_subs)
        from temp_prim T, pairing_area S
        where S.class_area = T.pe
        group by T.id_1, T.id_2, S.class_area
        order by T.id_1 asc, T.id_2 asc, S.class_area asc


2.  приписываю классы S.num_subs к каждой возможной подгруппе для каждой новой комбинации
insert into temp_prim (id_1, id_2, pe, ndeg )
      select T.id_s, T.num, S.num_subs, 0
        from sylov_id T, sub_structure S
        where S.num_maim = T.id_s
        order by T.id_s asc, T.num asc, S.num_subs asc


insert into temp_prim (id_1, id_2, pe, ndeg )
    select distinct id_1, id_2, num_subs, 0 from (
      select T.id_1, T.id_2, S.num_subs
        from temp_pe T, sub_structure S
        where S.num_maim = T.id_1
           union all
      select T.id_1, T.id_2, S.num_subs
        from temp_pe T, sub_structure S
        where S.num_maim = T.id_2
     )

1. заношу всевозможные сочетания групп классов сопряженных элементов для 2-х, 3-х,... малых норм подгрупп
insert into sylov_id (id_s, num)
  select an, bn from (
     select distinct  A.num_maim an, B.num_maim bn
        from sub_structure A, sub_structure B, pairing_area PA, pairing_area PB
        where  A.num_maim < B.num_maim and
    PA.class_area = A.num_subs and PB.class_area = B.num_subs and
	A.num_maim > 1 and A.num_subs > 1 and B.num_subs > 1 and
	a.deg < 48 and B.deg < 48
	)





 */
public class substitutionS {
    // работа с подстановкой, зранилище основных переменных
    static private final String TAG = "GRUGRA_SUBS";
    static private final boolean DISPLAYLOG = false;

    static private final int MAXLEN = 100;  // мах длина множества переставляемых чисел
    static int punktSn = -1;  // = 1 строится группа Sn
    public mAplication mApp;
    static public  List<ClassNewSubs> newSubsMas = new ArrayList<ClassNewSubs>(); // массив объектов подстановок с флагом удаления

    public static String Edinica = "", // единица группы как [...]
            Edinica_n = "";
    public static int codEdinicy = 0, codEdinicy_n = 0, codEdinicy_a = 0;   // _id единицы группы
    public static int  nomSocSub = 1;  // № подгр цоколя (число подгрупп цоколя  + 1)
    static public String  sel2Multiplier; /* select выбора нормальных подгрупп (по классам ) для
     разложения группы в прямое произведение подгрупп вида  -  НЕ ИСПОЛЬЗУЕТСЯ
 select a.num_klass as num1, b.num_klass as num2
  from soc_list a,  soc_list b, soc_tmp at, soc_tmp bt
  where at.num =  a.num_klass and bt.num = b.num_klass and
   a.num_klass < b.num_klass and
   (a.deg * b.deg) = ... and  (at.k2 isNull or  bt.k2 isNull)
and  (at.k3 isNull or  bt.k3 isNull)
and  (at.k4 isNull or  bt.k4 isNull)
and  (at.k5 isNull or  bt.k5 isNull)
and  (at.k6 isNull or  bt.k6 isNull)
 */

    final public List< Integer> arrPrNumber = new ArrayList(); // массив простых чисел
    static private List<Integer> ODIN;  // единичная подстановка по размеру  MAXLEN

    static public List<String> epiEdinica = new ArrayList<>(),  // единица для образа при епиморфизме для pe по возрастанию
            epiEdinica_n = new ArrayList<>();
    static public List<Integer> epiPe = new ArrayList<>(),     // pe по возрастанию для образа при епиморфизме
            epiPe_n = new ArrayList<>();


    public void initSubstitutionS(mAplication mApp) {
        // инициализация объекта

        this.mApp = mApp;

        ODIN = new ArrayList();
        for (int i=0; i<MAXLEN; i++)
            ODIN.add(i+1);
        if (DISPLAYLOG)
            Log.e(TAG, " substitutionS create ");
    }


    public void f_createPrimeryNumber(int maxNum) {
        // создает arrPrNumber - массив простых чисел
        int indPN = 1, k, j;
        boolean ye;
        arrPrNumber.clear();
        k = mApp.dbH.f_getCountRow("select number as ccc from prime_number order by 1 asc;");

        if (k < maxNum) {   // заадано большее число , чем есть
            mApp.dbH.db.execSQL("delete from prime_number;");
            k = 0;
        }

        if (k == 0) {
            arrPrNumber.add(2);
            mApp.dbH.db.execSQL("insert into prime_number (number) values (2);");
            for (k = 3; k < maxNum + 25; k++) {
                ye = true;
                for (j = 0; j < indPN; j++) {
                    if (k % arrPrNumber.get(j) == 0) {
                        ye = false;
                        break;
                    }
                }
                if (ye) {
                    arrPrNumber.add(k);
                    mApp.dbH.db.execSQL("insert into prime_number (number) values (" + k + ");");
                    indPN++;
                }
            }
        } else {    // таблица простых чисел заполнена
            k = mApp.dbH.f_getMInt("select number as stext from prime_number order by 1 asc;");
            for (j = 0; j < k; j++)
                arrPrNumber.add(DbHelper.selectMasInt[j]);
        }
    }

    public String f_reverseSubstitution(String subsIn) {
        // возвращает обратную подстановку
        String subsRev;
        List<Integer> subsNew = new ArrayList(DbHelper.faktSubsLen); //  и результат - подстановки
        int subsArr [] = f_toArray(subsIn, DbHelper.faktSubsLen),
                subsM[] = new int[DbHelper.faktSubsLen], i;
        subsNew.clear();
        for (i = 0; i < DbHelper.faktSubsLen; i++)
            subsM[subsArr[i] - 1] = i + 1;   // обратная подстановка к subsL

        for (i = 0; i < DbHelper.faktSubsLen; i++)
            subsNew.add(subsM[i]);

        subsRev = subsNew.toString();
        //    Log.e(TAG, "f_reverseSubstitution subsIn="+ subsIn + " subsRev="  +subsRev );
        return subsRev;
    }

    // данные заносит DBH.f_getParm
    static public List<Integer> sylovPrimeGrupNum = new ArrayList<>(),  // pe - простые числа встречающиеся в порядке группы: 2, 3
            sylovPower = new ArrayList<>(), // порядки силовских подгрупп соотвественно и после расчета при графе
            sylovGraphNomer = new ArrayList<>(), // номера силовских подгрупп соотвественно только после расчета при графе: 3,4,5, (для pe=2)  1,2  (для pe=3)
            sylovOrderPe = new ArrayList<>(), // простые числа: 2, 2, 2, 3, 3 соответственно номерам силовских подгрупп в sylovGraphNomer
            sylovPrimeGrupPower = new ArrayList<>(); // их степени соотвественно (только при расчете)

    static public List<Integer> sylovPrimeGrupNum_n = new ArrayList<>(),  // pe - простые числа встречающиеся в порядке группы: 2, 3
            sylovPower_n = new ArrayList<>(), // порядки силовских подгрупп соотвественно и после расчета при графе
            sylovGraphNomer_n = new ArrayList<>(), // номера силовских подгрупп соотвественно только после расчета при графе: 3,4,5, (для pe=2)  1,2  (для pe=3)
            sylovOrderPe_n = new ArrayList<>(); // простые числа: 2, 2, 2, 3, 3 соответственно номерам силовских подгрупп в sylovGraphNomer

    public void f_numToPrime(int n) {
        // раскладывает n на простые числа,
        // записывается в sylovPrimeGrupNum, sylovPrimeGrupPower

        if (n <= 0) {
            mApp.putProt("Ошибка: Порядок группы / центра = 0");
            return;
        }

        int i=0, m, n1, q;
        sylovPrimeGrupNum.clear();
        sylovPrimeGrupPower.clear();
        do {    // проверяю содержит ли n очередное простое число q
//            Log.e(TAG, "f_numToPrime i="+ i + " arrPrNumber.size()="  + arrPrNumber.size() + " n = " + n );
            q = arrPrNumber.get(i);
            m = 0;
            do {    // вычисляю m = степень q в n
                n1 = n % q;
                if (n1 != 0)    // q не входит в n
                    break;
                else {
                    m++;    // степень простого q в n
                    n /=  q;
                }
                if (n == 1)
                    break;
            } while (true);
            if (m > 0) {
                sylovPrimeGrupNum.add(q);
                sylovPrimeGrupPower.add(m);
            }
            i++;
        } while (n != 1);
    }

    public int[] f_mnoj(int []  s1, int []  s2) {
        // возвращает s1 * s2
        int leng = DbHelper.faktSubsLen;
        int r[] = new int[leng]; // обычно DbHelper.faktSubsLen
        for (int i=0; i<leng; i++)
            r[i] = s2[s1[i] - 1];

        return r;
    }

    // общие временные переменные для 1 подстановки:
    static public int peInDeg = 0,  // f_calculateDeg устанавливает здесь простое число, если степень подстановки есть степень простого
            parity = 0, // четность подстановки: 0 для четной и 1 для нечетной подстановки
            primitivPower = 0;  // = 1 - подстановка subs = образующая силовской подгруппы - вычисляю ее степени
    public int f_calculateDeg( Boolean raschet) {
        // по массиву arrCiklLen вычисляет степень подстановки и устанавливает четность parity
        // должна вызываться после f_toIndependentCycle()
        // arrPrNumber, sylovPrimeGrupNum, sylovPrimeZNum  д б построено
        //  raschet = true - вызвана функция из f_createCykles
        //-----------------------------------------------
        peInDeg = parity = 0; // 0 для четной и 1 для нечетной подстановки (1,2,3,4) = (1,4)(2,4)(3,4)
        if (arrCiklLen.size() == 0) return 0;
        int p = arrCiklLen.get(0),  // всех циклов  arrCiklLen.get(j) или длина цикла, если подстановка = 1 цикл
                i, ii, j, degPods, n, n1, m, q;

        if (p == 0)  return 0; // для единицы группы
//        Log.e(TAG, "f_calculateDeg p="+ p + " arrCiklLen.size()="  + arrCiklLen.size() );

        List<Integer> primaryNum = new ArrayList<>();  // простые числа встречающиеся в циклах
        List<Integer> primaryPower = new ArrayList<>(); // их мах степени соотвественно

        for (j=0; j < arrCiklLen.size(); j++) { // цикл по циклам подстановки
            n =  arrCiklLen.get(j); // длина цикла
            if (n % 2 == 0 ) parity = parity == 0 ? 1 : 0;  // цикл четной длины - меняет четность (1,2,3,4) = (1,4)(2,4)(3,4)
//            Log.e(TAG, "f_calculateDeg j="+ j + " n="+ n + " parity=" + parity);

            i=0;
            do {    // проверяю содержит ли n очередное простое число q
//                Log.e(TAG, "f_calculateDeg i="+ i + " arrPrNumber.size()="  + arrPrNumber.size() + " n = " + n + " p = " + p );
                q = arrPrNumber.get(i);
                m = 0;
                do {    // вычисляю m = степень q в n
                    n1 = n % q;
                    if (n1 != 0)    // q не входит в n
                        break;
                    else {
                        m++;    // степень простого q в n
                        n /=  q;
                    }
                    if (n == 1)
                        break;
                } while (true);
                //           Log.e(TAG, "f_calculateDeg j="+ j + " показатель n="+ n + " простое q=" +q + " степнь q m="+m);

                if (m > 0) {    // есть число q  в n
                    for (ii = 0; ii < primaryNum.size(); ii++)
                        if (primaryNum.get(ii) == q) {  //  q уже было в степенях циклов подстановки
                            degPods = primaryPower.get(ii);
                            if (degPods < m)
                                primaryPower.set(ii, m); // запомнили показатель
                            m = 0;
                        }
                    if (m > 0) {// не найдено простое q среди запомненных простых в степени эл-та
                        primaryNum.add(q);  // добавить q в как присутствующее в степень цикла
                        primaryPower.add(m);
                    }
                }
                i++;
            } while (n != 1);
        }
        if (DISPLAYLOG)
            Log.e(TAG, "f_calculateDeg parity=" + parity);

        degPods = 1;
        for (j=0; j < primaryNum.size(); j++) {
            p = primaryNum.get(j);
            m = primaryPower.get(j);
            for (i=0; i<m; i++)
                degPods *= p;
//            Log.e(TAG, "f_calculateDeg k=" +k + " p=" + p + " m =" + m);
        }
        primitivPower = 0;
        if ( primaryNum.size() == 1) {
            peInDeg = primaryNum.get(0); // показатель элемента = степнь простого
            if (raschet) { // вызвана функция из f_createCykles
                i = sylovPrimeGrupNum.indexOf(peInDeg);
                Log.e(TAG, "f_calculateDeg i=" + i + " p= " + peInDeg + " primitivPower="+primitivPower);
                primitivPower = sylovPrimeGrupPower.get(i); // степень простого силовской подгруппы, если показатель = 1
            }
        }

        return  degPods;
    }

    public String f_ciklToSubs(String nameSubs, String ciklos) {
// конвертировать произведение НЕОБЯЗАТЕЛЬНО независимых циклов в формат   [x,x,...,x], что и заносит в DbHelper.arrInitSubs
// возвращает [....]

        DbHelper.arrInitName.add(nameSubs);
        //  Log.e(TAG, "f_ciklToSubs A nameSubs = " + nameSubs + " ciklos = " + ciklos );

        String cikl, leftSubs = "", curSubs;
        String [] subsTxtL, subsTxtR;
        int pos, j;
        int [] subsL = new int[MAXLEN],
                subsR = new int[MAXLEN];
        List<Integer>  subsNew = new ArrayList<>();
        do {
            pos = ciklos.indexOf(")"); // выделяю очередной цикл cikl
            if (pos > 0) {
                cikl = ciklos.substring(1, pos);    // 1-цикл
                ciklos = ciklos.substring(pos + 1); // остаток
                curSubs = f_oneCiklToSubs(cikl); // этот цикл в виде длинной строки
                if (leftSubs.length() > 0) {
                    leftSubs = leftSubs.substring(1, leftSubs.indexOf("]"));
                    subsTxtL = leftSubs.split(","); // массив строковых чисел цикла
                    for (j = 0; j < MAXLEN; j++)
                        subsL[j] = Integer.parseInt(subsTxtL[j].trim());

                    curSubs = curSubs.substring(1, curSubs.indexOf("]"));
                    subsTxtR = curSubs.split(","); // массив строковых чисел цикла
                    for (j = 0; j < MAXLEN; j++)
                        subsR[j] = Integer.parseInt(subsTxtR[j].trim());
                    // перемножение
                    subsNew.clear();
                    for (j = 0; j < MAXLEN; j++)
                        subsNew.add(subsR[subsL[j] - 1]);   // произведение L * R
                    leftSubs =  subsNew.toString();
                } else {
                    leftSubs = curSubs;
                }
            } else {
                if (ciklos.length() > 0) {
                    Log.e(TAG, "f_ciklToSubs Нет скобки ) nameSubs = " + nameSubs + " ciklos = " + ciklos + " leftSubs = " + leftSubs );
                    mApp.putProt("Нет скобки ) "+ ciklos);
                    DbHelper.err += "Нет скобки ) "+ ciklos;
                    return "";
                }
            }

        } while (ciklos.length() > 1);
        //       Log.e(TAG, "f_ciklToSubs nameSubs = " + nameSubs + " ciklos = " + ciklos + " leftSubs = " + leftSubs );
        DbHelper.arrInitSubs.add(leftSubs); // результат преобразования [x, ....]
        return leftSubs;
    }

    private String f_oneCiklToSubs( String cikl) {
// цикл один cikl преобразует к виду [...] и возвращает его
        int j, k, m, lenPods, maxCikl;
        List< Integer> arrCikl = new ArrayList(MAXLEN); // 1 цикл
        List< Integer> arrPods = new ArrayList(MAXLEN);
        String pods[];
        arrPods.addAll(ODIN);   // будет посстановка (цикл) в видк List от [...]
        pods = cikl.split(","); // массив строковых чисел цикла
        lenPods = pods.length;
        arrCikl.clear();    // цикл в виде List
        for (j = 0; j<lenPods; j++) {
            arrCikl.add(Integer.parseInt( pods[j].trim() ) );
        }

//        Log.e(TAG, " cikl = "  + cikl + " lenPods="+ lenPods);

        // теперь строю подстановку
        maxCikl = 0;
        for (j=0; j<lenPods; j++) {
            k = (int) arrCikl.get(j);
            if (maxCikl < k) maxCikl = k;
            if (j == lenPods - 1) m = (int) arrCikl.get(0);
            else m = (int) arrCikl.get(j + 1); // k->m
            arrPods.set(k-1, m);
//            Log.e(TAG, "k->m  " + k + " "+ m + " ===========");
        }
        DbHelper.maxNum.add(maxCikl);

//       Log.e(TAG, "f_oneCiklToSubs " + cikl + " = " + arrPods.toString());
        return arrPods.toString();    // [x,x,...,x]
    }

    public void f_setEdinica() {
        // устанавливает единичную подстановку
        List<Integer> e1 = new ArrayList<Integer>();
        for (int i=0; i<DbHelper.faktSubsLen; i++)
            e1.add(i+1);

        Edinica = e1.toString();
        mApp.putProt("Единица группы "+ Edinica);

    }

    public int[] f_toArray(String strSubs, int countSize) {
        // преобразовать текстовый вид подстановки [...] в массив
        int subsR[] = new int[countSize];
        strSubs = strSubs.substring(1, strSubs.indexOf("]"));  // убрать скобки
        String pods[] = strSubs.split(","); // массив строковых чисел цикла
        for (int j = 0; j < countSize; j++)
            subsR[j] = Integer.parseInt(pods[j].trim());
        return  subsR;
    }

    public String f_toStringSubs(int [] subs, int razmer) {
        // преобразовать int[] в текстовый вид
        List<Integer> subsNew = new ArrayList(razmer); //  и результат - подстановки
        subsNew.clear();
        for (int j = 0; j < razmer; j++)
            subsNew.add(subs[j]);   //
        return subsNew.toString();
    }

    public static List< Integer> arrCiklLen = new ArrayList(); // список длин непересекающихся циклов для текущей подстановки

    public String f_stab(int lenMas, int subs[]) {
        // возвращает строку стабилизаторов 1,2,3,...
        String ret = "";
        for (int i = 1; i<=lenMas; i++ )
            if (subs[i-1] == i) {
                if (ret.length() > 0)
                    ret += ", ";
                ret += (i + "");
            }
//  Log.e(TAG, "f_stab ret=" + ret);

        return ret;
    }
    public String f_toIndependentCycle(int legN, int subs[]) {
        // преобразовать подстановку в виде массива в произведение независимых циклов
        // заносит в arrCiklLen длины циклов
        //  subs ПОРТИТСЯ!!!
        String cyklos = "";
        int i, k, startNum, startInd = 0, lCikl = 0;
        boolean endSubs = false;
        arrCiklLen.clear();
        do {
            for (i = startInd; i < legN; i++ ) {
                k = subs[i];
                if (k > 0)
                    if (k != i + 1) break;
            }
            if (i == legN) {
                endSubs = true;
                continue;
            }
            startInd = startNum = i + 1;
            cyklos += "(" + (i + 1);
            do {
                k = subs[i];
                if (k !=  startNum)
                    cyklos += ", " + k;
                subs[i] = -1;
                i = k -1;
                lCikl++;
            } while (startNum != k);
            cyklos += ")";
            arrCiklLen.add(lCikl);
            lCikl = 0;
        } while (! endSubs);
        Collections.sort(arrCiklLen,  new ciklComparator());    // сортировка по убыванию как принято
//        Log.e(TAG, "f_toIndependentCycle dim= " + legN + " cyklos= " + cyklos + " l = " + subs[0]) ;

        return cyklos;
    }

    static class ciklComparator implements java.util.Comparator<Integer> {
        public int compare(Integer a, Integer b) {
            return b - a;
        }
    }

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