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
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
|
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE Book SYSTEM "gapdoc.dtd">
<Book Name="HAPprog">
<TitlePage>
<Title><Package>Hap Programming</Package> – An experimental framework
for objectifying the data structures of Hap</Title>
<Version>( development version of
<#Include SYSTEM "today.ver">
)
</Version>
<Author>Marc Röder
<Email>marc.roeder(at)nuigalway.ie</Email>
</Author>
<Abstract>
This extension does not change the behaviour of Hap and is fully
backwards-compatible. It is not a part of Hap and there is no guarantee that
it will at any point be supported by Hap. Use at your own risk.
</Abstract>
<Address>
Marc Röder, Department of Mathematics, NUI Galway, Irleland
</Address>
<Acknowledgements>
This work was supported by Marie Curie Grant No. MTKD-CT-2006-042685
</Acknowledgements>
<Copyright>©right; 2007 Marc Röder. <P/>
This package is distributed under the terms of the GNU General
Public License version 2 or later (at your convenience). See the file
<File>LICENSE</File> or
<URL>https://www.gnu.org/copyleft/gpl.html</URL>
</Copyright>
</TitlePage>
<TableOfContents/>
<Body>
<Chapter Label="hapresolution"><Heading>Resolutions in Hap</Heading>
This document is only concerned with the representation of resolutions in
Hap. Note that it is not a part of Hap. The framework provided here is just an
extension of Hap data types used in HAPcryst and HAPprime.
<P />
From now on, let <M>G</M> be a group and <M>\dots \to M_n\to M_{n-1}\to\dots\to M_1\to M_0\to Z</M> be a
resolution with free <M>ZG</M> modules <M>M_i</M>.
<P/>
The elements of the modules <M>M_i</M> can be represented in different
ways. This is what makes different representations for resolutions
desirable. First, we will look at the standard representation
(<C>HapResolutionRep</C>) as it is defined in Hap. After that, we will present
another representation for infinite groups.
Note that all non-standard representations must be sub-representations of the
standard representation to ensure compatibility with Hap.
<Section Label="hapresolutionrep"><Heading>The Standard Representation <K>HapResolutionRep</K></Heading>
For every <M>M_i</M> we fix a basis and number its elements. Furthermore, it is
assumed that we have a (partial) enumeration of the group of a resolution.
In practice this is done by generating a lookup table on the fly.
<P/>
In standard representation, the elements of the modules <M>M_k</M> are
represented by lists -"words"- of pairs of integers. A letter <C>[i,g]</C> of
such a word consists of the number of a basis element <C>i</C> or <C>-i</C> for
its additive inverse and a number
<M>g</M> representing a group element.
<P/>
A <C>HapResolution</C> in <C>HapResolutionRep</C> representation is a component
object with the components
<List>
<Item><C>group</C>, a group of arbitrary type.</Item>
<Item><C>elts</C>, a (partial) list of (possibly duplicate) elements in G. This
list provides the "enumeration" of the group. Note that there are
functions in Hap which assume that <C>elts[1]</C> is the identity element of G.
</Item>
<Item><C>appendToElts(g)</C> a function that appends the group element
<C>g</C> to <C>.elts</C>. This is not documented in Hap 1.8.6 but seems to
be required for infinite groups. This requirement might vanish in some later
version of Hap [G. Ellis, private communication].
</Item>
<Item><C>dimension(k)</C>, a function which returns the ZG-rank of the Module
<M>M_k</M></Item>
<Item><C>boundary(k,j)</C>, a function which returns the image in <M>M_{k-1}</M>
of the <M>j</M>th free generator of <M>M_k</M>. Note that negative <M>j</M> are
valid as input as well. In this case the additive inverse of the boundary of
the <M>j</M>th generator is returned</Item>
<Item><C>homotopy(k,[i,g])</C> a function which returns the image in
<M>M_{k+1}</M>, under a contracting homotopy <M>M_k \to M_{k+1}</M>, of the
element <C>[[i,g]]</C> in <M>M_k</M>. The value of this might be <K>fail</K>.
However, currently (version 1.8.4) some Hap functions assume that
<C>homotopy</C> is a function without testing.</Item>
<Item><C>properties</C>, a list of pairs <C>["name","value"]</C> "name" is a
string and value is anything (boolean, number, string...). Every
<C>HapResolution</C> (regardless of representation) has to have
<C>["type","resolution"]</C>, <C>["length",length]</C> where <C>length</C> is
the length of the resolution and <C>["characteristic",char]</C>. Currently (Hap
1.8.6), <C>length</C> must not be <K>infinity</K>.
The values of these properties can be tested using the Hap function
<C>EvaluateProperty(resolution,propertyname)</C>.</Item>
</List>
Note that making <C>HapResolution</C>s immutable will make the <C>.elts</C>
component immutable. As this lookup table might change during calculations,
we do not recommend using immutable resolutions (in any representation).
</Section>
<Section Label="largegrouprep"><Heading>The <K>HapLargeGroupResolutionRep</K> Representation</Heading>
In this sub-representation of the standard representation, the module elements
in this resolution are lists of groupring elements.
So the lookup table <C>.elts</C> is not used as long as no conversion to
standard representation takes place.
In addition to the components of a <K>HapResolution</K>, a resolution in large
group representation has the following components:
<List>
<Item><C>boundary2(resolution,term,gen)</C>, a function that returns the
boundary of the <A>gen</A>th generator of the <A>term</A>th module.</Item>
<Item><C>groupring</C> the group ring of the resolution <A>resolution</A>.</Item>
<Item><C>dimension2(resolution,term)</C> a function that returns the dimension
of the <A>term</A>th module of the resolution <A>resolution</A>.</Item>
</List>
The effort of having two versions of <C>boundary</C> and <C>dimension</C> is
necessary to keep the structure compatible with the usual Hap resolution.
</Section>
</Chapter>
<!-- ================================================== -->
<Chapter><Heading>Accessing and Manipulating Resolutions</Heading>
<Section><Heading>Representation-Independent Access Methods</Heading>
All methods listed below take a <C>HapResolution</C> in any representation. If
the other arguments are compatible with the representation of the resolution,
the returned value will be in the form defined by this representation. If the
other arguments are in a different representation, &GAP;s method selection is
used via <C>TryNextMethod()</C> to find an applicable method (a suitable representation).
<P/>
The idea behind this is that the results of computations have the same form as
the input. And as all representations are sub-representations of the
<C>HapResolutionRep</C> representation, input which is compatible with the
<C>HapResolutionRep</C> representation is always valid.
<P/>
Every new representation must support the functions of this section.
<ManSection>
<Meth Name="StrongestValidRepresentationForLetter" Arg="resolution term
letter"/>
<Returns>filter</Returns>
<Description>
Finds the sub-representation of <C>HapResolutionRep</C> for which
<A>letter</A> is a valid letter of the <A>term</A>th module of
<A>resolution</A>. Note that <A>resolution</A> automatically is in some
sub-representation of <C>HapResolutionRep</C>.This is mainly meant for
debugging.
</Description>
</ManSection>
<ManSection>
<Meth Name="StrongestValidRepresentationForWord" Arg="resolution term
word"/>
<Returns>filter</Returns>
<Description>
Finds the sub-representation of <C>HapResolutionRep</C> for which
<A>word</A> is a valid word of the <A>term</A>th module of
<A>resolution</A>. Note that <A>resolution</A> automatically is in some
sub-representation of <C>HapResolutionRep</C>. This is mainly meant for
debugging.
</Description>
</ManSection>
<ManSection>
<Meth Name="PositionInGroupOfResolution" Arg="resolution g" />
<Meth Name="PositionInGroupOfResolutionNC" Arg="resolution g"/>
<Returns>positive integer</Returns>
<Description>
This returns the position of the group element <A>g</A> in the enumeration
of the group of <A>resolution</A>. The NC version does not check if <A>g</A>
really is an element of the group of <A>resolution</A>.
</Description>
</ManSection>
<ManSection>
<Meth Name="IsValidGroupInt" Arg="resolution n"/>
<Returns>boolean</Returns>
<Description>
Returns true if the <A>n</A>th element of the group of <A>resolution</A> is known.
</Description>
</ManSection>
<ManSection>
<Meth Name="GroupElementFromPosition" Arg="resolution n"/>
<Returns>group element or <K>fail</K></Returns>
<Description>
Returns <A>n</A>th element of the group of <A>resolution</A>. If the
<A>n</A>th element is not known, <K>fail</K> is returned.
</Description>
</ManSection>
<ManSection>
<Meth Name="MultiplyGroupElts" Arg="resolution x y"/>
<Returns>positive integer or group element, depending on the type of <A>x</A> and <A>y</A></Returns>
<Description>
If <C>x</C> and <C>y</C> are given in standard representation (i.e. as
integers), this returns the position of the product of the group elements
represented by the positive integers <A>x</A> and <A>x</A>.
<P/>
If <C>x</C> and <C>y</C> are given in any other representation, the returned
group element will also be represented in this way.
</Description>
</ManSection>
<ManSection>
<Meth Name="MultiplyFreeZGLetterWithGroupElt" Arg="resolution letter g"/>
<Returns>A letter</Returns>
<Description>
Multiplies the letter <A>letter</A> with the group element <A>g</A> and
returns the result. If <A>resolution</A> is in standard representation,
<A>g</A> has to be an integer and <A>letter</A> has to be a pair of
integer. If <A>resolution</A> is in any other representation, <A>letter</A>
and <A>g</A> can be in a form compatible with that representation or in the
standard form (in the latter case, the returned value will also have
standard form).
</Description>
</ManSection>
<ManSection>
<Meth Name="MultiplyFreeZGWordWithGroupElt" Arg="resolution word g"/>
<Returns>A word</Returns>
<Description>
Multiplies the word <A>word</A> with the group element <A>g</A> and
returns the result. If <A>resolution</A> is in standard representation,
<A>g</A> has to be an integer and <A>word</A> has to be a list of pairs of
integers. If <A>resolution</A> is in any other representation, <A>word</A>
and <A>g</A> can be in a form compatible with that representation or in the
standard form (in the latter case, the returned value will also have
standard form).
</Description>
</ManSection>
<ManSection>
<Meth Name="BoundaryOfFreeZGLetter" Arg="resolution term letter"/>
<Returns>free ZG word (in the same representation as <A>letter</A>)</Returns>
<Description>
Calculates the boundary of the letter (word of length 1) <A>letter</A> of
the <A>term</A>th module of <A>resolution</A>.
<P/>
The returned value is a word of the <A>term</A>-1st module and comes in the
same representation as <A>letter</A>.
</Description>
</ManSection>
<ManSection>
<Meth Name="BoundaryOfFreeZGWord" Arg="resolution term word"/>
<Returns>free ZG word (in the same representation as <A>letter</A>)</Returns>
<Description>
Calculates the boundary of the word <A>word</A> of
the <A>term</A>th module of <A>resolution</A>.
<P/>
The returned value is a word of the <A>term</A>-1st module and comes in the
same representation as <A>word</A>.
</Description>
</ManSection>
</Section>
<Section><Heading>Converting Between Representations</Heading>
Four methods are provided to convert letters and words from standard
representation to any other representation and back again.
<ManSection>
<Meth Name="ConvertStandardLetter" Arg="resolution term letter"/>
<Meth Name="ConvertStandardLetterNC" Arg="resolution term letter"/>
<Returns>letter in the representation of <A>resolution</A></Returns>
<Description>
Converts the letter <A>letter</A> in standard representation to the
representation of <A>resolution</A>. The NC version does not check whether
<A>letter</A> really is a letter in standard representation.
</Description>
</ManSection>
<ManSection>
<Meth Name="ConvertStandardWord" Arg="resolution term word"/>
<Meth Name="ConvertStandardWordNC" Arg="resolution term word"/>
<Returns>word in the representation of <A>resolution</A></Returns>
<Description>
Converts the word <A>word</A> in standard representation to the
representation of <A>resolution</A>. The NC version does not check whether
<A>word</A> is a valid word in standard representation.
</Description>
</ManSection>
<ManSection>
<Meth Name="ConvertLetterToStandardRep" Arg="resolution term letter"/>
<Meth Name="ConvertLetterToStandardRepNC" Arg="resolution term letter"/>
<Returns>letter in standard representation</Returns>
<Description>
Converts the letter <A>letter</A> in the representation of <A>resolution</A>
to the standard representation. The NC version does not check whether
<A>letter</A> is a valid letter of <A>resolution</A>.
</Description>
</ManSection>
<ManSection>
<Meth Name="ConvertWordToStandardRep" Arg="resolution term word"/>
<Meth Name="ConvertWordToStandardRepNC" Arg="resolution term word"/>
<Returns>word in standard representation</Returns>
<Description>
Converts the word <A>word</A> in the representation of <A>resolution</A>
to the standard representation. The NC version does not check whether
<A>word</A> is a valid word of <A>resolution</A>.
</Description>
</ManSection>
</Section>
<Section><Heading>Special Methods for <K>HapResolutionRep</K></Heading>
Some methods explicitely require the input to be in the standard
representation (<A>HapResolutionRep</A>). Two of these test if a word/letter is
really in standard representation, the other ones are non-check versions of the
universal methods.
<ManSection>
<Meth Name="IsFreeZGLetter" Arg="resolution term letter"/>
<Returns>boolean</Returns>
<Description>
Checks if <A>letter</A> is an valid letter (word of length 1) in standard
representation of the <A>term</A>th module of <A>resolution</A>.
</Description>
</ManSection>
<ManSection>
<Meth Name="IsFreeZGWord" Arg="resolution term word"/>
<Returns>boolean</Returns>
<Description>
Check if <A>word</A> is a valid word in large standard representation of the
<A>term</A>th module in <A>resolution</A>.
</Description>
</ManSection>
<ManSection>
<Meth Name="MultiplyGroupEltsNC" Arg="resolution x y"/>
<Returns>positive integer</Returns>
<Description>
Given positive integers <C>x</C> and <C>y</C>, this returns the position of
the product of the group elements represented by the positive integers
<A>x</A> and <A>x</A>. This assumes that all input is in standard
representation and does not check the input.
</Description>
</ManSection>
<ManSection>
<Meth Name="MultiplyFreeZGLetterWithGroupEltNC" Arg="resolution letter g"/>
<Returns>A letter in standard representation</Returns>
<Description>
Multiplies the letter <A>letter</A> with the group element represented by
the positive integer <A>g</A> and
returns the result. The input is assumed to be in <A>HapResolutionRep</A>
and is not checked.
</Description>
</ManSection>
<ManSection>
<Meth Name="MultiplyFreeZGWordWithGroupEltNC" Arg="resolution word g"/>
<Returns>A letter in standard representation</Returns>
<Description>
Multiplies the word <A>word</A> with the group element represented by
the positive integer <A>g</A> and
returns the result. The input is assumed to be in <A>HapResolutionRep</A>
and is not checked.
</Description>
</ManSection>
<ManSection>
<Meth Name="BoundaryOfFreeZGLetterNC" Arg="resolution term letter"/>
<Returns>free ZG word in standard representation</Returns>
<Description>
Calculates the boundary of the letter (word of length 1) <A>letter</A> of
the <A>term</A>th module of <A>resolution</A>.
The input is assumed to be in standard representation and not checked.
</Description>
</ManSection>
<ManSection>
<Meth Name="BoundaryOfFreeZGWordNC" Arg="resolution term word"/>
<Returns>free ZG word in standard representation</Returns>
<Description>
Calculates the boundary of the word <A>word</A> of
the <A>term</A>th module of <A>resolution</A>.
The input is assumed to be in standard representation and not checked.
</Description>
</ManSection>
</Section>
<#Include SYSTEM "./resolutionAccess_GroupRing.xml">
</Chapter>
<Chapter><Heading>Contracting Homotopies</Heading>
<#Include SYSTEM "./contraction.xml">
</Chapter>
</Body>
</Book>
|
