# Aligned Induction

## Implementation

The implementation of practicable inducers must exclude partition variables because they are impracticable. In the following computers none of the instantiated variables are partition variables.

### Sections

Limited-underlying tuple set list builder

Highest-layer limited-derived derived variables set builder

Tuple partitioner

Maximum-roll-by-derived-dimension tuple partitioner

Tuple-partition value roller

Maximum-roll tuple-partition value roller

Highest-layer layerer

Highest-layer maximum-roll layerer

Highest-layer excluded-self maximum-roll layerer

Highest-layer maximum-roll-by-derived-dimension layerer

Highest-layer excluded-self maximum-roll-by-derived-dimension layerer

Highest-layer fud induction computer

Highest-layer maximum-roll excluded-self fud induction computer

Highest-layer maximum-roll-by-derived-dimension excluded-self fud induction computer

Highest-layer fud decomper

Highest-layer excluded-self maximum-roll fud decomper

Highest-layer excluded-self maximum-roll-by-derived-dimension fud decomper

### Limited-underlying tuple set list builder

In order to implement the limited-underlying tuple set list maximiser, $Z_{P,A,A_R,F,\mathrm{B}}$, (Haskell) define the limited-underlying tuple set list builder $I_{P,U,\mathrm{B}} \in \mathrm{computers}$ such that (i) the domain is $\mathrm{domain}(I_{P,U,\mathrm{B}}) = \mathrm{P}(\mathcal{V}_U) \times \mathcal{F}_{U,1} \times \mathcal{A}_U \times \mathcal{A}_U$, (ii) the range is $\mathrm{range}(I_{P,U,\mathrm{B}}) = \mathrm{P}(\mathcal{V}_U) \times \mathcal{A}_U \times \mathcal{A}_U \to \mathbf{Q}$, and (iii) the application is (Haskell) $\begin{eqnarray} I_{P,U,\mathrm{B}}^{ * }((V,\emptyset,X,X_R)) &=& \mathrm{topd}(\lfloor\mathrm{bmax}/\mathrm{mmax}\rfloor)(\mathrm{buildb}(V,X,X_R,\mathrm{init}(V),\emptyset))\\ I_{P,U,\mathrm{B}}^{ * }((V,F,X,X_R)) &=& \mathrm{topd}(\lfloor\mathrm{bmax}/\mathrm{mmax}\rfloor)(\mathrm{buildb}(\mathrm{vars}(F) \cup V,X,X_R,\\ &&\hspace{10em}\mathrm{init}(\mathrm{der}(F)),\emptyset)) \end{eqnarray}$ where $\mathrm{init}(V) := \{(((\{w\},\emptyset,\emptyset),0),0) : w \in V\}$, $\mathrm{buildt} = ((\mathrm{P}(\mathcal{V}_U) \times \mathcal{A}_U \times \mathcal{A}_U) \times \mathbf{Q}) \times (\mathbf{Q} \times \mathbf{N} \times \mathbf{Q} \times \mathbf{N} \times \mathbf{N})$ and $\mathrm{buildb} \in \mathrm{P}(\mathcal{V}_U) \times \mathcal{A}_U \times \mathcal{A}_U \times \mathrm{buildt} \times \mathrm{buildt} \to \mathrm{buildt}$ is defined $\begin{eqnarray} &&\mathrm{buildb}(W,X,X_R,Q,N) = \\ &&\hspace{1em}\mathrm{if}(M \neq \emptyset, \mathrm{buildb}(W,X,X_R,M,N \cup M), \mathrm{final}(N)) : \\ &&\hspace{2em}P = \{J : (((K,\cdot,\cdot),\cdot),\cdot) \in Q,~w \in W \setminus K,~J = K \cup \{w\}\}, \\ &&\hspace{2em}M = \mathrm{top}(\mathrm{omax})(\{(((J,B,B_R),a_1-b_1), \\ &&\hspace{8em}(a_1-a_2-b_1+b_2,~-l,~-b_1+b_2,~-u,~D_{\mathcal{X}}(J))) :\\ &&\hspace{4em}J \in P,~u = |J^{\mathrm{C}}|,~u \leq \mathrm{xmax},~l = \mathrm{sumlayer}(F,J),\\ &&\hspace{4em}B = I_{\%}^{ * }((J,X)),~B_R = I_{\%}^{ * }((J,X_R)),\\ &&\hspace{4em}a_1 = I_{\mathrm{\mathrm{S}\approx\mathrm{ln}!}}^{ * }(B),~a_2 = I_{\mathrm{\mathrm{S}\approx\mathrm{ln}!}}^{ * }(I_{\mathrm{X}}^{ * }(B)),\\ &&\hspace{4em}b_1 = I_{\mathrm{\mathrm{S}\approx\mathrm{ln}!}}^{ * }(B_R),~b_2 = I_{\mathrm{\mathrm{S}\approx\mathrm{ln}!}}^{ * }(I_{\mathrm{X}}^{ * }(B_R))\}) \end{eqnarray}$ where $\mathrm{final}(N) := \{(((K,A,B),y),a) : (((K,A,B),y),a) \in N,~|K|>1\}$, $D_{\mathcal{X}} \in \mathrm{enums}(\mathcal{X})$ is an arbitrary order, $\mathrm{sumlayer} \in \mathcal{F} \times \mathrm{P}(\mathcal{V}) \to \mathbf{N}$, the reducer $I_{\%} = \mathrm{reducer} \in \mathrm{computers}$, the independenter $I_{\mathrm{X}} = \mathrm{independenter} \in \mathrm{computers}$ is such that $I_{\mathrm{X}}^{ * }(A) = A^{\mathrm{X}}$, and $I_{\mathrm{\mathrm{S}\approx\mathrm{ln}!}} = \mathrm{sumlogfactorialer} \in \mathrm{computers}$ is defined $I_{\mathrm{\mathrm{S}\approx\mathrm{ln}!}}^{ * }(A) = \sum_{S \in A^{\mathrm{FS}}} I_{\mathrm{\approx\mathrm{ln}!}}^{ * }(A_S)$ where $I_{\mathrm{\approx\mathrm{ln}!}} = \mathrm{logfactorialer} \in \mathrm{computers}$ is defined $I_{\mathrm{\approx\mathrm{ln}!}}^{ * }(x) \approx \ln \Gamma_! x$.

The tuples of the limited-underlying tuple set list builder $I_{P,U,\mathrm{B}}$, are pluri-variate, $\forall ((K,\cdot,\cdot),\cdot) \in I_{P,U,\mathrm{B}}^{ * }((V,F,X,X_R))~(|K|>1)$.

The $\mathrm{buildb}$ function argument histograms, $X,X_R$, have the same variables, $\mathrm{vars}(X)=\mathrm{vars}(X_R)$. The argument variables, $W$, are a subset of the argument histograms variables, $W \subseteq \mathrm{vars}(X)$. It is sufficient that the system, $U$, contains the variables of the argument histograms, $\mathrm{vars}(X) \subseteq \mathrm{vars}(U)$.

The argument histograms, $X,X_R$, are in a list representation or binary map representation, because in some cases the volume, $|\mathrm{vars}(X)^{\mathrm{C}}|$, is impracticably large for an array representation. The resultant histograms, $B,B_R$, may be in array representation because their volume cannot exceed the given limit, $|B^{\mathrm{C}}| \leq \mathrm{xmax}$, which is chosen to be practicable.

The limited-underlying tuple set list builder implements the limited-underlying tuple set list maximiser, insofar as the inclusion boundaries are the same, $\mathrm{dom}(I_{P,U,\mathrm{B}}^{ * }((V,F,A,A_R))) \subseteq \mathrm{top}(\lfloor\mathrm{bmax}/\mathrm{mmax}\rfloor)(\mathrm{elements}(Z_{P,A,A_R,F,\mathrm{B}}))$.

The tuple set list builder never returns more than $\lfloor\mathrm{bmax}/\mathrm{mmax}\rfloor$ tuples, because of the trailing arbitrary ordering of the tuples, $D_{\mathcal{X}}(J)$.

Although inducers are defined only for substrate histograms, $A \in \mathcal{A}_z$, which are constrained such that the independent sample histogram is completely effective, $A^{\mathrm{XF}} = A^{\mathrm{C}}$, the implementation of induction computers here only requires that the argument histogram, $X$, be in the system $U$, $X \in \mathcal{A}_U$.

The limited-underlying tuple set list builder returns the non-independent content sum factorial, $a_1-b_1 = I_{\mathrm{\mathrm{S}\approx\mathrm{ln}!}}^{ * }(B) - I_{\mathrm{\mathrm{S}\approx\mathrm{ln}!}}^{ * }(B_R)$, to avoid unnecessary recomputation subsequently in the partitioner.

The computation of $\mathrm{sumlayer}(F,J)$ is costly so some implementations may exclude it, especially as it only affects tuples in the inclusion boundary (Haskell). If the layerer (see later) is subject to the excluded-self restriction then it is less likely that there will be duplicate tuple alignments, so the inclusion bouundary is more likely to be a singleton.

Another performance improvement is to restrict the builder to variables that are multi-effective, $\{u : u \in V,~|(X\%\{u\})^{\mathrm{F}}|>1\}$ (Haskell) (Python). This prevents some variables from being included in the tuple that are necessarily independent of the other variables in the tuple.

### Highest-layer limited-derived derived variables set builder

To implement the highest-layer limited-derived derived variables set list maximiser, $Z_{P,A,A_R,F,\mathrm{D,d}}$, (Haskell) define the highest-layer limited-derived derived variables set builder $I_{P,U,\mathrm{D,d}} \in \mathrm{computers}$ such that (i) the domain is $\mathrm{domain}(I_{P,U,\mathrm{D,d}}) = \mathrm{P}(\mathcal{V}_U) \times \mathcal{F}_{U,1} \times \mathcal{A}_U \times \mathcal{A}_U$, (ii) the range is $\mathrm{range}(I_{P,U,\mathrm{D,d}}) = (\mathrm{P}(\mathcal{V}_U) \times \mathcal{A}_U \times \mathcal{A}_U) \to \mathbf{Q}$, and (iii) the application is (Haskell) $\begin{eqnarray} I_{P,U,\mathrm{D,d}}^{ * }((V,F,X,X_R)) = \mathrm{maxd}(\mathrm{buildd}(\mathrm{vars}(F) \setminus V,X,X_R,\mathrm{init}(\mathrm{der}(F)),\emptyset)) \end{eqnarray}$ where $\mathrm{buildd} \in \mathrm{P}(\mathcal{V}_U) \times \mathcal{A}_U \times \mathcal{A}_U \times \mathrm{buildt} \times \mathrm{buildt} \to \mathrm{buildt}$ is defined $\begin{eqnarray} &&\mathrm{buildd}(W,X,X_R,Q,N) = \\ &&\hspace{1em}\mathrm{if}(M \neq \emptyset, \mathrm{buildb}(W,X,X_R,M,N \cup M), \mathrm{final}(N)) : \\ &&\hspace{2em}P = \{J : (((K,\cdot,\cdot),\cdot),\cdot) \in Q,~w \in W \setminus K,~J = K \cup \{w\}\}, \\ &&\hspace{2em}M = \mathrm{top}(\mathrm{omax})(\{(((J,B,B_R),(a-b)/c), \\ &&\hspace{10em}((a-b)/c,~-l,~-b/c,~-u,~D_{\mathcal{X}}(J))) :\\ &&\hspace{4em}J \in P,~u = |J^{\mathrm{C}}|,~u \leq \mathrm{wmax},~\mathrm{der}(\mathrm{depends}(F,J))=J,\\ &&\hspace{4em}m = |J|,~l = \mathrm{sumlayer}(F,J),\\ &&\hspace{4em}B = I_{\%}^{ * }((J,X)),~B_R = I_{\%}^{ * }((J,X_R)),\\ &&\hspace{4em}a = I_{\mathrm{a}}^{ * }(B),~b = I_{\mathrm{a}}^{ * }(B_R),~c=I_{\approx\mathrm{pow}}^{ * }((u,1/m))\}) \end{eqnarray}$ where the power approxer $I_{\approx\mathrm{pow}} \in \mathrm{computers}$ is such that $I_{\approx\mathrm{pow}}^{ * }((x,y)) \approx x^y$, and the alignmenter I_{\mathrm{a}} = \mathrm{alignmenter} \in \mathrm{computers} is such that $I_{\mathrm{a}}^{ * }(A) \approx \mathrm{algn}(A)$.

The tuples of the highest-layer limited-derived derived variables set builder $I_{P,U,\mathrm{D,d}}$, are pluri-variate, $\forall ((K,\cdot,\cdot),\cdot) \in I_{P,U,\mathrm{D,d}}^{ * }((V,F,X,X_R))~(|K|>1)$.

The $\mathrm{buildd}$ function argument histograms, $X,X_R$, have the same variables, $\mathrm{vars}(X)=\mathrm{vars}(X_R)$. The argument variables, $W$, are a subset of the argument histograms variables, $W \subseteq \mathrm{vars}(X)$. It is sufficient that the system, $U$, contains the variables of the argument histograms, $\mathrm{vars}(X) \subseteq \mathrm{vars}(U)$.

The argument histograms, $X,X_R$, are in a list representation or binary map representation, because in some cases the volume, $|\mathrm{vars}(X)^{\mathrm{C}}|$, is impracticably large for an array representation. The resultant histograms, $B,B_R$, may be in array representation because their volume cannot exceed the given limit, $|B^{\mathrm{C}}| \leq \mathrm{wmax}$, which is chosen to be practicable.

If the fud is a non-empty substrate fud, $F \in \mathcal{F}_{U_A,V_A} \setminus \{\emptyset\}$, the highest-layer limited-derived derived variables set builder implements the highest-layer limited-derived derived variables set list maximiser, insofar as the inclusion boundaries are the same, $\mathrm{dom}(I_{P,U,\mathrm{D,b}}^{ * }((V,F,A,A_R))) \subseteq \mathrm{top}(\lfloor\mathrm{bmax}/\mathrm{mmax}\rfloor)(\mathrm{elements}(Z_{P,A,A_R,F,\mathrm{D,b}}))$ Similarly to the tuple builder above, some implementations may drop the computation of $\mathrm{sumlayer}(F,J)$, especially if the layerer is subject to the excluded-self restriction (Haskell) (Python).

Also, some implementations may drop the exclusion of hidden variables $J = \mathrm{der}(\mathrm{depends}(F,J))$. This computation is costly, but dropping may in some cases lead to tuple rolls that result in a single derived variable. However, this is also true of the excluded-self restriction which is applied in the layerer (see later).

### Tuple partitioner

In order to implement the limited-valency contracted decrementing linear non-overlapping fuds list maximiser initial set, $R_{P,A,A_R,F,\mathrm{n,w},-,K}$, (Haskell) the tuple partitioner $I_{P,U,\mathrm{K}} \in \mathrm{computers}$ is defined such that (i) $\mathrm{domain}(I_{P,U,\mathrm{K}}) = (\mathrm{P}(\mathcal{V}_U) \times \mathcal{A}_U \times \mathcal{A}_U) \times \mathbf{Q}$, (ii) $\mathrm{range}(I_{P,U,\mathrm{K}}) = \mathrm{P}(\mathcal{L}(\mathcal{S}_U \to \mathbf{N}) \times \mathcal{A}_U \times \mathcal{A}_U)$, and (iii) the application is (Haskell) $\begin{eqnarray} &&I_{P,U,\mathrm{K}}^{ * }(((K,B,B_R),y_1)) = \\ &&\hspace{1em}\mathrm{topd}(\mathrm{pmax})(\{((N,C,C_R),~((y_1-a_2+b_2)/c,~b_2/c,~-m,~D_{\mathcal{X}}(J))) :\\ &&\hspace{2em}m \in \{2 \ldots \mathrm{mmax}\},~Y \in \mathrm{S}(K,m),~(\forall J \in Y~(|J^{\mathrm{C}}| \leq \mathrm{umax})),\\ &&\hspace{2em}N = \{(i,\mathrm{order}(D_{\mathrm{S}},J^{\mathrm{CS}})) : (J,i) \in \mathrm{order}(D_{\mathrm{P}(\mathcal{V})},Y)\},\\ &&\hspace{2em}T=(\{\bigcup \{S \cup \{(w,u)\} : (w,(S,u)) \in L\} : L \in \prod N\}^{\mathrm{U}},\{1 \ldots m\}),\\ &&\hspace{2em}C = I_{ * \mathrm{T}}^{ * }((T,B)),~C_R = I_{ * \mathrm{T}}^{ * }((T,B_R)),\\ &&\hspace{2em}a_2 = I_{\mathrm{\mathrm{S}\approx\mathrm{ln}!}}^{ * }(I_{\mathrm{X}}^{ * }(C)),~b_2 = I_{\mathrm{\mathrm{S}\approx\mathrm{ln}!}}^{ * }(I_{\mathrm{X}}^{ * }(C_R)),~c=I_{\approx\mathrm{pow}}^{ * }((v,1/m))\}) \end{eqnarray}$ where $v = |K^{\mathrm{C}}|$, $\mathrm{vars}(U) \cap \mathbf{N} = \emptyset$, $D_{\mathrm{S}} \in \mathrm{enums}(\mathcal{S}_U)$, $D_{\mathrm{P}(\mathcal{V})} \in \mathrm{enums}(\mathrm{P}(\mathcal{V}_U))$, and the transformer $I_{\mathrm{ * T}} = \mathrm{transformer} \in \mathrm{computers}$ is such that $I_{ * \mathrm{T}}^{ * }((T,A)) = A * T$.

The tuple partitioner has non-empty application if $|K| \geq 2$. The resultant histograms, $C,C_R$ where $(\cdot,C,C_R) \in I_{P,U,\mathrm{K}}^{ * }((K,B,B_R,y_1))$, should be in array representation, suitable for succeeding value roll computers. The tuple partitioner assumes that the array index variables are not system variables, $\mathrm{vars}(U) \cap \mathbf{N} = \emptyset$.

Because (i) the alignmenter equals the difference in the non-independent sum log factorialer and the independent sum log factorialer, $I_{\mathrm{a}}^{ * }(A) = I_{\mathrm{\mathrm{S}\approx\mathrm{ln}!}}^{ * }(A) - I_{\mathrm{\mathrm{S}\approx\mathrm{ln}!}}^{ * }(A^{\mathrm{X}})$, and (ii) the non-independent terms are constant, $\sum_{S \in C^{\mathrm{S}}} \ln \Gamma_! C_S = \sum_{S \in B^{\mathrm{S}}} \ln \Gamma_! B_S$, so only the independent terms, $\sum_{S \in C^{\mathrm{XS}}} \ln \Gamma_! C^{\mathrm{X}}_S$, need be computed for each of the possible partitions. Thus the non-independent part of the computation of the difference in alignments, $I_{\mathrm{a}}^{ * }(C)-I_{\mathrm{a}}^{ * }(C_R)$, need not be re-computed, but can be carried from the tuple builder.

### Maximum-roll-by-derived-dimension tuple partitioner

In order to implement the maximum-roll-by-derived-dimension limited-valency contracted decrementing linear non-overlapping fuds list maximiser initial set, $R_{P,A,A_R,F,\mathrm{n,w},-,K,\mathrm{mm}}$, (Haskell) the maximum-roll-by-derived-dimension tuple partitioner $I_{P,U,\mathrm{K},\mathrm{mm}} \in \mathrm{computers}$ is defined such that (i) $\mathrm{domain}(I_{P,U,\mathrm{K},\mathrm{mm}}) = (\mathrm{P}(\mathcal{V}_U) \times \mathcal{A}_U \times \mathcal{A}_U) \times \mathbf{Q}$, (ii) $\mathrm{range}(I_{P,U,\mathrm{K},\mathrm{mm}}) = \mathrm{P}(\mathcal{L}(\mathcal{S}_U \to \mathbf{N}) \times \mathcal{A}_U \times \mathcal{A}_U)$, and (iii) the application is (Haskell) (Python) $\begin{eqnarray} &&I_{P,U,\mathrm{K},\mathrm{mm}}^{ * }(((K,B,B_R),y_1)) = \\ &&\hspace{1em}\bigcup \{\mathrm{topd}(\mathrm{pmax})(\{((N,C,C_R),~((y_1-a_2+b_2)/c,~b_2/c,~-m,~D_{\mathcal{X}}(J))) :\\ &&\hspace{3em}Y \in \mathrm{S}(K,m),~(\forall J \in Y~(|J^{\mathrm{C}}| \leq \mathrm{umax})),\\ &&\hspace{3em}N = \{(i,\mathrm{order}(D_{\mathrm{S}},J^{\mathrm{CS}})) : (J,i) \in \mathrm{order}(D_{\mathrm{P}(\mathcal{V})},Y)\},\\ &&\hspace{3em}T=(\{\bigcup \{S \cup \{(w,u)\} : (w,(S,u)) \in L\} : L \in \prod N\}^{\mathrm{U}},\{1 \ldots m\}),\\ &&\hspace{3em}C = I_{ * \mathrm{T}}^{ * }((T,B)),~C_R = I_{ * \mathrm{T}}^{ * }((T,B_R)),\\ &&\hspace{3em}a_2 = I_{\mathrm{\mathrm{S}\approx\mathrm{ln}!}}^{ * }(I_{\mathrm{X}}^{ * }(C)),~b_2 = I_{\mathrm{\mathrm{S}\approx\mathrm{ln}!}}^{ * }(I_{\mathrm{X}}^{ * }(C_R)),~c=I_{\approx\mathrm{pow}}^{ * }((v,1/m))\}) : \\ &&\hspace{2em}m \in \{2 \ldots \mathrm{mmax}\}\} \end{eqnarray}$

### Tuple-partition value roller

After constructing the initial set in a tuple partitioner, $I_{P,U,\mathrm{K}}$, the remainder of the limited-valency contracted decrementing linear non-overlapping fuds list maximiser, $Z_{P,A,A_R,F,\mathrm{n,w},-,K}$, (Haskell) is implemented by means of value roll computers, defined in section ‘Value roll computers’. The tuple-partition value roller $I_{P,U,\mathrm{R}} \in \mathrm{computers}$ is defined such that (i) the domain is $\mathrm{domain}(I_{P,U,\mathrm{R}}) = \mathrm{P}(\mathcal{L}(\mathcal{S}_U \to \mathbf{N}) \times \mathcal{A}_U \times \mathcal{A}_U)$, (ii) the range is $\mathrm{range}(I_{P,U,\mathrm{R}}) = \mathrm{P}(\mathcal{L}(\mathcal{S}_U \to \mathbf{N}))$, and (iii) the application is (Haskell) (Python) $\begin{eqnarray} &&I_{P,U,\mathrm{R}}^{ * }(Q) = \\ &&\hspace{1em}\{N’ :\\ &&\hspace{2em}M = \{((N,R_A,R_B),(a-b)/c) : \\ &&\hspace{6em}(N,A,B) \in Q,\\ &&\hspace{6em}a=I_{\mathrm{a}}^{ * }(A),~b=I_{\mathrm{a}}^{ * }(B),\\ &&\hspace{6em}w = \prod_{(\cdot,I) \in N} |\mathrm{ran}(I)|,~m =|N|,~c = I_{\approx\mathrm{pow}}^{ * }((w,1/m)),\\ &&\hspace{6em}R_A = (a,A,I_{\mathrm{X}}^{ * }(A)),~R_B = (b,B,I_{\mathrm{X}}^{ * }(B))\}, \\ &&\hspace{2em}(N’,\cdot,\cdot) \in \mathrm{topd}(\mathrm{pmax})(\mathrm{rollb}(M,M))\} \end{eqnarray}$ where $\mathrm{rollb} \in \mathrm{rollbt} \times \mathrm{rollbt} \to \mathrm{rollbt}$, where $\mathrm{rollbt} = \mathcal{L}(\mathcal{S}_U \to \mathbf{N}) \times (\mathbf{Q} \times \mathcal{A}_U \times \mathcal{A}_U)^2 \to \mathbf{Q}$, is defined $\begin{eqnarray} &&\mathrm{rollb}(Q,P) = \\ &&\hspace{1em}\mathrm{if}(M \neq \emptyset, \mathrm{rollb}(M,P \cup M),P) : \\ &&\hspace{2em}M = \mathrm{top}(\mathrm{pmax})(\{((N’,R’_A,R’_B), (a’-b’)/c’) :\\ &&\hspace{4em}((N,R_A,R_B),\cdot) \in Q,\\ &&\hspace{4em}V=\mathrm{dom}(N),~(\cdot,A,A_{\mathrm{X}}) = R_A,~(\cdot,B,B_{\mathrm{X}}) = R_B,\\ &&\hspace{4em}Y_A = \mathrm{rals}(N,A,A_{\mathrm{X}}),~Y_B = \mathrm{rals}(N,B,B_{\mathrm{X}}),\\ &&\hspace{4em}(v,I) \in N,~|\mathrm{ran}(I)|>2,~s,t \in \mathrm{ran}(I),~s > t,\\ &&\hspace{4em}N’ = N \setminus \{(v,I)\} \cup \{(v,\{(s,t)\} \circ I)\},\\ &&\hspace{4em}R’_A = I_{\mathrm{R,a}}^{ * }(((V,v,s,t),Y_A,R_A)),\\ &&\hspace{4em}R’_B = I_{\mathrm{R,a}}^{ * }(((V,v,s,t),Y_B,R_B)),\\ &&\hspace{4em}(a’,\cdot,\cdot) = R’_A,~(b’,\cdot,\cdot) = R’_B,\\ &&\hspace{4em}w = \prod_{(\cdot,I’) \in N’} |\mathrm{ran}(I’)|,~m =|V|,~c’ = I_{\approx\mathrm{pow}}^{ * }((w,1/m)) \}) \end{eqnarray}$ where $I_{\mathrm{R,a}} = \mathrm{rollValueAlignmenter} \in \mathrm{computers}$ is defined as $\begin{eqnarray} &&I_{\mathrm{R,a}}^{ * }(((V,v,s,t), Y, (a,A,A^{\mathrm{X}})) = \\ &&\hspace{2em}(I^{ * }_{\mathrm{a}}(A * (V,v,s,t)^{\mathrm{R}}), A * (V,v,s,t)^{\mathrm{R}},(A * (V,v,s,t)^{\mathrm{R}})^{\mathrm{X}}) \end{eqnarray}$ and $\mathrm{rals} \in \mathcal{L}(\mathcal{S}_U \to \mathbf{N}) \times \mathcal{A} \times \mathcal{A} \to (\mathcal{V} \to (\mathcal{S} \to \mathbf{Q}))$ is defined as $\begin{eqnarray} &&\mathrm{rals}(N,A,A_{\mathrm{X}}) := \\ &&\hspace{2em}\{(w,\{(S, \sum (I_{\mathrm{\approx\mathrm{ln}!}}^{ * }(A(T)) : T \in A^{\mathrm{S}},~T \supseteq S) - \\ &&\hspace{5em}\sum (I_{\mathrm{\approx\mathrm{ln}!}}^{ * }(A_{\mathrm{X}}(T)) : T \in A_{\mathrm{X}}^{\mathrm{S}},~T \supseteq S)) : \\ & &\hspace{7em}u \in \mathrm{ran}(N_w),~S = \{(w,u)\}\}) : w \in \mathrm{dom}(N)\} \end{eqnarray}$ The roll value alignmenter, $I_{\mathrm{R,a}}$, requires that all histograms are implemented in array histogram representations on ordered list state representations.

The value roll compositions do not necessarily lead to a contiguous set, so in some cases $\mathrm{ran}(I) \neq \{1 \ldots |\mathrm{ran}(I)|\}$. In some implementations, however, a source value may be completely removed from the representation, rather than simply zeroed out. In these cases the value roll compositions must also value roll by one all values higher than the source values. That is, instead of $\{(s,t)\} \circ I$ the composition is $\{(r,r-1) : r \in \mathrm{ran}(I),~r>s\} \circ \{(s,t)\} \circ I$.

### Maximum-roll tuple-partition value roller

The operation to take the $\mathrm{top}(\mathrm{pmax})$ at each step requires that the value roll list composition, $I$, be computed for each value roll because different value roll lists can have the same composition. However, the computation is costly, so some implementations may simply take the top value roll lists rather than the top value roll list compositions. The functionality is only equivalent with respect to value roll list compositions when $\mathrm{pmax}=1$.

An alternative is to implement the limited-valency maximum-roll contracted decrementing linear non-overlapping fuds tree maximiser, $Z_{P,A,A_R,F,\mathrm{n,w},-,K,\mathrm{mr}}$, (Haskell) which only applies the $\mathrm{pmax}$ parameter to the initial set. The tuple partitioner, $I_{P,U,\mathrm{K}}$, is unchanged and the tuple-partition value roller, $I_{P,U,\mathrm{R}}$, is modified to use the $\mathrm{max}$ inclusion function instead of $\mathrm{top}(\mathrm{pmax})$. The maximum-roll tuple-partition value roller $I_{P,U,\mathrm{R,mr}} \in \mathrm{computers}$ is defined such that (i) the domain is $\mathrm{domain}(I_{P,U,\mathrm{R,mr}}) = \mathcal{L}(\mathcal{S}_U \to \mathbf{N}) \times \mathcal{A}_U \times \mathcal{A}_U$, (ii) the range is $\mathrm{range}(I_{P,U,\mathrm{R,mr}}) = \mathrm{P}(\mathcal{L}(\mathcal{S}_U \to \mathbf{N}))$, and (iii) the application is (Haskell) $\begin{eqnarray} &&I_{P,U,\mathrm{R,mr}}^{ * }((N,A,B)) = \\ &&\hspace{1em}\{N’ :\\ &&\hspace{2em}M = \{((N,R_A,R_B),(a-b)/c) : \\ &&\hspace{6em}a=I_{\mathrm{a}}^{ * }(A),~b=I_{\mathrm{a}}^{ * }(B),\\ &&\hspace{6em}w = \prod_{(\cdot,I) \in N} |\mathrm{ran}(I)|,~m =|N|,~c = I_{\approx\mathrm{pow}}^{ * }((w,1/m)),\\ &&\hspace{6em}R_A = (a,A,I_{\mathrm{X}}^{ * }(A)),~R_B = (b,B,I_{\mathrm{X}}^{ * }(B))\}, \\ &&\hspace{2em}(N’,\cdot,\cdot) \in \mathrm{maxd}(\mathrm{rollb}(M,M))\} \end{eqnarray}$ and $\begin{eqnarray} &&\mathrm{rollb}(Q,P) = \\ &&\hspace{1em}\mathrm{if}(M \neq \emptyset, \mathrm{rollb}(M,P \cup M),P) : \\ &&\hspace{2em}M = \mathrm{max}(\{((N’,R’_A,R’_B), (a’-b’)/c’) :\\ &&\hspace{4em}((N,R_A,R_B),\cdot) \in Q,\\ &&\hspace{4em}V=\mathrm{dom}(N),~(\cdot,A,A_{\mathrm{X}}) = R_A,~(\cdot,B,B_{\mathrm{X}}) = R_B,\\ &&\hspace{4em}Y_A = \mathrm{rals}(N,A,A_{\mathrm{X}}),~Y_B = \mathrm{rals}(N,B,B_{\mathrm{X}}),\\ &&\hspace{4em}(v,I) \in N,~|\mathrm{ran}(I)|>2,~s,t \in \mathrm{ran}(I),~s > t,\\ &&\hspace{4em}N’ = N \setminus \{(v,I)\} \cup \{(v,\{(s,t)\} \circ I)\},\\ &&\hspace{4em}R’_A = I_{\mathrm{R,a}}^{ * }(((V,v,s,t),Y_A,R_A)),\\ &&\hspace{4em}R’_B = I_{\mathrm{R,a}}^{ * }(((V,v,s,t),Y_B,R_B)),\\ &&\hspace{4em}(a’,\cdot,\cdot) = R’_A,~(b’,\cdot,\cdot) = R’_B,\\ &&\hspace{4em}w = \prod_{(\cdot,I’) \in N’} |\mathrm{ran}(I’)|,~m =|V|,~c’ = I_{\approx\mathrm{pow}}^{ * }((w,1/m)) \}) \end{eqnarray}$

### Highest-layer layerer

Next, the functionality of (i) the highest-layer limited-layer limited-underlying limited-breadth fud tree searcher, $Z_{P,A,A_R,\mathrm{L,d}}$, (Haskell) and (ii) the highest-layer limited-derived derived variables set list maximiser, $Z_{P,A,A_R,F,\mathrm{D,d}}$, (Haskell) is implemented in the highest-layer layerer $I_{P,U,\mathrm{L,d}} \in \mathrm{computers}$, which is defined such that (i) the domain is $\mathrm{domain}(I_{P,U,\mathrm{L,d}}) = \mathrm{P}(\mathcal{V}_U) \times \mathcal{A}_U \times \mathcal{A}_U \times \mathbf{N}$, (ii) the range is $\mathrm{range}(I_{P,U,\mathrm{L,d}}) = \mathcal{U} \times \mathcal{F} \times (\mathrm{P}(\mathcal{V}) \to \mathbf{Q})$, and (iii) the application is (Haskell) $\begin{eqnarray} I_{P,U,\mathrm{L,d}}^{ * }((V,A,A_R,f)) = \mathrm{layer}(V,U,\emptyset,\emptyset,A,A_R,f,1) \end{eqnarray}$ where $\begin{eqnarray} &&\mathrm{layer} \in \mathrm{P}(\mathcal{V}) \times \mathcal{U} \times \mathcal{F} \times ((\mathrm{P}(\mathcal{V}) \times \mathcal{A} \times \mathcal{A}) \to \mathbf{Q}) \times \mathcal{A} \times \mathcal{A} \times \mathbf{N} \times \mathbf{N} \to \\ &&\hspace{20em}(\mathcal{U} \times \mathcal{F} \times (\mathrm{P}(\mathcal{V}) \to \mathbf{Q})) \end{eqnarray}$ is defined $\begin{eqnarray} &&\mathrm{layer}(V,U,F,M,X,X_R,f,l) = \\ &&\hspace{1em}\mathrm{if}((l \leq \mathrm{lmax}) \wedge (H \neq \emptyset) \wedge (M \neq \emptyset \implies \mathrm{maxr}(M’)>\mathrm{maxr}(M)),\\ &&\hspace{4em}\mathrm{layer}(V,U’,F \cup H,M’,X’,X’_R,f,l+1),\\ &&\hspace{4em}(U,F,M)) :\\ &&\hspace{2em}L = \{(b,(T,(w, \mathrm{ran}(I)))) : \\ &&\hspace{4em}((\cdot,I),b) \in \mathrm{order}(D_{\mathrm{L}},\{(v,I) : \\ &&\hspace{6em}Q \in I_{P,U,\mathrm{B}}^{ * }((V,F,X,X_R)),\\ &&\hspace{6em}N \in I_{P,U,\mathrm{R}}^{ * }(I_{P,U,\mathrm{K}}^{ * }(Q)),\\ &&\hspace{6em}(v,I) \in N\}),\\ &&\hspace{4em}w=(f,l,b),~T = (\{S \cup \{(w,k)\} : (S,k) \in I\},\{w\})\},\\ &&\hspace{2em}L’ = \{(i,(T,(w,W))) : (i,(T,(w,W))) \in L, \\ &&\hspace{4em}\forall (i’,(T’,(w’,W’))) \in L~(i>i’ \implies T^{\mathrm{P}} \neq T^{‘\mathrm{P}})\},\\ &&\hspace{2em}H = \mathrm{dom}(\mathrm{set}(L’)),~U’ = U \cup \mathrm{ran}(\mathrm{set}(L’)),\\ &&\hspace{2em}X’ = I_{\mathrm{ * X}}^{ * }((H,X)),~X’_R = I_{\mathrm{ * X}}^{ * }((H,X_R)),\\ &&\hspace{2em}M’ = I_{P,U’,\mathrm{D,d}}^{ * }((V,F \cup H,X’,X’_R)) \end{eqnarray}$ where $I_{\mathrm{ * X}} = \mathrm{applier} \in \mathrm{computers}$.

Here the order $D_{\mathrm{L}}$ is some enumeration of the layer fud representation, $D_{\mathrm{L}} \in \mathrm{enums}(\mathbf{N} \times (\mathcal{S}_U \to \mathbf{N}))$.

The new variable, $w=(f,l,b)$, is constructed from the fud identifier, $f$, the layer identifier, $l$, and the position within the breadth of the layer fud, $b$. The new variable, $w$, is added to a new system, $U’$. The values of the new variable are cardinal numbers, $U’(w) \subset \mathbf{N}_{>0}$, such that $1 \in U’(w)$. The values are not necessarily contiguous, unless the implementation completely removes source values, in which case $U’(w) = \{1 \ldots |U’(w)|\}$.

### Highest-layer maximum-roll layerer

A variation of the highest-layer layerer, $I_{P,U,\mathrm{L,d}}$, is to implement the limited-valency maximum-roll contracted decrementing linear non-overlapping fuds tree maximiser, $Z_{P,A,A_R,F,\mathrm{n,w},-,K,\mathrm{mr}}$, (Haskell) by means of the maximum-roll tuple-partition value roller, $I_{P,U,\mathrm{R,mr}}$ (Haskell). The highest-layer maximum-roll layerer $I_{P,U,\mathrm{L,mr,d}} \in \mathrm{computers}$ is defined such that the application is (Haskell) $\begin{eqnarray} I_{P,U,\mathrm{L,mr,d}}^{ * }((V,A,A_R,f)) = \mathrm{layer}(V,U,\emptyset,\emptyset,A,A_R,f,1) \end{eqnarray}$ and $\begin{eqnarray} &&\mathrm{layer}(V,U,F,M,X,X_R,f,l) = \\ &&\hspace{1em}\mathrm{if}((l \leq \mathrm{lmax}) \wedge (H \neq \emptyset) \wedge (M \neq \emptyset \implies \mathrm{maxr}(M’)>\mathrm{maxr}(M)),\\ &&\hspace{4em}\mathrm{layer}(V,U’,F \cup H,M’,X’,X’_R,f,l+1),\\ &&\hspace{4em}(U,F,M)) :\\ &&\hspace{2em}L = \{(b,(T,(w, \mathrm{ran}(I)))) : \\ &&\hspace{4em}((\cdot,I),b) \in \mathrm{order}(D_{\mathrm{L}},\{(v,I) : \\ &&\hspace{6em}Q \in I_{P,U,\mathrm{B}}^{ * }((V,F,X,X_R)),\\ &&\hspace{6em}P \in I_{P,U,\mathrm{K}}^{ * }(Q),~N \in I_{P,U,\mathrm{R,mr}}^{ * }(P),\\ &&\hspace{6em}(v,I) \in N\}),\\ &&\hspace{4em}w=(f,l,b),~T = (\{S \cup \{(w,k)\} : (S,k) \in I\},\{w\})\},\\ &&\hspace{2em}L’ = \{(i,(T,(w,W))) : (i,(T,(w,W))) \in L, \\ &&\hspace{4em}\forall (i’,(T’,(w’,W’))) \in L~(i>i’ \implies T^{\mathrm{P}} \neq T^{‘\mathrm{P}})\},\\ &&\hspace{2em}H = \mathrm{dom}(\mathrm{set}(L’)),~U’ = U \cup \mathrm{ran}(\mathrm{set}(L’)),\\ &&\hspace{2em}X’ = I_{\mathrm{ * X}}^{ * }((H,X)),~X’_R = I_{\mathrm{ * X}}^{ * }((H,X_R)),\\ &&\hspace{2em}M’ = I_{P,U’,\mathrm{D,d}}^{ * }((V,F \cup H,X’,X’_R)) \end{eqnarray}$

### Highest-layer excluded-self maximum-roll layerer

A further variation of the highest-layer maximum-roll layerer $I_{P,U,\mathrm{L,mr,d}}$, is to add the functionality of the excluded-self contracted decrementing linear non-overlapping fuds tree maximiser, $Z_{P,A,A_R,\mathrm{L,xs}}$, (Haskell) by excluding self partitions. The highest-layer excluded-self maximum-roll layerer $I_{P,U,\mathrm{L,mr,xs,d}} \in \mathrm{computers}$ is defined such that the application is (Haskell) $\begin{eqnarray} I_{P,U,\mathrm{L,mr,xs,d}}^{ * }((V,A,A_R,f)) = \mathrm{layer}(V,U,\emptyset,\emptyset,A,A_R,f,1) \end{eqnarray}$ and $\begin{eqnarray} &&\mathrm{layer}(V,U,F,M,X,X_R,f,l) = \\ &&\hspace{1em}\mathrm{if}((l \leq \mathrm{lmax}) \wedge (H \neq \emptyset) \wedge (M \neq \emptyset \implies \mathrm{maxr}(M’)>\mathrm{maxr}(M)),\\ &&\hspace{4em}\mathrm{layer}(V,U’,F \cup H,M’,X’,X’_R,f,l+1),\\ &&\hspace{4em}(U,F,M)) :\\ &&\hspace{2em}L = \{(b,(T,(w, \mathrm{ran}(I)))) : \\ &&\hspace{4em}((\cdot,I),b) \in \mathrm{order}(D_{\mathrm{L}},\{(v,I) : \\ &&\hspace{6em}Q \in I_{P,U,\mathrm{B}}^{ * }((V,F,X,X_R)),\\ &&\hspace{6em}P \in I_{P,U,\mathrm{K}}^{ * }(Q),~N \in I_{P,U,\mathrm{R,mr}}^{ * }(P),\\ &&\hspace{6em}(v,I) \in N,~|\mathrm{ran}(I)|<|I|\}),\\ &&\hspace{4em}w=(f,l,b),~T = (\{S \cup \{(w,k)\} : (S,k) \in I\},\{w\})\},\\ &&\hspace{2em}L’ = \{(i,(T,(w,W))) : (i,(T,(w,W))) \in L, \\ &&\hspace{4em}\forall (i’,(T’,(w’,W’))) \in L~(i>i’ \implies T^{\mathrm{P}} \neq T^{‘\mathrm{P}})\},\\ &&\hspace{2em}H = \mathrm{dom}(\mathrm{set}(L’)),~U’ = U \cup \mathrm{ran}(\mathrm{set}(L’)),\\ &&\hspace{2em}X’ = I_{\mathrm{ * X}}^{ * }((H,X)),~X’_R = I_{\mathrm{ * X}}^{ * }((H,X_R)),\\ &&\hspace{2em}M’ = I_{P,U’,\mathrm{D,d}}^{ * }((V,F \cup H,X’,X’_R)) \end{eqnarray}$

### Highest-layer maximum-roll-by-derived-dimension layerer

A variation of the highest-layer maximum-roll layerer, $I_{P,U,\mathrm{L,mr,d}}$, is to implement the limited-valency maximum-roll-by-derived-dimension contracted decrementing linear non-overlapping fuds tree maximiser, $Z_{P,A,A_R,F,\mathrm{n,w},-,K,\mathrm{mm}}$, by means of the maximum-roll-by-derived-dimension tuple partitioner, $I_{P,U,\mathrm{K},\mathrm{mm}}$ (Haskell). The highest-layer maximum-roll-by-derived-dimension layerer $I_{P,U,\mathrm{L,mm,d}} \in \mathrm{computers}$ is defined such that the application is $\begin{eqnarray} I_{P,U,\mathrm{L,mm,d}}^{ * }((V,A,A_R,f)) = \mathrm{layer}(V,U,\emptyset,\emptyset,A,A_R,f,1) \end{eqnarray}$ and $\begin{eqnarray} &&\mathrm{layer}(V,U,F,M,X,X_R,f,l) = \\ &&\hspace{1em}\mathrm{if}((l \leq \mathrm{lmax}) \wedge (H \neq \emptyset) \wedge (M \neq \emptyset \implies \mathrm{maxr}(M’)>\mathrm{maxr}(M)),\\ &&\hspace{4em}\mathrm{layer}(V,U’,F \cup H,M’,X’,X’_R,f,l+1),\\ &&\hspace{4em}(U,F,M)) :\\ &&\hspace{2em}L = \{(b,(T,(w, \mathrm{ran}(I)))) : \\ &&\hspace{4em}((\cdot,I),b) \in \mathrm{order}(D_{\mathrm{L}},\{(v,I) : \\ &&\hspace{6em}Q \in I_{P,U,\mathrm{B}}^{ * }((V,F,X,X_R)),\\ &&\hspace{6em}P \in I_{P,U,\mathrm{K},\mathrm{mm}}^{ * }(Q),~N \in I_{P,U,\mathrm{R,mr}}^{ * }(P),\\ &&\hspace{6em}(v,I) \in N\}),\\ &&\hspace{4em}w=(f,l,b),~T = (\{S \cup \{(w,k)\} : (S,k) \in I\},\{w\})\},\\ &&\hspace{2em}L’ = \{(i,(T,(w,W))) : (i,(T,(w,W))) \in L, \\ &&\hspace{4em}\forall (i’,(T’,(w’,W’))) \in L~(i>i’ \implies T^{\mathrm{P}} \neq T^{‘\mathrm{P}})\},\\ &&\hspace{2em}H = \mathrm{dom}(\mathrm{set}(L’)),~U’ = U \cup \mathrm{ran}(\mathrm{set}(L’)),\\ &&\hspace{2em}X’ = I_{\mathrm{ * X}}^{ * }((H,X)),~X’_R = I_{\mathrm{ * X}}^{ * }((H,X_R)),\\ &&\hspace{2em}M’ = I_{P,U’,\mathrm{D,d}}^{ * }((V,F \cup H,X’,X’_R)) \end{eqnarray}$

### Highest-layer excluded-self maximum-roll-by-derived-dimension layerer

A further variation of the highest-layer maximum-roll-by-derived-dimension layerer $I_{P,U,\mathrm{L,mm,d}}$, is to add the functionality of the excluded-self contracted decrementing linear non-overlapping fuds tree maximiser, $Z_{P,A,A_R,\mathrm{L,xs}}$, (Haskell) by excluding self partitions. The highest-layer excluded-self maximum-roll-by-derived-dimension layerer $I_{P,U,\mathrm{L,mm,xs,d}} \in \mathrm{computers}$ is defined such that the application is (Haskell) (Python) $\begin{eqnarray} I_{P,U,\mathrm{L,mm,xs,d}}^{ * }((V,A,A_R,f)) = \mathrm{layer}(V,U,\emptyset,\emptyset,A,A_R,f,1) \end{eqnarray}$ and $\begin{eqnarray} &&\mathrm{layer}(V,U,F,M,X,X_R,f,l) = \\ &&\hspace{1em}\mathrm{if}((l \leq \mathrm{lmax}) \wedge (H \neq \emptyset) \wedge (M \neq \emptyset \implies \mathrm{maxr}(M’)>\mathrm{maxr}(M)),\\ &&\hspace{4em}\mathrm{layer}(V,U’,F \cup H,M’,X’,X’_R,f,l+1),\\ &&\hspace{4em}(U,F,M)) :\\ &&\hspace{2em}L = \{(b,(T,(w, \mathrm{ran}(I)))) : \\ &&\hspace{4em}((\cdot,I),b) \in \mathrm{order}(D_{\mathrm{L}},\{(v,I) : \\ &&\hspace{6em}Q \in I_{P,U,\mathrm{B}}^{ * }((V,F,X,X_R)),\\ &&\hspace{6em}P \in I_{P,U,\mathrm{K},\mathrm{mm}}^{ * }(Q),~N \in I_{P,U,\mathrm{R,mr}}^{ * }(P),\\ &&\hspace{6em}(v,I) \in N,~|\mathrm{ran}(I)|<|I|\}),\\ &&\hspace{4em}w=(f,l,b),~T = (\{S \cup \{(w,k)\} : (S,k) \in I\},\{w\})\},\\ &&\hspace{2em}L’ = \{(i,(T,(w,W))) : (i,(T,(w,W))) \in L, \\ &&\hspace{4em}\forall (i’,(T’,(w’,W’))) \in L~(i>i’ \implies T^{\mathrm{P}} \neq T^{‘\mathrm{P}})\},\\ &&\hspace{2em}H = \mathrm{dom}(\mathrm{set}(L’)),~U’ = U \cup \mathrm{ran}(\mathrm{set}(L’)),\\ &&\hspace{2em}X’ = I_{\mathrm{ * X}}^{ * }((H,X)),~X’_R = I_{\mathrm{ * X}}^{ * }((H,X_R)),\\ &&\hspace{2em}M’ = I_{P,U’,\mathrm{D,d}}^{ * }((V,F \cup H,X’,X’_R)) \end{eqnarray}$

### Highest-layer fud induction computer

The functionality of the practicable highest-layer shuffle content alignment valency-density fud inducer, $I_{z,\mathrm{csd,F,\infty,q},P,\mathrm{d}}^{‘}$, is implemented in the highest-layer fud induction computer $I_{P,U,\mathrm{Z,F,d}} \in \mathrm{computers}$, which is defined such that (i) the domain is $\mathrm{domain}(I_{P,U,\mathrm{Z,F,d}}) = \mathrm{P}(\mathcal{V}_U) \times \mathcal{A}_U \times \mathcal{A}_U \times \mathbf{N}$, (ii) the range is $\mathrm{range}(I_{P,U,\mathrm{Z,F,d}}) = \mathcal{F} \to \mathbf{Q}$, and (iii) the application is $\begin{eqnarray} &&I_{P,U,\mathrm{Z,F,d}}^{ * }((V,A,A_R,f)) = \\ &&\hspace{4em}\{(G,a) : \\ &&\hspace{6em}(\cdot,F,N) = I_{P,U,\mathrm{L,d}}^{ * }((V,A,A_R,f)),\\ &&\hspace{6em}(K,a) \in N,~G = \mathrm{depends}(F,K)\} \end{eqnarray}$ The fud identifier, $f$, is used to construct the new variables in the new system. The fud identifier should be such that $\forall i,j \in \mathbf{N}_{>0}~((f,i,j) \notin \mathrm{vars}(U))$.

The fuds of the fud induction computer, $I_{P,U,\mathrm{Z,F,d}}$, are not partition fuds, $\forall (U’,F,\cdot) \in I_{P,U,\mathrm{L,d}}^{ * }((V,A,A_R,f))~(F \notin \mathcal{F}_{U’,\mathrm{P}})$, so the fud induction computer is not a literal implementation of the fud inducer, $I_{z,\mathrm{csd,F,\infty,q},P,\mathrm{d}}^{‘}$. However, the fuds flatten to the same substrate partition transforms, $\begin{eqnarray} &&\forall A \in \mathcal{A}_{z} \\ &&\hspace{2em}(\{(F^{\mathrm{TPT}},a) : (F,a) \in I_{P,U_A,\mathrm{Z,F,b,d}}^{ * }((V_A,A,A^{\mathrm{X}},f))\} = \\ &&\hspace{4em}\{(F^{\mathrm{TPT}},a) : (F,a) \in I_{z,\mathrm{csd,F,\infty,q},P,\mathrm{d}}^{‘ * }(A)\} \subset (\mathcal{T}_{U_A,V_A} \to \mathbf{Q})) \end{eqnarray}$ Thus, an inducer implemented with the fud induction computer, $I_{P,U,\mathrm{Z,F,d}}$, after suitable conversion of the fuds to substrate models, would have the same inducer correlation as the fud inducer, $I_{z,\mathrm{csd,F,\infty,q},P,\mathrm{d}}^{‘}$. That is, $\mathrm{maxr}(I_{P,U,\mathrm{Z,F,d}}^{ * }((V,A,A^{\mathrm{X}},f))) = \mathrm{maxr}(I_{z,\mathrm{csd,F,\infty,q},P,\mathrm{d}}^{‘ * }(A))$.

### Highest-layer maximum-roll excluded-self fud induction computer

The even more restricted functionality of the practicable highest-layer excluded-self maximum-roll shuffle content alignment valency-density fud inducer, $I_{z,\mathrm{csd,F,\infty,q},P,\mathrm{mr,xs,d}}^{‘}$, is implemented in the highest-layer maximum-roll excluded-self fud induction computer $I_{P,U,\mathrm{Z,F,mr,xs,d}} \in \mathrm{computers}$, which is defined such that the application is $\begin{eqnarray} &&I_{P,U,\mathrm{Z,F,mr,xs,d}}^{ * }((V,A,A_R,f)) = \\ &&\hspace{4em}\{(G,a) : \\ &&\hspace{6em}(\cdot,F,N) = I_{P,U,\mathrm{L,mr,xs,d}}^{ * }((V,A,A_R,f)),\\ &&\hspace{6em}(K,a) \in N,~G = \mathrm{depends}(F,K)\} \end{eqnarray}$

### Highest-layer maximum-roll-by-derived-dimension excluded-self fud induction computer

Finally, the maximum-roll variation functionality of the practicable highest-layer excluded-self maximum-roll-by-derived-dimension shuffle content alignment valency-density fud inducer, $I_{z,\mathrm{csd,F,\infty,q},P,\mathrm{mm,xs,d}}^{‘}$, is implemented in the highest-layer maximum-roll-by-derived-dimension excluded-self fud induction computer $I_{P,U,\mathrm{Z,F,mm,xs,d}} \in \mathrm{computers}$, which is defined such that the application is $\begin{eqnarray} &&I_{P,U,\mathrm{Z,F,mm,xs,d}}^{ * }((V,A,A_R,f)) = \\ &&\hspace{4em}\{(G,a) : \\ &&\hspace{6em}(\cdot,F,N) = I_{P,U,\mathrm{L,mm,xs,d}}^{ * }((V,A,A_R,f)),\\ &&\hspace{6em}(K,a) \in N,~G = \mathrm{depends}(F,K)\} \end{eqnarray}$

### Highest-layer fud decomper

Now consider the practicable highest-layer summed shuffle content alignment valency-density fud decomposition inducer, $I_{z,\mathrm{Scsd,D,F,\infty,q},P,\mathrm{d}}^{‘}$, (Haskell) implemented by means of induction computers. The implementation of the practicable fud decomposition inducer in terms of optimisers is described above in section ‘Optimisation’. The functionality of the highest-layer limited-models infinite-layer substrate fud decompositions tree searcher, $Z_{P,A,\mathrm{D,F,d}}$, is implemented in the highest-layer fud decomper $I_{P,U,\mathrm{D,F,d}} \in \mathrm{computers}$, which is defined such that (i) the domain is $\mathrm{domain}(I_{P,U,\mathrm{D,F,d}}) = \mathrm{P}(\mathcal{V}_U) \times \mathcal{A}_U$, (ii) the range is $\mathrm{range}(I_{P,U,\mathrm{D,F,d}}) = \mathcal{U} \times \mathcal{D}_{\mathrm{F,d}}$, and (iii) the application is (Haskell) $\begin{eqnarray} I_{P,U,\mathrm{D,F,d}}^{ * }((V,A)) = \mathrm{decomp}(V,A,U,\emptyset,1,\emptyset) \end{eqnarray}$ where $\mathrm{decomp} \in \mathrm{P}(\mathcal{V}) \times \mathcal{A} \times \mathcal{U} \times \mathcal{D}_{\mathrm{F,d}} \times \mathbf{N} \times \mathrm{P}(\mathcal{L}(\mathcal{S} \times \mathcal{F}) \times \mathcal{S}) \to (\mathcal{U} \times \mathcal{D}_{\mathrm{F,d}})$ is defined as $\begin{eqnarray} &&\mathrm{decomp}(V,A,U,D,f,Z) = \\ &&\hspace{1em}\mathrm{if}(Q \neq \emptyset,\\ &&\hspace{4em}\mathrm{if}(N \neq \emptyset \wedge \mathrm{maxr}(N)>0,\\ &&\hspace{6em}\mathrm{decomp}(V,A,U’,E,f+1,Z’),\\ &&\hspace{6em}\mathrm{decomp}(V,A,U,D,f,Z’)),\\ &&\hspace{4em}(U,D)) : \\ &&\hspace{2em}Q = \mathrm{maxd}(\mathrm{order}(D_{\mathbf{Q} \times \mathrm{S} \times \mathcal{X}^3},\{(z_B,S,L,B) : \\ &&\hspace{4em}(L,Y) \in \mathrm{places}(D),\\ &&\hspace{4em}(\cdot,F) = L_{|L|},~W=\mathrm{der}(F),\\ &&\hspace{4em}S \in W^{\mathrm{CS}} \setminus \mathrm{dom}(\mathrm{dom}(Y)),\\ &&\hspace{4em}(L,S) \notin Z,\\ &&\hspace{4em}R_L = \bigcup \mathrm{dom}(\mathrm{set}(L)),~H_L = \bigcup \mathrm{ran}(\mathrm{set}(L)),\\ &&\hspace{4em}B = I_{\%}^{ * }((V,I_{ * }^{ * }((I_{\mathrm{ * X}}^{ * }((H_L,A)),\{R_L \cup S\}^{\mathrm{U}})))),\\ &&\hspace{4em}z_B = \mathrm{size}(B),~z_B>0\})),\\ &&\hspace{2em}\{(\cdot,S,L,B)\} = Q,\\ &&\hspace{2em}Z’ = Z \cup \{(L,S)\},\\ &&\hspace{2em}(U’,F,N) = I_{P,U,\mathrm{L,d}}^{ * }((V,B,B_{R(B)},f)),\\ &&\hspace{2em}\{K\} = \mathrm{maxd}(\mathrm{order}(D_{\mathrm{K}},\mathrm{dom}(N))),\\ &&\hspace{2em}G = \mathrm{depends}(F,K),\\ &&\hspace{2em}M=L \cup \{(|L|+1,(S,G))\},\\ &&\hspace{2em}E = \mathrm{tree}(\mathrm{paths}(D) \setminus \{L\} \cup \{M\})\} \end{eqnarray}$ and $\begin{eqnarray} &&\mathrm{decomp}(V,A,U,\emptyset,f,Z) = \\ &&\hspace{1em}\mathrm{if}(N \neq \emptyset \wedge \mathrm{maxr}(N)>0,\\ &&\hspace{4em}\mathrm{decomp}(V,A,U’,D,f+1,\emptyset),\\ &&\hspace{4em}(U,D_{\emptyset})) : \\ &&\hspace{2em}(U’,F,N) = I_{P,U,\mathrm{L,d}}^{ * }((V,A,A_{R(A)},f)),\\ &&\hspace{2em}\{K\} = \mathrm{maxd}(\mathrm{order}(D_{\mathrm{K}},\mathrm{dom}(N)))),\\ &&\hspace{2em}G = \mathrm{depends}(F,K),\\ &&\hspace{2em}D = \{((\emptyset,G),\emptyset)\} \end{eqnarray}$ The fuds of the decomposition in the fud decomposition induction computer, $I_{P,U,\mathrm{D,F,d}}$, are not partition fuds, $\forall F \in \mathrm{fuds}(D)~(F \notin \mathcal{F}_{U’,\mathrm{P}})$ where $(U’,D) = \mathrm{decomp}(V,A,U,\emptyset,1,\emptyset)$, so the fud decomposition induction computer is not a literal implementation of the fud decomposition inducer, $I_{z,\mathrm{Scsd,D,F,\infty,q},P,\mathrm{d}}^{‘}$. However, the fuds flatten to the same substrate partition transforms, so an inducer implemented with the fud decomposition induction computer, $I_{P,U,\mathrm{D,F,d}}$, after suitable conversion of the fuds to substrate models, would have the same maximum function correlation as the fud decomposition inducer, $I_{z,\mathrm{Scsd,D,F,\infty,q},P,\mathrm{d}}^{‘}$. That is, $I_{\mathrm{Scsd}}^{ * }((A,D)) = \mathrm{maxr}(I_{z,\mathrm{Scsd,D,F,\infty,q},P,\mathrm{d}}^{‘ * }(A))$, where $D = I_{P,U,\mathrm{D,F,d}}^{ * }((V,A))$.

### Highest-layer excluded-self maximum-roll fud decomper

The practicable highest-layer excluded-self maximum-roll summed shuffle content alignment valency-density fud decomposition inducer, $I_{z,\mathrm{Scsd,D,F,\infty,q},P,\mathrm{mr,xs,d}}^{‘}$, is implemented in the highest-layer excluded-self maximum-roll fud decomper $I_{P,U,\mathrm{D,F,mr,xs,d}} \in \mathrm{computers}$ (Haskell) exactly as in the highest-layer fud decomper $I_{P,U,\mathrm{D,F,d}}$, above, except that the highest-layer maximum-roll excluded-self fud induction computer, $I_{P,U,\mathrm{Z,F,mr,xs,d}}$, replaces the highest-layer fud induction computer, $I_{P,U,\mathrm{Z,F,d}}$.

### Highest-layer excluded-self maximum-roll-by-derived-dimension fud decomper

The practicable highest-layer excluded-self maximum-roll-by-derived-dimension summed shuffle content alignment valency-density fud decomposition inducer, $I_{z,\mathrm{Scsd,D,F,\infty,q},P,\mathrm{mm,xs,d}}^{‘}$, is implemented in the highest-layer excluded-self maximum-roll-by-derived-dimension fud decomper $I_{P,U,\mathrm{D,F,mm,xs,d}} \in \mathrm{computers}$ (Haskell) (Python) exactly as in the highest-layer fud decomper $I_{P,U,\mathrm{D,F,d}}$, above, except that the highest-layer maximum-roll-by-derived-dimension excluded-self fud induction computer, $I_{P,U,\mathrm{Z,F,mm,xs,d}}$, replaces the highest-layer fud induction computer, $I_{P,U,\mathrm{Z,F,d}}$.

top