More specifically, Geometer is a program for drawing, editing, and displaying figures, (or "diagrams", as they will be called here), of plane Euclidean geometry. It is a constraint solving system in the sense that the user specifies constraints, and Geometer calculates the diagram from those constraints.
At first glance, it seems like a simple drawing program with a geometric flavor. Imagine the following sequence of commands:
On the screen, the "obvious" diagram appears, but internally, only the locations of the points are stored, together with the constraints that the circle and two lines must satisfy. What makes Geometer dynamic is that at any point in the display or editing of the diagram, the user may move one or more of the unconstrained points (A, B, and C in this particular example) and the diagram will be altered so that the constraints continue to be satisfied.
The figure above illustrates four possible configurations of the situation described in the previous example. After the inital commands to specify the figure, the user can simply use the mouse to drag around the points A, B, and C and the drawing will change dynamically in such a way that the circle remains centered at A, passing through B, and so that the lines through C remain tangent to that circle. All four examples in the figure can be obtained from any of the others by a suitable movement of the points A, B, and C.
In fact, the user doesn't even need to wait for all the constraints to be satisfied before modifying the figure. Imagine that the original points were arranged as in the lower left example, and after drawing the circle, the user realizes that the tangent lines won't make sense. So all that's required is to drag C outside the circle, and then to issue the commands to draw the tangent lines.
In the vast majority of cases, geometric diagrams can be manipulated in Geometer using a graphical user interface (GUI). The mouse is used to select and drag points, and as they are moved, the constraints are continuously re-solved, and with each solution, an updated diagram is displayed.
Geometer can step through a proof or demonstration, emphasizing the important parts of each step, but still allowing you to manipulate the figure at any stage, and to go back to previous steps if you get confused or need to check on something.
In addition to being dynamic, the diagrams have features that can be emphasized by means of different colors, labels, marks, and blinking. Text can be associated with each stage of a demonstration.
Geometer also has a script mode where a diagram can be driven automatically through a programmed animated script.
The best thing about Geometer, however, is not the collection of packaged examples and illustrations, but the fact that you, as a student or teacher of geometry, can build and manipulate your own diagrams, making geometric discovery much easier and more fun.
The word "geometry", of course, is used here in a very loose sense. Geometer can work with trigonometry, projective geometry, and can even be used to generate computer art. If you're willing to go to the effort, it can be used like a miniature graphical programming language with a user interface that's primarily graphical.
In addition to the points, lines and circles in the example, Geometer supports other types of geometric primitives. The complete list includes points, lines, circles, conic sections, angles, arcs, polygons and Bézier curves. There are dozens and dozens of constraints among the geometric primitives that can be specified. Finally, Geometer supports a few non-geometric primitives, including, but not limited to: floating point numbers, text, and projective transformations.
Also included is machinery to define "macros"---complex operations that are constructed from simpler ones which can be repeated many times. It supports machinery to run scripts to put Geometer into "auto-pilot" mode, and still other machinery that allows users to step through a complex proof or construction and to have various features appear and disappear as necessary. At every stage, the user can manually alter the geometry (and the constraints will be continuously re-solved) to see what happens.
Finally, and this is perhaps one of its most powerful features, Geometer can present both a textual and a geometric representation of any diagram. In other words, you can edit geometric diagrams using either visually or textually.
To illustrate, here is Geometer's textual description of the example above with the circle and the tangent lines:
.geometry "version 0.2"; v1 = .free(0.2275, 0.515, "A"); v2 = .free(0.52, 0.76, "B"); v3 = .free(0.685, 0.5625, "C"); c1 = .c.vv(v1, v2); l1 = .l.vc(v3, c1, 1); l2 = .l.vc(v3, c1, 2);
Don't worry about the exact details, but here's how to read that textual description.
The first three lines create the three free points (the ".free" means they can be freely moved with a mouse). Internally, they are named v1, v2 and v3; on the screen, they are called A, B, and C. The two numbers in each line are the current coordinates of the point. The next line defines a circle, internally called c1, which satisfies the .c.vv constraint. That constraint is that the circle created must use the first point as its center and must pass through the second. In this example, the first point is v1 (labelled A) and the second point is v2 (labelled B)---exactly what we see in the diagram. The final lines of text define the tangent lines with similar constraints.
So far there's nothing too special, but (again without worrying too much about the details, take a look at the following Geometer code that draws the actual figure displayed in the text. Remember that the actual figure has four copies of the figure above, where each contains points, circles and lines, but in all cases the constraints satisfied are the same. By using a macro, all the constraints are specified once, and then those are applied to four different sets of points to draw the four examples you see in the figure. The macro consists of the six lines beginning with .macro and the three lines between the curly braces are the macro body.
.geometry "version 0.2";
.macro circtans(.vertex v1, .vertex v2, .vertex v3)
{
c1 = .c.vv(v1, v2);
l1 = .l.vc(v3, c1, 1);
l2 = .l.vc(v3, c1, 2);
}
v1 = .free(0.2275, 0.515, "A");
v2 = .free(0.52, 0.76, "B");
v3 = .free(0.685, 0.5625, "C");
w1 = .free(-0.445, -0.4075, "A");
w2 = .free(-0.2375, -0.1275, "B");
w3 = .free(-0.4225, -0.325, "C");
x1 = .free(0.56, -0.6025, "A");
x2 = .free(0.6175, -0.57, "B");
x3 = .free(0.1375, -0.17, "C");
y1 = .free(-0.5825, 0.5775, "A");
y2 = .free(-0.425, 0.435, "B");
y3 = .free(-0.285, 0.27, "C");
circtans(v1, v2, v3);
circtans(w1, w2, w3);
circtans(x1, x2, x3);
circtans(y1, y2, y3);
Since there's both a textual and a graphical version of every diagram and you can edit it using the graphical user interface or a text editor, you have the best of all possible worlds---you can edit it using the text or the graphics, whichever is more appropriate.
(Because of the existence of a textual version of each diagram, if you are computer-literate, it is quite easy to write computer programs that generate Geometer diagrams. This can be quite a powerful feature for complex diagrams. Some of the more complicated diagrams on this CD were generated that way.)