From 6fde3f8617ebf837a452f38c9d715f70d93e71e2 Mon Sep 17 00:00:00 2001
From: Karl Berry <karl@freefriends.org>
Date: Mon, 11 Dec 2017 22:22:32 +0000
Subject: spectralsequences (11dec17)

git-svn-id: svn://tug.org/texlive/trunk@46038 c570f23f-e606-0410-a88d-b1316a301751
---
 .../manual/spectralsequencesmanual.tex             | 431 ++++++++++-----------
 1 file changed, 199 insertions(+), 232 deletions(-)

(limited to 'Master/texmf-dist/doc/latex/spectralsequences/manual/spectralsequencesmanual.tex')

diff --git a/Master/texmf-dist/doc/latex/spectralsequences/manual/spectralsequencesmanual.tex b/Master/texmf-dist/doc/latex/spectralsequences/manual/spectralsequencesmanual.tex
index 7d786975e8f..8ebebb4d312 100644
--- a/Master/texmf-dist/doc/latex/spectralsequences/manual/spectralsequencesmanual.tex
+++ b/Master/texmf-dist/doc/latex/spectralsequences/manual/spectralsequencesmanual.tex
@@ -1,8 +1,8 @@
 %%
-%% Package: spectralsequences v1.1.1 2017-09-16 2017-09-16
+%% Package: spectralsequences v1.2.0 2017-09-16 2017-09-16
 %% Author: Hood Chatham
 %% Email: hood@mit.edu
-%% Date: 2017-09-16
+%% Date: 2017-12-10
 %% License: Latex Project Public License
 %%
 %% File: spectralsequencesmanual.tex
@@ -12,14 +12,15 @@
 
 %
 % TODO:
-%  families
+%
+%  maybe move more examples into external files?
 %
 %  consistency issues?
 %  perhaps think about ordering, particularly of "Misc commands" section
 %  tutorial
 %  explain / cross reference examples folder?
 %
-
+\def\version{Version 1.2.0}
 
 
 \input spectralsequencesmanualpreamble
@@ -51,8 +52,8 @@ Many thanks to the authors of \tikzpkg\  for producing such a wonderful package
 The \sseqpages\  package consists of two main environments -- the \sseqdataenv\  environment, which specifies the data for a named spectral sequence, and the \sseqpageenv\  environment, which prints a single page of a spectral sequence. The |\printpage| command is also available as a synonym for a \sseqpageenv\  environment with an empty body.
 
 Here is a basic example:
-\begin{codeexample}[width = 9cm]
-\begin{sseqdata}[ name = ex1, scale = 0.6,
+\begin{codeexample}[width = 8.7cm]
+\begin{sseqdata}[ name = basic, xscale = 0.6,
                   cohomological Serre grading ]
 \class(0,0)
 \class(0,2)
@@ -60,10 +61,10 @@ Here is a basic example:
 \class(3,2)
 \d3(0,2)
 \end{sseqdata}
-\printpage[ name = ex1, page = 3 ]  \quad
-\printpage[ name = ex1, page = 4 ]
+\printpage[ name = basic, page = 3 ]  \quad
+\printpage[ name = basic, page = 4 ]
 \end{codeexample}
-|\begin{sseqdata}[|| name = ex1, cohomological Serre grading]| starts the declaration of the data of a spectral sequence named |ex1| whose page $\mathtt{r}$ differentials go $\mathtt{r}$ to the right and down $\mathtt{r-1}$ -- that is, it has cohomological Serre grading. Then we specify four classes and one page 3 differential, and we ask \sseqpages\  to print the third and fourth pages of the spectral sequence. Note that on the fourth page, the source and target of the differential have disappeared.
+\codeverb|\begin{sseqdata}[name = basic, cohomological Serre grading]| starts the declaration of the data of a spectral sequence named |basic| with cohomological Serre grading -- that is, the page $\mathtt{r}$ differentials go $\mathtt{r}$ to the right and down $\mathtt{r-1}$. Then we specify four classes and one page 3 differential, and we ask \sseqpages\  to print the third and fourth pages of the spectral sequence. Note that on the fourth page, the source and target of the differential have disappeared.
 
 \subsection{Installation}
 In both \miktex\ and \texlive\ installation should be automatic -- your \TeX\ distribution should automatically install the package the first time you include |\usepackage{spectralsequences}| in a document and compile it. However, in 2016, \texlive\ made an incompatible change to their database, so no new packages will run on versions of \texlive\ from before 2016. This includes \sseqpages. If you have an old version of \texlive, you can either perform a manual install,
@@ -77,7 +78,7 @@ The easiest solution is to run \LuaLaTeX. \LuaLaTeX\ dynamically allocates memor
 Another option is to increase the static memory caps for \pdfLaTeX. See \href{https://tex.stackexchange.com/a/26213}{this \TeX stack exchange post} for instructions on how to do this.
 
 \subsection{A warning about fragile macros}
-All the data in a \sseqpages\  environment is stored and used later. As a result, most of the \sseqpages\  commands currently cannot tolerate fragile macros. Unfortunately, it is impossible for \sseqpages\  to warn you about this situation -- if you use a fragile command in a place that it doesn't belong, the result will be an incomprehensible error message. If you are getting nonsense error messages, this is probably why. The solution is to convert fragile macros into robust ones. \href{http://www.tex.ac.uk/FAQ-protect.html}{See here for more information.}
+All the data in a \sseqpages\  environment is stored and used later. As a result, most of the \sseqpages\  commands currently cannot tolerate fragile macros. Unfortunately, it is impossible for \sseqpages\  to warn you about this situation -- if you use a fragile command in a place that it doesn't belong, the result will be an incomprehensible error message. If you are getting nonsense error messages, this might be why. The solution is to convert fragile macros into robust ones. \href{http://www.tex.ac.uk/FAQ-protect.html}{See here for more information.}
 
 
 \section{Package Options and Environments}
@@ -132,17 +133,17 @@ If a class is the source or the target of a differential on a certain page, then
 See the \pgfmanualpdfref{class options}{class options} section for a list of the sort of options available for classes.
 \end{command}
 
-\begin{commandlist}{{\replaceclass\ooptions\parargthreeopt{x}{y}{n}},\replaceclass\ooptions\pararg{classname}}
-After a class is the source or target of a differential, it disappears on the next page. However, some differentials are not injective or not surjective. Using the command |\replaceclass| causes a new symbol to appear on the page after a class supported or accepted a differential (or both). If there are multiple classes at the coordinate |(x,y)| you may specify which using an integer or a |tag| $n$. By default, this command will affect the first class placed in that position. You can also provide the |class:name| of a class.
+\begin{commandlist}{{\replaceclass\ooptions\parargthreeopt{x}{y}{n}},\replaceclass\ooptions\pararg{classname}, \replacesource\ooptions, \replacetarget\ooptions}
+After a class is the source or target of a differential, it disappears on the next page. However, some differentials are not injective or not surjective. Using the command |\replaceclass| causes a new symbol to appear on the page after a class supported or accepted a differential (or both). If there are multiple classes at the coordinate |(x,y)| you may specify which using an integer or a |tag| $n$. By default, this command will affect the first class placed in that position. You can also provide the |class:name| of a class. The variants |\replacesource| and |\replacetarget| replace the source and target respectively of the most recent differential.
 \begin{codeexample}[]
 \begin{sseqdata}[name = replace class example, Adams grading, classes = {draw = none } ]
 \class["\mathbb{Z}"](0,3)
 \class["\mathbb{Z}"](1,1)
 \class["\mathbb{Z}"](1,0)
 \d["\cdot 2"]2(1,1)
-\replaceclass["\mathbb{Z}/2"](0,3)
-\d[->>]3(1,0)
-\replaceclass["2\mathbb{Z}"](1,0)
+\replacetarget["\mathbb{Z}/2"] %\replaceclass["\mathbb{Z}/2"](0,3)
+\d[-> >]3(1,0)
+\replacesource["2\mathbb{Z}"]    % \replaceclass["2\mathbb{Z}"](1,0)
 \end{sseqdata}
 \printpage[ name = replace class example, page = 2 ] \qquad
 \printpage[ name = replace class example, page = 3 ] \qquad
@@ -265,7 +266,7 @@ This command creates a structure line from \sourcecoord\  to \targetcoord. The s
 If the source or target of a structure line is hit by a differential, then on subsequent pages, the structure line disappears.
 
 If the source or target has had multiple generations (i.e., they got hit and you used |\replaceclass|), then the |\structline| will only appear starting on the first page where the current generation of both the source and target are present. If this is undesirable, you can use the |structline:page| option to change it.
-\begin{codeexample}[width = 7cm]
+\begin{codeexample}[width = 7.5cm]
 \DeclareSseqGroup\tower {} {
     \class(0,0)
     \foreach \y in {1,...,5} {
@@ -279,7 +280,7 @@ If the source or target has had multiple generations (i.e., they got hit and you
 \begin{sseqdata}[ name = structline example,
                   classes = { circle, fill },
                   Adams grading, no axes,
-                  yscale = 1.39 ]
+                  yscale = 1.28 ]
 \class(1,1) \class(1,2)
 \class(2,3) \class(2,3) \class(2,5)
 \tower[classes = blue](0,0)
@@ -302,33 +303,7 @@ This command is a lot like |\structline| except that it puts a circle around the
 
 \begin{commandlist}{\draw,\path,\node,\clip}
 Any code that would work in a \tikzpictureenv\  environment will also work unchanged in a \sseqdataenv\  or \sseqpageenv\  environment, with a few minor differences. This is a very flexible way to add arbitrary background or foreground features to the spectral sequence:
-\begin{codeexample}[]
-\begin{sseqdata}[ name = tikz example, Adams grading, math nodes = false,
-                  tikz primitives = { blue, font = \tiny, <- }, circle classes = tikz primitive style,
-                  x range = {0}{2}, x axis extend end = 2em ]
-\class(0,0)
-\class(1,0)
-\class(0,2)
-\d2(1,0)
-\end{sseqdata}
-
-\begin{sseqpage}[ name = tikz example ]
-\circleclasses[ name path = myellipse, inner sep = 3pt, ellipse ratio = 1.6 ] (1,0) (0,2)
-\path[ name path = myline ] (1.3,1.25) -- (0.6,1);
-\draw[ name intersections = { of = myellipse and myline } ]
-      (intersection-1) to (1.3,1.25) node[ right, text width = 1.6cm ] {Consider this differential};
-\end{sseqpage} \qquad
-
-\begin{sseqpage}[ name = tikz example ]
-\draw[ xshift = 1 ] (0,0) to (0.6,0.2) node[ right, text width = 1.1cm ] {This is the source};
-\draw[ yshift = 2 ] (0,0) to (0.6,0.2) node[ right, text width = 1.1cm ] {This is the target};
-\end{sseqpage} \qquad
-
-\begin{sseqpage}[ page = 3, name = tikz example ]
-\circleclasses[ name path = myellipse, inner sep = 3pt, ellipse ratio = 1.6 ] (1,0)(0,2)
-\node[ right, font = \tiny ] at (1.2,1.2) {Now it's gone!};
-\end{sseqpage}
-\end{codeexample}
+\codeexample[from file=tikz]
 \end{commandlist}
 
 
@@ -518,19 +493,41 @@ These options control the size of a node. This is typically useful to make the s
 \end{keylist}
 
 \begin{key}{class:name = \meta{node name}}
-The |\class| command makes a \tikzpkg\ node on appropriate pages. You can refer to this node using \tikzpkg\ commands by using coordinates. Using the |class:name| option, you can give the node a second shorter name. One potential benefit to this is that it is immune to coordinate transformations. For example, in the following code, |xshift| does not apply to the nodes specified by |(id)| and |(eta)| but does apply to the coordinate specified by |(1,1)|:
+The |\class| command makes a \tikzpkg\ node on appropriate pages. You can refer to this node using \tikzpkg\ commands by using its coordinates. Using the |class:name| option, you can give the node a name, which you can use to refer to the class. Using names creates more readable code. The |show name| option can be used to display the names of classes. You can modify the names of classes systematically using the options |class name prefix|, |class name postfix|, and |class name handler|.
 
+Named classes are immune to coordinate transformations. For example, in the following code, |xshift| does not apply to the nodes specified by |(id)| and |(eta)| but does apply to the coordinate specified by |(1,1)|:
 \begin{codeexample}[width = 6cm]
-\begin{sseqpage}
-\class[class:name = id](0,0)
-\class[class:name = eta](1,1)
+\begin{sseqpage}[classes = { show name=above }]
+\class[class:name = 1](0,0)
+\class[class:name = \eta](1,1)
 \class(2,1)
-\draw[xshift = 1] (id) -- (eta);
-\draw[xshift = 1,blue] (id) -- (1,1);
+\structline[xshift = 1] (1) (\eta)
+\structline[xshift = 1,blue] (1) (1,1)
 \end{sseqpage}
 \end{codeexample}
 \end{key}
 
+\begin{key}{show name = \meta{label options}}
+This option is like saying |"class name"\marg{label options}| if the class has a name, and does nothing if the class has no name. If the class has multiple names, only the most recent is used. This is particularly useful with class styles, . For instance, by saying |this page classes = { show name = above }| you can display names of all of the sources and targets of differentials on each page.
+\begin{codeexample}[width=7cm]
+\begin{sseqdata}[
+    name = show name example,
+    this page classes = { show name = {above right, pin} }
+]
+\class[name=a](0,2)
+\class[name=b](0,3)
+\class[name=x](1,0)
+\d2(x)(a)
+\replacesource[name=2x]
+\d3(x)(b)
+\end{sseqdata}
+
+\printpage[name=show name example,page=2]
+
+\printpage[name=show name example,page=3]
+\end{codeexample}
+\end{key}
+
 \begin{key}{tag = \meta{tag}}
 This key adds a tag to the current class. Tags are used for identifying which of multiple classes in the same position you are referring to. They are useful when you have groups of related classes and want a family of differentials connecting them.  For instance:
 \begin{codeexample}[width = 8cm]
@@ -562,44 +559,8 @@ We want each differential to go from the |h21| vee to the |id| vee, independent
 \end{key}
 
 \begin{key}{insert = \meta{integer}}
-If there are multiple classes in the same position, this option allows you to insert classes later into earlier positions. This is intended to help you put logically related classes next to each other. If the integer is positive, it inserts the class in the specified position, and if the integer is negative, it counts backwards from the end. Providing |0| is the same as omitting the option entirely. Values larger in absolute value than the total number of classes are truncated.
- Consider:
-\begin{codeexample}[]
-\DeclareSseqGroup \tower {} {
-    \class(0,0)
-    \DoUntilOutOfBounds {
-        \class(\lastx,\lasty+1)
-        \structline
-    }
-}
-
-\begin{sseqdata}[name=test, y range={0}{4}, class pattern = linear]
-\tower(0,2)
-\tower(0,3)
-\tower(0,1)
-\end{sseqdata}
-\qquad
-\begin{sseqpage}[name=test]
-\tower[red,classes={insert=1}](0,0)
-\end{sseqpage}
-\qquad
-\begin{sseqpage}[name=test]
-\tower[red,classes={insert=2}](0,0)
-\end{sseqpage}
-\qquad
-\begin{sseqpage}[name=test]
-\tower[red,classes={insert=3}](0,0)
-\end{sseqpage}
-\qquad
-\begin{sseqpage}[name=test]
-\tower[red,classes={insert=-2}](0,0)
-\end{sseqpage}
-\qquad
-\begin{sseqpage}[name=test]
-\tower[red,classes={insert=-3}](0,0)
-\end{sseqpage}
-\end{codeexample}
-
+If there are multiple classes in the same position, this option allows you to insert classes later into earlier positions. This is intended to help you put logically related classes next to each other. If the integer is positive, it inserts the class in the specified position, and if the integer is negative, it counts backwards from the end. Providing |0| is the same as omitting the option entirely. Values larger in absolute value than the total number of classes are truncated. Consider:
+\codeexample[from file=insert]
 \end{key}
 
 \begin{key}{offset = \{\pars{\meta{x offset},\meta{y offset}}\}}
@@ -614,8 +575,8 @@ By default, a class uses the offset specified by |class pattern|. Occasionally t
 \draw(0,1)--(0,2);
 \class(1,0)
 \d2(1,0,,1)
+\replacetarget
 \d2(1,0,,2)
-\replaceclass(0,2)
 \end{sseqdata}
 \printpage[name = offset example, page=2]
 \printpage[name = offset example, page=3]
@@ -628,7 +589,7 @@ By default, a class uses the offset specified by |class pattern|. Occasionally t
 \begin{key}{tooltip = \meta{text}}
 This key generates a ``tooltip'' over the given class. That is, if you hover your mouse over it, a little window will popup with the tooltip text. This is particularly useful to give the coordinates or names of classes in large charts where it may be hard to tell from looking at the picture what position the class is in, or there may not be room to supply names to classes.
 
-The tooltip is made using the |\pdftooltip| command from the |pdfcomment| package. This cannot handle math, but it will print math expressions into \TeX input form. Not all pdf viewers will display the tooltip correctly. If this concerns you, the command |\sseqtooltip| is used to produce the tooltip, and you can redefine it as any other command that takes |\sseqtooltip|\marg{text}\marg{tooltip text} and produces a tooltip. For instance, on \href{https://tex.stackexchange.com/a/164186/23866}{this stack exchange post}, there is code that supposedly produces tooltips that work with Evince. I have not tested whether it works by itself or whether it works with my package, but you could. You could potentially figure out how to get math to work in tooltips too -- if you find a satisfactory method, please let me know.
+The tooltip is made using the |\pdftooltip| command from the |pdfcomment| package. The |pdfcomment| package generates two extra auxiliary files, so it is not included by default. In order to use the |tooltip| option, you have to use the |tooltips| package option (e.g., load \sseqpages\ with |\usepackage[tooltips]{spectralsequences}|). This cannot handle math, but it will print math expressions into \TeX\ input form. Not all pdf viewers will display the tooltip correctly. If this concerns you, the command |\sseqtooltip| is used to produce the tooltip, and you can redefine it as any other command that takes |\sseqtooltip|\marg{text}\marg{tooltip text} and produces a tooltip. For instance, on \href{https://tex.stackexchange.com/a/164186/23866}{this stack exchange post}, there is code that supposedly produces tooltips that work with Evince. I have not tested whether it works by itself or whether it works with my package, but you could. You could potentially figure out how to get math to work in tooltips too -- if you find a satisfactory method, please let me know.
 
 Anyways, here's an example:
 \begin{codeexample}[]
@@ -658,53 +619,8 @@ These options only work in |\classoptions|. The |page| option gives a range of p
 \end{codeexample}
 A ``generation'' of a class is the interval from one call of |\class| or |\replaceclass| to the page on which it next supports or is hit by a differential.
 By default the |\classoptions| command adds options only to the most recent generation of the class in a \sseqdataenv\  environment, or on the generation appropriate to the current page in a \sseqpageenv\  environment. Using the |generation| option allows you to provide a single generation or range of generations of the class that the options should apply to. The first generation is generation 0, and the most recent generation is generation -1. Larger negative values count backwards.
-\begin{codeexample}[]
-\begin{sseqdata}[ name = page_example2, Adams grading, xscale = 0.6, yscale = 0.5 ]
-\class(0,2)\class(1,0)
-\d2(1,0)
-\replaceclass(1,0)
-\class(0,3)
-\d3(1,0)
-\replaceclass(1,0)
-\classoptions[fill,red](1,0) % (a) applies to most recent (last) generation.
-\end{sseqdata}
-
-\printpage[ name = page_example2, page = 1 ] % generation 0 of (1,0), not styled
-\quad
-\begin{sseqpage}[ name = page_example2, page = 1, keep changes ]
-\classoptions[fill,blue](1,0) % (b) applies to the generation present on page 1, that is, generation 0.
-\end{sseqpage} \quad
-
-% generation 0 of (1,0), so class is blue from (b)
-\printpage[ name = page_example2, page = 2 ] \quad
-
-% generation 1 of (1,0), class is not styled
-\printpage[ name = page_example2, page = 3 ] \quad
-
-% generation 2 of (1,0), class is red from (a)
-\printpage[ name = page_example2, page = 4 ]
-\end{codeexample}
-
-\begin{codeexample}[]
-\begin{sseqdata}[ name = page_example2, Adams grading,update existing ]
-% (c) applies to all generations, overwrites (b) and (a):
-\classoptions[fill, red, generation = 0 ---- -1](1,0)
-\end{sseqdata}
-
-\printpage[ name = page_example2, page = 1 ]% generation 0 of (1,0), so class is red
-\quad
-\begin{sseqpage}[ name = page_example2, page = 1, keep changes ]
-\classoptions[fill,blue](1,0) % (d) applies to the generation present on page 1, that is, generation 0.
-\end{sseqpage} \quad
-
-% generation 0 of (1,0), class is blue from (d)
-\printpage[ name = page_example2,page = 2 ] \quad
-
-% generation 1 of (1,0), class is red from (c)
-\printpage[ name = page_example2, page = 3 ]
-\quad
-\printpage[ name = page_example2, page = 4 ] % generation 2 of (1,0), class is red from (c)
-\end{codeexample}
+\codeexample[from file=class-page2a]
+\codeexample[from file=class-page2b]
 \end{keylist}
 
 \begin{commandlist}{\xcoord,\ycoord}
@@ -775,10 +691,8 @@ This key is only for |\structline| and |\structlineoptions|. By default, the |\s
 \class(0,4)
 \class(1,0)
 \class(1,1)
-\d2(1,0)(0,2)
-\d3(1,1)(0,4)
-\replaceclass(1,0)
-\replaceclass(1,1)
+\d2(1,0)(0,2) \replacesource
+\d3(1,1)(0,4) \replacesource
 \structline(1,0)(1,1)
 \end{sseqdata}
 \printpage[name = structpage example,page = 3]
@@ -794,10 +708,8 @@ By specifying a page number, you can adjust which page the |\structline| starts
 \class(0,4)
 \class(1,0)
 \class(1,1)
-\d2(1,0)(0,2)
-\d3(1,1)(0,4)
-\replaceclass(1,0)
-\replaceclass(1,1)
+\d2(1,0)(0,2) \replacesource
+\d3(1,1)(0,4) \replacesource
 \structline[structline:page = 2](1,0)(1,1)
 \end{sseqdata}
 \printpage[name = structpage example2,page = 1]
@@ -919,18 +831,19 @@ One useful tip is that you can ensure consistent bounding boxes between differen
 \end{key}
 
 \begin{keylist}{page constraint = \meta{predicate}, page constraint or = \meta{predicate}}
+\declarecustomhandler{page constraint}{\codehandler}
 This places a constraint on the pages in which the \tikzpkg\  primitive is printed. This predicate should look something like
-\texttt{(\string\page< = 4)} |&&| \texttt{(\string\page> = 3)}. The predicate is anded together with any previous predicates, so that you can use this as an option for a \scopeenv\  and again for the individual \tikzpkg\ primitive.
+\texttt{(\string\page\ <= 4)} |&&| \texttt{(\string\page\ >= 3)}. The predicate is anded together with any previous predicates, so that you can use this as an option for a \scopeenv\  and again for the individual \tikzpkg\ primitive.
 
 \begin{commandlist}{\isalive\pararg{coordinate},\isalive\{\pararg{coordinate 1}$\cdots$\pararg{coordinate n}\}}
 This command can only be used with |page constraint|. Saying
-$$|page constraint = ||{|\pars{\meta{x},\meta{y}\opt{,\meta{index}}}|}}|$$
+\[|page constraint = {\pars{\meta{x},\meta{y}\opt{,}\oarg{index}}}}}|\]
 will print the \tikzpkg\  primitive only on pages where the specified class is alive. Saying
-$$|page constraint = ||{\isalive|\pars{\meta{coordinate 1}}\,\cdots\,\pars{\meta{coordinate n}}|}|$$
+\[|page constraint = {\isalive(\meta{coordinate 1})|\,\cdots\,|(\meta{coordinate n})}|\]
 is equivalent to
-$$|page constraint = ||{\isalive|\pararg{coordinate 1}| &&|\,\cdots\,|&& \isalive|\pararg{coordinate n}|}|$$
+\[|page constraint = {\isalive\pararg{coordinate 1} &&|\,\cdots\,|&& \isalive\pararg{coordinate n}}|\]
 Writing
-$$|\draw[||page constraint = ||{\isalive(1,0)(2,2)}](1,0)|\texttt{-{}-}|(2,2);|$$
+\[\codeverb|\draw[page constraint = {\isalive(1,0)(2,2)}](1,0)|\texttt{-{}-}|(2,2);|\]
 is the same as |\structline(1,0)(2,2)|, except that you can't later use |\structlineoptions| on it (and it won't have the |struct lines| style applied).
 \end{commandlist}
 \end{keylist}
@@ -986,10 +899,16 @@ These handlers create reusable styles to be used in spectral sequences. If this
 \end{keylist}
 \end{command}
 
-\begin{command}{\sseqerrortowarning\meta{error-name}}
+\begin{command}{\SseqErrorToWarning\meta{error-name}}
 Turns the error with the given name into a warning. An error message will start by saying \let\eatclnifpresent\empty|spectralsequences error: "error-name"|. This is the name you need to put into this command.
 \end{command}
 
+\begin{environment}{{quiet}}
+This environment quiets error messages that occur inside of it. \sseqpages\ is pretty good at error recovery, and so most of commands will fail gracefully and do nothing if their preconditions aren't met. If there are any parsing errors in the body of the |{quiet}| environment, prepare to see low level internal error messages. You might also run into bugs in \sseqpages\ -- the error recovery code hasn't been that carefully tested. If you do get low level error messages, remember to comment out the |{quiet}| environment before trying to debug.
+
+This is particularly useful for code reuse commands. Sometimes there is a source of long differentials that only applies to classes that haven't already supported shorter differentials. Sometimes there should be a structure line if a certain class exists, but it might not exist. In these cases, the |{quiet}| environment will help you out. See also |\DrawIfValidDifferential|, which is a variant of |\d| that behaves as if it were inside a |{quiet}| environment.
+\end{environment}
+
 \subsection{Code reuse commands}
 \begin{command}{\foreach }
 This command is from \tikzpkg\  and works in pretty much the same way in \sseqpages, though with slightly better variants. The |\foreach| command is very flexible and has a lot of variants. The basic usage is |\foreach \x in {\meta{xmin},...,\meta{xmax}} \marg{loop body}| which will execute |\meta{loop body}| with |\x| set to each value between \meta{xmin} and \meta{xmax} inclusive. If you want a step greater than 1, try |\foreach \x in {\meta{xmin},\meta{xmin}+\meta{xstep},...,\meta{xmax}} \marg{loop body}|.
@@ -1073,6 +992,7 @@ If you need to know how many iterations one of these three commands has gone thr
 \end{commandlist}
 \begin{commandlist}{\NewSseqCommand    \cmdarg{command}\marg{argspec}\marg{body},
                     \DeclareSseqCommand\cmdarg{command}\marg{argspec}\marg{body}}
+% TODO: Explain the difference between NewSseqCommand and DeclareSseqCommand!
 The \xparsepkg\ package provides these very powerful commands for defining macros. They are used internally to the \sseqpages\  package to define |\class|, |\d|, etc. To help you create variants of these commands, I will record here the argument specifications for each of them. See the \href{\xparseurl}{\xparsepkg\ manual} for a better explanation and more information.
 
 To make a command like |\class|, you can use the argument specification |O{}r()|. The argument type \texttt{O\marg{default}} stands for a bracket delimited optional argument with default value \meta{default}. In this case, we've specified the default to be empty. |r()| stands for a ``required'' argument delimited by |(| and |)|. In the command definition, access the optional argument with |#1| and the coordinate with |#2|.
@@ -1178,56 +1098,47 @@ For instance:
 Here we define a command which takes an options list, a coordinate, and a single mandatory argument. The options are applied to all the classes and structlines, the coordinate shifts the origin, and the mandatory argument is the length of the tower.
 \end{commandlist}
 
-\subsection{Families}
-\spectralsequences\ has a concept of ``class families'' that can be drawn or suppressed as a group, and that can have styling options applied to them as a group. 
-\begin{command}{\sseqnewfamily\marg{family name}}
-This makes a new family with name \meta{family name}. The effect of this is to define global options |\meta{family name} style| which apply options to all classes in the family, |draw \meta{family name}| which causes the family to be drawn, and |no \meta{family name}| which suppresses the family (drawing is the default behavior of course). It also defines an option |\meta{family name}| which puts a feature into the family -- so it can be used as an option to any of the normal commands like |\class|, |\d|, |\structline|, etc and to a scope. 
-
-\begin{codeexample}[vbox]
-\sseqnewfamily{imJ}
-\begin{sseqdata}[
-    name=ANSS-S_2, Adams grading,
-    class labels={below}, label distance=-1pt,
-    class placement transform={rotate=90,scale=2},
-    differentials=blue,
-    x range={0}{9}, y range={0}{4},
-    xscale=0.7, grid=go
-]
-% Image of J classes
-\begin{scope}[imJ]
-\class[rectangle,fill,inner sep=3pt](0,0)
-\DoUntilOutOfBoundsThenNMore{3}{\etaclass}
-\classoptions["\alpha_1" above left](1,1)
-\class["\alpha_{2/2}",circlen=2](3,1)
-\structline(0,0) \structline[dashed](3,3)
-\class["\alpha_3"](5,1) \d3\relax
-\DoUntilOutOfBounds{ \etaclass \d3 }
-\class["\alpha_{4/4}", rectangle, "16" {font=\tiny,inside}, inner sep=1pt](7,1)
-\DoUntilOutOfBoundsThenNMore{3}{\etaclass}
-\end{scope}
-
-% Other classes
-\class["\beta_{2/2}" {below right=-4pt}, insert = 1](6,2)
-\structline(3,1)
-\class["\beta_{2}" left](8,2)
-\etaclass\structline(6,2,2) % This is a *nu
-\end{sseqdata}
+\begin{command}{\SseqCopyPage\cmdarg{command}\marg{spectral sequence name}\marg{page}}
+This copies all of the classes and structlines on page |\meta{page}| of the spectral sequence named |\meta{spectral sequence name}|, throwing out differentials and tikz primitives. The resulting |\cmdarg{command}| has syntax as if you had used |\DeclareSseqGroup| with no extra arguments -- that is, it takes an optional options list, which are passed to a scope, and an optional coordinate pair.
+\end{command}
 
-\printpage[name=ANSS-S_2, title = with image of J, imJ style=purple]
+\subsection{Families}
+\spectralsequences\ has a concept of ``class families'' that can be drawn or suppressed as a group, and that can have styling options applied to them as a group.
+\begin{command}{\SseqNewFamily\marg{family name}}
+This makes a new family with name \meta{family name}. The effect of this is to define global options |\meta{family name} style| which apply options to all classes in the family, |draw \meta{family name}| which causes the family to be drawn, and |no \meta{family name}| which suppresses the family (drawing is the default behavior of course). It also defines an option |\meta{family name}| which puts a feature into the family -- so it can be used as an option to any of the normal commands like |\class|, |\d|, |\structline|, etc and to a scope.
 
-\printpage[name=ANSS-S_2, no imJ, x range={2}{9}, title = without image of J]
-\end{codeexample}
+\codeexample[vbox, from file=imJ]
 \end{command}
 
 
 \subsection{Utilities}
-\begin{command}{\sseqparseint\cmdarg{macro}\marg{integer expression}}
+\begin{command}{\SseqParseInt\cmdarg{macro}\marg{integer expression}}
 Stores the result of evaluating an integer expression into \cmdarg{macro}. An integer expression consists of |+|, |-|, |*|, |/|, parentheses, and macros that expand to more of the same. The exact rules regarding what is a valid expression are pretty much what you would expect. Note that juxtaposition is a syntax error, not multiplication, so |2(1+1)| is invalid, you must say |2*(1+1)|.
 \end{command}
 
-\begin{command}{\sseqifempty\marg{expression}\marg{true code}\marg{false code}}
-This tests if an expression is the empty expression. This is mainly useful for giving systematic labels to things. Probably it won't ever matter to you.
-\end{command}
+\begin{commandlist}{
+    \SseqIfEmptyTF\marg{expression}\marg{true code}\marg{false code},
+    \SseqIfEmptyT\marg{expression}\marg{true code},
+    \SseqIfEmptyF\marg{expression}\marg{false code}
+}
+This tests if an expression is the empty expression. This is mainly useful for giving systematic labels to things.
+\end{commandlist}
+
+\begin{commandlist}{
+    \IfExistsTF\marg{page}\pararg{coordinate}\marg{true code}\marg{false code},
+    \IfExistsT\marg{page}\pararg{coordinate}\marg{true code},
+    \IfExistsF\marg{page}\pararg{coordinate}\marg{false code}
+}
+Test whether a class of the given description exists. The description can be any valid coordinate, including a named coordinate. If the coordinate is not valid, this will return false.
+\end{commandlist}
+
+\begin{commandlist}{
+    \IfAliveTF\marg{page}\pararg{coordinate}\marg{true code}\marg{false code},
+    \IfAliveT\marg{page}\pararg{coordinate}\marg{true code},
+    \IfAliveF\marg{page}\pararg{coordinate}\marg{false code}
+}
+Test whether a class is alive on the given page. If the class doesn't exist, this will return false.
+\end{commandlist}
 
 \begin{commandlist}{
     \IfOutOfBoundsTF\pararg{coordinate}\marg{true code}\marg{false code},
@@ -1237,19 +1148,49 @@ This tests if an expression is the empty expression. This is mainly useful for g
     \IfInBoundsT\pararg{coordinate}\marg{true code},
     \IfInBoundsF\pararg{coordinate}\marg{false code}
 }
-Test whether an existing class is in bounds or out of bounds. I don't have an obvious use for these. I had to make commands to do this as part of the drawing code and in order to make |\DoUntilOutOfBounds| and it was no extra effort to expose them. Maybe they will be helpful at some point.
+Test whether a class is in bounds or out of bounds. If no such class exists, returns false.
+\end{commandlist}
+
+\begin{commandlist}{
+    \IfValidDifferentialTF\meta{page}\pararg{coordinate}\opt{\pararg{target coordinate}}\marg{true code}\marg{false code},
+    \IfValidDifferentialT\meta{page}\pararg{coordinate}\opt{\pararg{target coordinate}}\marg{true code},
+    \IfValidDifferentialF\meta{page}\pararg{coordinate}\opt{\pararg{target coordinate}}\marg{false code},
+    \DrawIfValidDifferentialTF\ooptions\meta{page}\pararg{coordinate}\opt{\pararg{target coordinate}}\marg{true code}\marg{false code},
+    \DrawIfValidDifferentialT\ooptions\meta{page}\pararg{coordinate}\opt{\pararg{target coordinate}}\marg{true code},
+    \DrawIfValidDifferentialF\ooptions\meta{page}\pararg{coordinate}\opt{\pararg{target coordinate}}\marg{false code},
+    \DrawIfValidDifferential\ooptions\meta{page}\pararg{coordinate}\opt{\pararg{target coordinate}}\marg{false code}
+}
+Test whether a differential is valid. There are many possible reasons for a differential to not be valid -- the source or target class could not exist, the target could not be in the correct grading, etc. If any error would be generated if you supplied the same arguments to |\d|, this tests false. Otherwise, this tests true. The command |\DrawIfValidDifferental| draws the differential if it is valid, whereas |\DrawIfValidDifferentalT| draws the differential and executes the true code if it is valid,
+|\DrawIfValidDifferentalF| draws the differential or executes false code if it isn't valid, etc.
 \end{commandlist}
 
 
-\begin{command}{\sseqnormalizemonomial}
-This command simplifies a monomial by combining like variables and removing bases that are raised to the 0th power, removing exponents of 1, removing 1's, and replacing the empty monomial with 1. It outputs its result into |\processedlabel|. This command is specifically meant to be used as a value for |class label handler|, so see the example there for the actual purpose. The exponents must be integers or else it will misbehave.
+
+\begin{command}{\SseqNormalizeMonomial}
+This command simplifies a monomial by combining like variables and removing bases that are raised to the 0th power, removing exponents of 1, removing 1's, and replacing the empty monomial with 1. The variables are sorted by first occurrence, use |\SseqNormalizeMonomialSetVariables| to set a different sort order. It outputs its result into |\result|. This command is specifically meant to be used as a value for |class label handler| or |class name handler|. See the example in the documentation for |class label handler| for a realistic example. The exponents must be integers or else it will misbehave.
 \begin{codeexample}[]
-\sseqnormalizemonomial{x^0y^0} $\processedlabel$, \quad
-\sseqnormalizemonomial{x^3yx^{-1}z^0} $\processedlabel$, \quad
-\sseqnormalizemonomial{1x_2^2x^2_2} $\processedlabel$
+\SseqNormalizeMonomial{x^0y^0} $\result$, \quad
+\SseqNormalizeMonomial{x^3yx^{-1}z^0} $\result$, \quad
+\SseqNormalizeMonomial{1x_2^2x^2_2} $\result$
 \end{codeexample}
 \end{command}
 
+\begin{command}{\SseqNormalizeMonomialSetVariables}
+This command takes an undelimited list sets up |\SseqNormalizeMonomial| to sort the variables in the input in the specified order. This is useful for consistency, and particularly important for when you use it to name classes.  For example:
+\begin{codeexample}[]
+% We always want a first, then b, then x_1, then x_2, then x_3
+\SseqNormalizeMonomialSetVariables{abx_1x_2x_3}
+\SseqNormalizeMonomial{ba} $\result$, \quad
+\SseqNormalizeMonomial{bx_1} $\result$, \quad
+\SseqNormalizeMonomial{abx_2x_3x_1} $\result$
+\end{codeexample}
+\SseqNormalizeMonomialSetVariables{}
+\end{command}
+
+
+\begin{command}{\SseqAHSSNameHandler}
+This command expects an argument of the form |\meta{monomial}[\meta{integer expression}]| and defines |\result| to be |m[n]| where |m| is the result of applying |\SseqNormalizeMonomial| to the monomial, and |n| is the result of evaluation the integer expression plus any |yshift| that is present. This is intended for use with in drawing Atiyah Hirzebruch spectral sequences. See |class name handler| for an example of the calculation of $KO^*\mathbb{R}P^8$.
+\end{command}
 
 \subsection{Coordinate parsers and related}
 %    \parsecoordinate and \parsedifferential
@@ -1291,10 +1232,8 @@ For instance, consider the following example, suggested by Catherine Ray:
                 (source) -- (intersection-1);
 }
 \begin{sseqdata}[ name = cathex, Adams grading, differentials = { blue } ]
-\class(0,2)
-\class(0,2)
+\class(0,2)\class(0,2)
 \class(1,0)\class(1,0)
-
 \twods2(1,0,-1,1){2}
 \end{sseqdata}
 \printpage[ name = cathex, page = 1 ]
@@ -1313,8 +1252,8 @@ The |\nameclass| command gives a name to a class. It's similar to saying |\dopti
 The |\tagclass| command gives a tag to a class. It's similar to saying |\doptions[tag = |\meta{name}|]|, but faster. See \example{tmfmayss} for a use case for this.
 \end{command}
 
-\begin{command}{\gettag\cmdarg{somecontrolsequence}\pararg{coordinate}}
-The |\gettag| command finds the most recent tag applied to the coordinate and stores it into the command. This is useful for connecting groups of nodes. For example, consider the following code, inspired by \example{tmfmayss}.
+\begin{command}{\gettag\cmdarg{macro}\pararg{coordinate}}
+The |\gettag| command finds the most recent tag applied to the coordinate and stores it into |\cmdarg{macro}|. This is useful for connecting groups of nodes. For example, consider the following code, inspired by \example{tmfmayss}.
 \begin{codeexample}[width=6cm]
 \DeclareSseqCommand \tower { O{} } {
     \begin{scope}[#1]
@@ -1388,11 +1327,11 @@ The command |\lastclass| evaluates to the coordinate of the most recent class on
 \end{sseqpage}
 \end{codeexample}
 
-You can use |\lastx| and |\lasty| in other contexts than in the body of a \sseqpages\ command, most notably inside |\sseqparseint| (they also go fine inside |\pgfmathparse| if you need it or one of its siblings). For instance, consider the following tower command:
+You can use |\lastx| and |\lasty| in other contexts than in the body of a \sseqpages\ command, most notably inside |\SseqParseInt| (they also go fine inside |\pgfmathparse| if you need it or one of its siblings). For instance, consider the following tower command:
 \begin{codeexample}[width=6cm]
 \DeclareSseqCommand \tower { } {
     \savestack
-    \sseqparseint\numclasses{\ymax-\lasty0}
+    \SseqParseInt\numclasses{\ymax-\lasty0}
     \foreach \n in {1,...,\numclasses}{
         \class(\lastx,\lasty+1)
         \structline
@@ -1420,16 +1359,16 @@ This saves and reverts the stack. Saves nest. Most frequently, you will want to
 \section{Styles}
 The \sseqpages\  package has a large number of styles which control the appearance of specific components (e.g., classes, differentials, or structure lines) of a spectral sequence. Each style has two corresponding keys: |classes| and |change classes|.  Saying |classes = |\marg{keys} adds the keys to the list of options used to style every future class, whereas |change classes = |\marg{keys} only makes sense in a \sseqpageenv\  environment, and temporarily overwrites the list of options. Note that |change classes| only applies to classes that existed before the current page, and that even with the |keep changes| option, the |change classes| options are local to the current page. Compare:
 \begin{codeexample}[width = 8cm]
-\begin{sseqdata}[ name = stylesex ]
+\begin{sseqdata}[ name = style example ]
 \class(0,0)\class(1,1)
 \end{sseqdata}
-\begin{sseqpage}[ name = stylesex,
+\begin{sseqpage}[ name = style example,
                   classes = { fill, blue },
                   title = change new classes ]
 \class(0,1)\class(1,0)
 \end{sseqpage}
 \quad
-\begin{sseqpage}[ name = stylesex,
+\begin{sseqpage}[ name = style example,
                   change classes = { fill, blue },
                   title = change old classes ]
 \class(0,1)\class(1,0)
@@ -1524,7 +1463,7 @@ These options change the appearance of all transient cycles (e.g., those classes
 \end{stylekeylist}
 
 \begin{stylekeylist}{this page classes, this page cycles, change this page classes,change this page cycles}
-These options change the appearance of all cycles which support or are hit by a differential on this page. Any class that is hit on the current page is also a transient cycle, and so |this page classes| takes precedence over |transient cycles|
+These options change the appearance of all cycles which support or are hit by a differential on this page. Any class that is hit on the current page is also a transient cycle, and so |this page classes| takes precedence over |transient cycles|.
 \begin{codeexample}[width = 6cm]
 \begin{sseqdata}[ name = this page cycles example, Adams grading,
                   transient cycles = { red, fill }, this page cycles = { blue } ]
@@ -1612,20 +1551,20 @@ If an edge runs off the edge of the clipping, \sseqpages\ automatically add an a
 
 \begin{key}{class label handler = \meta{function}}
 \declarecustomhandler{class label handler}{\codehandler}
-The value of |class label handler| is a function that is applied to all labels before displaying them. It should put its output into |\processedlabel|.
+The value of |class label handler| is a function that is applied to all labels before displaying them. It should put its output into |\result|.
 This is intended to help with code reusability. Because these handlers may crash or have annoying side-effects on some input, you may want to toggle the value of this command on and off. To turn this off for the rest of the current spectral sequence you can say |\sseqset{class label handler = {}}|. You can also use the |class label handler| key in a \scopeenv.
 
-The main function \sseqpages\ provides for use here is |\sseqnormalizemonomial{#1}|. This makes it convenient to translate expressions with polynomial labels. You can write your own handlers if your \TeX\ programming skills are sufficient. Let me know if there are any other functions that you want here, and if you implement them yourself, please send me your implementation.
+The main function \sseqpages\ provides for use here is |\SseqNormalizeMonomial{#1}|. This makes it convenient to translate expressions with polynomial labels. You can write your own handlers if your \TeX\ programming skills are sufficient. Let me know if there are any other functions that you want here, and if you implement them yourself, please send me your implementation.
 Here is an example of a function that evaluates an arithmetic expression:
 \begin{codeexample}[width=6cm]
 \begin{sseqpage}[
-    class label handler = { \sseqparseint\processedlabel{#1} }
+    class label handler = { \SseqParseInt\result{#1} }
 ]
 \class["1+1"](0,0)
 \class["1+2*(1+3*(4-1))"](1,1)
 \end{sseqpage}
 \end{codeexample}
-Here's an example using |\sseqnormalizemonomial|:
+Here's an example using |\SseqNormalizeMonomial|:
 \begin{codeexample}[width = 6cm]
 \NewSseqGroup \test {m} {
     \class["1#1"](0,0)
@@ -1634,7 +1573,7 @@ Here's an example using |\sseqnormalizemonomial|:
     \class["\alpha y#1"](1,1)
 }
 \begin{sseqpage}[
-    class label handler = { \sseqnormalizemonomial{#1} },
+    class label handler = { \SseqNormalizeMonomial{#1} },
     classes = { draw = none }, class labels = { font = \small } ]
 \test{}
 \test[red](2,0){y^2}
@@ -1643,13 +1582,13 @@ Here's an example using |\sseqnormalizemonomial|:
 \end{sseqpage}
 \end{codeexample}
 
-Here is another example which demonstrates a useful idiom for drawing Serre spectral sequences. For a more complete example, see \example{KF3n}. Note the use of braces in |{Sq^1\iota_2}|. Without braces, |\sseqnormalizemonomial| will simplify |Sq^1xSq^2x| into $S^2q^3x^2$, which is obviously undesirable, so the correct way to input this is |{Sq^1x}{Sq^2x}|. Unfortunately, |\foreach| strips a pair of braces from its arguments, so you need to put two pairs of braces.
+Here is another example which demonstrates a useful idiom for drawing Serre spectral sequences. For a more complete example, see \example{KF3n}. Note the use of braces in |{Sq^1\iota_2}|. Without braces, |\SseqNormalizeMonomial| will simplify |Sq^1xSq^2x| into $S^2q^3x^2$, which is obviously undesirable, so the correct way to input this is |{Sq^1x}{Sq^2x}|. Unfortunately, |\foreach| strips a pair of braces from its arguments, so you need to put two pairs of braces.
 %\pgfmanualpdflabel{normalizemonomialex-labels}
 \begin{codeexample}[width=8cm]
 \begin{sseqpage}[
   xscale = 1.4,
   classes = { draw = none },
-  class label handler = {\sseqnormalizemonomial{#1}} ]
+  class label handler = {\SseqNormalizeMonomial{#1}} ]
 
 \foreach \x/\xlabel in
   { 0/1, 2/\iota_2, 3/{{Sq^1\iota_2}}, 4/\iota_2^2 }
@@ -1663,6 +1602,35 @@ Here is another example which demonstrates a useful idiom for drawing Serre spec
 \end{key}
 
 
+\begin{key}{class name handler = \meta{function}}
+\declarecustomhandler{class name handler}{\codehandler}
+The value of |class name handler| is a function that is applied to all names before using them. It should put its output into |\result|.
+The main functions intended for use here are |\SseqAHSSNameHandler| and |\SseqNormalizeMonomial|, though you can make your own. This is applied both when you name the class, as in \codeverb|\class[name=a](\meta{coordinate})| and when you refer to a class by name, as in |\structline(a)(b)|. One advantage if you are using |\SseqNormalizeMonomial| is that you can ensure that |xy| and |yx| refer to the same class:
+\begin{codeexample}[]
+\SseqNormalizeMonomialSetVariables{xy}
+\begin{sseqpage}[ class name handler = \SseqNormalizeMonomial,
+                  classes = {show name = {right,pin}} ]
+\class[name=xy](0,0)
+\class[name=yxy](0,1)
+\class(1,0)
+\structline(yx)(yyx)
+\end{sseqpage}
+\end{codeexample}
+The next page is an example drawing the Atiyah Hirzebruch spectral sequence computing $KO^*\mathbb{R}P^{8}$.
+% Have to load from file so that \afterpage doesn't cause trouble with verbatim reading.
+\afterpage{%
+    An AHSS using \scantokens{|class name handler = \SseqAHSSNameHandler|:}
+    \par
+    \codeexample[from file=KORP8,vbox]
+    \newpage
+}
+\end{key}
+
+\begin{keylist}{class name prefix = \meta{prefix}, class name postfix = \meta{postfix}}
+These keys add respectively a prefix or a postfix to all names of all classes in the scope. This is applied both when you name the class, as in \codeverb|\class[name=a](\meta{coordinate})| and when you refer to a class by name, as in |\structline(a)(b)|.
+The prefix and postfix are added to the command before the |class name handler| is applied, so if you say |name=\meta{the name}| then the name actually given to the class is the value of |\result| after saying |\classnamehander{\meta{name prefix}\meta{the name}\meta{name postfix}}|
+\end{keylist}
+
 \section{Global Options}
 These options can only be set at the beginning of a \sseqdataenv\  or \sseqpageenv\  environment. When it makes sense, you can also set a default value using |\sseqset|. Generally, these options either modify the plot style or the logic for the spectral sequence.
 \begin{key}{name = \meta{sseq name}}
@@ -1698,7 +1666,7 @@ You can make a named grading convention by saying \codeverb|\sseqset{my grading/
 \end{sseqpage}
 \end{codeexample}
 \begin{codeexample}[width = 6cm]
-% equivalent to degree = {-1}{#1-1}:
+% equivalent to degree = {-1}{#1}:
 \begin{sseqpage}[ Adams grading ]
 \class(0,2)
 \class(1,0)
@@ -1827,7 +1795,7 @@ For instance the third row indicates that if there are three classes at the posi
 \end{key}
 
 
-\begin{key}{class placement transform = \marg{transform keys}, add class placement transform = \marg{transform keys} }
+\begin{keylist}{class placement transform = \marg{transform keys}, add class placement transform = \marg{transform keys} }
 \declareasstyle{class placement transform}\declareasstyle{add class placement transform}
 The option |class placement transform| allows the user to specify a \tikzpkg\  coordinate transform to adjust the relative position of multiple nodes in the same $\mathtt{(x,y)}$ position. The |class placement transform| key overrides the previous value of transformations, the |add class placement transform| just adds the new transformation to the end of the list. This coordinate transform can only involve rotation and scaling, no translation. Specifying a scaling factor helps if the nodes are too large and overlap. In some cases a rotation makes it easier to see which class is the target of a differential.
 \begin{codeexample}[width = 5cm]
@@ -1853,7 +1821,7 @@ The option |class placement transform| allows the user to specify a \tikzpkg\  c
 \draw[->,red](3,0,1)--(0,0);
 \end{sseqpage}
 \end{codeexample}
-With multiple large class names, the best option is to arrange the classes vertically:
+With multiple large class labels, the best option is to arrange the classes vertically:
 \begin{codeexample}[width = 5.5cm]
 \begin{sseqpage}[ classes = {draw = none }, xscale = 2, yscale=1.55,
     class pattern = linear,
@@ -1875,7 +1843,7 @@ With multiple large class names, the best option is to arrange the classes verti
 \class["\iota_2\beta P^1\iota_3"](8,2)
 \end{sseqpage}
 \end{codeexample}
-\end{key}
+\end{keylist}
 
 \begin{key}{math nodes = \meta{boolean} (default true)(initially true)}
 This key instructs \sseqpages\  to put all labels in math mode automatically.
@@ -1989,19 +1957,19 @@ Sets the label offset -- by default the ticks will always be the set of numbers
 \end{keylist}
 
 \begin{keylist}{
-    x major tick step=\meta{nonnegative integer} (initially 0),
-    y major tick step=\meta{nonnegative integer} (initially 0),
-    major tick step=\meta{nonnegative integer},
-    x minor tick step=\meta{nonnegative integer} (initially 0),
-    y minor tick step=\meta{nonnegative integer} (initially 0),
-    minor tick step=\meta{nonnegative integer}%
+    x major tick step = \meta{nonnegative integer} (initially 0),
+    y major tick step = \meta{nonnegative integer} (initially 0),
+    major tick step = \meta{nonnegative integer},
+    x minor tick step = \meta{nonnegative integer} (initially 0),
+    y minor tick step = \meta{nonnegative integer} (initially 0),
+    minor tick step = \meta{nonnegative integer}%
 }
 If these are nonzero, they control the placement of tick marks on the axes. The value 0 prevents tick marks from being drawn. Uses |x tick offset| as an offset.
 \begin{codeexample}[width=7cm]
-\begin{sseqpage}[ 
+\begin{sseqpage}[
     tick step = 5,
-    major tick step = 5, 
-    minor tick step = 1, 
+    major tick step = 5,
+    minor tick step = 1,
     scale = 0.4,
     axes type = frame
 ]
@@ -2046,7 +2014,6 @@ The value for |x tick handler| should be a function that takes in the current $\
 \end{codeexample}
 \end{keylist}
 
-\newpage
 \subsection{Layout}
 \begin{keylist}{x axis type = \meta{type} (initially border), y axis type = \meta{type} (initially border),axes type = \meta{type} (initially border), no x axis, no y axis, no axes}
 The \meta{type} is either |border|, |center|, |frame|, or |none|. |no axes| is a shorthand for |axes type=none|. The |border| type is the default and puts the axes on the bottom and left of the picture. The |center| type by default places the axes to pass through $(0,0)$; this can be modified using the |x axis origin| and |y axis origin| keys. See \example{KRAHSS} and \example{KUHFPSS} for examples where this is used. The |frame| type draws a frame around the entire chart:
@@ -2061,7 +2028,7 @@ The \meta{type} is either |border|, |center|, |frame|, or |none|. |no axes| is a
 
 \parskip=0pt
 \begin{keylist}{x axis origin = \meta{x value} (initially 0), y axis origin = \meta{y value} (initially 0)}
-If you use |axes style = center|, these keys change the position of the axes. Otherwise, they are ignored.
+If you use |axes type = center|, these keys change the position of the axes. Otherwise, they are ignored.
 \end{keylist}
 %
 \begin{keylist}{x axis gap = \meta{dimension} (initially 0.5cm),y axis gap = \meta{dimension} (initially 0.5cm), axes gap = \meta{dimension} (initially 0.5cm)}
@@ -2073,7 +2040,7 @@ If you use |axes style = center|, these keys change the position of the axes. Ot
 \end{keylist}
 %
 \begin{keylist}{
-    x axis start extend = \meta{dimension} (initially 0.5cm), y axis start extend = \meta{dimension} (initially 0.5cm),
+    x axis extend start = \meta{dimension} (initially 0.5cm), y axis extend start = \meta{dimension} (initially 0.5cm),
     x axis extend end = \meta{dimension} (initially 0.5cm), y axis extend end = \meta{dimension} (initially 0.5cm),
     x axis tail = \meta{dimension} (initially 0.9cm), y axis tail = \meta{dimension} (initially 0.9cm)%
 }
-- 
cgit v1.2.3

