the algebraic decision-tree model
The plain decision-tree model only lets an algorithm ask 'is x less than y?'. That is enough for sorting and searching, but many problems — especially in geometry — naturally ask richer questions, like 'is this point above that line?' or 'do these three points turn left or right?', which involve arithmetic, not just comparing two given numbers. The algebraic decision-tree model widens the rulebook: at each node you may compute a polynomial of the inputs and branch on its sign. It is the right arena for proving lower bounds on geometric and arithmetic problems.
Concretely, each internal node evaluates some polynomial p of the input coordinates and tests whether p > 0, p = 0, or p < 0, sending the computation down one of three branches; leaves announce the answer. A plain comparison 'x < y' is the special case p = y - x with a sign test, so this model contains the comparison model and is strictly more powerful — it can, for instance, test whether x^2 + y^2 < r^2 (is a point inside a circle?) in one step. The cost charged is the height of the tree, the number of sign tests on the worst-case input. Lower bounds in this model count how many sign tests are forced, and the deepest technique (Ben-Or's theorem) connects that count to geometry: if the set of YES inputs breaks into N disconnected pieces, the tree must have height Omega(log N), because a low tree cannot reach enough separated regions.
Why bother with the extra generality? Because it lets lower bounds survive against algorithms that do real arithmetic, not just comparisons, which is essential in computational geometry where coordinates get added, multiplied, and squared. The honest caveats: even this richer model is not universal — it still does NOT capture hashing, indirect addressing, or reading the bit representation of a number, so results like the Omega(n log n) element-distinctness bound hold here yet are sidestepped by hashing in the RAM model. Also, bounding 'number of connected components' is geometrically delicate; the technique gives clean Omega(n log n)-type floors but is not a turnkey method for every problem.
An orientation test for three points p, q, r computes the sign of the cross product (q-p) x (r-p): positive means left turn, zero means collinear, negative means right turn. That single sign test is one algebraic decision-tree node, richer than any plain 'a < b' comparison.
Each node tests the sign of a polynomial; the comparison model is the special case p = y - x.
Richer than the comparison model, but still not all-powerful: it does not model hashing or reading bits, so RAM-model tricks (like hashing for element distinctness) can beat lower bounds proven here without contradicting them.