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

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


import android.util.Log;

import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class myOtchet {
    // создание отчетов
    static private final String TAG = "GRUGRA_OTCH";
    static private final boolean DISPLAYLOG = false;

    public final static String textSpinerAll [] = {
// "1. Основные отчеты", "2. По силовским подгруппам", "3. По четным подстановкам", "4. Таблицы умножения", "5. Вложение по Кэли", "6. Прочее"};
            " 1. 1.  *Все элементы группы упорядоченный по построению",            // 0
            " 1. 2.  *Все элементы группы с непересекающимся циклами по классам сопряженных элементов",           // 1
            " 2. 1.  *Все элементы группы по подгруппам Силова",  // Sylow           // 2
            "10. 1.  Заданные образующие группы",    // прочее           // 3
            "10. 2.  *Таблица умножения группы", // прочее           // 4
            " 6. 4.  Нормальные и характеристические подгруппы и их порядки",           // 5
            "10. 3.  *Вычисление коммутаторов с циклами",           // 6
            " 1. 4.  *Центр группы",           // 7
            " 2. 2.  *Число силовских подгрупп по простым", // Sylow           // 8
            " 2. 3.  *Число силовских подгрупп куда входят их общие элементы",      // 9
            " 2. 4.  *Подгруппы общих элементов силовских подгрупп", // Sylow           // 10
            " 2. 6.  *Порядки классов сопряженных элементов общих силовских подгрупп",         // 11
            " 2. 5.  *Элементы силовских подгрупп не всходящие в подгруппу четных подстановок",  // Sylow           // 12
            " 2. 7.  *Подгруппы силова",                          // 13 Sylow
            " 1. 5.  *Порядки классов сопряженных элементов",           // 14
            " 1. 6.  *Порядки классов сопряженных элементов без объединения центра",           // 15
            " 2. 8.  *Порядки силовских подгрупп",           // 16
            "10. 4.  *Сопряжение элементов степени простого порядка ",           // 17
            "10. 5.  *Вычисление сопряженных элементов",           // 18
            "10. 6.  *Произведения элментов степней одного простого которое не является степенью этого простого",    // 19
            "10. 7.  *Порядки централизаторов классов сопряженных элементов",     // 20
            "10. 8.  *Централизаторы представителей классов сопряженных элементов",   // 21
            "10. 9.  Все соотношерия между образующими",  // прочее            22
            "10.10. Координаты вершин построенного графа Кэли/визкализации группы ",   // прочее     23
            "10.11. Ребра построенного графа Кэли/визкализации группы",  // прочее           // 24
            " 2.10. *Элементы группы, не входящие в силовские подгруппы",       // 25
            " 3. 1. *Четные подстановки коммутантов",  //     26
            " 5. 1. Правое регулярное представление",            //  27
            " 5. 2. Отличия в регулярном представлении", //   28
            " 3. 2. *Таблица умножения четных подстановок" ,   //  29
            " 2.11. *Группировка общих силовских подгрупп (не включает e)",  // Sylow       30
            " 2.12. *Классы сопряженных элементов силовских подгрупп",        //            31
            " 2.13. *Классы сопряженных элементов не входящих в силовские подгруппы", // Sylow        32
            "10.14. Хранимые переменные группы",   // прочее           // 33
            " 4. 1. *Таблица умножения силовской подгруппы",     // Табл умнож            34
            " 4. 2. *Таблица умножения общей подгруппы силовских подгруппах",  // Табл умнож            35
            " 2.15. *Общие элементы в силовских подгруппах 2-го уровня",    //  36
            " 2.14. *Порядки P подгрупп по уровням вложенности",     // 37
            " 2.17. *Количество найденных P подгрупп по уровням",   // 38
            " 2. 9. *Количество сопрягающих элементов у силовских подгрупп",     // 39
            " 2.16. *Иерархия общих P подгрупп ",   // 40
            " 5. 3. Отличия в цикловых типах в регулярном представлении",    // 41
            " 1. 7. *Число элементов одного порядка в группе (спектр группы)",  // 42
            " 1. 8. *Число элементов одного циклового типа в группе",  // 43
            " 2.19. *Порядки найденных P-подгрупп",   // 44
            " 2.22. *Нормализаторы силовских подгрупп",  // 45
            " 4. 3. *Эпиморфизм на группу подстановок на силовских подгруппах",  // 46
            " 4. 4. *Образ при эпиморфизме на группу подстановок на силовских подгруппах",  // 47
            " 4. 5. *Ядро при эпиморфизме на группу подстановок на силовских подгруппах",  // 48 - все что переходит в 1 = порядок образа = 0
            " 4. 6. *Смежные классы при эпиморфизме на группу подстановок на силовских подгруппах",  // 49
            " 4. 7. Образы силовских подгрупп при эпиморфизме на группу подстановок на силовских подгруппах",  // 50
            " 4. 8. *Номера и порядки силовских подгрупп при эпиморфизме на группу подстановок на силовских подгруппах",  // 51
            "10.12. Образы образующих при эпиморфизме на группу подстановок на силовских подгруппах",  // 52
            "10.13. Перенумирация силовских подгрупп при эпиморфизме на группу подстановок на силовских подгруппах",  // 53
            " 4. 9. *Таблица умножения ядра при эпиморфизме на группу подстановок на силовских подгруппах",  // 54
            " 1. 9. Элементы основных подгрупп",    // 55
            " 1.10. Порядки основных подгрупп",        // 56
            " 1. 3. *Коммутант любого расчитанного уровня", // 57
            " 4.11. Таблица умножения коммутанта любого расчитанного уровня",  // 58
            " 6. 1. *Цоколь",   // 59
            " 6. 6. *Элементы нормальной подгруппы", // 60 pairing_area
            " 6. 2. *Состав и порядки нормальных подгрупп", // 61 soc_list
            " 1.11. *Элементы группы по цикловому типу", // 62
            " 6.12. Таблица умножения цикловых типов с числом элементов (общий центр)", // 63
            " 6. 9. *Разложение группы и подгрупп в прямое произведение подгрупп",   // 64
            " 6. 5. *Вложенность нормальных подгрупп",    // 65
            " 6. 7. *Порядок подгруппы как состоящую из классов" ,   // 66
            " 6.10. *Таблица умножения класcов подгруппы (центр не объединяется)",    // 67
            " 6. 8. *Порядки нормальных подгрупп по классам",    // 68
            " 6.11. Классы, получающиеся при умножении элементов одного класса",    // 69
            " 7. 6. Силовская подгруппа в составе Sn",  // 70
            " 7. 3. Классы группы в классах Sn с элементами",    // 71
            " 7. 4. Порядки классов группы в классах Sn (пересечение)",         // 72
            " 1.12. *Классы элементов одного порядка (в спектре группы)",  // 73
            " 7. 9. Классы группы и Sn",     // 74
            " 7. 1. Элементы группы не содержащиеся в Sn",  // 75
            " 7. 5. Пересечение группы с Sn",  // 76
            " 7. 7. Порядки P подгрупп подгруппы и Sn",  // 77
            " 7. 2. Как подгруппа в Sn ",                   //  78
            " 7. 8. Общие элементы силовских подгрупп",  // 79
            " 2.21. *Число p-элементов по классам со степенями",    // 80
            " 2.18. *Классы по степеням элементов с силовскими подгруппами",  // 81
            " 2.20. *Число сопрягающих элементов силовских подгрупп по классам",  // 82
            " 1.13. *Классы стабилизаторов",      // 83
            " 2.23. *Порядки нормализаторов силовских подгрупп",   // 84
            " 4.12. *Порядки ядра и образа при эпиморфизме на силовские подгруппы",    // 85
            " 1.14. *Не сопряженные классы",        //  86
            " 1.15. *Не сопряженные подстановки одного класса",   // 87
            " 7.10. Спектр группы и Sn",          // 88
            " 7.11. Спектр в разрезе классов",        // 89
            " 6. 3. *Состав нормальных подгрупп с цикловыми типами", // 90 soc_list
            " 7.12. Классы стабилизаторов группы и Sn",   // 91
            " 4.13. Таблица умножения цикловых типов группы",    //  92
            " 8. 1. *Экспоненты",  //  93
            " 4.14. Таблица умножения цикловых типов p-элементов группы",    //  94
            " 4.10. Таблица умножения цикловых типов p-элементов Sn",    //  95
            " 8. 2. Экспоненты Sn",  //  96
            " 8. 3. *Элементы порядки которых = экспоненте",  //  97
            " 7.13. Силовские подгруппы в Sn",  //  98
            " 7.14. Отдельная силовская подгруппа группы в силовских подгруппах Sn (без e)",  //  99
            " 8. 4. *Коммутант силовской подгруппы",      // 100
            " 8. 5. Структура силовской подгруппы",           // 101
            " 8. 6. *Разбиение классов",              // 102
            " 1.16. *Порядки классов в разрезе цикловых типов",            // 103
            " 9. 1  Группа автоморфизмов",           // 104
            " 9. 2  Группа внутренних автоморфизмов",   // 105
            " 9. 3  Порядки силовских подгрупп группы автоморфизмов",    // 106
            " 9.16  Изменение циклового типа при автоморфизмах",    // 107
            " 9. 4  Действие выбранного автоморфизма",    // 108
            " 9. 5  Действие всех автоморфизмов на выбранный элемент группы",    // 109
            " 9. 6  Подгруппы неподвижных элементов автоморфизмов ",    // 110
            " 9. 9  Централизатор группы в Sn ",    // 111
            " 9. 8  Нормализатор группы в Sn",    // 112
            " 9.11  Образы классов группы",    // 113
            " 9.12  Образы цикловых типов группы",   // 114
            " 9.13  Характеристические подгруппы ",   // 115
            " 9. 7  Порядки подгрупп неподвижных элементов автоморфизмов", // 116
            " 9.14  Образы нормальных подгрупп",  //      117
            " 9.15  Образы силовских подгрупп",  //      118
            " 9.15a Образы силовских подгрупп с автоморфизмами",  //      119
            " 9.12a Образы цикловых типов с автоморфизмами",  //      120
            " 9.11a Образы классов с автоморфизмами",  //      121 - 19
            " 9.17  Нормальные подгруппы группы автоморфизмов их порядки",  //      122
            " 9.18  Внутренние автоморфизмы",  //      123
/*
            " 1. 9. Элементы основных подгрупп",    // 55
            " 1.10. Порядки основных подгрупп",        // 56
 */
//             " 6. 4.  Нормальные и характеристические подгруппы и их порядки",           // 5
    };


    // textSpiner - список названий отчетов, для каждого вида настраивается в f_init
    static public List<String> textSpiner;

    static public String[]  zag,    // заголовки колонок
            from;                //  колонки select
    static public int[]  to;    // колонки отчета
    static public int dbItem,  colCount = 0;   // число колонок

    myOtchet() {
    }
    public void f_init( int typOtch) {
        // настройка на вид отчета выбран typOtch
        int i;
        String ns = "";

        textSpiner = new ArrayList<>();

        for (i = 0; i<textSpinerAll.length; i++) {
            ns = textSpinerAll[i].substring(0, textSpinerAll[i].indexOf("."));
            if (Integer.parseInt(ns.trim()) == typOtch)
                textSpiner.add(textSpinerAll[i]);
        }
        Collections.sort(textSpiner);

    }

    public void f_create(int index) {
        // создание колонок sql, колонок (zag, from, to, dbItem, colCount )
        //  index - индекс отчета в  textSpinerAll
        if (DISPLAYLOG)
            Log.e(TAG, "f_create index = "+index);
        switch (index) {
            case 0:
//  1          "select _id,  sylow_num,  pe, deg, forming, primitiv, name,  ciklos, cykl_len, substitution, pairing_num, center_num, switchboard_num, stabilizer, iteration, parity, nomer_soc  from elements order by _id asc;",
                zag = new String[]{"Id", "Номер итерации, когда создан", "№ группы силова", "P", "Порядок эл-та",  "Является степенью цикл силовской подгруппы",
                        "Выражение через образующие", "Вид в циклах", "Цикл тип", "Подстановка",
                        "№ класса сопр эл-тов", "Порядок центализатора элемента", "№ коммутанта", "Стабилизатор для", "0 - четная", "Входит в цоколь ?"};
                from = new String[]{"_id", "iteration", "sylow_num", "pe", "deg",  "primitiv", "name", "ciklos", "cykl_len", "substitution",
                        "pairing_num", "center_num", "switchboard_num", "stabilizer", "parity", "nomer_soc"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14, R.id.db15, R.id.db16};
                colCount = 16;    // колонок в таблиц
                dbItem = R.layout.db_item19;
                break;
            case 1:
// 2 "select _id,  pairing_num, name, substitution, ciklos, deg, pe, forming, primitiv, sylow_num, cykl_len, center_num, switchboard_num, stabilizer, iteration, nomer_soc  from elements order by pairing_num asc;",
                zag = new String[]{"Id", "№ класса сопряженных эл-тов", "Выражение через образующие", "Подстановка", "Вид в циклах", "Порядок элемента", "P",
                        "Является степенью цикл силовской подгруппы", "Входит в подгруппу силова с №", "Цикленный тип", "Порядок централизатора", "№ коммутанта", "Стабилизатор для", "Получен на итерации", "0 - четная", "Входит в цоколь ?"};
                from = new String[]{"_id", "pairing_num", "name", "substitution", "ciklos", "deg", "pe",  "primitiv", "sylow_num", "cykl_len", "center_num", "switchboard_num", "stabilizer", "iteration", "parity", "nomer_soc"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14, R.id.db15, R.id.db16};
                colCount = 16;    // колонок в таблицк
                dbItem = R.layout.db_item19;
                break;
// 3
            case 2: //  "select _id,  sylow_num,  pe, deg, forming, primitiv,
                // name,  ciklos, cykl_len, substitution, pairing_num, center_num, switchboard_num, stabilizer, iteration, nomer_soc  from elements order by sylow_num asc, deg asc, forming asc;",
                zag = new String[]{"Id", "№ группы силова", "P", "Порядок эл-та", "Является степенью цикл силовской подгруппы",
                        "Выражение через образующие", "Вид в циклах", "Цикл тип", "Подстановка",
                        "№ класса сопр эл-тов", "Порядок центализатора элемента", "№ коммутанта", "Стабилизатор для", "Номер итерации, когда создан", "0 - четная", "1 - входит в цоколь"};
                from = new String[]{"_id", "sylow_num", "pe", "deg", "primitiv", "name", "ciklos", "cykl_len", "substitution",
                        "pairing_num", "center_num", "switchboard_num", "stabilizer", "iteration", "parity", "nomer_soc"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14, R.id.db15, R.id.db16};
                colCount = 16;    // колонок в таблицк
                dbItem = R.layout.db_item19;
                break;
            case 3:
// 4            "select E._id as _id,  I.name as name, I.substitution as substitution, E.ciklos as ciklos, E.deg as deg, E.switchboard_num as switchboard_num, E.center_num as center_num "+
                from = new String[]{"_id", "name", "substitution", "ciklos", "deg", "switchboard_num", "center_num"};
                zag = new String[]{"Id", "Имя", "Подстановка", "в циклах", "Порядок", "№ коммутанта", "Порядок централизатора"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7};
                colCount = 7;
                dbItem = R.layout.db_item7;
                break;

            case 4:
/*  5   Таблица умножения",
        "select  L._id as _id, L._id as idl, R._id as idR, E._id as idm, L.name as namel, R.name as namer, E.name as namem, L.ciklos as ciklosl, " +
            "   R.ciklos as ciklosr, E.ciklos as ciklosm, " +
                    "L.cykl_len as lcykll, R.cykl_len as lcyklr, E.cykl_len as lcykle, " +
            "   L.deg as degl, R.deg as degr, E.deg as degm, M.iteration   "+
*/
                from = new String[]{"idl", "idR", "idm", "namel", "namer", "namem", "ciklosl", "ciklosr", "ciklosm",
                        "lcykll", "lcyklr", "lcykle", "degl", "degr", "degm", "iteration"};
                zag = new String[]{"Id левой", "Id правой", "Id произведения", "Выражение через образующие 1-го множителя", "Выражение через образующие 2-го множителя", "Выражение через образующие произведения",
                        "1-й в циклах", "2-й множитель", "Результат в циклах",
                        "1-й Цикл тип", "2-й Цикл тип", "Результат Цикл тип",
                        "Порядок 1-го множителя", "Порядок 2-го множителя", "Порядок произведения", "№ итерации"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14, R.id.db15, R.id.db16};
                colCount = 16;
                dbItem = R.layout.db_item16;
                break;

            case 5:
/* 5   6. 4.  Нормальные и характеристические подгруппы и их порядки
 "select 0 as _id,  num,  sum(ccc) as itog_sub, sum(carac) as charc from (\n" +
                    "  select  S.num_maim as num, count( P.id_subs ) as ccc, 0 as carac\n" +
                    "     from pairing_area P, sub_structure S\n" +
                    "        where P.class_area = S.num_subs\n" +
                    "     group by S.num_maim\n" +
                    "         union all\n" +
                    "  select  S.num_subs as num, 0 as ccc, 1 as carac\n" +
                    "   from charac_group S\n" +
                    " ) group by num   \n" +
                    " order by num asc;",
     */
                zag = new String[]{ "№ подгруппы", "Порядок подгруппы", "Характеристическая?"};
                from = new String[]{"num", "itog_sub", "charc"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;
                dbItem = R.layout.db_item3;
                break;

            case 6:
// 7 "select L._id, L.name as namel, L.substitution as substitutionl, L.ciklos as ciklosl, R.name as namer, R.substitution as substitutionr, R.ciklos as ciklosr, S.name as namem, S.substitution as substitutionm, S.ciklos as ciklosm "+
                from = new String[]{"namel", "substitutionl", "ciklosl", "namer", "substitutionr", "ciklosr", "namem", "substitutionm", "ciklosm"};
                zag = new String[]{"Выражение через образующие левой подстановки", "Левая подстановка", "Левая подстановка в циклах",
                        "Выражение через образующие правой подстановки", "Правая подстановка", "Правая подстановка в циклах", "Выражение через образующие коммутатора", "Коммутатор", "Коммутатор в циклах"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9};
                colCount = 9;
                dbItem = R.layout.db_item9;
                break;

            case 7:
// 8 select _id, name, substitution, deg, ciklos, iteration from elements where center_num = "+ 0 + " order by ciklos asc;"
                from = new String[]{"_id", "name", "substitution", "ciklos", "deg", "iteration"};
                zag = new String[]{"Id", "Выражение через образующие подстановки", "Подстановка", "в циклах", "Порядок элемента", "Итерация"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item6;
                break;
            case 8:
 /*  9 // 8  (9) Число силовских подгрупп по простым"
            "select 0 as _id, pe, sum(ccc0) as count0, sum(ccc2) as count2 from (\n" +
                    "select pe, count(distinct num) as ccc0, 0 as ccc2 from sylov_table \n" +
                    "\tgroup by pe \n" +
                    " union\n" +
                    "select pe, 0 as ccc0, count(distinct num) as ccc2 from sylov_table \n" +
                    "\twhere parity = 0\n" +
                    "\tgroup by pe \n" +
                    "  )   group by pe \n" +
                    "  order by pe asc; ; ",
 */
                from = new String[]{"pe", "count0", "count2"};
                zag = new String[]{"P", "Число Силовских подгрупп группы", "Число Силовских подгрупп подгруппы четных подстановок"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;
                dbItem = R.layout.db_item3;
                break;
            case 9:
/*   Число силовских подгрупп куда входят их общие элементы
            "select C._id as _id, C.pe as pe, E.sylow_num as sylow_num, C.id_s as id_s, E.ciklos as ciklos, E.deg as deg, C.count_id as count_id\n" +
               "from sylov_common C, elements E " +
                    "where E._id = C.id_s and C.parity = 0 " + // parity= 0 - вся группа, parity = 1 - четная часть
                    "order by C.pe asc, C.id_s asc; ",
                 */
                from = new String[]{"pe", "sylow_num", "id_s", "ciklos", "deg", "count_id"};
                zag = new String[]{"P", "№ силовских подгрупп","Id общей подстановки для силовских подгрупп этого простого",
                        "Цикл вид", "ее порядок",
                        "число силовских подгрупп в которые она входит"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item6;
                break;

            case 10:
/*          " Подгруппы общих элементов силовских подгрупп",
            "select G._id as _id, G.pe as pe, G.sylow_zag as sylow_zag, G.id_s as id_s,  E.parity as parity, " +
                    "E.cykl_len as cykl_len, E.ciklos as ciklos, E.pairing_num as pairing_num, G.nomer1 as nomer1, G.nomer2 as nomer2, E.deg as deg " +
                    "from sylov_com_grup G, elements E\n" +
                    "where G.id_s = E._id\n" +
                    "order by G.pe asc, G.nomer1 asc,  G.nomer2 asc, G.sylow_zag asc, G.id_s asc\n",
                zag = new String[]{"P", "№ силовских подгрупп","Id общей подстановки для силовских подгрупп этого простого",
                        "Четность"," № подгруппы", "Уровень вложенности", "ее порядок",
                        "Цикл тип", "Цикл вид", "Кд", "", "", "число силовских подгрупп в которые она входит"};
*/

                from = new String[]{"pe", "nomer1", "nomer2", "sylow_zag", "id_s", "cykl_len", "ciklos", "pairing_num", "deg", "parity"};
                zag = new String[]{"P", "№ подгруппы", "Уровень вложенности", "Подгруппы, куда входит", "Id общей подстановки",
                        "Цикленный тип", "Циклы", "№ класса сопряженных эл-тов", "Порядок элемента", "0 - четная подстановка"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10};
                colCount = 10;
                dbItem = R.layout.db_item11;
                break;

            case 11:
/* 11  2. 6.  Порядки классов ссопряженных элементов общих элементов силовских подгрупп
select  0 as _id, pe, nomer2, nomer1, pairing_num, cykl_len, count(distinct Eid) as ccc from (
select  E.pe as pe, G.nomer2 as nomer2, G.nomer1 as nomer1, P.class_area as pairing_num, E.cykl_len as cykl_len, E._id Eid
                      from elements E, sylov_com_grup G, pairing_area P
                      where  E._id = G.id_s  and P.id_subs = E._id and E.pe > 0
	union all
	 select  E.pe as pe, null nomer2, null nomer1, P.class_area as pairing_num, 'всего в классе'  cykl_len, E._id  Eid
         from elements E, pairing_area P
         where E._id = P.id_subs and  E.pe > 0
       )
     group by pe, pairing_num, cykl_len, nomer2, nomer1
  order by pe asc, pairing_num asc, nomer2 desc, nomer1 asc
*/
                from = new String[]{"pe", "nomer2", "nomer1", "pairing_num", "cykl_len", "ccc"};
                zag = new String[]{"P", "Уровень вложенности подгруппы", "№ прогруппы", "Класс", "Цикленный тип", "Эл-тов в классе"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item6;
                break;

            case 12:
 /* "12 Элементы силовских подгрупп не всходящие в подгруппу четных подстановок
            "select distinct 0 as _id, C.pe as pe, C.num as num, C.id_s as id_s, E.ciklos as ciklos, E.deg as deg\n" +
                    "                   from sylov_table C, elements  E \n" +
                    "                   where E._id = C.id_s and C.parity = 1 \n" +
                    "                   order by C.pe asc, C.id_s asc; ",
                 */
                from = new String[]{"pe", "num", "id_s", "ciklos", "deg"};
                zag = new String[]{"P", "№ силовской подгруппы", "Id подстановки",
                        "Циклы подстановка", "ее порядок"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5};
                colCount = 5;
                dbItem = R.layout.db_item5;
                break;

            case 13:
/* 13 Подгруппы Силова
                    SQL =   "select S.effort effort, S.pe as pe, S.num as num, E._id as _id, E.name as namee, E.cykl_len cykl_len, E.ciklos as ciklos, E.deg as deg, P.class_area as pairing_num, E.forming as forming, E.primitiv as primitiv, E.center_num as center_num,\n" +
                            "    E.switchboard_num as switchboard_num, E.parity as parity, E.nomer_soc as nomer_soc\n" +
                            "   from elements E, sylov_table S, pairing_area P\n" +
                            "      where S.id_s = E._id and P.id_subs = E._id and\n" +
                            "        S.num = " + nomerPodgrup[0] + " \n" +
                            "       order by  S.pe asc, S.num asc, E.cykl_len asc; ";
  */
                zag = new String[]{"P", "№ подгруппы Силова",
                        "Id", "Выражение через образующие", "Цикл тип",  "Вид в циклах", "Порядок элемента", "№ класса сопряженных эл-тов", "№ класса в подгруппе",
                        "Является степенью цикл силовской подгруппы", "порядок централизатора", "№ коммутанта", "0 - четная подстановка", "Входит в цоколь"};
                from = new String[]{"pe", "num", "_id", "namee", "cykl_len",  "ciklos", "deg", "pairing_num", "effort", "primitiv", "center_num", "switchboard_num", "parity", "nomer_soc"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14};
                colCount = 14;    // колонок в таблицк
                dbItem = R.layout.db_item15;
                break;
            case 14:
//  14          "select 0 as _id, num,  sum(cc) as ccc, sum(pp) as ppp from (
//select pairing_num as  num, 1 as cc, 0 as pp from elements
//  union all
//select pairing_num as  num, 0 as cc, 1 as pp from elements
// where parity = 0
//)
//group by num
//order by num asc",
                zag = new String[]{"№ класса сопряженных элементов ", "Порядок класса", "В т. ч. четных подстановок"};
                from = new String[]{"num", "ccc", "ppp"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;    // колонок в таблицк
                dbItem = R.layout.db_item3;
                break;
            case 15:
/* 15 Порядки классов сопряженных элементов без объединения центра"
select 0 as _id, klass,  num, cykl_len, sum(cc) as ccc, sum(pp) as ppp from (
select P.class_area as klass, P.num as num, 1 as cc, 0 as pp, E.cykl_len as cykl_len from pairing_area P, elements E
 where P.id_subs = E._id
  union all
select P.class_area as klass, P.num as num, 0 as cc, 1 as pp, E.cykl_len as cykl_len from pairing_area P, elements E
 where E.parity = 0 and P.id_subs = E._id
)
group by num, klass, cykl_len
order by klass asc
 */
                zag = new String[]{"№ класса сопряженных элементов ", "Цикл тип", "Порядок класса",  "В т. ч. четных подстановок", "№ подгруппы цоколя"};
                from = new String[]{"klass", "cykl_len", "ccc", "ppp", "num"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5};
                colCount = 5;    // колонок в таблицк
                dbItem = R.layout.db_item5;
                break;

            case 16:
/*  2. 8.  Порядки силовских подгрупп",            16
            "select num, pe, count(id_s) as ccc\n" +
                    "                from sylov_table\n" +
                    "                group by  num, pe\n" +
                    "                order by pe asc, num asc;",

*/
                zag = new String[]{"P", "№ подгруппы", "Порядок подгруппы"};
                from = new String[]{"pe", "num", "ccc"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;    // колонок в таблиц
                dbItem = R.layout.db_item3;
                break;

            case 17:
/*  18  id_pair  код сопряженного элемента = (idleft**-1) * idright * idleft
                "select W._id as _id, E1.pe as pe, E1.sylow_num as sylow_num, W.id_left as id_left, W.id_right as id_right, W.id_pair as id_pair, \n" +
                    "E0.deg as deg0, E1.deg as deg1,  "+
                    "E0.ciklos as ciklos0, E1.ciklos as ciklos1, E2.ciklos as ciklos2, \n" +
                    "E0.name as name0, E1.name as name1, E2.name as name2, "+
            " E0.pairing_num as pairing_num0, E1.pairing_num as pairing_num1, E2.pairing_num as pairing_num2 "+
            "from  switchboard W, elements E0, elements E1, elements E2 \n" +
                    "where e0._id = W.id_left and E1._id = W.id_right and E2._id = W.id_pair and not E1.pe = 0\n" +
                    "order by  E0.pe asc, E0.sylow_num asc, W.id_right asc\n;",
 */
                zag = new String[]{"P", "№ ссиловской подгруппы", "Id сопрягающей подстановки", "Id исходной", "Id сопряженной",
                        "Степень сопрягающей", "Степень исходной",
                        "Циклы сопрягающей", "Циклы исходной", "Циклы сопряженной", "Имя сопрягающей", "Имя исходной", "Имя сопряженной",
                        "№ класса сопр элементов сопрягающей", "№ класса сопр элементов исходной", "№ класса сопр элементов сопряженной",};
                from = new String[]{"pe", "sylow_num", "id_left", "id_right", "id_pair", "deg0", "deg1",
                        "ciklos0", "ciklos1", "ciklos2",
                        "name0", "name1", "name2", "pairing_num0", "pairing_num1", "pairing_num2"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14, R.id.db15, R.id.db16};
                colCount = 16;    // колонок в таблицк
                dbItem = R.layout.db_item16;
                break;
            case 18:
/*  15     "select L._id as _id, R._id as rid, M._id as mid, L.name as namel, L.substitution as substitutionl, L.ciklos as ciklosl, R.name as namer, R.substitution as substitutionr, R.ciklos as ciklosr, M.name as namem, M.substitution as substitutionm,  M.ciklos as ciklosm, "+
                    "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 order by M.pairing_num asc, L._id asc; ",
    id_pair  код сопряженного элемента = (idleft**-1) * idright * idleft
*/
                from = new String[]{"pairing_numm", "rid", "_id", "mid", "namer", "substitutionr", "ciklosr", "namel", "substitutionl", "ciklosl",
                        "namem", "substitutionm", "ciklosm"};
                zag = new String[]{"Номер класса сопряженных элементов",
                        "Id", "Id чем сопряжена", "Id сопряженной", "Выражение через образующие подстановки", "Подстановка", "В циклах", "Чем сопряжена - выражение", "Чем сопряжена - подстановка", "В циклах",
                        "Сопряженная подстановка - выражение", "Сопряженная подстановка", "В циклах"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13};
                colCount = 13;
                dbItem = R.layout.db_item13;
                break;
            case 19:
/*  16             "select m._id as _id, e1.pe as pe, m.idleft as idleft, m.idright as idright, m.idproiz as idproiz, e1.deg as deg1, e2.deg as deg2, e0.deg as deg0, \n" +
                    " e1.ciklos as ciklos1 , e2.ciklos as ciklos2 , e0.ciklos as ciklos0, "+
                    "e1.name as name1, e2.name as name2, e0.name as name0  \n" +
            "from temp_multiplication m, elements e1, elements e2, elements e0 \n" +
                   "where e1._id = m.idleft and e2._id = m.idright and e0._id = idproiz and \n" +
                   "    e1.pe = e2.pe  and not e0.pe = e1.pe and not e1.pe = 0 and not e0.deg = 0 " +
                   "order by e1.pe asc,  e0.deg asc,  e1.deg asc;",
 */
                zag = new String[]{"P", "Id левой", "Id правой", "Id произведения", "Cтепень левой", "Cтепень правой", "Степень произведения",
                        "Левая", "Правая", "Произведение",
                        "Имя левой", "Имя правой", "Имя произведения"};
                from = new String[]{"pe", "idleft", "idright", "idproiz", "deg1", "deg2", "deg0",
                        "ciklos1", "ciklos2", "ciklos0",
                        "name1", "name2", "name0"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13};
                colCount = 13;    // колонок в таблицк
                dbItem = R.layout.db_item13;
                break;
/* 20
   "Порядки централизаторов  классов сопряженных элементов",
            "select DISTINCT 0 as _id, pairing_num, count_permutation, count_pairing from centers order by pairing_num asc;",
*/
            case 20:
                from = new String[]{"pairing_num", "count_permutation", "count_pairing"};
                zag = new String[]{"№ класса сопряженных элементов", "Кол-во элементов централизатора", "Кол-во элементов класса сопр эл-тов"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;
                dbItem = R.layout.db_item3;
                break;
/* 18
           "Централизаторы представителей классов сопряженных элементов", // 12
            "select C._id as _id, C.class_pair as pairing_numc, E1.name as name1, E1.ciklos as ciklos1, E1.center_num as center_num, E1.switchboard_num as switchboard_num, E1.deg as deg1," +
                    "E.name as namee, E.ciklos as ciklos, E.deg as deg, E.pe as pe, E.pairing_num as pairing_nume, E.stabilizer as stabilizer  " +
 */
            case 21:
                from = new String[]{"pairing_numc", "name1", "ciklos1", "center_num", "switchboard_num", "deg1",
                        "namee", "ciklos", "deg", "pe", "pairing_nume", "stabilizer"};
                zag = new String[]{"№ класса сопряженных эл-тов", "Подстановка класса (представитель)", "В циклах", "Порядок централизатора", "№ коммутанта", "Порядок представител класса",
                        "Подстановка - элемент ценрализатора", "в циклах", "ее порядок", "степень простого?", "№ класса сопряженных эл-тов централизатора", "Стабилизатор для"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12};
                colCount = 12;
                dbItem = R.layout.db_item12;
                break;
            case 22: // select _id, text_ratios from  ratios order by _id asc;
// 19
                from = new String[]{"text_ratios", "iteration"};
                zag = new String[]{"Соотношение между образующими", "На какой итерации построено"};
                to = new int[]{R.id.db1, R.id.db2};
                colCount = 2;
                dbItem = R.layout.db_item2;
                break;
            case 23:
/*  23  Координаты вершин построенного графа Кэли
            "select P._id as _id, P.id_element as id_element, P.iteration as iteration, P.xp as xp, P.yp as yp, P.zp as zp, \n" +
                    " E1.name as name, E1.ciklos as ciklos, E1.sylow_num as sylow_num, E1.pairing_num as pairing_num, E1.deg as deg, P.ind_point ind_point  \n" +
                    " from points P, elements E1\n" +
                    "where E1._id = P.id_element\n" +
                    " order by _id asc;",
 */
                from = new String[]{"ind_point", "id_element", "iteration", "xp", "yp", "zp",
                        "name", "ciklos", "sylow_num", "pairing_num", "deg"};
                zag = new String[]{"# точки", "Id элемента группы", "Итерация", "X", "Y", "Z",
                        "Элемент", "Циклы", "Подгруппы силова", "Класс", "Порядок"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11};
                colCount = 11;
                dbItem = R.layout.db_item11;
                break;
            case 24:
/* 21 Линии графика
select L._id as _id, L.id_1 +1 as id_1, L.id_2 +1 as id_2, id_start,  L.name as name0,
                               E1.name as name1, E2.name as name2,
                               E0.ciklos as ciklos0,  E1.ciklos as ciklos1,  E2.ciklos as ciklos2,
                               P1.xp as xp1, P1.yp as yp1, P1.zp as zp1, P2.xp as xp2, P2.yp as yp2, P2.zp as zp2,  L.color color
                               from  lines L, points P1, points P2, elements E0, elements E1, elements E2
                              where L.id_1 +1 = E1._id and L.id_2 +1 = E2._id  and L.id_start = E0._id  and L.id_1 +1 = P1.id_element and L.id_2 +1 = P2.id_element order by L.nomer asc,  _id asc; */
                from = new String[]{"id_1", "id_2", "id_start", "name0", "name1", "name2",
                        "ciklos0", "ciklos1", "ciklos2",
                        "xp1", "yp1", "zp1", "xp2", "yp2", "zp2", "color"};
                zag = new String[]{"Id точки 1", "Id точки 2", "Id линии", "Имя линии (образующего элемента)", "Имя точки 1", "Имя точки 2",
                        "Циклы линии (образующего элемента)", "Циклы точки 1", "Циклы точки 2",
                        "X1", "Y1", "Z1", "X2", "Y2", "Z2", "Код цвета"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14, R.id.db15, R.id.db16};
                colCount = 16;
                dbItem = R.layout.db_item16;
                break;
            case 25:
  /*
            "select _id,  pairing_num, name, substitution, ciklos, deg,  cykl_len, center_num,
            switchboard_num, stabilizer, iteration, parity, nomer_soc \n" +
            "from elements \n" +
            "where sylow_num is null \n" +
            "order by pairing_num asc;\n",
                 */
                from = new String[]{"_id", "pairing_num", "name", "substitution", "ciklos", "deg", "cykl_len",
                        "center_num", "switchboard_num", "stabilizer", "iteration", "parity", "nomer_soc"};
                zag = new String[]{"Id", "№ класса сопр эл-тов", "Выражение через образующие", "Подстановка", "Вид в циклах",
                        "Порядок эл-та", "Цикл тип",
                        "Порядок центализатора элемента", "№ коммутанта", "Стабилизатор для", "Номер итерации, когда создан", "0 - четная", "Входит в цоколь"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13};
                colCount = 13;    // колонок в таблицк
                dbItem = R.layout.db_item13;
                break;

            case 26:
/*  // 23 Коммутант подгруппы четных подстановок
            "select distinct L._id as _id, L.name as name, L.substitution as substitution, L.ciklos as ciklos, L.deg as deg, L.sylow_num as sylow_num, l.pairing_num as pairing_num, L.switchboard_num as switchboard_num, L.parity as parity\n" +
                    "   from  switchboard S, elements L\n" +
                    "    where S.work_field = 0 and S.id_switch = L._id\n" +
                    "\torder by L._id asc; ",
 */
                from = new String[]{"_id", "name", "substitution", "ciklos", "deg", "sylow_num", "pairing_num",
                        "switchboard_num", "parity"};
                zag = new String[]{"Id", "Выражение через образующие", "Подстановка", "Вид в циклах",
                        "Порядок эл-та", "Входит в силовские подгруппы", "№ класса сопр эл-тов", "№ коммутанта", "0 - четная"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9};
                colCount = 9;    // колонок в таблицк
                dbItem = R.layout.db_item9;
                break;

            case 27:
/* // 24 Вложение в группу подстановок на множестве своих элементов
            "select M._id as _id, M.name as name, M.ciklos as ciklos, A.cykl as cykl, m.deg as degm, A.deg as dega,\n" +
                    "  M.cykl_len as cykl_len, A.clength as clength, M.parity as parityM, A.parity as parityA, A.stabilizer as stabilizer" +
                    "  from elements M, addition A\n" +
                    "  where M._id = A.main_id\n" +
                    "  order by M._id asc",
*/
                from = new String[]{"_id", "name", "ciklos", "cykl", "degm", "dega",
                        "cykl_len", "clength", "parityM", "parityA", "stabilizer"};
                zag = new String[]{"Id", "Выражение через образующие", "Исходные циклы", "Циклы представления",
                        "Исходный порядок эл-та", "Порядок эл-та представления", "Исходный цикл тип", "Цикл тип представления", "Четность исходная", "Четность новая", "Неподвижные точки представления"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11};
                colCount = 11;    // колонок в таблицк
                dbItem = R.layout.db_item11;
                break;

            case 28:
/* // 25 "26. Отличия при вложение в группу подстановок на множестве своих элементов",
            "select M._id as _id, M.name as name, M.ciklos as ciklos, A.cykl as cykl, m.deg as degm, A.deg as dega,\n" +
                    "  M.cykl_len as cykl_len, A.clength as clength, M.parity as parityM, A.parity as parityA\n" +
                    "  from elements M, addition A\n" +
                    "  where M._id = A.main_id\n and not (m.deg = A.deg and M.parity =  A.parity)" +
                    "  order by M._id asc",
 */
                from = new String[]{"_id", "name", "ciklos", "cykl", "degm", "dega",
                        "cykl_len", "clength", "parityM", "parityA"};
                zag = new String[]{"Id", "Выражение через образующие", "Исходные циклы", "Циклы представления",
                        "Исходный порядок эл-та", "Порядок эл-та представления", "Исходный цикл тип", "Цикл тип представления", "Четность исходная", "Четность представления"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10};
                colCount = 10;    // колонок в таблицк
                dbItem = R.layout.db_item10;
                break;
            case 29:
/* 26 таблица умножения четных подстановок
            "select  L._id as _id, L._id as idl, R._id as idR, E._id as idm, L.name as namel, R.name as namer, E.name as namem, L.ciklos as ciklosl, \n" +
                    "            R.ciklos as ciklosr, E.ciklos as ciklosm, \n" +
                    "           L.cykl_len as lcykll, R.cykl_len as lcyklr, E.cykl_len as lcykle, \n" +
                    "           L.deg as degl, R.deg as degr, E.deg as degm, M.iteration as iteration, \n" +
                    " L.parity as lparity, R.parity as rparity, E.parity as mparity \n" +
                    "         from temp_multiplication M, elements L, elements R, elements E \n" +
                    "          where L._id = M.idleft and R._id = M.idright AND M.idproiz = E._id and" +
                    "L.parity = 0 and  R.parity = 0;",
*/
                from = new String[]{"idl", "idR", "idm", "namel", "namer", "namem", "ciklosl", "ciklosr", "ciklosm",
                        "lcykll", "lcyklr", "lcykle", "degl", "degr", "degm", "iteration", "lparity", "rparity", "mparity"};
                zag = new String[]{"Id левой", "Id правой", "Id произведения", "Выражение через образующие 1-го множителя", "Выражение через образующие 2-го множителя", "Выражение через образующие произведения",
                        "1-й в циклах", "2-й множитель", "Результат в циклах",
                        "1-й Цикл тип", "2-й Цикл тип", "Результат Цикл тип",
                        "Порядок 1-го множителя", "Порядок 2-го множителя", "Порядок произведения", "№ итерации",
                        "Четность 1-го множителя", "Четность 2-го множителя", "Четность произведения"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14, R.id.db15, R.id.db16, R.id.db17, R.id.db18, R.id.db19};
                colCount = 19;
                dbItem = R.layout.db_item19;
                break;

            case 30:
// 27 Группировка общих элементов силовских подгрупп
//            "select pe, sylow_num from elements where instr(sylow_num, ' ') > 0 and pe > 0 order by pe asc;",
                from = new String[]{"pe", "sylow_num"};
                zag = new String[]{"P", "№ силовских подгрупп"};
                to = new int[]{R.id.db1, R.id.db2};
                colCount = 2;
                dbItem = R.layout.db_item2;
                break;
            case 31:
/* // 31 2.12 Классы сопряженных элементов силовских подгрупп
select  0 as _id, pe, sylow_num, pairing_num, cykl_len, count(Eid) as ccc, deg from (
  select  E.pe as pe, T.num sylow_num, P.class_area as pairing_num, E.cykl_len as cykl_len, E._id Eid, E.deg as deg
                       from elements E, pairing_area P, sylov_table T
                       where E._id = P.id_subs and E.pe > 0 and  E._id = T.id_s
             UNION ALL
  select   E.pe as pe, 'Всего эл-тов в классе' sylow_num, P.class_area as pairing_num, E.cykl_len as cykl_len, E._id Eid, E.deg as deg
          from elements E, pairing_area P
                      where E._id = P.id_subs and E.pe > 0
)   group by pairing_num, cykl_len, deg, pe, sylow_num
      order by  pairing_num asc, pe asc, sylow_num asc
*/
                from = new String[]{"pe", "pairing_num",  "cykl_len", "sylow_num", "ccc", "deg"};
                zag = new String[]{"P", "№ класса сопряженныъ элементов", "Цикл тип", "№№ подгрупп", "Всего эл-тов", "Порядок элементов ккласса"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item6;
                break;

            case 32:
/* // 32 2.13 Классы сопряженных элементов не входящих в силовские подгруппы
            "select  0 as _id, pairing_num, cykl_len, count(_id) as ccc, deg \n" +
                    " from elements where sylow_num is null \n" +
                    " group by pairing_num, cykl_len\n" +
                    " order by pairing_num asc;",
 */
                from = new String[]{"pairing_num", "cykl_len", "ccc", "deg"};
                zag = new String[]{"№ класса сопряженныъ элементов", "Цикл тип", "Порядок класса", "Степень ккласса"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4};
                colCount = 4;
                dbItem = R.layout.db_item4;
                break;

            case 33:
// 24 "select  _id, parm, ind, val, val_txt from params;"
                from = new String[]{"_id", "parm", "ind", "val", "val_txt"};
                zag = new String[]{"№", "Параметр", "Индекс", "Значение-число", "Значение-текст"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5};
                colCount = 5;
                dbItem = R.layout.db_item5;
                break;

            case 34:    //  Таблица умножения силовской подгруппы
            case 35: // Таблица умножения общей подгруппы силовских подгруппах
/*  "select T._id as _id, T.idleft as idleft, T.idright as idright, T.idproiz as idproiz, T.num1 as num1, T.num2 as num2,\n" +
                    "         E1.ciklos as ciklos1, E2.ciklos as ciklos2, E0.ciklos as ciklos0, T.pe as pe\n" +
                    "   from temp_sylow T, elements E1, elements E2, elements E0\n" +
                    "       where T.idleft = E1._id and T.idright = E2._id and T.idproiz = E0._id\n" +
                    "      order by T.pe asc, T.idleft asc, T.idright asc;",
 */
                from = new String[]{ "idleft", "idright", "idproiz", "num1", "num2",
                        "ciklos1", "ciklos2", "ciklos0", "pe"};
                zag = new String[]{"Id 1 множителя", "Id 2 множителя", "Id произведения", "№ подгрупп сомножителей","№ подгруппы произведения",
                        "Циклы 1 множителя", "Циклы 2 множителя", "Циклы произведения", "P"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9};
                colCount = 9;
                dbItem = R.layout.db_item9;
                break;

            case 36:
/*36 общие элементы общих подгрупп в силовских подгруппых
            "select 0 as _id, U.pe as pe, U.id_s as id_s, U.ccc as ccc, elements.name as name, elements.ciklos as ciklos, nomer_soc  \n" +
                    "from (\n" +
                    " select G.pe, G.id_s, count(nomer1) as ccc \n" +
                    "\tfrom sylov_com_grup G\n" +
                    "\tgroup by G.pe, id_s\n" +
                    " ) U, elements \n" +
                    " where U.ccc > 1 and elements._id = U.id_s\n" +
                    "order by U.pe asc, id_s asc;"
*/
                from = new String[]{"pe", "id_s", "name", "ciklos", "ccc", "nomer_soc"};
                zag = new String[]{"P", "Id", "Элемент", "Циклы", "Кол-во подгрупп в которые входит Id", "Входит в цоколь"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item6;
                break;

            case 37:
/*  // 37  2.14 Порядки P подгрупп по уровням вложенности
            "select 0 as _id, pe, ur, nom, sum(ccc) as kolvo, sum(kkk) as kokom, sum(ppp) as koppp from (\n" +
                    "                      select  pe, nomer2 as ur, nomer1 as nom, 1 as ccc, 0 as kkk, 0 as ppp from sylov_com_grup\n" +
                    "                        union ALL\n" +
                    "                      select  G.pe as pe, G.nomer2 as ur, G.nomer1 as nom, 0 as ccc, 1 as kkk, 0 as ppp from sylov_com_grup G, elements E\n" +
                    "   where E._id = G.id_s and  E.switchboard_num > 0\n" +
                    "                       union ALL\n" +
                    "                      select  G.pe as pe, G.nomer2 as ur, G.nomer1 as nom, 0 as ccc, 0 as kkk, 1 as ppp from sylov_com_grup G, elements E\n" +
                    "   where E._id = G.id_s and  E.parity = 0\n" +
                    "                       union ALL\n" +
                    "                     select  pe, 0 as ur, num as nom, 1 as ccc, 0 as kkk, 0 as ppp from sylov_table\n" +
                    "                        union ALL\n" +
                    "                     select  S.pe as pe, 0 as ur, num as nom, 0 as ccc, 1 as kkk, 0 as ppp from sylov_table S, elements E\n" +
                    "   where E._id = S.id_s and  E.switchboard_num > 0\n" +
                    "                        union ALL\n" +
                    "                     select  S.pe as pe, 0 as ur, num as nom, 0 as ccc, 0 as kkk, 1 as ppp from sylov_table S, elements E\n" +
                    "   where E._id = S.id_s and  E.parity = 0\n" +
                    "                       )\n" +
                    "                      group by pe, ur, nom\n" +
                    "                      order by pe, ur, nom;",
 */
                from = new String[]{"pe", "ur", "nom", "kolvo", "kokom", "koppp"};
                zag = new String[]{"P", "Уровень вложенности подгрупп", "№ подгруппы", "Порядок подгруппы",
                        "Количество коммутаторов", "Количество четных подстановок"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item6;
                break;

            case 38:
/* 38  2.17 Количество общих P подгрупп по уровням
            "select 0 as _id, pe, ur, count(ccc) as kolvo from (
                    select pe, nomer2 as ur, nomer1 as ccc from sylov_com_grup
                      union ALL
                    select pe, 0 as ur, num as ccc from sylov_table
                    )
                    group by pe, ur
                    order by pe, ur;",
 */
                from = new String[] {"pe", "ur", "kolvo" };
                zag = new String[]{"P", "Уровень вложенности подгрупп", "Количество подгрупп"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;
                dbItem = R.layout.db_item3;
                break;

            case 39:
/* // 39 "2.9 Количество сопрягающих элементов у силовских подгрупп"     // 39
            "select 0 as _id, S.pe as pe, S.num1 as num1, S.num2 as num2, count(S.id_conj) as ccc\n" +
                    "         from sylow_conj S, elements E1,  elements E2\n" +
                    "    where S.id_conj = E1._id and S.id_reverse = E2._id\n" +
                    "\t group by S.pe, S.num1, S.num2\n" +
                    "   order by S.pe asc, S.num1 asc, S.num2 asc; "
 */
                from = new String[] {"pe", "num1", "num2", "ccc" };
                zag = new String[]{"P", "№ 1-ой силовской подгруппы", "№ сопряженной с ней силовской подгруппы", "Кол-во сопрягающих элементов"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4};
                colCount = 4;
                dbItem = R.layout.db_item4;
                break;

            case 40:
/* // 40  2.18 Номера общих силовских подгрупп уровня 2 в общих силовских подгруппах уровня 1"
            "select _id, main_lelel, att_level, pe, mail_num, att_num, att_order, att_index from sylow_attachments " +
                    " order by  pe, main_lelel, att_level, mail_num, att_num; "
 */
                from = new String[] {"pe", "main_lelel", "mail_num", "att_level", "att_num", "att_order", "att_index" };
                zag = new String[]{"P", "Уровень основной подгруппы", "№ основной подгруппы",
                        "Уровень вложенной подгруппы", "№ вложенной подгруппы",
                        "Порядок вложенной подгруппы", "Индекс подгруппы"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7};
                colCount = 7;
                dbItem = R.layout.db_item7;
                break;

            case 41:
/*  "5. 3 Отличия в цикловых типах при вложение в группу подстановок"    // 41
            "select 0 as _id,  m.deg as degm, M.cykl_len as cykl_len, A.clength as clength\n" +
                    "     from elements M, addition A\n" +
                    "     where M._id = A.main_id and not M.cykl_len = A.clength\n" +
                    "     order by m.deg asc"
 */
                from = new String[] {"degm", "cykl_len", "clength" };
                zag = new String[]{"Порядок элемента", "Цикленный тип основной группы",
                        "Цикленный тип представления"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;
                dbItem = R.layout.db_item3;
                break;

            case 42:
//             "1. 7 Число элементов одного порядка в группе"  // 42
//            "select 0 as _id, deg, count(*) as chislo from elements group by deg order by deg asc;"
                from = new String[] {"deg", "chislo" };
                zag = new String[]{"Порядок элемента", "Число элементов этого порядка"};
                to = new int[]{R.id.db1, R.id.db2};
                colCount = 2;
                dbItem = R.layout.db_item2;
                break;

            case 43:
//            "1. 8 Число элементов одного циклового типа в группе"  // 43
//            "select 0 as _id, deg, cykl_len,  count(*) as chislo from elements group by deg, cykl_len order by deg asc, cykl_len  asc;"
                from = new String[] {"deg", "cykl_len", "chislo" };
                zag = new String[]{"Порядок элемента","Цикленный тип", "Число элементов этого порядка и цикл типа"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;
                dbItem = R.layout.db_item3;
                break;

            case 44:
/*  "2.19. Порядки общих силовские подгруппы",   // 44
 select 0 _id, pe, nomer1, nomer2, sylow_zag, count(*) ccc
    from sylov_com_grup
   group by nomer1, nomer2, pe, sylow_zag
     order by pe asc, nomer1 asc, nomer2 asc;
*/
                from = new String[] {"pe", "nomer1", "nomer2", "sylow_zag",  "ccc" };
                zag = new String[]{ "P", "№ общей подгруппы", "Уровень подгруппы", "Куда входит", "Порядок подгруппы"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5};
                colCount = 5;
                dbItem = R.layout.db_item5;
                break;

            case 45:
/*  "2.18. Нормализаторы силовских подгрупп",  // 45
               "select N.pe pe, N.num num, id_s _id, E.pe epe, E.cykl_len cykl_len, E.ciklos ciklos, P.class_area class_area " +
                    " from normalizer N, elements E, pairing_area P " +
                    "  where P.id_subs = E._id and N.id_s = E._id " +
                    "  order by pe asc, num asc, E.pe asc, id_s asc;",
*/
                from = new String[] {"pe", "num", "epe", "cykl_len", "class_area", "ciklos", "_id" };
                zag = new String[]{"P подгруппы","№ силовской подгруппы",
                        "P нормализатора", "Цикл тип", "Класс", "Циклы нормализатора", "Id нормализатора"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7};
                colCount = 7;
                dbItem = R.layout.db_item7;
                break;


            case 46:
            case 48:
/*    "4. 3 Эпиморфизм на группу подстановок на силовских подгруппах",  // 46
      "4. 5 Ядро при эпиморфизме на группу подстановок на силовских подгруппах",  // 48
                   SQL = "select F.pe as pe, M._id as _id, F.id_element as id_element, F.id_obraz as id_obraz,  M.name as name, M.substitution as substitutionM, F.substitution as substitutionF, M.ciklos as ciklosM, F.ciklos as ciklosF,\n" +
                           " M.cykl_len as cykl_lenM, F.cykl_len as cykl_lenF,\n" +
                     " M.sylow_num as sylow_num, M.deg as degM, F.deg as degF, M.switchboard_num as switchboard_num, M.pairing_num as pairing_num, M.center_num as center_num, M.nomer_soc as nomer_soc\n" +
                           "from  elements M, epimorphism F\n" +
                           "where M._id = F.id_element and F.pe = "+ nomerPodgrup[0]  +
                           " order by F.id_element asc;";
 */
                from = new String[] {"pe", "_id", "id_element", "id_obraz", "name", "substitutionM", "substitutionF",
                        "ciklosM", "ciklosF", "cykl_lenM", "cykl_lenF", "sylow_num", "degM" , "degF", "switchboard_num", "pairing_num", "center_num", "nomer_soc" };
                zag = new String[]{"P эпиморфизма","Id", "Id образа", "Id образа без повторения", "Имя", "Подстановка", "Ее образ",
                        "Циклы", "Циклы образа", "Цикленный тип", "Цикленный тип образа", "№ силовских подгрупп элемента",
                        "Порядок элемента", "Порядок образа", "№ коммутанта", "№ класса сопряженных элементов", "Порядок централизатора элемента", "Элемент цоколя"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14, R.id.db15, R.id.db16, R.id.db17, R.id.db18};
                colCount = 18;
                dbItem = R.layout.db_item19;
                break;

            case 47:
/*   "4. 4 Образ при эпиморфизме на группу подстановок на силовских подгруппах",  // 47
                    "select distinct F.pe as pe, F.id_obraz as id_obraz,  F.substitution as substitutionF, F.ciklos as ciklosF,\n" +
                            "  F.cykl_len as cykl_lenF, F.deg as degF\n" +
                            "from  epimorphism F\n" +
                            "where F.pe = 2\n" +
                            "order by F.pe  asc, F.id_element asc;"
*/
                from = new String[] {"pe", "id_obraz",  "substitutionF",
                        "ciklosF", "cykl_lenF", "degF" };
                zag = new String[]{"P эпиморфизма", "Id образа", "Подстановка образа",
                        "Циклы образа", "Цикленный тип образа", "Порядок образа"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item6;
                break;

            case 49:
/*   4. 6 Смежные классы при эпиморфизме на группу подстановок на силовских подгруппах,  // 49
                   SQL = "select F.pe as pe, F.adjacent as adjacent, M._id as _id, F.id_obraz as id_obraz,  M.name as name, M.substitution as substitutionM, F.substitution as substitutionF, M.ciklos as ciklosM, F.ciklos as ciklosF,\n" +
                           " M.cykl_len as cykl_lenM, F.cykl_len as cykl_lenF,\n" +
                           " M.sylow_num as sylow_num, M.deg as degM, F.deg as degF\n" +
                           "from  elements M, epimorphism F\n" +
                           "where M._id = F.id_element and F.pe = "+ nomerPodgrup[0]  +
                           " order by F.adjacent asc, M._id asc;";
*/
                from = new String[] {"pe", "adjacent", "_id", "id_obraz", "name", "substitutionM", "substitutionF",
                        "ciklosM", "ciklosF", "cykl_lenM", "cykl_lenF", "sylow_num", "degM" , "degF" };
                zag = new String[]{"P эпиморфизма","№ смежного класса ", "Id", "Id образа", "Имя", "Подстановка", "Ее образ",
                        "Циклы", "Циклы образа", "Цикленный тип", "Цикленный тип образа", "№ силовских подгрупп элемента",
                        "Порядок элемента", "Порядок образа"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14};
                colCount = 14;
                dbItem = R.layout.db_item14;
                break;

            case 50:
/*  "4. 7 Силовские подгруппы при эпиморфизме на группу подстановок на силовских подгруппах",  // 50
accordance
select F.pe as pe, S.pe as pesyl, A.num_old as num,  A.num as sylow_new, M._id as _id, F.id_obraz as id_obraz,  M.name as name, M.substitution as substitutionM, F.substitution as substitutionF, M.ciklos as ciklosM, F.ciklos as ciklosF,
      M.cykl_len as cykl_lenM, F.cykl_len as cykl_lenF,
     M.deg as degM, F.deg as degF
   from  elements M, epimorphism F, sylov_table S, accordance A
     where M._id = F.id_element and S.id_s = M._id and id_obraz > 0
        and A.num_old = S.num and  F.pe = 2
         order by S.pe asc, A.num_old asc, M._id asc;
 */
                from = new String[] {"pe", "pesyl", "num", "sylow_new", "_id",  "id_obraz", "name", "substitutionM", "substitutionF",
                        "ciklosM", "ciklosF", "cykl_lenM", "cykl_lenF",  "degM" , "degF" };
                zag = new String[]{"P эпиморфизма", "P подгруппы силова", "Исходный № подгруппы", "№ подгруппы после перенумирации", "Id", "Id образа", "Имя", "Подстановка", "Ее образ",
                        "Циклы", "Циклы образа", "Цикленный тип", "Цикленный тип образа",
                        "Порядок элемента", "Порядок образа"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14, R.id.db15};
                colCount = 15;
                dbItem = R.layout.db_item15;
                break;


            case 51:
/*  "4. 8 Порядки силовских подгрупп при эпиморфизме на группу подстановок на силовских подгруппах",  // 51
select pe, pesyl, num, numold, sum(cobraz) as cobr, sum(cmain) as cmn, 0 as _id from (
                             select F.pe as pe, S.pe as pesyl, A.num as num, S.num as numold, count(distinct S.id_s) as cobraz, 0 as  cmain
                             from  epimorphism F, sylov_table S, accordance A
                               where  S.id_s = F.id_element and id_obraz > 0 and A.num_old = S.num
                                   and  F.pe = 3
                               group by F.pe, S.pe, A.num, S.num
                                   union
                             select 3 as pe, S.pe as pesyl, A.num as num, S.num as numold, 0 as cobraz, count(distinct S.id_s) as  cmain
                               from   sylov_table S, accordance A
                               where   A.num_old = S.num  and
								A.pe = S.pe
                                group by S.pe, A.num, S.num
                           )
                              group by pe, pesyl, num, numold
                             order by  pesyl  asc, num asc;
          SQL = "select pe, pesyl, num, numold, sum(cobraz) as cobr, sum(cmain) as cmn, 0 as _id from (\n" +

*/
                from = new String[] {"pe", "pesyl", "num", "numold", "cobr",   "cmn" };
                zag = new String[]{"P эпиморфизма", "P подгруппы силова", "№ силовской подгруппы после перенумирации", "№ силовской подгруппы в группе",
                        "Порядок образа", "Порядок исходной подгруппы"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item6;
                break;

            case 52:
 /*   "6.14 Образы образующих при эпиморфизме на группу подстановок на силовских подгруппах"  // 51
            select F.pe as pe, M._id as _id, F.id_obraz as id_obraz,  M.name as name, M.substitution as substitutionM, F.substitution as substitutionF, M.ciklos as ciklosM, F.ciklos as ciklosF,
                     M.cykl_len as cykl_lenM, F.cykl_len as cykl_lenF,
                     M.sylow_num as sylow_num, M.deg as degM, F.deg as degF
                    from  elements M, epimorphism F
                    where M._id = F.id_element and M.iteration = 0
                    order by F.pe  asc, M._id asc;
 */
                from = new String[] {"pe", "_id", "id_obraz", "name", "substitutionM", "substitutionF",
                        "ciklosM", "ciklosF", "cykl_lenM", "cykl_lenF", "sylow_num", "degM" , "degF" };
                zag = new String[]{"P эпиморфизма","Id", "Id образа", "Имя", "Подстановка", "Ее образ",
                        "Циклы", "Циклы образа", "Цикленный тип", "Цикленный тип образа", "№ силовских подгрупп элемента",
                        "Порядок элемента", "Порядок образа"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13};
                colCount = 13;
                dbItem = R.layout.db_item13;
                break;

            case 53:
/*   "6.15 Перенумирация силовских подгрупп при эпиморфизме на группу подстановок на силовских подгруппах"  // 53
            "select pe, num_old,  num\n" +
                    "from   accordance \n" +
                    "     order by pe asc, num_old asc;"
*/
                from = new String[] {"pe", "num_old", "num"};
                zag = new String[]{"P исходной силовской подгруппы",  "№ силовской подгруппы в группе", "№ силовской подгруппы в образе"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;
                dbItem = R.layout.db_item3;
                break;

            case 54: // "4. 9 Таблица умножения ядра при эпиморфизме на группу подстановок на силовских подгруппах",  // 54
/*             "select T._id as _id, T.idleft as idleft, T.idright as idright, T.idproiz as idproiz, T.num1 as num1, T.num2 as num2,\n" +
              "    E1.ciklos as ciklos1, E2.ciklos as ciklos2, E0.ciklos as ciklos0, E1.deg as deg1, E2.deg as deg2, E0.deg as deg0\n" +
                 "   from temp_sylow T, elements E1, elements E2, elements E0\n" +
                    "       where T.idleft = E1._id and T.idright = E2._id and T.idproiz = E0._id\n" +
                    "      order by T.pe asc, T.idleft asc, T.idright asc;",
 */
                from = new String[]{ "idleft", "idright", "idproiz", "num1", "num2",
                        "ciklos1", "ciklos2", "ciklos0", "deg1", "deg2", "deg0"};
                zag = new String[]{"Id 1 множителя", "Id 2 множителя", "Id произведения", "P эпиморфизма подгрупп сомножителей","P подгруппы произведения",
                        "Циклы 1 множителя", "Циклы 2 множителя", "Циклы произведения", "Порядок 1 сомножителя", "Порядок 2 сомножителя", "Порядок произведения"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11};
                colCount = 11;
                dbItem = R.layout.db_item11;
                break;

            case 55:    //  "1. 9 Вхождение элементов в основные подгруппы",    // 55
            case 56:    //  "1.10 Порядки основных подгрупп"    // 56
                colCount = DbHelper.grupZag.size();
                if (colCount > classIds.MAX_COL_NUM)
                    colCount = classIds.MAX_COL_NUM;

                from = new String[colCount];
                zag = new String[colCount];
                to = new int[colCount];
//     Log.e("DBACT", "f_OtchetText colCount=" + colCount + " myApl.dbH.grupRow.=" + myApl.dbH.grupRow.size() + " myApl.dbH.grupZag=" + myApl.dbH.grupZag.size());
                for (int i = 0; i<colCount; i++ ) {
                    from[i] = DbHelper.grupRow.get(i);
                    zag[i] = DbHelper.grupZag.get(i);
                    to[i] = classIds.toA[i];
                }
                dbItem = R.layout.db_item30;
                break;

//  "1. 3. Коммутант любого расчитанного уровня" // 57
            case 57:
/*  SQL = "select L._id as _id, L.switchboard_num as switchboard_num, L.name as namel, L.substitution as substitutionl, L.ciklos as ciklos,
                L.center_num as center_num, L.deg as deg, L.sylow_num as sylow_num, L.parity as parity, L.pairing_num as pairing_num  " +
                            "from  elements L " +
                            "where L.switchboard_num >= " + nomerPodgrup[0] + " order by L._id asc; ";
 */
                zag = new String[]{"Id", "№ коммутанта", "Выражение через образующие подстановки", "Коммутатор", "В циклах", "Порядок центализатора элемента", "Порядок коммутатора", "Элемент силовской подгруппы", "0 - четная", "№ класса сопр эл-тов"};
                from = new String[]{"_id", "switchboard_num", "namel", "substitutionl", "ciklos", "center_num", "deg", "sylow_num", "parity", "pairing_num"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10};
                colCount = 10;
                dbItem = R.layout.db_item10;
                break;

            case 58:
//  "4.11 Таблица умножения коммутанта любого расчитанного уровня"  // 58
/*             "select T._id as _id, T.idleft as idleft, T.idright as idright, T.idproiz as idproiz, E1.switchboard_num as num1, E2.switchboard_num as num2," +
                    " E0.switchboard_num as num0 \n" +
                    "         E1.ciklos as ciklos1, E2.ciklos as ciklos2, E0.ciklos as ciklos0 \n" +
                    "   from temp_sylow T, elements E1, elements E2, elements E0\n" +
                    "       where T.idleft = E1._id and T.idright = E2._id and T.idproiz = E0._id\n" +
                    "      order by T.idleft asc, T.idright asc;",
 */
                from = new String[]{ "idleft", "idright", "idproiz", "num1", "num2", "num0",
                        "ciklos1", "ciklos2", "ciklos0"};
                zag = new String[]{"Id 1 множителя", "Id 2 множителя", "Id произведения", "№ коммутанта 1 сомножителя",
                        "№ коммутанта 2 сомножителя", "№ коммутанта произведения",
                        "Циклы 1 множителя", "Циклы 2 множителя", "Циклы произведения"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9};
                colCount = 9;
                dbItem = R.layout.db_item9;
                break;

            case 59:
//  "6. 1 Цоколь"   // 59
//  select _id,  pairing_num, name, substitution, ciklos, deg, pe, sylow_num, cykl_len, center_num, switchboard_num, stabilizer, nomer_soc  from elements where not nomer_soc isnull order by  nomer_soc asc, pairing_num asc;"
                zag = new String[]{"Id",  "№ группы силова", "P", "Порядок эл-та",
                        "Выражение через образующие", "Вид в циклах", "Цикл тип", "Подстановка",
                        "№ класса", "Порядок центализатора элемента", "№ коммутанта",
                        "№ подгруппы цоколя"};
                from = new String[]{"_id", "sylow_num", "pe", "deg",
                        "name", "ciklos", "cykl_len", "substitution",
                        "pairing_num", "center_num", "switchboard_num",  "nomer_soc"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12};
                colCount = 12;    // колонок в таблиц
                dbItem = R.layout.db_item12;
                break;

            case 60:
/* "6. 6 Элементы нормальной подгруппы
      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" +
*/
                zag = new String[]{"№ подгруппы", "Id", "№ класса", "№ подгруппы цоколя",
                        "Вид в циклах",
                        "Силовские подгруппы", "Порядок центализатора элемента", "Стабилизатор для",
                        "№ коммутанта",  "Подстановка",  "Порядок эл-та"};
                from = new String[]{"num_maim", "_id", "class_area", "num",  "ciklos",
                        "sylow_num", "center_num", "stabilizer",
                        "switchboard_num", "substitution", "deg"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11};
                colCount = 11;    // колонок в таблиц
                dbItem = R.layout.db_item11;
                break;
            case 61:
/* "6. 3 Состав нормальных подгрупп с минимальным количеством классов сопряженных элементов" // 61 soc_list
            "select _id,  num, num_klass, count_klass, deg, comm_level, even_flag, soc_level, centr_flag, dubl_flag, sylow_num, connon_sylow, " +
                    "sostav, summa_num, epi_pe\n" +
               " from  soc_list\n" +
                    " order by num_klass asc;",
 */
                zag = new String[]{ "№ подгруппы (класс подгруппы)", "Число классов в подгруппе", "Порядок подгруппы", "№ подгруппы цоколя",
                        "Подгруппа коммутанта уровня","Подгруппа всех четных подстановок", "Вся подгруппа цоколя", "Центр", "P подгруппа", "Уровень p-подгруппы",
                        "Разлагается в сумму подгрупп", "Ядро эпиморфизма для P", "Подгруппа дублируется",
                        "Состав (классы)"};
                from = new String[]{"num_klass", "count_klass", "deg", "num",
                        "comm_level","even_flag", "soc_level", "centr_flag", "sylow_num", "connon_sylow",
                        "summa_num", "epi_pe",
                        "dubl_flag", "sostav"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14};
                colCount = 14;
//                dbItem = R.layout.db_item14;
                dbItem = R.layout.db_item10_63;
                break;

            case 62:
/*//  "1.11 Элементы группы по цикловому типу" // 62
            "select E._id, abs(substr(cykl_len, 1, instr(trim(cykl_len) ||' ', ' '))) as sym1, length(cykl_len) as len, P.class_area, cykl_len, P.num,  ciklos, deg, sylow_num,
            center_num, switchboard_num, stabilizer, substitution\n" +
                    " from elements E, pairing_area P\n" +
                    " where P.id_subs = E._id\n" +
                    "  order by abs(substr(cykl_len, 1, instr(trim(cykl_len) ||' ', ' '))) asc,\n" +
                    " length(cykl_len) asc,\n" +
                    " cykl_len asc;"
*/
                zag = new String[]{ "Id",  "№ подгруппы цоколя", "№ класса", "Цикл тип", "Циклы", "Порядок эл-та",
                        "Силовские подгр-пы", "Порядок централизатора", "№ коммутанта", "Стабилизатор для", "Подстановка"};
                from = new String[]{"_id",  "num",  "class_area", "cykl_len", "ciklos", "deg",
                        "sylow_num", "center_num", "switchboard_num", "stabilizer", "substitution"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11};
                colCount = 11;    // колонок в таблиц
                dbItem = R.layout.db_item13;
                break;

            case 63:
/*  "6. 4 Моноид классов " // 63
            "select distinct 0 as _id, EA.pairing_num as num1, EB.pairing_num as num2, ER.pairing_num as num0,\n" +
                    " EA.cykl_len as cykl1, EB.cykl_len as cykl2, ER.cykl_len as cykl0,\n" +
                    " count(distinct EA._id) as k1, count(distinct EB._id) as k2, count(distinct ER._id) as k0\n" +
                    " from temp_multiplication M,\n" +
                    "       elements EA, elements EB, elements ER\n" +
                    "                    where ER._id = M.idproiz and EA._id = M.idleft  and EB._id = M.idright\n" +
                    "  group by  EA.pairing_num, EB.pairing_num, ER.pairing_num,\n" +
                    "    EA.cykl_len, EB.cykl_len, ER.cykl_len\n" +
                    "                    order by ER.cykl_len asc, EB.cykl_len asc;\n;",
 */
                zag = new String[]{ "№ класса 1","№ класса 2", "№ класса произведения", "Цикл тип 1 ","Цикл тип 2", "Цикл тип  произведения ",
                        "Число эл-тов 1", "Число эл-тов 2", "Число эл-тов произведения"};
                from = new String[]{"num1",  "num2", "num0",  "cykl1", "cykl2", "cykl0",
                        "k1", "k2", "k0" };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9};
                colCount = 9;    // колонок в таблиц
                dbItem = R.layout.db_item9;
                break;

            case 64:

/*  "6. 4 Разложение группы в прямое произведение своих подгрупп"   // 64 = sel2Multiplier
            "select iter,  num_maim,  num_subs, deg from sub_summa order by iter asc, num_maim asc;",
 */
                zag = new String[]{ "№ разложения", "№ подгруппы", "№ вложенной подгруппы", "Порядок вложенной подгруппы"};
                from = new String[]{"iter",  "num_maim",  "num_subs", "deg" };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4};
                colCount = 4;    // колонок в таблиц
                dbItem = R.layout.db_item4;
                break;

            case 65:
/* 6. 5 Вложенность нормальных подгрупп"    // 65
            select N._id as _id,  N.num_maim as num_maim,  N.num_sub as num_sub, LM.nrow as nrowm, LS.nrow as nrows,
   LM.count_klass as c_main, LM.deg as deg_m,
   LS.count_klass as c_sub, LS.deg as deg_s, LS.num as nums
    from  normal_subgroup N, soc_list LM, soc_list LS
    where N.num_maim = LM.num_klass and  N.num_sub = LS.num_klass
    order by LM.nrow asc, LS.nrow asc, N.num_maim asc;
 */
                zag = new String[]{ "№ подгруппы", "№ вложенной подгруппы", "Уровень подгрыппы", "Уровень вложенной подгрыппы",
                        "Классов подгруппы", "Классов вложенной подгруппы", "Порядок подгруппы", "Порядок вложенной подгруппы", "№ подгруппы цоколя"};
                from = new String[]{"num_maim",  "num_sub", "nrowm" , "nrows" ,
                        "c_main" , "c_sub" , "deg_m" , "deg_s" , "nums"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9};
                colCount = 9;    // колонок в таблиц
                dbItem = R.layout.db_item9;
                break;

            case 66:    // 6. 7 Классы нормальных подгрупп"    // 66
//    SQL = "select 0 as _id, ' ' as txt,  klass, num,  sum(ccc) as itog_sub, sum(fff) as no_sub, sum(ccc + fff) as itog from (\n" +
                zag = new String[]{ " ", "№ класса", "№ подгруппы, если класс входит в нее", "Порядок класса подгрыппы",
                        "Порядок класса не вхолящего в подгруппу", "Итого"};
                from = new String[]{"txt",  "klass", "num" , "itog_sub" ,
                        "no_sub" , "itog"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item6;
                break;

            case 67:    //   "6.10 Таблица умножения подгруппы (классы)"    // 67
// SQL = "select distinct 0 as _id, S1.num_maim as num, P1.class_area as klass1, P2.class_area as klass2, P0.class_area as klass0\n" +
                zag = new String[]{ "№ подгруппы", "№ класса сомножителя 1", "№ класса сомножителя 2", "№ класса произведения"};
                from = new String[]{"num",  "klass1", "klass2", "klass0"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4};
                colCount = 4;
                dbItem = R.layout.db_item4;
                break;

            case 68:
/*  "6. 8 Порядки нормальных подгрупп"    // 68
            "select 0 as _id,  txt,  klass, num,  sum(ccc) as itog_sub from (\n" +
                    "        select ' ' as txt, S.num_maim as num, P.class_area as klass, count( P.id_subs ) as ccc\n" +
                    "              from pairing_area P, sub_structure S\n" +
                    "              where P.class_area = S.num_subs \n" +
                    "              group by S.num_maim, P.class_area\n" +
                    "      union all\n" +
                    "       select 'Итго по ' as txt, S.num_maim as num, '   ' as klass, count( P.id_subs ) as ccc\n" +
                    "           from pairing_area P, sub_structure S\n" +
                    "            where P.class_area = S.num_subs \n" +
                    "           group by S.num_maim, P.class_area\n" +
                    ")     group by txt, num, klass\n" +
                    "   order by num asc, klass asc\n"
*/
                zag = new String[]{ "", "№ подгруппы", "№ класса подгруппы", "Число элементов"};
                from = new String[]{"txt", "num",  "klass", "itog_sub"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4};
                colCount = 4;
                dbItem = R.layout.db_item4;
                break;

            case 69:
/*   "6.11 Классы при умножении элементов одного класса"    // 69
            "select distinct 0 as _id, EA.class_area as kla, ER.class_area as kl0, EA.cykl_len as ca, ER.cykl_len as cr\n" +
                    " from temp_multiplication M,\n" +
                    "       pairing_area EA, pairing_area EB, pairing_area ER\n" +
                    "                    where ER.id_subs = M.idproiz and EA.id_subs = M.idleft  and EB.id_subs = M.idright and\n" +
                    "                    EA.class_area = EB.class_area\n" +
                    "                    order by EA.class_area asc, ER.class_area asc;"
*/
                zag = new String[]{ "№ класса", "№ класса произведения эл-тов касса (зависимые классы)", "Цикл тип класса", "Цикл тип зависимого класса"};
                from = new String[]{"kla", "kl0",  "ca", "cr"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4};
                colCount = 4;
                dbItem = R.layout.db_item4;
                break;

            case 70:
/*   "7. 6
      SQL =   "select pe, num, num_resech, _id, id_resech," +
              "  ciklos, ciklos_resech, sylow_num, sylow_num_resech,  for_n from (\n" +
*/
                zag = new String[]{ "P", "№ под-пы Силова Sn", "№ под-пы Силова", "Id Sn", "Id под-пы", "Цикл Sn", "Цикл под-пы",
                        "№№ под-п Силова Sn", "№№ под-п Силова в под-пе",  "n в какую Sn входит подстановка"};
                from = new String[]{"pe", "num",  "num_resech", "_id", "id_resech", "ciklos", "ciklos_resech", "sylow_num", "sylow_num_resech", "for_n"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10};
                colCount = 10;
                dbItem = R.layout.db_item10;
                break;

            case 71:
/*  7. 3 Классы подгруппы в классах Sn с элементами    // 71
            "select 0 _id, PN.class_area nclass, PM.class_area mclass, N.id_true id_true, M._id id, N.cykl_len ncykl, M.cykl_len mcykl\n" +
                    "  from elements_n N, pairing_area_n PN, elements M, pairing_area PM\n" +
                    "  where PN.id_subs = N.id_true and PM.id_subs = M._id and M._id = N.link_to_elements \n" +
                    " union ALL\n" +
                    "select 0 _id, PN.class_area nclass, null mclass, N.id_true, null, N.cykl_len, null  " +
                    "  from elements_n N, pairing_area_n PN\n" +
                    "  where PN.id_subs = N.id_true and N.link_to_elements is null\n" +
                    "      order by nclass asc, mclass asc, id_true asc ;",
   */
                zag = new String[]{ "Класс Sn", "Класс подгруппы", "Цикл тип Sn", "Цикл тип под-пы", "Id Sn", "Id подгруппы"};
                from = new String[]{"nclass", "mclass", "ncykl", "mcykl", "id_true", "id"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item16;
                break;

            case 72:
/* 7. 4 Порядки классоов подгруппы в классах Sn",   72
            "select 0 _id,  nclass, mclass, count(id_true) nnn, count(id) mmm, ncykl,  mcykl \n" +
                    " from (\n" +
                    "select 0 _id, PN.class_area nclass, PM.class_area mclass, N.id_true id_true, M._id id, N.cykl_len ncykl, M.cykl_len mcykl\n" +
                    "  from elements_n N, pairing_area_n PN, elements M, pairing_area PM\n" +
                    "    where PN.id_subs = N.id_true and PM.id_subs = M._id and M._id = N.link_to_elements \n" +
                    " union ALL\n" +
                    "select  0 _id,  PN.class_area nclass, null mclass, N.id_true id_true, null id, N.cykl_len ncykl, null mcykl\n" +
                    "  from elements_n N, pairing_area_n PN\n" +
                    "   where PN.id_subs = N.id_true and N.link_to_elements is null\n" +
                    "  )\n" +
                    "   group by nclass, mclass, ncykl,  mcykl \n" +
                    "            order by nclass asc, mclass asc\n"

*/
                zag = new String[]{ "Класс Sn", "Класс подгруппы", "Цикл тип Sn", "Цикл тип под-пы", "Эл-тов в классе Sn", "Эл-тов в классе подгруппы"};
                from = new String[]{"nclass", "mclass", "ncykl", "mcykl", "nnn", "mmm"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item16;
                break;

            case 73:
/* // 1. 8 Классы элементов одного порядка (в спектре группы)",  // 73
            "select 0 as _id, E.deg deg, P.class_area class_area,  count(*) as chislo, E.cykl_len cykl_len \n" +
                    "  from elements E, pairing_area P \n" +
                    "   where E._id = P.id_subs\n" +
                    "   group by E.deg, P.class_area, E.cykl_len \n" +
                    " union all \n" +
              " select 0 as _id, 'всего в классе' deg, P.class_area class_area,  count(*) as chislo, null cykl_len \n" +
                    "  from elements E, pairing_area P \n" +
                    "   where E._id = P.id_subs " +
                    "   group by E.deg, P.class_area \n" +
                    "  order by  P.class_area asc, E.deg asc;" ,
*/
                zag = new String[]{  "Класс", "Порядок элементов", "Эл-тов в классе", "Цикл тип"};
                from = new String[]{ "class_area", "deg", "chislo", "cykl_len"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4};
                colCount = 4;
                dbItem = R.layout.db_item4;
                break;

            case 74:
/*7. 9 Классы подгруппы в классах Sn только классы",     // 74
select distinct 0  _id, stabilizer,  pairing_num, deg, cykl_len, sum(chisloS) sss, sum(chisloG) ggg from (
select distinct '' stabilizer, P.class_area as pairing_num, M.deg as deg, M.cykl_len as cykl_len, Count(*) chisloS, 0 chisloG
         from  elements_n M,  pairing_area_n P
        where  M.id_true = P.id_subs
        group by  P.class_area, M.deg, M.cykl_len
           union all
select distinct '' stabilizer, P.class_area as pairing_num, M.deg as deg, M.cykl_len as cykl_len, 0 chisloS, Count(*) chisloG
         from  elements M,  pairing_area P
        where  M._id = P.id_subs
        group by  P.class_area, M.deg, M.cykl_len
           union all
  select distinct   'Всего эл-тов в классе' as stabilizer,  P.class_area as pairing_num, M.deg as deg, M.cykl_len as cykl_len, 0 chisloS, Count(*) chisloG
         from  elements M,  pairing_area P
         where  M._id = P.id_subs
         group by P.class_area, M.deg, M.cykl_len
           union all
  select distinct  'Всего эл-тов в классе' as stabilizer,  P.class_area as pairing_num, M.deg as deg, M.cykl_len as cykl_len, Count(*) chisloS, 0 chisloG
         from  elements_n M,  pairing_area_n P
         where  M.id_true = P.id_subs
         group by P.class_area, M.deg, M.cykl_len
		 )
      group by pairing_num, deg, cykl_len, stabilizer
 order by pairing_num, deg, stabilizer;
*/
                zag = new String[]{ " ", "Класс ", "Порядок эл-тов", "Цикл тип", "Число элементов Sn", "Число элементов группы"};
                from = new String[]{"stabilizer", "pairing_num", "deg", "cykl_len", "sss", "ggg"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item6;
                break;

            case 75:
/*  7. 1 Элементы подгруппы не содержащиеся в Sn 75
            "select distinct E._id _id, E.name name, E.substitution substitution, E.ciklos ciklos,\n" +
                    "        E.sylow_num sylow_num, E.switchboard_num switchboard_num, E.center_num center_num, \n" +
                    "        E.cykl_len cykl_len, E.pe pe, E.iteration iteration, E.nomer_soc nomer_soc, E.pairing_num pairing_num, P.class_area class_area  \n" +
                    "     from elements E, pairing_area P\n" +
                    "        where  P.id_subs = E._id and not E._id in\n" +
                    "        (select N.link_to_elements from elements_n N\n" +
                    "           where not N.link_to_elements is null\n" +
                    "        )  \n" +
                    "   order by E._id asc;",
*/
                zag = new String[]{ "Id", "Имя", "Подстановка", "В циклах",
                        "№№ подгрупп силова", "№ коммутатна", "Центр",
                        "Цикл тип", "P", "Итерация", "Цоколь", "Класс с объед центром",  "Класс без объединения" };
                from = new String[]{"_id", "name", "substitution", "ciklos",
                        "sylow_num", "switchboard_num", "center_num",
                        "cykl_len", "pe", "iteration", "nomer_soc", "pairing_num", "class_area"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13};
                colCount = 13;
                dbItem = R.layout.db_item13;
                break;

            case 76:
/*  7. 5 Пересечение подгруппы с Sn",  // 76
select distinct E._id _id, N.id_true id_true, E.name name, N.name name_n, E.substitution substitution, E.ciklos ciklos,
        E.sylow_num sylow_num, E.switchboard_num switchboard_num, E.center_num center_num,
        E.cykl_len cykl_len, E.pe pe, E.iteration iteration, E.nomer_soc nomer_soc, E.pairing_num pairing_num, N.pairing_num pairing_num_n,
		P.class_area class_area, PN.class_area class_area_n
     from elements E, pairing_area P, elements_n N, pairing_area_n PN
        where  P.id_subs = E._id and E._id = N.link_to_elements and	not N.link_to_elements is null and  PN.id_subs = N.id_true
   order by E._id asc
*/
                zag = new String[]{ "Id", "Id Sn", "Имя", "Имя Sn", "Подстановка", "В циклах",
                        "№№ подгрупп силова", "№ коммутатна", "Центр",
                        "Цикл тип", "P", "Итерация", "Цоколь", "Класс с объед центром", "Класс Sn с объед центром", "Класс без объединения",  "Класс Sn без объединения" };
                from = new String[]{"_id", "id_true", "name", "name_n",  "substitution", "ciklos",
                        "sylow_num", "switchboard_num", "center_num",
                        "cykl_len", "pe", "iteration", "nomer_soc", "pairing_num", "pairing_num_n",  "class_area", "class_area_n"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11,
                        R.id.db12, R.id.db13, R.id.db14, R.id.db15, R.id.db16, R.id.db17};
                colCount = 17;
                dbItem = R.layout.db_item19;
                break;

            case 77:
/* 7. 7 Порядки P подгрупп подгруппы и Sn"  // 77
          select 0 _id, pe, num_s, num_p, sum(yyy) sum_n, sum(xxx) sum_p
   from (
select distinct 0 _id, SN.pe pe, SN.num num_s, SM.num num_p, 0 yyy, count(*) xxx
                      from elements AA, elements_n BB, sylov_table SM, sylov_table_n SN
                       where AA._id = BB.link_to_elements and
                       AA._id = SM.id_s and BB.id_true = SN.id_s and
                       substr(BB.sylow_num,  (
                       select  substr( '0000', 1, 3 - length(S.num)) || S.num
                       from sylov_table_n S)
                       ) > 0
                       group by SN.pe, SN.num, SM.num
                       having count(*) > 1
     union all
select 0 _id, SN.pe pe, SN.num num_s, null num_p, count(id_s) yyy, 0 xxx
                      from sylov_table_n SN
                       group by SN.pe, SN.num
                       )
                       group by pe, num_s, num_p
                      order by  pe asc, num_s asc, num_p asc

*/
                zag = new String[]{ "P", "№ подгрупп силова Sn", "№ подгрупп силова в G", "Порядок подгруппы в Sn", "Число общих элементов"};
                from = new String[]{"pe", "num_s", "num_p", "sum_n", "sum_p"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5};
                colCount = 5;
                dbItem = R.layout.db_item5;
                break;

            case 78:

/* //  7. 2 Подгруппа в Sn "    78
            "select N.id_true, M._id _id, N.name nname, M.name mname,  N.cykl_len n_cykl, M.cykl_len m_cykl, N.ciklos ncik, M.ciklos  mcik,
             Pn.class_area n_class, PM.class_area m_class,\n" +
                    "   N.pairing_num npairing_num, M.pairing_num mpairing_num,  N.sylow_num nsylow_num, M.sylow_num msylow_num,N.center_num ncenter_num, M.center_num mcenter_num, \n" +
                    "    N.switchboard_num nswitchboard_num, M.switchboard_num mswitchboard_num, N.pe pe, \n" +
                    "    N.substitution nsubstitution, M.substitution  msubstitution\n" +
                    "       from elements_n N, elements M, pairing_area_n PN, pairing_area PM\n" +
                    "      where PN.id_subs = N.id_true and PM.id_subs = M._id and M._id = N.link_to_elements\n" +
                    "      union ALL\n" +
                    "select N.id_true, 0  _id, N.name nname, '' mname,  N.cykl_len n_cykl, '' m_cykl, N.ciklos as ncik, ''  mcik,
                      Pn.class_area n_class, null m_class,\n" +
                    "  N.pairing_num npairing_num, null mpairing_num,  N.sylow_num nsylow_num, null msylow_num,
                     N.center_num ncenter_num, null mcenter_num,\n" +
                    "    N.switchboard_num nswitchboard_num, null mswitchboard_num, N.pe pe,\n" +
                    "    N.substitution nsubstitution, null  msubstitution\n" +
                    "       from elements_n N, pairing_area_n PN\n" +
                    "      where PN.id_subs = N.id_true and N.link_to_elements is null\n" +
                    "            order by N.id_true  asc;"
 */
                zag = new String[]{ "Id Sn", "Id группы", "Имя в Sn", "Имя в группе", "Цикл тип Sn", "Цикл тип группы", "Циклы Sn", "Циклы группы",
                        "Класс Sn без объединения", "Класс группы без объединения", "Класс Sn с объед центром", "Класс группы с объед центром", "№№ подгрупп силова Sn", "№№ подгрупп силова группы",
                        "Центр Sn", "Центр группы",  "№ коммутатна Sn",  "№ коммутатна группы", "P",
                        "Подстановка в Sn", "Подстановка группы"};
                from = new String[]{"id_true", "_id", "nname", "mname",  "n_cykl", "m_cykl", "ncik", "mcik",
                        "n_class", "m_class",
                        "npairing_num", "mpairing_num",  "nsylow_num", "msylow_num",
                        "ncenter_num", "mcenter_num",  "nswitchboard_num", "mswitchboard_num", "pe",
                        "nsubstitution", "msubstitution"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11,
                        R.id.db12, R.id.db13, R.id.db14, R.id.db15, R.id.db16, R.id.db17, R.id.db18, R.id.db19, R.id.db20, R.id.db21};
                colCount = 21;
                dbItem = R.layout.db_item30;
                break;

            case 79:
/*
/   "7. 8 Общие элементы силовских подгрупп" 79
            "select  BB.pe pe, BB.sylow_num nnum, AA.sylow_num mnum, AA._id _id, BB.id_true id_true,\n" +
                    "    BB.name nname, AA.name mname,  BB.cykl_len n_cykl, AA.cykl_len m_cykl, BB.ciklos ncik, AA.ciklos  mcik\n" +
                    "   from elements AA, elements_n BB\n" +
                    "    where AA._id = BB.link_to_elements and\n" +
                    "    substr(BB.sylow_num,  (\n" +
                    "    select  substr( '0000', 1, 3 - length(S.num)) || S.num\n" +
                    "    from sylov_table_n S)\n" +
                    "    ) > 0\n" +
                    "   order by BB.pe,  BB.sylow_num asc, AA.sylow_num asc;\n"
 */
                zag = new String[]{ "P", "№№ Sn", "№№ группы", "Id Sn", "Id группы", "Имя в Sn", "Имя в группе", "Цикл тип Sn", "Цикл тип группы", "Циклы Sn", "Циклы группы"};
                from = new String[]{"pe", "nnum", "mnum", "id_true", "_id",    "nname", "mname",  "n_cykl", "m_cykl", "ncik", "mcik"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11};
                colCount = 11;
                dbItem = R.layout.db_item11d;
                break;

            case 80:
/*
//   "2.21. Классы p-жлементов по их степеням"           // 80
      "select 0 as _id, P.class_area class_area, E.pe, E.deg deg,  count(*) as chislo\n" +
                    "  from elements E, pairing_area P\n" +
                    "     where E._id = P.id_subs and E.pe > 0\n" +
                    "      group by E.deg, P.class_area, E.pe\n" +
                    "\t  union all\n" +
                    "select 0 as _id, P.class_area class_area, null pe, 'всего в классе' deg,   count(*) as chislo\n" +
                    "  from elements E, pairing_area P\n" +
                    "     where E._id = P.id_subs and P.class_area in (\n" +
                    "\t\tselect P.class_area class_area\n" +
                    "  from elements E, pairing_area P\n" +
                    "     where E._id = P.id_subs and E.pe > 0\n" +
                    "\t )\n" +
                    "      group by P.class_area\n" +
                    "\t  order by  P.class_area asc, E.deg asc;",
 */
                zag = new String[]{ "Класс", "P", "Степень элементов", "Число элементов"};
                from = new String[]{"class_area", "pe", "deg", "chislo"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4};
                colCount = 4;
                dbItem = R.layout.db_item4;
                break;

            case 81:
/* // 2.21. Классы силовских подгрупп по степеням элементов"  // 81
 select 0 as _id, E.deg deg, E.cykl_len cykl_len, P.class_area class_area, E.sylow_num, E.pe pe, count(*) as chislo
    from elements E, pairing_area P
           where E._id = P.id_subs
           group by E.deg, E.sylow_num, P.class_area, E.cykl_len, E.pe
  union all
    select 0 as _id, null deg, E.cykl_len cykl_len,  P.class_area class_area, null sylow_num, E.pe pe, count(*) as chislo
  from elements E, pairing_area P
         where E._id = P.id_subs and P.class_area in (
		select  P.class_area class_area
    from elements E, pairing_area P
           where E._id = P.id_subs
		 )
         group by E.deg, P.class_area, E.cykl_len,  E.pe
                      order by  P.class_area asc, E.deg asc, E.sylow_num;
*/
                zag = new String[]{  "Степень элементов", "Класс", "Цикл тип", "№№ подгрупп силова", "P", "Число элементов"};
                from = new String[]{"deg",  "class_area", "cykl_len", "sylow_num", "pe", "chislo"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item6;
                break;

            case 82:
 /* // 2.20. Число сопрягающих элементов силовских подгруппы с другими подгруппами"  // 82
select distinct 0   _id, M.pe as pe, V.num1 as num1, V.num2 as num2, P.class_area as pairing_num, M.deg as deg, M.cykl_len as cykl_len, Count(distinct P.class_area) chislo
                      from sylow_conj V, elements M,  pairing_area P
                     where V.id_conj = M._id and M._id = P.id_subs and V.num1 < V.num2
                       group by V.pe, V.num1, V.num2, P.class_area, M.deg, M.cykl_len
                       union all
                    select distinct 0 as  _id, M.pe as pe, 'всего в классе' as num1, null num2,  P.class_area as pairing_num, M.deg as deg, M.cykl_len as cykl_len, Count(distinct P.class_area) chislo
                      from  elements M,  pairing_area P
                     where  M._id = P.id_subs
                       group by M.pe, P.class_area, M.deg, M.cykl_len
                       order by pairing_num asc, deg asc, num1 asc
 */
                zag = new String[]{  "Класс", "Цикл тип сопрягаемого", "Порядок сопрягаемого", "№ подгруппы силова", "№ сопряженной подгруппы", "P", "Число сопряженных элементов"};
                from = new String[]{ "pairing_num", "cykl_len", "deg", "num1", "num2", "pe", "chislo"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7};
                colCount = 7;
                dbItem = R.layout.db_item7;
                break;

            case 83:

/* //   "2.23 Классы стабилизаторов     // 83
select distinct 0   _id, M.pe as pe, M.stabilizer as stabilizer,  P.class_area as pairing_num, M.deg as deg, M.cykl_len as cykl_len, Count(*) chislo
  from  elements M,  pairing_area P
 where  M._id = P.id_subs
   group by M.pe, M.stabilizer, P.class_area, M.deg, M.cykl_len
   union all
select distinct 0 as  _id, M.pe as pe, 'Все эл-ты' as stabilizer,  P.class_area as pairing_num, M.deg as deg, M.cykl_len as cykl_len, Count(*) chislo
  from  elements M,  pairing_area P
 where  M._id = P.id_subs
   group by M.pe, P.class_area, M.deg, M.cykl_len
   order by pairing_num, deg, stabilizer
 */
                zag = new String[]{  "Класс", "Цикл тип", "Степень элементов", "Неподвижные точки", "P", "Число элементов"};
                from = new String[]{ "pairing_num", "cykl_len", "deg",  "stabilizer", "pe", "chislo"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item6;
                break;

            case 84:
/*  2.23. Порядки нормализаторов силовских подгрупп"   // 84
select pe, num, 0 _id,  sum(ppp) sumn, sum(ggg) sgr from (
                        select N.pe pe, N.num num, 1 ppp, 0 ggg
                     from normalizer N
                        union ALL
                        select  pe, num as nom, 0 as ppp, 1 as ggg from sylov_table
                     )
                      group by pe, num
                        order by pe asc, num asc;
 */
                zag = new String[]{  "P", "№ силовской подгр-пы", "Порядок подгруппы", "Порядок нормализатора"};
                from = new String[]{ "pe", "num", "sgr", "sumn"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4};
                colCount = 4;
                dbItem = R.layout.db_item4;
                break;

            case 85:
/*  "4. 3. Порядки ядра и образа при эпиморфизме на силовские подгруппы"   85
select 0 id, pe, sum(ooo) obr, sum(jjj)/ sum(ooo) jdro from (
select pe, count(id_obraz) ooo, 0 jjj
  from epimorphism
  group by
  union ALL
select pe, 0 ooo, count(id_element) jjj
  from epimorphism
  group by pe
)
  group by pe
order by pe asc
*/
                zag = new String[]{  "P", "Порядок образа", "Порядок ядра"};
                from = new String[]{ "pe", "obr", "jdro"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;
                dbItem = R.layout.db_item3;
                break;

            case 86:
/* "1.14. Не сопряженные классы"       //  86
 select distinct 0 _id,  P.cykl_len, count( distinct P.class_area) ccc
          from elements E, pairing_area P
            where  P.id_subs = E._id
          GROUP by E.cykl_len
         having count(distinct P.class_area) > 1
        order by E.cykl_len asc
 */
                zag = new String[]{  "Цикл тип", "Число несопряженных классов"};
                from = new String[]{ "cykl_len", "ccc"};
                to = new int[]{R.id.db1, R.id.db2};
                colCount = 2;
                dbItem = R.layout.db_item2;
                break;

            case 87:
/*  "1.15. Не сопряженные группы подстановок"   // 87
select distinct EE._id  _id, Q.cykl_len cykl_len, Q.class_area cls, EE.substitution substitution, EE.ciklos ciklos
          from elements EE, pairing_area Q
          where Q.cykl_len in (
		  select distinct cykl_len from (
    select P.cykl_len cykl_len, count( distinct P.class_area)
          from elements E, pairing_area P
            where  P.id_subs = E._id
          GROUP by E.cykl_len
         having count(distinct P.class_area) > 1
        order by E.cykl_len asc
        ))  and Q.id_subs = EE._id
     order by Q.cykl_len asc, Q.class_area asc
 */
                zag = new String[]{  "Цикл тип", "Класс", "Подстановка", "В циклах", "Id"};
                from = new String[]{ "cykl_len", "cls", "substitution", "ciklos", "_id"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5};
                colCount = 5;
                dbItem = R.layout.db_item5;
                break;

            case 88:
/* //  7.10. Спектр группы и Sn"          // 88
select 0 as _id, deg, sum(dega) da,  sum(degs) ds  from (
   select deg, count(*) as dega, 0 degs from elements group by deg
   union ALL
   select deg, 0 as dega, count(*) degs from elements_n group by deg
   )
   group by deg
   order by deg asc;
 */
                zag = new String[]{  "Порядок элемента", "Число эл-тов в группе", "Число эл-тов в Sn"};
                from = new String[]{ "deg", "da", "ds"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;
                dbItem = R.layout.db_item3;
                break;

            case 89:
/*  7.11. спектр в разрезе классов
select 0 as _id, nnn,  clsa, deg, cykl_len, sum(dega) da,  sum(degs) ds  from (
        select '' nnn, deg, P.class_area clsa, P.cykl_len cykl_len, count(distinct E._id) as dega, 0 degs from elements E, pairing_area P
         where  P.id_subs = E._id
         group by deg, P.cykl_len, P.class_area
     union ALL
        select '' nnn, deg, P.class_area clsa, P.cykl_len cykl_len, 0 as dega, count(distinct E._id) degs from elements_n E, pairing_area_n P
          where  P.id_subs = E.id_true
         group by deg, P.cykl_len, P.class_area
                 union ALL
           select 'всего в классе' nnn, deg, P.class_area clsa, P.cykl_len cykl_len, count(distinct E._id) as dega, 0 degs
            from elements E, pairing_area P
           where  P.id_subs = E._id
           group by deg, P.cykl_len, P.class_area
                 union ALL
           select 'всего в классе' nnn, deg, P.class_area clsa, P.cykl_len cykl_len, 0 as dega, count(distinct E._id) degs
            from elements_n E, pairing_area_n P
           where  P.id_subs = E.id_true
           group by deg, P.cykl_len, P.class_area
   )
     group by deg, cykl_len, clsa, nnn
     order by deg asc, cykl_len asc, clsa asc;

 */
                zag = new String[]{ "Порядок элемента", "",  "Класс", "Цикл тип", "Число эл-тов в Sn", "Число эл-тов в группе"};
                from = new String[]{ "deg", "nnn", "clsa", "cykl_len", "ds", "da"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;
                dbItem = R.layout.db_item6;
                break;

            case 90:
/* 6. 3. Состав нормальных подгрупп с классами", // 90 soc_list
            "select _id,  num, num_klass, count_klass, deg, comm_level, even_flag, soc_level, centr_flag, dubl_flag, sylow_num, connon_sylow, " +
                    "sostav_type, sostav_count, summa_num, epi_pe\n" +
                    " from  soc_list\n" +
                    " order by dubl_flag asc, num_klass asc;",
 */
                zag = new String[]{ "№ подгруппы (класс подгруппы)", "Число классов в подгруппе", "Порядок подгруппы", "№ подгруппы цоколя",
                        "Подгруппа коммутанта уровня","Подгруппа всех четных подстановок", "Вся подгруппа цоколя", "Центр",  "P подгруппа", "Уровень p-подгруппы",
                        "Разлагается в сумму подгрупп", "Ядро эпиморфизма для P", "Подгруппа дублируется",
                        "Состав: класс - цикл тип", "Состав: класс - порядок класса"};
                from = new String[]{"num_klass", "count_klass", "deg", "num",
                        "comm_level","even_flag", "soc_level", "centr_flag", "sylow_num", "connon_sylow",
                        "summa_num", "epi_pe",
                        "dubl_flag", "sostav_type", "sostav_count"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14, R.id.db15};
                colCount = 15;
                dbItem = R.layout.db_item10_63;
                break;

            case 91:
/*   7.12. Классы стабилизаторов группы и Sn"   // 91
select distinct 0  _id, pe, stabilizer,  pairing_num, deg, cykl_len, sum(chisloS) sss, sum(chisloG) ggg from (
select distinct M.pe as pe, M.stabilizer as stabilizer,  P.class_area as pairing_num, M.deg as deg, M.cykl_len as cykl_len, Count(*) chisloS, 0 chisloG
         from  elements_n M,  pairing_area_n P
        where  M.id_true = P.id_subs
        group by M.pe, M.stabilizer, P.class_area, M.deg, M.cykl_len
           union all
select distinct M.pe as pe, M.stabilizer as stabilizer,  P.class_area as pairing_num, M.deg as deg, M.cykl_len as cykl_len, 0 chisloS, Count(*) chisloG
         from  elements M,  pairing_area P
        where  M._id = P.id_subs
        group by M.pe, M.stabilizer, P.class_area, M.deg, M.cykl_len
           union all
  select distinct  null as pe, 'Всего эл-тов в классе' as stabilizer,  P.class_area as pairing_num, M.deg as deg, M.cykl_len as cykl_len, 0 chisloS, Count(*) chisloG
         from  elements M,  pairing_area P
         where  M._id = P.id_subs
         group by P.class_area, M.deg, M.cykl_len
           union all
  select distinct  null as pe, 'Всего эл-тов в классе' as stabilizer,  P.class_area as pairing_num, M.deg as deg, M.cykl_len as cykl_len, Count(*) chisloS, 0 chisloG
         from  elements_n M,  pairing_area_n P
         where  M.id_true = P.id_subs
         group by P.class_area, M.deg, M.cykl_len
		 )
      group by pairing_num, deg, cykl_len, stabilizer
 order by pairing_num, deg, stabilizer;
 */
                zag = new String[]{  "Класс", "Цикл тип", "Степень элементов", "Неподвижные точки", "P", "Число элементов Sn", "Число элементов группы"};
                from = new String[]{ "pairing_num", "cykl_len", "deg",  "stabilizer", "pe", "sss", "ggg"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7};
                colCount = 7;
                dbItem = R.layout.db_item7;
                break;

            case 92:
/*  6.13. Таблица умножения цикловых типов"    //  92
select distinct 0 as _id,
              EA.cykl_len as cykl1, EB.cykl_len as cykl2, ER.cykl_len as cykl0
     from temp_multiplication_n M,
              elements_n EA, elements_n EB, elements_n ER
     where ER.id_true = M.idproiz and EA.id_true = M.idleft  and EB.id_true = M.idright
	 order by EA.cykl_len asc, EB.cykl_len asc;
 */
                zag = new String[]{  "Цикл тип 1 ","Цикл тип 2", "Цикл тип  произведения "};
                from = new String[]{ "cykl1", "cykl2", "cykl0" };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;
                dbItem = R.layout.db_item3;
                break;

            case 93:
/*  8. 1. Экспоненты",  //  93
               "select 0 _id, pe, val_exp  \n" +
                    "   from  exponent_n \n" +
                    "    order by pe asc;",
    */
                zag = new String[]{ "P",  "Экспонента"};
                from = new String[]{ "pe", "val_exp" };
                to = new int[]{R.id.db1, R.id.db2};
                colCount = 2;
                dbItem = R.layout.db_item2;
                break;

            case 94:
/*  "4.14. Таблица умножения цикловых типов p-элементов группы",    //  94
select distinct 0 as _id,
 EA.cykl_len as cykl1, EB.cykl_len as cykl2, ER.cykl_len as cykl0
   from temp_multiplication M,  elements EA, elements EB, elements ER
  where ER._id = M.idproiz and EA._id = M.idleft  and EB._id = M.idright
         and EA.pe > 0 and EB.pe > 0
    order by EA.cykl_len asc, EB.cykl_len asc;
 */
                zag = new String[]{ "Цикл тип A", "Цикл тип B", "Цикл тип A*B"};
                from = new String[]{ "cykl1", "cykl2", "cykl0" };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;
                dbItem = R.layout.db_item3;
                break;

            case 95:

/*  "4.10. Таблица умножения цикловых типов p-элементов Sn"    //
select distinct 0 as _id,
 EA.cykl_len as cykl1, EB.cykl_len as cykl2, ER.cykl_len as cykl0
   from temp_multiplication_n M,  elements_n EA, elements_n EB, elements_n ER
  where ER._id = M.idproiz and EA._id = M.idleft  and EB._id = M.idright
         and EA.pe > 0 and EB.pe > 0
    order by EA.cykl_len asc, EB.cykl_len asc;
 */
                zag = new String[]{ "Цикл тип A", "Цикл тип B", "Цикл тип A*B"};
                from = new String[]{ "cykl1", "cykl2", "cykl0" };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;
                dbItem = R.layout.db_item3;
                break;

            case 96:

/* //  8. 2. Экспоненты Sn",
            "select 0 _id, pe, val_exp  \n" +
                    "   from  exponent_n \n" +
                    "    order by pe asc;",
*/
                zag = new String[]{ "P",  "Экспонента"};
                from = new String[]{ "pe", "val_exp" };
                to = new int[]{R.id.db1, R.id.db2};
                colCount = 2;
                dbItem = R.layout.db_item2;
                break;

            case 97:
/*  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
    from Elements E, exponent Q, pairing_area P
  where E.pe = Q.pe and E.deg = Q.val_exp and P.id_subs = E._id
  order by E.pe asc, E.cykl_len asc
 */
                zag = new String[]{ "Id", "P", "Циклы", "Порядок эл-та,", "Цикл тип",
                        "№ подгр-пы силова", "Класс", "Имя эл-та"};
                from = new String[]{ "_id", "pe", "ciklos", "deg", "cykl_len",
                        "sylow_num", "pairing_num", "namee"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8};
                colCount = 8;
                dbItem = R.layout.db_item9;
                break;

            case 98:
/*    "7.13. Силовские подгруппы в Sn",  //  98
  select id_true,  _id, pe, nsylow_num, msylow_num, n_cykl, m_cykl, ncik, mcik, n_class, m_class,
       ncenter_num, mcenter_num,
      nswitchboard_num, mswitchboard_num, nname, mname,
      nsubstitution, msubstitution from (
select N.id_true id_true, M._id _id, N.name nname, M.name mname,  N.cykl_len n_cykl, M.cykl_len m_cykl, N.ciklos ncik, M.ciklos  mcik,  Pn.class_area n_class, PM.class_area m_class,
                        N.sylow_num nsylow_num, M.sylow_num msylow_num,N.center_num ncenter_num, M.center_num mcenter_num,
                        N.switchboard_num nswitchboard_num, M.switchboard_num mswitchboard_num, N.pe pe,
                        N.substitution nsubstitution, M.substitution  msubstitution
                           from elements_n N, elements M, pairing_area_n PN, pairing_area PM
                          where PN.id_subs = N.id_true and PM.id_subs = M._id and M._id = N.link_to_elements
                          union ALL
  select N.id_true id_true, 0  _id, N.name nname, '' mname,  N.cykl_len n_cykl, '' m_cykl, N.ciklos as ncik, ''  mcik,  Pn.class_area n_class, null m_class,
                       N.sylow_num nsylow_num, null msylow_num, N.center_num ncenter_num, null mcenter_num,
                        N.switchboard_num nswitchboard_num, null mswitchboard_num, N.pe pe,
                        N.substitution nsubstitution, null  msubstitution
                           from elements_n N, pairing_area_n PN
                          where PN.id_subs = N.id_true and N.link_to_elements is null
  )  where not nsylow_num is null
      order by pe asc, nsylow_num  asc, msylow_num  asc;
 */
                zag = new String[]{ "P", "№ подгр-пы силова Sn","№ подгр-пы силова группы", "Id Sn", "Id гр-пы",
                        "Цикл тип Sn", "Цикл тип группы", "Циклы Sn", "Циклы группы", "Класс Sn", "Класс группы",
                        "Порядок централизатора Sn", "Порядок централизатора гр-пы",
                        "№ коммутанта Sn", "№ коммутанта гр-пы", "Имя Sn",  "Имя в гр-пе", "Подстановка Sn", "Подстановка гр-пы"};
                from = new String[]{ "pe", "nsylow_num", "msylow_num", "id_true", "_id",
                        "n_cykl", "m_cykl", "ncik", "mcik", "n_class", "n_class",
                        "ncenter_num", "mcenter_num",  "nswitchboard_num", "mswitchboard_num", "nname", "mname", "nsubstitution", "msubstitution"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12,
                        R.id.db13, R.id.db14, R.id.db15, R.id.db16, R.id.db17, R.id.db18, R.id.db19};
                colCount = 19;
                dbItem = R.layout.db_item19;
                break;

            case 99:
/*  "7.14. Отдельная силовская подгруппа группы в Sn"  //  99

select  DISTINCT pe, num, nump,  _id, idp, cykl_len, cykl_lenp, ciklos,  ciklosp, deg, degp,
                                pairing_num, pairing_nump,  center_num,
                                switchboard_num,  parity from (
                            select  S.pe as pe, S.num as num, null nump, E.id_true as _id, null idp,  E.cykl_len cykl_len, null cykl_lenp ,
                            E.ciklos as ciklos, null ciklosp, E.deg as deg,  null  degp, E.pairing_num as pairing_num,  null pairing_nump,
                                E.center_num as center_num, E.sylow_num sylow_num, null  sylow_nump,
                                null switchboard_num,  E.parity as parity
                            from elements_n E, sylov_table_n S
                              where S.id_s = E.id_true and E.link_to_elements is null
                              union all
                            select  S.pe as pe, S.num as num, SM.num nump, E.id_true as _id, M._id idp,  E.cykl_len cykl_len, M.cykl_len cykl_lenp ,
                            E.ciklos as ciklos, M.ciklos ciklosp, E.deg as deg, M.deg degp, E.pairing_num as pairing_num, M.pairing_num pairing_nump,
                                E.center_num as center_num, E.sylow_num sylow_num, M.sylow_num sylow_nump,
                                M.switchboard_num as switchboard_num,  E.parity as parity
                            from elements_n E, sylov_table_n S, elements M, sylov_table SM
                              where S.id_s = E.id_true and E.link_to_elements = M._id and SM.id_s = M._id and  not E.link_to_elements is null
                              )  where nump = 25 and deg > 0
                             order by  pe asc, num asc, nump asc, cykl_len asc;

                    SQL = "select  pe, num, nump,  _id, idp, sylow_num, sylow_nump, cykl_len, cykl_lenp, ciklos,  ciklosp, deg, degp,\n" +
                            "    pairing_num, pairing_nump,  center_num,\n" +
                            "    switchboard_num,  parity from (\n" +
                            "select  S.pe as pe, S.num as num, null nump, E.id_true as _id, null idp,  E.cykl_len cykl_len, null cykl_lenp ,\n" +
                            "E.ciklos as ciklos, null ciklosp, E.deg as deg,  null  degp, E.pairing_num as pairing_num,  null pairing_nump,\n" +
                            "    E.center_num as center_num, E.sylow_num sylow_num, null  sylow_nump,\n" +
                            "    null switchboard_num,  E.parity as parity\n" +
                            "from elements_n E, sylov_table_n S\n" +
                            "  where S.id_s = E.id_true and E.link_to_elements is null\n" +
                            "  union all\n" +
                            "select  S.pe as pe, S.num as num, SM.num nump, E.id_true as _id, M._id idp,  E.cykl_len cykl_len, M.cykl_len cykl_lenp ,\n" +
                            "E.ciklos as ciklos, M.ciklos ciklosp, E.deg as deg, M.deg degp, E.pairing_num as pairing_num, M.pairing_num pairing_nump,\n" +
                            "    E.center_num as center_num, E.sylow_num sylow_num, M.sylow_num sylow_nump,\n" +
                            "    M.switchboard_num as switchboard_num,  E.parity as parity\n" +
                            "from elements_n E, sylov_table_n S, elements M, sylov_table SM\n" +
                            "  where S.id_s = E.id_true and E.link_to_elements = M._id and SM.id_s = M._id and  not E.link_to_elements is null\n" +
                            "  )  where nump = " + nomerPodgrup[0] + " and deg > 0\n" +
                            " order by  pe asc, num asc, nump asc, cykl_len asc;";
 */
                zag = new String[]{ "P", "№ подгр-пы силова Sn","№ подгр-пы силова группы",  "Id Sn", "Id гр-пы",
                        "№№ силова Sn", "№№ силова гр-пы",
                        "Цикл тип Sn", "Цикл тип группы", "Циклы Sn", "Циклы группы", "Порядок эл-та Sn", "Порядок эл-та гр-пы",
                        "Класс Sn", "Класс группы",
                        "Порядок централизатора Sn", "Порядок централизатора гр-пы",
                        "№ коммутанта группы", "Четность"};
                from = new String[]{ "pe", "num", "nump",  "_id", "idp",  "sylow_num", "sylow_nump",
                        "cykl_len", "cykl_lenp", "ciklos", "ciklosp", "deg", "degp",
                        "pairing_num", "pairing_nump",  "center_num", "switchboard_num", "parity"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12,
                        R.id.db13, R.id.db14, R.id.db15, R.id.db16, R.id.db17, R.id.db18};
                colCount = 18;
                dbItem = R.layout.db_item19;
                break;

            case 100:
/* "9. 4. Коммутант силовской подгруппы",      // 100
select distinct T.num num,  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, sylov_table T
         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 T.id_s = R._id and T.num = 3
		 order by PM.class_area asc, M.deg asc,  M.cykl_len asc
*/
                zag = new String[]{ "№ заданной подгр-пы", "P", "Id", "№ подгр-пы силова эл-та","Класс коммутатора в гр-пе",
                        "Циклы", "Цикл тип", "Порядок", "№ коммутанта всей группы"};
                from = new String[]{ "num", "pe", "_id",  "sylow_num",  "class",  "ciklos", "cl", "deg", "switch"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9};
                colCount = 9;
                dbItem = R.layout.db_item9;
                break;

            case 101:
/*  Структура силовской подгруппы",           // 101
select 0 _id, T.num numsyl, id_1  idl,  idm idmain, id_2 iditog, class0, classM, gpe,  syl_g, syl_0,
                                              degn,  degg,  deg0,
                                               sw_g, sw_0,  sw_s,
                                                ciklos0, ciklosM, lystm, forming0  from (
                                               select id_1, id_s idm, id_2, P.class_area class0, null classM, G.pe gpe, 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  idm, id_2, P.class_area class0, PM.class_area classM, G.pe gpe, 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
                                             ), sylov_table T
                                              where  T.id_s =  idm and T.num = 39
                                                order by  idm asc, id_1 asc, id_2 asc, syl_g asc;

select 0 _id, T.num numsyl, id_1  idl,  idm idmain, id_2 iditog, class0, classM, gpe,  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, 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

 */
                zag = new String[]{ "№ запрошенной подгр-пы силова", "№ p-подгр-пы куда входит эл-нт", "P", "Id 1-го множителя", "Id исходный",
                        "Id результата","Класс исходный", "Класс результата",
                        "№ подгр-пы силова исходной", "Степень исходного", "Порядок результата", "Порядок исходного",
                        "Признак коммутанта сил подгр результата", "Признак коммутанта исходного гр-пы", "Признак коммутанта сил подгр исходного",
                        "Циклы исходного", "Циклы результата", "Id-ы результата","Id-ы исходного"};
                from = new String[]{ "numsyl", "syl_g",  "gpe",  "idl", "idmain",
                        "iditog", "class0", "classM",
                        "syl_0", "degn", "degg", "deg0",
                        "sw_g", "sw_0", "sw_s",
                        "ciklos0", "ciklosM", "lystm", "forming0"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12,
                        R.id.db13, R.id.db14, R.id.db15, R.id.db16, R.id.db17, R.id.db18, R.id.db19};
                colCount = 19;
                dbItem = R.layout.db_item19;
                break;

            case 102:
/* "9. 4. Разбиение классов"   // код сопряженного элемента = (idleft**-1) * idright * idleft           // 102
            "select 0  _id, PL.class_area cls1, L.cykl_len lel1, PR.class_area cls2, R.cykl_len lel2, Pm.class_area cls3, M.cykl_len lel3, \n" +
                    "count( distinct L._id)  p_l, count( distinct R._id)  p_r,  count( distinct M._id) p_m \n" +
                    "  from switchboard S, elements L, elements R, elements M, \n" +
                    "      pairing_area PL, pairing_area PR, pairing_area PM \n" +
                    "   where L._id = S.id_left and R._id = S.id_right and M._id = S.id_pair and \n" +
                    "         PL.id_subs = L._id and PR.id_subs = R._id and PM.id_subs = M._id \n" +
                    "   group by PL.class_area, PR.class_area, PM.class_area \n" +
                    "  order by PM.class_area asc, PR.class_area asc, Pl.class_area asc;",
 */
                zag = new String[]{ "Класс сопрягателя", "Его цикл тип", "Класс исходного", "Его цикл тип",
                        "Класс сопряженного", "Его цикл тип", "Число сопрягателей", "Число исходных", "Число сопряженных"};
                from = new String[]{ "cls1", "lel1", "cls2", "lel2",
                        "cls3", "lel3", "p_l", "p_r", "p_m"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9};
                colCount = 9;
                dbItem = R.layout.db_item9;

                if (DISPLAYLOG)
                    Log.e(TAG, "f_calcPrim myOtchet index =" + index + " colCount = " + colCount );

                break;

            case 103:
/* // 1.16. Порядки классов в разрезе цикловых типов "            // 103
select  0 _id, P.class_area, E.cykl_len cykl_len, count(E._id) xxx
  from elements E, pairing_area P
  where P.id_subs = E._id
  group by class_area, E.cykl_len
  order by class_area asc
  */
                zag = new String[]{ "Класс","Цикл тип", "Число эл-тов"};
                from = new String[]{ "class_area", "cykl_len", "xxx"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;
                dbItem = R.layout.db_item3;
                break;

            case 104:
//
                zag = new String[]{"Id", "№ класса сопряженных эл-тов", "Выражение через образующие", "Подстановка", "Вид в циклах", "Порядок элемента", "P",
                        "Является степенью цикл силовской подгруппы", "Входит в подгруппу силова с №", "Цикленный тип", "Порядок централизатора", "№ коммутанта", "Стабилизатор для", "Получен на итерации", "0 - четная", "Входит в цоколь ?",
                        "_id осн группы", "_id Sn"};
                from = new String[]{"_id", "pairing_num", "name", "substitution", "ciklos", "deg", "pe", "primitiv", "sylow_num", "cykl_len", "center_num", "switchboard_num", "stabilizer", "iteration", "parity", "nomer_soc",
                        "link_to_group", "link_to_sn"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14, R.id.db15, R.id.db16, R.id.db17, R.id.db18};
                colCount = 18;
                dbItem = R.layout.db_item19;
                break;

            case 105:
/* // 105  9. 2  Группа внутренних автоморфизмов",   // 105
            "select E._id as _id, A._id as ida, E.substitution as substitution, E.pairing_num as pairing_num, A.pairing_num as pairing_a, " +
                    "E.ciklos as ciklos, A.ciklos as ciklosa, E.cykl_len as cykl_len, A.cykl_len as cykl_a, " +
                    " E.deg as deg, A.deg as dega, E.pe as pe, A.pe as pea, \n" +
                    "  E.sylow_num as sylow_num, A.sylow_num as sylow_numa, E.switchboard_num as switchboard_num, A.switchboard_num as switchboard_a,\n" +
                    "   E.nomer_soc as nomer_soc, A.nomer_soc as nomer_soca " +
                    "    from elements_a A, elements E " +
                    "      where E._id = A.E.link_to_group \n" +
                    "     order by A.ciklos asc;",
 */
                zag = new String[]{"Id G", "Id A",  "Подстановка G", "№ класса сопряж эл-тов G", "№ класса сопряж эл-тов A", "Вид в циклах G", "Вид в циклах A",
                        "Цикленный тип G", "Цикленный тип A",
                        "Порядок элемента G", "Порядок элемента A", "Степень простого G", "Степень простого A",
                        "№ сил под-п G", "№ сил под-п A", "№ коммутанта G", "№ коммутанта A",
                        "Входит в цоколь G?", "Входит в цоколь A?"
                        };
                from = new String[]{"_id", "ida", "substitution", "pairing_num", "pairing_a", "ciklos", "ciklosa", "cykl_len", "cykl_a",
                        "deg", "dega", "pe", "pea",
                        "sylow_num", "sylow_numa", "switchboard_num", "switchboard_a",
                        "nomer_soc",  "nomer_soca"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14, R.id.db15, R.id.db16, R.id.db17, R.id.db18, R.id.db19};
                colCount = 19;    // колонок в таблицк
                dbItem = R.layout.db_item19;
                break;

            case 106:
/* 106 9. 3  Порядки силовских подгрупп группы автоморфизмов",    // 106
 select 0 _id,  pe, num, sum(ccc) aaa,  sum(ooo) ggg from (
select num, pe, count(id_s) as ccc, 0 ooo
    from sylov_table_a
        group by  num, pe
  union ALL
  select num, pe,  0 ccc,  count(id_s) as ooo
    from sylov_table
        group by  num, pe
		)
        group by  num, pe
   order by pe asc, num asc;  */
                zag = new String[]{ "P",  "№ сил подгруппы", "Порядок подгруппы группы автом-мов", "Порядок исходной подгруппы"};
                from = new String[]{"num", "pe", "aaa", "ggg"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4};
                colCount = 4;
                dbItem = R.layout.db_item4;
                break;

            case 107:
/* 107 9. 4  Изменение циклового типа при автоморфизмах",    // 107
            "select A._id, A.ciklos aciklos, E._id old_id, O._id new_id, E.ciklos old_ciklos, O.ciklos new_ciklos, \n" +
                    "E.pairing_num old_pairing, O.pairing_num new_pairing, E.cykl_len old_cykl_len, O.cykl_len new_cykl, \n" +
                    "E.substitution old_s, O.substitution new_s, A.link_to_group, A.name\n" +
                    "from  elements E, elements O, elements_a A,  sub_scribe_a F\n" +
                    "where F.id_s = A._id and O._id = substr(F.text_sub, 2 + 5*(E._id - 1), 4) AND\n" +
                    " not E.cykl_len = O.cykl_len\n" +
                    " order by A._id asc, E._id asc;",

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
 not E.cykl_len = O.cykl_len
 order by A._id asc, E._id asc
*/
                zag = new String[]{ "ID авто-ма", "Цикл авто-ма", "ID G", "ID образа", "Циклы", "Циклы образа",
                        "Класс G", "Класс образа", "Цикл тип", "Цикл тип образа", "Подстановка", "Подстановка образа", "Автом-зм сопряжения или 0", "Имя автоморфизма" };
                from = new String[]{"_id", "aciklos", "old_id", "new_id", "old_ciklos", "new_ciklos",
                        "old_pairing", "new_pairing", "old_cykl_len", "new_cykl",
                        "old_s", "new_s", "link_to_group", "name"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14};
                colCount = 14;    // колонок в таблицк
                dbItem = R.layout.db_item19;
                break;
            case 108: //   " 9. 5  Действие выбранного автоморфизма",    // 108
            case 109:  // " 9. 6  Действие всех автоморфизмов на выбранный элемент группы",    // 109
/*                        SQL =   "select A._id _id, A.ciklos aciklos, E._id old_id, O._id new_id, E.ciklos old_ciklos, O.ciklos new_ciklos,\n" +
                            "E.pairing_num old_pairing, O.pairing_num new_pairing, E.cykl_len old_cykl_len, O.cykl_len new_cykl,\n" +
                            "E.sylow_num syl_old, O.sylow_num syl_new, \n" +
                            "E.substitution old_s, O.substitution new_s, A.link_to_group, A.name\n" +
                            "from  elements E, elements O, elements_a A,  sub_scribe_a F\n" +
                            "where F.id_s = A._id and O._id = substr(F.text_sub, 2 + 5*(E._id - 1), 4) AND\n" +
                            " E._id = " + nomerPodgrup[0] + "\n" +
                            " order by O._id asc, E._id asc;";

 */
                zag = new String[]{ "ID авто-ма", "Цикл авто-ма", "ID G", "ID образа", "Циклы", "Циклы образа", "№ сил под-п", "№ сил под-п образа",
                        "Класс G", "Класс образа", "Цикл тип", "Цикл тип образа", "Подстановка", "Подстановка образа", "Автом-зм сопряжения или 0", "Имя автоморфизма" };
                from = new String[]{"_id", "aciklos", "old_id", "new_id", "old_ciklos", "new_ciklos", "syl_old", "syl_new",
                        "old_pairing", "new_pairing", "old_cykl_len", "new_cykl",
                        "old_s", "new_s", "link_to_group", "name"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11, R.id.db12, R.id.db13, R.id.db14, R.id.db15, R.id.db16};
                colCount = 16;    // колонок в таблицк
                dbItem = R.layout.db_item19;
                break;

            case 110:
/*  9. 7  Подгруппы неподвижных элементов автоморфизмов ",    // 110
            "select  0  _id, srt, aid, aciklos, old_id,  new_ciklos, sylow_num, pairing, cykl_len, old_s, link_to_group, ccc itogo from (\n" +
  select A._id aid, A.ciklos aciklos, E._id old_id,  E.ciklos new_ciklos,  0 srt,
      E.pairing_num pairing, E.cykl_len cykl_len,
      E.substitution old_s,  A.link_to_group link_to_group, 0 ccc
 from  elements E, elements_a A,  sub_scribe_a F
    where F.id_s = A._id and E._id = substr(F.text_sub, 2 + 5*(E._id - 1), 4)
  union all
 select A._id aid, A.ciklos aciklos, null old_id,  null new_ciklos,  1 srt,
      null pairing, 'Итого по подгруппе' cykl_len,
      null old_s,  null link_to_group, count(E._id) ccc
 from  elements E, elements_a A,  sub_scribe_a F
    where F.id_s = A._id and E._id = substr(F.text_sub, 2 + 5*(E._id - 1), 4)
    group by A._id, A.ciklos, srt
     order by srt asc, aid asc
)
    group by srt, aid, aciklos, old_id,  new_ciklos, pairing, cykl_len, old_s, link_to_group, srt
     order by aid asc, srt asc;

select  0  _id, srt, aid, aciklos, old_id,  new_ciklos, sylow_num, pairing, cykl_len, old_s, link_to_group, ccc itogo from (\n" +
     */
              zag = new String[]{ "ID авто-ма", "Цикл авто-ма", "ID",  "Циклы", "№ сил под-п",
                      "Класс", "Цикл тип", "Подстановка",  "Автом-зм сопряжения или 0", "Порядок под-пы" };
              from = new String[]{"aid", "aciklos", "old_id", "new_ciklos", "sylow_num",
                      "pairing", "cykl_len", "old_s", "link_to_group", "itogo"
              };
              to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10};
              colCount = 10;    // колонок в таблицк
              dbItem = R.layout.db_item10;
              break;

            case 111:
/* 9. 8  Централизатор группы в Sn ",    // 111
            "select  A._id _id, A.ciklos aciklos, A.cykl_len cykl_len, A.pe pe, A.deg deg, A.pairing_num pairing_num " +
                    " from elements_a A, auto_centralizer C " +
                    " where A.-id = C.id_sn",
 */
                zag = new String[]{ "ID Sn", "Цикл Sn", "Цикл тип", "P", "Класс" };
                from = new String[]{"_id", "aciklos", "cykl_len", "pe", "deg", "pairing_num"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5};
                colCount = 5;    // колонок в таблицк
                dbItem = R.layout.db_item5;
                break;

            case 112:
/*  9. 9  Нормализатор группы в Sn",    // 112
                    "select  A._id _id, A.ciklos aciklos, A.cykl_len, A.pe, A.deg, A.pairing_num " +
                            " from elements_a A, auto_centralizer C " +
                            " where A.-id = C.id_sn",
 */
                zag = new String[]{ "ID Sn", "Цикл Sn", "Цикл тип", "P", "Класс" };
                from = new String[]{"_id", "aciklos", "cykl_len", "pe", "deg", "pairing_num"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5};
                colCount = 5;    // колонок в таблицк
                dbItem = R.layout.db_item5;
                break;

            case 113:
/*  9.10  Образы классов группы",    // 113
         "select  A._id _id, A.class_in cin, A.class_out cout, A.chararter chararter, A.porjadok porjadok, cykl_in, cykl_out " +
                " from charac_class A " +
                    " order by 1 asc, 2 asc;",
 */
                zag = new String[]{ "Класс сопряж эл-тов", "Его образ", "Сохраняется при всех автоморфизмах", "Порядок класса",
                        "Цикл типы класса", "Цикл типы образа"};
                from = new String[]{"cin", "cout", "chararter", "porjadok", "cykl_in", "cykl_out"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;    // колонок в таблицк
                dbItem = R.layout.db_item6;
                break;

            case 114:
/*  9.12  Образы цикловых типов группы",   // 114
            "select  A._id  _id, A.cykl_in cin, A.cykl_out cout, A.chararter chararter, A.porjadok porjadok, classes_in, classes_out " +
                            " from charac_cykls A " +
                            " order by 1 asc, 2 asc;",
*/
                zag = new String[]{ "Цикл тип", "Его образ", "Сохраняется при всех автоморфизмах", "Порядок класса",
                        "Классы цикл типа", "Классы образа цикл типа"};
                from = new String[]{"cin", "cout", "chararter", "porjadok", "classes_in", "classes_out"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6};
                colCount = 6;    // колонок в таблицк
                dbItem = R.layout.db_item6;
                break;

            case 115:
/*    // 9.13  Характеристические подгруппы ",   // 115
            "select  A._id _id, A.num_subs num_subs, A.porjadok cout, A.cykl_len \n" +
                    "                     from charac_group A \n" +
                    "                     order by 1 asc;",

*/
                zag = new String[]{ "№ подгруппы", "Её порядок", "Циклы"  };
                from = new String[]{"num_subs", "cout", "cykl_len"   };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3};
                colCount = 3;    // колонок в таблицк
                dbItem = R.layout.db_item3;
                break;

            case 116:
/*  // 9. 8  Порядки подгрупп неподвижных элементов автоморфизмов", // 116
  "select A._id _id, A.link_to_group link_to_group, A.ciklos aciklos, A.pe pe, A.pairing_num pairing_num, A.sylow_num sylow_num," +
                    "A.switchboard_num switchboard_num, A.center_num center_num, count(E._id) ccc \n" +
                    "from  elements E, elements_a A, sub_scribe_a F\n" +
                    "where F.id_s = A._id and E._id = substr(F.text_sub, 2 + 5*(E._id - 1), 4) " +
                    " group by A._id, A.ciklos, A.pe, A.pairing_num, A.sylow_num" +
                    " order by A._id asc, E._id asc;",
 */
                zag = new String[]{ "ID ав-ма", "Внутренний?", "Его циклы", "P авт-ма", "Класс",  "№ сил под-п",
                        "Коммутант", "Центр", "Порядок подгруппы"
                };
                from = new String[]{"_id", "link_to_group",  "aciklos", "pe", "pairing_num", "sylow_num",
                        "switchboard_num", "center_num", "ccc"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9};
                colCount = 9;    // колонок в таблицк
                dbItem = R.layout.db_item9;
                break;

            case 117:
/* //  " 9.14  Образы нормальных подгрупп",  //      117
            "SELECT distinct 0 _id, num_in, num_out, porjadok, harac \n" +
                    "from (\n" +
                    "SELECT distinct  A.num_in num_in, A.num_out num_out, A.porjadok porjadok, 1 harac\n" +
                    "  FROM auto_group A, charac_group H\n" +
                    "   where H.num_subs = num_in and H.num_subs = num_out \n" +
                    "  union all \n" +
                    "SELECT distinct  A.num_in num_in, A.num_out num_out, A.porjadok porjadok, 0 harac\n" +
                    "  FROM auto_group A \n" +
                    "   where A.num_in not in (\n" +
                    "     select HH.num_subs from charac_group HH\n" +
                    "    )\n" +
                    ")\n" +
                    "order by num_in asc, num_out asc;",
 */
                zag = new String[]{ "№ подгруппы", "№ ее образа", "Порядок под-пы", "Характеристическая?"
                };
                from = new String[]{"num_in", "num_out",  "porjadok", "harac"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4};
                colCount = 4;
                dbItem = R.layout.db_item4;
                break;

            case 118:
/* //   " 9.15  Образы силовских подгрупп",  //      118
            SELECT 0 _id, S.pe pe, num_in, num_out, count(S.id_s) ccc from (
  SELECT distinct 0 _id, C.pe pe, C.num_in num_in, C.num_out num_out
    FROM charac_sylow C
), sylov_table S
  where num_in = S.num
group by S.pe, num_in, num_out
order by S.pe, num_in, num_out
 */
                zag = new String[]{"P", "№ подгруппы", "№ ее образа", "Порядок под-пы"
                };
                from = new String[]{"pe", "num_in", "num_out",  "ccc"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4};
                colCount = 4;
                dbItem = R.layout.db_item4;
                break;

            case 119:
/*   " 9.16  Образы силовских подгрупп с автоморфизмами",  //      119
            "SELECT distinct 0 _id, C.pe pe, C.num_in num_in, C.num_out num_out, \n" +
                    "  C.id_auto id_auto, A.Pe ape, A.ciklos ciklos, A.cykl_len cykl_len, A.link_to_group lgr, A.link_to_sn lsn   \n" +
                    "    FROM charac_sylow C, elements_a A \n" +
                    "    where A._id = C.id_auto \n" +
                    "order by C.id_auto asc, C.pe, num_in, num_out;",
*/
                zag = new String[]{ "ID авто-ма", "P", "№ под-пы", "№ её образа",
                        "P автом-ма", "Циклы авто-ма", "Цикл тип авто-ма", "Внутренний G?",  "Внутренний Sn" };
                from = new String[]{"id_auto", "pe", "num_in", "num_out",
                        "ape", "ciklos", "cykl_len", "lgr", "lsn"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9};
                colCount = 9;    // колонок в таблицк
                dbItem = R.layout.db_item19;
                break;

            case 120:
/*    " 9.17  Образы цикловых типов с автоморфизмами",  //      120
    "select 0 as _id,  num,  ccc as itog_sub from (\n" +
                    "  select  S.num_maim as num, count( P.id_subs ) as ccc \n" +
                    "     from pairing_area_a P, sub_structure_a S\n" +
                    "        where P.class_area = S.num_subs\n" +
                    "     group by S.num_maim \n" +
                    ") order by num asc;",
*/
                zag = new String[]{ "ID авто-ма", "Цикл тип", "Цикл тип образа",
                        "P автом-ма", "Циклы авто-ма", "Цикл тип авто-ма", "Внутренний G?",  "Внутренний Sn" };
                from = new String[]{"id_auto", "cykl_in", "cykl_out",
                        "ape", "ciklos", "cykl_len", "lgr", "lsn"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8};
                colCount = 8;    // колонок в таблицк
                dbItem = R.layout.db_item19;
                break;

            case 121:
/*  " 9.19  Образы классов с автоморфизмами",  //      121
                    "SELECT  0 _id, C.id_auto id_auto, C.class_in class_in, C.class_out class_out,\n" +
                            "   A.Pe ape, A.ciklos ciklos, A.cykl_len cykl_len, A.link_to_group lgr, A.link_to_sn lsn   \n" +
                            "FROM auto_class C, elements_a A\n" +
                            "    where A._id = C.id_auto  \n" +
                            "order by C.id_auto asc, C.class_in asc, C.class_out asc"
*/
                zag = new String[]{ "ID авто-ма", "№ класса сопр эл-тов", "№ его образа",
                        "P автом-ма", "Циклы авто-ма", "Цикл тип авто-ма", "Внутренний G?",  "Внутренний Sn" };
                from = new String[]{"id_auto", "class_in", "class_out",
                        "ape", "ciklos", "cykl_len", "lgr", "lsn"
                };
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8};
                colCount = 8;    // колонок в таблицк
                dbItem = R.layout.db_item19;
                break;

            case 122:
/* // 9.17  Нормальные подгруппы группы автоморфизмов их порядки",  //      122
            "select 0 as _id,  num,  sum(ccc) as itog_sub from (\n" +
                    "  select  S.num_maim as num, count( P.id_subs ) as ccc \n" +
                    "     from pairing_area_a P, sub_structure_a S\n" +
                    "        where P.class_area = S.num_subs\n" +
                    "     group by S.num_maim \n" +
                    ") order by num asc;",
 */
                zag = new String[]{ "№ подгруппы", "Её порядок" };
                from = new String[]{"num", "itog_sub"
                };
                to = new int[]{R.id.db1, R.id.db2};
                colCount = 2;
                dbItem = R.layout.db_item19;
                break;

            case 123:
/*   " 9.18  Внутренние автоморфизмы",  //      123
            " SELECT B._id _id, \n" +
                    "            A.Pe ape, B.Pe bpe, A.name aname, B.name bname, A.ciklos aciklos, B.ciklos bciklos, A.cykl_len acykl_len, B.cykl_len bcykl_len,\n" +
                    "            A.deg adeg, B.deg bdeg, A.center_num acenter_num, B.center_num  bcenter_num, \n" +
                    "            A.stabilizer astabilizer, B.stabilizer bstabilizer, A.sylow_num asylow_num, B.sylow_num bsylow_num, A.pairing_num apairing_num, B.pairing_num bpairing_num,\n" +
                    "            A.link_to_sn lsn \n" +
                    "      FROM elements_a A, elements B \n" +
                    "      where B._id = A.link_to_group  \n" +
                    "       order by B._id asc;",
*/
                  zag = new String[]{"Id G", "P A",  "P G", "Имя A", "Имя G", "Вид в циклах A", "Вид в циклах G", "Цикл тип A", "Цикл тип G",
                          "Порядок эл-та A", "Порядок эл-та G", "Порядок центализатора A", "Порядок центализатора G",
                          "Стабилизатор A", "Стабилизатор G", "№ группы силова A", "№ группы силова G", "Класс сопр эл-тов A", "Класс сопр эл-тов G"
                          };
                from = new String[]{"_id", "ape", "bpe", "aname", "bname", "aciklos", "bciklos", "acykl_len", "bcykl_len",
                        "adeg", "bdeg", "acenter_num", "bcenter_num",
                        "astabilizer", "bstabilizer",
                        "asylow_num", "bsylow_num", "apairing_num", "bpairing_num"};
                to = new int[]{R.id.db1, R.id.db2, R.id.db3, R.id.db4, R.id.db5, R.id.db6, R.id.db7, R.id.db8, R.id.db9, R.id.db10, R.id.db11,
                        R.id.db12, R.id.db13, R.id.db14, R.id.db15, R.id.db16, R.id.db17, R.id.db18, R.id.db19};
                colCount = 19;
                dbItem = R.layout.db_item19;
                break;

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