Standard 23.1 - std::map::value_type must be assignable?

I'm puzzled about part of the standard. 23.1 states that items stored
in a container must be assignable. Therefore, the items in a map--that
is, std::pair<const Key, value> must be assignable. However, such a
pair--with the const Key--is not assignable.

My concern is more than academic; take for instance the following code
to make a copy of a map while eliminating some of the elements:

#include <map>
#include <algorithm>

typedef std::map<char, int> MapType;

bool predicate(const MapType::value_type& x)
{
    return x.second > 1;
}

int main()
{
    MapType bigMap;
    bigMap['a'] = 1;
    bigMap['b'] = 2;

    MapType littleMap;

    // This shouldn't work, right? Standard 23.1 says objects in
    // container must be assignable, but MapType::value_type is
    // std::pair<const char, int> which is NOT assignable
    std::remove_copy_if(bigMap.begin(),
                        bigMap.end(),
                        std::inserter(littleMap, littleMap.end()),
                        &predicate);
    return 0;
}

This compiles fine on g++ 4.1.2, but I want to make sure I'm not
writing nonstandard code. That leaves me with two questions:

1) is there part of the standard that I'm missing that describes how
maps can have values of std::pair<const Key, value> even though that
pair is not assignable?

2) is the sample code above standard compliant, and if not, how should
I accomplish something like this?

Thanks,
Omari