How to map an inequality to a list?

Question

vars = Table[Subscript[a, j], {j, 5}]

We can do the total

Total[vars]

and produce

Times@@vars

What's the most efficient way to get this

{Subscript[a, 1]<=Subscript[a, 2]<=Subscript[a, 3]<=Subscript[a, 4]<=Subscript[a, 5]}

I can't seem to find a proper way to map this.

Answer 1

Rather than considering this question "too simple" and closing it I tried to think of a way to make it or its answer of wider interest. It seems to me that for this question to have been asked it must not be clear that there is equivalence between <= and LessEqual, and/or that LessEqual is not a binary function but can receive many arguments.

One can see with FullForm that operators such as <= are represented by a common Head such as LessEqual. Some other examples:

expr = {
  a < b < c,
  a <= b <= c,
  a > b > c,
  a >= b >= c,
  a == b == c,
  a != b != c,
  a && b && c,
  a | b | c,
  a.b.c
};

FullForm /@ expr // Column

Less[a, b, c]
LessEqual[a, b, c]
Greater[a, b, c]
GreaterEqual[a, b, c]
Equal[a, b, c]
Unequal[a, b, c]
And[a, b, c]
Alternatives[a, b, c]
Dot[a, b, c]

Therefore these and other heads may be used to construct such expressions:

operators = {Less, LessEqual, Greater, GreaterEqual, Equal, Unequal, Dot, And, Or, Nand, 
   Nor, Xor, Alternatives, Equivalent, Proportional};

list = {a, b, c, d, e};

Table[
 op @@ list,
 {op, operators}
]

{a < b < c < d < e, a <= b <= c <= d <= e, a > b > c > d > e, a >= b >= c >= d >= e, 
 a == b == c == d == e, a != b != c != d != e, a.b.c.d.e, a && b && c && d && e, 
 a || b || c || d || e, a ⊼ b ⊼ c ⊼ d ⊼ e, 
 a ⊽ b ⊽ c ⊽ d ⊽ e, a ⊻ b ⊻ c ⊻ d ⊻ e, 
 a | b | c | d | e, a ⧦ b ⧦ c ⧦ d ⧦ e, 
 a ∝ b ∝ c ∝ d ∝ e}

Not included in the example are SameQ and UnsameQ only because those evaluate on symbolic arguments:

SameQ @@ list
UnsameQ @@ list

False
True

With holding to prevent that evaluation:

SameQ @@@ HoldForm @@ {list}
UnsameQ @@@ HoldForm @@ {list}

a === b === c === d === e
a =!= b =!= c =!= d =!= e

All of the operators shown above are of the kind that work with multiple arguments. Not all operators are like this. For other operators one may refer to the Operator Precedence Table. Note that something like Map parses differently:

HoldForm @ FullForm[a /@ b /@ c /@ d /@ e]

Map[a, Map[b, Map[c, Map[d, e]]]]

(I believe this is known as a right-associative operator.) One therefore cannot construct an equivalent expression with Apply:

 Map @@ {a, b, c, d, e}

Map::nonopt: Options expected (instead of e) beyond position 3 in Map[a,b,c,d,e]. An option must be a rule or a list of rules. >>

Map[a, b, c, d, e]

---

Recommended reading:

• How to make a binary function associative? (Or define an n-ary function?)