This method takes generators as arguments, then create the group generated by these elements and for each generators, search all same orders elements in this group, try to create valid automorphism with these tuples and then generate the group which has for generators the previous valid automorphisms.

It is easy to verify for Cn monogenic group which has only one generator through euler function, but for Symmetric Group subgroup or for cartesian product of Cn, it will difficult and needs to use more things to validate this method.

Unit tests will be restricted to well known groups.

In the current interface model, Homomorphism, LeftCoset and Relators are not well implemented, that makes the project hard to maintain and it doesnt cover Undergraduated level.

Introducing Monoid, Set Theory and Magma Interfaces can makes the model more robust and more structured.

Actual implementation of P-Adic numbers are crafting, and it must be improved. There is many possibilities described very well in many academics papers. Padic numbers are essential for faster polynomial factorization and completed finite group theory study.

Below two links of right implementation of p-adic numbers.

• Relaxed algorithms for -adic numbers
• Computations with p-adic numbers

Running this example in console

var g1 = Group.SemiDirectProd(Product.Generate(new Cn(3), new Cn(3)), new Cn(2));
DisplayGroup.HeadSdp(g1);
Console.WriteLine(g1.ElementsOrders.Values.Ascending().Glue(", "));

will output

|(C3 x C3) x: C2| = 18
Type        NonAbelianGroup
BaseGroup    C3 x C3 x Z2
NormalGroup  |C3 x C3| = 9
ActionGroup  |C2| = 2

Actions
g=0 y(g) = ((0, 0)->(0, 0), (0, 1)->(0, 1), (0, 2)->(0, 2), (1, 0)->(1, 0), (1, 1)->(1, 1), (1, 2)->(1, 2), (2, 0)->(2, 0), (2, 1)->(2, 1), (2, 2)->(2, 2))
g=1 y(g) = ((0, 0)->(0, 0), (0, 1)->(1, 0), (0, 2)->(2, 0), (1, 0)->(0, 1), (1, 1)->(1, 1), (1, 2)->(2, 1), (2, 0)->(0, 2), (2, 1)->(1, 2), (2, 2)->(2, 2))

1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, 6

But when we try to find this group in GAP system, the result is different

gap> StructureDescription(SmallGroup(18,4));
"(C3 x C3) : C2"
gap> SortedList(List(SmallGroup(18,4),Order));
[ 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3 ]

The difference comes from the choose of the operation by automorphism which is actually arbitrary.

In GAP

gap> StructureDescription(SmallGroup(18,3));
"C3 x S3"
gap> SortedList(List(SmallGroup(18,3),Order));
[ 1, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 6, 6, 6, 6, 6, 6 ]

Rewriting the previous C# code

var n = Product.Generate(new Cn(3), new Cn(3));
var g = new Cn(2);
var thetas = Group.AllOpsByAutomorphisms(g, n);
foreach (var theta in thetas)
{
    var g1 = new SemiDirectProduct<Ep2<ZnInt, ZnInt>, ZnInt>("G", n, theta, g);
    DisplayGroup.HeadSdp(g1);
    Console.WriteLine(g1.ElementsOrders.Values.Ascending().Glue(", "));
}

Will produce

...
...
...
|G| = 18
Type        NonAbelianGroup
BaseGroup    C3 x C3 x Z2
NormalGroup  |C3 x C3| = 9
ActionGroup  |C2| = 2

Actions
g=0 y(g) = ((0, 0)->(0, 0), (0, 1)->(0, 1), (0, 2)->(0, 2), (1, 0)->(1, 0), (1, 1)->(1, 1), (1, 2)->(1, 2), (2, 0)->(2, 0), (2, 1)->(2, 1), (2, 2)->(2, 2))
g=1 y(g) = ((0, 0)->(0, 0), (0, 1)->(0, 2), (0, 2)->(0, 1), (1, 0)->(2, 0), (1, 1)->(2, 2), (1, 2)->(2, 1), (2, 0)->(1, 0), (2, 1)->(1, 2), (2, 2)->(1, 1))

1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3
...
...
...

There is problem when building automorphism and also a bad comprehension of the subject.

Some problems occure when computing Conway polynomial.

Actually, morphisms are computed only for monogenics groups or external product of monogenics groups or few cases of internal products of monogenics groups.
May be taking a look on the pGroup will resolves the problem of generators of small groups.

Dicyclics 30 and 42 bugs, wordgroup and semi-direct product are not isomorphic for the first faithfull action which is choosen by default for semi-direct product.

Semi-direct product is faster than word group or than permutation group but has many problems for choosing the right group action.

This method computes all homomorphism between a group and the automorphism group of the second argument. It must be rewritten.

These two structures have many methods introduced and Unit tests are mandatory.

Two challenges for deepening about generators.

1. How to create computationally an isomorphic WordGroup given any other UserGroup ?
2. How to create WordGroup from FreeGroup using Normal subgroup of relators and without Todd Coxeter procedure ?

The current implementation for the simplification of Cyclotomic Field Cnf elements is not efficient, especially for numbers $$\displaystyle A_{cnf} = \sum_{i \in I} a_i ξ(m)^i$$ where $m$ is not prime.

This inefficiency is causing the process to be slow. Resolving this issue will enable a more effective pretty print for the character table using the trace property of $χ_r (g_i)$.

The file Program.cs becomes unreadable and many useful code can be structured in multiple UnitTest files.

The new interface for manipulating G-Module N, when N is an abelian group, is cumbersome and not suitable for computation of extensions of N by G. It also can't be used for modeling character computations, but it only simplifies reading. Restricting computation for N abelian, or the center of N, becomes mandatory since it corrects many bugs occurred when computing extensions of Dihedral Group D8 by C2.

Perhaps it would be better to use the previous object for manipulating polynomials of multiple indeterminates over the finite field Fq. Reducing systems could be done with Groebner, which is already possible and tested for trivial action, and group action could be possible through permutations of unknowns but it needs to be tested for evidence.

The book, Cohomology of Finite Group from Alejandro Adem and R.James Milgram will be very useful for that. The subject is becoming challenging, profound, and captivating.

ZnInt division is invalid.

JetBrains is throwing a lot of memory issues.

Example at

which can be resolved

But a lot of other issues remains.

The example of creating an Extension E from two groups N and G was invalid. It is impractical to compute all twisted actions for all maps exhaustively, and it needs to be fixed for exploring more groups of order 32.

ChatGPT pro version is the must have assistant for a concise and professional documentation.

Using Todd Coxeter algorithm to create a Word Group.

Bad relators produce an infinite loop.

XML documentation for code and Coverage 90% before any release.

When working on BCH codes using the Berlekamp Massey algorithm for decoding, everything is working well except for a minor issue with ±1 on many parameters such as the size of the word to encode, the degree of the syndrome polynomial, and the size of detected errors. Some comments and more relevant naming are also needed for better understanding.

For example in the below line, there is a confusion in the range for j.

Cayley table is an easy but powerful tool for studying finite group and it must be added, at least for better performance.

When running this code, some results are hard to understand and they need deepening in this question.

O1 represents the minimum number of digits required in the lattice, while O2 represents the maximum number of digits required for precise computation before populating the lattice, both of which are typically determined through trial and error. However, a more efficient approach involves using a minorant to predict O1 and O2 based on the polynomial degree and its coefficients. Although this method may be challenging, it represents a significant improvement for future applications.

I'm thrilled to announce that the latest Early Access Program (EAP) release as of November 2023 now supports both .NET 8 and the AI Assistant. I'm looking forward to utilizing these updated features in my development work.

The method below is incorrect for counting all possible values for a map with symbolic unknowns. It includes redundant possibilities that need to be eliminated.

The project offers a plethora of promising tools. However, their abundance can sometimes lead to confusion, and they aren't always effective. I believe it's crucial for undergraduates to master these complex tools to successfully complete their mathematics proofs or to enhance their efficiency during graduate studies and after. This issue aims to motivate users to experiment with these materials and source code before completing their undergraduate level.

Writing Jekyll Docs and Wiki

A new functionality for studying group morphisms will be probabely the last step for releasing the first candidat v1.0 of this project.

Examples from the Readme file wont work. Pushing on main branch only for minor changes or when everything in a new branch are coherent.

Symmetric 4 group is isomorphic to Holomorph group of C2 x C2.

But the following code will output an invalid result.

var s4 = new Symm(4);
var V = Group.Generate("V", s4, s4[(1, 2), (3, 4)], s4[(1, 3), (2, 4)]);
var autV = Group.AutomorphismGroup(V);
DisplayGroup.AreIsomorphics(autV, new Symm(3));
var homs = Group.AllHomomorphisms(autV, autV);
var allSdp = homs.Select((theta, i) => Group.SemiDirectProd($"(V x: Aut[V])[{i}]", V, theta, autV)).ToList();
allSdp.ForEach(holV => DisplayGroup.AreIsomorphics(holV, s4));

output

Aut[V] IsIsomorphicTo S3 : True
...
(V x: Aut[V])[2] IsIsomorphicTo Symm4 : False
(V x: Aut[V])[3] IsIsomorphicTo Symm4 : False
...

Associativity is not verified.

Latin square is cheap, complexity is O(n2) when Associativity is more costly O(n3)

Interfaces for Groups are ambiguous. A primitive element is always user-defined related to a primitive user-defined group. Other computational groups are manipulating primitives elements or a tuple of primitive elements. Their base group is always the same of the neutral element base group which is at least the first requirement for their creation.

This condition is necessary for isomorphic groups but it is not sufficient.
A counter-example is between groups (C8 : C4) and (C4 : C8) as shown in Examples folder.

which will output

|C8 x: C4| = 32
Type        NonAbelianGroup
BaseGroup    Z8 x Z4
NormalGroup  |C8| = 8
ActionGroup  |C4| = 4

Actions
g=0 y(g) = (0->0, 1->1, 2->2, 3->3, 4->4, 5->5, 6->6, 7->7)
g=1 y(g) = (0->0, 1->5, 2->2, 3->7, 4->4, 5->1, 6->6, 7->3)
g=2 y(g) = (0->0, 1->1, 2->2, 3->3, 4->4, 5->5, 6->6, 7->7)
g=3 y(g) = (0->0, 1->5, 2->2, 3->7, 4->4, 5->1, 6->6, 7->3)

Sorted Orders C8 x: C4 : (1, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8)
|C4 x: C8| = 32
Type        NonAbelianGroup
BaseGroup    Z4 x Z8
NormalGroup  |C4| = 4
ActionGroup  |C8| = 8

Actions
g=0 y(g) = (0->0, 1->1, 2->2, 3->3)
g=1 y(g) = (0->0, 1->3, 2->2, 3->1)
g=2 y(g) = (0->0, 1->1, 2->2, 3->3)
g=3 y(g) = (0->0, 1->3, 2->2, 3->1)
g=4 y(g) = (0->0, 1->1, 2->2, 3->3)
g=5 y(g) = (0->0, 1->3, 2->2, 3->1)
g=6 y(g) = (0->0, 1->1, 2->2, 3->3)
g=7 y(g) = (0->0, 1->3, 2->2, 3->1)

Sorted Orders C4 x: C8 : (1, 2, 2, 2, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8)

Isomorphic C4 x: C8 C8 x: C4 True
Homomorphisms Count = 256
Isomorphisms  Count = 0

And then, this example also provide how to check computationally isomorphism between two group.

Symm5 contains multiples dihedrals subgroups, D8, D10 and D12.

There is also a bug in Isomorphic methods between two groups.

Cartesian Product is only for user defined BaseGroup of interface IGroup and external Direct Product of groups cannot be made between groups from interface IConcreteGroup.

In the algorithm, all operations are right coset, (1).a = (2), where (1) and (2) are classes, H.a = K. In every other part, operations are from left x.H = K, this is why a word is reversed before being rewrited.

Fixing this issue will need to rewrite all the namespace ToddCoxeter.

Need to validate if the group action is an automorphism when creating a semidirect product to fix bugs.

The previous design was able to deal with Finite Fields but now, the current one support also Galois Group in Q[X] for small polynomials of degree 4. It can be simplified and a lot of examples can be moved to structure folder.

Direct product of Zn automorphisms group Un is not possible at time, and must be resolved as soon as possible. Insted, only automorphisms group of monogenics group can be done through generators. Fixing this bugs will allow to illustrate the simple criteria Aut(Cm x CN) ~ Aut(Cm) x Aut(Cn) when m and n are coprime

The files PolynomialFactorization(Part1 and Part2).cs are unreadables and need to be splitted and to be refactored.

LLL-Algorithm isnt illustrated in any part of examples

Cannot factor non monic or non integers coefficients polynomials

The CommonNames method does not include GL(2,3)

and it should be added.

A better design would avoid using the non-generic type ZnInt in the Structures namespace.

With basics abelians groups or direct products, computing all automorphisms or all homomorphism is possibles from canonics generetors, but it can takes very long time. Generators for abelians subgroups is more complicated, they are not canonics but it is possible.

Dealing with generators will also resolve complex cases of semidirect product. Finding generators quickly for non abelian groups, when they are isomorphic to a semidirect product, it can be probably done, may be a tiny classifier of groups by order is necessary.

Computing finitely presented group by generators and relators with bruteforce is very costly, they can be included in this project but not at this time.

The project uses implicitly many well known theorems and they can be explained in details inside the "future" documentation.

Generators allows also to compute all subgroups, and will be the possible last step to finish dealing with Groups Morphisms, then classic groups will be fast to write, to complete the first objective of this project, and staying accessible for undergraduate level.

New Dotnet 7.0 features seem useful.

I have faced significant challenges when computing splitting fields and Galois groups of high-degree symbolic polynomials.

These calculations can be incredibly time-consuming, especially when dealing with polynomials of degree greater than 5.

One approach that I am considering is leveraging numerical techniques such as approximation and interpolation to speed up the calculations.

Let's try.

Runnig this code

var s4 = new Sn(4);
var S4 = Group.Generate("S4", s4[(1, 2)], s4[(1, 2, 3, 4)]);
var V = Group.Generate("V", S4, s4[(1, 2), (3, 4)], s4[(1, 3), (2, 4)]);
var Q = S4.Over(V);
DisplayGroup.HeadClassesTable(Q);

will output

|S4/V| = 6
Type        AbelianGroup
BaseGroup   S4
SuperGroup  |S4| = 24
NormalGroup |V| = 4

Cosets
(1)[1]
(2)[2]
(3)[2]
(4)[2]
(5)[3]
(6)[3]

1 2 3 4 5 6
2 1 6 5 4 3
3 5 1 6 2 4
4 6 5 1 3 2
5 3 4 2 6 1
6 4 2 3 1 5

The table and the order of classes are valid but the group is not Abelian.

The name of this struct must be changed to KAutGroup
An element KAut must be created with strong equality comparer related to a KAutGroup by checking linear dependency with previous elements. It may be costly but it doesn't matter for small groups.

GL(2,4) isnt supported because it needs $\mathbb{F}_4$ which also needs a better implementation for Galois field.
But a better implementation of Field needs a better implementation of Ring, particularly multiple indeterminates polynomials.

The project will go a little over undergraduate level to graduate level, but it will be more stable and it becomes exciting to be able to deal with group extension faster using ring and field theory.