Is Normal coordinates the same as Cartesian coordinates in flat space?

Let $ \gamma_v$ be the unique maximal geodesic with initial conditions $ \gamma_v(0)=p$ and $ \gamma_v'(0)=v$ then the exponential map is defined by
$ $ exp_p(v)=\gamma_v(1)$ $

If we pick any orthonormal basis,$ (e_1,…e_n)$ of $ T_pM$ then the $ x_i$ ’s, with $ x_i = pr_i◦exp^{-1}$ and $ pr_i$ the projection onto $ Re_i$ , are called normal coordinates at $ p$ .

My question is , if our manifold $ M$ is flat than does this normal coordinates coincide to what we call Cartesian coordinates ?

Do modifiers to jump length/height apply to flat values from some monster traits?

Some monsters have traits that give them jump heights without following the rules laid out in the Movement section of the Basic Rules. One example is the Frog:

Standing Leap. The frog’s long jump is up to 10 feet and its high jump is up to 5 feet, with or without a running start.

If one of these monsters gets access to a jump-modifying effect, how do they apply? Do effects like the jump spell multiply these flat values? Does a class feature like Second-Story Work (Thief Roguish Archetype) apply to the flat bonus?

Descent for the cotangent complex along faithfully flat SCRs

By Theorem 3.1 of Bhatt-Morrow-Scholze II (, we know that for $ R$ a commutative ring, $ \wedge^{i}L_{(-)/R}$ satisfies descent for faithfully flat maps $ A \rightarrow B$ of (ordinary) $ R$ -algebras. Can this descent statement be promoted to, say, faithfully flat maps of simplicial commutative $ R$ -algebras (where $ R$ is either discrete or a simplicial commutative ring)? I am primarily interested in the case where $ i=1$ , as the proof of this claim along with an induction argument using a filtration, can probably give the $ i>1$ case.

Efficient way of flat mapping a range of a multidimensional random access collection

I’ve recently answered a question about reading elements from an array of arrays. The basic idea of the iterative approach is to only read the needed elements from the original array:

func get<T>(_ range: Range<Int>, from array2d: [[T]]) -> [T]? {     var result: [T] = []     result.reserveCapacity(range.upperBound - range.lowerBound)      var count1 = 0      //Get the index of the first element     guard var low = array2d             .firstIndex(where: {                  count1 += $  0.count                  return range.lowerBound < count1 }),           count1 != 0     else { return nil }      let before = count1 - array2d[low].count     var count2 = before      //Get the index of the last element in the range     guard let high = array2d[low..<array2d.endIndex]             .firstIndex(where: {                  count2 += $  0.count                  return range.upperBound <= count2             }),           count2 != 0     else { return nil }      //Append the elements in the array with the low index     for i in (range.lowerBound - before)..<min(range.upperBound - before, array2d[low].count) {          result.append(array2d[low][i])      }      //If the range spans over multiple arrays     if count1 < count2 {         low += 1          //Append the elements in the arrays with an index between low and high         while low < high {             result.append(contentsOf: array2d[low])             low += 1         }          //Append the elements in the array with the high index         for i in 0..<(range.upperBound - count2 + array2d[high].count) {             result.append(array2d[high][i])         }     }      return result } 

This code feels.. on the border of sanity/maintainability…

What I’d like to do is to make it more generic, maybe as an extension to RandomAccessCollection, and making the flattening process recursive for arrays/collections of arbitrary dimensions. I’m stuck here and not sure if this is the appropriate network to ask such a question.

Feedback on all aspects of the code is welcome, such as (but not limited to):

  • Efficiency,
  • Readability,
  • Naming.

Will real world applications ever need a 128-bit flat address space?

This is a bit “one megabyte should be enough for anyone”, but…

A 64-bit flat address space allows up to 4.3ish billion times more space than a 32-bit address space. That’s 17,179,869,184 GiB.

Obviously, the transition from 8 bits to 16 bits was pretty quick (I’m viewing things in a teen-during-the-80s way, ignoring all those mainframes and minis because they couldn’t run a port of Elite). The transition from 16 bits to 32 bits took a bit longer, and 32 bits actually lasted quite a while.

Now we have 64 bits, would it be stupid to say “17,179,869,184 GiB should be enough for anyone”?

This is a programmers question because I really have the programming viewpoint in mind. Even if a computer some day has a seemingly infinite amount of working memory, that doesn’t mean that applications will need to see a seemingly infinite flat address space.

Basically, can we programmers breath a sigh of relief and say “well, whatever integers or floats may do, at least I don’t have to worry about my pointers growing any more?”.

Macbook battery runs flat while “charging” with nearly full USB Brick

Road warriors buy Macbooks for untethered working and at times find themselves in a place without a powerpoint. So charging a Macbook from a USB Brick is a fundamental operational requirement. I thought I’d just plug my 2018 Macbook Pro into a USB Power Brick and it would just “work”. How wrong I was

The USB Brick charged at such a poor rate my Macbook’s battery would run flat despite having almost a full 26800 mAH Brick. Something was badly wrong. Was it the USB brick I was using? Was it the cable? Was it a combination of these things? Much head scratching…

Since this is an issue I feel of broad interest for all mobile workers, I’ll give a thorough treatment of the issue and the solution.

Why is product flat collection disabled in checkout / cart pages since CE / EE

Since CE / EE cart and checkout controllers have preDispatch method updated with the following changes:


which forces product collections to use EAV tables instead of catalog_product_flat_x one(s). Is the reason behind this known? There are no exact mentions of the change in release notes.

Flat cohomology and finite direct sum

Let $ X$ be a scheme (we can assume $ X$ is smooth over a field $ k$ ). Let $ \mathcal F_1$ and $ \mathcal F_2$ be two sheaves of abelian groups on $ X$ .

Is it always true that $ H^i_{\text{flat}}(X, \mathcal F_1 \oplus \mathcal F_2) = H^i_{\text{flat}}(X, \mathcal F_1) \oplus H^i_{\text{flat}}(X, \mathcal F_2)$ ? If not in general, is it true in particular that $ H^i_{\text{flat}}(X, \mu_{n} \times \mu_n) = H^i_{flat}(X, \mu_n ) \oplus H^i_{\text{flat}}(X, \mu_n )$ , or if we assume extra conditions on $ X$ (like quasi-compactness etc. …)?

A proper flat family with geometrically reduced fibers

Let $ R$ be a Noetherian commutative unital ring. Let $ f:X\rightarrow Y=\mathrm{Spec}\,R$ be a proper flat morphism of schemes with geometrically reduced fibers. We want to prove that the induced map $ Z=\mathrm{Spec}\, H^0(X, O_X)\rightarrow Y$ is flat.

Some thoughts. Since $ f$ is qcqs, $ f_*O_X$ is a quasi-coherent $ O_Y$ -module, i.e. associated to an $ R$ -module. Since flatness of a module can be checked on localizations, and properness and flatness are preserved by base change, we reduce to the case $ R$ is local. I am not sure what to do next.