[Top][All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]


From: Joe Corneli
Subject: scholia.el
Date: Mon, 07 Mar 2005 10:27:05 -0600

This code is meant to be a "proof of concept" for the digital library
infrastructure described here:

The basic idea is to create a "sea of documents" that can be attached
to one another.  For example comments on an essay might be attached to
the essay.

This implementation is preliminary - some features I'm sure everyone
would like have simply been left out.  I'd be interested in comments
anyway.  Specifically, there is a use of `recursive-edit' I'm not so
sure about, and I wonder if it wouldn't be better to store the
collection of documents in a hash table. (Hash tables and user input
are new to me.)

An essay I wrote with commentary by me and by some reviewers who
didn't accept it into their conference is included as an example
showing how the system works.

;;; scholia.el --- for writing and viewing documents with scholia

;; Copyright (C) 2005 Joe Corneli <address@hidden>

;; Time-stamp: <jac -- Mon Mar  7 10:20:45 CST 2005>

;; This file is not part of GNU Emacs, but it is distributed under
;; the same terms as GNU Emacs.

;; GNU Emacs is free software; you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published
;; by the Free Software Foundation; either version 2, or (at your
;; option) any later version.

;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; GNU General Public License for more details.

;; You should have received a copy of the GNU General Public License
;; along with GNU Emacs; see the file COPYING.  If not, write to the
;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
;; Boston, MA 02111-1307, USA.

;;; Commentary:

;; The function `scholium' puts a document into a database of
;; documents.  We then have the opportunity to view any documents in
;; that database (see `select-document-to-view').  Some of the
;; documents will have scholia "about" portions of them, also in the
;; database, and these will be shown on-screen whenever the "base"
;; document is viewed.  Run `scholia-example' for an example of all of
;; this.  After a collection of documents and scholia have been
;; created, `wind-down-scholia' gives the user the opportunity to save
;; their work in scholia.el-compatible format.

;; Advice to new users:

;; The display here relies on font lock.  You might as well run
;;    (global-font-lock-mode 1) 
;;                             ^ [Position cursor behind right paren
;;                               and hit C-x C-e (control+x followed
;;                               by control+e).]
;; if you are going to test this file and you don't already have
;; font lock enabled globally.
;; In order to create new scholia using the function
;; `make-scholium-about-current-document', you have to know how to
;; mark a region of text.  This is done by pressing C-SPC and then
;; using navigation commands to change the selected area.  To
;; cancel a selection, press C-g.  Since the exact endpoints of
;; the region are important, it is advisable that you also run
;;    (setq transient-mark-mode t)
;; Finally, some basic instructions for your first run:
;;  M-x scholia-example
;;     gets an example set up.
;;  RET (in the Document Selection buffer)
;;     view the document listed on the current line.
;;  mark a region (in Main Document Display buffer)
;;     prepare to create a scholium about this region.
;;  M-x make-scholium-about-current-document
;;     edit the new scholium (press C-c C-c to end).
;;  M-x wind-down-scholia
;;     gives you a chance to save your work.

;; Current limitations: 

;; * If scholia have been written about overlapping pieces of text,
;;   display is going to get a bit weird.  This could be dealt with by
;;   a more intelligent fontification scheme - specifically, scholia
;;   could alternate in color, and regions with overlapping scholia
;;   should be shown in a third color.  Well, maybe that wouldn't work
;;   perfectly with the Scholia Display I have set up.  But it ought
;;   to work OK with a different type of display...  the idea of
;;   "right click" seems somehow relevant.  "Mouse over" (cursor over)
;;   could be important too.
;; * We should have a function for reading-in documents that have been
;;   saved in our interchange format.
;; * Can't create new top-level document (this would be easy to do,
;;   but I'm anxious to upload something...)
;; * many more...

;;; Code:

(require 'align)
(require 'cl)

;; The "library" should probably be handled in a much more
;; sophisticated way, but a simple list will do for a prototype.
;; Ideally we would have some sort of file format that would allow you
;; to save the set of documents and scholia you have been working on.
;; The format of elements of this list is:
;; docname text &optional about beg end
(defvar document-list nil "This is our \"digital library\".")

;; this will pop up a window with the names of things in the digital
;; library.  Hit "enter" on one of these, and the document itself will
;; be opened.
;; Maybe this shouldn't change the other windows unless asked - or
;; we could separate the window initializer from the document initializer.
;; Seems very sensible to me.
(defun select-document-to-view ()
  (pop-to-buffer (get-buffer-create "Document Selection"))
  ;; setting up the rest of the windows too...
  (save-excursion (delete-other-windows)
                  (other-window 1)
                  (switch-to-buffer (get-buffer-create 
                                     "Main Document Display"))
                  (other-window 1)
                  (switch-to-buffer (get-buffer-create 
                                     "Scholia Display"))
                  (other-window 1))

(defvar show-all-scholia-in-selection-buffer nil 
  "Environment variable used to toggle display of all scholia.")

(defun update-document-selection-display ()
  (set-buffer (get-buffer-create "Document Selection"))
  (delete-region (point-min) (point-max))
  (dolist (docstr document-list)
    ;; only list selectable scholia, unless we've been instructed
    ;; otherwise.
    (when (or show-all-scholia-in-selection-buffer (sixth docstr))
       (format "%s   |-%s...\n" 
               (car docstr)
                "\n" " "
                (substring (cadr docstr) 
                           (min 30
                                (1- (length
                                     (cadr docstr))))))))))
  ;; just copied and modified from `align-regexp'...
  (align-region (point-min) (point-max) 'entire 
                (list (list nil (cons 'regexp "|-")
                            (cons 'group (abs 0))
                            (cons 'justify t)
;                           (cons 'bogus 0)
                            (cons 'spacing 0)
;                           (cons 'column (abs 0))
                            (cons 'repeat 0))) nil nil)
  (goto-char (point-min))
  (while (re-search-forward "|-" nil t)
    (replace-match "  "))
  (untabify (point-min) (point-max)))

(defun toggle-show-all-scholia ()
  "Toggle display of all scholia in the Document Selection buffer."
  (setq show-all-scholia-in-selection-buffer 
        (not show-all-scholia-in-selection-buffer))

(defun delete-scholium ()
    (goto-char (line-beginning-position))
    (when (looking-at "^.*?\\_>")
      (delete (assoc (intern (buffer-substring (point) 
                                                 (forward-sexp 1) 

;; We should have the option to view *all* scholia, toggle their
;; "selectability", and delete them, dired style.
(define-derived-mode document-selection-mode text-mode 
  "Mode for selecting the document to view.
  (set (make-local-variable 'font-lock-defaults)

;; It would be cool to have the current document marked in a different
;; color from the others.
(defconst document-selection-font-lock-keywords 
    (list '("^.*?\\_>" 0 font-lock-function-name-face))))

;; We could also provide functionality for deleting articles, and for
;; showing all of the articles in the collection.
(setq document-selection-mode-map
      (let  ((map (make-sparse-keymap)))
        (define-key map "
" 'document-selection-select)
        (define-key map "t" 'toggle-show-all-scholia)
        (define-key map "d" 'delete-scholium)

(defvar current-main-document nil 
  "The canonical name of the current document.")

;; It would be cool if you could edit either the scholia or the
;; original document, and have notifications of changes (character
;; positions) spread throughout the DL, or at least have the stuff
;; saved.  Text properties might be the way to go for making sure
;; character positions are updated properly.
;; if there are scholia about *our* scholia, then we should be
;; able to "scroll" to the right, to read those scholia, and
;; scroll back to the left to read the previous ones -- my
;; goodness, but this is getting complicated.
;; And remember, we still need a way to *combine* various
;; documents from the DL to make one "main" document to put in
;; the main document display box.
(defun document-selection-select ()
    (goto-char (line-beginning-position))
    (when (looking-at "^.*?\\_>")
      (let* ((current-doc (intern (buffer-substring (point) 
                                                      (forward-sexp 1) 
             (docstr (assoc current-doc document-list)))
        (when docstr
          (set-buffer (get-buffer-create "Main Document Display"))
          (delete-region (point-min) (point-max))
          ;; we first insert the text and then see if at has any scholia
          ;; associated with it.  If there are scholia, then we should
          ;; display those in a separate window alongside.
          ;; setting up the windows appropriately is something I guess we 
          ;; should do at first, all at once...
          (insert (cadr docstr))
          (setq current-main-document (car docstr))

(defun update-scholia-display ()
  (set-buffer (get-buffer-create "Scholia Display"))
  (delete-region (point-min) (point-max))
  (setq scholia-count 0)
  ;; instead of adding all of the scholia right away, it might
  ;; be better to cache them in a list and then `sort' them.
  (let (sorted-scholia)
    (dolist (possible-scolium document-list)
      ;; whenever the possible-scolium is "about" the current doc,
      ;; we do some stuff.
      (when (eq (third possible-scolium) current-main-document)
        (setq sorted-scholia (cons possible-scolium sorted-scholia))))
    (when sorted-scholia
       (sort sorted-scholia #'(lambda (scho1 scho2) 
                                (< (fourth scho1) (fourth scho2))))))))

(defvar scholia-display-buffer-positions nil)

;; this should maintain a list of buffer positions that tell us the
;; start and end of each of the scholia in the Scholia Display window
;; -- this list can be used to decide, if we are about to create a new
;; scholium, whether to make it about one of the existing scholia, or
;; about the scholium list.
;; And when one of these scholia has some scholium written about it,
;; that should be indicated here visually somehow.
(defun mark-things-up (scholium-list)
  (setq scholia-display-buffer-positions nil)
  (dolist (scho scholium-list)
    (let ((sbeg (point)))
      (insert (second scho))
      ;; now that we're maintaining the
      ;; `scholia-display-buffer-positions' list, we could wait until
      ;; everything was inserted to adjust the text properties, then
      ;; do that in some way that depended, say, on the total number
      ;; of scholia that had been inserted.  But whatever.
       ;; use different faces for the different scholia
       `(face ,(scholium-face))
       (get-buffer "Scholia Display"))
      (add-to-list 'scholia-display-buffer-positions (cons (first scho) (list 
sbeg (point))) t)
      (insert "\n\n")
       (fourth scho)
       (fifth scho)
       ;; should use different faces for the different scholia
       ;; I guess...
       `(face ,(scholium-face))
       (get-buffer "Main Document Display"))
      (setq scholia-count (mod (1+ scholia-count) 6)))))

(defvar scholia-count 0)

(defun scholium-face ()
  (cond ((eq scholia-count 0)
        ((eq scholia-count 1)
        ((eq scholia-count 2)
        ((eq scholia-count 3)
        ((eq scholia-count 4)
        ((eq scholia-count 5)

;; We should also save "bookkeeping" information - like author or date
;; or whatever.
(defun scholium (can text &optional about beg end selectable)
  "Put canonically-named document CAN, with text TEXT, in scratch buffer. 
ABOUT is a document that this scholium is attached to. BEG and
END are optional character positions within ABOUT denoting the
region being commented on. A scholium is only listed in the Document
Selection buffer if it is SELECTABLE."
  (setq document-list 
        (add-or-replace document-list 
                        (cons can (list text about beg end selectable))
                        ;; the fact that this appears to work is a
                        ;; little scary.  should probably rewrite to
                        ;; not be scary.
                        #'(lambda (obj) (eq (car obj) (car elt))))))

(defun add-or-replace (lis elt pred)
  (let ((unfound t)
        (n 0)
        (len (length lis)))
    (while (and unfound 
                (< n len))
      (when (funcall pred (nth n lis))
        (setcar (nthcdr n lis) elt)
        (setq unfound nil))
      (setq n (1+ n)))
    (when unfound
      (setq lis (append lis (list elt)))))

;; very preliminary (not a "real" function yet).  This should probably
;; behave differently depending on whether we are making a scholium
;; about the current "main" document, or one of the scholia...

(defvar new-scholium-name "" "Name of the new scholium we're creating.")

(defvar new-scholium-about nil "Scholium this one is attached to.")

(defvar new-scholium-beg nil "Beginning of the referenced text.")

(defvar new-scholium-end nil "End of the referenced text.")

;; We can now successfully make a scholium about the current main
;; document - but how about one of the scholia?  How should such 
;; a secondary scholium be displayed?
;; Oh, and another thing, it would be good to be able to add a
;; scholium directly to the document list without having it be "about"
;; anything in particular at all (i.e. a top-level document).
(defun make-scholium-about-current-document ()
  (cond ((equal (buffer-name (current-buffer)) "Main Document Display")
         (setq new-scholium-about current-main-document
               new-scholium-beg (region-beginning)
               new-scholium-end (region-end))
;        ((equal (buffer-name (current-buffer)) "Scholia Display")
;         )
;         (error "Currently only enabled in \"Main Document Display\" and 
\"Scholia Display\" buffers")
         (error "Currently only enabled in \"Main Document Display\" buffer for 

(define-derived-mode new-scholium-mode text-mode 
  "Mode for editing a new scholium.
  (setq fill-column 64))

(define-key new-scholium-mode-map
  "" 'escape-scholium-creation)

;; This should probably forbid the creation of "empty" scholia, because
;; these are rather silly.
(defun escape-scholium-creation (selectable)
  "Get out of the recursive edit, and store the contents of the scholium.
If SELECTABLE is non-nil, the scholium will be added to the index."
  (interactive (list
                (y-or-n-p "Make scholium selectable? ")))
  (scholium (intern (replace-regexp-in-string " " "-" new-scholium-name) )
            (buffer-substring-no-properties (point-min) (point-max))
  (if selectable
  ;; we should also update the main document window and the scholium window.
  (kill-buffer (concat "Editing scholium:" new-scholium-name))
  ;; either this function or some main function should save the text
  ;; of the DL in some readable format in buffer from which it can be
  ;; restored.
  (throw 'exit nil))

(defun make-new-toplevel-scholium ()
  (setq new-scholium-about nil
        new-scholium-beg nil
        new-scholium-end nil)

(defun make-scholium ()
  (let ((config (current-window-configuration)))
    (setq new-scholium-name (read-string "Scholium name: "))
    (set-buffer "Document Selection")
    (other-window -1)
    (other-window 1)
    (switch-to-buffer (get-buffer-create (concat "Editing scholium:" 
    ;; this is where we wait for user input; see `escape-scholium-creation'.
    (set-window-configuration config)))

;; We should presumably offer the option of just saving new or modified
;; scholia, rather than saving the whole library.
(defun wind-down-scholia (save)
  (interactive (list (y-or-n-p "Write current library to buffer? ")))
  (when save
    (set-buffer (get-buffer-create "*Scholia*"))
    (delete-region (point-min) (point-max))
    (dolist (doc document-list)
      (write-out-scholia doc))
    (delete-char -1)
    (message "Library written to *Scholia* (not yet saved to disk)."))
  (kill-buffer (get-buffer-create "Scholia Display"))
  (kill-buffer (get-buffer-create "Main Document Display"))
  (kill-buffer (get-buffer-create "Document Selection")))

(defun write-out-scholia (doc)
  (insert (concat "(scholium '" (format "%s" (first doc))
                  "\n" (format "%S" (second doc))
                  "\n'" (format "%s" (third doc))
                  " " (format "%s" (fourth doc))
                  " " (format "%s" (fifth doc))
                  " " (format "%s" (sixth doc))

;;; Text:

(defun scholia-example ()
  "A ready-made example for testing this code.
Warning: this will change `document-list', so if you're in the
middle of working on a collection of documents already, you may
want to run `wind-down-scholia' and save your work before running
this function."
  (setq document-list nil)
  (scholium 'original-document
            "The HDM project
Joseph Corneli


What exactly the Hyperreal Dictionary of Mathematics is meant to be
is this: a free and comprehensive database of mathematics together
with tools that enable efficient interaction with this database. To
introduce more colorful terms, the goal of the HDM project is to
make a simulation of mathematics that surpasses ``real'' mathematics
in possibility.

The first objective of the project is to systematically transpose
all extant mathematics into free hypertext. Optical character
recognition software that works on mathematical text, mathematical
language parsing software, and hypertext generating software are
three stepping stones that I think could help achieve this
objective. These tools would allow one to transform print-based
mathematical text into electronic hypertext automatically.

Human-generated hypertext is not meant to be excluded, but given the
quantity of extant mathematics, and the fact that much of the text
falls under copyright, and the need for some standards for the
database entries, automation of many parts of the process will be

The underlying reason why such a project might be expected to work
at all is that math is highly modular, or outline-based. By this I
mean that you can read math on many levels; you can get the outline
of an argument and then later fill in the details. You can follow up
on related ideas if you wish, or ignore them.  You can seek an
in-depth understanding of a theorem or definition, or you can just
use it and see that it works. Above all, you do not have to
understand all the details of a problem to have a good understanding
of one of its minor aspects.

This phenomenon of modularity means that the database can grow by
small steps and that any electronic aids used in its production
(such as a parser or hypertext generator) can be made to work
without a terribly huge scope.

As time goes by and the database grows, more knowledge-intensive
tasks can be carried out.  Among these is the development of a
library of new free mathematical works.  Sometimes these works will
take the form of collections of dictionary entries, sometimes
documentation that explains how to use some aspect of the dictionary
effectively. Some will contain original mathematics.  The semantic
content of all of these works, whether technical or expository,
should be added to the HDM.

On developing the HDM

Since we currently do not have robust math-ready OCR, extant
transparent texts are our only testing ground for the parsing tools
we will develop (1).  It isn't clear yet whether it will be possible
to create the kernel of the HDM any other way than ``by hand''.
Nonetheless, the more high-quality transparent mathematical text we
have to work with, the better.

We should now ask: what exactly is the kernel supposed to be?  The
HDM kernel is what needs to exist for the HDM to autonomously
support creation and linking of new entries from transparent
source. In other words, the HDM kernel is whatever software and
mathematical content we need to prime the pump. However, once a
kernel is ready, that is not the end of the story. On the one hand,
no doubt the kernel will run into trouble a lot, especially at
first, and it will have to be fixed. On the other hand, even once it
is running quite smoothly, its behavior should be continually
improved. For instance, as the HDM grows, the kernel will have to be
used to refactor entries into more useful forms, and we will want to
implement new and better ways to do this.

It should be clear that while the HDM is motivated by formal
mathematics, in contrast to proposed systems like QED, the HDM does
not lie properly within formal mathematics.  While people working on
the core of the kernel will certainly have to be comfortable working
with formal mathematics, later we will write software that will make
it relatively easy for anyone to write for the HDM.

Similarly, while the HDM is motivated by mainstream AI, we do not
intend to stick to AI methods. In particular, we do not expect to
produce an artificial system that will learn math the same way
people do -- at least not for a very long time.  It will also be a
long time before the HDM will be able to parse a whole paper
automatically.  Prerelease versions of the kernel will require a
human operator to answer questions as it runs, and dialog with human
users will be an important part of the system for the foreseeable

OCR is considered separately from the other tools for a few reasons.
First, producing a robust math OCR program seems to be particularly
challenging, and second, it isn't completely clear that it will be
necessary.  While I am fairly confident that OCR will eventually
become far more efficient than typing, the fact of the matter is
that a lot of important math has been typed into the computer
already. We can begin with this body of work. Before too long,
someone else may develop a free OCR engine -- perhaps the people
working on the Digital Mathematics Library at Cornell University
(2).  It is even conceivable that, working together with their
colleagues around the world, the DML group will transform all, or
most, extant mathematics into a transparent form. If they do, their
methods will almost certainly differ from the ones we would have
employed.  In particular, it is not clear at this point how they
will deal with the fact that most mathematical writing is currently
under copyright protection.  If they choose the route of simply
digitizing the portion of mathematical writing that lies in the
public domain, then their product will be free in the sense of
freedom, but not comprehensive in any concrete sense.

On freedom as it relates to the HDM

All the content that is generated automatically by the HDM software
will be placed in the public domain. The code for the kernel of the
HDM will be developed and released under the GNU General Public

The HDM will make freedoms akin to those guaranteed by free software
licenses part of day-to-day mathematics, but it will do this in a
hithertofore unprecedented way (3).  The success of the HDM project
hinges upon the basic freedom to write about any idea whatsoever. As
we improve the kernel, all mathematics that is understandable to
humans will eventually become part of the HDM. The HDM will catch up
with the frontiers of mathematical knowledge.  As this comes about,
people will still be able to publish mathematics in a traditional
medium, but they typically will not be able to distribute their
writing without their ideas quickly being improved upon inside the

It is not our ambition to put all publishers of mathematics out of
business any more than it is our ambition to disenfranchise teachers
or producers of mathematics; on the contrary, the HDM will create
new opportunities in all of these areas, even as it transforms them.

Some fundamentals, or, this is not the HDM manifesto

  Math is very much like software. But there are also many

  Math is in many ways like an operating system for human minds (and
  it also works very well on distributed networks of human
  processors). It is even more like a ``complete Unix-compatible
  software system'' to quote Stallman's description of GNU (4). But
  again, there are many differences.

  To continue the analogy, we might say that if math was software,
  it would be a very special kind of software, namely software that
  lends itself to performing simulations. We could say that the
  mind, when thinking about math, engages with a prototypical

  There is software that can ``do math for you'' -- for example,
  software that can row reduce a matrix. This software engages with
  the same hyperreality that your mind engages with when you do
  math. Accordingly, a free version of all such software belongs in
  the HDM.

  Furthermore, there is a lot of ``code'' in math that hasn't been
  written in a language that a computer can compile, much less
  execute. For example, there is an algorithm for determining the
  canonical form of a 2-D surface that is specified by identifying
  pairs of edges from a planar polygon in a given way. Is there a
  version of this algorithm that a computer can execute?  Yes there
  is: I know, because I wrote a version of this algorithm in C (not
  the best implementation, but it works).  There are lots of
  mathematical algorithms for which there is no computer
  code. Indeed, many proofs are algorithms: ``If epsilon is greater
  than zero, then there is some delta such that...'' -- if the proof
  tells you how to get an appropriate delta, it is an
  algorithm. Ideally, all such ``software'' would be included in the
  HDM. Certainly any math that is a self-proclaimed algorithm that
  does something potentially useful (e.g.  polynomial-time primality
  testing) should be included in the HDM in an actionable form.

  The body of extant mathematics is vast and largely unknown. To the
  best of my knowledge, there is no systematic catalog or census of
  mathematical results.

  As far as I can tell, anyone has the right to think or write about
  anything in mathematics, but one is typically not allowed to
  redistribute the writing of other people (i.e. copyright law
  restricts copying of mathematical writing).  It would appear that
  while mathematics itself is close to being free, encodings of
  mathematics are in general not free. (This applies to both text
  and code.)

  However (and that is a big however) the mathematical analogue of
  ``source code'' can not be said to be all that readily
  available. Nor can it be said to be totally unavailable. The fact
  of the matter is that it is not available to many people.

  The primary reason that mathematical source is not readily
  available is that most mathematical source code is currently
  stored in opaque formats (books in particular) (5). Another reason
  is that mathematical writing is sometimes rather turgid, and a
  third reason is that scope problems frequently make it hard to get
  the information you're looking for when you want it.

  The issue of ``capital formation'' applies to mathematics. It
  appears that (if one is unlucky) one can study math without
  establishing any mathematical capital. For individuals,
  mathematical capital seems to exists on two levels -- there is
  ``real'' capital, which gets embodied in things like books and
  journal articles (i.e. including in particular the ones you see in
  vitas) and there is ``hyperreal'' capital, which is knowledge,
  that one can use to exploit the resources of mathematics in order
  to produce new mathematics or related mathematical commodities.

  The issue of the ``gap between developed and developing
  countries'' is mirrored in mathematics by the gap between
  established mathematicians and students. Students (and, I suppose,
  others) who are capable of establishing sufficient mathematical
  capital have a chance of ``making it'' as mathematicians.

The HDM and the ``Moore method''

I am writing this note from the University of Texas at Austin. Much
of it was written at the Robert Lee Moore Mathematics, Physics, and
Astronomy building, where I was literally surrounded by reminders of
Moore. I've often asked myself whether the HDM is compatible with
Moore's problem-solving method of instruction.  Moore's method is an
extension of Socrates' method of instruction by
questioning. According to the strictest interpretation of this
method, students are not allowed to look at books or even talk to
each other about the problems they are assigned.  Moore's idea was
that you gain strength by figuring things out for yourself and that
you are made weak by having someone else tell you the answers.

The HDM would make all the answers to basic problems available to
anyone who would want to use them.  This seems to suggest that the
existence of the HDM would lead to there being more weak
mathematicians.  Though, of course, in a context where the answers
are available, the artificial restraining of oneself from looking at
the answers is also always available.

Is it a good idea to restrain oneself in this way? Moore thought
so. I'm not so sure. For one thing, even if the answers to many
questions are known, the answers to many other harder questions
remain unknown. If it is confronting the unknown that makes you a
stronger mathematician, then why not confront the unknown that
nobody knows, rather than the unknown that lots of people know?

On the other hand, there is the possibility that confronting the
basics as unknowns (even though they are actually known to lots of
people) is what makes for strong mathematicians. In fact, this seems
very likely to me.  Nevertheless, students can not learn in a

In sum, the HDM would not force people to learn by the Moore method
or the ``anti-Moore method'' or any other method. It would make it
easier for students to search for the method they felt suited them
the best and work towards the goals that they found most
worthwhile. It would also make many more resources available to
people who are interested in learning what kinds of educational
methods are most effective.

Obstacles, real and imagined

We must ask whether it is legal to produce the HDM.  Though we will
not copy directly from texts, we will endeavor to copy all of the
ideas from a large set of texts. I imagine that this activity is
legally safe because it is something that people do all the
time. Indeed,

  In no case does copyright protection for an original work of
  authorship extend to any idea, procedure, process, system, method
  of operation, concept, principle, or discovery, regardless of the
  form in which it is described, explained, illustrated, or embodied
  in such work (6).

Some concern has arisen over the possibility that the particular
selection of ideas in a given book might be subject to copyright
protection. More generally, it isn't perfectly clear how far
copyright protection for a particular way of expressing an idea or
collection of ideas actually goes.

A recently proposed bill, HR 3261, would go beyond copyright to make
it illegal to copy collections of facts that appear in
databases. According to HR 3261,

  the term `database' means a collection of a large number of
  discrete items of information produced for the purpose of bringing
  such discrete items of information together in one place or
  through one source so that persons may access them (7).

For purposes of enforcement, a periodical issue, anthology, or
encyclopedia would be considered to be a database.  I hope that this
bill does not pass into law.

Another concern is what to do about the fact that people are taking
out patents on math (in the form of software patents).

One extra-legal concern has to do with proofs or theorems that are
in some sense inaccessible to computers. Perhaps there are proofs
that can not be written down in a sensible way (though I doubt if
any such proof would be acceptable to human mathematicians), or that
rely on ideas or perceptions that can not be formalized (though I
wonder if such things could qualify as mathematics).  Going to the
other extreme, there are computer proofs that are inaccessible to
humans in some sense.  If private companies or individuals keep
details of such proofs a secret, they may remain inaccessible to the
HDM for some time.


The following people have had particularly helpful comments on the
HDM project or on the contents of this essay; they are listed here
approximately in reverse chronological order from the time I first
talked with them about the project: Bob Boyer, Madeleine Corneli,
Karl Berry, Lawrence Lessig, Richard Stallman, David Jao, Daniel
Ford, Frank Morgan, Richard Fateman, Rajesh Bhatt, Tandy Warnow,
Gordon Novak, Luther Gerlach, Reuben Hersch, Aaron Krowne, Greg
Newby, Michael Hart, Steve Corneli, Zoe Corneli, Timothy Teravainen.
Don Simon kindly sent me a copy of his thesis and associated code
related to proof-checking proofs written in natural
language. Richard Fateman kindly sent me a code-base he had
developed for doing math OCR.


(1) A ``Transparent'' copy of [a] Document means a machine-readable
    copy, represented in a format whose specification is available
    to the general public, whose contents can be viewed and edited
    directly and straightforwardly with generic text editors or (for
    images composed of pixels) generic paint programs or (for
    drawings) some widely available drawing editor, and that is
    suitable for input to text formatters or for automatic
    translation to a variety of formats suitable for input to text
    formatters. A copy made in an otherwise Transparent file format
    whose markup has been designed to thwart or discourage
    subsequent modification by readers is not Transparent. (Source:
    the GNU Free Documentation License Version 1.2.).

(2) To get a sense of this project's goals, please see Twenty
    centuries of mathematics: Digitizing and disseminating the past
    mathematical literature, by John Ewing. The current version of
    this document is

(3) Free software is defined in terms of the following four

    The freedom to run the program, for any purpose.

    The freedom to study how the program works, and adapt it to your

    The freedom to redistribute copies so you can help your neighbor.

    The freedom to improve the program, and release your
    improvements to the public.

    (Source: The Free Software Definition, as published by the Free
    Software Foundation.).

(4) (Source: The GNU Manifesto.).

(5) A copy that is not ``Transparent'' is called
    ``Opaque''. (Source: the GNU Free Documentation License Version

(6) (Source: Title 17 of the United States Code.) Thanks go to David
    Jao for bringing this particular passage my attention.

(7) (Source: HR 3261, Database and Collections of Information
    Misappropriation Act.)
            nil nil nil t)

  (scholium 'first-reviewers-summary
"A sort of manifesto for a visionary project." nil nil nil t)

  (scholium 'first-reviewers-comments
"The paper is a kind of mainfesto (even if the author claims the
converse) for a long-term (how long?), visionary project of global
mathematical repository, comprising both documents and tools. Even
if some of the goals of the HDM project can be shared, this kind of
documents are strictly counterproductive.

In particular:

a. the paper does not contain any real analysis of the current state
of the art. The few other projects mentioned, namely QED or the
\"Digital mathematical Library\" group at Cornell are quoted in a way
that reveals no actual knowledge of their work. A lot, of other work
shoul be mentioned as well (the list is just too long to be recalled
here; the list of topics of MKM could provide a vague idea of its

b. the paper does not provide any sensible timetable, with clear
milestones. In this way, it is impossible to make a distinction
between a dream and a project.

c. the paper does not give any hint on the current state of
advancement of the work. We presume the project has not really
started yet." nil nil nil t)

  (scholium 'second-reviewers-summary
"This paper is simply a discussion of ideas.  Although there are some
good points in the discussion, there is no evidence of work,
research or experimentation which lead to solid results or a system
upon which this paper is based.  The paper simply reports opinions
and plans which are not substantiated neither by research nor by
experimentation. As such, the paper is really neither research nor
experience.  Rather, just a bunch of ideas and opinions." nil nil nil t)

  (scholium 'second-reviewers-comments
"It is not clear what is proposed in the paper, how it can be done or
why it will work.  It is not clear whether the author is aware of
the different research in the field or whether he knows the
directions to follow.  The project as proposed remains too immature
for making any impact." nil nil nil t)

  (scholium 'second-reviewers-points
"The style, the content free discussions, the lack of directions,
lack of comparisons, lack of literature and lack of research are all
points against." nil nil nil t)

  (scholium 'third-reviewers-summary
"The paper describes the Hyperreal Dictionary of mathematics project.
The project is not really describes, only some (rather superficially
described) considerations relations to such an enterprise are given." nil nil 
nil t)

  (scholium 'third-reviewers-comments
"The paper is very preliminary. No concrete details of the project
are given. The points brought up are very general and not at all
discussed in depth. There are many related projects, but non of them
is discussed (except one at Cornell) and no references are given, so
the paper is far from complete. Also the points that are brought up
are not really interesting. E.. pae 2 whee the \"kernel\" is discussed
contains rather empty definitions and no concrete details. The
discussions on copy right and GNU licences seem rather irrelevant at
this point: there are more interesting technical problems to be
solved." nil nil nil t)

  (scholium 'third-reviewers-points
"See above: only point against, no points in favour." nil nil nil t)

;; building a base document according to some markup style ;
;; remember that we need input like... ;
;; can text &optional about beg end ;
;; ;
;; Remember that for some forms of combined documents, it is important ;
;; to combine the scholia from those documents too, and make them ;
;; apply to the new compiled document. ;

;; (scholium 'first-reviewers-review  (review-concat ;
;;                                     'first-reviewers-summary ;
;;                                     'first-reviewers-comments)) ;

;; (scholium 'second-reviewers-review (review-concat ;
;;                                    second-reviewers-summary ;
;;                                    second-reviewers-comments ;
;;                                    second-reviewers-points)) ;

;; (scholium 'third-reviewers-review (review-concat ;
;;                                    third-reviewers-summary ;
;;                                    third-reviewers-comments ;
;;                                    third-reviewers-points)) ;

;; (scholium 'reviews-of-hdm-paper (combine-reviews ;
;;                                  'first-reviewers-review ;
;;                                  'second-reviewers-review ;
;;                                  'third-reviewers-review)) ;

;; My replies ;

;; Note that `scholium' should *replace* anything with the same name ;
;; that is present in the digital library whenever it is reevaluated. ;
  (scholium 'on-manifestos
"A manifesto entails a detailed plan; the reason I
didn't say manifesto is the same reason they didn't
like the paper.  So much for being honest."
'first-reviewers-comments 1 74)

  (scholium 'more-than-a-repository
"Anyway, its rather more than a repository."
'first-reviewers-comments 75 193)

  (scholium 'on-being-counterproductive
"What is meant by \"counterproductive\"?"
'first-reviewers-comments 194 308)

  (scholium 'on-not-being-state-of-the-art
"This is a fair point, but more relevant WRT linguistics."
'first-reviewers-comments 329 406)

  (scholium 'on-related-work
"I'm not so sure that knowledge of the work of QED
or DML is actually that important to the essay.
Obviously the list of related work is long.  Does
it really help to recite the list?"
'first-reviewers-comments 407 743)

  (scholium 'comparison-to-other-manifestos
"The proposal doesn't seem any more vague than QED
or GNU manifestos.  Maybe I missed something."
'first-reviewers-comments 748 904)

  (scholium 'on-assuming-work-not-started
"That isn't a very sensible assumption.  Perhaps
this is just a manner of speaking."
'first-reviewers-comments 909 1041)

  (scholium 'on-talking-about-ideas
"Since when is that a problem?"
'second-reviewers-summary 1 44)

  (scholium 'on-lack-of-clarity
"This might be a fair comment, its hard to tell,
since the comment is neither substantiated by quotes
from the paper nor questions about the material!"
'second-reviewers-comments 1 87)

  (scholium 'on-disinterest
"I am amazed that the reviewer is not interested enough
to offer more detailed suggestions.  Apparently the paper
completely failed to earn a modicum of respect."
'second-reviewers-comments 218 286)

  (scholium 'your-harsh-words
"Harsh!  How about a complement sandwich?  Or even a
Reality Sandwich."
'second-reviewers-points 1 150)

  (scholium 'the-paper-doesnt-describe-its-topic
"The HDM project that is described is not the true
HDM project."
'third-reviewers-summary 1 207)

  (scholium 'on-being-preliminary
"Finally an insightful comment!"
'third-reviewers-comments 1 31)

  (scholium 'on-uninteresting-points
"Harsh!  They are really interesting to me. At least, I
think so."
'third-reviewers-comments 302 365)

  (scholium 'on-law-possibility-and-feasibility
"You can't separate theory from practice with a razor-thin
knife.  Since when is the law irrelevant?  The law is
what makes or breaks the HDM project, at least as much as
the \"technical problems\". A major point in the essay is that
the possibility of an HDM is entailed in the law.  True,
the feasibility is not, but does that matter?  Let's first
talk about possibilities; then allow feasibility to grow
on us as time goes by."
'third-reviewers-comments 466 610)

(scholium 'on-metadata
"Titles and whatnot should probably be stored as metadata."
'original-document 1 16 nil)

(scholium 'compare-impossible-exchange
"Compare Baudrilliard's somewhat positive take on hyperreality
in the book \"Impossible Exchange\"."
'original-document 316 400 nil)

(scholium 'innocence
"This does seem a bit innocent to me now."
'original-document 1121 1244 nil)

(scholium 'on-footnotes
"It would be great to have footnotes done as scholia instead.
This would be a case in which the TYPE of the scholium 
influenced the way it was displayed."
'original-document 2416 2567 nil)

(scholium 'awkward-transition
"Somewhat awkward transition.  Once I get better at writing,
maybe I'll come back and rewrite this whole article to make
it sound better!"
'original-document 5471 5688 nil)

(scholium 'teachers-are-present
"Of course, teachers are available -- and in this model, they filter 
all the on-topic information about the outside world to the students."
'original-document 11453 11619 nil)

(scholium 'different-kinds-of-utility
"It may depend on what the \"utility landscape\" looks like."
'original-document 12133 12183 nil)

(scholium 'free-culture-point-of-view
"From the \"Free Culture\" point of view, this is probably the most
important section in the essay."
'original-document 13239 13405 nil)

(scholium 'very-philosophical
"This goes beyond \"free culture\" to epistemology.  The idea
that computers simply can not be good at math is one that
I've come across, and don't exactly know how to respond to."
'original-document 14900 15178 nil)


;;; scholia.el ends here

reply via email to

[Prev in Thread] Current Thread [Next in Thread]