\subsubsection{j48/C4.5}
j48/C4.5 is based in the ID3 tree learner. It creates chooses its
splits in data based off of normalized information gain of the
attributes. Once an attribute is chosen, new child nodes are created
for each of the values present in the chosen attribute. The algorithm
then recurses on each of the children nodes. This differs from Clump
because each node can split into at most 2 additional nodes: one for
the true branch, and one for the false branch. Clump chooses a predicate
function for the node, while j48 chooses an attribute to split on.

\subsubsection{jRip/RIPPER}
jRip, also called RIPPER, is a rule based algorithm rather than a rule
tree algorithm. RIPPER stands for Repeated Incremental Pruning to
Produce Error Reduction. RIPPER creates as series of individual rules,
adding conjunctions until the rule only satisfies members of one
class. The rules are then pruned to remove the rules that decrease the
performance of the algorithm. RIPPER is closer to OneR than Clump
because RIPPER creates a series of conjunctions. If the test data
matches the first rule, the class of the first rule is chosen. The
test data is passed down the rule list until it matches on rule or the
final catch-all rule is chosen. RIPPER explores all possible rules,
while Clump explores only the necessary rules to create the tree.

\subsubsection{OneR}
OneR, also referred to as 1R, creates a series of rules. The rules are
compared to the testing data one by one. As soon as a rule matches,
processing terminates for the matching rows, and the matching rule's
classification is assigned to the rows. Over-fitting avoidance is
accomplished by requiring each rule to match a pre-determined number
of rows. The attributes are ranked according to their error in
classifying the training set, rather than some entropy or information
gain metric. This learner is included as the ``straw man'' of the rule
based classifiers.

\subsubsection{Naive Bayes}
Naive Bayes makes many assumptions about data. All attributes are:
\bi
\item assumed to be equally important.
\item statistically independent.
\item do not predict values of other attributes
\ei
These assumptions rarely hold up to real world data, but empirically,
they work quite well\cite{domingos97}. Naive Bayes is frequently
augmented by different pre and post processing algorithms to attempt
to reduce the its naivety while still maintaining its performance and
runtime.

Naive Bayes runs in O(n) time, as no structure is built, no rules are
learned, and no complex processing is done. Only frequency statistics
are gathered during training, followed by simple arithmetic during
testing. Missing values are handled by ignoring that attribute during
calculations. The major drawback to Naive Bayes is that, although Naive
Bayes offers conclusions, it offers little insight into how these
conclusions were reached. By adding a decision tree to Naive Bayes, we
hope to add the ``why'' to the ``what'' of Naive Bayes.

\subsubsection{Locally Weighted Learning}
Locally Weighted Learning, or LWL, is lazy naive bayes classifier. It
is called lazy because, upon training, the data is just stored,
leaving the computational work to occur during testing. Testing is
accomplished one row at a time. As each row is tested, the records in
the training set are weighted based on their Euclidean distance from
the testing row. After the training instances are weighted, a standard
naive bayes algorithm is applied.

This algorithm assumes that the data near the testing row holds the
most relevance to it. It is possible that two rows can be near
each other while never sharing a common attribute. It is also possible
that two rows could be identical in several attributes, while having
many that are substantially different. Clump attempts to balance these
two approaches by grouping data by their similarities and minimizing
entropy.

\subsubsection{RIpple DOwn Rules/Ridor}
Ridor, or RIpple DOwn Rules, by Compton is the first implementation of
a Ripple Down Rule tree. The main difference between Ridor and Clump is
that Ridor is a classifier and Clump is an incremental clusterer. Overlooking the
difference in usage, we can compare the generation of the two
learner's trees. Ridor generates its trees using information gain to
split continuous attributes into two bins, and then uses a $\leq$ or
$>$ operator to represent the split. Clump on the other hand splits its
data into equal width bins before using its own scoring
function(described in \tion{training} to determine the chosen
attribute and range to split on.

A traditional Ripple Down Rules tree as described in \cite{rdr} has a
rule with an ``except'' and ``or'' branch that represents the true
patch and false patch respectively. A patch is created as new data
enters the tree that violates a previous rule. By patching the tree,
it can remain relevant even as new, previously unseen, data is
discovered.
