text:
% LaTeX class specification.  Any changes will not appear in the final version
\documentclass[12pt,letterpaper, reqno]{amsart}

% Only the following packages are available.
% If these are not sufficient, then you must submit a special request
% for a new package to be includade.  (We apologize for any inconvenience,
% but we cannot maintain these documents indefinitely without such restrictions).
\usepackage{amssymb,latexsym, amsmath, amsxtra, xy}
\usepackage[dvips]{graphics}

% The aimpl style file is necessary in order for the latex version
% to faithfully mimic the appearance of the problem list after it is
% uploaded. The file aimpl.sty should be in same directory as this file.

\usepackage{aimpl_2}

% The problem list should be arranged like a research paper, with
% introductory material followed be one or more main sections.
% Do not divide the sections into subsections.
% Each section could have its own introductory material.
% The main part of each section is a "problem block" which has the format
% [[see elsewhere for more documentation]]

% New macros.
% If at all possible, please do not define any new macros.  Each
% macro you introduce has the potential to cause problems with the
% long-term maintenance of the problem list.
\newcommand{\Cat}{{\rm Cat}}
\newcommand{\A}{\mathcal A}
\newcommand{\freestar}{ \framebox[7pt]{$\star$} }

\begin{document}
\title{Braid Groups, Clusters, and Free Probability}
\author{Drew Armstrong}

\maketitle

This document grew out of the workshop {\em Braid Groups, Clusters,
and Free Probability}, which was held at the American Institute of
Mathematics in Palo Alto, on January 10--14, 2005. The organizers of
the workshop were Jon McCammond, Alexandru Nica, and Vic Reiner.

What follows is a joint statment of the participants regarding important
open problems and promising directions for future progress in the
subject. For further information, including a list of participants and
participant abstracts, see the AIM webpage \texttt{www.aimath.org}. Jon
McCammond also maintains a webpage with resources related to these
topics \cite{mccammond:webpage}.

The goal of this workshop was to bring together mathematicians from
different backgrounds to discuss a central theme which has recently
emerged in many different contexts.  Given a finite Coxeter group $W$,
define the corresponding {\sf Catalan number}
\begin{equation*}
\Cat(W):=\prod_{i=1}^n \frac{h+e_i+1}{e_i+1},
\end{equation*}
where $h$ is the Coxeter number, and $e_1,e_2,\ldots,e_n$ are the
exponents of the group $W$ (for notation related to Coxeter groups
and reflection groups, we refer to \cite{humphries}). When $W$ is
the symmetric group $A_{n-1}$, this is just the usual Catalan number
$\Cat(A_{n-1})=\frac{1}{n+1}\binom{2n}{n}$. As with the classical Catalan
numbers, these type $W$ Catalan numbers have a wealth of combinatorics
associated with them, and they have recently appeared independently in
several different fields, including Garside structures for braid groups,
cluster algebras, and free probability.

This {\em Catalan combinatorics} describes extensive and surprising
enumerative correspondences between these subjects, which in most cases
are still unexplained (the term ``numerology'' is often used). A common
goal of the workshop participants is to understand these concurrences,
and search for underlying theories which can explain the combinatorics.

This is an exciting, emerging subject with many fundamental questions
yet to be solved. We present here a collection of important and
interesting questions offered by the participants. Many problems have
attributions. These are to the person who brought the problem to my
attention, and are used for the purpose of facilitating communication. No
attempt has been made to track down the original source. A more detailed
history can likely be found by contacting the contributor of the problem.

%I would like to thank the organizers and participants of the workshop for their helpful comments in preparing this outline.

\section{Central Questions}
\label{sec:central}

There are three main families of combinatorial structures counted by
the Catalan combinatorics, which arise independently in three different
subjects.

\begin{enumerate}
\item Let $W$ be a finite Coxeter group, and let $T$ be the generating
set of {\em all} reflections ($T$ is defined as the set of conjugates of
a standard Coxeter generating set $S$). Let $\ell$ denote the word length
on $W$ with respect to $T$. This function induces a partial order on $W$
by setting $a\leq b$ whenever $\ell(b)=\ell(a)+\ell(a^{-1}b)$. The Hasse
diagram of this poset is just the Cayley graph of $(W,T)$, directed away
from the identity element $1$.

Let $c$ be a Coxeter element of $W$. The interval $[1,c]$ in
this poset is called the poset of {\sf noncrossing partitions}
$NC_W$. (This is well-defined, since Coxeter elements form a conjugacy
class.) $NC_W$ in its full generality was defined independently
by David Bessis \cite{bessis:dual} and Tom Brady and Colum Watt
\cite{brady,brady-watt:kpi1} in order to study the geometric group theory
of braid groups. However, important special cases of the generalization
had been considered earlier by Vic Reiner \cite{reiner} and Philippe Biane
\cite{biane}. In the type $A$ case, Roland Speicher showed that this poset
lies at the heart of the subject of free probability in operator algebras
\cite{speicher:survey}. The study of the type $A$ case is classical and
goes back to Kreweras \cite{kreweras}. The survey paper \cite{simion}
by Rodica Simion gives a comprehensive view of the classical noncrossing
partitions, and the survey \cite{mccammond:noncrossing} by Jon McCammond
gives a more modern overview of the subject.

\item For every finite Coxeter group $W$, Sergey Fomin and Andrei
Zelevinsky have defined a simplicial complex $\Delta_W$ called the
{\sf simplicial associahedron} of type $W$. Let $\Phi$ be the root
system corresponding to $W$, and let $\Phi^+$ and $\Pi$ be a choice
of positive roots and simple roots, respectively. Then $\Delta_W$ is
defined as a flag complex on the set of {\sf almost positive roots}
$\Phi_{\geq -1}:= \Phi^+ \cup (-\Pi)$. Their original construction
\cite{fomin-zelevinsky:ysystems} applied only to crystallographic
root systems, but the definition may be uniformly generalized to all
root systems (see the notes \cite{fomin-reading:survey}). The complex
$\Delta_W$ generalizes the well-known associahedron (or Stasheff polytope)
in type $A$, and the well-known cyclohedron (or Bott-Taubes polytope)
in type $B$. For more information, see Section \ref{sec:cluster}.

Related to this are the {\sf Cambrian lattices} of Nathan Reading
\cite{reading:cambrian}. To each orientation of the Coxeter diagram of
$W$, he associates a lattice which is a quotient of the weak order on
$W$. Conjecturally, each of these Cambrian lattices is an orientation
of the $1$-skeleton of the {\sf simple associahedron}, the dual complex
to $\Delta_W$. Cambrian lattices may be regarded as a generalization of
the classical Tamari lattices, and this idea has also been considered
by Hugh Thomas in type $B$ \cite{thomas}.

\item In the case that $W$ is a Weyl group (that is, a crystallographic
Coxeter group), Postnikov has suggested how to define a poset of {\sf
nonnesting partitions} $NN_W$ (see remarks in \cite{reiner}). Given
a crystallographic root system $\Phi$ with positive roots $\Phi^+$,
the {\sf root order} $(\Phi^+,\leq)$ is a partial order on $\Phi^+$,
where $\alpha\leq\beta$ if and only if $\beta-\alpha$ is in the positive
integer span of $\Pi$.

To each antichain $\A$ (set of pairwise-incomparable elements) in
the root order, associate the vector subspace $\cap_{\alpha\in\A}
\alpha^{\perp}$, which is the intersection of the orthogonal hyperplanes
to the corresponding roots. Then $NN_W$ is defined as the poset of
antichains under reverse inclusion of subspaces.

The antichains may also be interpreted as order ideals (or order
filters) in the root order, and Cellini and Papi have shown that these
are in bijection with nilpotent ideals of a Borel subalgebra of the
corresponding semisimple Lie algebra \cite{cellini-papi}. One may define
a {\em different} partial order on the antichains via inclusion of ideals,
and this poset describes the structure of the chambers within the dominant
cone of the Shi hyperplane arrangement \cite{shi}.

\end{enumerate}

\begin{problemblock}

\begin{problem}
\label{central:one}
Explain the numerology. The cardinality of $NC_W$, the cardinality of
$NN_W$ and the number of facets of $\Delta_W$ are all equal to the Catalan
number $\Cat(W)$. The rank numbers of $NC_W$, the height numbers of $NN_W$
(in general, $NN_W$ is not graded), and the $h$-vector of $\Delta_W$ are
all the same, given by the {\sf Narayana numbers} (for which there is no
known closed formula, in general).
\end{problem}

 The enumerative coincidences are quite
extensive, and quite mysterious, as there is  still no theoreretical
connection between these objects.  In fact, only for $NN_W$ and its
relatives is there {\em any} proof whatsoever of the enumerative formulas
that is not case-by-case, using the finite type classification.
\end{problemblock}

\begin{problemblock}
\begin{problem}
Find bijections between these objects which preserve the numerology. Is
there some theoretical algebraic framework behind the scenes, as
yet undiscovered? David Bessis has suggested a notion of ``dual''
Coxeter systems \cite{bessis:dual}. Is there a way to formalize this
notion? The exponents of $W$ are one below the corresponding degrees of
the fundamental polynomial invariants of $W$ (see \cite{humphries}). Does
the number $\Cat(W)$ have any significance in an invariant theory context?
\end{problem}

\begin{remark}
 There are two remarkable enumerative refinements of the Catalan combinatorics, each in a different direction.
\begin{enumerate}
\item Fr\'ed\'eric Chapoton has defined a two variable generating function
on each of the three main families (the $M$-triangle on noncrossing
partitions, the $F$-triangle on the associahedron, and the $H$-triangle
on nonnesting partitions), and conjectured precise algebraic relationships
between these functions \cite{chapoton:one,chapoton:two}. This gives very
refined enumerative correspondences between these objects, and is strong
evidence for the existence of hidden structural relationships. Explain
Chapoton's formulas.

\item Christos Athanasiadis and Vic Reiner have described an enumerative
correspondence between $NC_W$ and $NN_W$ that refines the Narayana numbers
\cite{athanasiadis-reiner}. Both of these posets may be injected into the
lattice of hyperplane intersections $\Pi_W$ of the corresponding Coxeter
arrangement. For $\pi$ in $NC_W$ let $f(\pi)$ be the fixed subspace
of $\pi$, and for $\A$ in $NN_W$, let $g(\A)$ be the intersection of
hyperplanes $\cap_{\alpha\in\A} \alpha^{\perp}$, as before. The result
states that the filters of $f$ and $g$ over any $W$-orbit in $\Pi_W$
are equinumerous.

The proof is case-by-case, using computer in the exceptional types. Find
a theoretical proof. Is there a natural statistic on $\Delta_W$ that
agrees with this refinement of the Narayana numbers? Is there a way to
express this statistic within the context of Chapoton's $M$-triangle,
$F$-triangle and $H$-triangle generating functions?
\end{enumerate}
\end{remark}

\begin{remark}The recent work of Nathan Reading on Coxeter-sortable elements
\cite{reading} gives an explicit bijection between $NC_W$ and the
facets of $\Delta_W$, however the proof of this bijection is currently
case-by-case (see Problem \ref{prob:c-sorted}). Also, Tom Brady and Colum
Watt have given a new definition of $\Delta_W$ in terms of noncrossing
partitions \cite{brady-watt}. This may provide some connection between
the structure of $NC_W$ and $\Delta_W$.
\end{remark}

\end{problemblock}

\begin{problemblock}

\begin{problem}\label{central:two} What are the largest natural domains of definition for the families $NC_W$, $NN_W$ and $\Delta_W$, and for their corresponding applications?\end{problem}

\begin{remark}
In a sense, the broadest setting possible for the numerology is {\em finite groups generated by pseudoreflections}. (A pseudoreflection is a unitary operator on an $n$-dimensional complex vector space whose eigenvalues are $0$ with multiplicity $n-1$, and $-1$ with multiplicity $1$.) It is a classical result of Shephard and Todd that the ring of invariants of a group $W$ is a polynomial ring precisely when the group is of this type. And in this case the sequence of degrees $d_1,d_2,\ldots,d_n$ of fundamental invariants is unique \cite{shephard-todd}.

In the general (complex) case, David Bessis suggests that the Catalan number should be
\begin{equation*}
\Cat(W):= \prod_{i=1}^n  \frac{h+d_i}{d_i},
\end{equation*}
where we set $h$ equal to the highest degree $d_n$. This agrees with our earlier definition in the real types. However, this may apply only when $W$ is a {\sf duality group} (or a {\sf well-generated group}), since otherwise $\Cat(W)$ may fail to be an integer. See the paper \cite{bessis:complex} by David Bessis for more information.
\end{remark}

\begin{remark}
The noncrossing partitions are currently the most general of the Catalan families. The poset $NC_W$ is defined for all finite Coxeter groups, and the definition makes sense in principle for any finitely generated Coxeter group (although the definition may not be unique when $W$ is infinite \cite{mccammond-etal}). David Bessis and Ruth Corran gave a combinatorial realization of $NC_W$ for an infinite class of complex reflection groups in \cite{bessis-corran}, and Bessis has suggested a uniform definition for $NC_W$ whenever $W$ is a well-generated complex reflection group \cite{bessis:complex}.
\end{remark}

\begin{remark}
Can one generalize free probability beyond types $A$ and $B$? The combinatorics of free probability is naturally expressed in terms of the type $A$ noncrossing partitions \cite{speicher:survey}, and some work has been done on a type $B$ free probability \cite{biane-goodman-nica}. Does it make sense to generalize further? One would presumably need to express Roland Speicher's work on multiplicative functions \cite{speicher} in the completely general case. See Problem \ref{prob:freeprobability}.
\end{remark}

\begin{remark}
Explain the theory of cluster algebras in infinite types. See Problem \ref{prob:infinitetypes}.
\end{remark}

\begin{remark}
 The most glaring case of this problem is the seeming dependence of $NN_W$ and its relatives on the crystallographic structure of $W$. When $W$ is a Weyl group, there are amazing enumerative correspondences with the other Catalan objects (see the remarks following Problem \ref{central:one}). But there is currently no idea how to generalize these objects to the noncrystallographic types.

To what extent can the nonnesting partitions and root order be generalized to noncrystallographic types? Presumably, there are objects which can not be generalized in their current form, such as Lie algebras and affine hyperplane arrangements. Generalize where possible, and explain where there are essential barriers to this generalization. Cathy Kriloff and Arun Ram have dealt with some of these issues in studying the representation theory of noncrystallographic types \cite{kriloff-ram}.

Fr\'ed\'eric Chapoton's conjecture gives a way to define the $H$-triangle for all finite Coxeter groups \cite{chapoton:two}. What object is it counting in the noncrystallographic types?
\end{remark}

\end{problemblock}

\begin{problemblock}

\begin{problem}
\label{central:three}
What are the most natural generalizations of the families $NC_W$, $NN_W$, and $\Delta_W$? Classical combinatorics is full of enumerative generalizations of the Catalan numbers. Which of these is relevant in the reflection group setting?
\end{problem}

Define the {\sf Fuss-Catalan numbers}
\begin{equation*}
\Cat^{(k)}(W):= \prod_{i=1}^n \frac{kh+e_i+1}{e_i+1},
\end{equation*}
where $k$ is a positive integer. In type $A$, these generalize the classical Fuss numbers and the Catalan numbers \cite{fomin-reading,hilton-pederson}. As seen from the formula, $\Cat^{(k)}(W)$ is a very natural generalization of the Catalan numbers in the reflection group context. Recently these numbers  have shown up in all three of the Catalan families.

\begin{remark}
Drew Armstrong has defined a generalization of the noncrossing partitions $NC_W^{(k)}$, called the {\sf $k$-divisible noncrossing partitions} \cite{armstrong}. This is a graded join-semilattice which is counted by $\Cat^{(k)}(W)$. Call the rank numbers the {\sf Fuss-Narayana numbers}. In types $A$ and $B$, $NC_W^{(k)}$ is isomorphic to the poset of $k$-divisible noncrossing set partitions (partitions in which each block has size divisible by $k$).
\end{remark}

\begin{remark}
Sergey Fomin and Nathan Reading have defined a simplicial complex $\Delta^{(k)}_W$ which is a generalization of the simplicial associahedron \cite{fomin-reading}. The facets of $\Delta^{(k)}_W$ are counted by the Fuss-Catalan numbers, and the entries of the $h$-vector are given by the Fuss-Narayana numbers. In types $A$ and $B$, this complex is defined in terms of $(k+2)$-angulations of a regular polygon, and has been studied independently by Eleni Tzanaki \cite{tzanaki}.
\end{remark}

\begin{remark}
The Fuss-Catalan numbers appear in many places in the $NN_W$ family of objects. Let $W$ be a finite Weyl group. Christos Athanasiadis suggested the definition of the Fuss-Narayana numbers in this context, and proved that these numbers count several objects, including positive regions in a certain affine deformation of the Coxeter hyperplane arrangement, as well as co-filtered multichains of ideals in the root order \cite{athanasiadis:cat,athanasiadis:nar}. Mark Haiman has shown that the Fuss-Catalan numbers count orbits in the quotient $\check{Q}/(kh+1)\check{Q}$ of the coroot lattice $\check{Q}$ \cite{haiman:conjectures}, and Eric Sommers has encountered these numbers in the study of Lie algebras \cite{sommers}.
\end{remark}
\end{problemblock}

\begin{problemblock}
\begin{problem}
Repeat Problems \ref{central:one} and \ref{central:two} in this more general setting. Any theoretical relationships found between $NC_W$, $NN_W$, and $\Delta_W$, must generalize to explain the Fuss-Catalan combinatorics. Given that $\Cat^{(k)}(W)$ is naturally defined in terms of the exponents of $W$, is there an underlying algebraic framework that explains these numbers?
\end{problem}

\begin{remark}
Extend Fr\'ed\'eric Chapoton's $M$-triangle, $F$-triangle, and $H$-triangle to the Fuss-Catalan case. (Eleni Tzanaki has worked on this for the $H$-triangle.)
\end{remark}

\begin{remark}
What is the significance of these Fuss-Catalan objects in applications, for instance in Garside Structures, cluster algebras, or free probability? For example, the $k$-divisible noncrossing partitions may have some application to Problem \ref{prob:kdivisible}, in free probability.
\end{remark}

\begin{remark}
Is there a natural generalization of the poset of nonnesting partitions $NN^{(k)}_W$? In type $A$, one may take $k$-divisible nonnesting set partitions under refinement (mimicking $NC_{A_{n-1}}^{(k)}$). In the general case, perhaps this is isomorphic to a partial order on co-filtered multichains of ideals in the root order.
\end{remark}

\begin{remark}
Christos Athanasiadis and Stavros Garoufallidis have suggested a $q$-version of the Catalan combinatorics. See Problem \ref{prob:qcat} below.
\end{remark}

\end{problemblock}

\section{Enumerative Combinatorics}

Define the {\sf $q$-Fuss-Catalan numbers}
\begin{equation}\label{eq:qcat}
q\text{-\Cat}^{(k)}(W):= \prod_{i=1}^n \frac{[kh+e_i+1]_q}{[e_i+1]_q},
\end{equation}
where $[n]_q=q+q^2+\cdots + q^n$ is the usual $q$-analogue of the positive integer $n$.

\begin{problemblock}
\begin{problem}\label{prob:qcat} Show that $q\text{-\Cat}^{(k)}(W)$ is a polynomial in $q$ with nonnegative integer coefficients.\end{problem}

This is known in the classical $A$, $B$, and $D$ cases. In type $A$ with $k=1$, this coincides (up to a power of $q$) with the $q,t$-Catalan number of Adriano Garsia and Mark Haiman \cite{garsia-haiman}, with the specialization $t=1/q$.

\begin{remark}
\by{D. Bessis} Does the same statement hold when $W$ is a complex finite reflection group, with the fundamental degrees $d_i$ subsituted for the $e_i+1$, and the highest degree substituted for $h$?
\end{remark}

\begin{remark}
\by{V. Reiner} Conjecture: Let $c$ be a Coxeter element of $W$, and let $\zeta$ be a primitive $d$th root of unity, where $d$ divides the Coxeter number $h$. Then $\zeta\text{-\Cat}^{(1)}(W)$ is the number of elements of $NC_W=[1,c]$ that are invariant under conjugation by $c^{h/d}$.
\end{remark}

\begin{remark}
\by{S. Fomin, V. Reiner} Are there corresponding $q$-analogues of other Catalan statistics? For instance, is the expression
\begin{equation*}
q\text{-\Cat}^{(k)}_+(W):=\prod_{i=1}^n \frac{[kh+e_i-1]_q}{[e_i+1]_q}
\end{equation*}
also a polynomial in $q$ with nonnegative integer coefficients? Is there a refinement of $q\text{-\Cat}^{(k)}(W)$ as a sum of polynomials in $q$ with nonnegative integer coefficients, generalizing the $q=1$ refinement by Fuss-Narayana numbers?
\end{remark}

\begin{remark}
Can one extend Fr\'ed\'eric Chapoton's $M$-triangle, $F$-triangle, and $H$-triangle to the $q$-Fuss-Catalan case?
\end{remark}

\end{problemblock}

\begin{problemblock}

\begin{problem}
\by{C. Kriloff, V. Reiner} This is a possible systematic approach to Problem \ref{prob:qcat}. As mentioned, in type $A$ with $k=1$, the numbers \eqref{eq:qcat} correspond (up to a power of $q$, and specialized at $t=1/q$) with the $q,t$-Catalan numbers of Garsia and Haiman, which are given by the $q,t$-bigraded Hilbert series for the sign-isotypic component of the ring of diagonal harmonics $\C[V\oplus V]/(\C[V\oplus V]_+^W)$ \cite{haiman}. Can this situation be generalized to other $W$?
\end{problem}

When $W$ is a symmetric group $A_{n-1}$, it is known that the action of $W$ on the (ungraded) diagonal harmonics has the same irreducible decomposition as the action of $W$ on the ``finite torus'' $Q/(h+1)Q$, where $Q$ is the root lattice. Mark Haiman noted that this does not hold in type $B$ \cite{haiman}. However, Iain Gordon has shown that the problem may be feasible for general $W$, since it is possible to take a further quotient which does give the right combinatorics \cite{gordon}.

\end{problemblock}

\begin{problemblock}
 The following are two elementary combinatorial facts, for which it would be nice to have elementary explanations. Both problems are unique to type $B$, and concern centrally symmetric structures on polygons (structures that are invariant under the antipodal map).

\begin{problem}
\by{S. Fomin} Among the centrally symmetric partial $(k+2)$-angulations of a regular $(2kn+2)$-gon containing $i$ orbits (under the antipodal map) of $k$-admissible chords \cite{fomin-reading,tzanaki}, the proportion that contain a diameter is $i/n$. (A $k$-admissible chord is one that may be present in a full $(k+2)$-angulation.) Give an elementary proof.
\end{problem}
\end{problemblock}

\begin{problemblock}
\begin{problem}
 \by{D. Armstrong} Among the centrally symmetric $k$-divisible noncrossing partitions of a $2kn$-gon with $i$ orbits (under the antipodal map) of nonzero blocks \cite{armstrong, reiner}, the proportion that contain a zero block is $i/n$. (A zero block is a block that contains a diameter.) Give an elementary proof.
\end{problem}

\begin{remark}
 These problems are strikingly similar. The first is a statement about the $f$-numbers of the complex $\Delta_{B_n}^{(k)}$ \cite{fomin-reading}, and the second is a statment about the $h$-numbers of this complex. The similarity between these problems, and the fact that they both have been resistant to elementary proofs, suggests that there may be some connection. However, no connection between $\Delta_{B_n}^{(k)}$ and $NC_{B_n}^{(k)}$ is currently known. (See Problem \ref{central:three}.)
\end{remark}

\end{problemblock}

\begin{problemblock}
\by{H.T. Hall} Suppose that a stream has $2n$ bridges across it. A classical {\sf meander} is (the homotopy class of) a closed path which crosses each bridge once without intersecting itself. On each side of the stream, the  meander is given by a noncrossing pairing of the set $[2n]:=\{1,2,\ldots,2n\}$. Noncrossing pairings are naturally in bijection with type $A$ noncrossing partitions of the set $[n]$.

Every ordered pair of noncrossing partitions defines a path (with possibly multiple components) which crosses each bridge exactly once. There is a bijection which says that the meanders (the paths with only one connected component) correspond exactly to pairs of noncrossing partitions that are maximally separated in the Hasse diagram of $NC_{A_{n-1}}$ (they are diameters in the graph theoretical sense).

\begin{problem}
 Does this bijection suggest a new way to count meanders?
\end{problem}
\end{problemblock}

\begin{problemblock}
\begin{problem}
One may also use this bijection to define meanders of type $W$ (they are the ordered diameters of the Hasse diagram of $NC_W$). Is there some combinatorial object that this corresponds to? Is there a type $B$ meander?
\end{problem}

\begin{remark}
\by{A. Nica, J. Scott} In type $A$, one may build a ``meander determinant'' which is known to factor as a product of Chebyshev polynomials \cite{difrancesco}. Similarly, one may define a type $W$ meander determinant. What factorization properties does it have?

Meanders are related to chromatic polynomials of graphs, and the Temperley-Lieb algebra \cite{cautis-jackson}. What is the significance of type $W$ meanders in this context?
\end{remark}

\end{problemblock}

\section{Reflection Groups}

\begin{problemblock} Let $W$ be a finite Coxeter group, and let $T$ be the generating set of all reflections, as in Section \ref{sec:central}. Again, let $\ell$ denote the word length on $W$ with respect to $T$. This is often called the {\sf absolute length} on $W$. In general, for all $u,v$ in $W$, we have the triangle inequality $\ell(uv)\leq \ell(u)+\ell(v)$.

Define the {\sf absolute length poset}, as before, by setting $a\leq b$ whenever $\ell(b)=\ell(a)+\ell(a^{-1}b)$. This is a partial order on $W$ whose Hasse diagram is the Cayley graph of $W$ with respect to $T$. The poset is graded with rank function given by $\ell$.

\begin{problem} \by{V. Reiner}
What is the topology of this poset? In types $A$ and $B$ is there an $EL$-labelling which exhibits a shelling of the order complex?
\end{problem}

 It is known that the absolute length poset is not shellable in type $D$. Perhaps this can be fixed in a uniform way by considering only the subposet which is the order ideal of parabolic Coxeter elements (elements of $W$ which are a Coxeter element in some parabolic subgroup)

\begin{remark} The noncrossing partitions $NC_W$ are defined as an interval in the absolute length poset. Recent work of Brady and Watt \cite{brady-watt} seems to give an $EL$-labelling for $NC_W$. Do their methods generalize to the problem above?\end{remark}

\end{problemblock}

\begin{problemblock}Let $W$ be a finite Coxeter group. In \cite{reading}, Nathan Reading defines the notion of {\sf Coxeter-sortability} for elements of $W$, relative to some Coxeter element $c$.

There are natural maps $nc$ and $cl$ from the Coxeter-sortable elements of $W$ to the noncrossing partitions $NC_W$, and to the set of clusters of type $W$, respectively. In \cite{reading}, these maps are concretely defined, but the proof that they are bijections is case-by-case, using the fact that both objects are known to be counted by the Catalan number $\Cat(W)$.

\begin{problem}\by{N. Reading}\label{prob:c-sorted}
\begin{enumerate}
\item Give a uniform proof that the Coxeter-sorted elements are counted by $\Cat(W)$.
\item Give a uniform proof that the map $nc$ is well-defined.
\item Give a uniform proof that the maps $nc$ and $cl$ are bijections.
\item The notion of Coxeter-sortable elements, and the maps $nc$ and $cl$ can be defined for infinite type Coxeter groups. What happens in this case?
\end{enumerate}

\end{problem}

\end{problemblock}

\begin{problemblock}
\by{D. Bessis, F. Chapoton}

The Lyashko-Looijenga mapping associates to any complex-valued function on a manifold the polynomial in one variable whose roots are the critical values of the function. The main theorem in \cite{looijenga} states that this mapping is a ramified covering for some families of functions. There is a known relationship between the Lyashko-Looijenga covering of the complex sphere, and the combinatorial cacti of Ian Goulden and David Jackson \cite{goulden-jackson}.

Interpret the combinatorics of the type $A$ noncrossing partitions in terms of the Lyashko-Looijenga covering of the sphere. The degree of the covering is $n^{n-2}$, which is also the number of maximal chains in $NC_{A_{n-1}}$. This number is known to count many things, including labelled trees, and cacti.

\begin{problem}Do these combinatorics generalize to other types?\end{problem}

\end{problemblock}

%here is an example of a problem with no associated lead-in or comments.
%the \begin{problemblock} and \end{problemblock} have been omitted.
%The pre-processor needs to add that in automatically
\begin{problem}
\by{D. Bessis}
Is there a structure theory of Lie groups and algebraic groups that is analogous to the dual braid monoid \cite{bessis:dual}? Is there some dual notion of $BN$-pairs?
\end{problem}

\section{Garside Structures}
As mentioned, the lattice of noncrossing partitions $NC_W$ in its full generality was defined by David Bessis \cite{bessis:dual} and Tom Brady \cite{brady} in order to study the Artin group $\A(W)$ corresponding to the Coxeter group $W$. It turns out that the properties of the poset $NC_W$ have many consequences for the group theory, including a nice algorithmic solution to the word and conjugacy problems.

In general, every poset $P$ together with a labelling of the edges in its Hasse diagram generates a monoid $M(P)$ and a group $G(P)$. When this labelling has certain properties, $P$ is called a {\sf combinatorial Garside structure}. Having such a Garside structure gives a powerful tool for studying the monoid $M(P)$ and the group $G(P)$. This is an emerging subject with interest to combinatorics and group theory. The survey article \cite{mccammond:garside} by Jon McCammond gives a good introduction to these topics.

%missing problemblock
\begin{problem} \by{R. Charney} Questions about classification.
\begin{enumerate}
\item Given an arbitrary poset $P$, when can it be given a Garside labelling? When such a labelling exists, say that $P$ is a {\sf Garside poset}.
\item Given a Garside poset $P$, what are the relationships between its inequivalent Garside labellings? When does $P$ have a unique Garside labelling?
\item Given a poset with an edge labelling, when can this be embedded in a Garside structure? When do the corresponding monoids/groups embed? What are the minimal obstructions to doing this?
\end{enumerate}
\end{problem}

%missing problemblock
\begin{problem} \by{P. Dehornoy}
\begin{enumerate}
\item Given a cancellative, finitely-generated monoid $M$ in which lcm's exist, is $M$ necessarily a Garside monoid? That is, does there exist a Garside element $\Delta$ in $M$?
\item In the case of Artin groups, the nicest Garside structures come from the Cayley graph of the corresponding Coxeter group. Is there a way to systematize this? Is there some notion of a ``Coxeter group'' corresponding to each Garside group?
\item Let $M$ be a Garside monoid with Garside element $\Delta$, and let $\ell$ be a length on $M$ ($M$ is atomic). Is it always true that $\ell(\Delta^k)\leq Ck\left|\Delta\right| $ for some constant $C$?
\end{enumerate}
\end{problem}

\begin{problemblock}
\by{J. McCammond}
In general, the most difficult property of a Garside structure to establish is the lattice property. Call an edge-labelled poset a {\sf quasi-Garside structure} if it satisfies all properties except the lattice property.

There is a large natural source of quasi-Garside structures. Let $G$
be a group, generated by a finite, conjugate-closed generating set
$T$. Then any interval in the Cayley graph of $G$ with respect to $T$
is a quasi-Garside structure. Many of these have the lattice property,
and many do not.

%another example of a problem that requires its lead-in text in order
%to make sense
\begin{problem}
Are there natural conditions on $G$ and $T$ that imply
the lattice property? Find a natural class of these posets in which the
presence or absence of the lattice property can be explained.
\end{problem}

\begin{remark}
Tom Brady and Colum Watt \cite{brady-watt} have recently given a uniform proof that the noncrossing partitions $NC_W$ are lattices. Their proof depends on the realization of $W$ as a real reflection group. Is there a class of quasi-Garside structures in which the lattice property can be seen only to depend on the group structure?
\end{remark}
\end{problemblock}

\begin{problemblock}\by{D. Armstrong}As above, let $G$ be a group generated by $T$, where $T$ is finite and closed under conjugation. Then every interval in the Cayley graph of $(G,T)$ is a locally self-dual poset (every interval in the poset is self-dual).

In particular, to each element $g$ of $G$, associate the poset $P_g$ which is the interval $[1,g]$ in the Cayley graph of $(G,T)$. Note that $P_g$ and $P_h$ are isomorphic whenever $g$ and $h$ are conjugate. Now, associate to each $P_g$ its {\sf Ehrenborg quasisymmetric function}
\begin{equation*}
F(P_g):= \sum_k \sum_{1\leq g_0\leq g_1\leq\cdots\leq g_k\leq g} x_1^{\ell(g_0^{-1}g_1)}x_2^{\ell(g_1^{-1}g_2)}\cdots x_k^{\ell(g_{k-1}^{-1}g_k)}.
\end{equation*}
It is known that the Ehrenborg function of a self-dual poset must, in fact, be a symmetric function (see \cite{stanley}). So $F$ is a map from conjugacy classes of $G$ to the ring of symmetric functions

\begin{problem}What is the structure of this map? Does it preserve some Hopf algebra structure?\end{problem}

\end{problemblock}

\section{Free Probability}
Free probability, initiated by Dan Voiculescu, is a subject in functional analysis which has been used successfully to study von Neumann algebras. It is a noncommutative analogue of probability in which the role of random variables is played by operators in some $*$-algebra (typically a $C^*$-algebra). The theory naturally describes the asymptotics of large random matrices, as well as the asymptotics of representations of large symmetric groups.

Roland Speicher showed that the combinatorics of free probability is governed by the lattice of type $A$ noncrossing partitions, in a role which is analogous to the role played by the lattice of unrestricted set partitions in classical probability. Many of the natural transforms on free algebras of random variables can be understood in terms of M\"{o}bius inversion in the incidence algebra of $NC_{A_{n-1}}$. See the survey \cite{speicher:survey} for more information.

\begin{problemblock} \label{prob:freeprobability}\by{F. Goodman, P. Sniady} Philippe Biane, Fred Goodman, and Alexandru Nica have defined a type $B$ analogue of free probability \cite{biane-goodman-nica}. The definition has been motivated by the combinatorics, and there is currently no model of this theory (as the large random matrices are a model for type $A$ free probability).

\begin{problem}
Find a natural model for type $B$ free probability, which motivates the combinatorics. Is there a corresponding notion of free probability in other types?
\end{problem}

\begin{remark} Many of the formulas of free probability depend on the fact that there is an infinite sequence of type $A$ noncrossing partition lattices $NC_{A_{n-1}}$, including, in particular, the formulas involving multiplicative functions \cite{speicher}. Type $B$ multiplicative functions were described by Vic Reiner \cite{reiner}. Is it possible to say something about free probability for an exceptional type $W$, where there is no infinite sequence?
\end{remark}

\end{problemblock}

\begin{problemblock} \by{A. Nica}
Let $(\A,\varphi)$ be a $*$-probability space. That is, $\A$ is some $*$-algebra, and $\varphi$ is a linear functional on $\A$ which plays the role of ``expectation''. Let $\C_0\langle\langle z_1,\ldots,z_s\rangle\rangle$ denote the set of power series in $s$ noncommuting variables which have zero constant term. For each $s$-tuple of elements $a_1,,\ldots,a_s$ in $\A$, there is a function $R_{a_1,\ldots,a_s}$ called the  {\sf $R$-transform}, which is an element of $\C_0\langle\langle z_1,\ldots,z_s\rangle\rangle$. See \cite{nica-speicher:ntuples} for details.

There is a unique binary operation $\freestar_s$ defined on $\C_0\langle\langle z_1,\ldots,z_s\rangle\rangle$ with the property that for any two families $\{a_1,\ldots,a_s\}$ and $\{b_1,\ldots,b_s\}$ of freely independent random variables, we have
\begin{equation*}
R_{a_1,\ldots,a_s}\,\freestar_s\, R_{b_1,\ldots,b_s} = R_{a_1b_1,\ldots,a_sb_s}.
\end{equation*}
The operation $\freestar_s$ is associative, and has a unit $\Delta_s(z_1,\ldots,z_s):= z_1+\cdots +z_s$. In \cite{nica-speicher:ntuples}, Alexandru Nica and Roland Speicher show that, in general, the coefficients of $f\,\freestar_s \,g$ can be described combinatorially, using a summation over noncrossing partitions of type $A$.

\begin{problem}
Describe the structure of the group of
invertible elements in the
semigroup
$( \C_0\langle\langle z_1,\ldots,z_s\rangle\rangle,\freestar_s )$.\end{problem}

\begin{remark}
The answer is known in the case $s=1$. This is the only value of $s$ for which $\freestar_s$ is commutative. Here, $\C_0\langle\langle z_1,\ldots,z_s\rangle\rangle$ is just $\C_0[[z]]$, the set of power series with zero constant term. In \cite{nica-speicher:fourier}, Nica and Speicher define an isomorphism $\F$ (the {\sf free Fourier transform}) between the group of invertible elements in $(\C_0[[z]], \freestar_1)$ and the group of invertible elements in $(\C_0[[z]], \cdot)$, under the usual multiplication of power series.
\end{remark}

\begin{remark}In the case $s=1$, the map $\F$ provides a connection between the $R$-transform and the {\sf $S$-transform} of Voiculescu. More precisely, we have $\F(R_a)=S_a$ for any element $a\in\A$ such that $\varphi(a)\neq 0$.

As mentioned, there is a version of the $R$-transform when $s>1$, but it is not known how to define an $S$-transform in this case. Find a multi-variable version of the $S$-transform. One way to approach this problem would be to find an analogue of the map $\F$ in this case.
\end{remark}

\end{problemblock}

\begin{problemblock}
\begin{problem} \label{prob:kdivisible}\by{A. Nica} Let $u$ be a unitary element of a $*$-probability space $(\A,\varphi)$. Suppose $u$ has order $k$ and that $\varphi(u^i)=0$ for $1\leq i< k$. Let $\kappa_n$ denote the multilinear cumulant functionals of $(\A,\varphi)$.

Give a combinatorial way to compute the cumulants in $u$ and $u^*$. Equivalently, give a formula for the $R$-transform of $(u,u^*)$.
\end{problem}

\begin{remark} The answer is known for $k=2$ and $k=\infty$. When $k=2$, the only nonvanishing cumulants are given by the Catalan numbers $\kappa_{2n}(u,u,\ldots,u)=(-1)^{n-1} \Cat(A_{n-1})$. When $k=\infty$, the only nonvanishing cumulants are of the form
\begin{equation*}
\kappa_{2n}(u,u^*,\ldots,u,u^*)\quad\text{or}\quad \kappa_{2n}(u^*,u,\ldots,u^*,u),
\end{equation*}
 and these are both equal to $(-1)^{n-1}\Cat(A_{n-1})$.
\end{remark}
\begin{remark} The cumulants may be expressed as a sum over noncrossing set partitions
\begin{equation*}
\kappa_n = \sum_{\substack{\pi\in NC_n\\ \pi=\{A_1,A_2,\ldots,A_t\}}} \alpha(\pi) \varphi_{A_1}\varphi_{A_2}\cdots \varphi_{A_t}.
\end{equation*}
For finite $k$, and with $u$ as above, the only nonvanishing terms in this sum come from the $k$-divisible noncrossing partitions.
\end{remark}

\end{problemblock}

\section{Cluster Algebras and Associahedra}
\label{sec:cluster}
Cluster algebras were defined by Sergey Fomin and Andrei Zelevinsky to study the phenomena of total positivity and dual canonical bases in semisimple Lie groups. In \cite{fomin-zelevinsky:finitetype} they show that the finite type cluster algebras are described by the Cartan-Killing classification.

Each cluster algebra has an associated simplicial complex, called the {\sf cluster complex} $\Delta_W$. As before, let $\Phi$ be a (crsytallographic) root system with Weyl group $W$, and let $\Phi^+$ and $\Pi$ be a corresponding choice of positive roots and simple roots, respectively. In \cite{fomin-zelevinsky:ysystems}, Fomin and Zelevinsky define a binary relation on the set of almost positive roots $\Phi_{\geq -1}= \Phi^+ \cup (-\Pi)$, called {\sf compatibility}. Then $\Delta_W$ is defined as the flag complex of pairwise compatible subsets of $\Phi_{\geq -1}$. In types $A$ and $B$, they show that these complexes generalize (the duals of) the classical associahedron and cyclohedron. The number of facets of $\Delta_W$ for finite type $W$ is the Catalan number $\Cat(W)$, and the $h$-vector of the complex is given by the Narayana numbers.

When $W$ is a noncrystallographic finite Coxeter group, there is no associated cluster algebra, but the complex $\Delta_W$ can still be defined as a flag complex on the almost positive roots of the corresponding (noncrystallographic) root system, and this complex obeys the same Catalan numerology. However, the only known polytopal realization of the type $W$ associahedron (given by Chapoton, Fomin and Zelevinsky in \cite{chapoton-fomin-zelevinsky}) does not generalize to this case.

For more on the combinatorics of cluster algebras and associahedra, see the notes \cite{fomin-reading:survey}.

\begin{problemblock}
\begin{problem} \label{prob:polytopal}\by{H. Thomas, A. Zelevinsky} When $W$ is a noncrystallographic finite Coxeter group, give a geometric construction that realizes $\Delta_W$ as a convex polytope. \end{problem}There is a realization of $\Delta_W$ in all types as a complete simplicial fan, but it is not clear whether this fan is polytopal in the noncrystallographic types.

\end{problemblock}

\begin{problem} \by{A. Zelevinsky}
In the classical types ($A$, $B$, $C$, and $D$), the associahedron $\Delta_W$ has a visually transparent realization in terms of regular plane polygons and their triangulations. Find a similar interpratation in the exceptional types.
\end{problem}

\begin{problemblock}
\begin{problem} \by{S. Fomin} Conjecture: The Fomin-Reading generalization of the associahedron $\Delta_W^{(k)}$ (see Problem \ref{central:three}) is Cohen-Macaulay, and is homotopy equivalent to a wedge of
\begin{equation*}
\Cat^{(k-1)}(W)=\prod_{i=1}^n \frac{(k-1)h +e_i +1}{e_i+1}
\end{equation*}
spheres. This has been proved by Eleni Tzanaki in types $A$ and $B$  using shelling methods \cite{tzanaki}.

Moreover, $\Delta_W^{(k)}$ seems to be the skeleton of a polytopal manifold. Can this be realized geometrically? (This generalizes Problem \ref{prob:polytopal} above.)
\end{problem}

\begin{remark}\by{V. Reiner} Is the Fomin-Reading complex $k$-Cohen-Macaulay in the sense of Baclawski \cite{baclawski}?\end{remark}

\end{problemblock}

\begin{problemblock}

\begin{problem} \by{D. Bessis, C. Kriloff}
There is no construction of a cluster algebra in the noncrystallographic finite types.
What happens when one applies matrix mutations to the Cartan matrix of a noncrystallographic finite Coxeter group? Are there recurrences?
\end{problem}

\begin{remark}\by {N. Reading, D. Speyer} Early calculations suggest that there are ``approximate'' recurrences, that one returns {\em close to, but bounded away from} the original matrix.
\end{remark}

\end{problemblock}

\begin{problemblock}
\begin{problem}\label{prob:infinitetypes} \by{A. Zelevinsky} Describe a classification of infinite type cluster algebras as tame or wild. This should generalize the notions of tame/wild Artin groups, tame/wild quivers, etc.
\end{problem}

\begin{remark} Affine types are certainly tame. \end{remark}

\end{problemblock}

\begin{thebibliography}{99}

\bibitem{armstrong}
D. Armstrong, \emph{$k$-Divisible noncrossing partitions for Coxeter groups}, in preparation.

\bibitem{athanasiadis:cat}
C. Athanasiadis, \emph{Generalized Catalan numbers, Weyl groups and arrangements of hyperplanes}, Bull. London Math. Soc. {\bf 36} (2004), 294--302.

\bibitem{athanasiadis:nar}
C. Athanasiadis, \emph{On a refinement of the generalized Catalan numbers for Weyl groups}, Trans. Amer. Math. Soc. {\bf 357} (2005), 179--196.

\bibitem{athanasiadis-reiner}
C. Athanasiadis and V. Reiner, \emph{Noncrossing partitions for the group $D_n$}, SIAM J. Discrete Math. {\bf 18} (2004), 397--417.

\bibitem{baclawski}
K. Baclawski, \emph{Cohen-Macaulay connectivity and geometric lattices}, Europ. J. Combin. {\bf 3} (1982), 293--305.f

\bibitem{bessis:dual}
D. Bessis, \emph{The dual braid monoid}, Ann. Sci. \'Ecole Norm. Sup. {\bf 36} (2003), 647--683.

\bibitem{bessis:complex}
D. Bessis, \emph{Topology of complex reflection groups}, \texttt{math.GT/0411645}, 2004.

\bibitem{bessis-corran}
D. Bessis and R. Corran, \emph{Non-crossing partitions of type $(e,e,r)$}, \texttt{math.GR/0403400}, 2004.

\bibitem{biane}
P. Biane, \emph{Some properties of crossings and partitions}, Discrete Math. {\bf 175} (1997), 41--53.

\bibitem{biane-goodman-nica}
P. Biane, F. Goodman and A. Nica, \emph{Non-crossing cumulants of type $B$}, Trans. Amer. Math Soc. {\bf 355} (2003), 2263--2303.

\bibitem{mccammond-etal}
N. Brady, J. Crisp, A. Kaul, and J. McCammond, \emph{Factoring isometries, poset completions and Artin groups of affine type}, in preparation.

\bibitem{brady}
T. Brady, \emph{A partial order on the symmetric group and new $K(\pi,1)$'s for the braid groups}, Advances in Math. {\bf 161} (2002), 20--40.

\bibitem{brady-watt:kpi1}
T. Brady and C. Watt, \emph{$K(\pi,1)$'s for Artin groups of finite type}, in {\emph Proceedings of the Conference on Geometric and Combinatorial group theory, part I (Haifa 2000)}, Geom. Dedicata {\bf 94} (2002), 225--250.

\bibitem{brady-watt}
T. Brady and C. Watt, \emph{Lattices in finite real reflection groups}, \texttt{math.CO/0501502}, 2005.

\bibitem{cautis-jackson}
S. Cautis, and D.M. Jackson, \emph{The matrix of chromatic joins and the Temperley-Lieb algebra}, J. Combin. Theory Ser. B {\bf 89} (2003), 109--155.

\bibitem{cellini-papi}
P. Cellini and P. Papi, \emph{ad-nilpotent ideals of a Borel subalgebra II}, J. Algebra {\bf 258} (2002), 112--121.

\bibitem{chapoton:one}
F. Chapoton, \emph{Enumerative properties of generalized associahedra}, S\'eminaire Lotharingien de Combinatoire {\bf 51} (2004), Article B51b.

\bibitem{chapoton:two}
F. Chapoton, \emph{Sur le nombre de reflexions pleines dans les groupes de Coxeter finis}, \texttt{math.RT/0405371}, 2004.

\bibitem{chapoton-fomin-zelevinsky}
F. Chapoton, S. Fomin, and A. Zelevinsky, \emph{Polytopal realizations of generalized associahedra}, Canad. Math. Bull. {\bf 45} (2002), 537--566.

\bibitem{difrancesco}
P.  DiFrancesco, \emph{Folding and coloring problems in mathematics and physics}, Bull.  Amer. Math. Soc. {\bf 37} (2000), 251--307.

\bibitem{fomin-reading}
S. Fomin and N. Reading, \emph{Generalized cluster complexes and Coxeter combinatorics}, in preparation.

\bibitem{fomin-reading:survey}
S. Fomin and N. Reading, \emph{Root systems and generalized associahedra}, lecture notes for the IAS/Park City Graduate Summer School in Combinatorics, 2004.

\bibitem{fomin-zelevinsky:finitetype}
S. Fomin and A. Zelevinsky, \emph{Cluster algebras II: finite type classification}, Invent. Math. {\bf 154} (2003), 63-121.

\bibitem{fomin-zelevinsky:ysystems}
S. Fomin and A. Zelevinsky, \emph{$Y$-systems and generalized associahedra}, Math. Ann. {\bf 158} (2003), 977-1018.

\bibitem{garsia-haiman}
A.M. Garsia and M. Haiman, \emph{A remarkable $q,t$-Catalan sequence and $q$-Lagrange inversion}, J. Algebraic Combin. {\bf 5} (1996), 191-244.

\bibitem{gordon}
I. Gordon, \emph{On the quotient ring by diagonal harmonics}, \texttt{math.RT/0208126}, 2002.

\bibitem{goulden-jackson}
I.P. Goulden and D.M. Jackson, \emph{The combinatorial relation between trees, cacti, and certain connection coefficients for the symmetric group}, Europ. J. Comin. {\bf 13} (1992), 357--365.

\bibitem{haiman:conjectures}
M. Haiman, \emph{Conjectures on  on the quotient ring by diagonal invariants}, J. Algebraic Combin. {\bf 3} (1994), 17--76.

\bibitem{haiman}
M. Haiman, \emph{Vanishing theorems and character formulas for the Hilbert scheme of points in the plane}, Inv. Math. {\bf 149} (2002), 371--407.

\bibitem{hilton-pederson}
P. Hilton and J. Pederson, \emph{Catalan numbers, their generalization and their uses}, Math. Int. {\bf 13} (1991), 64--75.

\bibitem{humphries}
J. E. Humphreys, \emph{Reflection Groups and Coxeter Groups}, Cambridge Studies in Advanced Mathematics, vol. 29 (Cambridge Univ. Press, Cambridge, 1990).

\bibitem{kreweras}
G. Kreweras, \emph{Sur les partitions non crois\'ees d'un cycle}, Discrete Math. {\bf 1} (1972), 333--350.

\bibitem{kriloff-ram}
C. Kriloff and A. Ram, \emph{Noncrystallographic Springer correspondences}, in preparation.

\bibitem{looijenga}
E. Looijenga, \emph{The complement of the bifurcation variety of a simple singularity}, Inv. Math. {\bf 23} (1974), 105--116.

\bibitem{mccammond:garside}
J. McCammond, \emph{An introduction to Garside structures}, survey, see \cite{mccammond:webpage}.

\bibitem{mccammond:noncrossing}
J. McCammond, \emph{Noncrossing partitions in surprising locations}, survey, see \cite{mccammond:webpage}.

\bibitem{mccammond:webpage}
J. McCammond, \emph{Associahedra and noncrossing partitions}, webpage, \verb+www.math.ucsb.edu/~jon.mccammond/associahedra/+.

\bibitem{nica-speicher:fourier}
A. Nica and R. Speicher, \emph{A `Fourier transform' for multiplicative functions on non-crossing partitions}, J. Algebraic Combin. {\bf 6} (1997), 141--160.

\bibitem{nica-speicher:ntuples}
A. Nica and R. Speicher, \emph{On the multiplication of free $n$-tuples of non-commutative random variables}, with an appendix {\em Alternative proofs for the type II free Poisson variables and for the free compression results} by D. Voiculescu, Amer. J. Math. {\bf 118} (1996) 799--837.

\bibitem{reading:cambrian}
N. Reading, \emph{Cambrian lattices}, \texttt{math.CO/0402086}, 2004.

\bibitem{reading}
N. Reading, \emph{Clusters, Coxeter-sortable elements and noncrossing partitions}, in preparation.

\bibitem{reiner}
V. Reiner, \emph{Non-crossing partitions for classical reflection groups}, Discrete Math. {\bf 177} (1997), 195--222.

\bibitem{shephard-todd}
G. C. Shephard and J. A. Todd, \emph{Finite unitary reflection groups}, Canad. J. Math. {\bf 6} (1954), 274--304.

\bibitem{shi}
J.-Y. Shi, \emph{The number of $\oplus$-sign types}, Quart. J. Math. Oxford {\bf 48} (1997), 375--390.

\bibitem{simion}
R. Simion, \emph{Noncrossing partitions}, Discrete Math. {\bf 217} (2000), 397--409.

\bibitem{sommers}
E. Sommers, \emph{$B$-stable ideals in the nilradical of a Borel subalgebra}, \texttt{math.RT/0303182}, 2003.

\bibitem{speicher:survey}
R. Speicher, \emph{Free probability theory and non-crossing partitions}, S\'eminaire Lotharingien de Combinatoire, {\bf 39} (1997), Article B39c.

\bibitem{speicher}
R. Speicher, \emph{Multiplicative functions on the lattice of non-crossing partitions and free convolution}, Math. Ann. {\bf 298} (1994), 611--628.

\bibitem{stanley}
R. Stanley, \emph{Flag-symmetric and locally rank-symmetric partially ordered sets}, Elec. J. Combin. {\bf 3} (1996), R6.

\bibitem{thomas}
H. Thomas, \emph{Tamari lattices and noncrossing partitions in type $B$ and beyond}, \texttt{math.CO/0311334}, 2003.

\bibitem{tzanaki}
E. Tzanaki, \emph{Polygon dissections and some generalizations of cluster complexes for the classical reflection groups}, \texttt{math.CO/0501100}, 2005.

\end{thebibliography}

\end{document}


text:
layout: shows/show
title: "New In Chrome"
description: "New In Chrome covers new developer features available in the latest stable release."
key_img: nic_rect.png
order: 4
---

redpajama_set_name: RedPajamaGithub


text:
/**
 * Adds a lovely dropdown menu to the green award button
 */
;(function (global, factory) {
    if (typeof define === 'function' && define.amd) {
        define(['jquery'], factory);
    } else if (typeof $script === 'function') {
        global.attachDropDown  = factory(jQuery);
        $script.done('awarder');
    }else {
        global.attachDropDown  = factory(jQuery);
    }
}(this, function($) {
    'use strict';

    var AwardBadge = function(options) {
        this.badges = options.badges;
        this.init('awardbadge', options, AwardBadge.defaults);
    };

    //inherit from Abstract input
    $.fn.editableutils.inherit(AwardBadge, $.fn.editabletypes.abstractinput);

    $.extend(AwardBadge.prototype, {
        render: function() {
            this.$input = this.$tpl.find('input');
            this.$list = this.$tpl.find('select');

            this.$list.empty();

            var fillItems = function($el, data) {
                if ($.isArray(data)) {
                    for (var i = 0; i < data.length; i++) {
                        if (data[i].children) {
                            $el.append(fillItems($('<optgroup>', {
                                label: data[i].text
                            }), data[i].children));
                        } else {
                            $el.append($('<option>', {
                                value: data[i].value
                            }).text(data[i].text));
                        }
                    }
                }
                return $el;
            };

            fillItems(this.$list, this.badges);
        },

        html2value: function(html) {
            return null;
        },

        value2str: function(value) {
            var str = '';
            if (value) {
                for (var k in value) {
                    str = str + k + ':' + value[k] + ';';
                }
            }
            return str;
        },

        str2value: function(str) {
            return str;
        },

        value2input: function(value) {
            if (!value) {
                return;
            }
            this.$input.filter('[name="badgeid"]').val(value.badgeid);
            this.$input.filter('[name="evidence"]').val(value.evidence);
        },

        input2value: function() {
            return {
                badgeid: this.$list.filter('[name="badgeid"]').val(),
                evidence: this.$input.filter('[name="evidence"]').val(),
            };
        },

        activate: function() {
            this.$input.filter('[name="badgeid"]').focus();
        },

        autosubmit: function() {
            this.$input.keydown(function(e) {
                if (e.which === 13) {
                    $(this).closest('form').submit();
                }
            });
        }
    });

    AwardBadge.defaults = $.extend({}, $.fn.editabletypes.abstractinput.defaults, {
        tpl: '
<select name="badgeid" class="form-control input-sm"></select>
' +
        '
' +
        '<input type="url" name="evidence" class="form-control input-sm" placeholder="Evidence (Optional)">
',
        inputclass: '',
        badges: []
    });

    $.fn.editabletypes.AwardBadge = AwardBadge;

    function attachDropDown (url) {
        $.ajax({
            method: 'GET',
            url: url
        }).done(function(ret) {
            $('#awardBadge').editable({
                name: 'title',
                title: 'Award Badge',
                display: false,
                highlight: false,
                placement: 'bottom',
                showbuttons: 'bottom',
                type: 'AwardBadge',
                value: ret[0],
                badges: ret,
                ajaxOptions: {
                    type: 'POST',
                    dataType: 'json',
                    contentType: 'application/json'
                },
                url: nodeApiUrl + 'badges/award/',
                params: function(params) {
                    // Send JSON data
                    return JSON.stringify(params.value);
                },
                success: function(data) {
                    document.location.reload(true);
                },
                pk: 'newBadge'
            });
        }).fail(
            $.osf.handleJSONError
        );
    };

    return attachDropDown;

}));

//userApiUrl + 'badges/json/'


text:
package com.intellij.vcs.log.graph.impl.print;

import consulo.logging.Logger;
import com.intellij.util.NullableFunction;
import com.intellij.util.SmartList;
import com.intellij.util.containers.ContainerUtil;
import com.intellij.util.containers.SLRUMap;
import com.intellij.vcs.log.graph.api.EdgeFilter;
import com.intellij.vcs.log.graph.api.LinearGraph;
import com.intellij.vcs.log.graph.api.elements.GraphEdge;
import com.intellij.vcs.log.graph.api.elements.GraphEdgeType;
import com.intellij.vcs.log.graph.api.elements.GraphElement;
import com.intellij.vcs.log.graph.api.elements.GraphNode;
import com.intellij.vcs.log.graph.api.printer.PrintElementManager;
import com.intellij.vcs.log.graph.utils.NormalEdge;
import javax.annotation.Nonnull;

import org.jetbrains.annotations.TestOnly;

import java.util.*;

import static com.intellij.vcs.log.graph.utils.LinearGraphUtils.*;

public class PrintElementGeneratorImpl extends AbstractPrintElementGenerator {
  @Nonnull
  private static final Logger LOG = Logger.getInstance(PrintElementGeneratorImpl.class);

  public static final int LONG_EDGE_SIZE = 30;
  private static final int LONG_EDGE_PART_SIZE = 1;

  private static final int VERY_LONG_EDGE_SIZE = 1000;
  private static final int VERY_LONG_EDGE_PART_SIZE = 250;
  private static final int CACHE_SIZE = 100;
  private static final boolean SHOW_ARROW_WHEN_SHOW_LONG_EDGES = true;
  private static final int SAMPLE_SIZE = 20000;

  @Nonnull
  private final SLRUMap<Integer, List<GraphElement>> myCache = new SLRUMap<>(CACHE_SIZE, CACHE_SIZE * 2);
  @Nonnull
  private final EdgesInRowGenerator myEdgesInRowGenerator;
  @Nonnull
  private final Comparator<GraphElement> myGraphElementComparator;

  private final int myLongEdgeSize;
  private final int myVisiblePartSize;
  private final int myEdgeWithArrowSize;
  private int myRecommendedWidth = 0;

  public PrintElementGeneratorImpl(@Nonnull LinearGraph graph, @Nonnull PrintElementManager printElementManager, boolean showLongEdges) {
    super(graph, printElementManager);
    myEdgesInRowGenerator = new EdgesInRowGenerator(graph);
    myGraphElementComparator = printElementManager.getGraphElementComparator();
    if (showLongEdges) {
      myLongEdgeSize = VERY_LONG_EDGE_SIZE;
      myVisiblePartSize = VERY_LONG_EDGE_PART_SIZE;
      if (SHOW_ARROW_WHEN_SHOW_LONG_EDGES) {
        myEdgeWithArrowSize = LONG_EDGE_SIZE;
      }
      else {
        myEdgeWithArrowSize = Integer.MAX_VALUE;
      }
    }
    else {
      myLongEdgeSize = LONG_EDGE_SIZE;
      myVisiblePartSize = LONG_EDGE_PART_SIZE;
      myEdgeWithArrowSize = Integer.MAX_VALUE;
    }
  }

  @TestOnly
  public PrintElementGeneratorImpl(@Nonnull LinearGraph graph,
                                   @Nonnull PrintElementManager printElementManager,
                                   int longEdgeSize,
                                   int visiblePartSize,
                                   int edgeWithArrowSize) {
    super(graph, printElementManager);
    myEdgesInRowGenerator = new EdgesInRowGenerator(graph);
    myGraphElementComparator = printElementManager.getGraphElementComparator();
    myLongEdgeSize = longEdgeSize;
    myVisiblePartSize = visiblePartSize;
    myEdgeWithArrowSize = edgeWithArrowSize;
  }

  public int getRecommendedWidth() {
    if (myRecommendedWidth <= 0) {
      int n = Math.min(SAMPLE_SIZE, myLinearGraph.nodesCount());

      double sum = 0;
      double sumSquares = 0;
      int edgesCount = 0;
      Set<NormalEdge> currentNormalEdges = ContainerUtil.newHashSet();

      for (int i = 0; i < n; i++) {
        List<GraphEdge> adjacentEdges = myLinearGraph.getAdjacentEdges(i, EdgeFilter.ALL);
        int upArrows = 0;
        int downArrows = 0;
        for (GraphEdge e : adjacentEdges) {
          NormalEdge normalEdge = asNormalEdge(e);
          if (normalEdge != null) {
            if (isEdgeUp(e, i)) {
              currentNormalEdges.remove(normalEdge);
            }
            else {
              currentNormalEdges.add(normalEdge);
            }
          }
          else {
            if (e.getType() == GraphEdgeType.DOTTED_ARROW_UP) {
              upArrows++;
            }
            else {
              downArrows++;
            }
          }
        }

        int newEdgesCount = 0;
        for (NormalEdge e : currentNormalEdges) {
          if (isEdgeVisibleInRow(e, i)) {
            newEdgesCount++;
          }
          else {
            RowElementType arrow = getArrowType(e, i);
            if (arrow == RowElementType.DOWN_ARROW) {
              downArrows++;
            }
            else if (arrow == RowElementType.UP_ARROW) {
              upArrows++;
            }
          }
        }

        int width = Math.max(edgesCount + upArrows, newEdgesCount + downArrows);

        sum += width;
        sumSquares += width * width;

        edgesCount = newEdgesCount;
      }

      double average = sum / n;
      double deviation = Math.sqrt(sumSquares / n - average * average);
      myRecommendedWidth = (int)Math.round(average + deviation);
    }

    return myRecommendedWidth;
  }

  @Nonnull
  @Override
  protected List<ShortEdge> getDownShortEdges(int rowIndex) {
    NullableFunction<GraphEdge, Integer> endPosition = createEndPositionFunction(rowIndex);

    List<ShortEdge> result = new ArrayList<>();
    List<GraphElement> visibleElements = getSortedVisibleElementsInRow(rowIndex);

    for (int startPosition = 0; startPosition < visibleElements.size(); startPosition++) {
      GraphElement element = visibleElements.get(startPosition);
      if (element instanceof GraphNode) {
        int nodeIndex = ((GraphNode)element).getNodeIndex();
        for (GraphEdge edge : myLinearGraph.getAdjacentEdges(nodeIndex, EdgeFilter.ALL)) {
          if (isEdgeDown(edge, nodeIndex)) {
            Integer endPos = endPosition.fun(edge);
            if (endPos != null) result.add(new ShortEdge(edge, startPosition, endPos));
          }
        }
      }

      if (element instanceof GraphEdge) {
        GraphEdge edge = (GraphEdge)element;
        Integer endPos = endPosition.fun(edge);
        if (endPos != null) result.add(new ShortEdge(edge, startPosition, endPos));
      }
    }

    return result;
  }

  @Nonnull
  private NullableFunction<GraphEdge, Integer> createEndPositionFunction(int visibleRowIndex) {
    List<GraphElement> visibleElementsInNextRow = getSortedVisibleElementsInRow(visibleRowIndex + 1);

    final Map<GraphElement, Integer> toPosition = new HashMap<>();
    for (int position = 0; position < visibleElementsInNextRow.size(); position++) {
      toPosition.put(visibleElementsInNextRow.get(position), position);
    }

    return edge -> {
      Integer position = toPosition.get(edge);
      if (position == null) {
        Integer downNodeIndex = edge.getDownNodeIndex();
        if (downNodeIndex != null) position = toPosition.get(myLinearGraph.getGraphNode(downNodeIndex));
      }
      return position;
    };
  }

  @Nonnull
  @Override
  protected List<SimpleRowElement> getSimpleRowElements(int visibleRowIndex) {
    List<SimpleRowElement> result = new SmartList<>();
    List<GraphElement> sortedVisibleElementsInRow = getSortedVisibleElementsInRow(visibleRowIndex);

    for (int position = 0; position < sortedVisibleElementsInRow.size(); position++) {
      GraphElement element = sortedVisibleElementsInRow.get(position);
      if (element instanceof GraphNode) {
        result.add(new SimpleRowElement(element, RowElementType.NODE, position));
      }

      if (element instanceof GraphEdge) {
        GraphEdge edge = (GraphEdge)element;
        RowElementType arrowType = getArrowType(edge, visibleRowIndex);
        if (arrowType != null) {
          result.add(new SimpleRowElement(edge, arrowType, position));
        }
      }
    }
    return result;
  }

  @javax.annotation.Nullable
  private RowElementType getArrowType(@Nonnull GraphEdge edge, int rowIndex) {
    NormalEdge normalEdge = asNormalEdge(edge);
    if (normalEdge != null) {
      return getArrowType(normalEdge, rowIndex);
    }
    else { // special edges
      switch (edge.getType()) {
        case DOTTED_ARROW_DOWN:
        case NOT_LOAD_COMMIT:
          if (intEqual(edge.getUpNodeIndex(), rowIndex - 1)) {
            return RowElementType.DOWN_ARROW;
          }
          break;
        case DOTTED_ARROW_UP:
          // todo case 0-row arrow
          if (intEqual(edge.getDownNodeIndex(), rowIndex + 1)) {
            return RowElementType.UP_ARROW;
          }
          break;
        default:
          LOG.error("Unknown special edge type " + edge.getType() + " at row " + rowIndex);
      }
    }
    return null;
  }

  @javax.annotation.Nullable
  private RowElementType getArrowType(@Nonnull NormalEdge normalEdge, int rowIndex) {
    int edgeSize = normalEdge.down - normalEdge.up;
    int upOffset = rowIndex - normalEdge.up;
    int downOffset = normalEdge.down - rowIndex;

    if (edgeSize >= myLongEdgeSize) {
      if (upOffset == myVisiblePartSize) {
        LOG.assertTrue(downOffset != myVisiblePartSize, "Both up and down arrow at row " +
                                                        rowIndex); // this can not happen due to how constants are picked out, but just in case
        return RowElementType.DOWN_ARROW;
      }
      if (downOffset == myVisiblePartSize) return RowElementType.UP_ARROW;
    }
    if (edgeSize >= myEdgeWithArrowSize) {
      if (upOffset == 1) {
        LOG.assertTrue(downOffset != 1, "Both up and down arrow at row " + rowIndex);
        return RowElementType.DOWN_ARROW;
      }
      if (downOffset == 1) return RowElementType.UP_ARROW;
    }
    return null;
  }

  private boolean isEdgeVisibleInRow(@Nonnull GraphEdge edge, int visibleRowIndex) {
    NormalEdge normalEdge = asNormalEdge(edge);
    if (normalEdge == null) {
      // e.d. edge is special. See addSpecialEdges
      return false;
    }
    return isEdgeVisibleInRow(normalEdge, visibleRowIndex);
  }

  private boolean isEdgeVisibleInRow(@Nonnull NormalEdge normalEdge, int visibleRowIndex) {
    return normalEdge.down - normalEdge.up < myLongEdgeSize || getAttachmentDistance(normalEdge, visibleRowIndex) <= myVisiblePartSize;
  }

  private void addSpecialEdges(@Nonnull List<GraphElement> result, int rowIndex) {
    if (rowIndex > 0) {
      for (GraphEdge edge : myLinearGraph.getAdjacentEdges(rowIndex - 1, EdgeFilter.SPECIAL)) {
        assert !edge.getType().isNormalEdge();
        if (isEdgeDown(edge, rowIndex - 1)) result.add(edge);
      }
    }
    if (rowIndex < myLinearGraph.nodesCount() - 1) {
      for (GraphEdge edge : myLinearGraph.getAdjacentEdges(rowIndex + 1, EdgeFilter.SPECIAL)) {
        assert !edge.getType().isNormalEdge();
        if (isEdgeUp(edge, rowIndex + 1)) result.add(edge);
      }
    }
  }

  @Nonnull
  private List<GraphElement> getSortedVisibleElementsInRow(int rowIndex) {
    List<GraphElement> graphElements = myCache.get(rowIndex);
    if (graphElements != null) {
      return graphElements;
    }

    List<GraphElement> result = new ArrayList<>();
    result.add(myLinearGraph.getGraphNode(rowIndex));

    for (GraphEdge edge : myEdgesInRowGenerator.getEdgesInRow(rowIndex)) {
      if (isEdgeVisibleInRow(edge, rowIndex)) result.add(edge);
    }

    addSpecialEdges(result, rowIndex);

    Collections.sort(result, myGraphElementComparator);
    myCache.put(rowIndex, result);
    return result;
  }

  private static int getAttachmentDistance(@Nonnull NormalEdge e1, int rowIndex) {
    return Math.min(rowIndex - e1.up, e1.down - rowIndex);
  }
}


text:
package com.lhkbob.entreri.components;

import com.lhkbob.entreri.Component;
import com.lhkbob.entreri.Named;
import com.lhkbob.entreri.property.Collection;
import com.lhkbob.entreri.property.Reference;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

/**
 * A test component that covers many of the options for collection properties.
 *
 * @author Michael Ludwig
 */
public interface CollectionComponent extends Component {
    // testing reference lists, testing the `return this` option for adding,
    // and that null elements are not allowed, and setter container validation
    @Collection(allowNullElements = false)
    @Reference
    @Named("points")
    public CollectionComponent addPoint(Point p);

    @Named("points")
    public boolean containsPoint(Point p);

    public boolean removePoint(Point p);

    public List<Point> getPoints();

    public void setPoints(List<Point> points);

    // testing reference sets, and getting container type from beans, testing the `return this` option for
    // removing, and null elements are allowed (the default with no @Collection)
    @Reference
    public Set<Point> getUniquePoints();

    public void setUniquePoints(Set<Point> points);

    public boolean addUniquePoint(@Named("uniquePoints") Point p);

    public boolean containsUniquePoint(@Named("uniquePoints") Point p);

    public CollectionComponent removeUniquePoint(@Named("uniquePoints") Point p);

    // testing reference maps, value put return, boolean remove, with no null elements
    @Reference
    public Map<String, Point> getMappedPoints();

    @Collection(allowNullElements = false)
    public void setMappedPoints(Map<String, Point> points);

    public Point putMappedPoint(String key, Point value);

    public Point getMappedPoint(String key);

    public boolean removeMappedPoint(String key);

    public boolean containsMappedPoint(String key);

    // testing value lists, testing the `return void` option for adding and removing,
    // and testing the collection type identified from the attribute
    @Collection(type = Collection.Type.LIST)
    public void addValuePoint(Point p);

    public boolean containsValuePoint(Point p);

    public void removeValuePoint(Point p);

    // testing value sets, testing overriding the default implementation, and pluralized name finding,
    // and basic value semantics for collections
    @Collection(setImpl = TreeSet.class, allowNullElements = false)
    public CollectionComponent addValueUniquePoint(Point p);

    public boolean containsValueUniquePoint(Point p);

    public boolean removeValueUniquePoint(Point p);

    public Set<Point> getValueUniquePoints();

    public void setValueUniquePoints(Set<Point> points);

    // testing value maps, map inference from get, boolean put return, void remove, null elements allowed
    public Point getValueMappedPoint(String key);

    public boolean putValueMappedPoint(String key, Point value);

    public void removeValueMappedPoint(String key);

    public boolean containsValueMappedPoint(String key);

    public static class Point implements Comparable<Point> {
        public int x, y;

        public Point() {
            this(0, 0);
        }

        public Point(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public int compareTo(Point o) {
            if (y == o.y) {
                return x - o.x;
            } else {
                return y - o.y;
            }
        }

        @Override
        public int hashCode() {
            return x ^ y;
        }

        @Override
        public boolean equals(Object o) {
            if (!(o instanceof Point)) {
                return false;
            }
            return compareTo((Point) o) == 0;
        }

        @Override
        public String toString() {
            return "(" + x + ", " + y + ")";
        }
    }
}


text:
<?xml version="1.0" encoding="utf-8"?>
<!--
  ~ Copyright (C) 2015 The Android Open Source Project
  ~
  ~ Licensed under the Apache License, Version 2.0 (the "License");
  ~ you may not use this file except in compliance with the License.
  ~ You may obtain a copy of the License at
  ~
  ~      http://www.apache.org/licenses/LICENSE-2.0
  ~
  ~ Unless required by applicable law or agreed to in writing, software
  ~ distributed under the License is distributed on an "AS IS" BASIS,
  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  ~ See the License for the specific language governing permissions and
  ~ limitations under the License
  -->

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/status_bar_latest_event_content"
    android:layout_width="match_parent"
    android:layout_height="64dp"
    android:orientation="horizontal"
    >
    <ImageView android:id="@+id/icon"
        android:layout_width="@dimen/notification_large_icon_width"
        android:layout_height="@dimen/notification_large_icon_width"
        android:scaleType="centerCrop"
        />
    <include layout="@layout/notification_template_lines"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:layout_weight="1"/>
    <LinearLayout
        android:id="@+id/media_actions"
        android:layout_width="wrap_content"
        android:layout_height="match_parent"
        android:layout_gravity="center_vertical|end"
        android:orientation="horizontal"
        android:layoutDirection="ltr"
        >
        <!-- media buttons will be added here -->
    </LinearLayout>
    <include layout="@layout/notification_media_cancel_action"
        android:layout_width="48dp"
        android:layout_height="match_parent"
        android:layout_marginRight="6dp"
        android:layout_marginEnd="6dp"/>
    <ImageView android:id="@+id/end_padder"
        android:layout_width="6dp"
        android:layout_height="match_parent"
        />
</LinearLayout>
<!-- From: file:/usr/local/google/buildbot/repo_clients/https___googleplex-android.googlesource.com_a_platform_manifest.git/mnc-supportlib-release/frameworks/support/v7/appcompat/res/layout/notification_template_media.xml --><!-- From: file:/C:/Users/Administrator/Desktop/OCode/Code/spannable_demo/build/intermediates/exploded-aar/com.android.support/appcompat-v7/23.1.0/res/layout/notification_template_media.xml -->


text:
class CreateM2mhubCustomerReports < ActiveRecord::Migration
  def up
    create_table :customer_reports, :force => true do |t|
      t.string :customer_number
      t.decimal :total_quote_amount, :precision => 12, :scale => 2
      t.decimal :total_sales_amount, :precision => 12, :scale => 2
      t.timestamps
    end
  end

  def down
    drop_table :customer_reports
  end
end


text:
CREATE TABLE postgres.accounts
(
  id bigserial NOT NULL,
  username character varying(255) NOT NULL,
  display_name character varying(255) DEFAULT ''::character varying,
  description character varying(255),
  email character varying(255) NOT NULL,
  password character varying(1023) NOT NULL DEFAULT ''::character varying,
  registration_date timestamp without time zone NOT NULL DEFAULT now(),
  last_login timestamp without time zone,
  login_count integer NOT NULL DEFAULT 0,
  account_type character varying(15) DEFAULT 'user'::character varying,
  account_state character varying(15) NOT NULL DEFAULT 'registered'::character varying,
  CONSTRAINT pkey_accounts PRIMARY KEY (id),
  CONSTRAINT unique_accounts_email UNIQUE (email),
  CONSTRAINT check_lower_email CHECK (email::text = lower(email::text)),
  CONSTRAINT check_account_type CHECK (account_type::text = 'user'::text OR account_type::text = 'admin'::text),
  CONSTRAINT check_accounts_account_state CHECK (account_state::text = 'active'::text OR account_state::text = 'registered'::text OR account_state::text = 'locked'::text)
)
WITH (
  OIDS=FALSE
);


text:
'use strict';

var assert = require('assert'),
    fs = require('fs'),
    exec = require('child_process').exec,
    msPerMin = 1000;

describe('gui-tool generate (offline|online)', function() {

    describe('exists', function() {
        it('should return help of gui-tool generate', function() {
            exec('node bin/gui-tool generate --help', function(err, stdout) {
                assert.equal(true, stdout.indexOf('Usage: generate [options]') > -1);
            });
        });
    });

    describe('prepare', function() {
        it('should create tmp directory, init project', function(done) {
            this.timeout(100 * msPerMin);
            fs.mkdir('tmp', function(err) {
                if (err) {
                    throw err;
                }
                exec('node ../bin/gui-tool init TmpApp --extjs ../sdk/extjs --siesta ../sdk/siesta', {
                    cwd: 'tmp'
                }, function(err) {
                    if (err) {
                        throw err;
                    }
                    //                    if (stderr) throw new Error('' + stderr);
                    done();
                });
            });
        });
    });

    describe('generate with gui.yml specification file', function() {
        this.timeout(20 * msPerMin);
        it('should found gui.yml in specification folder', function() {
            fs.existsSync('tmp/specification/gui.yml').should.equal(true);
        });

        it('should generate application sources', function(done) {
            exec('node ../bin/gui-tool generate -f', {
                cwd: 'tmp'
            }, function(err) {
                if (err) {
                    throw err;
                }
                //                if (stderr) throw new Error('' + stderr);
                done();
            });
        });

        it('should found generated files', function() {
            fs.existsSync('tmp/webui/app/Application.js').should.equal(true);
            fs.existsSync('tmp/webui/app/controller').should.equal(true);
            fs.existsSync('tmp/webui/app/model').should.equal(true);
            fs.existsSync('tmp/webui/app/store').should.equal(true);
            fs.existsSync('tmp/webui/app/view').should.equal(true);
            fs.existsSync('tmp/webui/app/view/Viewport.js').should.equal(true);
        });
    });

    describe('generate and compile with gui.yml specification file', function() {
        this.timeout(100 * msPerMin);
        it('should not found build folder', function() {
            fs.existsSync('tmp/webui/build/production/TmpApp').should.equal(false);
        });

        it('should generate and compile application sources', function(done) {
            exec('node ../bin/gui-tool generate -f -c', {
                cwd: 'tmp'
            }, function(err) {
                if (err) {
                    throw err;
                }
                //                if (stderr) throw new Error('' + stderr);
                done();
            });
        });

        it('should found generated files', function() {
            fs.existsSync('tmp/webui/app/Application.js').should.equal(true);
            fs.existsSync('tmp/webui/app/controller').should.equal(true);
            fs.existsSync('tmp/webui/app/model').should.equal(true);
            fs.existsSync('tmp/webui/app/store').should.equal(true);
            fs.existsSync('tmp/webui/app/view').should.equal(true);
            fs.existsSync('tmp/webui/app/view/Viewport.js').should.equal(true);
        });

        it('should found compiled files', function() {
            fs.existsSync('tmp/webui/build/production/TmpApp').should.equal(true);
        });
    });

    describe('generate with gui_copy.yml specification file', function() {
        this.timeout(20 * msPerMin);
        before(function(done) {
            var stream = fs.createReadStream('tmp/specification/gui.yml')
                .pipe(fs.createWriteStream('tmp/specification/gui_copy.yml'));
            stream.on('finish', function() {
                done();
            });
        });

        it('should found gui_copy.yml in specification folder', function() {
            fs.existsSync('tmp/specification/gui_copy.yml').should.equal(true);
        });

        it('should generate application sources', function(done) {
            exec('node ../bin/gui-tool generate -f -s gui_copy.yml', {
                cwd: 'tmp'
            }, function(err) {
                if (err) {
                    throw err;
                }
                //                if (stderr) throw new Error('' + stderr);
                done();
            });
        });

        it('should found generated files', function() {
            fs.existsSync('tmp/webui/app/Application.js').should.equal(true);
            fs.existsSync('tmp/webui/app/controller').should.equal(true);
            fs.existsSync('tmp/webui/app/model').should.equal(true);
            fs.existsSync('tmp/webui/app/store').should.equal(true);
            fs.existsSync('tmp/webui/app/view').should.equal(true);
            fs.existsSync('tmp/webui/app/view/Viewport.js').should.equal(true);
        });
    });

    describe('cleanup', function() {
        it('should remove tmp directory', function(done) {
            this.timeout(100 * msPerMin);
            exec('rm -rf tmp', function(err) {
                if (err) {
                    throw err;
                }
                done();
            });
        });
    });
});


text:
(function () {
	'use strict';

	function statisticData(data, baseServiceUrl) {
		return {
			get: function () {
				var headers = { 'Content-Type': 'application/json' };
				return data.get(baseServiceUrl + 'api/stats', headers);
			}
		}
	}

	angular.module('tripExchange.services')
		.factory('statisticData', ['data', 'baseServiceUrl', statisticData]);
} ());


text:
package rollback

import (
	"fmt"

	kerrors "k8s.io/apimachinery/pkg/api/errors"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/runtime"
	"k8s.io/apimachinery/pkg/util/validation/field"
	apirequest "k8s.io/apiserver/pkg/endpoints/request"
	kclientset "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset"
	kcoreclient "k8s.io/kubernetes/pkg/client/clientset_generated/internalclientset/typed/core/internalversion"

	"github.com/openshift/origin/pkg/client"
	deployapi "github.com/openshift/origin/pkg/deploy/apis/apps"
	"github.com/openshift/origin/pkg/deploy/apis/apps/validation"
	deployutil "github.com/openshift/origin/pkg/deploy/util"
)

// REST provides a rollback generation endpoint. Only the Create method is implemented.
type REST struct {
	generator RollbackGenerator
	dn        client.DeploymentConfigsNamespacer
	rn        kcoreclient.ReplicationControllersGetter
	codec     runtime.Codec
}

// NewREST safely creates a new REST.
func NewREST(oc client.Interface, kc kclientset.Interface, codec runtime.Codec) *REST {
	return &REST{
		generator: NewRollbackGenerator(),
		dn:        oc,
		rn:        kc.Core(),
		codec:     codec,
	}
}

// New creates an empty DeploymentConfigRollback resource
func (r *REST) New() runtime.Object {
	return &deployapi.DeploymentConfigRollback{}
}

// Create generates a new DeploymentConfig representing a rollback.
func (r *REST) Create(ctx apirequest.Context, obj runtime.Object, _ bool) (runtime.Object, error) {
	namespace, ok := apirequest.NamespaceFrom(ctx)
	if !ok {
		return nil, kerrors.NewBadRequest("namespace parameter required.")
	}
	rollback, ok := obj.(*deployapi.DeploymentConfigRollback)
	if !ok {
		return nil, kerrors.NewBadRequest(fmt.Sprintf("not a rollback spec: %#v", obj))
	}

	if errs := validation.ValidateDeploymentConfigRollback(rollback); len(errs) > 0 {
		return nil, kerrors.NewInvalid(deployapi.Kind("DeploymentConfigRollback"), rollback.Name, errs)
	}

	from, err := r.dn.DeploymentConfigs(namespace).Get(rollback.Name, metav1.GetOptions{})
	if err != nil {
		return nil, newInvalidError(rollback, fmt.Sprintf("cannot get deployment config %q: %v", rollback.Name, err))
	}

	switch from.Status.LatestVersion {
	case 0:
		return nil, newInvalidError(rollback, "cannot rollback an undeployed config")
	case 1:
		return nil, newInvalidError(rollback, fmt.Sprintf("no previous deployment exists for %q", deployutil.LabelForDeploymentConfig(from)))
	case rollback.Spec.Revision:
		return nil, newInvalidError(rollback, fmt.Sprintf("version %d is already the latest", rollback.Spec.Revision))
	}

	revision := from.Status.LatestVersion - 1
	if rollback.Spec.Revision > 0 {
		revision = rollback.Spec.Revision
	}

	// Find the target deployment and decode its config.
	name := deployutil.DeploymentNameForConfigVersion(from.Name, revision)
	targetDeployment, err := r.rn.ReplicationControllers(namespace).Get(name, metav1.GetOptions{})
	if err != nil {
		return nil, newInvalidError(rollback, err.Error())
	}

	to, err := deployutil.DecodeDeploymentConfig(targetDeployment, r.codec)
	if err != nil {
		return nil, newInvalidError(rollback, fmt.Sprintf("couldn't decode deployment config from deployment: %v", err))
	}

	if from.Annotations == nil && len(rollback.UpdatedAnnotations) > 0 {
		from.Annotations = make(map[string]string)
	}
	for key, value := range rollback.UpdatedAnnotations {
		from.Annotations[key] = value
	}

	return r.generator.GenerateRollback(from, to, &rollback.Spec)
}

func newInvalidError(rollback *deployapi.DeploymentConfigRollback, reason string) error {
	err := field.Invalid(field.NewPath("name"), rollback.Name, reason)
	return kerrors.NewInvalid(deployapi.Kind("DeploymentConfigRollback"), rollback.Name, field.ErrorList{err})
}


text:
package org.apache.hadoop.hbase.filter;

import java.util.Set;
import java.util.TreeSet;

import org.apache.hadoop.hbase.Cell;
import org.apache.hadoop.hbase.CellUtil;
import org.apache.yetus.audience.InterfaceAudience;
import org.apache.hadoop.hbase.exceptions.DeserializationException;
import org.apache.hadoop.hbase.shaded.protobuf.generated.FilterProtos;
import org.apache.hadoop.hbase.util.Bytes;

import org.apache.hadoop.hbase.shaded.com.google.protobuf.ByteString;
import org.apache.hadoop.hbase.shaded.com.google.protobuf.InvalidProtocolBufferException;
import org.apache.hadoop.hbase.shaded.com.google.protobuf.UnsafeByteOperations;

/**
 * The filter looks for the given columns in KeyValue. Once there is a match for
 * any one of the columns, it returns ReturnCode.NEXT_ROW for remaining
 * KeyValues in the row.
 *

 * Note : It may emit KVs which do not have the given columns in them, if
 * these KVs happen to occur before a KV which does have a match. Given this
 * caveat, this filter is only useful for special cases
 * like org.apache.hadoop.hbase.mapreduce.RowCounter.
 *

 * @deprecated Deprecated in 2.0. See HBASE-13347
 */
@InterfaceAudience.Public
@Deprecated
public class FirstKeyValueMatchingQualifiersFilter extends FirstKeyOnlyFilter {

  private Set<byte []> qualifiers;

  /**
   * Constructor which takes a set of columns. As soon as first KeyValue
   * matching any of these columns is found, filter moves to next row.
   *
   * @param qualifiers the set of columns to me matched.
   */
  public FirstKeyValueMatchingQualifiersFilter(Set<byte []> qualifiers) {
    this.qualifiers = qualifiers;
  }

  @Deprecated
  @Override
  public ReturnCode filterKeyValue(final Cell c) {
    return filterCell(c);
  }

  @Override
  public ReturnCode filterCell(final Cell c) {
    if (hasFoundKV()) {
      return ReturnCode.NEXT_ROW;
    } else if (hasOneMatchingQualifier(c)) {
      setFoundKV(true);
    }
    return ReturnCode.INCLUDE;
  }

  private boolean hasOneMatchingQualifier(Cell c) {
    for (byte[] q : qualifiers) {
      if (CellUtil.matchingQualifier(c, q)) {
        return true;
      }
    }
    return false;
  }

  /**
   * @return The filter serialized using pb
   */
  public byte [] toByteArray() {
    FilterProtos.FirstKeyValueMatchingQualifiersFilter.Builder builder =
      FilterProtos.FirstKeyValueMatchingQualifiersFilter.newBuilder();
    for (byte[] qualifier : qualifiers) {
      if (qualifier != null) builder.addQualifiers(UnsafeByteOperations.unsafeWrap(qualifier));
    }
    return builder.build().toByteArray();
  }

  /**
   * @param pbBytes A pb serialized {@link FirstKeyValueMatchingQualifiersFilter} instance
   * @return An instance of {@link FirstKeyValueMatchingQualifiersFilter} made from bytes
   * @throws DeserializationException
   * @see #toByteArray
   */
  public static FirstKeyValueMatchingQualifiersFilter parseFrom(final byte [] pbBytes)
  throws DeserializationException {
    FilterProtos.FirstKeyValueMatchingQualifiersFilter proto;
    try {
      proto = FilterProtos.FirstKeyValueMatchingQualifiersFilter.parseFrom(pbBytes);
    } catch (InvalidProtocolBufferException e) {
      throw new DeserializationException(e);
    }

    TreeSet<byte []> qualifiers = new TreeSet<>(Bytes.BYTES_COMPARATOR);
    for (ByteString qualifier : proto.getQualifiersList()) {
      qualifiers.add(qualifier.toByteArray());
    }
    return new FirstKeyValueMatchingQualifiersFilter(qualifiers);
  }

  /**
   * @param o the other filter to compare with
   * @return true if and only if the fields of the filter that are serialized
   * are equal to the corresponding fields in other.  Used for testing.
   */
  boolean areSerializedFieldsEqual(Filter o) {
    if (o == this) return true;
    if (!(o instanceof FirstKeyValueMatchingQualifiersFilter)) return false;

    FirstKeyValueMatchingQualifiersFilter other = (FirstKeyValueMatchingQualifiersFilter)o;
    return this.qualifiers.equals(other.qualifiers);
  }
}


text:
<?php

declare(strict_types = 1);

namespace Karma\Generator;

use Karma\Configuration\FileParser;
use Karma\Generator\NameTranslators\NullTranslator;

class VariableProvider
{
    private FileParser
        $parser;
    private NameTranslator
        $nameTranslator;

    public function __construct(FileParser $parser)
    {
        $this->parser = $parser;
        $this->nameTranslator = new NullTranslator();
    }

    public function setNameTranslator(NameTranslator $translator): void
    {
        $this->nameTranslator = $translator;
    }

    public function getAllVariables(): array
    {
        $parsedVariables = $this->parser->getVariables();

        $variables = [];

        foreach($parsedVariables as $variable => $info)
        {
            $variables[$variable] = $this->nameTranslator->translate($info['file'], $variable);
        }

        return $variables;
    }
}


text:
const postcss = require('postcss')

const SourceFactory = require('./sources/factory')
const CssNuker = require('./css-nuker')
const PostCssParser = require('./parser/postcss')

function createPlugin(sources, options) {
  sources = SourceFactory.from(sources, options)

  return parsed => {
    const parser = new PostCssParser(parsed)
    const nuker = new CssNuker(sources, parser, options)
    nuker.nuke()
  }
}

module.exports = postcss.plugin('nukecss', createPlugin)


text:
ACCEPTED

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Nova Hedwigia 41(1-4): 454 (1985)

#### Original name
Gorgomyces hungaricus J. Gönczöl & Révay, 1985

### Remarks
null


text: This is a basic portfolio for Aldo Sanchez.


text:
using System;
using System.Diagnostics;
using System.IO;
using Microsoft.Build.Framework;
using Microsoft.Build.Utilities;

namespace Hedgehog.Build.Razl
{
    public class RazlScript : Task
    {
        [Required]
        public string RazlPath { get; set; }

        [Required]
        public string FilePath { get; set; }

        public string Parameters { get; set; }

        public override bool Execute()
        {
            var result = false;

            if (File.Exists(FilePath))
            {
                try
                {
                    Log.LogMessage("Razl Script Started: {0}", FilePath);

                    ProcessStartInfo startInfo = new ProcessStartInfo();
                    startInfo.CreateNoWindow = false;
                    startInfo.UseShellExecute = false;
                    startInfo.FileName = RazlPath;
                    startInfo.WindowStyle = ProcessWindowStyle.Hidden;
                    startInfo.Arguments = string.Format("/script:{0}",FilePath);

                    if (!string.IsNullOrEmpty(Parameters))
                    {
                        startInfo.Arguments += string.Format(" /p:{0}", Parameters);
                    }

                    startInfo.RedirectStandardOutput = true;
                    startInfo.RedirectStandardError = true;

                    Log.LogMessage("{0} {1}", startInfo.FileName, startInfo.Arguments);

                    using (Process exeProcess = Process.Start(startInfo))
                    {
                        Log.LogMessage(exeProcess.StandardOutput.ReadToEnd());
                        Log.LogMessage(exeProcess.StandardError.ReadToEnd());

                        exeProcess.OutputDataReceived += (sender, args) => Log.LogMessage(args.Data);
                        exeProcess.WaitForExit();
                    }

                    result = true;

                    Log.LogMessage("Razl Script Finished: {0}", FilePath);
                }
                catch (Exception ex)
                {
                    Log.LogErrorFromException(ex, true);

                }

            }
            else
            {
                Log.LogError(string.Format("Razl Script Failed: Failed to find file {0}", FilePath));

            }

            return result;
        }
    }
}