Peaks

The number of peaks of $p$ : interior positions $i$ with $p_{i-1} < p_i > p_{i+1}$ .

✓ checked against that system · ! checked, with disagreements (hover a chip)FindStatSt000015via DyckPath✓St001068via DyckPath✓St000768via IntegerComposition✓St000023via Permutation✓

Peaks(p)the peak count of a one-line permutation

p

SageMathenumeratio_stat("Permutation", p, "Peaks")

Typed signatures

Type	Package	Applies
`(composition \| dyck_path \| list \| motzkin_path \| permutation \| schroeder_path) -> integer \| number`	`combinatorics`	always

Domain: Permutation statistics

Details

Only interior positions count ( $1 < i < n$ ), so $\mathrm{Peaks}(p) = 0$ whenever $n \leq 2$
Peaks and Valleys alternate along the sequence, so they differ by at most $1$
Defined over Permutation as an expression in _x, evaluated by compute-engine — the definition IS the implementation.
Takes a Permutation, and also a bare list of integers: this reading compares entries with each other rather than with their positions, so it stands on any sequence.
A separate definition exists for DyckPath (Occurrences of an up step immediately followed by a down step.) but is not the one declared: one head, one owner.
A separate definition exists for MotzkinPath (Occurrences of an up step immediately followed by a down step.) but is not the one declared: one head, one owner.
A separate definition exists for SchroederPath (Occurrences of an up step immediately followed by a down step.) but is not the one declared: one head, one owner.

Definition

Epsil, as the implementation runs it.

on Permutation, over _x

0 if Length(_x) < 3 else Count(Filter(
                                       Range(2, Length(_x) - 1),
                                       Function(_x[i - 1] < _x[i] && _x[i] >
                                                                     _x[i + 1], i),
                                     ))

on DyckPath, over _x

0 if Length(_x) < 2 else Count(Filter(
                                       Range(1, Length(_x) - 1),
                                       Function(_x[i] == 1 && _x[i + 1] == 0, i),
                                     ))

on IntegerComposition, over _x

0 if Length(_x) < 3 else Count(Filter(
                                       Range(2, Length(_x) - 1),
                                       Function(_x[i - 1] < _x[i] && _x[i] >
                                                                     _x[i + 1], i),
                                     ))