SignedAlignmentCount

The alignments of p: its nesting alignments, those of type EN and those of type NE.

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

SignedAlignmentCount(p)The alignments of p: its nesting alignments, those of type EN and those of type NE.

Typed signatures

Type	Package	Applies
(signed_permutation) -> number	combinatorics	always

Domain: Signed permutation statistics

Details

• Defined over SignedPermutation as an expression in _x, evaluated by compute-engine — the definition IS the implementation.
• Takes a SignedPermutation 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 St001822 (St001866, St001867, St001868 summed). Not Alignments, which counts the pairs of arcs of an unsigned permutation.

Definition

Epsil, as the implementation runs it.

on SignedPermutation, over _x

0 if Length(_x) < 1 else Max(0 + Sum(Map(
                                          Function(Count(Filter(
                                                                 Range(
                                                                        1,
                                                                        Length(_x),
                                                                      ),
                                                                 Function(j < i &&
                                                                          _x[i] <
                                                                          _x[j] && _x[j] <
                                                                              j, j),
                                                               )), i),
                                          Range(1, Length(_x)),
                                        )) + Sum(Map(
                                                     Function(Count(Filter(
                                                                            Range(1, Length(_x)),
                                                                            Function(j <= _x[j] &&
                                                                                     _x[j] < -_x[i], j),
                                                                          )), i),
                                                     Range(1, Length(_x)),
                                                   )) + Sum(Map(
                                                                Function(Count(Filter(
                                                                                       Range(1, Length(_x)),
                                                                                       Function(j > i &&
                                                                                                j <= _x[j] &&
                                                                                                _x[j] < _x[i], j),
                                                                                     )), i),
                                                                Range(
                                                                       1,
                                                                       Length(_x),
                                                                     ),
                                                              )) + Sum(Map(
                                                                           Function(Count(Filter(
                                                                                                  Range(1, Length(_x)),
                                                                                                  Function(_x[i] < 0 &&
                                                                                                           -_x[i] < _x[j] &&
                                                                                                           _x[j] < j, j),
                                                                                                )), i),
                                                                           Range(1, Length(_x)),
                                                                         )) +
                             Sum(Map(
                                      Function(Count(Filter(
                                                             Range(
                                                                    1,
                                                                    Length(_x),
                                                                  ),
                                                             Function(i <= _x[i] &&
                                                                      _x[i] <
                                                                      _x[j] && _x[j] <
                                                                          j, j),
                                                           )), i),
                                      Range(1, Length(_x)),
                                    )) + Sum(Map(Function(Count(Filter(
                                                               Range(
                                                                      1,
                                                                      Length(_x),
                                                                    ),
                                                               Function(_x[i] <
                                                                        i && i <
                                                                            j &&
                                                                            j <=
                                                                            _x[j], j),
                                                             )), i), Range(
                                                                           1,
                                                                           Length(_x),
                                                                         ))), 0)

Examples

Basic #

the signed word $2\,\bar{1}\,\bar{3}$

live ↗

In$\mathrm{SignedAlignmentCount}({\operatorname{SignedPermutation}}([2, -1, -3]))$Out$2$

Properties #

FindStat's value for [1]

live ↗

In$\mathrm{CombinatorialStat}({\operatorname{SignedPermutation}}([1]), \text{SignedAlignmentCount})$Out$0$

Known value · FindStat St001822

FindStat's value for [-1]

live ↗

In$\mathrm{CombinatorialStat}({\operatorname{SignedPermutation}}([-1]), \text{SignedAlignmentCount})$Out$0$

Known value · FindStat St001822

FindStat's value for [1,2]

live ↗

In$\mathrm{CombinatorialStat}({\operatorname{SignedPermutation}}([1, 2]), \text{SignedAlignmentCount})$Out$0$

Known value · FindStat St001822

About

Examples	4
Crosswalk	FindStat