The 2-primary Dyer-Lashof algebra

Tyler — Thu, 07 May 2009 22:30:19 +0000

I can never remember the indexing on this off the top of my head. I learned my point of view on this stuff from lectures given by Charles Rezk.

Assume . A model over the Dyer-Lashof theory is a graded commutative -algebra equipped with functions (upper indexing indicates the change in degree) for such that:

(the Cartan formula), and
2s' title='Q^r Q^s = \sum_{i+j=r+s} \binom{j-s-1}{2j-r}Q^i Q^j \text{ for }r > 2s' class='latex' /> (the Adem relations).

A monomial is admissible if for all ; in other words, if we cannot apply the Adem relations to it directly.

The excess of an admissible monomial is the quantity . It is the maximal degree of element upon which the monomial is not immediately forced to vanish.

The free model over this theory on an element in degree is the polynomial algebra for c' title='e(I) > c' class='latex' /> (i.e., polynomials on the admissible monomials that are not forced to vanish).

The two important classical cases are the following.

Homology of infinite loop spaces. If is a spectrum, then the spectrum is an algebra over , and so its homotopy groups are a model over the Dyer-Lashof theory. These are the “classical” Dyer-Lashof operations.
Cohomology of spaces. If is an ubased space, then the spectrum is an algebra over , and hence its homotopy groups inherit the structure of a model over the Dyer-Lashof theory. The operation is usually known as the Steenrod square . Sometimes the algebra of these Dyer-Lashof operations is sometimes known as the “big Steenrod algebra”. These have the two very special properties that for all (assuming ), and that the Steenrod algebra action can be identified with the Dyer-Lashof action.

The free -algebra over on is the free model over the Dyer-Lashof theory on generators in degrees .

Basic document sync with git

Tyler — Thu, 12 Jun 2008 02:23:11 +0000

So I type a lot of documents, and this necessitates shuffling them between my laptop and the various shell accounts I work in. Up to this point I’ve been too lazy to actually set up something to synchronize them automatically, but I’m sick of it.

So I set it up using git, which is total overkill if you’re not writing software. Here’s how to set it up for someone who uses very few features of the program. If you want more, I’d check out the documentation or Everyday GIT with 20 commands or so.

Pick a system to set up the main repository on. Ideally this should be one that is perpetually connected to the internet, allows ssh access, and has a superuser who you can convince to install git. If not, you can try this with cvs or Subversion, but I don’t know how to do it.
Create a repository directory for git to store everything, and move into it:
```
mkdir myrepo; cd myrepo
```
Initialize git in this directory:
```
git init
```
Move whatever files you want to start with into the directory:
```
mv ~/myfiles/* .
```
Add these files to those that git tracks:
```
git add .
```
Commit the update:
```
git commit -a
```
You’ll be asked to specify a description, which is good practice whenever you update the directory (think of it like a blog that you’ll go back and read someday, if you must). If you don’t want to accidentally end up editing it in vi, you can enter the description from the commandline:
```
git commit -a -m "initial commit of files"
```

The base repository is now set up. You can work in this directory if you want, or simply run copies of it on the same machine (git is smart enough to just crsvneate symlinks where necessary rather than copying everything, which helps to keep things organized).

Now, on any other machine that you might want to create a working copy of the repository, do the following.

Install git. For example, on a Ubuntu laptop where you have superuser access, you can just type:
```
sudo apt-get install git
```
Move to the location where you want to create a directory for the repository; for example, if you want it just off your rot directory, you would move there:
```
cd ~/
```
Clone a copy of the repository. If the repository is on the local machine, you can just type something like:
```
git clone ~/myrepo workingcopy
```
If instead it’s on another machine accessible by ssh, do like follows:
```
git clone ssh://username@myhost.com/~/myrepo workingcopy
```
The username is optional if you have the same username on both machines.

Once git is done, you’re set. You now have a working copy in the directory you specified. All you need now are the basic operating procedures. All of these commands need to be run in some subdirectory of your working copy of the repository.

To update all your files to be current with the repository:
```
git pull
```
(No re-entering of the ssh information necessary.)
To add files or directories to the list of files that git is tracking:
```
git add filename.txt *.tex mydir
```
After doing any editing, adding, or moving, commit your changes and fire them back to the repository:
```
git commit -a -m "here's what I added to this "
git push
```
At any time, you can get a list of what you’ve updated and what files you might have forgotten:
```
git status
```

And you’re set. Now syncing is pretty painless, you’ve got documentation of your progress, and you can always revert back if you do too much writing at 3 in the morning.

akth

The 2-primary Dyer-Lashof algebra

Basic document sync with git