Freezing a transform doesn't make it immutable, it just makes it independent of changes to its children (by recursively replacing the children by "private" copies of them). This is in fact the goal stated in the docstring:

        Returns a frozen copy of this transform node.  The frozen copy
        will not update when its children change.  Useful for storing
        a previously known state of a transform where
        ``copy.deepcopy()`` might normally be used.

Transforms are not hashable and typically not used as keys in AxesStack.

Ok, that makes sense, but this still seems hackish. Would in be better to remove the transform from the kwargs used to make the key (in Figure._make_key)?

On reading the code of the OP, does transform even get used? If an Axes is passed in, kwargs is only used for the key and nothing else. This seems not quite right.

FWIW I still think the ultimately correct way to do this is to get rid of the brittle "check whether there is already an axes with the same key" approach (for reasons already explained elsewhere).

Alternatively, instead of using a dict, you could just use a list of pairs (key, value) and check for equality with the keys one at a time -- there is no way you can have so many Axes that the performance becomes an issue. But this is still bound to have problematic semantics due to key mutability.

@anntzer I am convinced on this, can you rebase?

done

Thank you @anntzer