Debian Codegraph @

texmf-dist/doc/latex/spectralsequences/manual/spectralsequencesmanual.tex

raw
1 %%
2 %% Package: spectralsequences v1.3.3 2023-01-28
3 %% Author: Hood Chatham
4 %% Email: [email protected]
5 %% Date: 2023-01-28
6 %% License: Latex Project Public License
7 %%
8 %% File: spectralsequencesmanual.tex
9 %%
10 %% Manual content
11 %%
12
13 %
14 % TODO:
15 %
16 % maybe move more examples into external files?
17 %
18 % consistency issues?
19 % perhaps think about ordering, particularly of "Misc commands" section
20 % tutorial
21 % explain / cross reference examples folder?
22 % \sseqlastlabel is not currently documented.
23 %
24 \def\version{Version 1.3.3}
25
26
27 \input spectralsequencesmanualpreamble
28
29
30 \begin{document}
31 \newgeometry{margin = 4cm,nohead}
32 \begin{titlepage}
33 \title{\sseqpages}
34 \author{Hood Chatham\\\mailtoHC}
35 \date{\version\\\today}
36 \maketitle \thispagestyle{empty}
37
38 \begin{abstract}
39 \noindent
40 The \sseqpages\ package is a specialized tool built on top of \pgfpkg/\tikzpkg\
41 for drawing spectral sequence charts. It provides a powerful, concise syntax for
42 specifying the data of a spectral sequence, and then allows the user to print
43 various pages of a spectral sequence, automatically choosing which subset of the
44 classes, differentials, structure lines, and extensions to display on each page.
45 It also handles most of the details of the layout. At the same time, \sseqpages\
46 is extremely flexible. It is closely integrated with \tikzpkg\ to ensure that
47 users can take advantage of as much as possible of its expressive power. It is
48 possible to turn off most of the automated layout features and draw replacements
49 using \tikzpkg\ commands. \sseqpages\ also has a carefully designed error
50 reporting system intended to ensure that it is as clear as possible what is
51 going wrong.
52
53 Many thanks to the authors of \tikzpkg\ for producing such a wonderful package
54 with such thorough documentation. I would have needed to spend a lot more time
55 reading the \tikzpkg\ code if the documentation weren't so excellent. I took
56 ideas or code or both from \tikzcdpkg\ (part of the code for turning quotes into
57 class or edge labels), \pgfplotspkg\ (axes labels), and \sseqpkg\ (the grid
58 types, the stack). I lifted a fair amount of code from \TeX stack exchange.
59 Thanks to Eva Belmont for tons of helpful suggestions, bug reports, and
60 productive conversations. Talking to her has helped to clarify many design
61 concepts for the package. Thanks to Eric Peterson for being a very early adopter
62 and reporting many bugs. Also thanks to all my friends, family, and
63 acquaintances listened to me talk about \LaTeX\ programming even though they
64 probably found it dreadfully boring.
65 \end{abstract}
66 \end{titlepage}
67
68 \restoregeometry
69 \stepcounter{page}
70 \newpage
71 \thispagestyle{empty} % Should the table of contents have a page number?
72 \tableofcontents
73 \newpage
74 \section{Introduction}
75 The \sseqpages\ package consists of two main environments -- the \sseqdataenv\
76 environment, which specifies the data for a named spectral sequence, and the
77 \sseqpageenv\ environment, which prints a single page of a spectral sequence.
78 The |\printpage| command is also available as a synonym for a \sseqpageenv\
79 environment with an empty body.
80
81 Here is a basic example:
82 \begin{codeexample}[width = 8.7cm]
83 \begin{sseqdata}[ name = basic, xscale = 0.6,
84 cohomological Serre grading ]
85 \class(0,0)
86 \class(0,2)
87 \class(3,0)
88 \class(3,2)
89 \d3(0,2)
90 \end{sseqdata}
91 \printpage[ name = basic, page = 3 ] \quad
92 \printpage[ name = basic, page = 4 ]
93 \end{codeexample}
94 \codeverb|\begin{sseqdata}[name = basic, cohomological Serre grading]| starts
95 the declaration of the data of a spectral sequence named |basic| with
96 cohomological Serre grading -- that is, the page $\mathtt{r}$ differentials go
97 $\mathtt{r}$ to the right and down $\mathtt{r-1}$. Then we specify four classes
98 and one page 3 differential, and we ask \sseqpages\ to print the third and
99 fourth pages of the spectral sequence. Note that on the fourth page, the source
100 and target of the differential have disappeared.
101
102 \subsection{Installation}
103 In both \miktex\ and \texlive\ installation should be automatic -- your \TeX\
104 distribution should automatically install the package the first time you include
105 |\usepackage{spectralsequences}| in a document and compile it. However, in 2016,
106 \texlive\ made an incompatible change to their database, so no new packages will
107 run on versions of \texlive\ from before 2016. This includes \sseqpages. If you
108 have an old version of \texlive, you can either perform a manual install, or,
109 better, you should install an up to date version of \texlive. If you want to do
110 a manual install, see \href{https://tex.stackexchange.com/a/73017}{this \TeX
111 stack exchange post} for instructions.
112
113 \subsection{Memory Constraints}
114 In a default \TeX\ install, \pdfLaTeX\ has small static memory caps that prevent
115 it from using more than about 60 megabytes of total ram. However,
116 \spectralsequences\ and \pgfpkg/\tikzpkg\ use a large amount of memory. For this
117 reason, using \pdfLaTeX\ with a default install, you cannot draw more than about
118 2500 classes across all of your diagrams (fewer if you include differentials,
119 structure lines, and other features). There are a few solutions to this.
120
121 The easiest solution is to run \LuaLaTeX. \LuaLaTeX\ dynamically allocates
122 memory and so is unlikely to run out of it. Using \LuaLaTeX\ on my computer, I
123 can compile a document that draws two copies of a diagram with 20,000 classes in
124 it (so a total of 40,000 classes). This takes about 50 seconds and 250 megabytes
125 of ram. I expect any real-world use case will compile fine on a modern computer
126 using \LuaLaTeX. This option has the advantage that any modern \TeX\ install
127 comes with a copy of \LuaLaTeX, and that \LuaLaTeX\ is the designated successor
128 to \pdfLaTeX. It has the disadvantage that there are some incompatibilities
129 between \LuaLaTeX\ and \pdfLaTeX\ so if your document depends on
130 \pdfLaTeX-specific features, it might be a pain to switch to \LuaLaTeX.
131
132 Another option is to increase the static memory caps for \pdfLaTeX. See
133 \href{https://tex.stackexchange.com/a/26213}{this \TeX stack exchange post} for
134 instructions on how to do this.
135
136 \subsection{A warning about fragile macros}%
137 All the data in a \sseqpages\ environment is stored and used later. As a
138 result, most of the \sseqpages\ commands currently cannot tolerate fragile
139 macros. Unfortunately, it is impossible for \sseqpages\ to warn you about this
140 situation -- if you use a fragile command in a place that it doesn't belong, the
141 result will be an incomprehensible error message. If you are getting nonsense
142 error messages, this might be why. The solution is to convert fragile macros
143 into robust ones. Common examples of fragile macros include |\widehat| and
144 |\underline|. My suggested solution to this is to add the following code to your
145 preamble for each fragile macro (example given for |\mathbb|):
146 \begin{codeexample}[code only]
147 \let\oldwidehat\widehat
148 \protected\def\widehat{\oldwidehat}
149 \end{codeexample}
150
151
152 \section{Package Options and Environments}
153 \begin{manualentry}{Draft Mode}%
154 The drawings that \sseqpages\ produces can be quite slow, especially if they are
155 large. Draft mode skips drawing the content of the spectral sequence, but still
156 takes up exactly the same amount of space in the document, so that you can deal
157 with formatting issues. To active draft mode, load the package by saying
158 |\usepackage[draft]{spectralsequences}|.
159 \end{manualentry}
160
161 \begin{environment}{{sseqdata}\moptions}%
162 The \sseqdataenv\ environment is for storing a spectral sequence to be printed
163 later. This environment is intended for circumstances where you want to print
164 multiple pages of the same spectral sequence. When using the \sseqdataenv\
165 environment, you must use the |name| option to tell \sseqpages\ where to store
166 the spectral sequence so that you can access it later.
167 \end{environment}
168
169 \begin{environment}{{sseqpage}\ooptions}%
170 This environment is used for printing a page of existing spectral sequence that
171 was already specified using the \sseqdataenv\ environment. The body of the
172 environment adds local changes -- classes, differentials, structure lines,
173 extensions, and arbitrary \tikzpkg\ options that are by default only printed on
174 this particular page. The \sseqpageenv\ environment can also be used to print a
175 stand-alone page of a spectral sequence -- that is, if you only want to print a
176 single page of the spectral sequence, you can skip using the \sseqdataenv\
177 environment.
178 \end{environment}
179
180 \begin{command}{\printpage\moptions}%
181 This command prints a single page of an existing spectral sequence as-is. This
182 is equivalent to a \sseqpageenv\ environment with an empty body.
183 \end{command}
184
185
186 \section{The Main Commands}
187 \begin{command}{\class\ooptions\parargtwo{x}{y}}%
188 This places a class at |(x,y)| where |x| and |y| are integers. If multiple
189 classes occur at the same position, \sseqpages\ will automatically arrange them
190 in a pre-specified pattern. This pattern may be altered using the%
191 |class pattern| option.
192 \begin{codeexample}[]
193 \begin{sseqpage}[ no axes, ymirror, yscale = 0.8 ]
194 \class(0,0)
195 \class(1,0) \class(1,0)
196 \class(0,1) \class(0,1) \class(0,1)
197 \class(1,1) \class(1,1) \class(1,1) \class(1,1)
198 \class(0,2) \class(0,2) \class(0,2) \class(0,2) \class(0,2)
199 \class(1,2) \class(1,2) \class(1,2) \class(1,2) \class(1,2) \class(1,2)
200 \end{sseqpage}
201 \end{codeexample}
202
203 The effect of the |\class| command is to print a \tikzpkg\ node on a range of
204 pages. Any option that would work for a \tikzpkg\ |\node| command will also work
205 in the same way for the |\class|, |\replaceclass|, and |\classoptions| commands.
206
207 If a class is the source or the target of a differential on a certain page, then
208 the page of the class is set to that page, and the class is only rendered on
209 pages up to that number:
210 \begin{codeexample}[width = 8cm]
211 \begin{sseqdata}[ name = class example,
212 Adams grading,
213 yscale = 0.53 ]
214 \class(1,0)
215 \class(0,2)
216 \class(0,3)
217 \d2(1,0)
218 \end{sseqdata}
219 \printpage[ name = class example, page = 2 ]
220 \quad
221 \printpage[ name = class example, page = 3 ]
222 \end{codeexample}
223
224 See the \pgfmanualpdfref{class options}{class options} section for a list of the
225 sort of options available for classes.
226 \end{command}
227
228 \begin{commandlist}{{\replaceclass\ooptions\parargthreeopt{x}{y}{n}},\replaceclass\ooptions\pararg{classname},
229 \replacesource\ooptions, \replacetarget\ooptions}%
230 After a class is the source or target of a differential, it disappears on the
231 next page. However, some differentials are not injective or not surjective.
232 Using the command |\replaceclass| causes a new symbol to appear on the page
233 after a class supported or accepted a differential (or both). If there are
234 multiple classes at the coordinate |(x,y)| you may specify which using an
235 integer or a |tag| $n$. By default, this command will affect the first class
236 placed in that position. You can also provide the |class:name| of a class. The
237 variants |\replacesource| and |\replacetarget| replace the source and target
238 respectively of the most recent differential.
239 \begin{codeexample}[]
240 \begin{sseqdata}[name = replace class example, Adams grading, classes = {draw = none } ]
241 \class["\mathbb{Z}"](0,3)
242 \class["\mathbb{Z}"](1,1)
243 \class["\mathbb{Z}"](1,0)
244 \d["\cdot 2"]2(1,1)
245 \replacetarget["\mathbb{Z}/2"] %\replaceclass["\mathbb{Z}/2"](0,3)
246 \d[->>]3(1,0)
247 \replacesource["2\mathbb{Z}"] % \replaceclass["2\mathbb{Z}"](1,0)
248 \end{sseqdata}
249 \printpage[ name = replace class example, page = 2 ] \qquad
250 \printpage[ name = replace class example, page = 3 ] \qquad
251 \printpage[ name = replace class example, page = 4 ]
252 \end{codeexample}
253 Note that this will not restore any structure lines coming into or off of the
254 class. If you want to restore all structlines on the class use
255 |\replacestructlines|. If you want to selectively replace some of the structure
256 lines, you must use |\structline| again (or use the |structline:page| option).
257 \end{commandlist}
258
259 \begin{command}{\replacestructlines\opt{\pars{\sourcecoord}}}%
260 This command replaces all structlines touching a class that has been
261 replaced using |\replaceclass|, |\replacesource|, or |\replacetarget|.
262 \begin{codeexample}[]
263 \begin{sseqdata}[name=replacestructlines]
264 \class(0,1)
265 \class(0,2)
266 \structline
267 \class(1,0)
268 \d2(1,0)(0,2)
269 \replacetarget\replacestructlines
270 \end{sseqdata}
271 \printpage[name=replacestructlines, page=3]
272 \end{codeexample}
273 \end{command}
274
275 \begin{commandlist}{{\classoptions\moptions\parargthreeopt{x}{y}{n}},\classoptions\moptions\pararg{classname},
276 \classoptions\moptions}%
277 This adds options to an existing class. This can be used in a \sseqpageenv\
278 environment to modify the appearance of a class for just one drawing of the
279 spectral sequence, for instance to highlight it for discussion purposes.
280
281 If there are multiple classes at the coordinate |(x,y)| you may specify which
282 using an integer or a |tag| $n$. By default, this command will affect the first
283 class placed in that position. You can also provide the |class:name| of a class.
284 If no coordinate is indicated at all, then |\lastclass| is used.
285 \begin{codeexample}[width = 6cm]
286 \begin{sseqdata}[ name = class options example,
287 classes = fill ]
288 \class(2,1)
289 \foreach \x in {0,...,2} \foreach \y in {0,1} {
290 \class(\x,\y)
291 }
292 \end{sseqdata}
293 \begin{sseqpage}[ name = class options example,
294 right clip padding = 0.6cm ]
295 \classoptions[red](2,1,2) % Only is red on this page!
296 \node[ background ] at (0.3,-2.2)
297 {\textup{The red class is the problem}};
298 \end{sseqpage}
299 \end{codeexample}
300 Another reason to use this is to give a label to one instance of a class that
301 shows up in a loop or a command defined using |\NewSseqGroup|:
302 \begin{codeexample}[width = 6cm]
303 \NewSseqGroup\mygroup {} {
304 \class(0,0)
305 \class(0,1)
306 \class(0,2)
307 \class(1,1)
308 \class(2,2)
309 \structline(0,0)(0,1)
310 \structline(0,1)(0,2)
311 \structline(0,0)(1,1)
312 \structline(1,1)(2,2)
313 }
314 \begin{sseqpage}[ classes = fill, class labels = { left = 0.3em } ]
315 \mygroup(0,0)
316 \mygroup(1,2)
317 \classoptions["2"](0,1)
318 \classoptions["\eta"](1,1)
319 \end{sseqpage}
320 \end{codeexample}
321 See the \pgfmanualpdfref{class options}{class options} section for a list of the
322 sort of options available for classes.
323 \end{commandlist}
324
325 \begin{commandlist}{
326 {\d\ooptions\meta{page}},
327 {\d\ooptions\meta{page}\pars{\meta{x},\meta{y}\opt{,\sourcen,\targetn}}},
328 {\d\ooptions\meta{page}\pars{\sourcename\opt{,\targetn}}},
329 {\d\ooptions\meta{page}\pars{\sourcecoord}\pars{\targetcoord}}%
330 }%
331 Calling |\d\meta{page}|\parargtwo{x}{y} creates a differential starting at
332 \parargtwo{x}{y} of length determined by the specified page. In order to use the
333 |\d| command like this, you must first specify the |degree| of the differentials
334 as an option to the \sseqdataenv\ or \sseqpageenv\ environment. The degree
335 indicates how far to the right and how far up a page $\mathtt{r}$ differential
336 will go as a function of $\mathtt{r}$. If there is a page $\mathtt{r}$
337 differential, on page $\mathtt{r+1}$, the source, target, and any structure
338 lines connected to the source and target of the differential disappear. If no
339 class is specified, the default is to use |\lastclass|.
340
341 If there are multiple nodes in the source or target, you may specify which one
342 the differential should go to using an index or tag for \sourcen\ or \targetn.
343 It is also possible to provide the name of the source coordinate and an optional
344 target, or to separately provide the source and target coordinate, either as
345 names or as \parargthree{x}{y}{n}. Using |\d| with explicit source and target
346 coordinates works even if you did not provide a |degree| to the spectral
347 sequence. If you did provide a |degree|, then \sseqpages\ will check whether
348 the difference between the source and target is appropriate for a differential
349 of a given page, and if not it will throw an error. If this is undesirable, you
350 can use the |lax degree| option.
351 \begin{codeexample}[width = 7.5cm]
352 \begin{sseqdata}[ name = d example, degree = {-1}{#1},
353 struct lines = blue, yscale = 1.3 ]
354 \class(0,2)
355 \class(1,2)
356 \class(1,1)
357 \class(1,0)
358 \structline(1,2)(0,2)
359 \structline(1,2)(1,1)
360 \structline(1,1)(1,0)
361 \d2(1,0)
362 \end{sseqdata}
363 \printpage[ name = d example, page = 2 ] \quad
364 \printpage[ name = d example, page = 3 ]
365 \end{codeexample}
366 If there are multiple nodes in the source or target coordinate, then there is a
367 funny syntax for indicating which one should be the source and target:
368 \begin{center}
369 |\d\meta{page}\pars{\meta{x},\meta{y}\opt{,\sourcen,\targetn}}|
370 \end{center}
371 \begin{codeexample}[width = 7.5cm]
372 \begin{sseqpage}[ Adams grading, yscale = 0.8 ]
373 \class(1,0) \class(1,0)
374 \class(0,2) \class(0,2)
375 \d2(1,0,1,2)
376 \class(2,0) \class(2,0)
377 \class(1,2)
378 \d2(2,0,2)
379 \class(3,0)
380 \class(2,2) \class(2,2)
381 \d2(3,0,,2)
382 \end{sseqpage}
383 \end{codeexample}
384 Negative indices will count from the most recent class in the coordinate (so the
385 most recent is |-1|, the second most recent is |-2|, etc). You can also use a
386 |tag|, which works better if the situation is complicated.
387 \begin{codeexample}[width = 7.5cm]
388 \begin{sseqpage}[ Adams grading, yscale = 0.65 ]
389 \class(1,0)
390 \class(0,2) \class(0,2)
391 \d[blue]2(1,0,-1,-1)
392 \class(1,0)
393 \class(0,2)
394 \d[orange]2(1,0,-1,-1)
395 \class(1,0)
396 \d[red]2(1,0,-1,-2)
397 \end{sseqpage}
398 \end{codeexample}
399 \end{commandlist}
400
401 \begin{commandlist}{
402 {\doptions\moptions\meta{page}\pars{\meta{x},\meta{y}\opt{,\sourcen,\targetn}}},
403 {\doptions\moptions\meta{page}\pars{\sourcename\opt{,\targetn}}},
404 {\doptions\moptions\meta{page}\pars{\sourcecoord}\pars{\targetcoord}}%
405 }%
406 This command adds options to an existing differential, just like |\classoptions|
407 except for differentials. Its syntax is identical to that of |\d|.
408 \end{commandlist}
409
410 \begin{command}{\kill\meta{page}\oarg{coord}} This command sets the indicated
411 coordinate to die on the indicated page, but does not establish a target for the
412 differential. This is useful if you want to draw your own differential using
413 tikz (see |\getdtarget|) or if you are not drawing the class on the other side
414 of the differential for clutter reasons. As usual, if no coordinate is provided,
415 the default argument is |\lastclass|.
416 \end{command}
417
418 \begin{command}{\structline\ooptions\opt{\pars{\sourcecoord}\pars{\targetcoord}}}
419 The |\structline| command creates a structure line from \sourcecoord\ to
420 \targetcoord. The source and target coordinates are either of the form
421 \pars{\meta{x},\meta{y}\opt{,\meta{n}}} or \pararg{class name}. If there are
422 multiple classes at $\mathtt{(x,y)}$, then \meta{n} specifies which of the
423 classes at $\mathtt{(x,y)}$ the structure line starts and ends at -- if n is
424 positive, then it counts from the first class in that position, if n is
425 negative, it counts backwards from the most recent. You can also use a |tag| for
426 n. If the \targetcoord\ is omitted, then |\lastclass| is used, so that
427 |\structline(\sourcecoord)| connects the most recent class to the specified
428 coordinate. If both coordinates are omitted, then |\lastclass| and |\lastclass1|
429 are used, and so |\structline| with no arguments at all will connect the two
430 most recent classes.
431
432 If the source or target of a structure line is hit by a differential, then on
433 subsequent pages, the structure line disappears.
434
435 If the source or target has had multiple generations (i.e., they got hit and you
436 used |\replaceclass|), then the |\structline| will only appear starting on the
437 first page where the current generation of both the source and target are
438 present. If this is undesirable, you can use the |structline:page| option or the
439 to change it. Also, the structline will disppear the first time after this the
440 source or target has a differential, but this can be changed with the
441 |\replacestructlines| command.
442 \begin{codeexample}[width = 7.5cm]
443 \DeclareSseqGroup\tower {} {
444 \class(0,0)
445 \foreach \y in {1,...,5} {
446 \class(0,\y)
447 \structline
448 }
449 \class(0,2)
450 \structline(0,1,-1)
451 \structline(0,3,-1)
452 }
453 \begin{sseqdata}[ name = structline example,
454 classes = { circle, fill },
455 Adams grading, no axes,
456 yscale = 1.28 ]
457 \class(1,1) \class(1,2)
458 \class(2,3) \class(2,3) \class(2,5)
459 \tower[classes = blue](0,0)
460 \tower[struct lines = dashed,orange](1,0)
461 \tower[struct lines = red](2,0)
462 \d2(1,1,2)
463 \end{sseqdata}
464 \printpage[ name = structline example, page = 2 ] \quad
465 \printpage[ name = structline example, page = 3 ]
466 \end{codeexample}
467 \end{command}
468
469 \begin{command}{\structlineoptions\moptions\opt{\pars{\sourcecoord}\pars{\targetcoord}}}
470 This command adds options to an existing structure line, just like
471 |\classoptions| except for structure lines. Its syntax is identical to
472 |\structline|.
473 \end{command}
474
475 \begin{command}{\extension\ooptions\opt{\pars{\sourcecoord}\pars{\targetcoord}}}
476 The |\extension| command has an identical syntax to the |\structline| command
477 and most of the same options. Instead of adding a structline, it adds an
478 extension. The extensions are only shown on page $\infty$ or page ranges ending
479 at $\infty$.
480
481 \begin{codeexample}[width = 7.5cm]
482 \begin{sseqdata}[ name = extension example,
483 classes = { circle, fill },
484 Adams grading, no axes,
485 yscale = 1.28 ]
486 \class(0,0) \class(0,1)
487 \extension
488 \end{sseqdata}
489 \printpage[ name = extension example, page = 2 ] \quad
490 \printpage[ name = extension example, page = \infty ]
491 \end{codeexample}
492 \end{command}
493
494 \begin{command}{\extensionoptions\moptions\opt{\pars{\sourcecoord}\pars{\targetcoord}}}
495 This command adds options to an existing extension. Its syntax is identical to
496 |\extension|.
497 \end{command}
498
499 \begin{command}{\circleclasses\ooptions\pars{\sourcecoord}\pars{\targetcoord}}
500 This command is a lot like |\structline| except that it puts a circle around the
501 classes instead of connecting them with a line. It might take a certain amount
502 of fiddling with options to get |\circleclasses| to produce good results. There
503 is no |\circleclassesoptions| command because it doesn't seem necessary.
504 \end{command}
505
506 \begin{commandlist}{\draw,\path,\node,\clip}
507 Any code that would work in a \tikzpictureenv\ environment will also work
508 unchanged in a \sseqdataenv\ or \sseqpageenv\ environment, with a few minor
509 differences. This is a very flexible way to add arbitrary background or
510 foreground features to the spectral sequence:
511 \codeexample[from file=tikz]
512 \end{commandlist}
513
514
515 \section{Options for the main commands}
516 \subsection{Universal options}
517 The following options work with all of the drawing commands in this package,
518 including |\class|, |\d|, and |\structline|, |\extension|, their friends |\replaceclass|,
519 |\classoptions|, |\doptions|, |\structlineoptions|, |\extensionoptions|and |\replacestructlines|, as well as with \tikzpkg\
520 primitives.
521 \begin{keylist}{xshift = \meta{integer},yshift = \meta{integer}}
522 Shifts by integer values are the only coordinate changes that are allowed to be
523 applied to |\class|, |\d|, |\structline|, |\extension| their relatives, or to a \scopeenv\
524 environment that contains any of these commands. These shift commands help with
525 reusing code. For instance:
526 \begin{codeexample}[width = 6cm]
527 \begin{sseqpage}[ cohomological Serre grading, yscale = 0.45 ]
528 \foreach \x in {0,1} \foreach \y in {0,1} {
529 \begin{scope}[ xshift = \x, yshift = \y ]
530 \class(2,0)
531 \class(0,1)
532 \d2(0,1)
533 \end{scope}
534 }
535 \end{sseqpage}
536 \end{codeexample}
537 This code segment is very useful so \sseqpages\ has the command |\NewSseqGroup|
538 which to make code like this more convenient. The following code produces the
539 same output as above:
540 \begin{codeexample}[code only,width = 6cm]
541 \NewSseqGroup\examplegroup {} {
542 \class(2,0)
543 \class(0,1)
544 \d2(0,1)
545 }
546 \begin{sseqpage}
547 \examplegroup(0,0)
548 \examplegroup(0,1)
549 \examplegroup(1,0)
550 \examplegroup(1,1)
551 \end{sseqpage}
552 \end{codeexample}
553
554
555 A word of warning: the behavior of |xshift| in \sseqpages\ is incompatible with
556 the normal behavior of |xshift| in \tikzpkg. For some reason, saying%
557 |xshift = 1| in \tikzpkg\ does not shift the coordinate |(0,0)| to the
558 coordinate |(1,0)| -- instead it shifts by 1pt. In \sseqpages\ , saying%
559 |xshift = 1| moves the coordinate |(0,0)| to the coordinate |(1,0)|. This
560 includes \tikzpkg\ primitives: saying%
561 \codeverb|\draw[ xshift = 1 ] (0,0) -- (1,0);| inside a \sseqdataenv\ or
562 \sseqpageenv\ environment is the same as saying \codeverb|\draw(1,0) -- (2,0);|
563 despite the fact that this is not the case in the \tikzpictureenv\ environment.
564 \end{keylist}
565
566 \begin{manualentry}{Colors}
567 These come from the \LaTeX\ \colorpkg\ package via \tikzpkg, so see the
568 \href{\colormanualurl}{\colorpkg\ package documentation} for more information.
569 \begin{codeexample}[width = 6cm]
570 \begin{sseqpage}[ classes = {fill,inner sep = 0.4em},
571 no axes, scale = 1.3 ]
572 \class[red](0,0)
573 \class[blue](1,0)
574 \class[green](2,0)
575 \class[cyan](0,1)
576 \class[magenta](1,1)
577 \class[yellow](2,1)
578 \class[blue!50!red](0,2) % a 50-50 blend of blue and red
579 \class[green!30!yellow](1,2) % 30% green, 70% yellow
580 \class[blue!50!black](2,2)
581 \end{sseqpage}
582 \end{codeexample}
583 \end{manualentry}
584
585 \begin{manualentry}{\pgfmanualpdflabel{""quotes}{}|"|\meta{text}|"|\opt{\meta{options}}}
586 Specify a label for a class, a differential, or a structure line. This uses the
587 \tikzpkg\ quotes syntax. If the label text includes an equal sign or comma, you
588 need to enclose the entire label in braces, e.g., \codeverb|\class["{x =
589 y}"](0,0)|. The options include anything you might pass as an option to a
590 \tikzpkg\ node, including arbitrary coordinate transforms, colors, opacity
591 options, shapes, fill, draw, etc. The behavior is a little different depending
592 on whether you use it on a class or on a differential or structure line.
593
594 For a class, the \meta{text} is placed in the position |inside| the node by
595 default -- in effect, the \meta{text} becomes the label text of the node (so
596 saying |\class["label text"](0,0)| causes a similar effect to saying%
597 |\node at (0,0) {label text};|). There are other position options such as%
598 |left|, |above left|, etc which cause the label text to be placed in a separate
599 node positioned appropriately. If the placement is above, left, etc, then any
600 option that you may pass to a \tikzpkg\ node will also work for the label,
601 including general coordinate transformations. If the placement is ``inside'',
602 then the only relevant \opt{\meta{options}} are those that alter the appearance
603 of text, such as opacity and color.
604 \begin{codeexample}[width = 4cm]
605 \begin{sseqpage}[ classes = { minimum width = width("a") + 0.5em }, no axes ]
606 \class["a"](0,0)
607 \class["a", red](1,0)
608 \class["a" black, red](2,0)
609 \class["b" above](0,1)
610 \class["b" { below right, yshift = 0.1cm }](1,1)
611 \class["a" { above right = {1em} }](2,1)
612 \end{sseqpage}
613 \end{codeexample}
614 You can adjust the default behavior of class labels using the |labels| style
615 option or its relatives |class labels|, |inner class labels| or%
616 |outer class labels|. Note that it is also possible to give a label to a |\node|
617 this way, although the behavior is slightly different. In particular, the label
618 defaults to the |above| position instead of going in the |\node| text by
619 default. Also, this won't respect the various label style options like |labels|,
620 etc.
621 \begin{codeexample}[width = 6cm]
622 \begin{sseqpage}[ no axes ]
623 \class(0,0)
624 \class(2,0)
625 \node[circle, fill, "a"] at (1,0) {};
626 \end{sseqpage}
627 \end{codeexample}
628
629 \begin{key}{pin = \meta{style}} %
630 The |pin| key makes \sseqpages\ draw a line connecting the label to the relevant
631 class, which can provide necessary clarification in dense diagrams. The pin key
632 itself can take options which adjust the way that the line is drawn:
633 \begin{codeexample}[width = 6cm]
634 \begin{sseqpage}
635 \class(0,0)
636 \class["xy" { above, xshift = -4pt, pin = red }](0,0)
637 \class(0,0)
638 \class(0,1)
639 \structline
640 \end{sseqpage}
641 \end{codeexample}
642 \end{key}
643
644
645 The label normally goes on the right side of the edge. The special option |'|
646 makes it go in the opposite position from the default. I imitated the label
647 handling in the \tikzcdpkg\ package, so if you use \tikzcdpkg, this should be
648 familiar.
649 \begin{codeexample}[width = 6cm]
650 \begin{sseqpage}[ Adams grading, yscale = 0.63 ]
651 \class(0,0)
652 \class(0,1)
653 \class(0,2)
654 \structline["a"' blue](0,0)(0,1)
655 \class(1,0)
656 \class(1,1)
657 \structline["b"](1,0)(1,1)
658 \d[ "\cdot 2" { pos = 0.7, yshift = -5pt } ] 2 (1,0)
659 \end{sseqpage}
660 \end{codeexample}
661 You can use the style options |labels|, |edge labels|, |differential labels|,
662 |struct line labels|, and |extension labels| to adjust the styling of edge labels. For instance, if
663 you would prefer for the labels to default to the left hand side of the edge
664 rather than the right hand side, you could say |edge labels = {auto = left}|.
665 You can also use quotes to label edges drawn with \tikzpkg\ primitives:
666 \begin{codeexample}[width = 6cm]
667 \begin{sseqpage}[ yscale = 0.58, no axes ]
668 \class(0,0)
669 \class(1,1)
670 \draw (1,0) to["hi"'{ pos = 0.7, yshift = -0.5em }] (0,1);
671 \end{sseqpage}
672 \end{codeexample}
673
674 \needspace{3\baselineskip}
675 \begin{key}{description}
676 The |description| key, stolen from \tikzcdpkg, places the label on top of the
677 edge. In order to make this option work correctly, if the background coolor is
678 not the default white, you must inform \sseqpages\ about this using the key
679 |background color = |\meta{color}. In this document, the background color is
680 called \textit{graphicbackground}.
681 \begin{codeexample}[width = 6cm]
682 \begin{sseqpage}[ no axes, background color = graphicbackground ]
683 \foreach \x in {0,1,2} \foreach \y in {0,1} {
684 \class(\x,\y)
685 }
686 \structline["a" red](0,0)(0,1)
687 \structline["a'"'blue,"b"{yshift = 1em}](1,0)(1,1)
688 \structline["c" description](2,0)(2,1)
689 \end{sseqpage}
690 \end{codeexample}
691 \end{key}
692 \end{manualentry}
693
694
695
696 \subsection{Options for \sectionstring\class}\pgfmanualpdflabel{class options}{}
697 Because the main job of the |\class| command is to print a \tikzpkg\ |\node| on
698 the appropriate pages of the spectral sequence, most options that would work for
699 a \tikzpkg\ node also work for the commands |\class|, |\replaceclass|, and
700 |\classoptions|. Here are a few that you might care about:
701 \begin{manualentry}{A \tikzpkg\ shape}
702 If you give the name of a \tikzpkg\ shape, the class node will be of that shape.
703 The standard \tikzpkg\ shapes are |circle| and |rectangle|. \sseqpages\ defines
704 two new shapes:
705 \begin{key}{circlen = \meta{n}}%
706 This draws $n$ concentric circles. It's intended for indicating a
707 $\mathbb{Z}/p^n$ summand. For large values of $n$ the result isn't all that
708 appealing.
709 \begin{codeexample}[]
710 \begin{sseqpage}[ no axes ]
711 \class[circlen = 2](0,0)
712 \class[circlen = 2,fill](1,0)
713 \class[circlen = 3](0,1)
714 \class[circlen = 4](1,1)
715 \end{sseqpage}
716 \end{codeexample}
717 \end{key}
718
719 \begin{keylist}{newellipse,ellipse ratio = \meta{ratio}}%
720 This shape is used for |\circleclasses|. It's a variant on the |ellipse| shape
721 that gives more control over the ellipse's aspect ratio.
722 \end{keylist}
723
724 There are many more \tikzpkg\ shapes in the shapes library, which you can load
725 using the command |\usetikzlibrary{shapes}|. The following are some examples:
726 \begin{codeexample}[width = 6cm]
727 \begin{sseqpage}[ no axes, classes = { inner sep = 0.4em },
728 class placement transform = { scale = 1.8 },
729 yscale = 1.63 ]
730 \class(0,0)
731 \class[isosceles triangle](2,0)
732 \class[rectangle](1,0)
733 \class[diamond](0,1)
734 \class[semicircle](1,1)
735 \class[regular polygon, regular polygon sides = 5](2,2)
736 \class[regular polygon, regular polygon sides = 6](2,2)
737 \class[regular polygon, regular polygon sides = 7](2,2)
738 \class[regular polygon, regular polygon sides = 8](2,2)
739 \end{sseqpage}
740 \end{codeexample}
741 See the \href{\pgfmanualurl#section.49}{\tikzpkg\ manual} for more information.
742 \end{manualentry}
743
744 \begin{keylist}{minimum width = \meta{dimension}, minimum height =
745 \meta{dimension}, minimum size = \meta{dimension}, inner sep = \meta{dimension},
746 outer sep = \meta{dimension}}%
747 These options control the size of a node. This is typically useful to make the
748 size of nodes consistent independent of the size of their label text. For
749 instance:
750 \begin{codeexample}[width = 5cm]
751 \begin{sseqdata}[ name = minimum width example, no axes, yscale = 0.8 ]
752 \class["ab"](0,0)
753 \class["a"](0,1)
754 \class(0,2)
755 \end{sseqdata}
756 \printpage[ name = minimum width example ]
757 \printpage[ name = minimum width example,
758 change classes = { blue, minimum width = width("ab") + 0.5em } ]
759 \end{codeexample}
760 \end{keylist}
761
762 \begin{key}{class:name = \meta{node name}}%
763 The |\class| command makes a \tikzpkg\ node on appropriate pages. You can refer
764 to this node using \tikzpkg\ commands by using its coordinates. Using the
765 |class:name| option, you can give the node a name, which you can use to refer to
766 the class. Using names creates more readable code. The |show name| option can be
767 used to display the names of classes. You can modify the names of classes
768 systematically using the options |class name prefix|, |class name postfix|, and
769 |class name handler|.
770
771 Named classes are immune to coordinate transformations. For example, in the
772 following code, |xshift| does not apply to the nodes specified by |(id)| and
773 |(eta)| but does apply to the coordinate specified by |(1,1)|:
774 \begin{codeexample}[width = 6cm]
775 \begin{sseqpage}[classes = { show name=above }]
776 \class[class:name = 1](0,0)
777 \class[class:name = \eta](1,1)
778 \class(2,1)
779 \structline[xshift = 1] (1) (\eta)
780 \structline[xshift = 1,blue] (1) (1,1)
781 \end{sseqpage}
782 \end{codeexample}
783 \end{key}
784
785 \begin{key}{show name = \meta{label options}}
786 \declareasstyle{show name}
787 This option is like saying |"class name"\marg{label options}| if the class has a
788 name, and does nothing if the class has no name. If the class has multiple
789 names, only the most recent is used. This is particularly useful with class
790 styles, . For instance, by saying |this page classes = { show name = above }|
791 you can display names of all of the sources and targets of differentials on each
792 page.
793 \begin{codeexample}[width=7cm]
794 \begin{sseqdata}[
795 name = show name example,
796 this page classes = { show name = { above right, pin } }
797 ]
798 \class[ name = a ](0,2)
799 \class[ name = b ](0,3)
800 \class[ name = x ](1,0)
801 \d2(x)(a)
802 \replacesource[name=2x]
803 \d3(x)(b)
804 \end{sseqdata}
805
806 \printpage[ name = show name example, page = 2]
807
808 \printpage[ name = show name example, page = 3]
809 \end{codeexample}
810 \end{key}
811
812 \begin{key}{tag = \meta{tag}}%
813 This key adds a tag to the current class. Tags are used for identifying which of
814 multiple classes in the same position you are referring to. They are useful when
815 you have groups of related classes and want a family of differentials connecting
816 them. For instance:
817 \begin{codeexample}[width = 8cm]
818 \DeclareSseqGroup\tower {} {
819 \class(0,0)
820 \foreach \i in {1,...,11} {
821 \class(0,\i)
822 \structline(0,\i-1,-1)(0,\i,-1)
823 }
824 }
825 \NewSseqGroup\hvee {} {
826 \tower(0,0)
827 \foreach \i in {1,...,11} {
828 \class(\i,\i)
829 \structline(\i-1,\i-1,-1)(\i,\i,-1)
830 }
831 }
832 \begin{sseqpage}[ degree = {-1}{1}, yscale = 1.1,
833 x range = {0}{5}, y range = {0}{5} ]
834 \tower(3,0)
835 \hvee[ tag = id ](0,0)
836 \hvee[ tag = h21 ](4,2)
837 \foreach \n in {0,...,5} {
838 \d2(4+\n,2+\n,h21,id)
839 }
840 \end{sseqpage}
841 \end{codeexample}
842 We want each differential to go from the |h21| vee to the |id| vee, independent
843 of which classes are in the same position of the two vees. The easy way to
844 accomplish this is by giving tags to each of the two vees.
845 \end{key}
846
847 \begin{key}{insert = \meta{integer}}%
848 If there are multiple classes in the same position, this option allows you to
849 insert classes later into earlier positions. This is intended to help you put
850 logically related classes next to each other. If the integer is positive, it
851 inserts the class in the specified position, and if the integer is negative, it
852 counts backwards from the end. Providing |0| is the same as omitting the option
853 entirely. Values larger in absolute value than the total number of classes are
854 truncated. Consider:
855 \codeexample[from file=insert]
856 \end{key}
857
858 \begin{key}{offset = \{\pars{\meta{x offset},\meta{y offset}}\}}%
859 By default, a class uses the offset specified by |class pattern|. Occasionally
860 this is undesirable. In this case, you can specify the offset for a particular
861 class by hand. For example if the sum of two classes is hit by a differential,
862 it looks better for the class replacing them to be centered:
863 \begin{codeexample}[width = 9cm]
864 \begin{sseqdata}[ name = offset example,
865 xscale = 0.7,
866 Adams grading,
867 class placement transform = {scale = 1.8} ]
868 \class(0,1)
869 \class(0,2)\class(0,2)
870 \draw(0,1)--(0,2);
871 \class(1,0)
872 \d2(1,0,,1)
873 \replacetarget
874 \d2(1,0,,2)
875 \end{sseqdata}
876 \printpage[name = offset example, page=2]
877 \printpage[name = offset example, page=3]
878 \begin{sseqpage}[name = offset example, page=3]
879 \classoptions[offset = {(0,0)}](0,2)
880 \end{sseqpage}
881 \end{codeexample}
882 \end{key}
883
884 \begin{key}{tooltip = \meta{text}}%
885 This key generates a ``tooltip'' over the given class. That is, if you hover
886 your mouse over it, a little window will popup with the tooltip text. This is
887 particularly useful to give the coordinates or names of classes in large charts
888 where it may be hard to tell from looking at the picture what position the class
889 is in, or there may not be room to supply names to classes.
890
891 The tooltip is made using the |\pdftooltip| command from the |pdfcomment|
892 package. The |pdfcomment| package generates two extra auxiliary files, so it is
893 not included by default. In order to use the |tooltip| option, you have to use
894 the |tooltips| package option (e.g., load \sseqpages\ with
895 |\usepackage[tooltips]{spectralsequences}|). This cannot handle math, but it
896 will print math expressions into \TeX\ input form. Not all pdf viewers will
897 display the tooltip correctly. If this concerns you, the command |\sseqtooltip|
898 is used to produce the tooltip, and you can redefine it as any other command
899 that takes |\sseqtooltip|\marg{text}\marg{tooltip text} and produces a tooltip.
900 For instance, on \href{https://tex.stackexchange.com/a/164186/23866}{this stack
901 exchange post}, there is code that supposedly produces tooltips that work with
902 Evince. I have not tested whether it works by itself or whether it works with my
903 package, but you could. You could potentially figure out how to get math to work
904 in tooltips too -- if you find a satisfactory method, please let me know.
905
906 Here's an example:
907 \begin{codeexample}[]
908 \begin{sseqpage}[classes = {tooltip = {(\xcoord,\ycoord)}}]
909 \class(0,0)
910 \class(0,1)
911 \class(1,0)
912 \class(1,1)
913 \end{sseqpage}
914 \end{codeexample}
915
916 There's another example at the beginning of the section on the
917 \hyperref[sec:class stack]{class stack}.
918 \end{key}
919
920 \begin{keylist}{
921 class:page = \meta{page}\opt{-{}-\meta{page max}},
922 generation = \meta{generation}\opt{-{}-\meta{generation max}}
923 }
924 \def\classpagehandler#1#2{\textcolor{keycolor}{\noligs{#2}}}
925 \declarecustomhandler{class:page}{\classpagehandler}
926 These options only work in |\classoptions|. The |page| option gives a range of
927 pages for which the options apply to. If only one page is specified, it is the
928 minimum page and the option applies to all larger pages.
929 \begin{codeexample}[width = 6cm]
930 \begin{sseqdata}[ name = page_example, no axes,
931 title = \page, title style = {yshift = -0.5cm} ]
932 \class(0,0)
933 \classoptions[class:page = 2 -- 3, fill, blue](0,0)
934 \end{sseqdata}
935
936 \printpage[ name = page_example, page = 1 ] \qquad
937 \printpage[ name = page_example, page = 2 ] \qquad
938 \printpage[ name = page_example, page = 4 ]
939 \end{codeexample}
940 A ``generation'' of a class is the interval from one call of |\class| or
941 |\replaceclass| to the page on which it next supports or is hit by a
942 differential. By default the |\classoptions| command adds options only to the
943 most recent generation of the class in a \sseqdataenv\ environment, or on the
944 generation appropriate to the current page in a \sseqpageenv\ environment.
945 Using the |generation| option allows you to provide a single generation or range
946 of generations of the class that the options should apply to. The first
947 generation is generation 0, and the most recent generation is generation -1.
948 Larger negative values count backwards.
949 \codeexample[from file=class-page2a]
950 \codeexample[from file=class-page2b]
951 \end{keylist}
952
953 \begin{commandlist}{\xcoord,\ycoord}
954 These commands represent the $\mathtt{x}$ and $\mathtt{y}$ coordinate of the
955 current class when used in class options. The only use I have for them is in the
956 |tooltip| option, but maybe there is some other purpose for them.
957 \end{commandlist}
958
959
960 \subsection{Options for \sectionstring\d, \sectionstring\structline, and \sectionstring\extension}
961 Because the main job of the |\d|, |\structline|, and |\extension| commands is to
962 print an edge on the appropriate pages of the spectral sequence, most \tikzpkg\
963 options that you could apply to a \tikzpkg\ ``to'' operator (as in%
964 |\draw (x1,y1) to (x2,y2);|) can be applied to |\d|, |\structline|, and
965 |\extension|. Some such options are as follows:
966
967 \begin{keylist}{source anchor = \meta{anchor}, target anchor = \meta{anchor}}
968 Because you can't use the normal \tikzpkg\ mechanism for specifying the source
969 and target anchors, \sseqpages\ has these two keys for |\d|, |\structline|, and
970 |\extension|:
971 \begin{codeexample}[width = 4cm]
972 \begin{sseqpage}[ no axes, yscale = 1.24 ]
973 \foreach \x in {0,1} \foreach \y in {0,1} {
974 \class(\x,\y)
975 }
976 \structline(0,0)(0,1)
977 \structline[ source anchor = north west, target anchor = -30 ](1,0)(1,1)
978 \end{sseqpage}
979 \end{codeexample}
980 \end{keylist}
981
982
983 \begin{keylist}{shorten > = \meta{distance}, shorten < = \meta{distance}}%
984 These behave exactly like the corresponding options from \tikzpkg\ , shortening
985 the end and beginning of the edge respectively. Note that you can lengthen the
986 edge by shortening by a negative amount.
987 \end{keylist}
988
989 \begin{manualentry}{Dash patterns:}
990 See the \href{\pgfmanualurl#subsubsection.15.3.2}{\tikzpkg\ manual} for a
991 complete explanation of the dash pattern related options. Some examples:
992 \begin{codeexample}[width = 6cm]
993 \begin{sseqpage}[ no axes, yscale = 1.6 ]
994 \foreach \x in {0,1,2} \foreach \y in {0,1} {
995 \class(\x,\y)
996 }
997 \structline[densely dotted](0,0)(0,1)
998 \structline[dashed, red, "a"](1,0)(1,1)
999 \structline[dash dot, red, "a" black](2,0)(2,1)
1000 \end{sseqpage}
1001 \end{codeexample}
1002 %
1003 \end{manualentry}
1004
1005 \begin{keylist}{%
1006 bend left = \meta{angle}, bend right = \meta{angle},%
1007 *in = \meta{anchor}, *out = \meta{anchor}%
1008 }%
1009 \begin{codeexample}[width = 6cm]
1010 \begin{sseqpage}[no axes,yscale = 1.6]
1011 \foreach \x in {0,1,2} \foreach \y in {0,1} {
1012 \class(\x,\y)
1013 }
1014 \structline[bend left = 20](0,0)(0,1)
1015 \structline[bend right = 20](1,0)(1,1)
1016 \structline[in = 20, out = north](2,0)(2,1)
1017 \end{sseqpage}
1018 \end{codeexample}
1019 \end{keylist}
1020
1021 %\begin{key}{invisible}
1022 %
1023 % This key is only for |\d|. It prevents a differential from being drawn at all.
1024 % The typical reason you might want this is so that you can draw your own
1025 % differential using \tikzpkg\ commands. See |\getdtarget| for an example of
1026 % this.
1027 %
1028 % \end{key}
1029
1030 \begin{key}{structline:page = \meta{page}\opt{-{}-\meta{page max}}}%
1031 This key is only for |\structline| and |\structlineoptions|. By default, the
1032 |\structline| command only adds a structure line starting on the page where the
1033 most recent generation of the source or target is born:
1034
1035 \begin{codeexample}[width = 7.6cm]
1036 \begin{sseqdata}[ name = structpage example,
1037 title = \page, yscale = 0.53 ]
1038 \class(0,2)
1039 \class(0,4)
1040 \class(1,0)
1041 \class(1,1)
1042 \d2(1,0)(0,2) \replacesource
1043 \d3(1,1)(0,4) \replacesource
1044 \structline(1,0)(1,1)
1045 \end{sseqdata}
1046 \printpage[name = structpage example,page = 3]
1047 \qquad
1048 \printpage[name = structpage example,page = 4]
1049 \end{codeexample}
1050
1051 By specifying a page number, you can adjust which page the |\structline| starts
1052 on:
1053
1054 \begin{codeexample}[]
1055 \begin{sseqdata}[ name = structpage example2, title = \page, yscale = 0.5 ]
1056 \class(0,2)
1057 \class(0,4)
1058 \class(1,0)
1059 \class(1,1)
1060 \d2(1,0)(0,2) \replacesource
1061 \d3(1,1)(0,4) \replacesource
1062 \structline[structline:page = 2](1,0)(1,1)
1063 \end{sseqdata}
1064 \printpage[ name = structpage example2, page = 1 ]
1065 \qquad
1066 \printpage[ name = structpage example2, page = 2 ]
1067 \qquad
1068 \printpage[ name = structpage example2, page = 3 ]
1069 \qquad
1070 \printpage[ name = structpage example2, page = 4 ]
1071 \end{codeexample}
1072
1073 Similarly, for |\structlineoptions| you can specify a minimum page on which to
1074 apply the options, or a range of pages.
1075 \end{key}
1076
1077 \subsection{Options for \sectionstring\circleclass}
1078 \begin{key}{fit = \meta{coordinates or nodes}}%
1079 The |\circleclasses| command uses the \href{\pgfmanualurl#section.52}{\tikzpkg\
1080 fitting library}. Sometimes it's desirable to make the resulting node fit extra
1081 things, for example a label. It doesn't necessarily end up looking great though.
1082 \begin{codeexample}[]
1083 \begin{sseqpage}[ Adams grading, axes gap = 0.7cm ]
1084 \class(0,2)
1085 \class(1,0)
1086 % Fit in the label x and also a symmetric invisible label to maintain symmetry
1087 \d["x"{name = x}, "x"'{name = x', opacity = 0}]2(1,0)
1088 \circleclasses[fit = (x)(x'), rounded rectangle](1,0)(0,2)
1089 \end{sseqpage}
1090 \end{codeexample}
1091 \end{key}
1092
1093 \begin{key}{rounded rectangle}
1094 You can put a shape as an option and it will change the shape of the node drawn
1095 by |\circleclasses|. Any shape will do, but I think that an |ellipse| or
1096 |rounded rectangle| are the only particularly appealing options.
1097 \end{key}
1098
1099 \begin{key}{ellipse ratio = \meta{ratio} (initially 1.2)}%
1100 By default, the shape drawn by |\circleclasses| is a ``newelipse'' which is a
1101 custom defined shape that respects the option |elipse ratio| which roughly
1102 controls how long and skinny versus short and fat the ellipse is. If you find
1103 that the ellipse is too long, try a larger value of this option, and conversely
1104 if it's too fat try a smaller value. If no value is satisfactory, try out the
1105 |rounded rectangle| shape. (This is stolen from the following stack exchange
1106 answer: \url{https://tex.stackexchange.com/a/24621}.)
1107 \end{key}
1108
1109 \begin{keylist}{
1110 cc:class style,cc:permanent cycle style,cc:transient cycle style,
1111 cc:this page class style,cc:differential style,cc:struct line style,cc:extension style
1112 }
1113 See the \pgfmanualpdfref{class style}{corresponding entry} in the \tikzpkg\
1114 primitives section.
1115 \end{keylist}
1116
1117 \begin{key}{cc:page = \meta{page}\opt{-{}-\meta{page max}}}%
1118 By default, the ellipse will be drawn on the same set of pages that a structure
1119 line between the two classes would be drawn on. This specifies a range of pages
1120 for the ellipse to be drawn. Note that unlike with structure lines, you can
1121 instruct |\circleclasses| to draw the shape even on pages where one or both of
1122 the classes that it is fitting are dead.
1123 \end{key}
1124
1125 \subsection{Options for \tikzpkg\ primitives}
1126 \begin{key}{background}%
1127 This key instructs \sseqpages\ to put the current \tikzpkg\ primitive in the
1128 background. The way that the spectral sequence is printed is as follows:
1129 \begin{itemize}
1130 \item The title, axes, axes ticks, and axes labels are printed (the appropriate
1131 steps are skipped when the |no title|, |no axes|, |no ticks|, or |no labels|
1132 keys are used or if no title or axes labels are provided).
1133
1134 \item The \tikzpkg\ background paths are printed.
1135
1136 \item The clipping is inserted (unless the |no clip| key is used).
1137
1138 \item All foreground elements (classes, differentials, structure lines, and
1139 normal \tikzpkg\ paths) are printed.
1140 \end{itemize}
1141
1142 In particular, this means that foreground \tikzpkg\ paths can be clipped by the
1143 standard clipping, but background paths that are outside of the clipping expand
1144 the size of the \tikzpkg\ picture.
1145 \begin{codeexample}[]
1146 \begin{sseqpage}[ no ticks, yscale = 0.9, math nodes = false ]
1147 \class(0,0)
1148 \class(1,1)
1149 \begin{scope}[background]
1150 \draw(0.1,0.1)--(1.1,1.1);
1151 \end{scope}
1152 \node[background] at (0.5,-1) {not clipped};
1153 \node at (0.5,-0.4) {clipped};
1154 \end{sseqpage}
1155 \end{codeexample}
1156 Here is an example where \tikzpkg\ labels with the |background| key are used to
1157 add labels and a grid. Note that this styling is easier to make using the
1158 |title|, |x label|, |y label|, and |grid| options.
1159 \begin{codeexample}[]
1160 \begin{sseqdata}[ name = tikz background example, cohomological Serre grading, classes = fill ]
1161 \begin{scope}[background]
1162 \node at (\xmax/2,\ymax+1.2) {\textup{Page \page}};
1163 \node at (\xmax/2,-1.7) {H^*(B)};
1164 \node[rotate = 90] at (-1.5,\ymax/2) {H^*(F)};
1165 \draw[step = 1cm, gray, very thin] (\xmin-0.5,\ymin-0.5) grid (\xmax+0.4,\ymax+0.5);
1166 \end{scope}
1167 \class(0,0)
1168 \class(3,0)
1169 \class(0,2)
1170 \class(3,2)
1171 \d3(0,2)
1172 \end{sseqdata}
1173 \printpage[name = tikz background example, page = 2]
1174 \printpage[name = tikz background example, page = 3]
1175 \end{codeexample}
1176
1177 For this particular use case, it's probably better to use |title|, |x label|,
1178 and |y label|:
1179 \begin{codeexample}[]
1180 \begin{sseqdata}[ name = tikz background example2, cohomological Serre grading, classes = fill,
1181 grid = go, title = { Page \page }, x label = { $H^*(B)$ }, y label = { $H^*(F)$ } ]
1182 \class(0,0)
1183 \class(3,0)
1184 \class(0,2)
1185 \class(3,2)
1186 \d3(0,2)
1187 \end{sseqdata}
1188 \printpage[name = tikz background example2, page = 2]
1189 \printpage[name = tikz background example2, page = 3]
1190 \end{codeexample}
1191
1192 But if you need more flexible labeling, you'll likely want to use tikz
1193 primitives with |background|. See \example{KF3} for an instance where this key
1194 is useful.
1195
1196 One useful tip is that you can ensure consistent bounding boxes between
1197 different diagrams using%
1198 \begin{center}
1199 |\path[background] (smallest x, smallest y) -- (largest x, largest y);|:
1200 \end{center}
1201 \begin{codeexample}[]
1202 \begin{sseqdata}[ name = boundingboxex, x range = {0}{2}, y range = {0}{2}, scale = 0.5 ]
1203 \end{sseqdata}
1204 \printpage[ name = boundingboxex, title = not aligned ]
1205 \quad
1206 \printpage[ name = boundingboxex, x label = Hi ]
1207 \qquad
1208 \begin{sseqpage}[ name = boundingboxex, keep changes, title = aligned ]
1209 \path[background] (\xmin,\ymin-4) -- (\xmax,\ymax+2);
1210 \end{sseqpage}
1211 \quad
1212 \printpage[ name = boundingboxex, x label = Hi, title = {} ]
1213 \end{codeexample}
1214 \end{key}
1215
1216 \begin{keylist}{page constraint = \meta{predicate}, page constraint or = \meta{predicate}}
1217 \declarecustomhandler{page constraint}{\codehandler}
1218 This places a constraint on the pages in which the \tikzpkg\ primitive is
1219 printed. This predicate should look something like \texttt{(\string\page\ <= 4)}
1220 |&&| \texttt{(\string\page\ >= 3)}. The predicate is anded together with any
1221 previous predicates, so that you can use this as an option for a \scopeenv\ and
1222 again for the individual \tikzpkg\ primitive.
1223
1224 \begin{commandlist}{\isalive\pararg{coordinate},\isalive\{\pararg{coordinate 1}$\cdots$\pararg{coordinate n}\}}
1225 This command can only be used with |page constraint|. Saying
1226 \begin{center}
1227 |page constraint = {\pars{\meta{x},\meta{y}\opt{,}\oarg{index}}}}}|
1228 \end{center}
1229 will print the \tikzpkg\ primitive only on pages where the specified class is alive. Saying
1230 \begin{center}
1231 |page constraint = {\isalive(\meta{coordinate 1})|$\,\cdots\,$|(\meta{coordinate n})}|
1232 \end{center}
1233 is equivalent to
1234 \begin{center}
1235 |page constraint = {\isalive\pararg{coordinate 1} &&|$\,\cdots\,$|&& \isalive\pararg{coordinate n}}|
1236 \end{center}
1237 Writing
1238 \begin{center}
1239 \codeverb|\draw[page constraint = {\isalive(1,0)(2,2)}](1,0)|\texttt{-{}-}|(2,2);|
1240 \end{center}
1241 is the same as |\structline(1,0)(2,2)|, except that you can't later use
1242 |\structlineoptions| on it (and it won't have the |struct lines| style applied).
1243 \end{commandlist}
1244 \end{keylist}
1245
1246 \begin{keylist}{
1247 class style,permanent cycle style,transient cycle style,
1248 this page class style,differential style,struct line style,extension style
1249 }
1250 These classes apply the styling of the corresponding element to your \tikzpkg\
1251 commands.
1252 \begin{codeexample}[width = 6cm]
1253 \begin{sseqpage}[ differentials = blue, yscale = 0.65, no axes ]
1254 \class(0,2)
1255 \class(1,0)
1256 % This will be styled as if it were a differential
1257 \draw[differential style] (1,0) -- (0,2);
1258 \end{sseqpage}
1259 \end{codeexample}
1260 See |\getdtarget| for a more natural example.
1261 \end{keylist}
1262
1263
1264
1265 \section{Miscellaneous Commands}
1266 \subsection{Settings}
1267 \begin{command}{\sseqset\marg{keys}}%
1268 The |\sseqset| command is for adjusting the global options for all spectral
1269 sequences in the current scope, or for applying options to the rest of the
1270 current spectral sequence. For instance, if most of the spectral sequences in
1271 the current document are going to be Adams graded, you can say%
1272 |\sseqset{Adams grading}| and all future spectral sequences in the current scope
1273 will have Adams grading (unless you specify a different grading explicitly). As
1274 another example, |\sseqset{no axes}| will suppress axes from spectral sequences
1275 in the current scope. Note that defaults only apply to new \sseqdataenv\
1276 environments or to unnamed \sseqpageenv\ environments; they won't apply to
1277 existing spectral sequences.
1278
1279 You can also use |\sseqset| to create styles to be used in spectral sequences.
1280 \begin{keylist}{
1281 .global sseq style = \meta{keys},
1282 .global sseq append style = \meta{keys},
1283 .sseq style = \meta{keys},
1284 .sseq append style = \meta{keys}
1285 }%
1286 These handlers create reusable styles to be used in spectral sequences. If this
1287 style is a set of global options, then use the |.global sseq style| handler,
1288 whereas if it is supposed to be applied to individual features (classes,
1289 differentials, structure lines, circle classes, and tikz primitives) then use
1290 the |.sseq style| handler.
1291 \begin{codeexample}[width=6cm]
1292 \sseqset{
1293 mysseq/.global sseq style = {
1294 Adams grading, title = Page \page,
1295 x range = {0}{4}, y range = {0}{2},
1296 xscale = 0.5, yscale = 1.35
1297 },
1298 htwostruct/.sseq style = { gray, thin }
1299 }
1300 \begin{sseqpage}[ mysseq ]
1301 \class(0,0) \class(0,1) \class(0,2) \class(0,3)
1302 \class(3,1) \class(3,2) \class(3,3)
1303 \structline(0,0)(0,1) \structline(0,1)(0,2)
1304 \structline(0,2)(0,3)
1305 \structline(3,1)(3,2) \structline(3,2)(3,3)
1306 \structline[htwostruct](0,0)(3,1)
1307 \structline[htwostruct](0,1)(3,2)
1308 \structline[htwostruct](0,2)(3,3)
1309 \end{sseqpage}
1310 \end{codeexample}
1311 \end{keylist}
1312 \end{command}
1313
1314 \begin{command}{\SseqErrorToWarning\meta{error-name}}%
1315 Turns the error with the given name into a warning. An error message will start
1316 by saying \let\eatclnifpresent\empty|spectralsequences error: "error-name"|.
1317 This is the name you need to put into this command.
1318 \end{command}
1319
1320 \begin{environment}{{quiet}}%
1321 This environment quiets error messages that occur inside of it. \sseqpages\ is
1322 pretty good at error recovery, and so most of commands will fail gracefully and
1323 do nothing if their preconditions aren't met. If there are any parsing errors in
1324 the body of the |{quiet}| environment, prepare to see low level internal error
1325 messages. You might also run into bugs in \sseqpages\ -- the error recovery code
1326 hasn't been that carefully tested. If you do get low level error messages,
1327 remember to comment out the |{quiet}| environment before trying to debug.
1328
1329 This is particularly useful for code reuse commands. Sometimes there is a source
1330 of long differentials that only applies to classes that haven't already
1331 supported shorter differentials. Sometimes there should be a structure line if a
1332 certain class exists, but it might not exist. In these cases, the |{quiet}|
1333 environment will help you out. See also |\DrawIfValidDifferential|, which is a
1334 variant of |\d| that behaves as if it were inside a |{quiet}| environment.
1335 \end{environment}
1336
1337 \subsection{Code reuse commands}
1338 \begin{command}{\foreach }%
1339 This command is from \tikzpkg\ and works in pretty much the same way in
1340 \sseqpages, though with slightly better variants. The |\foreach| command is very
1341 flexible and has a lot of variants. The basic usage is%
1342 |\foreach \x in {\meta{xmin},...,\meta{xmax}} \marg{loop body}| which will
1343 execute |\meta{loop body}| with |\x| set to each value between \meta{xmin} and
1344 \meta{xmax} inclusive. If you want a step greater than 1, try%
1345 %
1346 \begin{center}
1347 |\foreach \x in {\meta{xmin},\meta{xmin}+\meta{xstep},...,\meta{xmax}}\marg{loop body}|.
1348 \end{center}
1349
1350 If you need to do multiple loops with a common body, you can just stack the
1351 |\foreach| commands:
1352 \begin{codeexample}[width=6cm]
1353 \begin{sseqpage}[ xscale = 0.5, x tick step = 2 ]
1354 \foreach \x in {0,2,...,6}
1355 \foreach \y in {0,...,3}{
1356 \class(\x,\y)
1357 }
1358 \end{sseqpage}
1359 \end{codeexample}
1360
1361 You can also loop through tuples, for instance:
1362 \begin{codeexample}[width=6cm]
1363 \begin{sseqpage}[ xscale = 0.5 ]
1364 \foreach \x/\y/\label in {0/1/a,1/1/b,0/0/c,1/0/d}{
1365 \class["\label" above](\x,\y)
1366 }
1367 \end{sseqpage}
1368 \end{codeexample}
1369 See the last example for |normalize monomial| for a better example of this
1370 usage.
1371
1372 There are tons of other things you can do with |\foreach|, though I haven't yet
1373 found need for them in combination with \sseqpages. See the
1374 \href{\pgfmanualurl#section.64}{\tikzpkg\ manual} for more details.
1375 \end{command}
1376
1377 \begin{commandlist}{
1378 \Do\marg{iterations}\meta{loop body},
1379 \DoUntilOutOfBounds\meta{loop body},
1380 \DoUntilOutOfBoundsThenNMore\marg{extra iterations}\meta{loop body},
1381 \iteration
1382 }%
1383 The one use case that |\foreach| doesn't cover all that well is if you want the
1384 loop to always repeat until the features you are drawing go off the page. This
1385 is what |\DoUntilOutOfBounds| and |\DoUntilOutOfBoundsThenNMore| are for. These
1386 help ensure that if you change the range of your chart, infinite families will
1387 automatically be drawn correctly without the need to adjust a bunch of loop
1388 bounds. The purpose of |\DoUntilOutOfBoundsThenNMore| is for towers that are
1389 receiving a differential. If your spectral sequence is Adams graded, and a tower
1390 is receiving a $d_r$ differential from another tower, you should use
1391 |\DoUntilOutOfBoundsThenNMore{r}|:
1392 \begin{codeexample}[width=7cm]
1393 \begin{sseqpage}[
1394 Adams grading, classes = fill,
1395 x range = {0}{10}, y range = {0}{6},
1396 x tick step = 2,
1397 xscale = 0.3,yscale = 0.7,
1398 run off differentials = {->}
1399 ]
1400 \class(0,0)
1401 \DoUntilOutOfBoundsThenNMore{3}{
1402 \class(\lastx+1,\lasty+1)
1403 \structline
1404 }
1405 \class(4,0)
1406 \d3
1407 \DoUntilOutOfBounds{
1408 \class(\lastx+1,\lasty+1)
1409 \structline
1410 \d3
1411 }
1412 \end{sseqpage}
1413 \end{codeexample}
1414 You can also nest |\DoUntilOutOfBounds| reasonably:
1415 \begin{codeexample}[width=7cm]
1416 \begin{sseqpage}[
1417 x range = {0}{6}, y range = {0}{6},
1418 tick step = 2,
1419 scale = 0.6
1420 ]
1421 \class(0,0)
1422 \DoUntilOutOfBounds{
1423 \class(\lastx+1,\lasty+1)
1424 \structline
1425 \DoUntilOutOfBounds{
1426 \class(\lastx,\lasty+1)
1427 \structline
1428 }
1429 }
1430 \end{sseqpage}
1431 \end{codeexample}
1432 One important difference between |\foreach| and the |\Do| family of commands is
1433 that |\Do| has no effect on the stack. This is in order to ensure that they nest
1434 properly.
1435
1436 Note that if you are using these commands and you are planning to draw several
1437 pictures of the chart with restricted range, you need to specify a range for the
1438 \sseqdataenv\ that contains all of the ranges of pages that you want to draw. If
1439 you then want to set a smaller default range, specify the smaller range the
1440 first time you use \sseqpageenv\ or |\printpage| to draw the spectral sequence,
1441 and include the |keep changes| key.
1442
1443 The |\Do| command is less general than |\foreach|; the purpose is to provide a
1444 syntax for stack-based looping that is similar to |\DoUntilOutOfBounds| but with
1445 a fixed range. So |\Do{n}\marg{loop body}| repeats \meta{loop body} |n| times.
1446 The assumption is that the loop body draws something relative to the position of
1447 the |\lastclass|.
1448
1449 If you need to know how many iterations one of these three commands has gone
1450 through, this is stored in the variable |\iteration|.
1451 \end{commandlist}
1452 \begin{commandlist}{\NewSseqCommand \cmdarg{command}\marg{argspec}\marg{body},
1453 \DeclareSseqCommand\cmdarg{command}\marg{argspec}\marg{body}}
1454 % TODO: Explain the difference between NewSseqCommand and DeclareSseqCommand!
1455 The \xparsepkg\ package provides these very powerful commands for defining
1456 macros. They are used internally to the \sseqpages\ package to define |\class|,
1457 |\d|, etc. To help you create variants of these commands, I will record here the
1458 argument specifications for each of them. See the \href{\xparseurl}{\xparsepkg\
1459 manual} for a better explanation and more information.
1460
1461 To make a command like |\class|, you can use the argument specification
1462 |O{}r()|. The argument type \texttt{O\marg{default}} stands for a bracket
1463 delimited optional argument with default value \meta{default}. In this case,
1464 we've specified the default to be empty. |r()| stands for a ``required''
1465 argument delimited by |(| and |)|. In the command definition, access the
1466 optional argument with |#1| and the coordinate with |#2|.
1467 \begin{codeexample}[width = 6.5cm,vbox]
1468 \DeclareDocumentCommand\demo{ O{} r() }
1469 { \#1 = \textcolor{purple}{\{#1\}};
1470 \#2 = \textcolor{purple}{\{#2\}} }
1471 \hbox{\demo[key = value](x,y)}
1472 \bigskip
1473 \hbox{\demo(1,2,3)}
1474 \end{codeexample}
1475 % TODO: explain what u does better
1476 If you want to separate out the coordinates into different arguments, you can
1477 use |O{}u(u,u)|. The argument type |u| stands for ``until'' and scans up until
1478 the next instance of the given character. So in this case, |#1| is of argument
1479 type |O| which is an option list, |#2| corresponds to the |u(| which is a
1480 throw-away argument, then |#3| corresponds to |u,| and contains the $\mathtt{x}$
1481 coordinate, and |#4| corresponds to |u)| and contains the $\mathtt{y}$
1482 coordinate. Note however that this will not match balanced parenthetical
1483 expressions.
1484 \begin{codeexample}[width = 6.5cm,vbox]
1485 \DeclareDocumentCommand\demo{ O{} u( u, u)}
1486 { \#1 = \textcolor{purple}{\{#1\}};
1487 \#3 = \textcolor{purple}{\{#3\}};
1488 \#4 = \textcolor{purple}{\{#4\}} }
1489 \hbox{\demo[hi](x,y)}
1490 \bigskip
1491 \hbox{\demo(1,2)}
1492 \bigskip
1493 \hbox{\demo((1+1)*2,2)}
1494 \bigskip
1495 \hbox{\demo(1,(1+1)*2)} % uh-oh -- *2) is left off!
1496 \end{codeexample}
1497 You can specify an optional argument delimited by parentheses using |d()|. Use
1498 the commands |\IfNoValueTF|, |\IfNoValueT|, and |\IfNoValueF| to test whether
1499 the user provided a value.
1500 \begin{codeexample}[width = 6.5cm,vbox]
1501 \DeclareDocumentCommand\demo{ O{} d() } {
1502 \#1 = \textcolor{purple}{\{#1\}};
1503 \#2 = \textcolor{purple}{
1504 \{\IfNoValueTF{#2}{no value}{#2}\} }
1505 }
1506 \hbox{\demo[hi](x,y)}
1507 \bigskip
1508 \hbox{\demo[options]}
1509 \bigskip
1510 \hbox{\demo(1,2)}
1511 \bigskip
1512 \hbox{\demo}
1513 \end{codeexample}
1514 An example where this is actually useful:
1515 \begin{codeexample}[width = 6.5cm]
1516 \DeclareSseqCommand\etaclass{ O{} d() }{
1517 \IfNoValueF{#2}{ \pushstack(#2) }
1518 \class[#1] (\lastx+1, \lasty+1)
1519 \structline
1520 }
1521 \begin{sseqpage}[ classes = fill, yscale = 0.55 ]
1522 \class(0,0)
1523 \class(0,1)
1524 \etaclass\etaclass
1525 \etaclass[blue](0,0)\etaclass
1526 \end{sseqpage}
1527 \end{codeexample}
1528
1529
1530 %The |\d| command has argument specification |O{} U( r()|. The argument type |U| is special to \sseqpages, and is a variant of until that reinserts the delimiting token. This allows the |(| token to also delimit the beginning of the |r()| argument. Note that the argument type |U| is specially added by \sseqpages\ and might be removed in the future if the \LaTeX3 team yells at me or something.
1531 % \ExplSyntaxOn
1532 % \cs_set_eq:NN \__xparse_add_type_U:w \sseq__xparse_add_type_U:w
1533 % \cs_set_eq:NN \__xparse_normalize_type_U:w \sseq__xparse_normalize_type_U:w
1534 % \sseq@install@xparse@Uarggrabber
1535 % \ExplSyntaxOff
1536 %\begin{codeexample}[width = 7cm,vbox]
1537 %\DeclareDocumentCommand {\demo} { O{} U( r() }
1538 % { \#1 = \textcolor{purple}{\{#1\}};
1539 % \#2 = \textcolor{purple}{\{#2\}};
1540 % \#3 = \textcolor{purple}{\{#3\}} }
1541 %\hbox{\demo[opts]page(x,y)}
1542 %\bigskip
1543 %\hbox{\demo5(x,y)}
1544 %\end{codeexample}
1545
1546 The |\structline| and |\changeclasses| commands have argument specification |O{}r()r()|.
1547 \begin{codeexample}[width = 7cm,vbox]
1548 \DeclareDocumentCommand\demo{ O{} r() r() }
1549 { \#1 = \textcolor{purple}{\{#1\}};
1550 \#2 = \textcolor{purple}{\{#2\}};
1551 \#3 = \textcolor{purple}{\{#3\}} }
1552 \hbox{\demo[hi](x,y)(x',y')}
1553 \bigskip
1554 \hbox{\demo(x,y,2)(x',y',-1)}
1555 \end{codeexample}
1556 \end{commandlist}
1557
1558 \begin{commandlist}{\NewSseqGroup\cmdarg{command}\marg{argspec}\marg{body},
1559 \DeclareSseqGroup\cmdarg{command}\marg{argspec}\marg{body}}%
1560 These are similar to |\NewSseqCommand| and |\DeclareSseqCommand| except that the
1561 commands defined take an optional square bracket delimited options list,
1562 followed by an optional parenthesis delimited |(x,y)| pair and wraps the body of
1563 the code in%
1564 \begin{center}
1565 |\begin{scope}[xshift = \meta{xcoord}, yshift = \meta{ycoord}, options]|.
1566 \end{center}
1567 For instance:
1568 \begin{codeexample}[width = 8cm]
1569 \DeclareSseqGroup\tower {m} {
1570 \class(0,0)
1571 \foreach \n in {1,...,#1} {
1572 \class(0,\n)
1573 \structline(0,\n-1)(0,\n)
1574 }
1575 }
1576 \begin{sseqpage}
1577 \tower[orange]{4}
1578 \tower(1,1){2}
1579 \end{sseqpage}
1580 \end{codeexample}
1581 Here we define a command which takes an options list, a coordinate, and a single
1582 mandatory argument. The options are applied to all the classes and structlines,
1583 the coordinate shifts the origin, and the mandatory argument is the length of
1584 the tower.
1585 \end{commandlist}
1586
1587 \begin{command}{\SseqCopyPage\cmdarg{command}\marg{spectral sequence name}\marg{page}}%
1588 This defines \cmdarg{command} to print all of the classes and structlines on
1589 page |\meta{page}| of the spectral sequence named%
1590 |\meta{spectral sequence name}|, throwing out differentials and tikz primitives.
1591 The resulting command has syntax as if you had used |\DeclareSseqGroup| with no
1592 extra arguments -- that is, it takes an optional options list, which are passed
1593 to a scope, and an optional coordinate pair.
1594 \end{command}
1595
1596 \subsection{Families}
1597 \spectralsequences\ has a concept of ``class families'' that can be drawn or
1598 suppressed as a group, and that can have styling options applied to them as a
1599 group.
1600 \begin{command}{\SseqNewFamily\marg{family name}}%
1601 This makes a new family with name \meta{family name}. The effect of this is to
1602 define global options |\meta{family name} style| which apply options to all
1603 classes in the family, |draw \meta{family name}| which causes the family to be
1604 drawn, and |no \meta{family name}| which suppresses the family (drawing is the
1605 default behavior of course). It also defines an option |\meta{family name}|
1606 which puts a feature into the family -- so it can be used as an option to any of
1607 the normal commands like |\class|, |\d|, |\structline|, etc and to a scope.
1608
1609 \codeexample[vbox, from file=imJ]
1610 \end{command}
1611
1612
1613 \subsection{Utilities}
1614 \begin{command}{\SseqParseInt\cmdarg{macro}\marg{integer expression}}%
1615 Stores the result of evaluating an integer expression into \cmdarg{macro}. An
1616 integer expression consists of |+|, |-|, |*|, |/|, parentheses, and macros that
1617 expand to more of the same. The exact rules regarding what is a valid expression
1618 are pretty much what you would expect. Note that juxtaposition is a syntax
1619 error, not multiplication, so |2(1+1)| is invalid, you must say |2*(1+1)|.
1620 \end{command}
1621
1622 \begin{commandlist}{
1623 \SseqIfEmptyTF\marg{expression}\marg{true code}\marg{false code},
1624 \SseqIfEmptyT\marg{expression}\marg{true code},
1625 \SseqIfEmptyF\marg{expression}\marg{false code}
1626 }%
1627 This tests if an expression is the empty expression. This is mainly useful for
1628 giving systematic labels to things.
1629 \end{commandlist}
1630
1631 \begin{commandlist}{
1632 \IfExistsTF\marg{page}\pararg{coordinate}\marg{true code}\marg{false code},
1633 \IfExistsT\marg{page}\pararg{coordinate}\marg{true code},
1634 \IfExistsF\marg{page}\pararg{coordinate}\marg{false code}
1635 }%
1636 Test whether a class of the given description exists. The description can be any
1637 valid coordinate, including a named coordinate. If the coordinate is not valid,
1638 this will return false.
1639 \end{commandlist}
1640
1641 \begin{commandlist}{
1642 \IfAliveTF\marg{page}\pararg{coordinate}\marg{true code}\marg{false code},
1643 \IfAliveT\marg{page}\pararg{coordinate}\marg{true code},
1644 \IfAliveF\marg{page}\pararg{coordinate}\marg{false code}
1645 }%
1646 Test whether a class is alive on the given page. If the class doesn't exist,
1647 this will return false.
1648 \end{commandlist}
1649
1650 \begin{commandlist}{
1651 \IfOutOfBoundsTF\pararg{coordinate}\marg{true code}\marg{false code},
1652 \IfOutOfBoundsT\pararg{coordinate}\marg{true code},
1653 \IfOutOfBoundsF\pararg{coordinate}\marg{false code},
1654 \IfInBoundsTF\pararg{coordinate}\marg{true code}\marg{false code},
1655 \IfInBoundsT\pararg{coordinate}\marg{true code},
1656 \IfInBoundsF\pararg{coordinate}\marg{false code}
1657 }%
1658 Test whether a class is in bounds or out of bounds. If no such class exists,
1659 returns false.
1660 \end{commandlist}
1661
1662 \begin{commandlist}{
1663 \IfValidDifferentialTF\meta{page}\pararg{coordinate}\opt{\pararg{target coordinate}}\marg{true code}\marg{false code},
1664 \IfValidDifferentialT\meta{page}\pararg{coordinate}\opt{\pararg{target coordinate}}\marg{true code},
1665 \IfValidDifferentialF\meta{page}\pararg{coordinate}\opt{\pararg{target coordinate}}\marg{false code},
1666 \DrawIfValidDifferentialTF\ooptions\meta{page}\pararg{coordinate}\opt{\pararg{target coordinate}}\marg{true code}\marg{false code},
1667 \DrawIfValidDifferentialT\ooptions\meta{page}\pararg{coordinate}\opt{\pararg{target coordinate}}\marg{true code},
1668 \DrawIfValidDifferentialF\ooptions\meta{page}\pararg{coordinate}\opt{\pararg{target coordinate}}\marg{false code},
1669 \DrawIfValidDifferential\ooptions\meta{page}\pararg{coordinate}\opt{\pararg{target coordinate}}\marg{false code}
1670 }%
1671 Test whether a differential is valid. There are many possible reasons for a
1672 differential to not be valid -- the source or target class could not exist, the
1673 target could not be in the correct grading, etc. If any error would be generated
1674 if you supplied the same arguments to |\d|, this tests false. Otherwise, this
1675 tests true. The command |\DrawIfValidDifferental| draws the differential if it
1676 is valid, whereas |\DrawIfValidDifferentalT| draws the differential and executes
1677 the true code if it is valid, |\DrawIfValidDifferentalF| draws the differential
1678 or executes false code if it isn't valid, etc.
1679 \end{commandlist}
1680
1681
1682
1683 \begin{command}{\SseqNormalizeMonomial}
1684 This command simplifies a monomial by combining like variables and removing
1685 bases that are raised to the 0th power, removing exponents of 1, removing 1's,
1686 and replacing the empty monomial with 1. The variables are sorted by first
1687 occurrence, use |\SseqNormalizeMonomialSetVariables| to set a different sort
1688 order. It outputs its result into |\result|. This command is specifically meant
1689 to be used as a value for |class label handler| or |class name handler|. See the
1690 example in the documentation for |class label handler| for a realistic example.
1691 The exponents must be integers or else it will misbehave.
1692 \begin{codeexample}[]
1693 \SseqNormalizeMonomial{x^0y^0} $\result$, \quad
1694 \SseqNormalizeMonomial{x^3yx^{-1}z^0} $\result$, \quad
1695 \SseqNormalizeMonomial{1x_2^2x^2_2} $\result$
1696 \end{codeexample}
1697 \end{command}
1698
1699 \begin{command}{\SseqNormalizeMonomialSetVariables}
1700 This command takes an undelimited list sets up |\SseqNormalizeMonomial| to sort
1701 the variables in the input in the specified order. This is useful for
1702 consistency, and particularly important for when you use it to name classes.
1703 For example:
1704 \begin{codeexample}[]
1705 % We always want a first, then b, then x_1, then x_2, then x_3
1706 \SseqNormalizeMonomialSetVariables{abx_1x_2x_3}
1707 \SseqNormalizeMonomial{ba} $\result$, \quad
1708 \SseqNormalizeMonomial{bx_1} $\result$, \quad
1709 \SseqNormalizeMonomial{abx_2x_3x_1} $\result$
1710 \end{codeexample}
1711 \SseqNormalizeMonomialSetVariables{}
1712 \end{command}
1713
1714
1715 \begin{command}{\SseqAHSSNameHandler}
1716 This command expects an argument of the form%
1717 |\meta{monomial}[\meta{integer expression}]| and defines |\result| to be |m[n]|
1718 where |m| is the result of applying |\SseqNormalizeMonomial| to the monomial,
1719 and |n| is the result of evaluation the integer expression plus any |yshift|
1720 that is present. This is intended for use with in drawing Atiyah Hirzebruch
1721 spectral sequences. See |class name handler| for an example of the calculation
1722 of $KO^*\mathbb{R}\mathrm{P}^8$.
1723 \end{command}
1724
1725 \subsection{Coordinate parsers and related}
1726 % \parsecoordinate and \parsedifferential
1727 \begin{command}{\parsecoordinate\cmdarg{macro}(\meta{coordinate})}%
1728 This command parses the coordinate and puts the triple |(x,y,n)| into
1729 \cmdarg{macro}. It also puts the components of the coordinate into macros, for
1730 instance if \cmdarg{macro} is |\coord|, then |\xcoord| will contain the x
1731 coordinate, |\ycoord| will contain the y coordinate, and |\ncoord| will contain
1732 the index. The coordinate can be anything that would be valid to use in a
1733 differential or structure line; this is the macro that is used internally to
1734 handle coordinates.
1735 \end{command}
1736
1737 \begin{command}{\getdtarget\cmdarg{macro}\marg{page}\pars{\sourcecoord}}%
1738 Sets \cmdarg{macro} equal to the coordinates of the target position of a length
1739 \meta{page} differential starting at \sourcecoord. This helps to make commands
1740 that draw fancy differentials.
1741 \end{command}
1742
1743 \begin{command}{\parsedifferential\meta{page}(\meta{differential coordinate})\opt{\pararg{differential target}}}%
1744 This has the same weird syntax of |\d|, except that you are required to put
1745 braces around the page (if it has multiple digits) and you are required to
1746 provide at least one coordinate (you have to say
1747 |\parsedifferential{2}(\lastclass)| for instance). This command is similar in
1748 effect to saying both |\parsecoordinate\source\meta{source coordinate}| and
1749 |\parsecoordinate\target\meta{target coordinate}|, but it handles determination
1750 of the target coordinate for you.
1751
1752
1753 For instance, consider the following example, suggested by Catherine Ray:
1754 \begin{codeexample}[]
1755 % O{} U( r() is the arg-spec for \d, O{} U( r() mm looks like \d with one extra mandatory arguments
1756 \NewSseqCommand{\twods}{ O{} U( r() d() m }{
1757 \parsedifferential{#2}(#3)(#4) % Store the target position in \target
1758 \nameclass{source}(\sourcecoord,\nsource) % give names to the three classes
1759 \nameclass{target1}(\targetcoord,\ntarget)
1760 \nameclass{target2}(\targetcoord,#5)
1761 %
1762 \circleclasses[ cc:differential style, name path = circ,
1763 #1, page = #2--#2 ]
1764 (target1)(target2) % Circle the classes, use differential style
1765 %
1766 % record source and targets as hit.
1767 \kill#2(source) \kill#2(target1) \kill#2(target2)
1768 %
1769 \path(target1)--(target2)
1770 coordinate[midway](midpt);% put a coordinate in the center of the two classes
1771 \path[name path = lin] (source) -- (midpt);% save path from start to midpoint
1772 %
1773 % draw line in "differential style" from start to intersection point of circ and lin
1774 \draw[ cc:differential style, #1, page constraint= { \page == #2 },
1775 name intersections = { of = circ and lin } ]
1776 (source) -- (intersection-1);
1777 }
1778 \begin{sseqdata}[ name = cathex, Adams grading, differentials = { blue } ]
1779 \class(0,2)\class(0,2)
1780 \class(1,0)\class(1,0)
1781 \twods2(1,0,-1,1){2}
1782 \end{sseqdata}
1783 \printpage[ name = cathex, page = 1 ]
1784 \qquad
1785 \printpage[ name = cathex, page = 2 ]
1786 \qquad
1787 \printpage[ name = cathex, page = 3 ]
1788 \end{codeexample}
1789 \end{command}
1790
1791 \begin{command}{\nameclass\marg{name}\pararg{coordinate}}%
1792 The |\nameclass| command gives a name to a class. It's similar to saying
1793 |\doptions[name = |\meta{name}|]|, but faster. It's also similar to saying
1794 |\pushstack|\pararg{coordinate}. Giving temporary names to coordinates that you
1795 are going to use repeatedly makes the code easier to read and is faster (though
1796 this only matters in very large charts). See |\getdtarget| for an example.
1797 \end{command}
1798
1799 \begin{command}{\tagclass\marg{tag}\pararg{coordinate}}%
1800 The |\tagclass| command gives a tag to a class. It's similar to saying
1801 |\doptions[tag = |\meta{name}|]|, but faster. See \example{tmfmayss} for a use
1802 case for this.
1803 \end{command}
1804
1805 \begin{command}{\gettag\cmdarg{macro}\pararg{coordinate}}%
1806 The |\gettag| command finds the most recent tag applied to the coordinate and
1807 stores it into |\cmdarg{macro}|. This is useful for connecting groups of nodes.
1808 For example, consider the following code, inspired by \example{tmfmayss}.
1809 \begin{codeexample}[width=6cm]
1810 \DeclareSseqCommand \tower { O{} } {
1811 \begin{scope}[#1]
1812 \foreach\i in {1,...,7}{
1813 \class(\lastx,\lasty+1)
1814 \structline
1815 }
1816 \end{scope}
1817 \restorestack
1818 }
1819 \DeclareSseqCommand \htwotower { O{} d() } {
1820 \IfNoValueF{#2}{
1821 \pushstack(#2)
1822 }
1823 \begin{scope}[#1]
1824 \gettag\thetag(\lastclass)
1825 \class(\lastx+3,\lasty+1)
1826 \structline[gray]
1827 \savestack
1828 \foreach\i in {1,...,7}{
1829 \class(\lastx,\lasty+1)
1830 \structline
1831 \structline[gray](\lastx-3,\lasty-1,\thetag)
1832 }
1833 \restorestack
1834 \end{scope}
1835 }
1836 \begin{sseqpage}[ y range = {0}{6}, x tick step = 3,
1837 xscale=0.6, yscale=1.3 ]
1838 \class(0,2) \class(0,3) \class(3,2)
1839 \class[tag = h_0^i](0,0)
1840 \tower[tag = h_0^i]
1841 \class(0,2) \class(0,1)
1842
1843 \htwotower[tag = h_2 h_0^i](0,0)
1844 \htwotower[tag = h_2 h_0^i]
1845 \end{sseqpage}
1846 \end{codeexample}
1847 \end{command}
1848
1849
1850 \subsection{The class stack}
1851 \label{sec:class stack}%
1852 The class stack is a linked list of the classes in the order that they are
1853 produced that \sseqpages\ maintains. Whenever you use the |\class| or
1854 |\replaceclass| command, the class you added is pushed onto the stack.
1855
1856 The following commands are used to access the stack:
1857
1858 \begin{commandlist}{\lastx\opt{\meta{n}},\lasty\opt{\meta{n}},\lastclass\opt{\meta{n}}}%
1859 The commands |\lastx| and |\lasty| evaluate to the |x| and |y| position,
1860 respectively, of the $n$th class on the stack. If $n = 0$ you can leave it off.
1861 The command |\lastclass| evaluates to the coordinate of the most recent class on
1862 the stack. This is useful for writing turtle-style code:
1863 \begin{codeexample}[width=6cm]
1864 \DeclareSseqCommand \etaclass {}{
1865 \class(\lastx+1,\lasty+1)
1866 \structline
1867 }
1868 \DeclareSseqCommand \divtwoclass {}{
1869 \class(\lastx,\lasty-1)
1870 \structline
1871 }
1872 \begin{sseqpage}
1873 \class(0,0)
1874 \savestack
1875 \foreach \y in { 1,...,5 }{
1876 \class(0,\y)
1877 \structline
1878 }
1879 \restorestack
1880 \etaclass\etaclass\etaclass
1881 \divtwoclass\divtwoclass
1882 \end{sseqpage}
1883 \end{codeexample}
1884
1885 You can use |\lastx| and |\lasty| in other contexts than in the body of a
1886 \sseqpages\ command, most notably inside |\SseqParseInt| (they also work
1887 correctly when used inside of |\pgfmathparse| and its siblings). For instance,
1888 consider the following tower command:
1889 \begin{codeexample}[width=6cm]
1890 \DeclareSseqCommand \tower { } {
1891 \savestack
1892 \SseqParseInt\numclasses{\ymax-\lasty0}
1893 \foreach \n in {1,...,\numclasses}{
1894 \class(\lastx,\lasty+1)
1895 \structline
1896 }
1897 \restorestack
1898 }
1899 \begin{sseqpage}[y range = {0}{5}]
1900 \class(0,0)\tower
1901 \class(1,3)\tower
1902 \class(3,2)\tower
1903 \end{sseqpage}
1904 \end{codeexample}
1905 \end{commandlist}
1906
1907
1908 \begin{command}{\pushstack\pararg{coordinate}}%
1909 This adds a class to the top of the stack. The coordinate is specified using the
1910 same syntax as a coordinate for |\structline| or |\replaceclass|.
1911 \end{command}
1912
1913 \begin{commandlist}{\savestack,\restorestack}%
1914 This saves and reverts the stack. Saves nest. Most frequently, you will want to
1915 use these at the start and end of a command.
1916 \end{commandlist}
1917
1918
1919 \section{Styles}%
1920 The \sseqpages\ package has a large number of styles which control the
1921 appearance of specific components (e.g., classes, differentials, or structure
1922 lines) of a spectral sequence. Each style has two corresponding keys: |classes|
1923 and |change classes|. Saying |classes = |\marg{keys} adds the keys to the list
1924 of options used to style every future class, whereas%
1925 |change classes = |\marg{keys} only makes sense in a \sseqpageenv\ environment,
1926 and temporarily overwrites the list of options. Note that |change classes| only
1927 applies to classes that existed before the current page, and that even with the
1928 |keep changes| option, the |change classes| options are local to the current
1929 page. Compare:
1930 \begin{codeexample}[width = 8cm]
1931 \begin{sseqdata}[ name = style example ]
1932 \class(0,0)\class(1,1)
1933 \end{sseqdata}
1934 \begin{sseqpage}[ name = style example,
1935 classes = { fill, blue },
1936 title = change new classes ]
1937 \class(0,1)\class(1,0)
1938 \end{sseqpage}
1939 \quad
1940 \begin{sseqpage}[ name = style example,
1941 change classes = { fill, blue },
1942 title = change old classes ]
1943 \class(0,1)\class(1,0)
1944 \end{sseqpage}
1945 \end{codeexample}
1946
1947 You can modify these styles outside of a spectral sequence or inside it using
1948 |\sseqset|, you can modify them as options to the \sseqdataenv\ and
1949 \sseqpageenv\ environments, or you can modify them as arguments to the
1950 \scopeenv\ environment.
1951
1952 In cases where the same drawing feature is affected by multiple of these styles,
1953 the more specific style takes precedence. For instance, for a class that is the
1954 source or target of a differential on the current page, the precedence order
1955 from lowest to highest goes: |sseq style|, |class style|,%
1956 |transient cycle style|, |this page cycle style|, and then any options from
1957 scopes in the order they appear, and any local options (the options that come
1958 right with the class, e.g., |\class[local options](x,y)|). If you don't want the
1959 options to your scopes to override more specific styles, use |sseq|:
1960 \begin{codeexample}[width = 7cm]
1961 \begin{sseqpage}[ classes = { blue, fill },
1962 title style = { align = center, text width = 2.4cm },
1963 title = { everything is orange } ]
1964 \begin{scope}[orange]
1965 \class(0,0) \class(0,1)
1966 \structline(0,0)(0,1)
1967 \end{scope}
1968 \end{sseqpage}
1969
1970 \begin{sseqpage}[ classes = { blue, fill },
1971 title style = { align = center, text width = 2.4cm },
1972 title = { only structure line is orange } ]
1973 \begin{scope}[ sseq = orange ]
1974 \class(0,0) \class(0,1)
1975 \structline(0,0)(0,1)
1976 \end{scope}
1977 \end{sseqpage}
1978 \end{codeexample}
1979
1980
1981 Throughout, ``class'' and ``cycle'' are synonyms.
1982 \begin{stylekeylist}{sseqs, change sseqs,sseq,change sseq}%
1983 This passes options to all features in all future spectral sequences in the
1984 current scope. Note that for many global options you can set a default directly
1985 by saying |\sseqset{key = \marg{value}}| and this is in some cases preferable.
1986
1987 \begin{codeexample}[width = 7cm]
1988 % Applies to both of the following sseqs:
1989 \sseqset{ sseqs = { blue, scale = 0.5 } }
1990 \begin{sseqpage}
1991 \foreach \x in {0,1}
1992 \foreach \y in {0,1,2} {
1993 \class(\x,\y)
1994 }
1995 \end{sseqpage}
1996 \begin{sseqpage}[ Adams grading, classes = fill ]
1997 \foreach \x in {0,1,2}
1998 \foreach \y in {0,1,2} {
1999 \class(\x,\y)
2000 }
2001 \d2(1,0)
2002 \d2(2,0)
2003 \end{sseqpage}
2004 \end{codeexample}
2005 \end{stylekeylist}
2006
2007 \begin{stylekeylist}{classes, cycles,change classes,change cycles}
2008 \begin{codeexample}[width = 6cm]
2009 \begin{sseqpage}[ classes = { blue, fill, minimum width = 0.5em },
2010 scale = 0.5, x tick step = 2, y tick step = 2 ]
2011 \class(0,0)
2012 \class(2,2)
2013 \end{sseqpage}
2014 \end{codeexample}
2015 \end{stylekeylist}
2016
2017
2018 \begin{stylekeylist}{%
2019 permanent classes, permanent cycles,%
2020 change permanent classes, change permanent cycles%
2021 }%
2022 These options change the appearance of all permanent cycles (e.g., those classes
2023 which never support or are hit by a differential). For instance, we can circle
2024 the permanent cycles automatically. In the following example, note that because
2025 |permanent cycles| is more specific than |classes|, the%
2026 |permanent cycles = {draw}| command takes precedence over the%
2027 |classes = {draw = none}| command and the permanent cycle nodes are drawn.
2028 \begin{codeexample}[width = 6.5cm]
2029 \begin{sseqpage}[ cohomological Serre grading,
2030 classes = { draw = none },
2031 permanent cycles = {draw} ]
2032 \foreach \x in {0,2} \foreach \y in {0,1} {
2033 \class["\mathbb{Z}"](\x,\y)
2034 }
2035 \d2(0,1)
2036 \end{sseqpage}
2037 \end{codeexample}
2038 \end{stylekeylist}
2039
2040 \begin{stylekeylist}{
2041 transient classes, transient cycles,
2042 change transient classes,change transient cycles
2043 }%
2044 These options change the appearance of all transient cycles (e.g., those classes
2045 which eventually support or are hit by a differential). Again, this takes
2046 precedence over the |classes| option.
2047 \begin{codeexample}[width = 6.5cm]
2048 \begin{sseqpage}[ cohomological Serre grading,
2049 classes = { draw = none },
2050 transient cycles = red ]
2051 \foreach \x in {0,2} \foreach \y in {0,1} {
2052 \class["\mathbb{Z}"](\x,\y)
2053 }
2054 \d2(0,1)
2055 \end{sseqpage}
2056 \end{codeexample}
2057 \end{stylekeylist}
2058
2059 \begin{stylekeylist}{%
2060 this page classes, this page cycles,%
2061 change this page classes,change this page cycles%
2062 }%
2063 These options change the appearance of all cycles which support or are hit by a
2064 differential on this page. Any class that is hit on the current page is also a
2065 transient cycle, and so |this page classes| takes precedence over%
2066 |transient cycles|.
2067 \begin{codeexample}[width = 6cm]
2068 \begin{sseqdata}[ name = this page cycles example, Adams grading,
2069 transient cycles = { red, fill }, this page cycles = { blue } ]
2070 \class(0,0)
2071 \class(0,2) \class(1,0)
2072 \class(1,3) \class(2,0)
2073 \d2(1,0) \d3(2,0)
2074 \end{sseqdata}
2075 \printpage[ name = this page cycles example, page = 2 ] \qquad
2076 \printpage[ name = this page cycles example, page = 3 ]
2077 \end{codeexample}
2078 \end{stylekeylist}
2079
2080 \begin{stylekeylist}{
2081 edges, differentials, struct lines, extensions,
2082 change edges, change differentials, change struct lines, change extensions
2083 }%
2084 The |edges| key applies to both differentials and structure lines. The
2085 |differentials|, |struct lines|, and |extensions| keys take precedence over |edges|.
2086 \end{stylekeylist}
2087
2088 \begin{stylekeylist}{this page struct lines, change this page struct lines}%
2089 This style applies to structure lines whose source or target is hit on the
2090 current page. It takes precedence over |struct lines|.
2091 \end{stylekeylist}
2092
2093 \begin{stylekeylist}{tikz primitives,change tikz primitives}
2094 Applies to all \tikzpkg\ primitives.
2095 \end{stylekeylist}
2096
2097
2098 \begin{stylekeylist}{labels,change labels}%
2099 This style applies to labels on classes, differentials, and structure lines. All
2100 the more specific label styles take precedence over it.
2101 \end{stylekeylist}
2102
2103 \begin{stylekeylist}{
2104 class labels,inner class labels,outer class labels,
2105 change class labels,change inner class labels,change outer class labels
2106 }%
2107 Inner class labels specifically applies to class labels that are inside the
2108 node, outer class labels specifically applies to ones outside it:
2109 \begin{codeexample}[]
2110 \begin{sseqpage}[ no axes, classes = { inner sep = 1pt },
2111 label distance = 2pt,
2112 outer class labels = { red },
2113 inner class labels = { blue } ]
2114 \class["a", "b" above](0,0)
2115 \class["a", "c" right](1,0)
2116 \end{sseqpage}
2117 \end{codeexample}
2118 \end{stylekeylist}
2119
2120 \begin{stylekeylist}{
2121 edge labels,differential labels,struct line labels, extension labels,
2122 change edge labels,change differential labels,change struct line labels, change extension labels,
2123 }%
2124
2125 \end{stylekeylist}
2126
2127
2128 \subsection{Style-like options}
2129 The options are not styles, but can be modified in the same set of places
2130 (namely, anywhere):
2131
2132 \begin{keylist}{label distance = \meta{dimension}}%
2133 This sets the default distance from a class to an outer label. There are also
2134 variants like |above label distance| corresponding to |above|, |below|, |left|,
2135 |right|, |above left|, |above right|, |below left|, and |below right|.
2136 \begin{codeexample}[width = 6cm]
2137 \begin{sseqpage}[ label distance = 0.3em,
2138 right label distance = 0em,
2139 no axes, yscale = 1.25 ]
2140 \class["a" above](0,0)
2141 \class["b" above right](0,1)
2142 \class["c" right](1,0)
2143 \class["c" {right = 1em}](1,1)
2144 \end{sseqpage}
2145 \end{codeexample}
2146 \end{keylist}
2147
2148 \begin{keylist}{run off = \meta{start tip}--\meta{end tip},
2149 run off differentials = \meta{start tip}--\meta{end tip} (initially {...--...}),
2150 run off struct lines = \meta{start tip}--\meta{end tip} (initially {...--...}),
2151 run off extensions = \meta{start tip}--\meta{end tip} (initially {...--...}),}%
2152 Change the default behavior of run off edges for either all edges, just
2153 differentials, just structure lines, or just extensions respectively. Local
2154 arrowhead options override this.
2155
2156 If an edge runs off the edge of the clipping, \sseqpages\ automatically add an
2157 arrowhead to indicate that the edge continues. This option controls which arrow
2158 head is added if the start or end of an edge runs off the page.
2159 \begin{codeexample}[width = 6cm]
2160 \begin{sseqpage}[ x range = {0}{2}, y range = {0}{2},
2161 draw orphan edges, run off = >-stealth ]
2162 \class(0,0)
2163 \class(3,0) \class(0,3)
2164 \structline(0,0)(3,0)
2165 \structline[red](0,0)(0,3)
2166 \structline[blue](3,0)(0,3)
2167 \end{sseqpage}
2168 \end{codeexample}
2169 \end{keylist}
2170
2171 \begin{key}{class label handler = \meta{function}}
2172 \declarecustomhandler{class label handler}{\codehandler}%
2173 The value of |class label handler| is a function that is applied to all labels
2174 before displaying them. It should put its output into |\result|. This is
2175 intended to help with code reusability. Because these handlers may crash or have
2176 annoying side-effects on some input, you may want to toggle the value of this
2177 command on and off. To turn this off for the rest of the current spectral
2178 sequence you can say |\sseqset{class label handler = {}}|. You can also use the
2179 |class label handler| key in a \scopeenv.
2180
2181 The main function \sseqpages\ provides for use here is
2182 |\SseqNormalizeMonomial{#1}|. This makes it convenient to translate expressions
2183 with polynomial labels. You can write your own handlers if your \TeX\
2184 programming skills are sufficient. Let me know if there are any other functions
2185 that you want here, and if you implement them yourself, please send me your
2186 implementation. Here is an example of a function that evaluates an arithmetic
2187 expression:
2188 \begin{codeexample}[width=6cm]
2189 \begin{sseqpage}[
2190 class label handler = { \SseqParseInt\result{#1} }
2191 ]
2192 \class["1+1"](0,0)
2193 \class["1+2*(1+3*(4-1))"](1,1)
2194 \end{sseqpage}
2195 \end{codeexample}
2196 Here's an example using |\SseqNormalizeMonomial|:
2197 \begin{codeexample}[width = 6cm]
2198 \NewSseqGroup \test {m} {
2199 \class["1#1"](0,0)
2200 \class["\alpha#1"](0,1)
2201 \class["y#1"](1,0)
2202 \class["\alpha y#1"](1,1)
2203 }
2204 \begin{sseqpage}[
2205 class label handler = { \SseqNormalizeMonomial{#1} },
2206 classes = { draw = none }, class labels = { font = \small } ]
2207 \test{}
2208 \test[red](2,0){y^2}
2209 \test[orange](2,2){\alpha^2y^2}
2210 \test[blue](0,2){\alpha^2}
2211 \end{sseqpage}
2212 \end{codeexample}
2213
2214 Here is another example which demonstrates a useful idiom for drawing Serre
2215 spectral sequences. For a more complete example, see \example{KF3n}. Note the
2216 use of braces in |{Sq^1\iota_2}|. Without braces, |\SseqNormalizeMonomial| will
2217 simplify |Sq^1xSq^2x| into $S^2q^3x^2$, which is obviously undesirable, so the
2218 correct way to input this is |{Sq^1x}{Sq^2x}|. Unfortunately, |\foreach| strips
2219 a pair of braces from its arguments, so you need to put two pairs of braces.
2220 %\pgfmanualpdflabel{normalizemonomialex-labels}
2221 \begin{codeexample}[width=8cm]
2222 \begin{sseqpage}[
2223 xscale = 1.4,
2224 classes = { draw = none },
2225 class label handler = {\SseqNormalizeMonomial{#1}} ]
2226
2227 \foreach \x/\xlabel in
2228 { 0/1, 2/\iota_2, 3/{{Sq^1\iota_2}}, 4/\iota_2^2 }
2229 \foreach \y/\ylabel in
2230 { 0/1, 1/\alpha, 2/x, 3/\alpha x, 4/x^2 }
2231 {
2232 \class["\ylabel\xlabel"] (\x,\y)
2233 }
2234 \end{sseqpage}
2235 \end{codeexample}
2236 \end{key}
2237
2238
2239 \begin{key}{class name handler = \meta{function}}
2240 \declarecustomhandler{class name handler}{\codehandler}%
2241 The value of |class name handler| is a function that is applied to all names
2242 before using them. It should put its output into |\result|. The main functions
2243 intended for use here are |\SseqAHSSNameHandler| and |\SseqNormalizeMonomial|,
2244 though you can make your own. This is applied both when you name the class, as
2245 in \codeverb|\class[name=a](\meta{coordinate})| and when you refer to a class by
2246 name, as in |\structline(a)(b)|. One advantage if you are using
2247 |\SseqNormalizeMonomial| is that you can ensure that |xy| and |yx| refer to the
2248 same class:
2249 \begin{codeexample}[]
2250 \SseqNormalizeMonomialSetVariables{xy}
2251 \begin{sseqpage}[ class name handler = \SseqNormalizeMonomial,
2252 classes = {show name = {right,pin}} ]
2253 \class[name = xy](0,0)
2254 \class[name = yxy](0,1)
2255 \class(1,0)
2256 \structline(yx)(yyx)
2257 \end{sseqpage}
2258 \end{codeexample}
2259 The next page is an example drawing the Atiyah Hirzebruch spectral sequence
2260 computing $KO^*\mathbb{R}P^{8}$.
2261 % Have to load from file so that \afterpage doesn't cause trouble with verbatim reading.
2262 \afterpage{%
2263 An AHSS using \scantokens{|class name handler = \SseqAHSSNameHandler|:}
2264 \par
2265 \codeexample[from file=KORP8,vbox]
2266 \newpage
2267 }
2268 \end{key}
2269
2270 \begin{keylist}{class name prefix = \meta{prefix}, class name postfix = \meta{postfix}}%
2271 These keys add respectively a prefix or a postfix to all names of all classes in
2272 the scope. This is applied both when you name the class, as in
2273 \codeverb|\class[name=a](\meta{coordinate})| and when you refer to a class by
2274 name, as in |\structline(a)(b)|. The prefix and postfix are added to the command
2275 before the |class name handler| is applied, so if you say |name=\meta{the name}|
2276 then the name actually given to the class is the value of |\result| after saying
2277 \begin{center}
2278 |\classnamehander{\meta{name prefix}\meta{the name}\meta{name postfix}}|
2279 \end{center}
2280 \end{keylist}
2281
2282 \section{Global Options}
2283 These options can only be set at the beginning of a \sseqdataenv\ or
2284 \sseqpageenv\ environment. When it makes sense, you can also set a default
2285 value using |\sseqset|. Generally, these options either modify the plot style or
2286 the logic for the spectral sequence.
2287 \begin{key}{name = \meta{sseq name}}%
2288 This option must be used with the \sseqdataenv\ environment where it indicates
2289 the name of the spectral sequence, which will be used with the \sseqpageenv\
2290 environment or |\printpage| command to draw the spectral sequence. The name used
2291 in a \sseqdataenv\ environment must be new unless the environment is used with
2292 the |update existing| key in which case the \sseqdataenv\ environment will add
2293 to the existing spectral sequence. It is optional when used with \sseqpageenv\ ,
2294 and if included the name given must be the name of an existing spectral
2295 sequence.
2296 \end{key}
2297
2298 \begin{key}{page = \meta{page number}\opt{--\meta{page max} (initially 0)}}%
2299 This key is for \sseqpageenv\ and |\printpage|. It specifies which page of the
2300 spectral sequence is to be printed. On page r, all |\class|es that are not hit
2301 by differentials on pages less than r will be printed, as well as all
2302 |\structline|s whose source and target classes are both printed on page r, and
2303 all differentials of length exactly r. The special value |page = 0| prints all
2304 classes, differentials, and structure lines but no extensions. The special value
2305 |page=\infty| will draw the infinity page with extensions.
2306
2307 If you use this key with a range, e.g., |page=2--5|, then all differentials in
2308 that range of lengths will be drawn, so in the example differentials of length
2309 greater than or equal to 2 and less than or equal to 5 are drawn. The larger
2310 number only changes which differentials are drawn, classes and structlines are
2311 drawn as if the page was the small endpoint of the range. If you use 0 for the
2312 \meta{page max}, then all differentials longer than \meta{page number} will be
2313 drawn, e.g., |page=5---0| draws all differentials of length at least 5, but no
2314 extensions. Using |page=5---\infty| will draw all differentials of length at
2315 least 5 and also all extensions whose endpoint classes are in the
2316 final generation on page 5.
2317 \end{key}
2318
2319 \begin{keylist}{%
2320 degree = \marg{x degree}\marg{y degree},%
2321 cohomological Serre grading,%
2322 homological Serre grading,%
2323 Adams grading%
2324 }%
2325 Specifies the degree of differentials. The \meta{x degree} and \meta{y degree}
2326 should both be mathematical expressions in one variable |#1| that evaluate to
2327 integers on any input. They specify the $\mathtt{x}$ and $\mathtt{y}$
2328 displacement of a page $\mathtt{\#1}$ differential. In practice, they will be
2329 linear expressions with |#1| coefficient 1, -1, or 0.
2330
2331 The |degree| option must be given before placing any differentials. It can be
2332 specified at the beginning of the \sseqdataenv\ environment, at the beginning
2333 of the \sseqpageenv\ environment if it is being used as a standalone page, or
2334 as a default by saying |\sseqset{degree = \marg{x degree}\marg{y degree}}| or
2335 |\sseqset{Adams grading}| outside of the \sseqdataenv\ and \sseqpages\
2336 environments.
2337
2338 You can make a named grading convention by saying \codeverb|\sseqset{my
2339 grading/.sseq grading = \marg{x degree}\marg{y degree}}|. Then later passing%
2340 |my grading| to a spectral sequence is equivalent to saying%
2341 |degree = \marg{x degree}\marg{y degree}|. The following grading conventions
2342 exist by default:
2343 \begin{codeexample}[width = 6cm]
2344 % equivalent to degree = {#1}{1-#1}:
2345 \begin{sseqpage}[ cohomological Serre grading ]
2346 \class(0,1)
2347 \class(2,0)
2348 \d2(0,1)
2349 \end{sseqpage}
2350 \end{codeexample}
2351 \begin{codeexample}[width = 6cm]
2352 % equivalent to degree = {-#1}{#1-1}:
2353 \begin{sseqpage}[ homological Serre grading ]
2354 \class(0,1)
2355 \class(2,0)
2356 \d2(2,0)
2357 \end{sseqpage}
2358 \end{codeexample}
2359 \begin{codeexample}[width = 6cm]
2360 % equivalent to degree = {-1}{#1}:
2361 \begin{sseqpage}[ Adams grading ]
2362 \class(0,2)
2363 \class(1,0)
2364 \d2(1,0)
2365 \end{sseqpage}
2366 \end{codeexample}
2367 \end{keylist}
2368
2369 \begin{keylist}{strict degree, lax degree}
2370 If the degree is strict, then \LaTeX will throw an error if you try to specify a
2371 differential that doesn't have the proper grading. The degree is strict by
2372 default.
2373 \begin{codeexample}[code only]
2374 \begin{sseqdata}[ name = laxdegree, Adams grading ]
2375 \class(0,2)
2376 \class(1,0)
2377 \d3(1,0)(0,2) % Error: differential does not respect grading.
2378 % Target should be in position (0,3) but instead it is (0,2)...
2379 \end{sseqdata}
2380 \end{codeexample}
2381
2382 \begin{codeexample}[]
2383 \begin{sseqdata}[ name = laxdegree, Adams grading, lax degree, yscale = 0.6 ]
2384 \class(0,2)
2385 \class(1,0)
2386 \d3(1,0)(0,2) % No error because degree checking is off
2387 \end{sseqdata}
2388 \printpage[ name = laxdegree, page = 3 ]
2389 \end{codeexample}
2390 \end{keylist}
2391
2392 \begin{key}{update existing}
2393 This key is only for the \sseqdataenv\ environment. It specifies that the
2394 current \sseqdataenv\ environment is adding data to an existing spectral
2395 sequence. If you don't pass this key, then giving a \sseqdataenv\ environment
2396 the same |name| as a different \sseqdataenv\ environment will cause an error.
2397 This is intended to help you avoid accidentally reusing the same name.
2398 \end{key}
2399
2400
2401 \begin{key}{keep changes =\meta{boolean} (default true)(initially false)}%
2402 This option is only for the \sseqpageenv\ environment, and only works when a
2403 |name| is provided. This option specifies that all of the commands in the
2404 current \sseqpageenv\ environment should be carried forward to future pages of
2405 the same named spectral sequence. For example:
2406 \begin{codeexample}[]
2407 \begin{sseqdata}[ name = keep changes example, Adams grading, y range = {0}{3} ]
2408 \class(0,0)
2409 \class(1,0)
2410 \end{sseqdata}
2411
2412 \begin{sseqpage}[ name = keep changes example, sseq = orange ]
2413 \class(0,2)
2414 \class(1,2)
2415 \classoptions[orange](1,0)
2416 \d2(1,0)
2417 \end{sseqpage} \qquad
2418
2419 \printpage[ name = keep changes example, page = 2 ] \qquad
2420
2421 \begin{sseqpage}[ name = keep changes example, sseq = blue, keep changes ]
2422 \class(0,3)
2423 \class(1,3)
2424 \classoptions[blue](1,0)
2425 \d3(1,0)
2426 \end{sseqpage} \qquad
2427
2428 \printpage[ name = keep changes example, page = 3 ]
2429 \end{codeexample}
2430 Note that the orange classes and differential do not persist because the
2431 |keep changes| option is not set in the first \sseqpageenv\ environment, but the blue
2432 classes and differential do, since the |keep changes| option is set in the
2433 second \sseqpageenv\ environment.
2434 \end{key}
2435
2436
2437 \begin{keylist}{no differentials,draw differentials}
2438 The option |no differentials| suppresses all of the differentials on the current
2439 page, whereas |draw differentials| causes the page appropriate differentials to
2440 be drawn. This is useful for explaining how the computation of a spectral
2441 sequence goes, or if you want to display one of the edges of the spectral
2442 sequence, like in \example{KF3n}.
2443 \end{keylist}
2444
2445 \begin{keylist}{no struct lines,draw struct lines}
2446 The option |no struct lines| suppresses all of the structure lines on the
2447 current page, whereas the option |draw struct lines| causes the page appropriate
2448 structure lines to be drawn.
2449 \end{keylist}
2450
2451 \begin{keylist}{no orphan edges,draw orphan edges}
2452 An edge is an ``orphan'' if both its source and target lie off the page. By
2453 default these are drawn, but with the option |no orphan edges| they are not. If
2454 the option |no orphan edges| has been set, |draw orphan edges| undoes it.
2455 \begin{codeexample}[width = 9cm]
2456 \begin{sseqdata}[
2457 name = orphan edges example,
2458 cohomological Serre grading,
2459 x range = {0}{2}, y range = {0}{2} ]
2460 \class(0,3) \class(3,1)
2461 \d3(0,3)
2462 \class(2,1) \class(4,0)
2463 \d2(2,1)
2464 \end{sseqdata}
2465 \printpage[ name = orphan edges example ]
2466 \quad
2467 \printpage[ name = orphan edges example,
2468 no orphan edges ]
2469 \end{codeexample}
2470 \end{keylist}
2471
2472
2473 \begin{key}{class pattern = \meta{class pattern name} (initially standard)}%
2474 This key specifies the arrangement of multiple classes at the same coordinate.
2475 The default value is |standard|.
2476 \begin{codeexample}[width = 5cm]
2477 \begin{sseqdata}[ name = class pattern example, no axes, ymirror ]
2478 \class(0,0)
2479 \class(1,0) \class(1,0)
2480 \class(0,1) \class(0,1) \class(0,1)
2481 \class(1,1) \class(1,1) \class(1,1) \class(1,1)
2482 \class(0,2) \class(0,2) \class(0,2) \class(0,2) \class(0,2)
2483 \class(1,2) \class(1,2) \class(1,2) \class(1,2) \class(1,2) \class(1,2)
2484 \end{sseqdata}
2485
2486 \printpage[ name = class pattern example, class pattern = standard ]
2487 \printpage[ name = class pattern example, change classes = blue,
2488 class pattern = linear, class placement transform = { rotate = 45 } ]
2489 \end{codeexample}
2490
2491 You can add new class patterns using |\SseqNewClassPattern|:
2492 \begin{command}{\SseqNewClassPattern\marg{class pattern name}\marg{offsets}}
2493 Creates a new class pattern. For example, the |linear| class pattern is created
2494 using the command:
2495 \begin{codeexample}[code only]
2496 \SseqNewClassPattern{linear}{
2497 (0,0);
2498 (-0.13,0)(0.13,0);
2499 (-0.2,0)(0,0)(0.2,0);
2500 (-0.3,0)(-0.1,0)(0.1,0)(0.3,0);
2501 (-0.4,0)(-0.2,0)(0,0)(0.2,0)(0.4,0);
2502 (-0.5,0)(-0.3,0)(-0.1,0)(0.1,0)(0.3,0)(0.5,0);
2503 }
2504 \end{codeexample}
2505 For instance the third row indicates that if there are three classes at the
2506 position |(x,y)| they should be printed at |(x-0.2,y)|, |(x,y)|, and
2507 |(x+0.2,y)|. You can give as many rows as you like; \sseqpages\ will throw an
2508 error if there are more classes in any position than the maximum number that
2509 your class pattern can handle -- for instance, the |linear| class pattern can
2510 handle up to six classes based on this definition.
2511 \end{command}
2512 \end{key}
2513
2514
2515 \begin{keylist}{%
2516 class placement transform = \marg{transform keys},%
2517 add class placement transform = \marg{transform keys}%
2518 }%
2519 \declareasstyle{class placement transform}\declareasstyle{add class placement transform}%
2520 The option |class placement transform| allows the user to specify a \tikzpkg\
2521 coordinate transform to adjust the relative position of multiple nodes in the
2522 same $\mathtt{(x,y)}$ position. The |class placement transform| key overrides
2523 the previous value of transformations, the |add class placement transform| just
2524 adds the new transformation to the end of the list. This coordinate transform
2525 can only involve rotation and scaling, no translation. Specifying a scaling
2526 factor helps if the nodes are too large and overlap. In some cases a rotation
2527 makes it easier to see which class is the target of a differential.
2528 \begin{codeexample}[width = 5cm]
2529 \begin{sseqpage}[ class placement transform = { xscale = 1.5 },
2530 class pattern = linear,
2531 classes = { draw = none },
2532 xscale = 2, x axis extend end = 0.7cm ]
2533 \class["\mathbb{Z}"](0,0)
2534 \class["\mathbb{Z}/2"](1,1)
2535 \class["\mathbb{Z}/3"](1,1)
2536 \end{sseqpage}
2537 \end{codeexample}
2538 \begin{codeexample}[width = 5cm]
2539 \begin{sseqpage}[ class placement transform = { rotate = 40 },
2540 cohomological Serre grading, scale = 0.65,
2541 classes = fill, differentials = blue ]
2542 \class(0,0)
2543 \class(0,2)\class(0,2)
2544 \class[red](3,0)\class[green](3,0)\class[blue](3,0)
2545
2546 \d3(0,2,1,2)
2547 \d3(0,2,-1,-1)
2548 \draw[->,red](3,0,1)--(0,0);
2549 \end{sseqpage}
2550 \end{codeexample}
2551 With multiple large class labels, the best option is to arrange the classes
2552 vertically:
2553 \begin{codeexample}[width = 5.5cm]
2554 \begin{sseqpage}[ classes = {draw = none }, xscale = 2, yscale=1.55,
2555 class pattern = linear,
2556 class placement transform = { scale = 1.5, rotate = 90 },
2557 right clip padding = 20pt, top clip padding = 20pt,
2558 x axis gap = 30pt, y axis gap = 20pt ]
2559 \class["\iota_3\beta\iota_3"](7,0)
2560 \class["P^1\iota_3"](7,0)
2561
2562 \class["\iota_2\iota_3\beta\iota_3"](7,2)
2563 \class["\iota_2P^1\iota_3"](7,2)
2564
2565 \class["(\beta\iota_3)^2"](8,0)
2566 \class["P^1\beta\iota_3"](8,0)
2567 \class["\beta P^1\iota_3"](8,0)
2568
2569 \class["\iota_2(\beta\iota_3)^2"](8,2)
2570 \class["\iota_2P^1\beta\iota_3"](8,2)
2571 \class["\iota_2\beta P^1\iota_3"](8,2)
2572 \end{sseqpage}
2573 \end{codeexample}
2574 \end{keylist}
2575
2576 \begin{key}{math nodes = \meta{boolean} (default true)(initially true)}%
2577 This key instructs \sseqpages\ to put all labels in math mode automatically.
2578 \end{key}
2579
2580
2581
2582 \subsection{Global coordinate transformations}
2583 Of the normal \tikzpkg\ coordinate transformations, only the following can be
2584 applied to a \sseqpages\ chart:
2585 \begin{keylist}{scale = \meta{factor},xscale = \meta{factor}, yscale = \meta{factor}, xmirror, ymirror}%
2586 Scale the chart by \meta{factor}. Under normal circumstances, you can tell
2587 \tikzpkg\ to mirror a chart by saying, for instance, |xscale = -1|, but
2588 \sseqpages\ needs to be aware that the chart has been mirrored in order to draw
2589 the axes correctly. Thus, if you want to mirror a spectral sequence, use the
2590 |xmirror| and |ymirror| options as appropriate.
2591 \end{keylist}
2592
2593 \begin{key}{rotate = \meta{angle}}
2594 It probably won't look great if you pick an angle that isn't a multiple of 90 degrees.
2595 \end{key}
2596
2597 \subsection{Plot options and axes style}
2598 \begin{keylist}{x range = \marg{x min}\marg{x max},y range = \marg{y min}\marg{y
2599 max}} These options set the x range (respectively y range) to be a specific
2600 interval. By default, if no range is specified then the range is chosen to fit
2601 all the classes. If an x range is specified but no y range, then the y range is
2602 chosen to fit all the classes that lie inside the specified x range, and vice
2603 versa. The values must be integers -- if you want to extend the x axis a
2604 noninteger amount, try using |x axis start extend| or |x axis end extend|.
2605 \end{keylist}
2606
2607 \begin{commandlist}{
2608 \SseqOrientationNormal,\SseqOrientationSideways,\SseqOrientationToggle
2609 }
2610 By default, the \sseqpageenv\ environment will try to check whether the chart
2611 fits onto the page (without causing overfull boxes). Environments like the
2612 \env{sideways} environment rotate the content by 90 degrees. The range checker
2613 needs to be aware of this. |\SseqOrientationNormal| indicates that the content is
2614 normal (not rotated). |\SseqOrientationSideways| indicates that the content is
2615 rotated 90 degrees (it doesn't matter in which direction). |\SseqOrientationToggle|
2616 swaps between |\SseqOrientationNormal| and |\SseqOrientationSideways|.
2617
2618 \sseqpages\ will automatically detect the chart is being printed inside of a
2619 sideways environment or not. This can be arranged for other environments with
2620 |\AtBeginEnvironment{my-sideways}{\SseqOrientationToggle}|.
2621 \end{commandlist}
2622 \begin{keylist}{range check on (default), range check off, range check standard, range check sideways}
2623 These options control the range checking behavior.
2624
2625 By default \sseqpages\ will try to compute whether the chart fits onto the page
2626 (without causing overfull boxes). The computation isn't perfectly accurate and
2627 it assumes that the entire page is available for the chart to use up, so for
2628 instance if the chart is indented because of |\textindent| or not at the top of
2629 the page, this might give overly large values. Also, the values computed aren't
2630 perfectly accurate.
2631
2632 If the range check is not desirable, you can use |range check off|.
2633
2634 The options |range check standard| and |range check sideways| only work for the
2635 \sseqpageenv\ environment. |range check standard| is equivalent to |range check on|
2636 and |\SseqOrientationNormal|. |range check sideways| is equivalent to |range check on|
2637 and |\SseqOrientationSideways|.
2638 \end{keylist}
2639
2640 \begin{keylist}{
2641 grid = \meta{grid type},
2642 grid color = \meta{color},
2643 grid step = \meta{positive integer},
2644 x grid step = \meta{positive integer},
2645 y grid step = \meta{positive integer}
2646 }%
2647 Makes \sseqpages\ draw a grid. The grid types and a significant part of the
2648 code that produces them were stolen from the \sseqpkg\ package.
2649 \begin{codeexample}[vbox]
2650 \begin{sseqdata}[ name = grid example, scale = 0.8 ]
2651 \class(0,0)
2652 \class(3,0)
2653 \class(2,1)\class(2,1)
2654 \class(1,2)\class(1,2)\class(1,2)
2655 \class(0,3)
2656 \class(3,3)
2657 \end{sseqdata}
2658 \hbox{
2659 \printpage[ name = grid example, grid = chess, title=chess ]
2660 \qquad
2661 \printpage[ name = grid example, grid = crossword, title=crossword ]
2662 }
2663 \vskip20pt
2664 \hbox{
2665 \printpage[ name = grid example, grid = go, title=go ]
2666 \qquad
2667 \printpage[ name = grid example, grid = none ]
2668 }
2669 \end{codeexample}
2670 It is possible to make your own grid type by defining the command
2671 |\sseq@grid@yourgridname| to draw a grid.
2672
2673 It is a known problem that acrobat reader displays grids very dark and thick.
2674 This is caused by the enhance thin lines ``feature'' of Acrobat reader. You can
2675 turn it off globally by going into the acrobat reader preferences window and
2676 unchecking the ``Enhance thin lines'' checkbox in the ``Rendering'' section.
2677 Unfortunately, there is no way to instruct Acrobat Reader to not apply this
2678 feature to a particular document. This has apparently been annoying graphic
2679 designers for over a decade.
2680
2681 The grid color option changes the color of the grid; the default value is |gray|.
2682 The grid step keys change the grid step.
2683 \end{keylist}
2684
2685 \begin{keylist}{%
2686 title = \meta{text},%
2687 title style = \meta{keys},%
2688 x label = \meta{text},%
2689 y label = \meta{text},%
2690 x label style = \meta{keys},%
2691 y label style = \meta{keys},%
2692 label style = \meta{keys}%
2693 }
2694 \declareasstyle{title style}
2695 \declareasstyle{x label style}
2696 \declareasstyle{y label style}
2697 \declareasstyle{label style}
2698 This make chart labels.
2699 \begin{codeexample}[width = 6cm]
2700 \begin{sseqpage}[ title = { An example }, yscale = 0.5,
2701 x label = { x axis label },
2702 y label = { y axis label },
2703 label style = { blue, font = \small },
2704 x label style = { yshift = 5pt },
2705 ]
2706 \class(0,0)
2707 \class(2,2)
2708 \end{sseqpage}
2709 \end{codeexample}
2710 Note that if you make multiple versions of the same chart and some of the charts
2711 have labels and others don't, they might not align the way you want. An easy
2712 solution to this is to use |\path[background] (min x, min y) -- (max x, max y);|
2713 where the coordinates are below and to the left, respectively above and to the
2714 right, of everything else drawn in any picture. This makes the bounding boxes
2715 for all of the pictures the same size, so that they line up even if the exact
2716 collection of things drawn changes. See the example at the end of the
2717 |background| key for an illustration of this.
2718 \end{keylist}
2719
2720 \needspace{5\baselineskip}
2721 \begin{keylist}{no title, draw title, no x label, no y label, no labels, draw x label, draw y label, draw labels}
2722 Suppress or unsuppress the title, x label, y label, or both x and y labels,
2723 respectively.
2724 \end{keylist}
2725
2726
2727 \begin{keylist}{no x ticks, no y ticks, no ticks, draw x ticks, draw y ticks, draw ticks}
2728 Suppress axes ticks (the numbers next to the axes). Only matters if axes are
2729 drawn. You can make your own ticks using \tikzpkg\ inside a \scopeenv\
2730 environment with the |background| key. For instance, you might want to label the
2731 axes as 0, $n$, $2n$, \ldots You can achieve this as follows: (you can also use
2732 |x tick handler|).
2733 \begin{codeexample}[width = 5.7cm]
2734 \begin{sseqpage}[ no x ticks, x range = {0}{3} ]
2735 \begin{scope}[ background ]
2736 \node at (0,\ymin - 1) {0};
2737 % \vphantom is fragile so we have to throw in an extra \protect
2738 \node at (1,\ymin - 1) {\protect\vphantom{2}n};
2739 \foreach \n in {2,..., \xmax}{
2740 \node at (\n,\ymin - 1) {\n n};
2741 }
2742 \end{scope}
2743 \class(0,0)
2744 \class(3,2)
2745 \end{sseqpage}
2746 \end{codeexample}
2747 \end{keylist}
2748
2749
2750 \begin{keylist}{x tick step = \meta{positive integer} (initially 1),y tick step = \meta{positive integer} (initially 1),tick step = \meta{positive integer} (initially 1)}
2751 Sets the interval between labels.
2752 \end{keylist}
2753
2754 \begin{keylist}{x tick offset = \meta{integer} (initially 0),y tick offset = \meta{integer} (initially 0),tick offset = \meta{integer} (initially 0)}%
2755 Sets the label offset -- by default the ticks will always be the set of numbers
2756 that are 0 mod \meta{tick step}. Change it so that the ticks are the set of
2757 numbers that are \meta{tick offset} mod \meta{tick step}.
2758 \end{keylist}
2759
2760 \begin{keylist}{
2761 x major tick step = \meta{nonnegative integer} (initially 0),
2762 y major tick step = \meta{nonnegative integer} (initially 0),
2763 major tick step = \meta{nonnegative integer},
2764 x minor tick step = \meta{nonnegative integer} (initially 0),
2765 y minor tick step = \meta{nonnegative integer} (initially 0),
2766 minor tick step = \meta{nonnegative integer}%
2767 }%
2768 If these are nonzero, they control the placement of tick marks on the axes. The
2769 value 0 prevents tick marks from being drawn. Uses |x tick offset| as an offset.
2770 \begin{codeexample}[width=7cm]
2771 \begin{sseqpage}[
2772 tick step = 5,
2773 major tick step = 5,
2774 minor tick step = 1,
2775 scale = 0.4,
2776 axes type = frame
2777 ]
2778 \class(0,0)
2779 \class(10,10)
2780 \end{sseqpage}
2781 \end{codeexample}
2782 \end{keylist}
2783
2784 \begin{stylekeylist}{x tick style,y tick style,tick style}
2785 Change the tick style:
2786 \begin{codeexample}[width = 7cm]
2787 \begin{sseqpage}[ tick style = { blue, font = \tiny } ]
2788 \class(0,0) \class(2,1)
2789 \end{sseqpage}
2790 \end{codeexample}
2791 \end{stylekeylist}
2792
2793 \begin{keylist}{%
2794 x tick handler = \meta{function} (initially \#1),%
2795 y tick handler = \meta{function} (initially \#1),%
2796 tick handler = \meta{function} (initially \#1)%
2797 }
2798 \declarecustomhandler{x tick handler}{\codehandler}
2799 \declarecustomhandler{y tick handler}{\codehandler}
2800 \declarecustomhandler{tick handler}{\codehandler}
2801 The value for |x tick handler| should be a function that takes in the current
2802 $\mathtt{x}$ value and outputs the appropriate tick. Correspondingly with%
2803 |y tick handler|. The |tick handler| key sets both.
2804 \begin{codeexample}[width = 7cm]
2805 \begin{sseqpage}[ x range = {0}{4}, yscale = 1.78,
2806 x tick handler = {
2807 \ifnum#1 = 0\relax
2808 0
2809 \else
2810 \ifnum#1 = 1\relax
2811 % \vphantom is fragile so we \protect it
2812 \protect\vphantom{2}n
2813 \else
2814 #1n
2815 \fi
2816 \fi
2817 }
2818 ]
2819 \class(0,0)
2820 \class(4,2)
2821 \end{sseqpage}
2822 \end{codeexample}
2823 \end{keylist}
2824
2825 \subsection{Layout}
2826 \begin{keylist}{%
2827 x axis type = \meta{type} (initially border),%
2828 y axis type = \meta{type} (initially border),%
2829 axes type = \meta{type} (initially border),%
2830 no x axis,%
2831 no y axis,%
2832 no axes%
2833 }%
2834 The \meta{type} is either |border|, |center|, |frame|, or |none|. |no axes| is a
2835 shorthand for |axes type=none|. The |border| type is the default and puts the
2836 axes on the bottom and left of the picture. The |center| type by default places
2837 the axes to pass through $(0,0)$; this can be modified using the |x axis origin|
2838 and |y axis origin| keys. See \example{KRAHSS} and \example{KUHFPSS} for
2839 examples where this is used. The |frame| type draws a frame around the entire
2840 chart:
2841
2842 \begin{codeexample}[width=6cm]
2843 \begin{sseqpage}[ axes type = frame ]
2844 \class(0,0)
2845 \class(3,2)
2846 \end{sseqpage}
2847 \end{codeexample}
2848 \end{keylist}
2849
2850 \parskip=0pt
2851 \begin{keylist}{%
2852 x axis origin = \meta{x value} (initially 0),%
2853 y axis origin = \meta{y value} (initially 0)%
2854 }%
2855 If you use |axes type = center|, these keys change the position of the axes.
2856 Otherwise, they are ignored.
2857 \end{keylist}
2858 %
2859 \begin{keylist}{%
2860 x axis gap = \meta{dimension} (initially 0.5cm),%
2861 y axis gap = \meta{dimension} (initially 0.5cm),%
2862 axes gap = \meta{dimension} (initially 0.5cm)%
2863 }%
2864 %
2865 \end{keylist}
2866 %
2867 \begin{keylist}{%
2868 x tick gap = \meta{dimension} (initially 0.5cm),%
2869 y tick gap = \meta{dimension} (initially 0.5cm)%
2870 }
2871 %
2872 \end{keylist}
2873 %
2874 \begin{keylist}{%
2875 x axis extend start = \meta{dimension} (initially 0.5cm),%
2876 y axis extend start = \meta{dimension} (initially 0.5cm),%
2877 x axis extend end = \meta{dimension} (initially 0.5cm),%
2878 y axis extend end = \meta{dimension} (initially 0.5cm),%
2879 x axis tail = \meta{dimension} (initially 0.9cm),%
2880 y axis tail = \meta{dimension} (initially 0.9cm)%
2881 }
2882 \end{keylist}
2883 %
2884 \begin{keylist}{%
2885 x axis clip padding = \meta{dimension} (initially 0.1cm),%
2886 y axis clip padding = \meta{dimension} (initially 0.1cm)%
2887 }
2888 \end{keylist}
2889 %
2890 \begin{keylist}{%
2891 right clip padding = \meta{dimension} (initially 0.1cm),%
2892 left clip padding = \meta{dimension} (initially 0.1cm),%
2893 top clip padding = \meta{dimension} (initially 0.1cm),%
2894 bottom clip padding = \meta{dimension} (initially 0.1cm)%
2895 }
2896 \end{keylist}
2897
2898 \afterpage{
2899 \begin{center}
2900 \input spectralsequencesmanual-layoutcharts
2901 \end{center}
2902 }
2903
2904
2905 \parskip=10pt
2906 \begin{key}{custom clip = \meta{clip path}}%
2907 Give a custom clipping. The clipping specified must be in the form of a valid
2908 \tikzpkg\ path, for instance |\clip (0,0) rectangle (10,10);|. This clipping is
2909 also applied to any grid and is used to draw ellipses on appropriate
2910 differentials or structure lines that go out of bounds and to determine whether
2911 a differential or structure line is an ``orphan''. It is not applied to any
2912 background elements, which is important because these are often used for axes
2913 labels and such that should lie outside of the clipping region. Weird things can
2914 happen with out of range edges if you provide an oddly shaped path.
2915 \end{key}
2916
2917 \begin{key}{clip = \meta{boolean} (default true)(initially true)}%
2918 If this is false the spectral sequence chart won't be clipped. I'm not really
2919 sure why you would want that, but there might be some use case. Setting this to
2920 be false is not fully supported, and it's possible that weird things will happen
2921 with some of the edges that go out of range.
2922 \end{key}
2923
2924
2925 \begin{key}{rotate labels = \meta{boolean} (default true)(initially false)}%
2926 If you use |rotate = 90| but also want the labels rotated (so that the whole
2927 chart is sideways) use this key.
2928 \end{key}
2929 \end{document}