File: TODO

package info (click to toggle)
gap-polycyclic 2.11-3
  • links: PTS
  • area: main
  • in suites: stretch
  • size: 2,936 kB
  • ctags: 512
  • sloc: xml: 3,000; makefile: 118; sh: 2
file content (160 lines) | stat: -rw-r--r-- 6,284 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
Misc:
* redo stuff in /etc; need a new script for making release tarballs
* Add GPL header to all files
* Update the versions and release dates in PackageInfo.g *AND* CHANGES
* Write a checklist (or maybe a script) for everything that needs to be
  done during a release. E.g. setting version & release date (and where:
  PackageInfo.g, docu, configure, website, ...)

Code:
* Document changes made to AbelianPcpGroup in 2.2->2.6 (it now accepts
  more parameter formats)
* fix things from my bug list
* add some of my new internal code
* add unit tests
* IsomorphismPcpGroupFromFpGroupWithPcPres

* MappedVector is used by lots of code, and also by 3rd party
  packages -> make it official & document it.
  Then again, the GAP core also contains a similar function with equal name. Oops

* add support for cohomology over arbitrary finite modules

* Should we use InstallSubsetMaintenance etc.?

* the methods for IsomorphismPcpGroup could be improved, e.g. the
  one starting with a permutation group, or with a pc group

* Maybe add IsFreeAbelian, IsTorsionFree, property to GAP, and just install
  methods for pcp groups in polycyclic. But beware of issues where users
  upgrade to a newer GAP but retain an old Polycyclic version, and vice versa.

* The third parameter "snf" in  Pcp( U, "snf" )
  is really an "option", and should be replaced by use of ValueOption()
  Similar for "all" in PrintPcpPresentation()

* Looking at the code in SchurExtension (and elsewhere), perhaps we should
  add a CollectorForPcp operation?

* Add code for computing conjugacy classes of elements

* Implement ConjugacySubgroupsBySeries

* implement missing Sylow subgroup code (borrow from the corresponding
  pcgroup code)

* The documentation in methods.xml, last section, mentions
   "two libraries of Schur tower p-groups", but then fails to list
   methods for these, nor do I see such libraries in polycyclic. Huh?

* Rename various operations/attributes/properties to better fit into the GAP
  naming conventions; also, in some cases, polycyclic adds new operations
  for things that already have different names in GAP; that should be changed
  as well.
  This includes:
  SchurExtensionEpimorphism => EpimorphismSchurExtension
  SchurCovering => SchurCover (already exists in GAP)
  NonAbelianExteriorSquareEpimorphism => EpimorphismNonabelianExteriorSquare
  NonAbelianExteriorSquare => NonabelianExteriorSquare
  ...

* Turn D!.crossedPairing (set by NonAbelianExteriorSquareEpimorphism)
  into an attribute or so?

* There is lots of dead/unused/undocumented code in polycyclic, e.g.
   CollectedOneCRNew
   CRRecordWithAction
   -> there is actually a *ton* of code related to that, dealing with "smats"
     "super" and other undocumented CR record entries.
  Decide what to keep of that and what to remove
  
  More unused code:
    - everything in gap/matrep/affine.gi

* in gap/matrix/latbases.gi, there is a function "LatticeBasis"
  perhaps BaseIntMat could / should be used instead?
  similary, study the possibility of replacing
   PcpNullspaceIntMat -> NullspaceIntMat,
   LatticeIntersection -> BaseIntersectionIntMats

* Document (in the manual) the return values of ComplementClasses, ComplementClassesEfaPcps
  and so on. They seem to be some kind of list of records

* Robert Morse suggests the following:

"NonAbelianTensorPlus and NonAbelianExteriorPlus are group products.  It
would be very nice to have the embeddings similar to direct product,
semidirect products, and free products.

For instance just like the other products:

nu := NonAbelianTensorPlus(g);
Embedding(nu,1);
returns a monomorphism from g into nu (first copy)
Embedding(nu,2);
returns a monomorphism from g int nu (second copy)


* Another suggestion by Robert Morse is to install methods that apply the
fast methods for NonAbelianTensorSquare, SchurCover(ing) etc. in polycyclic
to arbitrary polycyclic groups (or at least to pc groups), by temporarily
converting these groups to pcp groups, performing the computation, then
converting back.

* add a method for ConjugacyClasses

* several collector properties should perhaps be plain filters instead:
  IsWeightedCollector, IsPolynomialCollector, UseLibraryCollector

* Move !.collector from pcp group elements to the *family object* of these elements?
  Since the collector is shared by all elements in the same family, this
  seems like the sensible thing to do

* change NameTag resp. !.name -> only store !.name if it differs from "g".
  Which right now it *never* does...
  Indeed, might just as well get rid of NameTag in its current form.
  It is weird that this is an operation on the group elements anyway;
  it would make slightly more sense if it was an operation of the collector.
  

* set IsWholeFamily to true/false for pcp groups, esp. in PcpGroupByCollectorNC
  also add a method for it (this should be quite cheap)

* figure out why EfaSeriesParent is not directly installed as method for EfaSeries...


* consider removing "documentation" for built-in GAP operations like
  ClosureGroup, \in etc. and just document for which operations we provide
  special methods (if at all)

* Why does SubgroupByIgs use
    U := SubgroupNC( Parent(arg[1]), pcs );
  this contradicts what the documentation of SubgroupByIgs says... but we
  can't just simply change this, as some code might rely on the old "bad"
  behavior...


* Right now one can do horribly evil things like modifying a collector
  that is already "in use" by some groups:
	gap> G:=HeisenbergPcpGroup(3);
	Pcp-group with orders [ 0, 0, 0, 0, 0, 0, 0 ]
	gap> coll:=Collector(G);
	<<from the left collector with 7 generators>>
	gap> GetConjugate(coll, 2, 1);
	[ 2, 1 ]
	gap> SetConjugate(coll, 2, 1, []);
	gap> G.2*G.1;
	Error, Collector is out of date called from
	CollectWordOrFail( clt, e, f ) called from
	<function "unknown">( <arguments> )
	called from read-eval loop at line 44 of *stdin*
	you can 'quit;' to quit to outer loop, or
	you can 'return;' to continue
	brk> 

  One could argue that as soon as a collector is "in use" by a group, it
  should be sealed / finalized / made read-only.
  
  As a bonus, this would allow us to store the PcpGroupByCollectorNC(coll) of the collector

* replace PrintObj / ViewObj methods by PrintString / ViewString methods