Does std::mutex enforce cache cohesion?

I have a non-atomic variable my_var and an std::mutex mut. I assume up to this point in the code, the programmer has followed this rule:

Assuming this, Thread1 performs the following:

my_mut.lock();
my_var.modify();
my_mut.unlock();

Here is the sequence of events I imagine in my mind:

1. to my_mut.lock();, there were possibly multiple copies of my_var in main memory and some local caches. These values do not necessarily agree, even if the programmer followed the rule.
2. By the instruction my_mut.lock();, all writes from the previously executed my_mut critical section are visible in memory to this thread.
3. my_var.modify(); executes.
4. my_mut.unlock();, there are possibly multiple copies of my_var in main memory and some local caches. These values do not necessarily agree, even if the programmer followed the rule. The value of my_var at the end of this thread will be visible to the next thread that locks my_mut, by the time it locks my_mut.

I have been having trouble finding a source that verifies that this is exactly how std::mutex should work. I consulted the C++ standard. From ISO 2013, I found this section:

Is my understanding of std::mutex correct?