Why does 'Transpose[list]' work but 'Map[Transpose[#]&, list]' not when attempting to transpose a 2D-array list?

Question

I define this list:

list={{100,100},{200,200}}

Taking the transpose like this works as intended:

Transpose[list]

Taking the transpose like this yields an error message saying "Transpose::nmtx: The first two levels of {100,100} cannot be transposed.":

Map[Transpose[#]&, list]

Why aren't these two ways of taking the transpose equivalent? I've looked at the documentation on Map, but I can't figure out why the latter doesn't work. It looks like it should simply take list and put it where the # is, yet it doesn't.

Answer 1

Map will iterate over the list and apply some function element-wise. In your case, list is a 2D-array, so Map will iterate over the the elements of list, which are {100,100} and {200,200}. These are the values that are then applied to Transpose, which will clearly fail.

To better illustrate this, you can use some undetermined function f to see what's going on:

Clear[f]
Map[f[#] &, list]
(* {f[{100, 100}], f[{200, 200}]} *)

Replacing f with Transpose would then give

{Transpose[{100, 100}], Transpose[{200, 200}]}

which results in an error.

---

Edit: As Chris mentioned in the comments, this behavior can be controlled by the level spec. By, default, Map will map at the "first" level, which in the case of a 2D array like here, means that the mapped elements are lists themselves. However, if you use

 Map[Transpose, list, {0}]

this forces Map to only map elements on the "zeroth" level, which means the whole expression. This would be equivalent to

 Transpose[list]

If you use level 2, Map would go over every element in the 2D array like this:

 Map[f, list, {2}]
 (* {{f[100], f[100]}, {f[200], f[200]}} *)

Answer 2

An explanation of the description:

Transpose[list] transposes the first two levels in list.

If Transpose is applied at level $n$, then levels $n+1$ and $n+2$ are transposed, if the expression has a suitable structure: The expression must have levels $n+1$ and $n+2$, and the levels must form a "rectangular array" structure (e.g., a list of equal-length lists).

Transpose[list] applies Transpose at level 0 and transposes levels 1 and 2.

Transpose /@ list (or Map[Transpose[#]&, list]) applies Transpose at level 1 and transposes levels 2 and 3.

The OP's list has only two levels, so the second code results in an error.

---

The FullForm of list has the following level structure:

(*          level        0 *)
List[    (* level      1 | *)
  List[  (* level    2 | | *)
    100,100       (* 2 | | *)
  ],              (*   1 | *)
  List[  (* level    2 | | *)
    200,200       (* 2 | | *)
  ]               (*   1 | *)
]                 (*     0 *)

Every expression has a level structure of some sort. It's not easy to see the rectangular-array structure in FullForm. It may be visualized like this:

List
  ↓
 List ⟶  100 ⟶  100
  ↓
 List ⟶  200 ⟶  200

Transpose[list] restructures the expression like this:

List ⟶  List ⟶ List
           ↓        ↓
          100      100
           ↓        ↓
          200      200