Original: T WO I NSTANCES OF I NTERPRETABLE N EURAL N ETWORK FOR U NIVERSAL A PPROXIMATIONS
Revised: T WO I NSTANCES OF I NTERPRETABLE N EURAL N ETWORK FOR U NIVERSAL A PPROXIMATIONS

Original: Anonymous authors
Revised: Anonymous authors

Original: Paper under double-blind review
Revised: Paper under double-blind review

Original: A BSTRACT
Revised: A BSTRACT

Original: This paper proposes two bottom-up interpretable neural network (NN) constructions for universal approximation, namely Triangularly-constructed NN (TNN) and Semi-Quantized Activation NN (SQANN).
Revised: This paper proposes two bottom-up interpretable neural network (NN) constructions for universal approximation, namely Triangularly-constructed NN (TNN) and Semi-Quantized Activation NN (SQANN).

Original: The notable properties are (1) resistance to catastrophic forgetting (2) existence of proof for arbitrarily high accuracies on training dataset (3) for an input x , users can identify speciﬁc samples of training data whose activation “ﬁngerprints” are similar to that of x ’s activations.
Revised: The notable properties are (1) resistance to catastrophic forgetting (2) existence of proof for arbitrarily high accuracies on training dataset (3) for an input x , users can identify specific samples of training data whose activation “fingerprints” are similar to that of x ’s activations.

Original: Users can also identify samples that are out of distribution
Revised: Users can also identify samples that are out of distribution.

Original:  I NTRODUCTION
Revised:  I NTRODUCTION

Original: Artiﬁcial neural networks (NN) have recently seen successful applications in many ﬁelds.
Revised: Artificial neural networks (NN) have recently seen successful applications in many fields.

Original: Modern deep neural network (DNN) architecture, usually trained through the backpropagation mechanism, has been called a black-box because of its lack of interpretability.
Revised: Modern deep neural network (DNN) architecture, usually trained through the backpropagation mechanism, has been called a black-box because of its lack of interpretability.

Original: To tackle this issue, various studies have been performed to understand how a NN works; see the following surveys Arrieta et al.
Revised: To tackle this issue, various studies have been performed to understand how a NN works; see the following surveys Arrieta et al.

Original: Gilpin et al.
Revised: Gilpin et al.

Original: ; Tjoa & Guan (2020); Wiegreffe & Marasovi ´ c (2021).
Revised: ; Tjoa & Guan (2020); Wiegreffe & Marasovi ´ c (2021).

Original: This paper primarily proposes two interpretable models to perform universal approximation with three main desirable properties, complete with mathematical proofs and experimental assessments on some regression and classiﬁcation problems.
Revised: This paper primarily proposes two interpretable models, namely triangularly-constructed NN (TNN) and Semi-Quantized Activation NN (SQANN). Both possess the following three notable properties: (1) Resistance to catastrophic forgetting . (2) Mathematical proofs for arbitrarily high accuracy on training datasets experimentally demonstrable with python code and simple common datasets (see supp.

Revised: materials)

Revised: (3) Detection of out-of-distribution samples through weak activations

Original: Related works and interpretability issues . 
Revised: Concept disambiguation . Several concepts have multiple possible definitions. We clarify the definitions used in this paper. Interpretability.

Revised: We consider only fine-grained interpretation, i.e. we look at the meaning of each single neuron or its activation in our models.

Revised: Universal approximation.

Revised: Readers might be familiar with

Revised: universal approximation of functions on certain conditions, e.g. compact sets.

Revised: Our models can be more general, e.g. user can freely choose the interpolation function between 2 activations based on knowledge of the local manifold.

Revised: The function can even be pathological.

Revised: See appendix A.2.1.

Revised: Catastrophic forgetting: the tendency for knowledge of previously learned dataset to be abruptly lost as information relevant to a new dataset is incorporated.

Revised: This definition is a slightly nuanced version of Kirkpatrick et al.

Revised: Hence, our models’ resistance to catastrophic forgetting is the following.

Revised: Given a training dataset D accurately modeled by an architecture M , a new dataset D ′ (especially new, out of distribution dataset) can be incorporated into M without losing accuracy on

Revised: D .

Revised: See appendix A.2.2 (analogy to biological system included).

Revised: Related works and interpretability issues .

Original: Recent remarkable studies on universal approximators include the Deep Narrow Network by Kidger & Lyons (2020), DeepONet universal approximation for operators by Lu et al.
Revised: Recent remarkable studies on universal approximators include the Deep Narrow Network by Kidger & Lyons (2020), DeepONet universal approximation for operators by Lu et al.

Original: (2021) and the Broad Learning System by Chen et al.
Revised: (2021) and the Broad Learning System by Chen et al.

Original: ; Hanin (2019);
Revised: ; Hanin (2019);

Original: Park et al.
Revised: Park et al.

Original: ; Johnson (2019).
Revised: ; Johnson (2019).

Original: While insightful, they do not directly address the eXplainable
Revised: While insightful, they do not directly address the eXplainable

Original: Artiﬁcial Intelligence (XAI) issue, especially the blackbox property of the DNN.
Revised: Artificial Intelligence (XAI) issue, especially the blackbox property of the DNN.

Original: Similarly, a number of classical papers provide theoretical insights for NN as universal approximators, but interpretability, transparency and fairness issues are not their main focus.
Revised: Similarly, a number of classical papers provide theoretical insights for NN as universal approximators, but interpretability, transparency and fairness issues are not their main focus.

Original: The universal approximation theorem by Cybenko (1989) asserts that a NN with a single hidden layer can approximate any function to arbitrarily small error under common conditions, proven by asserting the density of that set of NN in the function space using classic mathematical theorems.
Revised: The universal approximation theorem by Cybenko (1989) asserts that a NN with a single hidden layer can approximate any function to arbitrarily small error under common conditions, proven by asserting the density of that set of NN in the function space using classic mathematical theorems.

Original: In particular, its theorem 1 uses an abstract proof by contradiction.
Revised: In particular, its theorem 1 uses an abstract proof by contradiction.

Original: From the proof, it is not easy to observe the internal mechanism of a
Revised: From the proof, it is not easy to observe the internal mechanism of a

Original: NN in a straight-forward manner; consequently modern works that depend on it (e.g. Deep Narrow
Revised: NN in a straight-forward manner; consequently modern works that depend on it (e.g. Deep Narrow

Original: Network) might inherit the blackbox property.
Revised: Network) might inherit the blackbox property.

Original: Bottom-up constructions for function approximation using NN then emerged. They still do not focus on interpretability, thus readers have to observe for themselves the shape of the resulting networks from the components used in the construction.
Revised: Bottom-up constructions for function approximation using NN then emerged, though they also lack the interpretability (see appendix A.3 for more related works).

Original: For example, there are works related to spline functions like Mhaskar & Micchelli (1992); Mhaskar (1993b;a); Chui et al. ; another example by Sartori & Antsaklis (1991) where two-layer NN can be formed by arbitrarily choosing the weights of ﬁrst layer and computing the weights of second layer explicitly; and section 5 of Pinkus (1999) shows the equations used to obtain weights and proves the existence of such solutions. In some of them and others such as Mhaskar (1996); Chui et al. , the focus lies in error quantiﬁcation.
Revised: Also consider a demonstration in Nielsen (2015) that could help improve our understanding of universal approximation.

Original: Outline .
Revised: Outline .

Original: This paper provides the constructions of (1) triangularly-constructed NN (TNN), interpretable through linear ordering of activations (2) Semi-Quantized Activation NN (SQANN) whose neurons in each layer can be understood as the exact ﬁngerprint of a training data sample, enhancing its interpretability.

Original: TNN will be the simpler construction that inspires SQANN.

Original: We must warn readers that our constructions are rooted in conditional algorithms, thus they might be somewhat technical; we provide pedagogical examples to help clarify the details.

Original: Notable features include:

Original: Resistance to catastrophic forgetting .

Original: See below.

Original: Mathematical proofs for arbitrarily high accuracy on training datasets; experimentally demonstrable with python code and simple common datasets (see supp.

Original: materials).

Original: For each prediction, strongly activated neurons or half-activated neurons (if any) can be identiﬁed precisely; see ﬁg. 1(C) bottom for SQANN and ﬁg. 2 for TNN.

Original: SQANN also allows user to identify a sample that activates all nodes weakly, i.e. the sample is likely out of distribution.

Original: Regarding resistance to catastrophic forgetting .

Original: Unlike artiﬁcial NN, mammalian brain retains old information when it learns new information by protecting previously acquired knowledge in neocortical circuits ; see Kirkpatrick et al.

Original: (2017) and the references thereof.

Original: As rats learn new skills, the volumes of dendritic spines in their brains increase (Yang et al.

Original: (2009)) while existing dendrites persist, thus they retain old memories.

Original: Both TNN and SQANN have similar property.

Original: Particularly, SQANN increases the size of a layer as it progressively acquires new samples during construction (learning).

Original: This inevitably increases the number of weights that connect the layers; see ﬁg. 1(D.1, D.2).

Original: Furthermore, each old sample is not forgotten since its exact “ﬁngerprint” is already registered (i.e. input x has been converted) to a neuron’s nucleus η <k>l , shown in ﬁg. 1(B).

Original: The activation pattern of a sample x in SQANN ( x ) includes the value 1 in a speciﬁc node of a “synapse”, v <k>l and the particular combinations of values in other synapses.

Original: This paper is arranged as the following.
Revised: This paper is arranged as the following.

Original: Section 2 shows explicit TNN construction, related results, including a pencil-and-paper example for pedagogical purpose.
Revised: Section 2 shows explicit TNN construction, related results, including a pencil-and-paper example for pedagogical purpose.

Original: Likewise, section 3 shows SQANN construction, statements regarding SQANN, another pencil-and-paper example , then experimental results of its application, before we conclude the paper with limitations and future works.
Revised: Likewise, section 3 shows SQANN construction, statements regarding SQANN, another pencil-and-paper example , then experimental results of its application, before we conclude the paper with limitations and future works.

Original: Python codes and clearer images of ﬁgures are fully available in supp.
Revised: Python codes and clearer figures are fully available in supp.

Original: materials (also see appendix).
Revised: materials (also see appendix).

Original:  T RIANGULARLY - CONSTRUCTED NN (TNN)
Revised:  T RIANGULARLY - CONSTRUCTED NN (TNN)

Original: TNN is the prototype NN for our interpretable universal approximator.
Revised: TNN is the prototype NN for our interpretable universal approximator.

Original: SQANN (next section) eventually borrows the concept from TNN only partially, but TNN will be useful as an easy and manageable illustration to deliver the following ideas: (1) organized activations of neurons and (2) the retrieval of α values as the outputs.
Revised: SQANN (next section) partially borrows the concept from TNN which will be useful as an easy and manageable illustration to deliver the following ideas: (1) organized activations of neurons and (2) the retrieval of α values as the outputs.

Original: TNN isin the form TNN ( x ) 
Revised: The model is TNN ( x ) =

Original: = α T σ ( Wx + b ) where x ∈ [0 , 1]n , α, b ∈ R N and W ∈ R N× n , where we use sigmoid function σ for simplicity.
Revised: α T σ ( Wx + b ) where x ∈ [0 , 1] , α, b ∈ R N and W ∈ R N , where we use sigmoid function σ for simplicity.

Revised: We start with a simple scalar function y = f ( x ) ∈ R for x ∈ [0 , 1] , thus TNN’s interpretability can be illustrated very clearly.

Revised: Assumption: Linear Ordering .

Original: It is constructed on a linearly ordered dataset containing N samples { ( x ( k ) , y ( k ) )
Revised: It is constructed on a linearly ordered dataset containing N samples { ( x ( k ) , y ( k ) )

Original: ∈ R n × R } Nk ={+=
+} such that x ( N ) <
Revised: ∈ R n × R } Nk {+=
+} such that x ( N ) <

Original: x ( N − 1) < · · · < x (1) and y ( k ) =
Revised: x ( N − 1) < · · · < x (1) and y ( k ) =

Original: f ( x ( k ) ) , f the true function that TNN will approximate.
Revised: f ( x ( k ) ) , f the true function that TNN will approximate.

Original: We start with a simple scalar function y = f ( x ) ∈ R for x ∈ [0 , 1] , thus TNN’s interpretability can be illustrated very clearly.

Original: The interpretability comes from the linear ordering property where higher value of x ( ≈ 1 ) will activate more neurons while lower values will activate less neurons as shown in ﬁg 2(A).
Revised: The interpretability comes from the linear ordering property where higher value of x ( ≈ 1 ) will activate more neurons while lower values will activate less neurons as shown in fig 1(A).

Original: Then α values will be retrieved in a continuous way through dot product, eventually used to compute the output for prediction.
Revised: Then α values will be retrieved in a continuous way through dot product, eventually used to compute the output for prediction.

Revised: In time series, such as ECG (Electrocardiogram), signals can be approximated point-wise (although it is still preferable to have a noise model during preprocessing to prevent overfitting the noise).

Revised: Meaningful interpretation can be given, for example, by mapping PQRST segments from ECG to specific neurons within TNN, giving some neurons specific meaning and thus interpretability.

Original: For more remarks and  linear ordering concept in mathematics, see appendix.
Revised: For more remarks and definition of formal linear ordering etc, see appendix A.4.

Original: Ordered activation .
Revised: Ordered activation .

Original: We would like x (1) to activate all neurons, while x ( N ) activates only 1 neuron.
Revised: We would like x (1) to activate all neurons, while x ( N ) activates only 1 neuron.

Original: In other words, ideally σ ( Wx (1) + b ) =
Revised: In other words, ideally σ ( Wx (1) + b ) =

Original: , 1 , 1] T , followed by σ ( Wx (2) + b ) =
Revised: , 1 , 1] T , followed by σ ( Wx (2) + b ) =

Original: , 1 , 0] T and so on until σ ( Wx ( N ) + b ) =
Revised: , 1 , 0] T and so on until σ ( Wx ( N ) + b ) =

Original: , 0] T ; again, refer to ﬁg. 2(A).
Revised: , 0] T ; again, refer to fig. 1(A).

Original: With this concept, we seek to achieve interpretability by successive activations of neurons depending on the “intensity” of the input, with x (1) being the most intense.
Revised: With this concept, we seek to achieve interpretability by successive activations of neurons depending on the “intensity” of the input, with x (1) being the most intense.

Original: In general, the above can be written as
Revised: In general, the above can be written as

Original: [Equation]
Revised: [Equation]

Original: which is approximately achieved for k = 1 , . .
Revised: which is approximately achieved for k = 1 , . .

Original: , N at large a (and exactly if a → ∞ ) with
Revised: , N at large a (and exactly if a → ∞ ) with

Original: [Equation]
Revised: [Equation]

Revised: For more remarks, see appendix A.4 subsection ordered activation .

Original: TNN construction: computing weights W, b, α .
Revised: TNN construction: computing weights W, b, α .

Original: How then do we compute W, b to achieve the ordered activation ?
Revised: How then do we compute W, b to achieve the ordered activation ?

Original: Consider ﬁrst ( Wx (2) + b ) N = − a
Revised: Consider first ( Wx (2) + b ) N = − a

Original: and ( Wx (1) + b ) N = a and solve them.
Revised: and ( Wx (1) + b ) N = a and solve them.

Original: This yields W N = 2 a/ ∆ (1) and b N = a − W N x (1) where ∆ (1) =
Revised: This yields W N = 2 a/ ∆ (1) and b N = a − W N x (1) where ∆ (1) =

Original: x (1) − x (2) .
Revised: x (1) − x (2) .

Original: Iterating through k, i.e. solving ( Wx ( k +1)
Revised: Iterating through k, i.e. solving ( Wx ( k +1)

Original: + b ) N − k +

Revised: + b ) N − k +

Original: = − a
Revised: = − a

Original: and ( Wx ( k ) + b ) N − k
Revised: and ( Wx ( k ) + b ) N − k

Original: +

Revised: +

Original: = a we obtain W N − k
Revised: = a we obtain W N − k

Original: +1 = 2 a/ ∆ ( k ) and b N − k +

Revised: +1 = 2 a/ ∆ ( k ) and b N − k +

Original: =
Revised: =

Original: a − W N − k +1 x ( k ) where ∆ ( k ) =
Revised: a − W N − k +1 x ( k ) where ∆ ( k ) =

Original: x ( k ) − x ( k +1) .
Revised: x ( k ) − x ( k +1) .

Original: We can rewrite the indices so that W k = 2 a/ ∆ ( N − k +1) and b k = a − W k x ( N − k +1) whenever convenient.
Revised: We can rewrite the indices so that W k = 2 a/ ∆ ( N − k +1) and b k = a − W k x ( N − k +1) whenever convenient.

Original: For ∆ ( N ) , we need a dummy x ( N +1) value or we can directly choose its value, e.g. 1 N Σ N − 1 k =1 ∆ ( k ) .
Revised: For ∆ ( N ) , we need a dummy x ( N +1) value or we can directly choose its value, e.g. 1 N Σ N − 1 k =1 ∆ ( k ) .

Original: The effect is illustrated by the value near x = 0 in ﬁg. 3(A1-3) and should not pose any problem; the chosen dummy value will only affect the shape at the left end of the graph.
Revised: The effect is illustrated by the value near x = 0 in fig. 2(A1-3) and should not pose any problem; the chosen dummy value will only affect the shape at the left end of the graph.

Original: by prioritizing interpretability of a neural network.

Original: As x ( k ) decreases in “strength”, the neurons are “turned off” correspondingly.

Original: (B) Activations of neurons for x ( k ) , x ( k +1) and their mid-point x mid,k .

Original: Not only will neuron activation be half at the mid-point, the output y mid,k = 12 ( y ( k ) + y ( k +1) ) is also half the sum of its neighbours’.

Original: We compute α using the property of equation (1).
Revised: We compute α using the property of equation (1).

Original: From ﬁg. 2(A), this means ideally y (1) =
Revised: From fig. 1(A), this means ideally y (1) =

Original: Σ [-Ni =
-]
Revised: Σ [-Ni =
-]N i =

Original: α i σ ( Wx (1) + b ) i for a → ∞ , and similarly y (2) =
Revised: α i σ ( Wx (1) + b ) i for a → ∞ , and similarly y (2) =

Original: Σ N − 1 i =

Revised: Σ N − 1 i =

Original: α i σ ( Wx (2) + b ) i and so on until y ( N ) =
Revised: α i σ ( Wx (2) + b ) i and so on until y ( N ) =

Original: α 1 σ ( Wx ( N ) + b ) 1 .
Revised: α 1 σ ( Wx ( N ) + b ) 1 .

Original: Putting them together as y =
Revised: Putting them together as y =

Original: [ y (1) , . . . ,
Revised: [ y (1) , . . . ,

Original: y ( N ) ] T ,
Revised: y ( N ) ] T ,

Original: we get y =
Revised: we get y =

Original: Aα where
Revised: Aα where

Original: A is an upper-left triangular matrix and the inverse A − 1 exists.
Revised: A is an upper-left triangular matrix and the inverse A − 1 exists.

Original: Thus, α =
Revised: Thus, α =

Original: A − 1 y , a matrix such that A − 1 ij = 1 along the diagonal, A − 1 i,i +1 = − 1 and zeroes otherwise, which facilitates a convenient computation.
Revised: A − 1 y , a matrix such that A − 1 ij = 1 along the diagonal, A − 1 i,i +1 = − 1 and zeroes otherwise, which facilitates a convenient computation.

Original: The triangular construction is complete:
Revised: The triangular construction is complete:

Original: [Equation]
Revised: [Equation]

Original: When the dataset is evenly spaced, x ( k ) = 1 − ( k − 1)∆ , k = 1 , ..., N, ∆ = 1 / ( N − 1) , the results simplify to W k = 2 a ( N − 1) and b k = a (3 − 2 k ) .

Original: Not only equation (2) is fulﬁlled, we also get ( Wx ( k ) + b ) j = a (1 + 2[ N − k + 1 − j ]) .

Original: For the k-th data sample, the activation will then be wellspaced in an interval of 2 a , so that σ ( k ) =

Original: σ ([ . . .

Original: , − 3 a, − a, a, 3 a, . . . ])

Original: T ≈ [ . . .

Original: T .

Original: TNN pencil-and-paper example . Use TNN to ﬁt the dataset ( x, y ) ∈ { (1 , 1) , (0 . 5 , 2) , (0 , 3) } . Then f ( x ) ≈ TNN
Revised: While Nielsen (2015) provides only visual demonstration, the following result shows rigorous proof on universal approximation at work (python code also available).

Original: ( x ) = 3 σ (20 x + 5) − σ (20 x − 5) − σ (20 x − 15) .

Original: Full workings, see appendix.

Original: Theorem 1 TNN achieves arbitrarily high accuracy on the training dataset.
Revised: Theorem 1 TNN achieves arbitrarily high accuracy on the training dataset.

Original: Proof: see appendix.
Revised: Proof: see appendix

Original: Smoothness . From the construction, assuming sigmoid function as the activation function, it is obvious that the function is continuous for ﬁnite a . As a increases, the function becomes more and more constant around each data sample as shown in ﬁg. 3(A1-3), i.e. becoming more step-wise. Generalizability to test dataset .
Revised: A.4.1.

Original: The proof of theorem 1 shows perfect ﬁtting to training dataset. There is an upper bound to errors on test dataset if the  test dataset is well-behaved.
Revised: Also see example results in fig. With the following proposition, test dataset that resembles training dataset will yield small error.

Original: Otherwise, if test dataset contains errant or novel samples, they can be incorporated into the training dataset to create a better model with the above-said error upper-bound. Furthermore, catastrophic forgetting will not occur.
Revised: Otherwise, there are out-of-distribution (ood) samples A ⊆ D ′ , which can be incorporated into the training dataset. Catastrophic forgetting is not a problem during re-training because when ood samples from the test dataset are included as training points, each training point x ∈ D is still identified with a neuron. By theorem 1, x is still approximated accurately.

Original: These are shown in the following proposition:
Revised: See appendix A.2.2 for remarks on advantage over existing methods .

Original: Proposition 1 Errors on monotonous interval .
Revised: Proposition 1 Errors on monotonous interval .

Original: Given ﬁnite training, test datasets D, D (cid:48) , there exists A ⊆ D (cid:48) such that, using TNN constructed with D ∪ A , for all samples in test dataset ( x (cid:48) , y (cid:48) ) ∈
Revised: Given finite training, test datasets D, D ′ , there exists A ⊆ D ′ such that, using TNN constructed with D ∪ A , for all samples in test dataset ( x ′ , y ′ ) ∈

Original: D (cid:48) , sample-wise error e = | y (cid:48) − TNN ( x (cid:48) ) | has an upper bound max ( | y (cid:48) − y ( k +1) | , | y (cid:48) − y ( k ) | ) for some k .
Revised: D ′ , sample-wise error e = | y ′ − TNN ( x ′ ) | has an upper bound max ( | y ′ − y ( k +1) | , | y ′ − y ( k ) | ) for some k .

Original: Proof: see appendix.
Revised: Proof: see appendix A.4.2.

Original: There is also a mid-point property that can be exploited for generalizability to arbitrarily high accuracy, where data must be sampled such that any instance x test lies inside either (1) the training dataset or (2) is equal to some mid-point of two neighbouring training samples; see the proposition below.
Revised: There is also a mid-point property that can be exploited for generalizability to arbitrarily high accuracy, where data must be sampled such that any instance x test lies inside either (1) the training dataset or (2) is equal to some mid-point of two neighbouring training samples; see the proposition below.

Original: Fig.
Revised: Fig.

Original: 2(B) shows how the component of x mid,k at j = N − k
Revised: 1(B) shows how the component of x mid,k at j = N − k

Original: + 1 is half-activated i.e. the activation value is 0 .
Revised: + 1 is half-activated i.e. the activation value is 0 .

Original: Admittedly, this is an ideal condition for accurate generalizability.
Revised: Admittedly, this is an ideal condition for accurate generalizability.

Original: Proposition 2 Mid-point property .
Revised: Proposition 2 Mid-point property .

Original: The mid-point x mid,k = 12 ( x ( k ) + x ( k +1) ) takes the value of α T 
Revised: The mid-point x mid,k = 12 ( x ( k ) + x ( k +1) ) takes the value of α T σ ( Wx mid,k + b )

Original: [Equation]
Revised: = 12 ( y ( k )

Original: [Equation]
Revised: + y ( k +1) ) .

Original: Proof: see appendix.
Revised: Proof: see appendix A.4.3.

Original: Generalization to n-dimensions . Generalization to scalar input and multi-dimensional output is relatively simple. From equation (3), we can treat α as the coefﬁcients for the only component of one-dimensional y . Generalizing to y ∈ R m , m > 1 , identify each vector α i with the component y i .
Revised: TNN pencil-and-paper example .

Original: Stacking them up, we can redeﬁne α = [ α T 1 ; α T 2 ; .  .
Revised: Use TNN to fit the dataset ( x, y ) ∈ { (1 , 1) , (0 . 5 , 2) , (0 , 3) } .

Original: . ] where a semi-colon denotes the next row, and the construction is done. Note that now α ∈ R m × N . Our further attempts at generalization to n-dimensional input data have been unsatisfactory, but do consider such attempts in the appendix. Still, along the way we ask, for high dimensional dataset, does there exist any linear ordering so that
Revised: Then f ( x ) ≈

Original: TNN can be used for high accuracy classiﬁcation?
Revised: TNN ( x ) = 3 σ (20 x + 5) − σ (20 x − 5) − σ (20 x − 15) .

Original: The proposition indicates that there is.
Revised: See appendix A.4.4.

Original: Proposition 3 Given a standard DNN for C classes classiﬁcation with a tr training accuracy, then there exists a linear ordering for TNN to achieve a tr accuracy. Test accuracy a test of DNN can be achieved by TNN with high probability through squeezed linear ordering. Proof: see appendix.
Revised: Remarks smoothness property, special case, scalability/complexity and generalizability to higher dimensions can be found in appendix A.4.5. We proceed with SQANN, a universal approximation inspired by TNN that allows multi-dimensional input, multi-layer stacking of neurons based on relative strength of neuron activations.

Original:  S EMI -Q UANTIZED A CTIVATION N EURAL N ETWORK (SQANN)
Revised:  S EMI -Q UANTIZED A CTIVATION N EURAL N ETWORK (SQANN)

Original: Directly extending TNN to a multi-dimensional model turns out to be subtly difﬁcult. After several trial-and-errors, we come up with the SQANN architecture  which (1) retains TNN’s idea of using an organized sequence of activations to retrieve α , (2) remotely resembles a Radial Basis Function, but (3) has deep neural network properties, such as the possibility of deep learning (multiple constructed layers) and neuron activations.
Revised: SQANN architecture is a multi-dimensional universal approximator which (1) retains TNN’s idea of using an organized sequence of activations to retrieve α , (2) remotely resembles a Radial Basis Function, but (3) has deep neural network properties, such as the possibility of deep learning (multiple constructed layers) and neuron activations.

Original: The difference is, a neuron in SQANN corresponds exactly to a data sample as SQANN stores its “ﬁngerprints” as neurons’ nuclei -see ﬁg. 1(B)- with different kinds of responses: (1) distinct peaks and (2) half-activations and (3) weak/zero activations, made possible by double selective activation σ dsa , see ﬁg. 1(A).
Revised: The difference is, a neuron in SQANN corresponds exactly to a data sample as SQANN stores its “fingerprints” as neurons’ nuclei as shown in fig. 3(B). The neurons can be activated with different kinds of responses: (1) distinct peaks and (2) half-activations and (3) weak/zero activations, made possible by double selective activation σ dsa .

Original: See appendix for more illustrative remarks in  the  proof of proposition 4, “ intuition behind σ dsa ”.
Revised: They are illustrated in fig. 3(A) and the sketch of proof of proposition 3 in appendix A.5.4, intuition behind σ dsa .

Original: This gives SQANN interpretability at least in the following sense: samples are highly/moderately/not recognizable if their activation patterns strongly/moderately/weakly resemble the activation patterns of an existing training sample x , where identiﬁcations are facilitated by the distinct regions of σ dsa .
Revised: The aforementioned distinct types of activation are key to SQANN’s main result and give the model an interpretability at least in the following sense: samples are highly/moderately/not recognizable if their activation patterns strongly/moderately/weakly resemble the activation patterns of an existing training sample x , where identifications are facilitated by the distinct regions of σ dsa .

Original: The design is “semi” quantized since σ dsa has approximately “distinct” levels yet remains continuous.
Revised: The design is “semi” quantized since σ dsa has approximately “distinct” levels yet remains continuous.

Original: Since SQANN incorporates multilayer structure, it avoids being a non-generalizing model that nearest neighbours methods suffer from; see the remark in (Pedregosa et al.
Revised: Since SQANN incorporates multi-layer structure, it avoids being a non-generalizing model that nearest neighbours methods suffer from; see the remark in (Pedregosa et al.

Original: (2011a)).
Revised: (2011a)).

Original: Notations .
Revised: Notations .

Original: The order of data sample within the dataset matters, thus we deﬁne our own indexing to prevent confusion.
Revised: The order of data sample within the dataset matters, thus we define our own indexing to prevent confusion.

Original: Let the ﬁnite training set be { ( x ( k ) , y ( k ) )
Revised: Let the finite training set be { ( x ( k ) , y ( k ) )

Original: ∈
Revised: ∈

Original: X × Y : k = 1 , 2 , . . . , N } .
Revised: X × Y : k = 1 , 2 , . . . , N } .

Original: We create the SQANN model that predicts y ( k )
Revised: We create the SQANN model that predicts y ( k )

Original: =
Revised: =

Original: SQANN ( x ( k ) ) with provably perfect accuracy and generalizes well to similar test distribution.
Revised: SQANN ( x ( k ) ) with provably perfect accuracy and generalizes well to similar test distribution.

Original: Subscript indicates layer, v denotes activation values collected in the “synapses”, square bracket with subscript denotes vector component so that [ v 2 ]is the 4-th vector component of the activation of layer 2.
Revised: Subscript indicates layer, v denotes activation values collected in the “synapses”, square bracket with subscript denotes vector component so that [ v 2 ]is the 4-th vector component of the activation of layer 2.

Original: Layer k consists of ( N k , α k ) , where
Revised: Layer k consists of ( N k , α k ) , where

Original: N k =
Revised: N k =

Original: ( η < 1 > k , η < 2 > k , . . .
Revised: ( η < 1 > k , η < 2 > k , . . .

Original: , η <n k > k ) stores ﬁngerprints/patterns, α k =
Revised: , η <n k > k ) stores fingerprints/patterns, α k =

Original: ( y < 1 > k , y < 2 > k , . . .
Revised: ( y < 1 > k , y < 2 > k , . . .

Original: , y <n k > k ) stores output values.
Revised: , y <n k > k ) stores output values.

Original: The angle bracket denotes the index after relabelling.
Revised: The angle bracket denotes the index after relabelling.

Original: Hence, if k-th data sample before relabelling is ( x ( k ) , y ( k ) ) , k = 

Revised: Hence, if k-th data sample before relabelling is ( x ( k ) , y ( k ) ) , k =

Original: and it becomes the ﬁrst node in layer 2, then we write η < 1 >= η (50) .
Revised: and it becomes the first node in layer 2, then we write η < 1 >= η (50) .

Original: Concatenation .
Revised: Concatenation .

Original: To denote the addition of the new k -th node to the layer l , use η <k>l ← v , where v can be for example v ( m )the activation of the m -th data at layer 2.
Revised: To denote the addition of the new k -th node to the layer l , use η <k>l ← v , where v can be for example v ( m )the activation of the m -th data at layer 2.

Original: Alternatively,
Revised: Alternatively,

Original: N l → concat ( N l , η <k>l ) .
Revised: N l → concat ( N l , η <k>l ) .

Original: We can speak about layer k using N k if α k is not yet involved.
Revised: We can speak about layer k using N k if α k is not yet involved.

Original: However, once concatenation of N l is decided, always correspondingly concatenate the α l i.e. y <k>l ← y ( m ) .
Revised: However, once concatenation of N l is decided, always correspondingly concatenate the α l i.e. y <k>l ← y ( m ) .

Original: Selective clustering of p k = ( x k , y k ) for k = 1 , 2 is loosely deﬁned for x 1 , x 2 that are close to each other such that: if y 1 , y 2 are similar, then p 1 , p 2 are clustered together, otherwise two distinct clusters are created; see appendix for formal deﬁnition, its effects on interpolation and more remarks.
Revised: Selective clustering of p k = ( x k , y k ) for k = 1 , 2 is loosely defined for x 1 , x 2 that are close to each other such that: if y 1 , y 2 are similar, then p 1 , p 2 are clustered together, otherwise two distinct clusters are created; see appendix for formal definition, its effects on interpolation and more remarks.

Original: Double selective activation .
Revised: Double selective activation .

Original: Given selective activation π ( x, a ) =
Revised: Given selective activation π ( x, a ) =

Original: a a + x 2 and Super Gaussian s g ( x, a ) = exp ( − ( x/a ) 2 n ) , n = 4 , r = 0 .
Revised: [Equation] 2 and Super Gaussian s g ( x, a ) = exp ( − ( x/a ) 2 n ) , n = 4 , r = 0 .

Original: 5 , then the double selective activation is (ﬁg. 1(A)):
Revised: 5 , then the double selective activation is (fig. 3(A)):

Original: [Equation]

Original: [Equation]
Revised: [Equation]

Original: Nodes activation .
Revised: Nodes activation .

Original: Denote the “synapse” or the activation value of node j at layer k by input v as:
Revised: Denote the “synapse” or the activation value of node j at layer k by input v as:

Original: [Equation]
Revised: [Equation]

Original: where η <j>k ∈ N k for j = 1 , . .
Revised: where η <j>k ∈ N k for j = 1 , . .

Original: . , n k and n k is the number of neurons/nodes in the layer.
Revised: . , n k and n k is the number of neurons/nodes in the layer.

Original: See ﬁg.
Revised: See fig.

Original: 1(B).
Revised: 3(B).

Original: In SQANN, activations will be forwarded layer by layer, i.e. [ v 1 ] j =
Revised: In SQANN, activations will be forwarded layer by layer, i.e. [ v 1 ] j =

Original: σ dsa (cid:0)
Revised: σ dsa (cid:0)

Original: || x − η <j>|| (cid:1) where η <j>∈ N 1 and [ v k +1 ]
Revised: || x − η <j>|| (cid:1) where η <j>∈ N 1 and [ v k +1 ]

Original: j = σ dsa (cid:0) ||
Revised: j = σ dsa (cid:0) ||

Original: v k − η <j>k
Revised: v k − η <j>k

Original: +

Revised: +

Original: ||
Revised: ||

Original: (cid:1) where v <j>k +1 ∈ N k +1 .
Revised: (cid:1) where v <j>k +1 ∈ N k +1 .

Original: 3. SQANN C ONSTRUCTION
Revised: 3. SQANN C ONSTRUCTION

Original: Outline of SQANN construction with interpretations .
Revised: Outline of SQANN construction with interpretations .

Original: SQANN is constructed without optimization like gradient descent.
Revised: SQANN is constructed without optimization like gradient descent.

Original: Each indexed training data sample is converted into a “ﬁngerprint” or pattern of neuron activations, which undergoes one of the following:
Revised: Each indexed training data sample is converted into a “fingerprint” or pattern of neuron activations, which undergoes one of the following:

Original: Admission to layer k .
Revised: Admission to layer k .

Original: Sample’s new/distinct ﬁngerprint is added into layer k if the sample weakly activates existing nodes in the layer ( ∀ j, [ v k ] j < τ ad ) and no collision occurs; see ﬁg. 1(D.1).
Revised: Sample’s new/distinct fingerprint is added into layer k if the sample weakly activates existing nodes in the layer ( ∀ j, [ v k ] j < τ ad ) and no collision occurs; see fig. 3(D.1).

Original: Collision .
Revised: Collision .

Original: A sample activates one or more neurons strongly
Revised: A sample activates one or more neurons strongly

Original: i
Revised: i

Original: e. ∃ j, k, [ v k ] j > τ act .
Revised: e. ∃ j, k, [ v k ] j > τ act .

Original: The earliest layer where collision occurs is denoted l c .
Revised: The earliest layer where collision occurs is denoted l c .

Original: Such sample is integrated into l c , thus very similar samples are selectively clustered .
Revised: Such sample is integrated into l c , thus very similar samples are selectively clustered .

Original: See ﬁg. 1(D.2); also illustrated in the sketch of proof for proposition 4, appendix.
Revised: See fig. 3(D.2); the concept is also illustrated in the sketch of proof for proposition 3, appendix A.5.4. 3.

Original: Filtering into deeper layer occurs when neither of the above occurs (no strong activation, some moderate activations).
Revised: Filtering into deeper layer occurs when neither of the above occurs (no strong activation, some moderate activations).

Original: Such sample has features loosely similar to previously seen samples, but we need to ﬁlter them further to distinguish its ﬁner features. 
Revised: Such sample has features loosely similar to previously seen samples, but we need to filter them further to distinguish its finer features. be redirected

Original: Layer 1 construction .
Revised: Layer 1 construction .

Original: To initialize, let N 1 =
Revised: To initialize, let N 1 =

Original: ( η < 1 >) and α 1 =
Revised: ( η < 1 >) and α 1 =

Original: ( y < 1 >) where η < 1 >← x (1) and y < 1 >← y (1) .
Revised: ( y < 1 >) where η < 1 >← x (1) and y < 1 >← y (1) .

Original: Let τ ad , τ act be the admission threshold and activation threshold respectively.
Revised: Let τ ad , τ act be the admission threshold and activation threshold respectively.

Original: We typically set τ ad = 0 .
Revised: We typically set τ ad = 0 .

Original: 1 , τ act = 0 .
Revised: 1 , τ act = 0 .

Original: We extend the layer to tuples N 1 = ( η < 1 >, . . .
Revised: We extend the layer to tuples N 1 = ( η < 1 >, . . .

Original: , η <n 1 >) and α 

Revised: , η <n 1 >) and α

Original: =
Revised: =

Original: ( y < 1 >, . . .
Revised: ( y < 1 >, . . .

Original: y <n 1 >) through sample-collection function in the pseudo code 1.
Revised: y <n 1 >) through sample-collection function in the pseudo code 1.

Original: To do this, take a new sample ( x ( k ) , y ( k ) ) , k > 2 and we check N 1 activation , i.e. let v ( k ) 1 be the activation of current layer by this new sample, i.e. [ v ( k ) 1 ]
Revised: To do this, take a new sample ( x ( k ) , y ( k ) ) , k > 2 and we check N 1 activation , i.e. let v ( k ) 1 be the activation of current layer by this new sample, i.e. [ v ( k ) 1 ]

Original: j = σ dsa (cid:0) || x ( k ) − η <j>|| (cid:1) for all η <j>∈ N 1 .
Revised: j = σ dsa (cid:0) || x ( k ) − η <j>|| (cid:1) for all η <j>∈ N 1 .

Original: Then, either: (1) new sample is admitted to N 1 as a new distinct node/neuron.
Revised: Then, either: (1) new sample is admitted to N 1 as a new distinct node/neuron.

Original: If for all j such that [ v (2)1 ] j < τ ad , then
Revised: If for all j such that [ v (2)1 ] j < τ ad , then

Original: N 1 → concat ( N 1 , x ( k ) ) and α 1 → concat ( α 1 , y ( k ) ) .
Revised: N 1 → concat ( N 1 , x ( k ) ) and α 1 → concat ( α 1 , y ( k ) ) .

Original: (2) collision occurs, when there exists j such that τ act < [ v ( k ) 1 ] j < 1 , thus sample is admitted via collision resolution mechanism.
Revised: (2) collision occurs, when there exists j such that τ act < [ v ( k ) 1 ] j < 1 , thus sample is admitted via collision resolution mechanism.

Original: Exclusively for layer 1, sample will simply be admitted into the layer for selective clustering.
Revised: Exclusively for layer 1, sample will simply be admitted into the layer for selective clustering.

Original: New sample causing [ v ( k ) 1 ] j = 1 collision is unresolvable; see appendix on ill-deﬁned datasets (3) or new sample is ﬁltered to deeper layers , when neither occurs.
Revised: New sample causing [ v ( k ) 1 ] j = 1 collision is unresolvable; see appendix on ill-defined datasets (3) or new sample is filtered to deeper layers , when neither occurs.

Original: Finally, we complete the iteration over all training data, N 1 = ( η <k>: k = 1 , . . . , n 1 ) and α 1 = ( y <k> : k = 1 , . . . , n 1 ) .
Revised: Finally, we complete the iteration over all training data, N 1 = ( η <k>: k = 1 , . . . , n 1 ) and α 1 = ( y <k> : k = 1 , . . . , n 1 ) .

Original: Lemma 1 First layer of SQANN achieves arbitrary accuracy on training data subset N 1 × α 1 .
Revised: Lemma 1 Layer 1 of SQANN achieves arbitrarily high accuracy on training data subset N 1 × α 1 .

Original: Proof: Let N 1 = ( x < 1 > = x (1) , x < 2 > , . . .
Revised: Proof: Let N 1 = ( x < 1 > = x (1) , x < 2 > , . . .

Original: , x <n 1 > ) ; note that x <k> is not necessarily x ( k ) except for k = 1 for initialization.
Revised: , x <n 1 > ) ; note that x <k> is not necessarily x ( k ) except for k = 1 for initialization.

Original: To prove the lemma, take a sample ( x, y ) ∈ N 1 × α 1 .
Revised: To prove the lemma, take a sample ( x, y ) ∈ N 1 × α 1 .

Original: Then we must have x = x <j> , y = α <j>for some j = 1 , . . . , n 1 .
Revised: Then we must have x = x <j> , y = α <j>for some j = 1 , . . . , n 1 .

Original: Since [ v 1 ] j (cid:48) =
Revised: Since [ v 1 ] j ′ =

Original: σ dsa ( || x − η <j (cid:48) >|| ) and η <j (cid:48) >
Revised: σ dsa ( || x − η <j ′ >|| ) and η <j ′ >

Original: = x <j (cid:48) > for all j (cid:48) = 1 , . ..
Revised: = x <j ′ > for all j ′ = 1 , . .

Original:  , n 1 , we get exactly [ v 1 ] j = 1 .
Revised: . , n 1 , we get exactly [ v 1 ] j = 1 .

Original: Furthermore, for other i (cid:54) =
Revised: Furthermore, for other i ̸

Original:  j , we have [ v 1 ] i < 1 due to the admission conditions (1) and (2) used during check N 1 process .
Revised: = j , we have [ v 1 ] i < 1 due to the admission conditions (1) and (2) used during check N 1 process .

Original: Finally, computing y =
Revised: Finally, computing y =

Original: α <j>where j = argmax j (cid:48) [ v 1 ] j (cid:48) , we retrieve the exact value.
Revised: α <j>where j = argmax j ′ [ v 1 ] j ′ , we retrieve the exact value.

Original: (cid:3)
Revised: □

Original: At this point, it may be clearer to readers how SQANN is constructed.
Revised: At this point, it may be clearer to readers how SQANN is constructed.

Original: In short, for each layer, representative activations become the neurons of the layer.
Revised: In short, for each layer, representative activations become the neurons of the layer.

Original: In layer 1, representatives activations are the samples themselves.
Revised: In layer 1, representatives activations are the samples themselves.

Original: In deeper layers, they are activations propagated to the layer.
Revised: In deeper layers, they are activations propagated to the layer.

Original: Layer k construction .
Revised: Layer k construction .

Original: Layer k construction is similar to layer 1 construction, except collision could occur at any layer l c ≤ k (next paragraph).
Revised: Layer k construction is similar to layer 1 construction, except collision could occur at any layer l c ≤ k (next paragraph).

Original: Assume every layer l ∈ Λ = { 1 , . . .
Revised: Assume every layer l ∈ Λ = { 1 , . . .

Original: , k − 1 } have been constructed using X i ∈ Λ ⊆ X .
Revised: , k − 1 } have been constructed using X i ∈ Λ ⊆ X .

Original: Assume there are still unused data samples i.e. U =
Revised: Assume there are still unused data samples i.e. U =

Original: X \ { (cid:83) k − 1 i =

Revised: X \ { (cid:83) k − 1 i =

Original: X i } is non-empty, obtained from samples that have been ﬁltered to deeper layers .
Revised: X i } is non-empty, obtained from samples that have been filtered to deeper layers .

Original: Let U = { u < 1 > , u < 2 > , . . . } after re-labelling the indices, with corresponding output values { y < 1 > , . . . } .
Revised: Let U = { u < 1 > , u < 2 > , . . . } after re-labelling the indices, with corresponding output values { y < 1 > , . . . } .

Original: Initialize by ﬁrst checking v < 1 > k , the activation of u < 1 > at layer k for collision; if collision occurs, see next paragraph, otherwise, set N k =
Revised: Initialize by first checking v < 1 > k , the activation of u < 1 > at layer k for collision; if collision occurs, see next paragraph, otherwise, set N k =

Original: ( η < 1 > k ) , α k =
Revised: ( η < 1 > k ) , α k =

Original: ( y < 1 > k ) i.e. η < 1 > k ← v < 1 > k .
Revised: ( y < 1 > k ) i.e. η < 1 > k ← v < 1 > k .

Original: Similar to layer 1 construction, perform check N k activation on ( u <i> , y <i> ) for i > 1 by computing activation v <i>k and checking it against the existing nodes.
Revised: Similar to layer 1 construction, perform check N k activation on ( u <i> , y <i> ) for i > 1 by computing activation v <i>k and checking it against the existing nodes.

Original: One of the three cases occur (1) admission, when [ v <i>k ] j < τ ad for all j = 1 , . . . , n k and no collision (2) collision, when there exists index j at a collided layer l c ≤ k such that [ v <i>l c ] j > τ act or (3) otherwise.
Revised: One of the three cases occur (1) admission, when [ v <i>k ] j < τ ad for all j = 1 , . . . , n k and no collision (2) collision, when there exists index j at a collided layer l c ≤ k such that [ v <i>l c ] j > τ act or (3) otherwise.

Original: If (1) occurs, the activation v <i>k is added as a new neuron to the layer, N k → concat ( N k , v <i>k ) .
Revised: If (1) occurs, the activation v <i>k is added as a new neuron to the layer, N k → concat ( N k , v <i>k ) .

Original: If (3) occurs, ﬁlter the data sample for deeper layer.
Revised: If (3) occurs, filter the data sample for deeper layer.

Original: Assuming no collision, the process is repeated for the next unused data sample u <i> until all remaining data samples are checked.
Revised: Assuming no collision, the process is repeated for the next unused data sample u <i> until all remaining data samples are checked.

Original: Once done, repeat the process for layer k +construction.
Revised: Once done, repeat the process for layer k +construction.

Original: Suppose collision happens when we check u <m> at layer l c , we use the collision resolution mechanism.
Revised: Suppose collision happens when we check u <m> at layer l c , we use the collision resolution mechanism.

Original: We destroy all layers l > l c and put the collided sample into l c , i.e. N l c → concat ( N l c , v <m>k ) and α l c → concat ( α l c , y <m>k ) (push-node in the pseudo code).
Revised: We destroy all layers l > l c and put the collided sample into l c , i.e. N l c → concat ( N l c , v <m>k ) and α l c → concat ( α l c , y <m>k ) (push-node in the pseudo code).

Original: No layer will be destroyed if l c = k , the current layer.
Revised: No layer will be destroyed if l c = k , the current layer.

Original: The data samples used in each destroyed layer are returned to the list of unused samples in the same order they have been used during the construction (returnindex() in the pseudo code); we refer to this as order integrity .
Revised: The data samples used in each destroyed layer are returned to the list of unused samples in the same order they have been used during the construction (returnindex() in the pseudo code); we refer to this as order integrity .

Original: Once the colliding sample is added to l c , effectively, the strong activation in this layer is now overshadowed by maximum activation ( selective clustering in action), since the exact neuron is now included as the representative of itself and its locality.
Revised: Once the colliding sample is added to l c , effectively, the strong activation in this layer is now overshadowed by maximum activation ( selective clustering in action), since the exact neuron is now included as the representative of itself and its locality.

Original: This is possibly a practically inefﬁcient process, since we tear down intermediate layers, but we only prioritize the completion of the construction for now.
Revised: This is possibly a practically inefficient process, since we tear down intermediate layers, but we only prioritize the completion of the construction for now.

Original: Computing output via SQANN propagation (prediction) .
Revised: Computing output via SQANN propagation (prediction) .

Original: Let an input be x .
Revised: Let an input be x .

Original: The output y =
Revised: The output y =

Original: SQANN ( x ) is computed by propagating and processing signals through the layers; ﬁg. 1(B).
Revised: SQANN ( x ) is computed by propagating and processing signals through the layers; fig. 3(B).

Original: Then [ v 1 ] j = σ dsa (cid:0) || x − η <j>|| (cid:1) .
Revised: Then [ v 1 ] j = σ dsa (cid:0) || x − η <j>|| (cid:1) .

Original: If there exists j such that v <j>> τ act , then set y =
Revised: If there exists j such that v <j>> τ act , then set y =

Original: α <j>where j = argmax j (cid:48) [ v 1 ] j (cid:48) .
Revised: α <j>where j = argmax j ′ [ v 1 ] j ′ .

Original: Otherwise, for subsequent layer k , recursively compute [ v k ] j = σ dsa (cid:0)
Revised: Otherwise, for subsequent layer k , recursively compute [ v k ] j = σ dsa (cid:0)

Original: || v k − 1 − η <j>k || (cid:1) for all j = 1 , . .
Revised: || v k − 1 − η <j>k || (cid:1) for all j = 1 , . .

Original: . , n k .
Revised: . , n k .

Original: If there exist j, k such that [ v k ] j > τ act , then y =
Revised: If there exist j, k such that [ v k ] j > τ act , then y =

Original: α <j>k where j = argmax j (cid:48) [ v k ] j (cid:48) .
Revised: α <j>k where j = argmax j ′ [ v k ] j ′ .

Original: If such layer k is not found, we have to perform interpolation.
Revised: If such layer k is not found, we have to perform interpolation.

Original: Interpolations can be done in many different ways, and this paper implements a simple interpolation using values from the two most strongly activated neurons.
Revised: Interpolations can be done in many different ways, and this paper implements a simple interpolation using values from the two most strongly activated neurons.

Original: Suppose V 1 =
Revised: Suppose V 1 =

Original: [ v m ] i and
Revised: [ v m ] i and

Original: V 2 =
Revised: V 2 =

Original: [ v n ] j are the two most activated neurons, then the interpolated value can be, for example, y 
Revised: [ v n ] j are the two most activated neurons, then the interpolated value can be, for example, y =

Original: =
Revised: [Equation]

Original: V 1 [ α m ] i + V[-
-]
Revised: [ α n [Equation] V[-
-]

Original: [ α n ] j V 1 + V. The form of interpolation can be adjusted according to the knowledge we have on the dataset, e.g. we can use TNN with high a if we know the dataset is locally constant.
Revised: [Equation] + V. The form of interpolation can be adjusted according to the knowledge we have on the dataset, e.g. we can use TNN with high a if we know the dataset is locally constant.

Original: See appendix  for illustration and remarks.
Revised: See appendix A.5.2 for illustration and remarks.

Original: Each training sample x admitted to layer N k leaves a ﬁngerprint, in the sense that it has a collection of activations { v l | l = 1 , . .
Revised: Each training sample x admitted to layer N k leaves a fingerprint, in the sense that it has a collection of activations { v l | l = 1 , . .

Original: . , k } as it is SQANN-propagated through the neural network.
Revised: . , k } as it is SQANN-propagated through the neural network.

Original: This collection is unique amongst training samples, especially because of [ v k ] j = 1 where j is an index within layer
Revised: This collection is unique amongst training samples, especially because of [ v k ] j = 1 where j is an index within layer

Original: k it is admitted into.
Revised: k it is admitted into.

Original: Furthermore, locality is preserved to the extent that if x (cid:48) ≈ x , then activation [ v (cid:48)
Revised: Furthermore, locality is preserved to the extent that if x ′ ≈ x , then activation [ v ′ k ]

Original: k ] j ≈ 1 is around the peak and thus, by SQANN propagation, due to argmax, it is likely we retrieve y , the ground-truth value corresponding to x .
Revised: j ≈ 1 is around the peak and thus, by SQANN propagation, due to argmax, it is likely we retrieve y , the ground-truth value corresponding to x .

Original: For now, we only use argmax, but more subtle adjustment can be done to obtain y(cid:48)
Revised: For now, we only use argmax, but more subtle adjustment can be done to obtain y

Original: ≈
Revised: ≈

Original: y but y (cid:48)
Revised: y but y ′ ̸

Original: (cid:54) = y for x (cid:48) by incorporating information about the manifold at that locality, if such knowledge is available.
Revised: = y for x ′ by incorporating information about the manifold at that locality, if such knowledge is available.

Revised: See appendix A.5.3 on good practice for scalability .

Original: Completing construction .
Revised: Completing construction .

Original: Due to collisions, readers might wonder if the construction will complete at all.
Revised: Due to collisions, readers might wonder if the construction will complete at all.

Original: During collision, layers are torn down and reconstructed.
Revised: During collision, layers are torn down and reconstructed.

Original: Suppose during layer k construction, collision occurs at layer c for c < k .
Revised: Suppose during layer k construction, collision occurs at layer c for c < k .

Original: Upon reconstruction back to layer k , layer c may be torn down again in the next collisions.
Revised: Upon reconstruction back to layer k , layer c may be torn down again in the next collisions.

Original: Is it possible that collision occurs inﬁnitely cyclically?
Revised: Is it possible that collision occurs infinitely cyclically?

Original: The following proposition addresses the concern through order integrity previously mentioned.
Revised: The following proposition addresses the concern through order integrity previously mentioned.

Original: Proposition 4 SQANN construction completes with high probability p ≈ 1 .
Revised: Proposition 3 SQANN construction completes with high probability p ≈ 1 .

Original: See appendix  for (1) sketch of proof and a required assumption (2) stronger assumption needed for p = 1 .
Revised: See appendix A.5.4 for (1) sketch of proof and a required assumption (2) stronger assumption needed for p = 1 .

Original: Arbitrarily high accuracy on training dataset D is relatively simple to prove in the following theorem: roughly for each ( x, y ) ∈ D , there exist l, k such that x maximally activates the node η <k>l , thus the correct y is guaranteed to be fetched from α l .
Revised: Arbitrarily high accuracy on training dataset D is relatively simple to prove in the following theorem: roughly for each ( x, y ) ∈ D , there exist l, k such that x maximally activates the node η <k>l , thus the correct y is guaranteed to be fetched from α l .

Original: Catastrophic forgetting resistance is proven similarly: when new samples are used for training, previous samples are not forgotten since
Revised: Catastrophic forgetting resistance is proven similarly: when new samples are used for training, previous samples are not forgotten since

Original: SQANN stores the particular ﬁngerprint η <k>l for each sample.
Revised: SQANN stores the particular fingerprint η <k>l for each sample.

Original: Theorem 2 Assume SQANN construction is completed.
Revised: Theorem 2 Assume SQANN construction is completed.

Original: SQANN achieves arbitrarily high accuracy on a training dataset.
Revised: SQANN achieves arbitrarily high accuracy on a training dataset.

Original: Furthermore, it is resistant to catastrophic forgetting.
Revised: Furthermore, it is resistant to catastrophic forgetting.

Original: Proof: see appendix.
Revised: Proof: see appendix

Original:  Note: Our code provides experimental demonstrations showing zero errors on all training samples.
Revised: A.5.5. Note: Our code provides experimental demonstrations showing zero errors on all training samples; see example results in fig. 3(C).

Original: SQANN pencil-and-paper example .
Revised: SQANN pencil-and-paper example .

Original: With a 1 , a 2 = 0 .
Revised: With a 1 , a 2 = 0 .

Original: 001 , 0 . 5 , τ ad , τ act = 0 . 1 , 0 . 9 , create
Revised: 001 , 0 . 5 , τ ad , τ act = 0 . 1 , 0 . 9 , create

Original: SQANN universal approximator for indexed data X =
Revised: SQANN universal approximator for indexed data X =

Original: [ x (1) , x (2) , x (3) , x (4) ]
Revised: [ x (1) , x (2) , x (3) , x (4) ]

Original: = (cid:2) [Table]
Revised: = (cid:2) 1 1 . 2 − 1 − 1 .

Original:  2 (cid:3) and Y =
Revised: 8 − 1 − 1 . 2 (cid:3) and Y =

Original: [ y 1 , y 2 , y 3 , y 4 ] =
Revised: [ y 1 , y 2 , y 3 , y 4 ] =

Original: See follow up questions and full solutions in the appendix.
Revised: See appendix A.5.6 for more questions and solutions.

Original: 3. E XPERIMENT TO TEST G ENERALIZABILITY OF SQANN
Revised: 3. E XPERIMENT TO TEST G ENERALIZABILITY OF SQANN

Original: Test datasets with increasing spread from training distribution .
Revised: Test datasets with increasing spread from training distribution .

Original: The accuracy of SQANN on high-dimensional dataset outside the training dataset is harder to formalize in theorems.
Revised: The accuracy of SQANN on high-dimensional dataset outside the training dataset is harder to formalize in theorems.

Original: Furthermore, real life data is often noisy and possibly not regularly structured.
Revised: Furthermore, real life data is often noisy and possibly not regularly structured.

Original: We avoid making any related statements for SQANN for now.
Revised: We avoid making any related statements for SQANN for now.

Original: We instead provide empirical results on test datasets that are similar to the training dataset, to the extent that each point in the test dataset is a training sample perturbed by uniform random values of increasing magnitude.
Revised: We instead provide empirical results on test datasets that are similar to the training dataset, to the extent that each point in the test dataset is a training sample perturbed by uniform random values of increasing magnitude.

Original: We refer to the noise magnitude as the test data spread .
Revised: We refer to the noise magnitude as the test data spread .

Original: Fig.
Revised: Fig.

Original: 4(A,A.2) show four domains X with different test data spread.
Revised: 4(A,A.2) show four domains X with different test data spread.

Original: Test dataset that has larger test data spread contains data samples that are noisier and further away from the training data points.
Revised: Test dataset that has larger test data spread contains data samples that are noisier and further away from the training data points.

Original: Fig.
Revised: Fig.

Original: 4(B,B.2) show that SQANN naturally performs better with smaller test data spread.
Revised: 4(B,B.2) show that SQANN naturally performs better with smaller test data spread.

Original: As the test data spread increases, larger errors are observed.
Revised: As the test data spread increases, larger errors are observed.

Original: Likewise, smaller spread means smaller N interp , i.e. fewer data samples fail to activate neurons in SQANN strongly.
Revised: Likewise, smaller spread means smaller N interp , i.e. fewer data samples fail to activate neurons in SQANN strongly.

Original: For all, training errors are 0 as expected from theorem 2 .
Revised: For all, training errors are 0 as expected from theorem 2 .

Original: Classiﬁcation and visualization of SQANN’s special interpretability features .
Revised: Classification and visualization of SQANN’s special interpretability features .

Original: We show the use of SQANN for a simple classiﬁcation problem in ﬁg. 1(C).
Revised: We show the use of SQANN for a simple classification problem in fig. 3(C).

Original: The ring outside is labelled 0 .
Revised: The ring outside is labelled 0 .

Original: 5 , while the ring inside 1 . 0 .
Revised: 5 , while the ring inside 1 . 0 .

Original: With activation parameters a 1 = a 2 = 1 , we achieve zero error not only for training dataset (to be expected from theorem 2) but also on test dataset.
Revised: With activation parameters a 1 = a 2 = 1 , we achieve zero error not only for training dataset (to be expected from theorem 2) but also on test dataset.

Original: A special feature in
Revised: A special feature in

Original: SQANN is its ability to tell the user which data samples fail to activate any neurons strongly; such samples’ output must be interpolated (see SQANN propagation).
Revised: SQANN is its ability to tell the user which data samples fail to activate any neurons strongly; such samples’ output must be interpolated (see SQANN propagation).

Original: In ﬁg. 1(C) right, points marked with red open circles need interpolation.
Revised: In fig. 3(C) right, points marked with red open circles need interpolation.

Original: Each such point is interpolated using two training samples whose “ﬁngerprint” neurons are most strongly excited.
Revised: Each such point is interpolated using two training samples whose “fingerprint” neurons are most strongly excited.

Original: These two samples are shown as the two points directly linked by colored straight lines to the open circle.
Revised: These two samples are shown as the two points directly linked by colored straight lines to the open circle.

Original: This is possible because SQANN systematically stores indices of training data samples within respective layers.
Revised: This is possible because SQANN systematically stores indices of training data samples within respective layers.

Original: The list of indices organized by layers can even be explicitly printed e.g. see SQANN.ipynb, supp.
Revised: The list of indices organized by layers can even be explicitly printed e.g. see SQANN.ipynb, supp.

Original: materials.
Revised: materials.

Original: SQANN is tested for regression on Boston Housing and Diabetes Datasets to demonstrate its generalizability to unseen/test samples, as the following (simpliﬁed here): (1) A small subset of samples D ⊆ D (the ﬁrst 20% of full dataset D ) is used to train SQANN and 9 other regression methods.
Revised: SQANN is tested for regression on Boston Housing and Diabetes Datasets to demonstrate its generalizability to unseen/test samples, as the following (simplified here): (1) A small subset of samples D ⊆ D (the first 20% of full dataset D ) is used to train SQANN and 9 other regression methods.

Original: (2) Mean Squared Errors (MSE) values are measured on unused data D test on allmodels; we expect large errors on some test samples.
Revised: (2) Mean Squared Errors (MSE) values are measured on unused data D test on allmodels; we expect large errors on some test samples.

Original: (3) SQANN’s activations are used to collect samples with large absolute errors e τ ( x ) =
Revised: (3) SQANN’s activations are used to collect samples with large absolute errors e τ ( x ) =

Original: | SQANN ( x ) − y 

Revised: | SQANN ( x ) − y

Original: | >
Revised: | >

Original: τ
Revised: τ

Original: and we treat them as out-ofdistribution (OOD) samples.
Revised: and we treat them as out-ofdistribution (OOD) samples.

Original: These samples are considered as new distinct samples to be integrated into D as the new training dataset D (cid:48) .
Revised: These samples are considered as new distinct samples to be integrated into D as the new training dataset D ′ .

Original: (4) Train the 10 models, now with D (cid:48) .
Revised: (4) Train the 10 models, now with D ′ .

Original: Then MSE is measured again on D test (yes, there will be partial overﬁtting).
Revised: Then MSE is measured again on D test (yes, there will be partial overfitting).

Original: From Boston dataset: for τ = 5 ,
Revised: From Boston dataset: for τ = 5 ,

Original: SQANN MSE improved from 9 .
Revised: SQANN MSE improved from 9 .

Original: 90 to 3 .
Revised: 90 to 3 .

Original: Decision tree improves the most with D (cid:48) (7.36 to 2.07); see table 1.
Revised: Decision tree improves the most with D ′ (7.36 to 2.07); see table 1.

Original: For more details and diabetes dataset, see the appendix.
Revised: For more details and diabetes dataset, see the appendix A.5.7.

Original:  C ONCLUSION , L IMITATION AND F UTURE D IRECTIONLimitations and future directions .
Revised:  C ONCLUSION , L IMITATION AND F UTURE D IRECTION

Revised: Limitations and future directions .

Original: TNN is clearly limited in regards to its application to multi-dimensional input data. However, it might ﬁnd interesting uses in time series, such as ECG (Electrocardiogram).
Revised: TNN is clearly limited in regards to its application to multidimensional input data although it can be useful on different types of time series data.

Original: ECG signals can be approximated point-wise, though it might be better to have a noise model to prevent overﬁtting.

Original: In particular, PQRST segments from ECG can be mapped to speciﬁc neurons within TNN, giving some neurons speciﬁc meaning and thus interpretability.

Original: SQANN limitation and possible future development currently include 1) simple sequential drawing of samples that may result in the imbalance of layer size.
Revised: SQANN limitation and possible future development currently include 1) simple sequential drawing of samples that may result in the imbalance of layer size.

Original: In the future, more sophisticated ordering of training samples can be used so that layers are constructed with meaningful and purposeful arrangement e.g. deeper layers can be purposefully reserved for rare cases; more research on this is necessary to optimize the results 2) layer destruction during the treatment of collision cases might be an inefﬁcient mechanism, which can be improved in the future.
Revised: In the future, more sophisticated ordering of training samples can be used so that layers are constructed with meaningful and purposeful arrangement e.g. deeper layers can be purposefully reserved for rare cases; more research on this is necessary to optimize the results 2) layer destruction during the treatment of collision cases might be an inefficient mechanism, which can be improved in the future.

Original: In conclusion, we have proposed TNN and SQANN, two interpretable NNs for universal approximation designed to (1) be resistant to catastrophic forgetting (2) have provably high accuracy on training datasets and (3)  be directly interpretable via neurons’ activation patterns.
Revised: Conclusion , we have proposed TNN and SQANN, two interpretable NNs for universal approximation designed to (1) be resistant to catastrophic forgetting (2) have provably high accuracy on training datasets and (3) can be used to handle out-of-distribution samples.

Original: Buffer page , just in case.
Revised: Buffer page . Just in case.

Original: [Table]
Revised: [Table]

Original: Note on table 1 .
Revised: Note on table 1 .

Original: The entries in the header denote the models available in scikit-learn (Pedregosa et al.
Revised: The entries in the header denote the models available in scikit-learn (Pedregosa et al.

Original: (2011b)):
Revised: (2011b)):

Original: Lin, Ridge and Lasso are the linear models: linear , Ridge (linear least square with L2 regularization), Lasso (linear with L1) respectively; the Support Vector Regression models:
Revised: Lin, Ridge and Lasso are the linear models: linear , Ridge (linear least square with L2 regularization), Lasso (linear with L1) respectively; the Support Vector Regression models:

Original: LinSVR, NuSVR, SVR are respectively linear SVR, ν -SVR and (cid:15) -SVR.
Revised: LinSVR, NuSVR, SVR are respectively linear SVR, ν -SVR and ϵ -SVR.

Original: DTree: Decision tree; kneigh: k neighbours are selected from the best k = 2 , 3 , ..., 16 , MLP: multi-layer perceptrons, or the fully-connected neural network, with 2 layers, each layer having 64 neurons each trained for a max of 12000 iterations (convergence is attained for both).
Revised: DTree: Decision tree; kneigh: k neighbours are selected from the best k = 2 , 3 , ..., 16 , MLP: multi-layer perceptrons, or the fully-connected neural network, with 2 layers, each layer having 64 neurons each trained for a max of 12000 iterations (convergence is attained for both).

Original: For SQANN, the initial model trained on D is kept after SQANN’ is trained on D (cid:48) .
Revised: For SQANN, the initial model trained on D is kept after SQANN’ is trained on D ′ .

Original: Thus, we can choose results based on the strength of activations between SQANN and SQANN’.
Revised: Thus, we can choose results based on the strength of activations between SQANN and SQANN’.

Original: For Boston Housing Dataset τ = 5 (i.e. e5 of table 1), using SQANN we integrated 211 samples from the test dataset into training dataset, so | D (cid:48) | = 311 .
Revised: For Boston Housing Dataset τ = 5 (i.e. e5 of table 1), using SQANN we integrated 211 samples from the test dataset into training dataset, so | D ′ | = 311 .

Original: Overall, 0 .
Revised: Overall, 0 .

Original: 615 of the whole D is used for new training.
Revised: 615 of the whole D is used for new training.

Original: For τ = 2 , i.e. e2 of table 1, using SQANN we integrated 319 samples, so | D (cid:48) | =i.e. 0 .
Revised: For τ = 2 , i.e. e2 of table 1, using SQANN we integrated 319 samples, so | D ′ | =i.e. 0 .

Original: 828 of the whole D is used for new training.
Revised: 828 of the whole D is used for new training.

Original: With τ = 2 , regression performance of SQANN improves greatly compared to other methods, except for decision tree regression.
Revised: With τ = 2 , regression performance of SQANN improves greatly compared to other methods, except for decision tree regression.

Original: We have thus also seen that SQANN can be used to perform sample selections for data that appear to be out of distribution; this has improved decision tree performance greatly.
Revised: We have thus also seen that SQANN can be used to perform sample selections for data that appear to be out of distribution; this has improved decision tree performance greatly.

Original: The performance of other models have improved reasonably too, especially MLP.
Revised: The performance of other models have improved reasonably too, especially MLP.

Original: For MLP, however, the randomness used to achieve convergence to some local minima might have led it to explore other minima; hence we get slightly decreased performance for e2 compared to e5.
Revised: For MLP, however, the randomness used to achieve convergence to some local minima might have led it to explore other minima; hence we get slightly decreased performance for e2 compared to e5.

Original: [Table]
Revised: [Table]

Revised: now) if ssig is ’no more data’: break elif ssig is ’collision’:

Revised: l c = collision[’collided layer’] for l j from l c+1 to l now+1: return index(l j) kp = collision[’perpetrator index’] push node(kp,X[kp,:],Y[kp],l c) l now =

Revised: l c l now+= def sample collection(X,Y,layer): i=unused indices[0] x=X[i,:]x,collision = forward cons(x,layer−1) ssig, collision = check signal(collision) nodes, node values = new nodes(x,Y[i]) remove index(i,layer) for i in unused indices: x=X[i,:]x,collision = forward cons(x,layer−1) ssig, collision = check signal(collision) act=activate(x,nodes) if all (act < admission threshold) update nodes(x,Y[i],nodes,node values) remove index(i,layer) return ssig, collision

Original: Pseudo code 1: Pseudo code for the construction of SQANN.
Revised: Pseudo code 1: Pseudo code for the construction of SQANN.

Original: The function activate corresponds to equation 5.
Revised: The function activate corresponds to equation 5.

Original: See appendix  for mapping to python code.
Revised: See appendix B.2 for mapping to python code.

Original: E THICS S TATEMENTS
Revised: E THICS S TATEMENTS

Original: This paper introduces function approximators with novel properties.
Revised: This paper introduces function approximators with novel properties.

Original: It is purely mathematical and algorithmic.
Revised: It is purely mathematical and algorithmic.

Original: No speciﬁc ethical issues are present.
Revised: No specific ethical issues are present.

Original: The ethical context depends only on the dataset but in this paper, only common public datasets have been used.
Revised: The ethical context depends only on the dataset but in this paper, only common public datasets have been used.

Original: R EPRODUCIBILITY S TATEMENTS
Revised: R EPRODUCIBILITY S TATEMENTS

Original: All codes are available in the supp.
Revised: All codes are available in the supp.

Original: materials (to be released to public repository in case of acceptance).
Revised: materials (to be released to public repository in case of acceptance).

Original: Results are easily reproducible even with without random number seeding since data distributions are sufﬁciently controlled.
Revised: Results are easily reproducible even with without random number seeding since data distributions are sufficiently controlled.

Original: Jupyter notebook for our particular results are also present.
Revised: Jupyter notebook for our particular results are also present.

Original: Proofs are all included in the appendix, with sketch of proof and additional statement of assumptions where applicable.
Revised: Proofs are all included in the appendix, with sketch of proof and additional statement of assumptions where applicable.

Original: A CKNOWLEDGMENTS
Revised: A CKNOWLEDGMENTS

Original: Anonymous for now.
Revised: Anonymous for now.

Revised: A A PPENDIX

Revised: We have reorganized the content based on ICLR 2022 reviews.

Revised: Also, contents that are less relevant are moved to the Extra section B at the end of appendix.

Original: A A PPENDIX A. A LGORITHM C ODE AND S UPPLEMENTARY M ATERIALS
Revised: A. A LGORITHM C ODE AND S UPPLEMENTARY M ATERIALS

Original: All the codes are available in the supplementary material, and the link to the repository will be made public if the paper is accepted.
Revised: All the codes are available in the supplementary material, and the link to the repository will be made public if the paper is accepted.

Original: README.md lists the necessary commands to obtain the results found in this paper.
Revised: README.md lists the necessary commands to obtain the results found in this paper.

Original: Results in Jupyter notebooks format are also included.
Revised: Results in Jupyter notebooks format are also included.

Original: A. A PPENDIX FOR TNN
Revised: A. C ONCEPT DISAMBIGUATION

Revised: Link back to main text introduction, section 1.

Revised: A.2. U NIVERSAL APPROXIMATION

Revised: Universal approximation by TNN and SQANN is not restricted to specific conditions.

Revised: Traditional approximation may require strong conditions e.g. Cybenko (1989) shows result on C ( I n ) , space of continuous function.

Revised: Continuous function that approximates two points necessitate continuous interpolation for any point along the path between these two points.

Revised: However, hypothetically, pathological set of data points may exist where the value is not even continuous along the path.

Revised: Our

Revised: SQANN, for example, can handle this since we allow user to choose the interpolation function in the case interpolations are opted for output computation (e.g. during weak activations).

Revised: A.2. C ATASTROPHIC F ORGETTING

Revised: Catastrophic forgetting and online learning .

Revised: Continual or online learning have posed some known challenges.

Revised: In Kirkpatrick et al.

Revised: (2017), catastrophic forgetting is defined as “the tendency for knowledge of previously learnt task(s) (e.g. task A) to be abruptly lost as information relevant to the current task (e.g. task B) is incorporated”.

Revised: In our context, we can distinguish task A from task

Revised: B as old and new dataset.

Revised: Learning from the new dataset which has possibly different distribution from the old dataset might degrade the performance of the model.

Revised: Analogy to biological system and resistance to catastrophic forgetting .

Revised: Unlike artificial NN, mammalian brain retains old information when it learns new information by protecting previously acquired knowledge in neocortical circuits ; see Kirkpatrick et al.

Revised: (2017) and the references thereof.

Revised: As rats learn new skills, the volumes of dendritic spines in their brains increase (Yang et al.

Revised: (2009)) while existing dendrites persist, thus they retain old memories.

Revised: Both TNN and SQANN have similar property.

Revised: Particularly, SQANN increases the size of a layer as it progressively acquires new samples during construction (learning).

Revised: This inevitably increases the number of weights that connect the layers; see fig.

Revised: 3(D.1, D.2).

Revised: Furthermore, they exhibit resistance to catastrophic forgetting .

Revised: In TNN, this is simply because the old sample x old still yields activation with signature [1 , 1 , ..., 1 , 0 , 0 , ..., 0] , in which the last activated neuron (taking the value 1) is still identified with the old sample.

Revised: For SQANN, each old sample is not forgotten since its exact “fingerprint” is already registered (i.e. input x old has been converted) to a neuron’s nucleus η <k>l for some l, k , as shown in fig.

Revised: 3(B).

Revised: The activation pattern of a sample x old includes the value 1 in a specific node of a “synapse”, v <k>l and the particular combinations of values in other synapses.

Revised: Advantage over existing methods .

Revised: Existing ML methods do not typically admit out-ofdistributions easily; i.e. even if we re-train them on the new ood samples, they may end up with poor prediction on ood.

Revised: As an illustration, a linear regression that includes ood samples may shift the gradient a little, but ood sample is still far from the regression line.

Revised: To make the matter worse, when there are many ood enough to change the distribution of the data sample significantly, the model may forget the previous distribution: we consider this catastrophic forgetting.

Revised: A. R ELATED WORKS

Revised: Older works on the construction of universal approximators do not focus on interpretability as well, thus readers have to observe for themselves the shape of the resulting networks from the components used in the construction.

Revised: For example, there are works related to spline functions like Mhaskar &

Revised: Micchelli (1992); Mhaskar (1993b;a); Chui et al. (1994); another example by Sartori & Antsaklis

Revised: (1991) where two-layer NN can be formed by arbitrarily choosing the weights of first layer and computing the weights of second layer explicitly; and section 5 of Pinkus (1999) shows the equations used to obtain weights and proves the existence of such solutions.

Revised: In some of them and others such as Mhaskar (1996); Chui et al.

Revised: , the focus lies in error quantification.

Revised: A. A PPENDIX FOR TNN

Revised: Link back to main text section 2.

Original: The traditional deﬁnition of NN with a single hidden layer is given by Σ i
Revised: The traditional definition of NN with a single hidden layer is given by Σ i

Original: α i σ ( y Ti x + b i ) following equation (1) from Cybenko (1989), with x, y i ∈ R n , b i ∈ R where σ is any sigmoidal function with the property speciﬁed in the paper.
Revised: α i σ ( y Ti x + b i ) following equation (1) from Cybenko (1989), with x, y i ∈ R n , b i ∈ R where σ is any sigmoidal function with the property specified in the paper.

Original: A familiar example of a sigmoidal function is the sigmoid function 1 / (1 + e − x ) .
Revised: A familiar example of a sigmoidal function is the sigmoid function 1 / (1 + e − x ) .

Original: Compared to the traditional version, TNN has a slight generalization on the weights W , which is also a form that has been used in modern implementation.
Revised: Compared to the traditional version, TNN has a slight generalization on the weights W , which is also a form that has been used in modern implementation.

Original: Note: linear  order is any binary relation with (1) reﬂexivity (2) transitivity (3) anti-symmetricity (4) x ≤ y or y ≤ x .
Revised: Assumption: linear ordering . Linear order is any binary relation with (1) reflexivity (2) transitivity (3) anti-symmetricity (4) x ≤ y or y ≤ x .

Original: As is customary (Mhaskar (1993a)), the domain of the function is limited to [0 , 1] n where n is the number of dimensions of the input, justiﬁable for practical dataset with ﬁnite domain easily scaled to [0 , 1] .
Revised: As is customary (Mhaskar (1993a)), the domain of the function is limited to [0 , 1] n where n is the number of dimensions of the input, justifiable for practical dataset with finite domain easily scaled to [0 , 1] .

Revised: Some readers might ask how linear ordering can be performed meaningfully.

Revised: Also, if linear ordering is done by human, interpretability is not improved, since human user already knows about ordering.

Revised: To answer that, we again refer to the ECG example we gave earlier: time series is a naturally linearly ordered data.

Revised: Next, linear ordering in TNN can be seen as a parameter strength tuning, useful for example when TNN is incorporated in a larger system.

Original: Ordered activation .
Revised: Ordered activation .

Original: Recall that we would like x (1) to activate all neurons, while x ( N ) activates only 1 neuron, so that eventually we achieve something like ﬁg. 2(A).
Revised: Recall that we would like x (1) to activate all neurons, while x ( N ) activates only 1 neuron, so that eventually we achieve something like fig. 1(A).

Original: To approximately fulﬁl the ordered activation conditions stated in the main text, we ﬁrst need ( Wx (1) + b ) j ≥ a for all j , where sub-script j denotes the j -th component in the vector, to distinguish from superscript ( k ) which denotes the k -th data sample according to the linear ordering.
Revised: To approximately fulfil the ordered activation conditions stated in the main text, we first need ( Wx (1) + b ) j ≥ a for all j , where sub-script j denotes the j -th component in the vector, to distinguish from superscript ( k ) which denotes the k -th data sample according to the linear ordering.

Original: The next iteration will be ( Wx (2) + b ) j ≤ − a for j = N and ( Wx (2) + b ) j ≥ a for j = 1 , . . .
Revised: The next iteration will be ( Wx (2) + b ) j ≤ − a for j = N and ( Wx (2) + b ) j ≥ a for j = 1 , . . .

Original: , N − 1 , and similarly for other x ( k ) for k = 3 , . .
Revised: , N − 1 , and similarly for other x ( k ) for k = 3 , . .

Original: . , N .
Revised: . , N .

Original: With this, we attain eq.
Revised: With this, we attain eq.

Original: (1) and (2).
Revised: (1) and (2).

Original: Since we use sigmoid function, these conditions are ideal and not strictly attainable, because sigmoid function asymptotically achieves 0 and 1 at inﬁnities.
Revised: Since we use sigmoid function, these conditions are ideal and not strictly attainable, because sigmoid function asymptotically achieves 0 and 1 at infinities.

Original: Nevertheless, we show later that we can achieve arbitrarily small error (cid:15) by adjusting activation threshold a .
Revised: Nevertheless, we show later that we can achieve arbitrarily small error ϵ by adjusting activation threshold a .

Original: We deﬁne the activation threshold to be the value a such that σ ( a ) = 1 − δ , where δ is a small number.
Revised: We define the activation threshold to be the value a such that σ ( a ) = 1 − δ , where δ is a small number.

Original: For this paper, ﬁxing a = 5 is sufﬁcient.
Revised: For this paper, fixing a = 5 is sufficient.

Original: The shape of sigmoid function is convenient enough to be symmetrical in the sense that σ ( − a )
Revised: The shape of sigmoid function is convenient enough to be symmetrical in the sense that σ ( − a )

Original: =
Revised: =

Original: δ since 1 / (1 + e − a ) = 1 − δ can be rearranged to 1 / (1 + e − ( − a ) )
Revised: δ since 1 / (1 + e − a ) = 1 − δ can be rearranged to 1 / (1 + e − ( − a ) )

Original: =
Revised: =

Original: δ , useful for the proof later.
Revised: δ , useful for the proof later.

Revised: A.4. TNN THEOREM PROOF

Original: Theorem 1 .
Revised: Theorem 1 .

Original: TNN achieves arbitrarily high accuracy on the training dataset.
Revised: TNN achieves arbitrarily high accuracy on the training dataset.

Original: Proof: We need equations (1) and (2).
Revised: Proof: We need equations (1) and (2).

Original: In practical situation, where a is ﬁnite, we therefore have σ ( k ) j ≥ 1 − δ for j ≤ N − ( k − 1) and σ ( k ) j ≤ δ for j > N − ( k − 1) and δ > 0 .
Revised: In practical situation, where a is finite, we therefore have σ ( k ) j ≥ 1 − δ for j ≤ N − ( k − 1) and σ ( k ) j ≤ δ for j > N − ( k − 1) and δ > 0 .

Original: Then, deﬁne sample error as e ( k ) =
Revised: Then, define sample error as e ( k ) =

Original: | y ( k ) − [ A − 1 y ] T σ ( k ) )
Revised: | y ( k ) − [ A − 1 y ] T σ ( k ) )

Original: | and average error per sample will be e = 1 N Σ Ni =1 e ( k ) .
Revised: | and average error per sample will be e = 1 N Σ Ni =1 e ( k ) .

Original: Then e ( k ) ≤ δ ( N + 1) U where U = max k | y
Revised: Then e ( k ) ≤ δ ( N + 1) U where U = max k | y

Original: ( k ) | is the upper bound for the absolute value of the function over all samples (see proof below).
Revised: ( k ) | is the upper bound for the absolute value of the function over all samples (see proof below).

Original: Hence, setting δ = (cid:15) U ( N +1) guarantees that e ≤ (cid:15) .
Revised: Hence, setting δ = ϵ U ( N +1) guarantees that e ≤ ϵ .

Original: Since δ can be monotonously decreased by increasing a , we have shown that arbitrarily small error (cid:15) can be achieved in this approximation; see ﬁg. 3(B1-3) for plotted examples.
Revised: Since δ can be monotonously decreased by increasing a , we have shown that arbitrarily small error ϵ can be achieved in this approximation; see fig. 2(B1-3) for plotted examples.

Original: Note that e ( k ) =
Revised: Note that e ( k ) =

Original: iff δ = 

Revised: iff δ =

Original: iff a = ∞ .
Revised: iff a = ∞ .

Original: Show that e ( k ) ≤ δ ( N + 1) U where U = max k | y ( k ) | .
Revised: Show that e ( k ) ≤ δ ( N + 1) U where U = max k | y ( k ) | .

Original: We abbreviate σ ( k ) as σ , ﬁxing k.e ( k ) = | y ( k ) − ( A − 1 y ) T σ ( k ) | = (cid:12)(cid:12)(cid:12) y ( k ) − (cid:16) y
Revised: We abbreviate σ ( k ) as σ , fixing k.

Original: [-( N ) σ 
 + ( y ( N − 1) − y ( N ) ) σ 2 + . . . + ( y ( k +1) − y ( k +2) )-]
Revised: [-( N ) σ 
 + ( y ( N − 1) − y ( N ) ) σ 2 + . . . + ( y ( k +1) − y ( k +2) )-][Equation]

Original: σ N − k + ( y ( k ) − y ( k +1) )σ N − k
Revised: which we can rearrange according to y ( j )

Original: +   σ j ≥ 1 − δ + ( y ( k − 1) − y ( k ) )

Original: σ N − k

Original: + + ( y ( k − 2)

Original: − y ( k − 1) ) σ N − k +3 + . . . + ( y (1) − y (2) ) σ N (cid:17)(cid:12)(cid:12)(cid:12)    σ j ≤ δ which we can rearrange according to y ( j ) instead to
Revised: instead to

Original: [Equation]
Revised: [Equation]

Original: Rewriting d i = σ i +1 − σ i , we now have
Revised: Rewriting d i = σ i +1 − σ i , we now have

Original: [Equation]
Revised: [Equation]

Original: As either σ i ≥ 1 − δ or σ i ≤ δ , we have | d i | ≤ δ for all applicable i , and using triangle inequality, 
Revised: As either σ i ≥ 1 − δ or σ i ≤ δ [Equation] we have | d i | ≤ δ for all applicable i , and using triangle inequality, e

Original: [Equation]
Revised: [Equation]

Original: and we are done.
Revised: and we are done.

Original: (cid:3)
Revised: □ A.4. TNN ERROR BOUND AND RESISTANCE TO CATASTROPHIC FORGETTING

Original: Proposition 1 .
Revised: Proposition 1 .

Original: Errors on monotonous interval .
Revised: Errors on monotonous interval .

Original: Given ﬁnite training, test datasets D, D (cid:48) , there exists A ⊆ D (cid:48) such that, using TNN constructed with D ∪ A , for all samples in test dataset ( x (cid:48) , y (cid:48) )
Revised: Given finite training, test datasets D, D ′ , there exists A ⊆ D ′ such that, using TNN constructed with D ∪ A , for all samples in test dataset ( x ′ , y ′ )

Original: ∈ D (cid:48) , sample-wise error e = | y (cid:48)
Revised: ∈ D ′ , sample-wise error e = | y ′

Original: − TNN ( x (cid:48) ) | has an upper bound max ( | y (cid:48) − y ( k +1) 
Revised: − TNN ( x ′ ) | has an upper bound max ( | y ′ − y ( k +1) | , | y ′

Original: | , | y (cid:48) − y ( k ) | ) for some k .
Revised: − y ( k ) | ) for some k .

Original: Proof: Trivial cases occur for example when (1) most samples in test datasets are novel or out of training dataset distribution.
Revised: Proof: Trivial cases occur for example when (1) most samples in test datasets are novel or out of training dataset distribution.

Original: The proposition will hold true trivially because then A = D (cid:48) i.e. all test data will be ﬁt into TNN.
Revised: The proposition will hold true trivially because then A = D ′ i.e. all test data will be fit into TNN.

Original: Most samples are already within the distribution, so sample-wise error e is already within bound.
Revised: Most samples are already within the distribution, so sample-wise error e is already within bound.

Original: Consider non-trivial case.
Revised: Consider non-trivial case.

Original: Since sigmoid function is monotonous, then for any x ∈ [ x k , x k +1 ] , we have TNN ( x ) ∈
Revised: Since sigmoid function is monotonous, then for any x ∈ [ x k , x k +1 ] , we have TNN ( x ) ∈

Original: [ y k , y k +1 ] .
Revised: [ y k , y k +1 ] .

Original: The error of a test sample is e = |y (cid:48)
Revised: The error of a test sample is e = |

Original:  − TNN ( x ) | .
Revised: y ′ − TNN ( x ) | .

Original: If x (cid:48) ∈ [ x k , x k +1 ] and y (cid:48) ∈ [ y k , y k +1 ] , the sample-wise error upper-bound result already holds.
Revised: If x ′ ∈ [ x k , x k +1 ] and y ′ ∈ [ y k , y k +1 ] , the sample-wise error upper-bound result already holds.

Original: We say that such sample is approximately within the training dataset distribution.
Revised: We say that such sample is approximately within the training dataset distribution.

Original: Note that if e turns out to be too large, i.e. the gradient within the interval is too large, we can always include the test data sample in the training dataset to make a more regular model.
Revised: Note that if e turns out to be too large, i.e. the gradient within the interval is too large, we can always include the test data sample in the training dataset to make a more regular model.

Revised: distribution, and thus it needs to be included also.

Original: Otherwise, if y (cid:48) / ∈ [ y k , y k +1 ] , then we say the sample is out of training distribution because monotonicity of sigmoid function prevents the model from possibly making the correct prediction.
Revised: Otherwise, if y ′ / ∈ [ y k , y k +1 ] , then we say the sample is out of training distribution because monotonicity of sigmoid function prevents the model from possibly making the correct prediction.

Original: Sample-wise error upper-bound no longer holds.
Revised: Sample-wise error upper-bound no longer holds.

Original: By including this sample to the training dataset and recomputing the weights, we recover the upper-bound for this sample.
Revised: By including this sample to the training dataset and recomputing the weights, we recover the upper-bound for this sample.

Original: Any such sample is then included as the family of subset A ⊆ D (cid:48) .
Revised: Any such sample is then included as the family of subset A ⊆ D ′ .

Original: For each test data sample, check whether y (cid:48) ∈ [ y k , y k
Revised: For each test data sample, check whether y ′ ∈ [ y k , y k

Original: +1 ] for some k and include them into A if it is out of training distribution.
Revised: +1 ] for some k and include them into A if it is out of training distribution.

Original: This is shown in ﬁg. 5(A).
Revised: This is shown in fig. 5(A).

Original: However, the remaining test dataset U = D (cid:48)
Revised: However, the remaining test dataset U = D ′ \

Original: \ A does not automatically fall nicely into “within training distribution” category.
Revised: A does not automatically fall nicely into “within training distribution” category.

Original: This is best illustrated in ﬁg. 5(B).
Revised: This is best illustrated in fig. 5(B).

Original: However, by repeatedly running the same procedure to U and expanding A , we will eventually terminate at a point where all ( x (cid:48) , y (cid:48) )
Revised: However, by repeatedly running the same procedure to U and expanding A , we will eventually terminate at a point where all ( x ′ , y ′ )

Original: ∈ U is within the expanded training distribution D ∪ A , or reaches the ﬁrst trivial case.
Revised: ∈ U is within the expanded training distribution D ∪ A , or reaches the first trivial case.

Original: (cid:3)
Revised: □

Original: As seen above, TNN is resistant to catastrophic forgetting for clear reasons: each data sample in D still corresponds to one exact neuron in TNN, even after adding A ⊆ D (cid:48) . 
Revised: As seen above, TNN is resistant to catastrophic forgetting for clear reasons: each data sample in D still corresponds to one exact neuron in TNN, even after adding A ⊆ D ′ . A.4. TNN MID POINT

Original: Proposition 2.
Revised: Proposition 2.

Original: Mid-point property .
Revised: Mid-point property .

Original: The mid-point x mid,k = 12 ( x ( k ) + x ( k +1) ) takes the value of α T σ ( Wx mid,k + b )
Revised: The mid-point x mid,k = 12 ( x ( k ) + x ( k +1) ) takes the value of α T σ ( Wx mid,k + b )

Original: = 12 ( y ( k 
Revised: = 12 ( y ( k )

Original: [Equation]

Original: + y ( k +
Revised: + y ( k +1) ) .

Original: [Equation] Proof: 
Revised: Proof: σ midj ≡ σ ( Wx mid,k + b ) j

Original: [Equation]
Revised: = σ ( 12 ( Wx ( k ) + b ) + 12 ( Wx ( k +1) + b )) j .

Original: Then σ midN − k +1{++
+} =
Revised: Then σ midN − k {++
+} =

Original: σ ( 12 a + 12 ( − a ))
Revised: σ ( 12 a + 12 ( − a ))

Original: =
Revised: =

Original: σ (0) = 0 .
Revised: σ (0) = 0 .

Original: For j ≤ N − k , σ midj =
Revised: For j ≤ N − k , σ midj =

Original: 1 , while for j ≥ N − k + 2 , σ midj = 0 .
Revised: 1 , while for j ≥ N − k + 2 , σ midj = 0 .

Original: The resulting output of the neural network looks like α T [ . . .
Revised: The resulting output of the neural network looks like α T [ . . .

Original: T , which is equal to 12 α T [ . . .
Revised: T , which is equal to 12 α T [ . . .

Original: T + 12 α T [ . . .
Revised: T + 12 α T [ . . .

Original: T = 12 ( y ( k )
Revised: T = 12 ( y ( k )

Original: + y ( k +1) ) (cid:3) .
Revised: + y ( k +1) ) □ .

Revised: A.4. TNN EXAMPLE

Original: TNN pencil-and-paper example .
Revised: TNN pencil-and-paper example .

Original: Use TNN to ﬁt the dataset ( x, y ) ∈ { (1 , 1) , (0 . 5 , 2) , (0 , 3) } .
Revised: Use TNN to fit the dataset ( x, y ) ∈ { (1 , 1) , (0 . 5 , 2) , (0 , 3) } .

Original: Then f ( x ) = 3 σ (20 x + 5) − σ (20 x − 5) − σ (20 x − 15) .
Revised: Then f ( x ) = 3 σ (20 x + 5) − σ (20 x − 5) − σ (20 x − 15) .

Original: Suppose a = 5 and we have a dataset { (1 , 1) , (0 . 5 , 2) , (0 , 3) } so that N = 3 and x (1) = 1 > x (2) = 0 .
Revised: Suppose a = 5 and we have a dataset { (1 , 1) , (0 . 5 , 2) , (0 , 3) } so that N = 3 and x (1) = 1 > x (2) = 0 .

Original: 5 > x (3) = 0 , which is evenly spaced thus we can use the simpliﬁed formula, for example, W k = 2 × 5 × (3 − 1)
Revised: 5 > x (3) = 0 , which is evenly spaced thus we can use the simplified formula, for example, W k = 2 × 5 × (3 − 1)

Original: = 20 for k = 1 , 2 , 3 and b 1 = 5(

Revised: = 20 for k = 1 , 2 , 3 and b 1 = 5(

Original: − 2 × 1) etc.
Revised: − 2 × 1) etc.

Original: Then W = [20 , 20 , 20] T , b
Revised: Then W = [20 , 20 , 20] T , b

Original: =
Revised: =

Original: [5 , − 5 , − 15] T and α =
Revised: [5 , − 5 , − 15] T and α =

Original: A − 1 y =
Revised: A − 1 y =

Original: (cid:32)    −1 − (cid:33) (cid:34) (cid:35) =
Revised: (cid:32)    −1 − (cid:33) (cid:34) (cid:35) =

Original: (cid:34)−−(cid:35)
Revised: (cid:34)−−(cid:35)

Original: f ( x ) =
Revised: f ( x ) =

Original: α T σ ( Wx + b ) =
Revised: α T σ ( Wx + b ) =

Original: [3 , − 1 , − 1] σ ([20 , 20 , 20] T x + [5 , − 5 , − 15] T ) where σ is applied component-wise, thus f ( x ) = 3 σ (20 x + 5) − σ (20 x − 5) − σ (20 x − 15) . 
Revised: [3 , − 1 , − 1] σ ([20 , 20 , 20] T x + [5 , − 5 , − 15] T ) where σ is applied component-wise, thus f ( x ) = 3 σ (20 x + 5) − σ (20 x − 5) − σ (20 x − 15) . A.4. M ORE REMARKS

Original: Scalability and complexity . 
Revised: Smoothness . From the construction, assuming sigmoid function as the activation function, it is obvious that the function is continuous for finite a . As a increases, the function becomes more and more constant around each data sample as shown in fig. 2(A1-3), i.e. becoming more step-wise.

Revised: Special case .

Revised: When the dataset is evenly spaced, x ( k ) = 1 − ( k − 1)∆ , k = 1 , ..., N, ∆ = 1 / ( N − 1) , the results simplify to W k = 2 a ( N − 1) and b k = a (3 − 2 k ) .

Revised: Not only equation (2) is fulfilled, we also get ( Wx ( k ) + b ) j = a (1 + 2[ N − k + 1 − j ]) .

Revised: For the kth data sample, the activation will then be well-spaced in an interval of 2 a , so that σ ( k ) =

Revised: σ ([ . . .

Revised: , − 3 a, − a, a, 3 a, . . . ])

Revised: T ≈ [ . . .

Revised: T .

Revised: Scalability and complexity .

Original: The bulk of memory space usage comes from W ∈ R N × n .
Revised: The bulk of memory space usage comes from W ∈ R N × n .

Original: N is the number of available data points, and this is an unusual feature compared to modern DNN architecture.
Revised: N is the number of available data points, and this is an unusual feature compared to modern DNN architecture.

Original: Since N in common datasets can grow very large, the space complexity becomes Ω( Nn + mn ) , still linear w.r.t N .
Revised: Since N in common datasets can grow very large, the space complexity becomes Ω( Nn + mn ) , still linear w.r.t N .

Original: Since it is more likely that m < N , it is reasonable to simplify to just Ω( Nn ) .
Revised: Since it is more likely that m < N , it is reasonable to simplify to just Ω( Nn ) .

Original: To reduce the complexity, we can pick a set of representative data points
Revised: To reduce the complexity, we can pick a set of representative data points

Original: X rep = { x rep } for NN construction.
Revised: X rep = { x rep } for NN construction.

Original: The selection of representatives depends on our error tolerance, and it can be done through other machine learning methods, such as clustering.
Revised: The selection of representatives depends on our error tolerance, and it can be done through other machine learning methods, such as clustering.

Original: Other data points can then be used for validation.
Revised: Other data points can then be used for validation.

Original: The resulting complexity Ω( N rep n ) will thus highly depend on the variability and the structure of the dataset where N rep = | X rep | .
Revised: The resulting complexity Ω( N rep n ) will thus highly depend on the variability and the structure of the dataset where N rep = | X rep | .

Original: Time complexity is almost irrelevant for now, since we are not able to ﬁnd any meaningful way to compare with the training process of modern DNN.
Revised: Time complexity is almost irrelevant for now, since we are not able to find any meaningful way to compare with the training process of modern DNN.

Original: As far as we know, there is no decisive rule on how many epochs are necessary for a DNN training through back-propagation.
Revised: As far as we know, there is no decisive rule on how many epochs are necessary for a DNN training through back-propagation.

Original: Possible Generalizations to n-dimensional input data .
Revised: Generalizability to n-dimensional output .

Original: As mentioned in the main text, our attempts at generalizing TNN directly to high-dimensional input data are unsatisfactory.

Original: Readers can skip this without losing any information required for understanding this paper .

Original: For the record, we still list these attempts here. Now, we consider multi-dimensional input x ∈ R n , n > 1 with one dimensional outputy for TNN. If the well-known space-ﬁlling curve can be constructed for the input data, generalization is immediately done. Otherwise, variable separability might help with modelling a system partially using TNN.
Revised: Generalization to scalar input and multi-dimensional output is relatively simple.

Original: For example, given an ideal two-variable model F ( x, y ) = f ( x ) g ( y) .
Revised: From equation (3), we can treat α as the coefficients for the only component of one-dimensional y .

Original: Suppose it ﬁts the experimental data poorly.

Original: Assuming that f is correct, correction can be applied to g by replacing it with g ( y ) + NN ( y ) to account for the errors.

Original: Computing TNN ( y ) =

Original: F ( x,y ) f

Original: ( x ) − g ( y ) yields the y values to be used for weight computations in our triangular construction.

Original: Clearly, error correction can be performed on f similarly, though we now have to determine how to allocate values to each factor.

Original: One way to order multi-dimensional data samples will be ordering by the magnitude of the vector x =

Original: [ x 1 , ..., x N ] T → [ r, x 2 , ..., x N ] T where r = (cid:112) Σ

Original: i x 2 i .

Original: The sign of x 1 can be generally dealt with once we include discrete variables (such as binary variables) in the vector, where weights could be toggled to different values according to the discrete variables.

Original: More generally, weights that vary with a continuous variable may be a powerful modiﬁcation to the current method of construction which uses constant weights.

Original: This will lead to the loss of linear ordering, in the sense of “larger” vs “smaller” in the inequality of real number, leaving us with more relaxed conditions, possibly partial order.

Original: However, they will not be within the scope of this paper.

Original: For now, assume we have already deﬁned a linearly ordering for the dataset, we can now generalize the construction.

Original: Now W ∈ R N × n , where N, n are still respectively the number of data samples and dimensions.

Original: [-Similar to the earlier sub-section computing weights , ( Wx ( k +1) + b ) N − k +
-]
Revised: [-Similar to the earlier sub-section computing weights , ( Wx ( k +1) + b ) N − k +
-]

Original: = − a

Original: and ( Wx ( k ) + b ) N − k

Original: [-+
-]
Revised: [-+
-]

Original: [-= a . By subtracting them, we now get [ W ( x ( k ) − x ( k +1) )] N − k +
 = 2 a-] .
Revised: [-= a . By subtracting them, we now get [ W ( x ( k ) − x ( k +1) )] N − k +
 = 2 a-]Generalizing to y ∈ R m , m > 1 , identify each vector α i with the component y i .

Original: Spelling it out and rewriting component-wise difference as ∆ ( k ) i

Original: = x ( k ) − x ( k +1) , we have

Original: [Equation]

Original: [Equation]

Original: Since ∆ ( k ) i can be zero, we only need to carefully choose W N − k +1 ,i to satisfy equation (6).

Original: This is simply done by setting [Equation] otherwise [Equation]
Revised: Stacking them up, we can redefine α =

Original: where N 1 is the number of non-zero ∆ ( k ) i over all i for the particular k .

Original: [-Finally, b N − k +
-]
Revised: [-Finally, b N − k +
-]

Original: = a − W N − k +1 x ( k ) and likewise α = A − 1 y in the same manner. Proposition 3 .Given a standard DNN for C classes classiﬁcation with a tr training accuracy, then there exists a linear ordering for TNN to achieve a tr accuracy.
Revised: [ α T 1 ; α T 2 ; . .

Original: Test accuracy a test of DNN can be achieved by TNN with high probability through squeezed linear ordering .

Original: Proof:

Original: In the stringent case, classiﬁcation is performed by taking c = argmax i y i where y = DNN ( x ) , x the image to be classiﬁed, and y ∈ R C the output from the last layer of the neural network DNN . Suppose C = 10 andc = 0 , 1 , . . . Partition the unit interval [0 , 1] such that the ten classes are evenly distributed, i.e. I c = [ cC , c +1 C ] .
Revised: . ] where a semi-colon denotes the next row, and the construction is done.

Original: For each class c , collect all the training data samples that are classiﬁed as c by the DNN, denote this set as P c .

Original: Then perform the following linear ordering: map p c to c

Original: +0 .

Original: 5 C where p c is the data point with the highest y c component at the last layer of DNN.

Original: Let R c = { r i ∈ P c \{ p c } : DNN c +1 ( r i ) ≥ DNN c − 1 ( r i ) } . Then, continue constructing the linear ordering p c < r 1 < r 2 < . . .so that r k < r k +1 whenever DNN c ( r k ) ≥ DNN c
Revised: Note that now α ∈ R m × N .

Original: ( r k +1 ) , i.e. going to the right of the interval, a data sample has the less probability of being classiﬁed as c and it is also more likely classiﬁed as c + 1 than c − 1 if c is excluded.

Original: Let L c be the remaining set of data samples classiﬁed as c , i.e. P c \ ( R c ∪ { p c } ) .

Original: Set · · · < l 2 < l 1 < p c so that l k +1 <

Original: l k whenever DNN c ( l k ) ≥ DNN c ( l k +1 ) .

Original: The linear ordering for training dataset is done and TNN will yield a tr . Squeezed linear ordering . We can map the ordered samples to the interval I c arbitrarily, so long as the order is preserved. However, placing each R c , L c nearer to p c increases TNN chances of achieving a test , i.e. we squeeze the linear ordering towards the centers p c for all c .
Revised: Further generalization to n-dimensional input has been unsatisfactory (see later section of appendix,

Original: This is because, ordering test data samples into the linear order made by training samples, we may get the situation where test sample has max y c (thus likely classiﬁed as c ), but lies beyond the extreme end of R c or L c .

Original: Conversely, such sample is beyond the extreme end of L c +1 or R c − 1 respectively. By squeezing, large spaces (the grey area ) are reserved between the extreme ends of two classes. Data samples could fall into these intervals, and we reduce the possibility of misclassifying edge cases, e.g. by letting users treat them separately when TNN indicates that these samples lie in the grey area . (cid:3)
Revised: B.1).

Original: Since TNN can achieve arbitrary accuracy on the training dataset, we will recover the same accuracy as the DNN from the newly ordered training data.

Original: We do not quantify the exact probability of attaining high a test because distribution of test dataset may not be exactly the same as the training dataset.

Original: With DNN as the encoder mapping the raw data into the unit interval is ironic since the hardwork is already spent on training the deep neural network. However, this shows that, in principle, there exist encodings thatcan achieve linear ordering for TNN to attain high accuracy classiﬁcations. Notes: when clashes occur, e.g. r k and r k +1 have the same DNN c components, for the purpose of this simple construction, simply randomly assign order between them. We only aim to prove the existence of linear ordering here.
Revised: Instead, SQANN has been developed with additional mechanism that TNN does not possess.

Original: A. A PPENDIX FOR SQANN
Revised: A. A PPENDIX FOR SQANN

Original: Regarding the pseudo code . Mapping names from pseudo code to python code: sample collection → layer k sample collection. push node → push node to layer. forward cons → forward to layer k for reconstruction.
Revised: Link back to main text section 3.

Original: ssig → STOP SIGNAL collision → COLLISION. remove index → remove index to layer node check signal, new nodes and update nodes are placeholders for simple check and update sequences in python code.
Revised: A.5. S ELECTIVE C LUSTERING

Original: Selective clustering has been loosely deﬁned in the main text for reasons that will be clear after this.
Revised: Selective clustering has been loosely defined in the main text for reasons that will be clear after this.

Original: Formally and more generally , selective clustering is deﬁned as the following.
Revised: Formally and more generally , selective clustering is defined as the following.

Original: Let A =
Revised: Let A =

Original: X
Revised: X

Original: × Y be a set, and ( x, y ) be a point.
Revised: × Y be a set, and ( x, y ) be a point.

Original: Deﬁne d ( A, x ) as the minimum distance between x and all points in
Revised: Define d ( A, x ) as the minimum distance between x and all points in

Original: X , x 1 = argmin x (cid:48) ∈ X | x − x (cid:48) | ; let ( x 1 , y 1 ) 
Revised: X , x 1 = argmin x ′ ∈ X | x − x ′ | ; let ( x 1 , y 1 ) ∈

Original: ∈ A .
Revised: A .

Original: Given error tolerances δ, (cid:15) > 0 .
Revised: Given error tolerances δ, ϵ > 0 .

Original: Let d ( X, x ) ≤ δ .
Revised: Let d ( X, x ) ≤ δ .

Original: If output values are similar (ﬁrst case), | y − y 1 | ≤ (cid:15) , then add ( x, y ) as a new member of A .
Revised: If output values are similar (first case), | y − y 1 | ≤ ϵ , then add ( x, y ) as a new member of A .

Original: Otherwise (second case), if output values are distinct , | y − y 1 | > (cid:15) , let ( x, y ) form its own cluster.
Revised: Otherwise (second case), if output values are distinct , | y − y 1 | > ϵ , let ( x, y ) form its own cluster.

Original: In short, a new cluster is created (at least nominally) if we have neighbours with distinct y values; they are neighbours, but we may be looking at points at different sides of classiﬁcation boundaries.
Revised: In short, a new cluster is created (at least nominally) if we have neighbours with distinct y values; they are neighbours, but we may be looking at points at different sides of classification boundaries.

Original: This can be easily generalized such that ( x, y ) is added to another set B where | y − y 2 | < (cid:15) for ( x 2 , y 2 ) ∈ B .
Revised: This can be easily generalized such that ( x, y ) is added to another set B where | y − y 2 | < ϵ for ( x 2 , y 2 ) ∈ B .

Original: As mentioned in the main text, this does have a role for interpolation during SQANN propagation.
Revised: As mentioned in the main text, this does have a role for interpolation during SQANN propagation.

Original: If y, y 1 are similar, then approximation is likely good.
Revised: If y, y 1 are similar, then approximation is likely good.

Original: Suppose x z is near both x and X .
Revised: Suppose x z is near both x and X .

Original: In the ﬁrst case (output values are similar), taking interpolation between strongly activated neurons within
Revised: In the first case (output values are similar), taking interpolation between strongly activated neurons within

Original: X (including x ) will yield approximately the same value as taking argmax (the most strongly activated neuron).
Revised: X (including x ) will yield approximately the same value as taking argmax (the most strongly activated neuron).

Original: This is the nice case.
Revised: This is the nice case.

Original: However, in the second case (output values are distinct), we can get unstable result.
Revised: However, in the second case (output values are distinct), we can get unstable result.

Original: This is because argmax might tilt between the two different values in, while interpolation could yield the “averaged” value which may not reside in either cluster.
Revised: This is because argmax might tilt between the two different values in, while interpolation could yield the “averaged” value which may not reside in either cluster.

Original: The concept selective clustering is thus introduced with the express purpose of talking about such situation.
Revised: The concept selective clustering is thus introduced with the express purpose of talking about such situation.

Original: During collision, if two samples strongly activate the neurons but have distinct values, we must be careful about using argmax or deciding to select our interpolation methods.
Revised: During collision, if two samples strongly activate the neurons but have distinct values, we must be careful about using argmax or deciding to select our interpolation methods.

Original: In this paper, only argmax is used; other variations will be left for further studies.
Revised: In this paper, only argmax is used; other variations will be left for further studies.

Original: For example, when x z causes activation of 0.99 on one neuron and 0.92 on another.
Revised: For example, when x z causes activation of 0.99 on one neuron and 0.92 on another.

Original: Both are strong activations, but with argmax-based selective clustering, x z is treated as a member of the ﬁrst neuron’s strong activation cluster, thus the y attached to the ﬁrst neuron will be used as the output.
Revised: Both are strong activations, but with argmaxbased selective clustering, x z is treated as a member of the first neuron’s strong activation cluster, thus the y attached to the first neuron will be used as the output.

Original: There might be no best universal choice of selective clustering, considering that the shape of local manifold may change depending on the dataset distribution.
Revised: There might be no best universal choice of selective clustering, considering that the shape of local manifold may change depending on the dataset distribution.

Original: Hence, we leave it for further studies.
Revised: Hence, we leave it for further studies.

Original: Computing output via SQANN propagation (prediction) .
Revised: [Figure]

Original: Fig.
Revised: Fig.

Original: 7 shows two cases occurring during SQANN propagation Case (A) shows a case when strong activation occurs at layer 2 node 3, i.e. [ v 2 ] 3 > τ act , near 1 or even exactly 1 (if x is the exact training sample used during construction).
Revised: 6 shows two cases occurring during SQANN propagation Case (A) shows a case when strong activation occurs at layer 2 node 3, i.e. [ v 2 ] 3 > τ act , near 1 or even exactly 1 (if x is the exact training sample used during construction).

Original: Then y
Revised: Then y

Original: =
Revised: =

Original: [ α 2 ] 3 .
Revised: [ α 2 ] 3 .

Original: In case (B), no nodes are strongly activated.
Revised: In case (B), no nodes are strongly activated.

Original: The α values of the two most strongly activated neurons are used for weighted average based on the strength of activations [ v 2 ] 

Revised: The α values of the two most strongly activated neurons are used for weighted average based on the strength of activations [ v 2 ]

Original: and [ v 3 ] 2 , i.e. interpolation is performed.
Revised: and [ v 3 ] 2 , i.e. interpolation is performed.

Original: Clearly, we can explore different variations, for example, taking 
Revised: Clearly, we can explore different variations, for example, taking three most strongly activated neurons etc. Link back to main text section 3. A.5. G OOD PRACTICE FOR SCALABILITY

Original: [Figure]
Revised: For both TNN and SQANN, if there are 1 million training data, there will be 1 million neurons. Do we need all 1 million data? Probably not, since it might be fair to assume that some data points in the training dataset may have similarities. This is where pre-processing can be done to ideally root out data that are redundant.

Revised: SQANN itself can be used to check how redundant they are; for example, a subset of the data can be collected and a smaller SQANN can be constructed for testing purposes.

Revised: We can check how the subset of ‘similar data’ activates each other’s neuron within this mini SQANN.

Revised: Link back to computing output via SQANN : go to lemma 1.

Revised: A.5. SQANN CONSTRUCTION CAN COMPLETE

Original: Proposition 4 .
Revised: Proposition 3 .

Original: SQANN construction completes with high probability p ≈ 1 .
Revised: SQANN construction completes with high probability p ≈ 1 .

Revised: We start with the sketch of proof: the precise proof will need a strong assumption on data distribution.

Original: Note: we exclude any dataset which is ill-deﬁned, i e. when there exists two identical x ( k ) =
Revised: Note: we exclude any dataset which is ill-defined, i.e. when there exists two identical x ( k ) =

Original: x ( k (cid:48) ) having different y ( k ) (cid:54)
Revised: x ( k ′ ) having different y ( k ) ̸

Original: = y ( k (cid:48) ) .
Revised: = y ( k ′ ) .

Original: This results in unresolvable collisions, and is not suitable for any function.
Revised: This results in unresolvable collisions, and is not suitable for any function.

Original: We start with the sketch of proof: the precise proof will need a strong assumption on data distribution.

Original: Let the activation space A be a high dimensional space of pattern activations illustrated in ﬁg.
Revised: Let the activation space A be a high dimensional space of pattern activations illustrated in fig.

Original: An element of a lk ∈ A is a collection of [ v l ] k , and distances between a lk , a l (cid:48) k (cid:48) can be, for example, Euclidean.
Revised: An element of a lk ∈ A is a collection of [ v l ] k , and distances between a lk , a l ′ k ′ can be, for example, Euclidean.

Original: In SQANN construction, however, you might have noticed that the “distance” is expressed by eq.
Revised: In SQANN construction, however, you might have noticed that the “distance” is expressed by eq.

Original: (5), i.e., only the between the activations at the relevant layer (during layer k check for admission, it will be layer k ; during collision, it will be the collision layer.
Revised: (5), i.e., only the between the activations at the relevant layer (during layer k check for admission, it will be layer k ; during collision, it will be the collision layer.

Original: Let red x be any activation a lk in A stored in SQANN currently being used to test a new sample in a check N k activation process during construction.
Revised: Let red x be any activation a lk in A stored in SQANN currently being used to test a new sample in a check N k activation process during construction.

Original: Let black open circles be pattern activations of other sample points already incorporated into SQANN layers.
Revised: Let black open circles be pattern activations of other sample points already incorporated into SQANN layers.

Original: Suppose we test a new training sample.
Revised: Suppose we test a new training sample.

Original: From the main SQANN construction, we have seen that 3 possibilities can occur.
Revised: From the main SQANN construction, we have seen that 3 possibilities can occur.

Original: (1) Admission of sample to layer N k , if the sample weakly activates the existing node without collision, like the green + mark in ﬁg.
Revised: (1) Admission of sample to layer N k , if the sample weakly activates the existing node without collision, like the green + mark in fig.

Original: 8(B) (2) collision if it activates an existing node very strongly, like the red + mark (3) ﬁltering into deeper layer if neither occurs, i.e. like blue + mark.
Revised: 8(B) (2) collision if it activates an existing node very strongly, like the red + mark (3) filtering into deeper layer if neither occurs, i.e. like blue + mark.

Original: The concern related to the completion of SQANN construction mainly stems from the collision problem.
Revised: The concern related to the completion of SQANN construction mainly stems from the collision problem.

Original: During collision, layers are torn down, and the red + mark is now added beside the red x mark; thus SQANN now can distinguish similar looking points that might be characterized differently ( selective clustering in action).
Revised: During collision, layers are torn down, and the red + mark is now added beside the red x mark; thus SQANN now can distinguish similar looking points that might be characterized differently ( selective clustering in action).

Original: The question is, will the black open circles be reconstructed back to the previously destroyed layers in the same manner as they were?
Revised: The question is, will the black open circles be reconstructed back to the previously destroyed layers in the same manner as they were?

Original: The answer is,
Revised: The answer is,

Original: they will
Revised: they will

Original: NOT be exactly the same as before since the new activations now need to consider a new node contributed by red + mark.
Revised: NOT be exactly the same as before since the new activations now need to consider a new node contributed by red + mark.

Original: Intuition behind σ dsa , double selective activation .
Revised: Intuition behind σ dsa , double selective activation .

Original: However, there is a high probability that they will come back in the same order.
Revised: However, there is a high probability that they will come back in the same order.

Original: This is the exact reason why double selective activation has a narrow band of strong activation (small red area in ﬁg. 8) distinguished from a band of moderate activation by steep gradient, that is in turn distinguished from near zero activation by steep gradients.
Revised: This is the exact reason why double selective activation has a narrow band of strong activation (small red area in fig. 8) distinguished from a band of moderate activation by steep gradient, that is in turn distinguished from near zero activation by steep gradients.

Original: With such characteristic, A will have a small red region of strong activation, a large orange buffer region of moderate activation and weak activation everywhere else.
Revised: With such characteristic, A will have a small red region of strong activation, a large orange buffer region of moderate activation and weak activation everywhere else.

Original: The main idea revolves around the fact that the buffer region reduces the probability that existing black open circles are too close to red + mark.
Revised: The main idea revolves around the fact that the buffer region reduces the probability that existing black open circles are too close to red + mark.

Original: Hence, the activation characteristic of each black open circle that has been temporarily removed from the torn down layer (because of collision) will be similar to the activation characteristic it has before i.e. it will not suddenly strongly activate a node it previously did not activate.
Revised: Hence, the activation characteristic of each black open circle that has been temporarily removed from the torn down layer (because of collision) will be similar to the activation characteristic it has before i.e. it will not suddenly strongly activate a node it previously did not activate.

Original: For example, if sample u weakly activates all existing neurons with values 0.01 before, after red + mark is added into the layer, u still weakly activates all existing neurons with values 0.01, including red + mark which is close to red x mark.
Revised: For example, if sample u weakly activates all existing neurons with values 0.01 before, after red + mark is added into the layer, u still weakly activates all existing neurons with values 0.01, including red + mark which is close to red x mark.

Original: More precisely, if u gives rise to v before collision (let us denote its component by [ v i ] , i = 1 , . . .
Revised: More precisely, if u gives rise to v before collision (let us denote its component by [ v i ] , i = 1 , . . .

Original: , n l , then after resolving collision, the new activation at the same layer is v (cid:48) such that [ v (cid:48)
Revised: , n l , then after resolving collision, the new activation at the same layer is v ′ such that [ v ′ i ]

Original: i ] ≈ [ v i ] , i = 1 , . .
Revised: ≈ [ v i ] , i = 1 , . .

Original: . , n l , although now [ v (cid:48) i ] has the ( n l + 1) -th component since the collided sample has been added into the layer.
Revised: . , n l , although now [ v ′ i ] has the ( n l + 1) -th component since the collided sample has been added into the layer.

Original: Probability of complication .
Revised: Probability of complication .

Original: Moving on from the illustration, let any sample u ∈ U where U is the subset of dataset not yet used during SQANN construction.
Revised: Moving on from the illustration, let any sample u ∈ U where U is the subset of dataset not yet used during SQANN construction.

Original: If its activation v < τ act on all existing nodes (i.e. are not activating any existing nodes too strongly), then, if any new sample s 1 activates s strongly, then u does not activate s 1 strongly.
Revised: If its activation v < τ act on all existing nodes (i.e. are not activating any existing nodes too strongly), then, if any new sample s 1 activates s strongly, then u does not activate s 1 strongly.

Original: Intuitively, this is because s 1 is near s , which is far from u because there is a buffer region, thus there is a high probability that u is also far from s(note: by far , we mean distance in the activation space).
Revised: Intuitively, this is because s 1 is near s , which is far from u because there is a buffer region, thus there is a high probability that u is also far from s(note: by far , we mean distance in the activation space).

Original: It is only with high probability, because complication may occur, as the following.
Revised: It is only with high probability, because complication may occur, as the following.

Original: In real dataset, there may be a non-zero probability that there are black circles lying at the edges very close to the boundary of red x mark and red + mark happens to activates that region.
Revised: In real dataset, there may be a non-zero probability that there are black circles lying at the edges very close to the boundary of red x mark and red + mark happens to activates that region.

Original: Let the probability that a complication occurs for u ∈ U be p cu .
Revised: Let the probability that a complication occurs for u ∈ U be p cu .

Original: Assumption for formal proof .
Revised: Assumption for formal proof .

Original: Formal result can thus be stated for p ≈ 1 if we have an assumption on data distribution; recall from the statement of the proposition that p is the probability that construction is completed.
Revised: Formal result can thus be stated for p ≈ 1 if we have an assumption on data distribution; recall from the statement of the proposition that p is the probability that construction is completed.

Original: Suppose W, U are subsets of dataset that respectively have already and not already been used for SQANN construction .
Revised: Suppose W, U are subsets of dataset that respectively have already and not already been used for SQANN construction .

Original: Let A ( x ) be the set of points strongly activating x (in the illustration, this is the area covered by the small red circle).
Revised: Let A ( x ) be the set of points strongly activating x (in the illustration, this is the area covered by the small red circle).

Original: Also let d (illustrated in ﬁg.
Revised: Also let d (illustrated in fig.

Original: 8(B)) denote the minimum distance between u ∈ U and any points within A ( w ) for any w ∈ W .
Revised: 8(B)) denote the minimum distance between u ∈ U and any points within A ( w ) for any w ∈ W .

Original: The required assumption is: for a given τ act , τ ad and the current ordering of dataset, there exists d > 0 , such that for any u ∈ U , for any w ∈ W , if the minimum distance between A ( w ) and u is greater than d , then the probability of complication u ∈ A ( w 1 ) for any w 1 ∈ W is p cu ≈ 0 .
Revised: The required assumption is: for a given τ act , τ ad and the current ordering of dataset, there exists d > 0 , such that for any u ∈ U , for any w ∈ W , if the minimum distance between A ( w ) and u is greater than d , then the probability of complication u ∈ A ( w 1 ) for any w 1 ∈ W is p cu ≈ 0 .

Original: Assumption can be weak; deﬁning the strong assumption .
Revised: Assumption can be weak; defining the strong assumption .

Original: With this assumption, each sample at risk of behaving differently after the addition of red + mark contributes to 1 − p cu probability of reconstructing the same SQANN layer previously torn down.
Revised: With this assumption, each sample at risk of behaving differently after the addition of red + mark contributes to 1 − p cu probability of reconstructing the same SQANN layer previously torn down.

Original: But if there are many collisions and p = Π u ∈ U (1 − p cu ) =
Revised: But if there are many collisions and p = Π u ∈ U (1 − p cu ) =

Original: 1 − δ , then δ might blow up easily, especially if there are many data points close to each other.
Revised: 1 − δ , then δ might blow up easily, especially if there are many data points close to each other.

Original: In this case, what we really need to consider are (1) our selection of τ ad , τ act might be unsuitable, since they cause too many overlaps.
Revised: In this case, what we really need to consider are (1) our selection of τ ad , τ act might be unsuitable, since they cause too many overlaps.

Original: As a rule of thumb, decrease τ ad and increase τ act to enable constructions with less overlaps between samples’ activations (2) there are too many similar data in the samples that could have been represented equally well with a fraction of available data.
Revised: As a rule of thumb, decrease τ ad and increase τ act to enable constructions with less overlaps between samples’ activations (2) there are too many similar data in the samples that could have been represented equally well with a fraction of available data.

Original: In this case, it might be better to remove some data from the samples and create smaller subsets for SQANN layer construction, which is beneﬁcial, since the remaining data can be used for validations.
Revised: In this case, it might be better to remove some data from the samples and create smaller subsets for SQANN layer construction, which is beneficial, since the remaining data can be used for validations.

Original: With these two ﬁxes, the collision distances between two data points are relatively increased, and, there might exist d such that p cu = 0 .
Revised: With these two fixes, the collision distances between two data points are relatively increased, and, there might exist d such that p cu = 0 .

Original: The strongest assumption is thus when there exists d such that p cu = 0 for all unused training sample u at any time, i.e. assume no complication.
Revised: The strongest assumption is thus when there exists d such that p cu = 0 for all unused training sample u at any time, i.e. assume no complication.

Original: Proof for p = 1 with the strongest assumption: assume there is no complication at each sample checking step .
Revised: Proof for p = 1 with the strongest assumption: assume there is no complication at each sample checking step .

Original: Suppose layer 1 , . . .
Revised: Suppose layer 1 , . . .

Original: , k − 1 have been constructed, and j − 1 nodes have been added to the latest layer k that is being constructed.
Revised: , k − 1 have been constructed, and j − 1 nodes have been added to the latest layer k that is being constructed.

Original: Recall and note the difference between x ( k ) and x <k> .
Revised: Recall and note the difference between x ( k ) and x <k> .

Original: Suppose sample x ( j ) causes collision in layer c ≤ k − 1 .
Revised: Suppose sample x ( j ) causes collision in layer c ≤ k − 1 .

Original: Then we tear down all layers after layer c ; here is where we will use the order integrity : let X temp = { x <r> , x <r +1 > . . .
Revised: Then we tear down all layers after layer c ; here is where we will use the order integrity : let X temp = { x <r> , x <r +1 > . . .

Original: , x <j − 1 > } be the set of samples that have been returned to the list of unused indices in the same order they have been put into SQANN layer (likewise Y temp )
Revised: , x <j − 1 > } be the set of samples that have been returned to the list of unused indices in the same order they have been put into SQANN layer (likewise Y temp )

Original: e.g. ( x <r> , y <r> ) is the ﬁrst sample in layer c + 1 .
Revised: e.g. ( x <r> , y <r> ) is the first sample in layer c + 1 .

Original: Then, resolve the collision by concatenating ( x ( j ) , y ( j ) ) to ( N c , α c ) of layer c .
Revised: Then, resolve the collision by concatenating ( x ( j ) , y ( j ) ) to ( N c , α c ) of layer c .

Original: The reconstruction of subsequent layers will occur as the following.
Revised: The reconstruction of subsequent layers will occur as the following.

Original: Check x <r> for admission, add it into layer c
Revised: Check x <r> for admission, add it into layer c

Original: + 1 , then checking x <r +1 > the same way it was added through “layer k construction” process in the main text, and so on up to x <j − 1 > .
Revised: + 1 , then checking x <r +1 > the same way it was added through “layer k construction” process in the main text, and so on up to x <j − 1 > .

Original: They will be returned to their previous positions the same way they were added to the torn down layers.
Revised: They will be returned to their previous positions the same way they were added to the torn down layers.

Original: By the no-complication assumption, samples will not collide with ( x ( j ) , y ( j ) ) .
Revised: By the no-complication assumption, samples will not collide with ( x ( j ) , y ( j ) ) .

Original: More verbosely, samples admitted via “admission to N k ” will again be admitted to the same N k at the same node, while sample admitted through collision with some node η <j (cid:48) > k (cid:48) will collide with the same node, and there is no collision with the node of activation corresponding to ( x ( j ) , y ( j ) ) because of no complication assumption.
Revised: More verbosely, samples admitted via “admission to N k ” will again be admitted to the same N k at the same node, while sample admitted through collision with some node η <j ′ > k ′ will collide with the same node, and there is no collision with the node of activation corresponding to ( x ( j ) , y ( j ) ) because of no complication assumption.

Original: As a consequence, we can always proceed with x ( j +1) , even if there is a need for multiple reconstructions of layers.
Revised: As a consequence, we can always proceed with x ( j +1) , even if there is a need for multiple reconstructions of layers.

Original: Thus, the construction can complete.
Revised: Thus, the construction can complete.

Original: (cid:3)
Revised: □ A.5. SQANN M AIN T HEOREM

Original: Theorem 2 .
Revised: Theorem 2 .

Original: Assume SQANN construction is completed.
Revised: Assume SQANN construction is completed.

Original: SQANN achieves arbitrarily high accuracy on a training dataset.
Revised: SQANN achieves arbitrarily high accuracy on a training dataset.

Original: Furthermore, it is resistant to catastrophic forgetting.
Revised: Furthermore, it is resistant to catastrophic forgetting.

Original: Proof: Let the training dataset be D = X × Y .
Revised: Proof: Let the training dataset be D = X × Y .

Original: For any x ∈ X , perform SQANN propagation.
Revised: For any x ∈ X , perform SQANN propagation.

Original: If x ∈ N 1 , then, by lemma 1, we obtain the arbitrarily high accuracy.
Revised: If x ∈ N 1 , then, by lemma 1, we obtain the arbitrarily high accuracy.

Original: If x ∈ N k , k > 1 , the heavy-lifting is in fact already done through the SQANN construction algorithm.
Revised: If x ∈ N k , k > 1 , the heavy-lifting is in fact already done through the SQANN construction algorithm.

Original: By SQANN construction, there exist index j and layer k > 1 such that either (1) the activation of x undergoes admission to N k as η <j>k or (2) pushed into layer N k during collision.
Revised: By SQANN construction, there exist index j and layer k > 1 such that either (1) the activation of x undergoes admission to N k as η <j>k or (2) pushed into layer N k during collision.

Original: One of the two must occur, otherwise SQANN construction is not completed, contradicting the assumption.
Revised: One of the two must occur, otherwise SQANN construction is not completed, contradicting the assumption.

Original: In either process, we have v k − 1 =
Revised: In either process, we have v k − 1 =

Original: η <j>k thus [ v k ] j = σ dsa ( || v k − 1 − η <j>k || )
Revised: η <j> k thus [ v k ] j = σ dsa ( || v k − 1 − η <j> k || )

Original: =
Revised: =

Original: σ dsa (0) = 1 > τ act where recursive computation [ v l ] i =
Revised: σ dsa (0) = 1 > τ act where recursive computation [ v l ] i =

Original: σ dsa (cid:0) || v l − 1 − η <i>
Revised: σ dsa (cid:0) || v l − 1 − η <i>

Original: l || (cid:1) for all i
Revised: l || (cid:1) for all i

Original: = 1 , . .
Revised: = 1 , . .

Original: . , n l is performed from layer l = 1 , . . .
Revised: . , n l is performed from layer l = 1 , . . .

Original: , k with v 0 ≡ x .
Revised: , k with v 0 ≡ x .

Original: Since such strongly activated neuron exists at layer k , by SQANN propagation, retrieve y =
Revised: Since such strongly activated neuron exists at layer k , by SQANN propagation, retrieve y =

Original: α <j>k where j = argmax j (cid:48) [ v k ] j (cid:48) .
Revised: α <j>k where j = argmax j ′ [ v k ] j ′ .

Original: To ensure that j is unique, we reasonably assume that there is no duplicate x with different y values that is admitted through collision, otherwise the dataset is ill-deﬁned (as previously mentioned).
Revised: To ensure that j is unique, we reasonably assume that there is no duplicate x with different y values that is admitted through collision, otherwise the dataset is ill-defined (as previously mentioned).

Original: The uniqueness is made possible because double selective activation is by its deﬁnition one-to-one onto around the peak,  i.e. there is no interval of constant value around the peak.
Revised: The uniqueness is made possible because double selective activation is, by definition, has a peak with unique value 1 and in the locality of the peak, to each side, it is one-to-one and onto, i.e. there is no interval of constant value around the peak.

Original: Finally, j is indeed the index from argmax, because the peak value of double selective activation is 1 by design.
Revised: Finally, j is indeed the index from argmax, because the peak value of double selective activation is 1 by design.

Original: Resistance to catastrophic-forgetting .
Revised: Resistance to catastrophic-forgetting .

Original: For each new training sample added into SQANN, previous samples still exist as nodes stored in the SQANN layers.
Revised: For each new training sample added into SQANN, previous samples still exist as nodes stored in the SQANN layers.

Original: Previously learned samples will therefore not be forgotten.
Revised: Previously learned samples will therefore not be forgotten.

Original: More precisely, suppose SQANN construction is not yet complete.
Revised: More precisely, suppose SQANN construction is not yet complete.

Original: Let D k ⊂ D be the subset of dataset whose samples have either been admitted to layers 1 , 2 , . . .
Revised: Let D k ⊂ D be the subset of dataset whose samples have either been admitted to layers 1 , 2 , . . .

Original: , k through normal admission or by resolvingcollision collision.
Revised: , k through normal admission or by resolving collision.

Original: Then for p k = ( x ( k ) , y ( k ) )
Revised: Then for p k = ( x ( k ) , y ( k ) )

Original: ∈
Revised: ∈

Original: D k can be exactly queried by obtaining activation at some layer l ≤ k for some j so that v =
Revised: D k can be exactly queried by obtaining activation at some layer l ≤ k for some j so that v =

Original: σ dsa
Revised: σ dsa

Original: ( || v l − 1 − η <j>l || ) is exactly 1 and l, j exist exactly at the layer and node where p k is admitted into SQANN through the main mechanism of layer construction.
Revised: ( || v l − 1 − η <j>l || ) is exactly 1 and l, j exist exactly at the layer and node where p k is admitted into SQANN through the main mechanism of layer construction.

Original: By SQANN propagation, as before, we retrieve the output α <j>l = y k stored exactly at l, j node through the main SQANN construction algorithm as well, hence, SQANN remembers the previously stored value.
Revised: By SQANN propagation, as before, we retrieve the output α <j>l = y k stored exactly at l, j node through the main SQANN construction algorithm as well, hence, SQANN remembers the previously stored value.

Original: Furthermore, if SQANN construction with
Revised: Furthermore, if SQANN construction with

Original: D has been completed and new training dataset D (cid:48) is available, construction with all samples in
Revised: D has been completed and new training dataset D ′ is available, construction with all samples in

Original: D by drawing samples in the same order will result in the same SQANN.
Revised: D by drawing samples in the same order will result in the same SQANN.

Original: Any new samples from
Revised: Any new samples from

Original: D (cid:48) can be admitted into SQANN in the same way speciﬁed in layer k reconstruction after all D samples are used up.
Revised: D ′ can be admitted into SQANN in the same way specified in layer k reconstruction after all D samples are used up.

Original: In this manner, previously learned samples from D will remain inside SQANN layers, i.e. like before we can ﬁnd l, j node corresponding to each sample previously admitted into
Revised: In this manner, previously learned samples from D will remain inside SQANN layers, i.e. like before we can find l, j node corresponding to each sample previously admitted into

Original: SQANN.
Revised: SQANN.

Original: Hence no forgetting will occur.
Revised: Hence no forgetting will occur.

Original: (cid:3)
Revised: □ A.5. SQANN EXAMPLE

Original: SQANN pencil-and-paper example .
Revised: SQANN pencil-and-paper example .

Original: With a 1 , a 2 = 0 .
Revised: With a 1 , a 2 = 0 .

Original: 001 , 0 . 5 , τ ad , τ act = 0 . 1 , 0 . 9 , create
Revised: 001 , 0 . 5 , τ ad , τ act = 0 . 1 , 0 . 9 , create

Original: SQANN universal approximator for indexed data X =
Revised: SQANN universal approximator for indexed data X =

Original: [ x (1) , x (2) , x (3) , x (4) ]
Revised: [ x (1) , x (2) , x (3) , x (4) ]

Original: = (cid:2)1 1 . 2 − 1 − 1 . 8 − 1 − 1 . 2 (cid:3) and Y = [ y 1 , y 2 , y 3 , y 4 ] = ) Show layer 1 stores the of ( x (1) ,
Revised: = (cid:2)

Original: (3) ) and layer stores ( v

Original: Use SQANN propagation to verify that we indeed get zero

Original: Note that the following can be matched with the demonstration in jupyter notebook
Revised: Note that the following can be matched with the demonstration in jupyter notebook

Original: SQANN small example.ipynb.
Revised: SQANN small example.ipynb.

Original: (A) SQANN construction .
Revised: (A) SQANN construction .

Original: We start by putting x 1 , y 1 into the ﬁrst layer, so put it into the ﬁrst layer of SQANN, N 

Revised: We start by putting x 1 , y 1 into the first layer, so put it into the first layer of SQANN, N

Original: =
Revised: =

Original: ( x 1 ) , α 1 =
Revised: ( x 1 ) , α 1 =

Original: ( y 1 ) .
Revised: ( y 1 ) .

Original: Now check ( x (2) , y (2) ) for admission to N 1 : if it activates a node in N 1 , then we ﬁlter it to a deeper layer , otherwise, we add it into N 1 , α 1 as well.
Revised: Now check ( x (2) , y (2) ) for admission to N 1 : if it activates a node in N 1 , then we filter it to a deeper layer , otherwise, we add it into N 1 , α 1 as well.

Original: We show that the latter occurs.
Revised: We show that the latter occurs.

Original: We only have one node in SQANN now, so the only possible activation is 
Revised: We only have one node in SQANN now, so the only possible activation is [ v (2)1 ] 1 =

Original: [ v (2)1 ] 1 = σ dsa ( || x (2) − x (1) || )
Revised: σ dsa ( || x (2) − x (1) || )

Original: = 0 .
Revised: = 0 .

Original: 3344 ≥ τ ad .
Revised: 3344 ≥ τ ad .

Original: Admission to N 1 only occurs if [ v (2)1 ] 1 < τ ad hence it is ﬁltered to a deeper layer.
Revised: Admission to N 1 only occurs if [ v (2)1 ] 1 < τ ad hence it is filtered to a deeper layer.

Original: Now we check ( x (3) , y (3) ) for admission to N 1 and get [ v (3)1 ] 1 = 5 .
Revised: Now we check ( x (3) , y (3) ) for admission to N 1 and get [ v (3)1 ] 1 = 5 .

Original: 655 × 10 − 5 .
Revised: 655 × 10 − 5 .

Original: It does not activate any node in the layer, thus this is a distinct sample we will admit into N 1 .
Revised: It does not activate any node in the layer, thus this is a distinct sample we will admit into N 1 .

Original: Now we check ( x (4) , y (4) ) for admission to N 1 .
Revised: Now we check ( x (4) , y (4) ) for admission to N 1 .

Original: We have two nodes, so we have to compute both: [ v (4)1 ] 1 =
Revised: We have two nodes, so we have to compute both: [ v (4)1 ] 1 =

Original: σ dsa ( || x (4) − η < 1 >|| )
Revised: σ dsa ( || x (4) − η < 1 >|| )

Original: = 4 .
Revised: = 4 .

Original: 450 × 10 − 6 and [ v (4)1 ] 2 =
Revised: 450 × 10 − 6 and [ v (4)1 ] 2 =

Original: σ dsa ( || x (4) − η < 2 >|| )
Revised: σ dsa ( || x (4) − η < 2 >|| )

Original: = 0 .
Revised: = 0 .

Original: 5676 > τ ad .
Revised: 5676 > τ ad .

Original: It does activate a node in N 1 , which is η < 2 >.
Revised: It does activate a node in N 1 , which is η < 2 >.

Original: Hence it is ﬁltered to a deeper layer.
Revised: Hence it is filtered to a deeper layer.

Original: We have shown that N 1 stores ( η < 1 >= x (1) , η < 2 >= x (3) ) , and not the other samples.
Revised: We have shown that N 1 stores ( η < 1 >= x (1) , η < 2 >= x (3) ) , and not the other samples.

Original: Note: since the activation < τ act , no node has been activated strongly (otherwise we will have collision).
Revised: Note: since the activation < τ act , no node has been activated strongly (otherwise we will have collision).

Original: Recall that each time we store x ( k ) into N l , we also store y ( k ) into α l , so now α 1 =
Revised: Recall that each time we store x ( k ) into N l , we also store y ( k ) into α l , so now α 1 =

Original: ( y (1) , y (3) ) .
Revised: ( y (1) , y (3) ) .

Original: We have gone through the training dataset once.
Revised: We have gone through the training dataset once.

Original: The unused data are { ( x ( k ) , y ( k ) ) , k = 2 , 4 } , as they have been ﬁltered to deeper layer.
Revised: The unused data are { ( x ( k ) , y ( k ) ) , k = 2 , 4 } , as they have been filtered to deeper layer.

Original: We now proceed with layer 2 construction.
Revised: We now proceed with layer 2 construction.

Original: Since it is empty, we put the activation of x (2) (not the sample itself) into N 1 since no collision occurs, i.e. η < 1 >= v (2) = (cid:2) [ v (2)2 ] 1 , [ v (2)2 ] 2 (cid:3) .
Revised: Since it is empty, we put the activation of x (2) (not the sample itself) into N 1 since no collision occurs, i.e. η < 1 >= v (2) = (cid:2) [ v (2)2 ] 1 , [ v (2)2 ] 2 (cid:3) .

Original: To show no collision, i.e. no strong activations in N 1 , similar to before, we compute [ v (2)1 ] 1 < τ act , which is previously done, and [ v (2)1 ] 2 = 6 .
Revised: To show no collision, i.e. no strong activations in N 1 , similar to before, we compute [ v (2)1 ] 1 < τ act , which is previously done, and [ v (2)1 ] 2 = 6 .

Original: × 10 − 5 < τ act .
Revised: × 10 − 5 < τ act .

Original: The last sample x (4) is admitted into N 2 by checking collisions against all N 1 (previously done), and then checking activation against existing N 2 node, η < 1 >, i.e v(4)= σ dsa ( || v (4)2 − η < 1 >|| )
Revised: The last sample x (4) is admitted into N 2 by checking collisions against all N 1 (previously done), and then checking activation against existing N 2 node, η < 1 >, i.e v (4)

Original: =0 .
Revised: =

Original: 00732 < {+1 >|| ) = 0 . 
+}
Revised: σ dsa ( || v (4)2 − η < {+1 >|| ) = 0 . 
+}

Original:  τ ad .
Revised: < τ ad .

Original: Hence, it is admitted to N 2 .
Revised: Hence, it is admitted to N 2 .

Original: We have used up all data points, hence we have shown
Revised: We have used up all data points, hence we have shown

Original: N 2 = ( v (2)2 , v (4)2 ) .
Revised: N 2 = ( v (2) 2 , v (4) 2 ) .

Original: (B) Using SQANN propagation on x ( k ) , k = 1 , 3 , we get σ dsa ( || v ( k) 1 − η <j>|| )
Revised: (B) Using SQANN propagation on x ( k ) , k = 1 , 3 , we get σ dsa ( || v ( k 1 − η < j> || )

Original: =
Revised: =

Revised: σ

Original: σ dsa(0) = 1 > τ act where j = 1 , 2 respectively.
Revised: dsa = 1 > τ act where j = 1 , 2 respectively.

Original: Since they are strongly activated, we get y =
Revised: Since they are strongly activated , we get y =

Original: α <j>= y (1) , y (3) for j = 1 , 2 respectively.
Revised: α <j> = y (1) , y (3) for j = 1 , 2 respectively.

Original: Thus the errors are zero.
Revised: Thus the errors are zero.

Original: [Table] For x (2) , we already previously computed v (2) = (cid:2) [ v (2)2 ] 1 , [ v (2)2 ] 2 (cid:3) , which becomes η < 1 >thus we will also get the distance of activation value from itself as stored in N 2 , σ dsa ( || v (2)2 − η < 1 >|| )
Revised: For x (2) , we already previously computed v (2) = (cid:2) [ v (2)2 ] 1 , [ v (2)2 ] 2 (cid:3) , which becomes η < 1 >thus we will also get the distance of activation value from itself as stored in N 2 , σ dsa ( || v (2)2 − η < 1 >|| )

Original: =
Revised: =

Original: σ dsa (0) = 1 .
Revised: σ dsa (0) = 1 .

Original: Likewise x (4) .
Revised: Likewise x (4) .

Original: (C) SQANN testing .
Revised: (C) SQANN testing .

Original: For x (1) t , we expect its ﬁngerprint to be close to x (1) or the activation of x (2) since their values are similar.
Revised: For x (1) t , we expect its fingerprint to be close to x (1) or the activation of x (2) since their values are similar.

Original: It turns out we get the following activations in layer 1, v (1) t, 1 = [0 .
Revised: It turns out we get the following activations in layer 1, v (1) t, 1 = [0 .

Original: 5053 , 4 . 938 × 10 − 5 ] , not strongly activating layer 1 nodes.
Revised: 5053 , 4 . 938 × 10 − 5 ] , not strongly activating layer 1 nodes.

Original: For layer 2, we have [ v (1) t, 2 ] 1 = σ dsa
Revised: For layer 2, we have [ v (1) t, 2 ] 1 = σ dsa

Original: ( || v t, 1 − v (2)2 || )
Revised: ( || v t, 1 − v (2)2 || )

Original: = 0 .
Revised: = 0 .

Original: 5165 and [ v (1) t, 2 ] 2 = 0 .
Revised: 5165 and [ v (1) t, 2 ] 2 = 0 .

Original: There is no strong activation anywhere, and this is the case when interpolation is needed.
Revised: There is no strong activation anywhere, and this is the case when interpolation is needed.

Original: Notice that of all the activations we computed, the strongest are [ v (1) t, 1 ] 1 and [ v (1) t, 2 ] 1 , which are the ﬁrst nodes in both layer, due to x (1) and x (2) respectively as we have expected.
Revised: Notice that of all the activations we computed, the strongest are [ v (1) t, 1 ] 1 and [ v (1) t, 2 ] 1 , which are the first nodes in both layer, due to x (1) and x (2) respectively as we have expected.

Original: Using SQANN propagation, we fetch its α values, both of which are 1 . , thus using linear interpolation, y = 0 .
Revised: Using SQANN propagation, we fetch its α values, both of which are 1 . , thus using linear interpolation, y = 0 .

Original: 5053 ∗ 1+0 .
Revised: 5053 ∗ 1+0 .

Original: 5165 ∗ 1 0 .
Revised: 5165 ∗ 1 0 .

Original: 5053+0 .= 1 .
Revised: 5053+0 .= 1 .

Original: The next sample in the test dataset x (2) t does activate the SQANN.
Revised: The next sample in the test dataset x (2) t does activate the SQANN.

Original: We expect it to activate either x (3) or the activation of x (4) .
Revised: We expect it to activate either x (3) or the activation of x (4) .

Original: First, get v (2) t, 1 = [5 . 

Revised: First, get v (2) t, 1 = [5 .

Original: × 10 − 5 , 0 . 5059] , i.e. no strong activation, so x (3) is not strongly activated.
Revised: × 10 − 5 , 0 . 5059] , i.e. no strong activation, so x (3) is not strongly activated.

Original: But we get σ dsa ( || v (2) t, 1 − η < 2 >|| )
Revised: But we get σ dsa ( || v (2) t, 1 − η < 2 >|| )

Original: = 0 .
Revised: = 0 .

Original: 9880 > τ act , thus we do get strong activation due to the ﬁngerprint of x (4) .
Revised: 9880 > τ act , thus we do get strong activation due to the fingerprint of x (4) .

Original: By SQANN propagation, we get y =
Revised: By SQANN propagation, we get y =

Original: α < 2 >=
Revised: α < 2 >=

Original: y (4) = 0 .
Revised: y (4) = 0 .

Original: The last test sample needs interpolation too, and we leave it for the reader.
Revised: The last test sample needs interpolation too, and we leave it for the reader.

Original: The plot of results are shown in ﬁg. 9.
Revised: The plot of results are shown in fig.

Revised: A.5. E XPERIMENTAL D ATA

Revised: For all experimental data, we perform no pre-processing beyond simple normalization.

Revised: We test all the data in nearly their raw forms.

Original: Experimental data in ﬁg. 4(A).
Revised: Experimental data in fig. 4(A).

Original: [Top row] Training Training samples X are x ∈ R 2 with components drawn from uniform r.v.
Revised: [Top row] Training Training samples X are x ∈ R 2 with components drawn from uniform r.v.

Original: (random variable) x 1 = x 2 = t ∼ U ( − 1 ., 1 . ) plus Gaussian noise.
Revised: (random variable) x 1 = x 2 = t ∼ U ( − 1 ., 1 . ) plus Gaussian noise.

Original: Test samples are X plus r.v.
Revised: Test samples are X plus r.v.

Original: from U ( − s, s ) where s is the test data spread.
Revised: from U ( − s, s ) where s is the test data spread.

Original: Also, y =
Revised: Also, y =

Original: ||
Revised: ||

Original: x || is indicated by the color.
Revised: x || is indicated by the color.

Original: [Bottom row] similar to top row, but x ∈ X with x = R [ cos ( t ) , sin ( t )] T where t ∼ U (0 , ≈ 2 π ) , R ∼ U (0 . 8 ,1 . 2) and y = cos ( t ) .
Revised: [Bottom row] similar to top row, but x ∈ X with x = R [ cos ( t ) , sin ( t )] T where t ∼ U (0 , ≈ 2 π ) , R ∼ U (0 . 8 ,

Original: For both experiments in the top and bottom rows , 128 training data samples are used for SQANN construction and tested on 128 test data samples.

Original: SQANN is tested for regression on Boston Housing and Diabetes Datasets to demonstrate its generalizability to unseen (test) samples.
Revised: SQANN is tested for regression on Boston Housing and Diabetes Datasets to demonstrate its generalizability to unseen (test) samples.

Original: The procedure is as the following.
Revised: The procedure is as the following.

Original: Let Boston Dataset be
Revised: Let Boston Dataset be

Original: D = { ( x ( k ) , y ( k ) ) , k = 1 , . .
Revised: D = { ( x ( k ) , y ( k ) ) , k = 1 , . .

Original: (1) A small set of samples D = { ( x ( k ) , y ( k ) ) , k = 1 , ..., 100 } is used to train SQANN and 9 other regression methods; recall that ordered sequence of data  is used for SQANN construction.
Revised: (1) A small set of samples D = { ( x ( k ) , y ( k ) ) , k = 1 , ..., 100 } is used to train SQANN and 9 other regression methods; recall that ordered sequence of data [Table] is used for SQANN construction.

Original: (2) Mean Squared Errors (MSE) values are measured on unused data D test =
Revised: (2) Mean Squared Errors (MSE) values are measured on unused data D test =

Original: D\ D on all 10 models listed in table 1.
Revised: D\ D on all 10 models listed in table 1.

Original: We expect large errors on some test samples, since the training dataset might be too small to be representative.
Revised: We expect large errors on some test samples, since the training dataset might be too small to be representative.

Original: (3) SQANN’s activations are used to collect samples with large absolute errors e τ ( x ) =
Revised: (3) SQANN’s activations are used to collect samples with large absolute errors e τ ( x ) =

Original: | SQANN ( x ) − y 

Revised: | SQANN ( x ) − y

Original: | >
Revised: | >

Original: τ
Revised: τ

Original: and we treat them as out-of-distribution (OOD) samples.
Revised: and we treat them as out-of-distribution (OOD) samples.

Original: These samples are considered as new distinct samples to be integrated into D as the new training dataset D (cid:48) .
Revised: These samples are considered as new distinct samples to be integrated into D as the new training dataset D ′ .

Original: (4) Train the 10 models, now with D (cid:48) .
Revised: (4) Train the 10 models, now with D ′ .

Original: Then MSE is measured again on D test (yes, there will be partial overﬁtting).
Revised: Then MSE is measured again on D test (yes, there will be partial overfitting).

Original: Repeat the process for diabetes dataset, where |D| = 442 ; we also start with | D | = 100 .
Revised: Repeat the process for diabetes dataset, where |D| = 442 ; we also start with | D | = 100 .

Original: Results for Boston Housing dataset has been described in the main text.
Revised: Results for Boston Housing dataset has been described in the main text.

Original: For Diabetes Dataset, τ = 40 yields relatively competitive performance.
Revised: For Diabetes Dataset, τ = 40 yields relatively competitive performance.

Original: using SQANN we integrated 218 samples, so | D (cid:48) | = 318 so 0 .
Revised: using SQANN we integrated 218 samples, so | D ′ | = 318 so 0 .

Original: 719 of the whole D is used for new training.
Revised: 719 of the whole D is used for new training.

Original: From the results of linear models, the dataset appears to have a somewhat strong linear structure; but nonlinear models still can perform better. 
Revised: From the results of linear models, the dataset appears to have a somewhat strong linear structure; but nonlinear models still can perform better. B M ORE C OMMENTS

Revised: This section consists of contents that we have considered less important, thanks to comments by reviewers in ICLR 2022.

Revised: B. O N D IRECT GENERALIZATION OF TNN

Revised: As mentioned in appendix section A.4.5, our attempts at generalizing TNN directly to highdimensional input data are unsatisfactory.

Revised: Readers can skip this without losing any information required for understanding this paper .

Revised: For the record, we still list these attempts here.

Revised: Now, we consider multi-dimensional input x ∈ R n , n > 1 with one dimensional output y for TNN.

Revised: If the well-known space-filling curve can be constructed for the input data, generalization is immediately done.

Revised: Otherwise, variable separability might help with modelling a system partially using TNN.

Revised: For example, given an ideal two-variable model F ( x, y ) =

Revised: f ( x ) g ( y ) .

Revised: Suppose it fits the experimental data poorly.

Revised: Assuming that f is correct, correction can be applied to g by replacing it with g ( y ) + NN ( y ) to account for the errors.

Revised: Computing TNN ( y ) =

Revised: F ( x,y ) f

Revised: ( x ) − g ( y ) yields the y values to be used for weight computations in our triangular construction.

Revised: Clearly, error correction can be performed on f similarly, though we now have to determine how to allocate values to each factor.

Revised: One way to order multi-dimensional data samples will be ordering by the magnitude of the vector x =

Revised: [ x 1 , ..., x N ] T → [ r, x 2 , ..., x N ] T where r = (cid:112) Σ

Revised: i x 2 i .

Revised: The sign of x 1 can be generally dealt with once we include discrete variables (such as binary variables) in the vector, where weights could be toggled to different values according to the discrete variables.

Revised: More generally, weights that vary with a continuous variable may be a powerful modification to the current method of construction which uses constant weights.

Revised: This will lead to the loss of linear ordering, in the sense of “larger” vs “smaller” in the inequality of real number, leaving us with more relaxed conditions, possibly partial order.

Revised: However, they will not be within the scope of this paper.

Revised: For now, assume we have already defined a linearly ordering for the dataset, we can now generalize the construction.

Revised: Now W ∈ R N × n , where N, n are still respectively the number of data samples and dimensions.

Original: {+Similar to the earlier sub-section computing weights , ( Wx ( k +1) + b ) N − k +
+}
Revised: {+Similar to the earlier sub-section computing weights , ( Wx ( k +1) + b ) N − k +
+}

Revised: = − a

Revised: and ( Wx ( k ) + b ) N − k

Original: {++
+}
Revised: {++
+}

Revised: = a .

Revised: By subtracting them, we now get [ W ( x ( k ) − x ( k +1) )]

Original: {+N − k +
+}
Revised: {+N − k +
+}

Revised: = 2 a .

Revised: Spelling it out and rewriting component-wise difference as ∆ ( k )

Revised: i

Revised: [Equation]

Revised: , we have

Revised: [Equation]

Revised: Since ∆ ( k ) i can be zero, we only need to carefully choose W N − k +1 ,i to satisfy equation (6).

Revised: This is simply done by setting

Revised: [Equation]

Revised: where N 1 is the number of non-zero ∆ ( k ) i over all i for the particular k .

Original: {+Finally, b N − k +
+}
Revised: {+Finally, b N − k +
+}

Revised: = a − W N − k +1 x ( k ) and likewise α =

Revised: A − 1 y in the same manner.

Revised: The difficulty is in selecting the choice of the linear ordering.

Revised: We are not able to provide any sensible ordering for high dimensional dataset, though a meaningful ordering we may still exist.

Revised: Thus we ask does there exist any linear ordering so that TNN can be used for high accuracy classification?

Revised: The proposition indicates that there is.

Revised: Proposition 4 .

Revised: Given a standard DNN for C classes classification with a tr training accuracy, then there exists a linear ordering for TNN to achieve a tr accuracy.

Revised: Test accuracy a test of DNN can be achieved by TNN with high probability through squeezed linear ordering.

Revised: Proof:

Revised: In the stringent case, classification is performed by taking c = argmax i

Revised: y i where y = DNN ( x ) , x the image to be classified, and y ∈ R C the output from the last layer of the neural network DNN .

Revised: Suppose C = 10 and c = 0 , 1 , . . .

Revised: Partition the unit interval [0 , 1] such that the ten classes are evenly distributed, i.e. I c = [ cC , c +1 C ] .

Revised: For each class c , collect all the training data samples that are classified as c by the DNN, denote this set as P c .

Revised: Then perform the following linear ordering: map p c to c

Revised: +0 .

Revised: 5 C where p c is the data point with the highest y c component at the last layer of DNN.

Revised: Let R c

Revised: = { r i ∈ P c \{ p c } : DNN c +1 ( r i ) ≥ DNN c − 1 ( r i ) } .

Revised: Then, continue constructing the linear ordering p c < r 1 < r 2 < . . .

Revised: so that r k < r k +1 whenever DNN c ( r k ) ≥ DNN c

Revised: ( r k +1 ) , i.e. going to the right of the interval, a data sample has the less probability of being classified as c and it is also more likely classified as c

Revised: + 1 than c − 1 if c is excluded.

Revised: Let L c be the remaining set of data samples classified as c , i.e. P c \ ( R c ∪ { p c } ) .

Revised: Set · · · < l 2 < l 1 < p c so that l k +1 <

Revised: l k whenever DNN c ( l k ) ≥ DNN c ( l k +1 ) .

Revised: The linear ordering for training dataset is done and TNN will yield a tr .

Revised: Squeezed linear ordering .

Revised: We can map the ordered samples to the interval I c arbitrarily, so long as the order is preserved.

Revised: However, placing each R c , L c nearer to p c increases TNN chances of achieving a test , i.e. we squeeze the linear ordering towards the centers p c for all c .

Revised: This is because, ordering test data samples into the linear order made by training samples, we may get the situation where test sample has max y c (thus likely classified as c ), but lies beyond the extreme end of R c or L c .

Revised: Conversely, such sample is beyond the extreme end of L c +1 or R c − 1 respectively.

Revised: By squeezing, large spaces (the grey area ) are reserved between the extreme ends of two classes.

Revised: Data samples could fall into these intervals, and we reduce the possibility of misclassifying edge cases, e.g. by letting users treat them separately when TNN indicates that these samples lie in the grey area .

Revised: □

Revised: Since TNN can achieve arbitrary accuracy on the training dataset, we will recover the same accuracy as the DNN from the newly ordered training data.

Revised: We do not quantify the exact probability of attaining high a test because distribution of test dataset may not be exactly the same as the training dataset.

Revised: With DNN as the encoder mapping the raw data into the unit interval is ironic since the hardwork is already spent on training the deep neural network.

Revised: However, this shows that, in principle, there exist encodings that can achieve linear ordering for TNN to attain high accuracy classifications.

Revised: Notes: when clashes occur, e.g. r k and r k +1 have the same DNN c components, for the purpose of this simple construction, simply randomly assign order between them.

Revised: We only aim to prove the existence of linear ordering here.

Revised: B. M ORE REMARKS ON SQANN

Revised: Regarding the pseudo code .

Revised: Mapping names from pseudo code to python code: sample collection → layer k sample collection.

Revised: push node → push node to layer.

Revised: forward cons → forward to layer k for reconstruction.

Revised: ssig → STOP SIGNAL collision → COLLISION.

Revised: remove index → remove index to layer node check signal, new nodes and update nodes are placeholders for simple check and update sequences in python code.