LatticePathsAboveWordCount

The paths of the word's length, ending anywhere, that stay weakly above the path the word gives.

✓ checked against that system · ! checked, with disagreements (hover a chip)FindStatSt001365via BinaryWord✓↗

LatticePathsAboveWordCount(word)The paths of the word's length, ending anywhere, that stay weakly above the path the word gives.

Typed signatures

Type	Package	Applies
(binary_word) -> number	combinatorics	always

Domain: Binary word statistics

Details

• Defined over BinaryWord as an expression in _x, evaluated by compute-engine — the definition IS the implementation.
• Takes a BinaryWord and nothing else — it reads values against their positions, or walks the orbits, so it needs the bijection. Applying it to a bare list is a type error, not a wrong answer.
• FindStat's St001365. A 1 is a step up and a 0 a step across; a path is above when it has made at least as many steps up after every step. The fold counts the paths by how many steps up they are ahead.

Definition

Epsil, as the implementation runs it.

on BinaryWord, over _x

0 if Length(_x) < 1 else Max(Sum(Apply(
                                        (a_init: list<integer>) => Fold((
                                                                          a: list<integer>,
                                                                          b,
                                                                        ) => Apply(
                                                                                   (a_next: list<integer>) => a_next,
                                                                                   Join(
                                                                                         [0],
                                                                                         Map(
                                                                                              Function(a[j] +
                                                                                                       a[j + 1] if b == 1 else a[j - 1] +
                                                                                                                       a[j], j),
                                                                                              Range(2, Length(_x) + 2, 1),
                                                                                            ),
                                                                                         [0],
                                                                                       ),
                                                                                 ), a_init, _x),
                                        Join([0, 1], Map(
                                                          Function(0, z),
                                                          Range(1, Length(_x) +
                                                                   1, 1),
                                                        )),
                                      )), 0)

Examples

Basic #

the word $110100111$

live ↗

In$\mathrm{LatticePathsAboveWordCount}({\operatorname{BinaryWord}}([1, 1, 0, 1, 0, 0, 1, 1, 1]))$Out$58$

Properties #

FindStat's value for 0

live ↗

In$\mathrm{CombinatorialStat}({\operatorname{BinaryWord}}([0]), \text{LatticePathsAboveWordCount})$Out$2$

Known value · FindStat St001365

FindStat's value for 1

live ↗

In$\mathrm{CombinatorialStat}({\operatorname{BinaryWord}}([1]), \text{LatticePathsAboveWordCount})$Out$1$

Known value · FindStat St001365

FindStat's value for 00

live ↗

In$\mathrm{CombinatorialStat}({\operatorname{BinaryWord}}([0, 0]), \text{LatticePathsAboveWordCount})$Out$4$

Known value · FindStat St001365

About

Examples	4
Crosswalk	FindStat