Speculative Flat Encodings

Flat encodings for nested values

Speculative design. Open, not settled — thinking and proposals, not shipped behavior. See Roadmap for what's in flight.

Status: speculative (2026-11-01). Tracks BL-422, BL-283 and BL-290 (rest). The JavaScript compile target (compute-engine's, through FastTarget in packages/engine/src/compiled-target.ts) declines Epsil bodies over ragged or variable-depth values: binary_tree, ordered_tree, the standard_tableau_pair and RSK output. This page measures what declines, compares three flat encodings the compiler accepts today, sets them against compute-engine recursive types, and recommends one.

What declines today

The probe (a scratch script over CARRIERS, MAPS, the Epsil families and the statistics areas, compiling each through FastTarget) compiles every map body and guard from its source carrier's shape, every Epsil family operation, and every statistic of the six statistics areas, and prints the compiler's message. Raw rows are at the end of the page (79 rows: 16 map, 10 family, 53 statistic: 33 BinaryTree, 20 OrderedTree).

Cause	Message	Maps	Statistics
Nested union read	Element / At / Reduce / Join operand "is not an indexed collection": a binary_tree is integer | list<any>, a leaf or a node	8 binary_tree maps (BinaryTreeParentArray, DyckPath, Mirror, LeftRotation, RightRotation, LeftBorderSymmetry, OrderedTree, RightBranchOrderedTree)	32 BinaryTree (all but DistinctSubtrees), 13 OrderedTree (5 Reduce, 8 At)
Recursion	Unknown operator self: recurse applies an anonymous Function to itself, and the target has no lowering for it	Mirror, BinaryTree, RightBranchBinaryTree, Rotation at ordered_tree; FromPermutation (and, behind the type error, every recurse body in the group above except the two rotations)	BoundaryLength, TrunkLength, BoundaryLengthBeyondTrunk at OrderedTree
Nested value as data	DyckPath@ordered_tree: Join operand 2 is the untyped result of self; Breadth: Max over collection elements; DistinctSubtrees (both trees): Unique compares nested lists structurally	DyckPath@ordered_tree	3 (DistinctSubtrees at both trees, Breadth)
Nothing omission	Sum over elements that may be Nothing	none	Leaves, NonRootInternalNodes at OrderedTree
Map head in a body	Unknown operator RskInsertion: Rsk is Tuple(RskInsertion, RskRecording), a call to two maps that compile on their own	Rsk@permutation	none
Composite shape	tuple<standard_tableau, standard_tableau> is a carrier alias the type parser does not resolve; behind it, inverseRsk in families/rsk-pairs.ts keeps rows in a Fold accumulator (list<any>)	ToPermutation@standard_tableau_pair	none

Notes on reading the table:

• The message is the first failure. LeftRotation and RightRotation use only At, If and List, so the nested union read is their only blocker. The other six binary_tree bodies use recurse and meet self next.
• BL-422 counts 15 map bodies; the probe has 16, because Mirror@ordered_tree declines too (self).
• The ten FAM rows (rank and valid of BinaryTrees, FullKAryTrees, OrderedTrees, IncreasingBinaryTrees, StandardTableauPairs) read no types: the probe found no declared operation types, so these are unmeasured, not compiler declines. IncreasingBinaryTrees rank and valid already run on a flat preorder inside the Epsil (#1006); the others have no flat form to measure. The "9 nested-tree inputs" are the tree statistics above.
• The probe resolves types the way scripts/compile-maps.ts does (compileTyped with the carrier's shape), so the map rows are the same declines the generated module records: none of these maps has an entry in compiled-maps.generated.js.

How values are encoded today

Carrier	Shape	Value
binary_tree	integer | list<any>	leaf 0, node [left, right]
increasing_binary_tree	same	leaf 0, node [label, left, right]
ordered_tree	integer | list<any>	a node is the list of its children, [] a lone vertex
binary_tree_parent_array	list<integer>	entry k is the parent of the k-th node in order, 0 at the root
standard_tableau	list<list<integer>>	rows
standard_tableau_pair	tuple<standard_tableau, standard_tableau>	two row lists

A compiled program sees a value as toJs of its MathJSON: integers, and lists and tuples of them, become plain JavaScript numbers and arrays, and fromJs reverses it (packages/engine/src/compiled.ts). Nested lists cross the boundary without trouble; the type checker is what declines them. A list<integer> is a JavaScript array of numbers that At lowers to list[i - 1], and Map, Fold, Filter, Range, Take, Drop, Join, Count, Flatten and Tuple take it.

Three precedents already work around the declines:

• #1006. IncreasingBinaryTrees rank and valid flatten the tree inside the body (preorder, a 0 per empty subtree) and run a stack over the tokens. The tree is nested at the boundary and flat inside the Epsil.
• #1171. BinaryTree@binary_tree_parent_array builds the nested tree from the parent array: a stack walk writes the preorder arity word, buildFromWord reads it back. It compiles because the input is flat; the nested output is only constructed.
• tableaux/src/flat.ts. RSK runs on a capacity layout (n row lengths, then n × n cells per tableau) and promotion on a compact layout (row lengths, row offsets, entries). RskInsertion, RskRecording and RskShape compile this way; rskPairRows already returns both tableaux, and inverseRsk in flat.ts already takes two capacity-layout states. Rsk and ToPermutation do not use them.

The direction matters. Reading a nested value is what the compiler declines, so a flat encoding cannot be produced from the nested value inside compiled code. The conversion BinaryTreeParentArray@binary_tree is itself one of the declined maps. Whatever the encoding, nested to flat happens in TypeScript at the toJs boundary; flat to nested may be either (#1171 does it in Epsil).

Candidates

Verified by compiling a sketch through FastTarget and running it: the parent-array Mirror and Height, an offset-indexed tableau row read, a Tuple of two list<integer>. Everything else below is reasoned, not run.

(a) Parent array

Trees as the parent of each node in a fixed order: in order for a binary tree (the existing carrier), preorder for an ordered tree.

Epsil sketch, Mirror@binary_tree_parent_array (verified; accepted and equal to the nested Mirror on [2, 4, 2, 0, 4] → [2, 0, 4, 2, 4]). Reflecting the in-order labels k → n + 1 − k reverses the array and renumbers its entries:

Map(k -> If(_raw[n + 1 - k] = 0, 0, n + 1 - _raw[n + 1 - k]), Range(1, n)),   n = Length(_raw)

Against the nested definition recurse(If(isLeaf(t), 0, [self(right(t)), self(left(t))])), this is a different algorithm, not the same meaning in other clothes.

• Binary-tree maps. Mirror (verified). LeftRotation, RightRotation: in-order labels do not change, so a rotation rewrites three entries (the new root, the old root, the moved subtree's root) with Map and If; the no-child case swaps the subtrees and renumbers by an offset. BinaryTreeParentArray: the identity on the encoding. DyckPath: the block start of each node follows top-down (s(left) = s + 1, s(right) = s + 2 + 2·|left|), computed by n rounds of relaxation as Height is; plausible, quadratic, not run. OrderedTree and RightBranchOrderedTree: produce an ordered_tree, so they need that carrier's encoding too. LeftBorderSymmetry declines in practice: it is recursive over a spine and has no local form.
• Statistics. Height (verified, n rounds of depth[k] = depth[parent[k]] + 1, quadratic). The counting statistics (Leaves, UnaryNodes, BinaryNodes, RightChildCount, LeftSpine by walking) are Count and Filter over the array. The path-count family (RightRightLeftPathCount and kin) needs a walk per node, again by rounds. DistinctSubtrees, Strahler, LinearExtensionCount and TreeFactorial need per-subtree values: bottom-up passes over the array, written as a fold over nodes in an order where children come first, which a parent array in order does not give. These stay open.
• Ordered tree. A preorder parent array makes DyckPath and the contour statistics direct, but Mirror, Rotation and the branch bijections renumber vertices by subtree size, which is relaxation again. Weak fit.
• Tableaux, RSK, FromPermutation. Not trees; no use. FromPermutation builds a Cartesian tree, whose parent array is the larger-valued of the nearest smaller entries on each side, a Filter and Max per position: compiles without recursion, quadratic.
• Boundary. Carrier value → array: one preorder walk in TypeScript, O(n). Array → carrier value: the compiled BinaryTree@binary_tree_parent_array (#1171) or a TypeScript walk. The array carrier exists, so BinaryTreeParentArray and BinaryTree are the codec already, in Epsil.
• Epsil as meaning. The nested definition can stay the meaning and the array body becomes an alternative compiled form held to it by the existing agrees check in compile-maps.ts. If the array body replaces the definition, it is plumbing.

(b) Preorder plus arity

Each node's number of children, in preorder: a binary tree is a word over {0, 2} (the existing buildFromWord form), an ordered tree a word of out-degrees. One encoding for both tree carriers.

Sketch, Mirror@binary_tree. The preorder of the mirror is not a reversal of the preorder (the reversal is the mirror's postorder), so a preorder word needs the end of each subtree before it can swap two of them:

ends  = Fold over the word from the right, a stack of pending subtree ends     // stack walk, as in #1171
Mirror = Join of, per node, [token, mirror(right block), mirror(left block)]    // still recursive in the blocks

A postorder word makes Mirror a Reverse, but then DyckPath and Rotation need the stack.

• Maps. The stack walk compiles (#1171, #1006), so any map can be written, each as a long fold over [height, position, cells…] states. Mirror, LeftRotation, RightRotation, DyckPath need a subtree-end array first. The two branch bijections between the tree carriers are token rewrites with block boundaries.
• Statistics. Size, leaf count and root degree are prefix counts. Height needs the stack.
• Boundary. Nested → word: a preorder walk, O(n). Word → nested: buildFromWord or TypeScript.
• Epsil as meaning. Worst of the three. #1006's rank is 80 lines of stack choreography where the nested definition is a few; every map would become a state machine.
• Variant. The Dyck word is the arity word with the closing step written out, so depth is a prefix sum. dyck_path is a list<integer> carrier, and its maps and statistics already compile (the probe's dyck area has no declines; ReverseComplement@dyck_path is a compiled one-liner). Ordered trees map to it by DyckPath@ordered_tree (the contour), and Mirror@ordered_tree is ReverseComplement of it. Binary trees map to it by DyckPath@binary_tree (U φ(L) D φ(R)), under which Mirror is DecompositionReverse, not a reversal. This variant needs no new carrier; it does mean ordered-tree and binary-tree statistics are stated on Dyck paths, which is the FindStat reading (Mp00012, Mp00051) and loses the tree vocabulary in the compiled body.

(c) Offset-indexed list<integer>

One integer list: a header of counts and offsets, then the payload. A tableau: [rows, length₁…length_r, offset₁…offset_r, entries…], which is flat.ts's compact layout. A pair: the two lists joined, or a tuple of them. A tree: node count, then for each node its first-child offset and child count (a CSR adjacency list), children in order.

Sketch, row r of a tableau in this layout (verified; accepted, [2, 3, 1, 0, 3, 1, 2, 4, 3] reads [[1, 2, 4], [3]]):

Map(r -> Take(Drop(_raw, 1 + 2·_raw[1] + _raw[1 + _raw[1] + r]), _raw[1 + r]), Range(1, _raw[1]))

Computing offsets inside the body with Total or Sum over a Take is rejected (the sum's type is not integer), so the offsets sit in the header and the codec writes them.

• Tableaux. Direct. Rsk becomes rskPairRows on _raw (it returns the two tableaux as a List, where today's constructor yields a Tuple: the same MathJSON contents, a different head, which the pair carrier must accept or the body must wrap). ToPermutation takes flat.ts's inverseRsk on two capacity-layout states built from the rows. Neither needs a new encoding: flat.ts is already (c), used inside the body.
• Trees, CSR form. Read-only statistics are direct: Leaves is a count of zero child counts, LargestOutDegree a Max over the count column, Height rounds as in (a). Mirror@ordered_tree reverses each children block and renumbers children by offset: a Map over nodes with index arithmetic through the offset column, not a one-liner. Binary rotations are local edits of two slots.
• Boundary. O(n) in TypeScript each way, with a header to build. The tableau codec is a flatten plus a prefix sum.
• Epsil as meaning. Tableau bodies are already written this way and read acceptably. Tree bodies become index arithmetic over the header.

Comparison

	(a) parent array	(b) preorder + arity	(b′) Dyck word	(c) offset-indexed
binary_tree maps unblocked	Mirror, LeftRotation, RightRotation, BinaryTreeParentArray; DyckPath plausible	all but with stack walks; none short	DyckPath (identity), others restated as Dyck maps	LeftRotation, RightRotation; Mirror by index arithmetic
binary_tree still declining	LeftBorderSymmetry, the two Ordered maps until ordered_tree is flat	none in principle	none in principle	LeftBorderSymmetry
ordered_tree maps	weak	stack walks	Mirror (= ReverseComplement), DyckPath; others via the binary bijections	Mirror, Rotation by arithmetic
Tableau pairs, RSK	no	no	no	Rsk, ToPermutation (already in flat.ts)
FromPermutation	yes, Cartesian parent array	stack	no	no
Tree statistics	counts and Height; bottom-up ones open	prefix counts; the rest by stack	Dyck statistics already compile	counts and Height; bottom-up open
Boundary cost	O(n) walk in, existing builder out	O(n) walk in, buildFromWord out	existing maps (declined today, so a TypeScript walk)	O(n) each way, header to build
Nested Epsil stays the meaning	yes, as the checked alternative	yes, but bodies are plumbing	yes	yes for tableaux; plumbing for trees

The statistics that need a value per subtree (Strahler, TreeFactorial, LinearExtensionCount, DistinctSubtrees, ProtectionNumber, the automorphism count) are open under all three. They are bottom-up folds over children, and none of the encodings gives a children-before-parents order cheaply except a postorder or reverse-preorder walk (for a preorder arity word, a right-to-left fold with a stack). That is the one place (b) is better than (a).

Caches: a compiled map chain (composedOf) runs entries in turn on the JavaScript value. Whether a chain can keep a value encoded between steps depends on src/compiled.ts and is not settled here; if each step round-trips through toJs / fromJs, a chain of tree maps pays two O(n) conversions per step and a codec on the carrier makes that cost visible. This is the first thing to check in the slice.

What compute-engine recursive types would buy

A recursive type such as tree = integer | list<tree>, lowered by the JavaScript target, would remove the first row of the decline table: Element(t, Integers) as a narrowing test, At(t, 1) on the list branch, Length, Join and Flatten on a nested operand. That unblocks LeftRotation and RightRotation outright, and the 32 + 13 statistics whose first failure is the nested read, as far as their next failure allows.

It does not unblock the self row. recurse is a self-applied anonymous Function, and the target has no lowering for a function applied to itself; types do not change that. A compute-engine ask would be a second one: lower a self-applied Function (or a named local function) to a JavaScript recursive function. With both, the nested definitions would compile as written and keep their meaning with no encoding plumbing. The remaining rows need their own asks: an omission representation for Nothing in Sum (the target says it needs "a distinct omission representation"), structural equality for Unique and Max over nested lists, and recursion depth (a JavaScript call per tree level, bounded by the stack).

Any of this goes to compute-engine through the CE upstream session as an issue with its PR, each draft signed off before posting. It is unknown how much of the type grammar (named recursive aliases, union narrowing in If) exists in the target today; that is a question for that session, not a result here.

Recommendation

Adopt flat encodings now, at one seam, rather than wait: the self row alone means a recursive-types ask would not clear the group, and it has no date.

The seam is a per-carrier codec at the toJs / fromJs boundary: an optional flat on a carrier giving the flat shape and the TypeScript conversion each way, and an optional flat body on a map, compiled from the flat shape and checked against the interpreter's nested definition by the existing agrees comparison. The nested Epsil remains the definition; the flat body is the compiled alternative, as kernel is the TypeScript alternative today. That keeps the AGENTS.md rule (a family's Epsil definition is its meaning) and puts the plumbing where it can be deleted when compute-engine lowers recursion.

The layout, per carrier, from the table:

• binary_tree and increasing_binary_tree: (a) the parent array (in order; the increasing tree adds a label column), for the reasons above: the carrier exists, the builder compiles, Mirror is a one-liner, rotations are local edits, and FromPermutation has a recursion-free form.
• standard_tableau, standard_tableau_pair, RSK output: (c) the compact layout flat.ts already uses.
• ordered_tree: (b′) the Dyck word, because dyck_path is a compiled list<integer> carrier with the contour map defined, and Mirror is its ReverseComplement. If a tree-shaped encoding is preferred, use the preorder parent array of (a), at the cost of the renumbering.

That is three layouts under one seam, not one layout: no single layout covers trees and tableaux without losing the cheap maps of each. If a single layout is wanted, (a) for both tree carriers is the least bad, and tableaux stay as they are inside flat.ts.

First slice

1. The codec seam on the carrier, with binary_tree ↔ parent array and its round-trip test over BinaryTrees for small n.
2. flat bodies for Mirror, LeftRotation, RightRotation@binary_tree and the statistics Height, Leaves, UnaryNodes, BinaryNodes, RightChildCount; the compiled-maps check agrees them with the interpreter.
3. No codec needed: Rsk@permutation as rskPairRows and ToPermutation through flat.ts's inverseRsk. This is independent of 1 and 2 and can land first. It needs a decision on the Tuple versus List head of the pair.
4. Check whether a map chain keeps values encoded between steps.

Leans (2026-11-01): keep the pair's Tuple head (Rsk already returns one, so the first slice changes no public value); the Dyck-word reading is fine for ordered-tree compiled bodies, since the nested Epsil stays the meaning; measure the quadratic passes in the first codec slice and keep slow ones out of the PR smoke set; a composedOf chain keeps values encoded between steps and decodes only at its boundary. The codec seam is approved (2026-11-01). Slices, after the no-codec Rsk/ToPermutation one: binary trees as the parent array (Mirror, rotations, FromPermutation's Cartesian form), then ordered trees as Dyck words, then tableaux; every flat body is checked against the nested Epsil by agrees.

Open questions, as first posed: the Tuple versus List pair head; whether the Dyck-word reading of ordered trees is acceptable for the tree statistics' compiled bodies; and the quadratic relaxation passes (Height, DyckPath) against the CI runners' speed, which the slice should measure before declaring a test standard rather than DEEP_TESTS=1.

Decline rows (main 6c757de02, 2026-11-01)

79 rows

Kind	Where	Message
MAP	Rsk@permutation	Unknown operator RskInsertion
MAP	FromPermutation@permutation	Unknown operator self
MAP	BinaryTreeParentArray@binary_tree	Could not compile Element: operand is not an indexed collection (list/vector/range).
MAP	DyckPath@binary_tree	Could not compile Element: operand is not an indexed collection (list/vector/range).
MAP	Mirror@binary_tree	Could not compile Element: operand is not an indexed collection (list/vector/range).
MAP	LeftRotation@binary_tree	Could not compile Element: operand is not an indexed collection (list/vector/range).
MAP	RightRotation@binary_tree	Could not compile Element: operand is not an indexed collection (list/vector/range).
MAP	LeftBorderSymmetry@binary_tree	Could not compile Element: operand is not an indexed collection (list/vector/range).
MAP	OrderedTree@binary_tree	Could not compile Element: operand is not an indexed collection (list/vector/range).
MAP	RightBranchOrderedTree@binary_tree	Could not compile Element: operand is not an indexed collection (list/vector/range).
MAP	Mirror@ordered_tree	Unknown operator self
MAP	BinaryTree@ordered_tree	Unknown operator self
MAP	RightBranchBinaryTree@ordered_tree	Unknown operator self
MAP	DyckPath@ordered_tree	Could not compile Join: operand 2 is not an indexed collection (list/vector/range).
MAP	Rotation@ordered_tree	Unknown operator self
MAP	ToPermutation@standard_tableau_pair	Failed to parse type "tuple<standard_tableau, standard_tableau>":
FAM	BinaryTrees rank	no types
FAM	BinaryTrees valid	no types
FAM	FullKAryTrees rank	no types
FAM	FullKAryTrees valid	no types
FAM	OrderedTrees rank	no types
FAM	OrderedTrees valid	no types
FAM	IncreasingBinaryTrees rank	no types
FAM	IncreasingBinaryTrees valid	no types
FAM	StandardTableauPairs rank	no types
FAM	StandardTableauPairs valid	no types
STAT	tree Height@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree LeftSubtreeSize@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree LeftSpine@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree Leaves@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree UnaryNodes@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree BinaryNodes@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree StrahlerNumber@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree PathLength@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree ExternalPathLength@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree Pitchforks@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree TreeFactorial@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree LinearExtensionCount@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree CollessIndex@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree MaximalLeftBranches@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree DistinctSubtrees@BinaryTree	Could not compile Unique: the interpreter compares elements structurally, but on the JavaScript target only real/boolean/string elements, and lists of them, c
STAT	tree ProtectionNumber@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree RightChildCount@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree RightSubtreeSizeSum@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree ParenthesisCodeValue@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree BoundaryNodes@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree NonBoundaryNodes@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree NonRootBinaryNodes@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree HookNumber@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree VertexHeightSum@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree RightRightPathCount@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree RightRightRightPathCount@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree RightRightRightRightPathCount@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree RightRightLeftPathCount@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree RightRightRightLeftPathCount@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree RightLeftLeftPathCount@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree RightLeftLeftLeftPathCount@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree RightRightLeftLeftPathCount@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree RightRightLeftRightPathCount@BinaryTree	Could not compile Element: operand is not an indexed collection (list/vector/range).
STAT	tree Height@OrderedTree	Could not compile Reduce: first operand is not an indexed collection (list/vector/range).
STAT	tree Leaves@OrderedTree	Could not compile Sum: possible 'Nothing' elements require a distinct omission representation.
STAT	tree NonRootInternalNodes@OrderedTree	Could not compile Sum: possible 'Nothing' elements require a distinct omission representation.
STAT	tree LargestOutDegree@OrderedTree	Could not compile Reduce: first operand is not an indexed collection (list/vector/range).
STAT	tree StrahlerNumber@OrderedTree	Could not compile At: first operand is not an indexed collection (list/vector/range).
STAT	tree PathLength@OrderedTree	Could not compile At: first operand is not an indexed collection (list/vector/range).
STAT	tree TreeFactorial@OrderedTree	Could not compile At: first operand is not an indexed collection (list/vector/range).
STAT	tree LinearExtensionCount@OrderedTree	Could not compile At: first operand is not an indexed collection (list/vector/range).
STAT	tree DistinctSubtrees@OrderedTree	Could not compile Unique: the interpreter compares elements structurally, but on the JavaScript target only real/boolean/string elements, and lists of them, c
STAT	tree ProtectionNumber@OrderedTree	Could not compile Reduce: first operand is not an indexed collection (list/vector/range).
STAT	tree BoundaryLength@OrderedTree	Unknown operator self
STAT	tree TrunkLength@OrderedTree	Unknown operator self
STAT	tree Breadth@OrderedTree	Could not compile Max: an element of the data is a collection (a list, a string, a set or a dictionary), which the compiled code would read as a number. The i
STAT	tree LongestPathVertexCount@OrderedTree	Could not compile Reduce: first operand is not an indexed collection (list/vector/range).
STAT	tree AutomorphismGroupSize@OrderedTree	Could not compile Reduce: first operand is not an indexed collection (list/vector/range).
STAT	tree InequivalentIncreasingTreeCount@OrderedTree	Could not compile At: first operand is not an indexed collection (list/vector/range).
STAT	tree OneProtectedNodeCount@OrderedTree	Could not compile At: first operand is not an indexed collection (list/vector/range).
STAT	tree TwoProtectedNodeCount@OrderedTree	Could not compile At: first operand is not an indexed collection (list/vector/range).
STAT	tree PruningNumber@OrderedTree	Could not compile At: first operand is not an indexed collection (list/vector/range).
STAT	tree BoundaryLengthBeyondTrunk@OrderedTree	Unknown operator self