ETPS User`s Manual - Pages on gtps

ETPS User`s Manual - Pages on gtps
ETPS User’s Manual
2010 February 12
Frank Pfenning
Sunil Issar
Dan Nesmith
Peter B. Andrews
Hongwei Xi
Matthew Bishop
Chad E. Brown
Version for
Basic Logic
Mathematical Logic I and II
Copyright  2010 Carnegie Mellon University. All rights reserved.
This manual is based upon work supported by NSF grants MCS81-02870, DCR-8402532, CCR-8702699,
CCR-9002546, CCR-9201893, CCR-9502878, CCR-9624683, CCR-9732312, CCR-0097179, and a grant from the
Center for Design of Educational Computing, Carnegie Mellon University. Any opinions, findings, and conclusions
or recommendations are those of the author(s) and do not necessarily reflect the views of the National Science
Foundation.
1. ETPS User Interface
1.1. Introduction
You may find the Table of Contents at the end of this manual.
ETPS is a program which is designed to help you do your logic homework. It was developed from TPS, an
ongoing research project in automated theorem proving. It is written in Common Lisp.
To do your homework on the computer, first enter ETPS. It is highly recommended that you run ETPS in an
X-window (on a Unix or Linux system) or use the Java interface for ETPS (if these facilities are available on your
system), so that formulas can be printed on the screen using special fonts which contain logical symbols, and so that
the proof you are developing can be printed and updated in special proofwindows as you work.
You can start the Java interface for ETPS using the JAVAWIN command; see Section 2.3. If you are running
ETPS in an X-window equipped with the special fonts used to print logical symbols, you need to tell ETPS that you
want to use the special fonts for output. At the ETPS prompt, issue the command
setflag style
then, at the subsequent prompt
xterm
This will cause the special symbols to appear when any wffs are printed by ETPS. (If for some reason the special
symbols won’t print properly, just change the style back from xterm to generic.)
If you are running ETPS in an X-window or using the Java interface, you will probably also wish to use the
BEGIN-PRFW command to start up windows containing the current subproof and the complete proof; see Section
2.4. You may need to iconify a window or move it up on your screen by the usual methods for manipulating
windows so that you will have room to issue ETPS commands. You can eventually close the proofwindows with
the END-PRFW comand. See Section 2.5 for commands which control what is regarded as the current subproof.
To help you learn how to use ETPS, transcripts of sample sessions are provided in Chapter 4. Just follow these
examples exactly on your own computer, and you will soon have a general idea of what to do. You can also do
some practice (unassigned) exercises (which you can find with the aid of the PROBLEMS command), and make
frequent use of the ADVICE command, which will offer suggestions about what to do next.
You should note that the only means of identification available to ETPS is the userid of the account from which it
is run. It will credit all work to the owner of that account and to no other user. Thus, in order to receive credit for an
exercise, you must run ETPS from your own account. Run it from a private directory so that the files which ETPS
creates containing your proofs will not be accessible to others.
Start work on an exercise with the command EXERCISE exercise-name; see Section 2.2. Next construct a
complete proof using the inference rules described in Chapter 3. However, some of the more powerful inference
rules may not be allowed for certain exercises. To find out which rules are prohibited, you should invoke the HELP
command on the exercise. If you cannot figure out what the next step in a proof should be, you may get hints by
using the ADVICE command; but beware: these hints are not always helpful and can be misleading.
A partially completed proof will be called a proof outline or simply an outline. When you start proving a theorem
with the EXERCISE or PROVE command, ETPS will create an outline for you which contains a single line: the
theorem you would like to prove. It is not yet justified since you are only planning to prove it. In place of the
justification there will be the word PLAN1. This last line of the outline is therefore called a planned line. Lines
1
ETPS User’s Manual
which are justified can be introduced by justifying a planned line, introducing a hypothesis, or deriving
consequences of already justified lines. Proofs may be built down from the top, adding consequences of established
lines, or up from the bottom, justifying planned lines by asserting new planned lines. It is a good idea to work up
from the bottom as much as possible, so that ETPS will already know about most of the wffs you need, and you will
not have to type them in.
ETPS was originally developed for use with the textbook An Introduction to Mathematical Logic and Type
Theory: To Truth Through Proof by Peter B. Andrews. A second edition was published by Kluwer Academic
Publishers in 2002, and is now available from Springer, which which has taken over Kluwer. Exercises from this
textbook are available in ETPS. However, the inference commands available in your version of ETPS may depend
on the particular logical system chosen by your teacher. Inference commands are specified as inference rules and
are listed in Chapter 3. Ideally, after repeatedly applying rules to planned and deduced lines, they will ‘‘meet’’ and
every planned line will be justified. The examples in Chapter 4 should make all this clearer.
When you have finished the proof, issue the DONE command. This will record the completion of the exercise if
you used the EXERCISE command. The PROVE command lets you prove arbitrary wffs, but it will not give you
credit for any exercises to which these wffs correspond. ETPS sends only a partial record of your session to a file on
the teacher’s area. You must submit a printed copy of the finished proof, as well. To make this copy, first print the
proof into a file, using the TEXPROOF command. When you have exited from ETPS, run this file through TEX.
Then print the press file generated by TEX and hand this output to your teacher.
A word of advice to the user: ETPS is intended to aid you in learning logic, but if you use it thoughtlessly, you
might be able to do exercises without learning much. ETPS does not allow you to use the rules of logic in an
incorrect manner, but it’s important that you learn for yourself how to apply the rules correctly. By allowing only
correct applications of the rules, ETPS encourages the user to spend more time learning the techniques of proving
theorems in logic. It is strongly recommended that when ETPS does not allow you to do something, you think about
why what you tried was incorrect.
1.2. Saving and Restoring Your Work
ETPS saves your work automatically as you try to prove a theorem. This facility is very similar to Emacs’
auto-save feature. ETPS commands SAVE-WORK, STOP-SAVE, RESUME-WORK and RESUME-SAVE allow
you to explicitly use this feature. ETPS also provides the commands SAVEPROOF and RESTOREPROOF for
saving your proofs. Unlike the automatic saving facility, which saves everything typed by the user (and later
re-executes every command in the file), this feature only saves a proof (and later restores this proof, thus avoiding
the re-execution of everything that was done to achieve this state). It is, however, up to you to decide when to save a
proof. Although the auto saving feature starts to save your work whenever you start an exercise, you need to
explicitly use the command SAVEPROOF when you wish to save a proof. Typically, you will want to save the
proof whenever you need to interrupt a session in which you are constructing a proof and wish to continue this proof
later. ETPS commands associated with saving work are described in Section 2.6.
As soon as you start an exercise (but not a proof of your own theorem), ETPS will save your commands with the
appropriate arguments in a file. The name of this file will be exercise.work where exercise is the first exercise
attempted in your current session with ETPS. When ETPS is saving work, it echoes every character you type in a
stream obtained by opening the save-work file. The echo stream is closed only when the user issues the command
STOP-SAVE or the command EXIT (to exit ETPS in the usual way). The save-work file is not available until ETPS
closes this stream.
2
Chapter 1: ETPS User Interface
One more caution: When starting the same exercise in two different sessions, the same filename will be used.
The work for the new attempt will overwrite the old file exercise.work. To save the old attempt, rename it before
restarting ETPS.
After your work has been restored by RESTORE-WORK, ETPS will continue to save subsequent work into the
same file by appending it to the end. If you would like to prevent that, give the STOP-SAVE command right after
RESTORE-WORK; better yet, use the EXECUTE-FILE command.
When commands are read from a save-work file, most errors such as illegal arguments or logical mistakes are
faithfully re-executed, since some of them have side-effects. Only Lisp errors will lead to an abort of the
RESTORE-WORK and the state of the proof will be the same as after the last correct command read from the file.
You may edit the save-work file in Emacs to delete wrong commands or correct illegal arguments, but you’ll be
skating on thin ice. It’s easy to make a mistake in editing the save-work file and you may not be able to recover the
proof you wanted to restore! The inquisitive user may note that lines beginning with a semi-colon are ignored when
the proof is being restored.
There are several options you have when using this auto-save feature. You may switch off saving with the
STOP-SAVE command. Also, you can explicitly save into a different file with the SAVE-WORK command. To
check whether your work is being saved, use the system command PSTATUS.
You also have the option of keeping a complete record of the session, including the system responses, in a file. If
you want to prepare such a copy, issue the ETPS command SCRIPT. Note, however, that the file obtained this way
cannot be used to restore your work as described earlier in this section.
1.3. Exiting and Reentering ETPS
If you wish to end a session with ETPS or temporarily interrupt your work, use the EXIT command. This allows
ETPS to halt gracefully and to close an open save-work file.
If you are running ETPS under Unix and wish to interrupt a session temporarily, you can also use Ctrl-Z. This
will return you immediately to the monitor; if you are currently saving work, the save-work file will not be closed.
Thus any work will be lost unless you return to ETPS. Once out of ETPS, you can run other programs, such as TEX.
To reeneter ETPS, use the Unix command fg.
1.4. Top-level Interaction
In ETPS every command line is identified with a statement number, shown in angle brackets. After a while,
command line numbers are reused, i.e., commands issued long ago are forgotten.
The following is a list of useful control characters and their meaning in ETPS. Some of them may not work under
certain operating systems or display environments. Additional control characters are discussed in Section I.1.
<Rubout> Delete the last character and back over it.
Ctrl-C
Quit current command and return to top-level. (In some implementations of ETPS you must use
Ctrl-G instead.) Using this command may cause problems for any save-work file that is being
created, so it may be better to use ABORT.
Ctrl-U
Delete current input line.
Ctrl-W
Delete last input word.
3
ETPS User’s Manual
The next three characters are special on the top-level only and are currently not to be used when typing in
arguments to commands.
Complete the name of the current command. If COMPLETION-OPTIONS is NIL, this works only if
there is a unique completion; if it is T, you will be offered a list of completions to choose from.
@
<Escape> Exactly equivalent to @. This character can confuse some terminals; we recommend using @ instead.
When typed at the top-level, ETPS will list all the available commands. Note that ? must be followed
by a <Return>.
?
<Linefeed>
This starts a new line on the terminal without terminating the input. This is useful for long command
arguments.
1.5. Using Commands and Defining Wffs
The commands available in ETPS are classified into system commands and inference commands. The system
commands, which are discussed in Chapter 2, deal with communication facilities, starting and finishing a session
with ETPS, the Java interface, proofwindows, the current subproof, saving work, printing, rearranging the proof,
getting assistance, displaying types in higher-order logic, setting flags, and locating and constructing wffs. The
inference commands, which are discussed in Chapter 3, correspond to inference rules. They transform one proof
outline into another by applying the rules.
Common to all commands is the way they are invoked. Simply type the name of the command (you may use
<Esc> to complete its name) and then type <Return>. The command may be printed in either upper or lower
case. If the command takes arguments, ETPS will prompt you in succession for each argument. The prompt takes
the general form
argument name (argument type) : help [default]>
For example:
<1>PROVE
WFF (GWFF0): Prove wff [No Default]>
PREFIX (SYMBOL): Name of the proof [No Default]>
NUM (LINE): Line number for theorem [100]>
You may also specify command arguments on the command line itself. ETPS will then prompt you only for the
arguments you haven’t specified. This is a useful option for commands like PL 2 50, which directly prints every
line in the range from 2 to 50.
After ETPS issues a prompt, you have the following options for your reply besides typing in the argument.
<Return> This selects the default, if there is one.
!
This selects the default, not only for this argument, but all remaining arguments. This can also be used
on the command line itself.
?
This gives help about the type of the argument ETPS is waiting for.
??
This gives help about the command for which you are supplying arguments. In particular, when
applying an inference rule, this will give you the statement of the rule.
ABORT
Aborts current command.
PUSH
Temporarily suspend whatever you’re doing and start a new top-level. The command POP will return
you to the point at which you typed PUSH.
Ctrl-G<Return> or Ctrl-C
To abort. This is a system-dependent feature, and one or the other, or both, may not work on your
4
Chapter 1: ETPS User Interface
system. Using this command may cause problems for any save-work file that is being created, so it
may be better to use ABORT.
If a mistake in an argument can be detected right away, ETPS will complain and let you try again. Sometimes ETPS
will note that something is wrong after all the arguments are typed in. You will then get an error message and be
thrown back to the top-level of ETPS.
The argument name is usually only important when typing in arguments to inference commands. If you are in
doubt what wff you are supposed to type in now, look at the description of the inference rule. The name of the
argument will be the same as the name of a wff in the rule description.
The argument type tells you what kind of object ETPS expects. The most important argument types are listed
below. (You may omit most of the rest of this section when first reading this manual. However, be sure to read the
description of GWFF.)
ANYTHING Any legal LISP object.
SYMBOL
Any legal LISP symbol.
BOOLEAN
A Boolean value (NIL for false, T for true).
YESNO
y or yes to mean YES, n or no to mean NO.
INTEGER+ A nonnegative integer.
POSINTEGER
A positive integer .
STRING
A string delimited by double-quotes. For example "This is a remark.". Strings may contain
<Return>, but no double-quotes.
FILESPEC
A file specification of the form "<dir>name.ext", "name.ext", or simply name.
For
example:"<FP01>EXAMPLE1.MSS". The defaults for dir and ext are usually correct and it is enough
to specify name.
LINE
The number of a line.
LINE-RANGE
A range of lines from M through N, written M--N, where M and N are positive integers and M <=
N. As shortcuts, one may write M, which represents the range M--M; M--, which stands for the range
from line M through the last line of the current proof; and --N, which represents the range from the first
line of the proof through line N. Hence -- represents the range consisting of every line in the proof.
EXISTING-LINE
The number of a line in the current outline.
PLINE
The number of a planned line.
GWFF
A well-formed formula (wff). ETPS prompts you for a GWFF if it needs a wff, term or variable, and it
will usually tell you which one of these it expects in the brief help message in the prompt.
A GWFF can be one of the following:
1. A string representing a wff in double quotes. Strings may contain <Return>’s for
formatting purposes. Case does matter for variables and constants like "x", "y", "P".
For example "x" is not the same as "X". Case is ignored, however, for special
keywords, like quantifiers, connectives, etc. All logical symbols must be separated by
spaces. In addition, the bracketing conventions used in the logic textbook are used in
ETPS, and the symbol "~" can be used as an abbreviation for "NOT"; thus
"forall x.P x y implies ~ [Q x or Q y]" represents the same gwff as
"FORALL x[P x y IMPLIES NOT .Q x OR Q y]". In general you may type
wffs just as they appear in the logic text. See Chapter 4 for some examples of typed wffs
and variables, and Chapter 5 (especially Section 5.1.3) for examples of wffs of higherorder logic (type theory). For more examples, execute the command PROBLEMS in
ETPS with style GENERIC and answer "yes" when you are asked if you wish to see
5
ETPS User’s Manual
definitions. Superscripts can be used, but unlike the textbook, they are not used to
indicate the arity of functions. Instead, they are used to distinguish variables. Superscripts
are indicated by using a "^". Valid superscripts must follow these rules.
• Only strings of the form [0-9]+ can be superscripts.
• The user will explicitly indicate a superscript by the use of the "^". E.g., "x^0",
"foo^1234567". A "^" which is not followed by a legal superscript is treated as any
(non-logical-constant) character would be. Thus "x^" is legal input, as is "^" or
"^^", or "x^y".
• A superscript can only be used at the end of a variable, not in the middle. Hence
"x^1y" will be parsed as "x^1(II) y(I)" (x^1 applied to y) not as "x^1y(I)" (a single
variable).
• Generic style will show the superscripts with the ^, i.e., if you enter "x^1(I)", then it
will print as "x^1(I)" when the style is generic and PRINTTYPES is T.
• Entering "x1" results in "x1", not "x^1", i.e., superscripts will not be created from
the user’s input unless explicitly indicated.
2. A number of a line in the proof, for example 100. ETPS will replace it with the wff
asserted in that line.
3. A label referring to a wff or the name of an exercise or lemma. A label can be assigned by
the CW command (see page 15).
4. (ed gwff) which allows you to locate a sub-expression of another GWFF. For example
(ed 100) can be used to extract a subformula from the assertion of line 100. See
Section 2.12 for an explanation of how to use this option.
5. A backquoted form, calling a wffop. For example, ‘(S x y A) is the wff resulting
from the substitution of x for y in A. See Appendix III for the most commonly used
wffops.
GWFF0
A gwff of type o. Two special constants of type o are provided: TRUTH and FALSEHOOD. These
gwffs act just as you might expect, e.g., TRUTH ≡ p∨∼p and FALSEHOOD ≡ p∧∼p. After running a
proof through SCRIBE, TRUTH will print as T and FALSEHOOD will print as ⊥.
GVAR
A gwff which must be a logical variable.
TYPESYM
The string representation of a type symbol. See Section 5.1.1.
BOOK-THEOREM
A theorem in the book. See the PROBLEMS command (page 9).
EXERCISE An exercise which may be assigned.
PRACTICE An unscored practice exercise.
TEST-PROBLEM
A potential test problem.
Several argument types are lists or pairs of other types. They are specified in parentheses, for example
(1 2 99). The empty list is specified by (). Pairs are entered as two element lists where the two elements are
separated by a period. For example, you might enter the pair ("x" . "y"). Do not put commas into your input!
We list the most common of the composite argument types below:
OCCLIST
A list of occurrences (counted left-to-right) of a subwff in a wff. This list may be entered as a list of
positive numbers or the symbol ALL. ALL refers to all occurrences of the subwff.
LINELIST A list of numbers of lines.
LINE-RANGE-LIST
A list of line ranges.
6
Chapter 1: ETPS User Interface
EXISTING-LINELIST
A list of numbers of lines in the current outline.
GWFFLIST A list of GWFFs.
GVAR-LIST
A list of GVARs.
1.6. Flags and Amenities
Many aspects of ETPS are controlled by flags. See section 2.11 for some information about flags.
ETPS incorporates several features of the Unix C-shell (csh) top-level. These features include various control
characters, command sequences, a history mechanism, and aliases. See Appendix I for details.
You may wish to set certain flags and define certain aliases each time you run ETPS. A good way to do this
without having to repeat the commands is to start a work file (using SAVE-WORK), then set the flags and define
your aliases, then use STOP-SAVE to stop saving into the file. When you subsequently use ETPS, you can use
EXECUTE-FILE to automatically execute all the commands in the work file to set the flags and define the aliases.
1.7. Bugs and Error Messages
Typing or logical errors are usually noticed by ETPS, which issues an appropriate diagnostic message and
typically throws you back to top-level.
Most bugs in ETPS itself will be caught by an error handler which appends an appropriate message to a file in the
teacher’s area. This of course only applies to real bugs in the ETPS software or Common Lisp, not typing errors
which are caught by the command interpreter. You may try again after you get a bug error message, and often you
will discover that you just made a mistake which was not caught by the usual error handling routines. If you still get
an error send mail to the teacher or send a message with the REMARK command. If you think that you have
discovered a bug in ETPS, don’t delete the .WORK file for that session but rename that file (say, to
Yexercise-number.work) so that your work is not overwritten, then allow read access for it and send mail to the
teacher with a pointer to that file.
7
ETPS User’s Manual
8
2. System Commands
2.1. Communication
HELP subject
Will list help available on the subject. The help messages for inference rules can be very long; you may
wish to set the flag SHORT-HELP to T, to prevent this. (The default value of this flag is NIL.)
?
Will list all available commands.
LIST-RULES
Will list all the available inference rules.
PROBLEMS Lists all exercises available in ETPS, and shows which are practice exercises for which ADVICE is
available. Also lists theorems which can be asserted with the ASSERT command.
NEWS
Will list all bugs fixed, changes, improvements, et cetera. The most recent ETPS news items are
announced whenever you start ETPS.
REMARK string
Will mail the string to the teacher, or will include it as a comment in a recordfile created in the teacher’s
directory.
2.2. Starting and Finishing
EXERCISE label
Set up the proof outline to attempt the proof of exercise label from the logic text.
PROVE gwff0 label line
Similar to EXERCISE, but lets you prove your own wff. label is the name of the proof, line is number
of the last line of the proof, i.e., the number of the line which will assert the theorem.
PROOFLIST
Gives a list of all the completed or partially completed proofs in memory, any of which may be
RECONSIDERed.
RECONSIDER label
Allows you to return to a previous proof. label is the name that you gave the proof when you originally
started it using EXERCISE or PROVE; all of the proofs that you have worked on in the current session
with ETPS may be RECONSIDERed.
CLEANUP
Deletes, in the current completed proof, unnecessary lines and redundant lines introduced by the SAME
rule. This command is applicable only if the proof is complete. CLEANUP asks for confirmation before
actually deleting lines.
DONE
Signals that you think that you have completed the current proof. ETPS will not believe you if you are
not really done. The DONE command appends a message to the recordfile in the teacher’s directory. If
you fail to use it, you may not get credit for your work.
SUMMARY
Tells the user what exercises have been completed.
EXIT
Leave ETPS. See Section 1.3 for some information on reentering ETPS. This command will
automatically close open work files.
HISTORY n reverse
Show history list. Shows the N most recent events; N defaults to the value of HISTORY-SIZE,
showing entire history list. REVERSE defaults to NO; if YES, most recent commands will be shown
first.
ALIAS name def
Define an alias DEF for the symbol NAME. Works just like the alias command in the Unix csh. If the
value of NAME is *ALL*, all aliases will be printed; if the value of DEF is the empty string, then the
current alias definition of NAME will be printed. See UNALIAS.
9
ETPS User’s Manual
UNALIAS name
Remove an alias for the symbol NAME. Like the Unix csh unalias, except that NAME must exactly
match the existing alias; no filename completion is done.
See Section I.4 for more discussion of aliases.
2.3. Starting the Java Interface
There is a Java interface for ETPS running under Allegro Lisp (version 5.0 or greater). Special symbol fonts,
proofwindows (see Section 2.4) and editor windows (see Section 2.12) are available when using the Java interface.
JAVAWIN
Start the Java interface. This should open a Java window with menus, a display area for ETPS output,
and possibly a prompt at the bottom of the window. All ETPS output after the Java window opens will
be printed into the Java window. Also, all user input must be entered via the Java window, either using
the menus or using the prompt at the bottom of the window. To enter input into the prompt, the user
may need to click on the prompt area to bring it into focus.
2.4. Proofwindows
When ETPS is running under X-windows or through the Java interface (see section 2.3), it is possible to start up
separate windows displaying the current subproof (which is described in Section 2.5 and can be printed on the
screen with the ^P command), the current subproof plus line numbers (which can be printed with the ^PN
command) and the complete proof (which can be printed with the PALL command). These windows will be
automatically updated as commands are issued to modify the proof interactively. (By scrolling up in these windows,
you can see the previous displays.) The windows may be moved around and resized by the usual methods for
manipulating windows. PSTATUS will update the proofwindows. Printing in the proofwindows can be modified
by changing the flags PROOFW-ACTIVE, PROOFW-ALL, PROOFW-ACTIVE+NOS, and PRINTLINEFLAG.
For more information about the proofwindows, type HELP BEGIN-PRFW.
BEGIN-PRFW
Begin proofwindow top-level; open Current Subproof, Current Subproof & Line Numbers, and
Complete Proof windows.
END-PRFW
End proofwindow top-level; close all the proofwindows.
If you forget to use the END-PRFW command before issuing the EXIT command to leave ETPS, the
proofwindows may not disappear. To get rid of such a window, put the cursor into it and hit ^C (control-C).
2.5. The Current Subproof
ETPS maintains a list which contains the status information for the current proof outline. The status information
consists of the planned lines (lines not yet justified) and the lines (called sponsoring lines) which ETPS thinks you
may wish to use in the proof of the associated planned line. The planned line which is the focus of current attention
and its sponsoring lines constitute the Current Subproof. This is displayed in the windows mentioned in Section 2.4
and can be printed on the screen by using the ^P command. The following commands allow you to examine and
modify the current subproof and the status information.
PSTATUS
This will print the status information in the form
(p1 l11 ... l1n) ... (pm lm1 ... lmk)
where p1 ... pm are the planned lines and the rest of each list are the sponsors for the planned line. The
first list corresponds to the ‘‘current’’ plan. In addition, it’ll issue a message if you are currently saving
work.
10
Chapter 2: System Commands
SUBPROOF pline
Tells ETPS that you now wish to focus on the planned line pline. This changes the current subproof; it
mainly affects the displays in the proofwindows, the results of the ^P and ^PN commands, and the
defaults offered for outline manipulations commands.
SPONSOR pline existing-linelist
Tells ETPS to add the lines in the list existing-linelist of existing proof lines to the list of sponsors for
the planned line pline.
UNSPONSOR pline existing-linelist
Tells ETPS to remove the lines in the list existing-linelist of existing proof lines from the list of
sponsors for the planned line pline.
2.6. Saving Work
SAVEPROOF filename
Saves the current natural deduction proof to the specified file in a form in which it can be restored. Use
RESTOREPROOF to restore the proof. Overwrites the file if it already exists.
RESTOREPROOF filename
Reads a natural deduction proof from a file created by SAVEPROOF and makes it the current proof. A
security feature prevents the restoration of saved proofs which have been altered in any way.
SAVE-WORK filename
Starts to save subsequent commands in the save-work file filename. Notice that this is not necessary,
unless you want to specify your own filename before starting an exercise or if you did a STOP-SAVE
some time before. A typical use would be to switch save-work files when you are done with one
exercise and are starting the next one without leaving ETPS. The extension of filename defaults to
.WORK.
STOP-SAVE
Stops saving into the current save-work file. All commands that have been given but not yet saved will
be written out to the file.
RESTORE-WORK filename show-lines exec-print outfile
Executes commands from filename and continues to save in that file. When the end of the file is
reached, you will be back at ETPS’ command level. show-lines controls whether proof lines will be
shown when restoring the proof. This is very time consuming, therefore the default is NO. exec-print
controls whether printing commands will be executed when restoring the proof. These are commands
like PLINE, PRINTPROOF, HELP, or PROBLEMS. The default is NO. outfile is the name of a file
where the commands and the output is echoed to, while they are re-executed. The default is TTY:, the
terminal, so you can see how far ETPS has progressed. To speed up the process you may select NUL:.
RESTORE-WORK will not re-execute any of the following: EXIT, RESUME-SAVE, RESTORE-WORK,
EXECUTE-FILE, SAVE-WORK, STOP-SAVE. They usually don’t make sense when reading
commands from a save-work file. If you aborted a command with a Ctrl-C, the Ctrl-C will be in the file
and will abort the execution of the commands.
RESUME-SAVE
Use this command to resume saving commands into the most recent save-work file. Unlike
RESTORE-WORK, this command doesn’t execute commands from the file, but simply appends
subsequent commands to the file. You may not use this command if you are already saving work.
Also, you may run into trouble if you forgot to save some commands.
EXECUTE-FILE filename show-lines exec-print outfile
Works like RESTORE-WORK, but does not continue saving into a file after executing the commands in
the file.
SCRIPT scriptfile if-exists-append
Saves a transcript of session to a file.
UNSCRIPT Closes the most recent file opened with the SCRIPT command.
11
ETPS User’s Manual
2.7. Printing
DEPTH n
n is a number. This command causes all subformulas at depth greater than n to be printed as &. For
example the wff "FORALL x FORALL y FORALL z.P x y z" will be printed as below after
the command DEPTH 4: FORALL x FORALL y FORALL z.&. This command may save time in
printing huge formulas, particularly in higher-order logic.
PW gwff
Print gwff.
PWSCOPE gwff
Print gwff with all brackets restored. This is sometimes useful if you are not sure which connective has
precedence over another.
PLINE line Print a specified line.
PL lower upper
Print all lines in the range from lower to upper.
PL* print-ranges
Print all proof lines in given ranges.
PPLAN pline
Prints the planned line pline and all of its sponsors. A similar effect can be achieved with the ^P,
provided pline is the current planned line. SUBPROOF will change the current planned line. See
Section 2.5 for more information on SUBPROOF.
^P
Same as PPLAN for the current planned line. Note that ^P is not a control-character, but two
characters ^ P followed by a <Return>.
^PN
As for ^P, but also prints the line numbers (only) of all the other lines of the proof. ^PN is not a control
character, but three characters ^, P and N.
PALL
Print all the lines in the current outline.
PRINTPROOF filespec
This will print the current proof into a file.
SCRIBEPROOF filespec
This will also print the current proof into a file, but uses special symbols. In order to print this file, you
must first run it through SCRIBE. filespec has the same format as in PRINTPROOF. The extension
defaults to MSS.
TEXPROOF filespec
Print the current proof into a tex file. After leaving tps, run this .tex file through TeX and print the
resulting file.
2.8. Rearranging the Proof
This section describes commands which rearrange the proof outline, which is described in Section 3.1. The first
two commands are frequently useful for starting over a part of the proof after you realize you have tried a wrong
approach.
DELETE existing-linelist
Delete the lines in existing-linelist from the proof. If you delete a hypothesis line, all lines which use
this hypothesis will also be deleted. If a line justifying another line is deleted, the justification of that
line is changed to PLANn. Lines are shown as they are deleted.
DELETE* ranges
Delete ranges of lines from the proof outline.
PLAN existing-line
Change a justified line back to a planned line.
The next few commands allow you to change the numbers of lines in the proof, or even change the order of lines, as
long as the conclusion of a rule of inference comes after the justifying lines. All references to line numbers are
12
Chapter 2: System Commands
changed automatically whenever the numbers are changed.
MOVE from to
Moves a line in the proof. ETPS checks to make sure the move is legal, i.e., the lines justifying a given
line appear before it in the proof.
MOVE* range-to-move new-start
Move all proof lines in given range to begin at new start number, but preserving the relative distances
between the lines.
RENUMBERALL increment
Renumbers all the lines in the proof with an increment of increment.
As a proof is constructed, new lines must be inserted into the outline and given new line numbers between
occupied line numbers. A space allotted for this task is called a gap. Gaps are indicated in the outline by ellipses
(...) and may be adjusted by the command MODIFY-GAPS.
INTRODUCE-GAP existing-line increment
Introduce a new gap (or increase an existing gap) above existing-line by increasing the line numbers by
increment of all lines beginning with line existing-line.
MODIFY-GAPS lower upper
Removes unnecessary gaps in line numbers from the proof structure. Also, gaps with length less than
lower have their length increased to lower, while gaps with length greater than upper have their length
decreased to upper. lower must be less than or equal to upper.
SQUEEZE
Removes unnecessary gaps in line numbers from the proof structure. Leaves necessary gaps (those just
above planned lines) alone.
There is no UNDO command in ETPS. Usually one can undo the results of commands fairly easily by such
measures as deleting lines from the proof. However, if this seems complicated, the following procedure can often be
used to restore the proof to one of its previous states. ETPS is probably creating a save-work file. Execute the
STOP-SAVE command, make a backup copy of the save-work file for safety, edit the save-work file by deleting the
commands you wish you had not executed, then start a new ETPS and use RESTORE-WORK with the edited
save-work file.
2.9. Proof Assistance
ADVICE
Initially gives hints based on the current structure of the proof. The next time it is executed, it suggests
the inference command based on the previous hint. It repeats this flip-flopping between hints and
suggestions until it has no more suggestions. Advice may not be available for some exercises. ETPS
will tell you if advice cannot be given and ask for confirmation if the advice would deduct points from
your score.
CHECK-STRUCTURE
Finds those lines which are not integrated into the proof and suggests their deletion. These lines are
deduced lines which have not been used to justify another line and are no longer supports for any
planned line. In addition, CHECK-STRUCTURE looks for extraneous hypotheses in each of the lines of
the proof.
2.10. Higher-Order Logic
PWTYPES gwff
Print wff with type symbols.
13
ETPS User’s Manual
SHOWTYPES
From now on show the types of all wffs.
SHOWNOTYPES
From now on suppress types of all wffs.
2.11. Flags and Review
Many aspects of ETPS are controlled by flags. Most of the time you can ignore these, but if you wish to change
some aspect of ETPS (such as the widths of the lines in a proof), you may be able to do so by changing the value of
a flag (such as RIGHTMARGIN). HELP flag will provide information about a particular flag. Use the REVIEW
top-level to find what flags are available. Enter ? for a list of all the commands in this top-level; the following is
just a selection of those available.
REVIEW
Enter the review top-level.
SETFLAG
Change the value of a flag.
SUBJECTS Each flag is associated with one or more subjects; this command lists all the known subjects. Some of
these subjects may be irrelevant to ETPS, but used in a larger system of which ETPS is a component;
you can ignore them.
LIST subjects
List all the flags associated with these subjects.
LEAVE
Return to the main top-level.
2.12. ETPS Editor
The ETPS editor can be used to construct new formulas and extract subformulas from formulas already known to
ETPS. You can enter the editor with the top-level command ED. Use (ed gwff) when asked for a GWFF. This
will prompt you with <Edn>. The wff you are editing will be referred to as EDWFF. Using the editor commands,
move to a subformula and/or modify the EDWFF until you have the GWFF you desire. Then exit the editor by using
the command OK; the current value of EDWFF will be returned.
For example, suppose that ETPS has asked you for a GWFF and the GWFF you would like to supply is B, a subwff
of the assertion in line 1, which is A AND B IMPLIES C. Enter (ed 1) to enter the editor with that formula.
Then use the following sequence of commands:
<Ed1>L
A AND B
<Ed2>R
B
<Ed3>OK
This moves to the left of the implication sign.
This moves to the right of the conjunction.
Since we have what we want, we exit the editor.
This is of course a trivial example, but if B had been a very complicated formula, using the editor would have
been both faster and less susceptible to error than typing it in would have been.
You can also use multiple commands on a single editor input line, which will save more time. We could have
done the above example as follows:
<Ed1>L R OK
When ETPS is running under X-windows or through the Java interface (see Section 2.3), the command ED will
also start up two windows which display the top formula and the current formula in the editor. These windows are
automatically updated as commands are issued to modify the formula, and they will disappear when you use OK to
leave the editor. (By scrolling up in these windows, you can see the previous displays.) The windows may be
14
Chapter 2: System Commands
moved around and resized by the usual methods for manipulating windows.
To prevent the windows from appearing, modify the flags EDWIN-TOP and EDWIN-CURRENT.
The following sections give brief descriptions of the most commonly used editor commands. Other editor
commands are listed in Appendix II.
2.12.1. Top-Levels
<Edn>OK
Exit the editor with the current wff.
2.12.2. Printing
<Edn>P
Print the current expression in short format, i.e., some subformulas will be replaced by &.
<Edn>PP
Pretty-print a wff.
<Edn>PS
Print a wff showing all brackets and dots.
<Edn>PT
Print a wff showing types.
2.12.3. Labels
<Edn>CW label
Assigns a label to the edwff, but does not change the edwff. You can use the label to refer to this wff
later.
2.12.4. Moving Commands
<Edn>0
Move up one-level, i.e., undo the last L, R, D, or A command. Note that 0 stands for the numeral zero.
<Edn>A
For an expression like P x y, delete the rightmost element; in this example the result will be to make
Px the current expression. For a quantified expression, move to the quantified variable.
<Edn>D
For an expression like P x y, move to the rightmost element; in this example y. For a quantified
expression, move to the scope of the quantifier.
<Edn>FB
Find the first binder (left to right).
<Edn>FI
Find an infix operator.
<Edn>L
For an infix-operator, move to the left argument.
<Edn>R
For an infix-operator, move to the right argument.
<Edn>UNDO
Moves up (like 0), but throws away any editing since your last downward moving command (typically
A,D,L,or R).
<Edn>XTR Makes the current edwff the top wff.
<Edn>^
Move upwards through enclosing wffs all the way to the top.
2.12.5. Substitution
<Edn>AB newvar
Alphabetic change of variable at top-level.
<Edn>IB term
Instantiate a top-level universal or existential binder with a term.
15
ETPS User’s Manual
<Edn>REW-EQUIV gwff
Replaces each equivalence in the gwff with a conjunction of implications.
<Edn>RP rep-sym rep-by
Replace one occurrence of a symbol rep-sym (such as AND) by a predefined equivalent wff involving
the symbol rep-by (such as [λ p λ q.~.p ⊃ ~q]). In this example, rep-sym is AND and rep-by is
IMPLIES. To see if a symbol can be replaced using this command, enter HELP symbol; any such
replacements will be listed under the heading ‘Replaceable Symbols’.
<Edn>RPALL rep-sym rep-by
Replace all occurrences of a symbol by a predefined equivalent wff.
<Edn>SUB gwff
Replaces the current wff by the wff supplied.
<Edn>SUBST term var
Substitute a term for the free occurrences of variable in a gwff. Bound variables may be renamed, using
the function in the global variable REN-VAR-FN.
<Edn>SUBSTYP typevar typesym
Substitute typevar with typesym.
2.12.6. Negation movers
<Edn>NEG Negates current wff, erasing double negations.
<Edn>NNF Return the negation normal form of the given wff.
<Edn>PULL-NEG
Pulls negations out one level.
<Edn>PUSH-NEG
Pushes negation through the outermost operator or quantifier.
16
3. Inference Rules
3.1. How to Read Inference Rules
The user works within a proof-outline, which is a sequence of lines. Each line is either a hypothesis, a
consequence of lines with lower numbers or an unjustified planned line. In general, a line of the proof has the
following form:
(n) H1,...,Hm ! assertion
justification: wffs l1 ... lk
n is a number which serves as a label for the line. Each of the Hi’s is the number of a line asserting a hypothesis. !
stands for the turnstyle |− , and l1 ... lk are the numbers of the lines which are used to justify this line.
Every description of a logical inference rule states that certain lines of a proof may be inferred from certain other
lines, provided that certain restrictions are satisfied, and notes the change which the rule effects on the proof status
(see Section 2.5). Inference commands apply inference rules, and they may be used in various ways to complete the
proof. They may generate either new planned or sponsoring lines, or close up a proof by justifying planned lines
with sponsoring lines. However, there is usually a most natural way to use a rule. This is indicated in the statement
of the rule by labelling those lines which are usually sponsors, before or after the rule is applied, with a D (for
deduced) followed by a number. Similarly, those lines the rule expects to be planned lines are labelled with a P
followed by a number.
The transformation statement in an inference rule description indicates the change in the proof status effected by
the most natural use of the rule. The lists before the arrow ==> are matched against the initial status; those after the
arrow describe what the new status should be. The first element of a list is always a planned line and the remaining
elements are its sponsors. Each element of a list is either a label for a line in the rule, pp or ss. The symbol pp
refers to all matched planned lines and the symbol ss to all (other) sponsoring lines for each of the matched planned
lines.
Certain lines in a rule description are expected to exist in the proof before the rule is applied; these are indicated
by an asterisk. If a line does not already exist when you apply an inference command, and its corresponding line in
the rule asserts a wff which cannot be formed from the wffs in rule lines corresponding to existing proof lines, then
the wff asserted by that new line will have to be entered. Thus, in order to avoid typing in long wffs, you should try
to organize your work (often by working up from the bottom) so that such lines will be introduced before they are
needed.
ETPS automatically applies the metatheorem that if H1 |− A and H1 ⊆ H2 then H2 |−
you do not have to worry about expanding sets of hypotheses before applying inference rules.
A, so that normally
Some rules use wffops, operations on well-formed formulae, in their descriptions. For example, a rule might form
the assertion of one line by substituting a term, t, for all free occurrences of a variable, x, in a wff, A, asserted in
another line. The new assertion would then be ‘(S t x A), where S is the wffop performing the substitution.
(The backquote tells ETPS that the application of a wffop is being asserted, and not a wff.) However, this
substitution will only be allowed when t is free for x in A. Thus, the form (FREE-FOR t x A) would appear in
the restrictions for the rule. FREE-FOR is the wffop which checks that t is free for x in A. A catalogue of the
wffops used in inference rules is provided in Appendix III. It is included in this manual only to help you understand
the descriptions of the inference rules.
Now we shall give an example which demonstrates how to read a command. Before proceeding the reader should
look at the description of DEDUCT in Section 3.5 below.
17
ETPS User’s Manual
Suppose the proof originally contains the line
(P3)
H |−
A ⊃ B
PLAN4
and we apply the command:
<n>DEDUCT
P3
H1
D2
Here
• P3 stands for the planned line that you are trying to prove.
• H1 stands for the number of the line which asserts the new hypothesis (the wff A in this case).
• D2 stands for the number of the new planned line (whose assertion is B in this case).
After the rule is applied, the proof will contain the lines:
(H1)
(D2)
(P3)
H,A
H,A
H
|−
|−
|−
A
B
A ⊃ B
Hyp
PLAN5
Deduct: D2
3.2. Quick Reference to Rules
Here is a list of the most generally useful rules of inference available in ETPS for quick reference. Some
additional rules of inference may be found by typing "?" or "LIST-RULES" in ETPS. See the page indicated for a
precise description of each rule listed below. You can also type "HELP rule" in ETPS. The rules of inference in
ETPS are applicable to both first-order logic and higher-order logic. The user who is interested only in first-order
logic should ignore the rules for higher-order logic.
Special Rules
RULEP
ASSERT
ADD-HYPS
DELETE-HYPS
19
20
20
20
Justify a line by Rule P.
Assert a theorem known to ETPS.
Weaken a line to include extra hypotheses.
Delete some hypotheses from the given line.
Miscellaneous Rules
HYP
20
LEMMA
20
SAME
20
Introduce a new hypothesis line into the proof outline.
Introduce a Lemma.
Use the fact that two lines are identical to justify a planned line.
Propositional Rules
CASES
20
DEDUCT
21
DISJ-IMP
21
ECONJ
21
EQUIV-IMPLICS 21
ICONJ
21
IMP-DISJ
21
IMPLICS-EQUIV 21
INDIRECT
21
INDIRECT1
22
INDIRECT2
22
MP
22
Rule of Cases.
The deduction rule.
Rule to replace a disjunction by an implication.
Rule to eliminate a conjunction.
Rule to convert an equivalence into twin implications.
Rule to introduce a conjunction.
Rule to replace an implication by a disjunction.
Rule to convert twin implications into an equivalence.
Rule of Indirect Proof.
Rule of Indirect Proof using one contradictory line.
Rule of Indirect Proof using two contradictory lines.
Modus Ponens.
Negation Rules
ABSURD
From falsehood, deduce anything.
22
18
Chapter 3: Inference Rules
22
22
22
23
ENEG
INEG
PULLNEG
PUSHNEG
Quantifier Rules
AB*
23
ABE
23
ABU
23
EGEN
RULEC
UGEN
UI
23
23
23
24
Substitution Rules
SUBSTITUTE
24
Equality Rules
EXT=
EXT=0
LET
24
24
24
SUBST=
24
SUBST=L
25
SUBST=R
25
SUBST-EQUIV
SYM=
25
25
Definition Rules
EDEF
25
EQUIV-WFFS
25
IDEF
25
Eliminate a negation.
Introduce a negation.
Pull out negation.
Push in negation.
Rule to alphabetically change embedded bound variables.
Rule to change a top-level occurrence of an existentially
quantified variable.
Rule to change a top-level occurrence of a universally quantified
variable.
Rule of Existential Generalization.
Rule C.
Rule of Universal Generalization.
Rule of Universal Instantiation.
Rule to substitute a term for a variable.
Rule of Extensionality.
Rule to derive an equality at type o from an equivalence.
Rule to produce a new variable which will represent an entire
formula during part of a proof.
Substitution of Equality. Performs whichever of the SUBST=L and SUBST=R
rules is appropriate.
Substitution of Equality. Replaces some occurrences of the left hand
side by the right hand side.
Substitution of Equality. Replaces some occurrences of the right
hand side by the left hand side.
Substitution of Equivalence.
Symmetry of Equality.
Rule to eliminate first definition, left to right.
Rule to assert equivalence of lines up to definition.
Rule to introduce a definition.
Lambda Conversion Rules
LAMBDA*
26 Convert between two equivalent lambda-expressions.
LCONTR*
26 Rule to put an inferred line into Lambda-normal form.
LEXPD*
26 Rule to put a planned line into Lambda-normal form.
3.3. Special Rules
RULEP
Justify a line by Rule P.
Infer Bο from A1ο and . . . and Anο, provided that [[A1ο ∧ . . . ∧ Anο] ⊃ Bο] is a substitution instance of
a tautology. As a special case, infer Bο if it is a substitution instance of a tautology. The first argument
must be the line to be justified; the second argument must be a list of lines (possibly empty) from which
this line follows by Rule P. The flag RULEP-MAINFN controls which of two functions will be used by
RULEP. When RULEP-MAINFN is set to RULEP-SIMPLE, RULEP will merely ensure that the
planned line follows by Rule P from the specified support lines. When RULEP-MAINFN is set to
RULEP-DELUXE (which is the default), RULEP will find a minimal subset of the support lines which
suffices to prove the planned line by Rule P (if any). Note that RULEP-DELUXE will be somewhat
slower than RULEP-SIMPLE. In order to check the setting of RULEP-MAINFN, merely enter
19
ETPS User’s Manual
"RULEP-MAINFN" at the top-level. You will be prompted for a new value and the current value will
be displayed. Hit <return> to accept the current value, or enter the new value.
Assert a theorem known to ETPS.
ASSERT
Use a theorem known to ETPS (see Appendix IV) as a lemma in the current proof. Such a theorem can
only be used if allowed by the teacher for that exercise. The first argument is the name of the theorem;
the second argument is the line number. If the line already exists, ETPS will check whether it is a legal
instance of the theorem schema, otherwise it will prompt for the metavariables in the theorem schema
(usually x or P, Q, ...).
Weaken a line to include extra hypotheses.
ADD-HYPS
Adding the hypotheses to the line may cause some lines to become planned lines. If possible, the user is
given the option of adding hypotheses to lines after the given line so that no lines will become planned.
DELETE-HYPS
Delete some hypotheses from the given line.
This may leave the given line as a planned line. The user is given the option of also deleting some
hypotheses from lines after the given line. If possible, the user is given the option of deleting some
hypotheses from lines before the given line so that the given line does not become a planned line.
3.4. Miscellaneous Rules
HYP
Introduce a new hypothesis line into the proof outline.
(H1) H1
|− Aο
*(P2) H
|− Bο
Transformation: (P2 ss) ==> (P2 H1 ss)
LEMMA
Hyp
Introduce a Lemma.
(P1) H
|− Aο
*(P2) H
|− Bο
Transformation: (P2 ss) ==> (P2 P1 ss) (P1 ss)
SAME
Use the fact that two lines are identical to justify a planned line.
*(D1) H
|− Aο
*(P2) H
|− Aο
Transformation: (P2 D1 ss) ==>
Same as: D1
3.5. Propositional Rules
CASES
Rule of Cases.
*(D1) H
|−
(H2) H,H2
|−
(P3) H,H2
|−
(H4) H,H4
|−
(P5) H,H4
|−
*(P6) H
|−
Transformation:
Aο ∨ Bο
Aο
Cο
Bο
Cο
Cο
(P6 D1 ss) ==> (P3 H2 ss) (P5 H4 ss)
20
Case 1: D1
Case 2: D1
Cases: D1 P3 P5
Chapter 3: Inference Rules
DEDUCT
The deduction rule.
(H1) H,H1
|−
(D2) H,H1
|−
*(P3) H
|−
Transformation:
Aο
Bο
Aο ⊃ Bο
(P3 ss) ==> (D2 H1 ss)
Hyp
Deduct: D2
DISJ-IMP Rule to replace a disjunction by an implication.
*(D1) H
|− ∼ Aο ∨ Bο
(D2) H
|− Aο ⊃ Bο
Transformation: (pp D1 ss) ==> (pp D2 ss)
ECONJ
Disj-Imp: D1
Rule to eliminate a conjunction by inferring its two conjuncts.
*(D1) H
|−
(D2) H
|−
(D3) H
|−
Transformation:
Aο ∧ Bο
Aο
Bο
(pp D1 ss) ==> (pp D2 D3 ss)
Conj: D1
Conj: D1
EQUIV-IMPLICS
Rule to convert an equivalence into twin implications.
*(D1) H
|− Pο ≡ Rο
(D2) H
|− [Pο ⊃ Rο] ∧.R ⊃ P
Transformation: (pp D1 ss) ==> (pp D2 ss)
ICONJ
EquivImp: D1
Rule to introduce a conjunction by inferring it from two conjuncts.
(P1) H
|−
(P2) H
|−
*(P3) H
|−
Transformation:
Aο
Bο
Aο ∧ Bο
(P3 ss) ==> (P1 ss) (P2 ss)
Conj: P1 P2
IMP-DISJ Rule to replace an implication by a disjunction.
*(D1) H
|− Aο ⊃ Bο
(D2) H
|− ∼ Aο ∨ Bο
Transformation: (pp D1 ss) ==> (pp D2 ss)
Imp-Disj: D1
IMPLICS-EQUIV
Rule to convert twin implications into an equivalence.
(P1) H
|− [Pο ⊃ Rο] ∧.R ⊃ P
*(P2) H
|− Pο ≡ Rο
Transformation: (P2 ss) ==> (P1 ss)
ImpEquiv: P1
INDIRECT Rule of Indirect Proof.
(H1) H,H1
|−
(P2) H,H1
|−
*(P3) H
|−
Transformation:
∼ Aο
⊥
Aο
(P3 ss) ==> (P2 H1 ss)
21
Assume negation
Indirect: P2
ETPS User’s Manual
INDIRECT1
Rule of Indirect Proof using one contradictory line.
(H1) H,H1
|−
(P2) H,H1
|−
*(P3) H
|−
Transformation:
∼ Aο
Bο ∧ ∼ Bο
Aο
(P3 ss) ==> (P2 H1 ss)
Assume negation
Indirect: P2
INDIRECT2
Rule of Indirect Proof using two contradictory lines.
(H1) H,H1
|−
(P2) H,H1
|−
(P3) H,H1
|−
*(P4) H
|−
Transformation:
MP
∼ Aο
Bο
∼ Bο
Aο
(P4 ss) ==> (P2 H1 ss) (P3 H1 ss)
Assume negation
Indirect: P2 P3
Modus Ponens.
(P1) H
|−
*(D2) H
|−
(D3) H
|−
Transformation:
Aο
Aο ⊃ Bο
Bο
(pp D2 ss) ==> (P1 ss) (pp D3 ss P1)
MP: P1 D2
3.6. Negation Rules
ABSURD
From falsehood, deduce anything.
(P1) H
|− ⊥
*(P2) H
|− Aο
Transformation: (P2 ss) ==> (P1 ss)
ENEG
Eliminate a negation.
*(D1) H
|−
(P2) H
|−
*(P3) H
|−
Transformation:
INEG
∼Aο
Aο
⊥
(P3 D1 ss) ==> (P2 ss)
NegElim: D1 P2
Introduce a negation.
(H1) H,H1
|−
(P2) H,H1
|−
*(P3) H
|−
Transformation:
PULLNEG
Absurd: P1
Aο
⊥
∼Aο
(P3 ss) ==> (P2 H1 ss)
Hyp
NegIntro: P2
Pull out negation.
(P1) H
|− ‘(PUSH-NEGATION [∼ Aο])
*(P2) H
|− ∼ Aο
Restrictions: (NON-ATOMIC Aο)
Transformation: (P2 ss) ==> (P1 ss)
22
Neg: P1
Chapter 3: Inference Rules
PUSHNEG
Push in negation.
*(D1) H
|− ∼ Aο
(D2) H
|− ‘(PUSH-NEGATION [∼ Aο])
Restrictions: (NON-ATOMIC Aο)
Transformation: (pp D1 ss) ==> (pp D2 ss)
Neg: D1
3.7. Quantifier Rules
AB*
Rule to alphabetically change embedded bound variables.
*(D1) H
|− Aο
(D2) H
|− Bο
Restrictions: (WFFEQ-AB Aο Bο)
Transformation: (pp D1 ss) ==> (pp D2 ss)
ABE
Rule to change a top-level occurrence of an existentially quantified variable.
*(D1) H
|− ∃xα Aο
(D2) H
|− ∃yα ‘(S y xα Aο)
Restrictions: (FREE-FOR yα xα Aο) (NOT-FREE-IN yα Aο)
Transformation: (pp D1 ss) ==> (pp D2 ss)
ABU
EGen: tα P1
Rule C.
*(D1) H
|− ∃xα Bο
(H2) H,H2
|− ‘(LCONTR [[λxα Bο] yα])
(D3) H,H2
|− Aο
*(P4) H
|− Aο
Restrictions: (IS-VARIABLE yα) (NOT-FREE-IN-HYPS yα)
(NOT-FREE-IN yα [∃xα Bο]) (NOT-FREE-IN yα Aο)
Transformation: (P4 D1 ss) ==> (D3 H2 ss)
UGEN
AB: x P1
Rule of Existential Generalization.
(P1) H
|− ‘(LCONTR [[λxα Aο] tα])
*(P2) H
|− ∃xα Aο
Transformation: (P2 ss) ==> (P1 ss)
RULEC
AB: y D1
Rule to change a top-level occurrence of a universally quantified variable.
(P1) H
|− ∀yα ‘(S y xα Aο)
*(P2) H
|− ∀xα Aο
Restrictions: (FREE-FOR yα xα Aο) (NOT-FREE-IN yα Aο)
Transformation: (P2 ss) ==> (P1 ss)
EGEN
AB: D1
Choose: y
RuleC: D1 D3
Rule of Universal Generalization.
(P1) H
|− Aο
*(P2) H
|− ∀xα Aο
Restrictions: (NOT-FREE-IN-HYPS xα)
Transformation: (P2 ss) ==> (P1 ss)
23
UGen: x P1
ETPS User’s Manual
UI
Rule of Universal Instantiation.
*(D1) H
|− ∀xα Aο
(D2) H
|− ‘(LCONTR [[λxα Aο] tα])
Transformation: (pp D1 ss) ==> (pp D2 D1 ss)
UI: t D1
3.8. Substitution Rules
SUBSTITUTE
Rule to substitute a term for a variable.
*(D1) H
|− Aο
(D2) H
|− ‘(S tα xα Aο)
Subst: t
Restrictions: (NOT-FREE-IN-HYPS xα) (FREE-FOR tα xα Aο)
Transformation: (pp D1 ss) ==> (pp D2 ss D1)
x D1
3.9. Equality Rules
EXT=
Rule of Extensionality.
(P1) H
|− ∀xβ.fαβ x = gαβ x
*(P2) H
|− fαβ = gαβ
Transformation: (P2 ss) ==> (P1 ss)
EXT=0
Rule to derive an equality at type o from an equivalence.
(P1) H
|− Pο ≡ Rο
*(P2) H
|− Pο = Rο
Transformation: (P2 ss) ==> (P1 ss)
LET
Ext=: P1
Rule to produce a new variable which will represent an entire formula during part of a proof.
(D1) H
|− Aα = A
(D2) H
|− ∃xα.x = Aα
(H3) H,H3
|− xα = Aα
(P4) H,H3
|− Cο
*(P5) H
|− Cο
Restrictions: (NOT-FREE-IN-HYPS xα) (NOT-FREE-IN xα Cο)
Transformation: (P5 ss) ==> (P4 ss D1 D2 H3)
SUBST=
Ext=: P1
Refl=
EGen: x D1
Choose: x
RuleC: D2 P4
Substitution of Equality. Performs whichever of the SUBST=L and SUBST=R rules is appropriate.
(P1) H
|− Pο
*(D2) H
|− sα = tα
(D3) H
|− Rο
Restrictions: (SAME-MODULO-EQUALITY Pο Rο sα tα)
Transformation: (pp D2 ss) ==> (P1 ss) (pp D3 ss P1 D2)
24
Sub=: P1 D2
Chapter 3: Inference Rules
SUBST=L
Substitution of Equality. Replaces some occurrences of the left hand side by the right hand side.
(P1) H
|− Pο
*(D2) H
|− sα = tα
(D3) H
|− Rο
Subst=: P1 D2
Restrictions: (R-PRIME-RESTR sα Pο tα Rο)
Transformation: (pp D2 ss) ==> (P1 ss) (pp D3 ss P1 D2)
SUBST=R
Substitution of Equality. Replaces some occurrences of the right hand side by the left hand side.
(P1) H
|− Pο
*(D2) H
|− tα = sα
(D3) H
|− Rο
Subst=: P1 D2
Restrictions: (R-PRIME-RESTR sα Pο tα Rο)
Transformation: (pp D2 ss) ==> (P1 ss) (pp D3 ss P1 D2)
SUBST-EQUIV
Substitution of Equivalence. Useable when R and P are the same modulo the equivalence s EQUIV t.
(P1) H
|− Pο
*(D2) H
|− sο ≡ tο
(D3) H
|− Rο
Sub-equiv: P1 D2
Restrictions: (SAME-MODULO-EQUALITY Pο Rο sο tο)
Transformation: (pp D2 ss) ==> (P1 ss) (pp D3 ss P1 D2)
SYM=
Rule of Symmetry of Equality.
(P1) H
|− Aα = Bα
*(P2) H
|− Bα = Aα
Transformation: (P2 ss) ==> (P1 ss)
Sym=: P1
3.10. Definition Rules
EDEF
Rule to eliminate first definition, left to right.
*(D1) H
|− Aο
(D2) H
|− ‘(INST-DEF Aο)
Restrictions: (CONTAINS-DEFN Aο)
Transformation: (pp D1 ss) ==> (pp D2 ss)
Defn: D1
EQUIV-WFFS
Rule to assert equivalence of lines up to definition.
*(D1) H
|− Pο
(D2) H
|− Rο
Restrictions: (WFFEQ-DEF Pο Rο)
Transformation: (pp D1 ss) ==> (pp D2 ss)
IDEF
EquivWffs: D1
Rule to introduce a definition.
(P1) H
|− ‘(INST-DEF Aο)
*(P2) H
|− Aο
Restrictions: (CONTAINS-DEFN Aο)
Transformation: (P2 ss) ==> (P1 ss)
25
Defn: P1
ETPS User’s Manual
3.11. Lambda Conversion Rules
LAMBDA*
Rule to infer a line from one which is equal up to lambda conversion using both beta and eta rules and
alphabetic change of bound variables.
*(D1) H
|− Aο
(D2) H
|− Bο
Restrictions: (WFFEQ-AB-LAMBDA Aο Bο)
Transformation: (pp D1 ss) ==> (pp D2 ss)
BETA*
Lambda=: D1
Rule to infer a line from one which is equal up to lambda conversion using beta rule (but NOT eta rule)
and alphabetic change of bound variables.
*(D1)
H
|− Aο
(D2)
H
|− Bο
Beta Rule: D1
Restrictions: (WFFEQ-AB-BETA Aο Bο)
Transformation: (pp D1 ss) ==> (pp D2 ss)
ETA*
Rule to infer a line from one which is equal up to lambda conversion using eta rule (but NOT beta rule)
and alphabetic change of bound variables.
*(D1)
H
|− Aο
(D2)
H
|− Bο
Beta Rule: D1
Restrictions: (WFFEQ-AB-ETA Aο Bο)
Transformation: (pp D1 ss) ==> (pp D2 ss)
LCONTR*
Rule to put an inferred line into Lambda-normal form using both beta and eta conversion.
*(D1) H
|− Aο
(D2) H
|− ‘(LNORM Aο)
Transformation: (pp D1 ss) ==> (pp D2 ss)
Lambda: D1
LCONTR*-BETA
Rule to put an inferred line into beta-normal form.
*(D1) H
|− Aο
(D2) H
|− ‘(LNORM-BETA Aο)
Transformation: (pp D1 ss) ==> (pp D2 ss)
Lambda: D1
LCONTR*-ETA
Rule to put an inferred line into eta-normal form.
*(D1) H
|− Aο
(D2) H
|− ‘(LNORM-ETA Aο)
Transformation: (pp D1 ss) ==> (pp D2 ss)
LEXPD*
Lambda: D1
Rule to put a planned line into Lambda-normal form using both beta and eta conversion.
(P1) H
|− ‘(LNORM Aο)
*(P2) H
|− Aο
Transformation: (P2 ss) ==> (P1 ss)
26
Lambda: P1
Chapter 3: Inference Rules
LEXPD*-BETA
Rule to put a planned line into beta-normal form.
(P1) H
|− ‘(LNORM-BETA Aο)
*(P2) H
|− Aο
Transformation: (P2 ss) ==> (P1 ss)
Lambda: P1
LEXPD*-ETA
Rule to put a planned line into eta-normal form.
(P1) H
|− ‘(LNORM-ETA Aο)
*(P2) H
|− Aο
Transformation: (P2 ss) ==> (P1 ss)
27
Lambda: P1
ETPS User’s Manual
28
4. Sample Proofs
The following are transcripts of proofs of sample theorems obtained by using script before starting ETPS.
Remarks are added in italics. It may be a good idea to look ahead a little bit, i.e., look at the final proof first to see
what we are trying to obtain. You can execute these proof steps on your own computer and use the PALL command
frequently to get a good picture of how the proof grows, or (if you are running ETPS under X-windows or using the
Java interface) use the BEGIN-PRFW command to open proofwindows, and watch the proof grow in them. As
mentioned in Section 1.1, you will probably find it best to set the style flag to xterm and have logical formulas
displayed with logical symbols if you can. However, in this chapter we display formulas in generic style.
4.1. Example 1
>etps
etps for issar. Version from Saturday, September 23, 1989 at 5:59:15..
(c) Copyrighted 1988 by Carnegie Mellon University. All rights reserved.
****************************************************************************
WARNING -- Be sure that you when you begin ETPS, your current directory is
one for which you have write access, e.g., your home directory.
****************************************************************************
****************************************************************************
WARNING -- You cannot use the Unix ~ convention in specifying file names.
Use the full pathname instead, e.g., instead of entering
"~/foo.work", enter "/afs/andrew/usr11/dn0z/foo.work".
****************************************************************************
****************************************************************************
ANNOUNCING -- ETPS can now be run on the sun3_35 workstation type, as well
as on the Microvax.
The more memory on the machine, the faster ETPS will run. To
check the amount of memory available on a Sun-3, type
"/etc/dmesg | grep avail" in your typescript.
****************************************************************************
[Loading changes ...
...done]
Loading /afs/andrew.cmu.edu/math/etps/etps.ini
Finished loading /afs/andrew.cmu.edu/math/etps/etps.ini
If you are using ETPS in an environment where proofwindows are
available, issue the BEGIN-PRFW command now to open proofwindows.
<1>exercise x2108
(100)
! FORALL x EXISTS y.P x IMPLIES P y
PLAN1
Since this theorem is universally quantified, we will first use
universal generalization. Note that to accept the defaults that ETPS
offers, we just hit a <Return>.
<2>ugen
P2 (LINE): Universally Quantified Line [100]>
P1 (LINE): Line with Scope of Universal Quantifier [99]>
(99)
! EXISTS y.P x IMPLIES P y
As we will see later, the justification of line 100 has been changed
from PLAN1 to UGen, which stands for universal generalization.
Now the formula we are trying to prove is existentially quantified,
so we use the appropriate rule.
<3>egen
P2 (LINE): Existentially Quantified Line [99]>
29
PLAN2
ETPS User’s Manual
P1 (LINE): Line to be Existentially Generalized [98]>
t (GWFF): Term to be Generalized Upon [No Default]>(ED 99)
Let’s use the editor to pick out the term we want from line 99.
<Ed1>p
EXISTS y.P x IMPLIES P y
<Ed2>d
P x IMPLIES P y
<Ed3>l d
x
<Ed4>ok
(98)
! P x IMPLIES P x
Here’s the current formula.
We move inside the quantifier.
We use two commands to get to x.
Return x as the GWFF we were asked for.
PLAN3
All that remains is an easy application of RULEP.
<4>rulep
P1 (PLINE): Plan Line [98]>
L (EXISTING-LINELIST): List of Lines [()]>
<5>squeeze
SQUEEZE removes any unnecessary gaps. Now we take a look at the
completed proof.
<6>pall
(1)
(2)
(3)
! P x IMPLIES P x
! EXISTS y.P x IMPLIES P y
! FORALL x EXISTS y.P x IMPLIES P y
RuleP
EGen: x 1
UGen: x 2
<7>done
Score file updated.
The DONE command is crucial! Not only does it
verify that the proof is complete, it also ensures that you get credit
for doing it. Now let’s make a nice copy of the proof.
<8>texproof
FILENAME (FILESPEC): Filename [x2108.tex]>
Written file x2108.tex
<9>^Z
Let’s interrupt ETPS and print the current proof.
>tex x2108
This is TeX, Version 3.14159 (C version 6.1)
(x2108.tex
Hyphenation patterns for english, german, loaded.
(/afs/cs/project/tps/tps/doc/lib/tps.tex) [1] )
Output written on x2108.dvi (1 page, 628 bytes).
Transcript written on x2108.log.
>dvips x2108 -o x2108.ps
This is dvipsk 5.58f Copyright 1986, 1994 Radical Eye Software
’ TeX output 1998.09.04:1219’ -> x2108.ps
<tex.pro>. [1]
>lpr -Pprinter x2108.ps
We’ll now resume our ETPS session. The unix command fg continues the
last job that was interrupted.
30
Chapter 4: Sample Proofs
>fg
Let’s now prove this same theorem in a different way,
and save it in a new file.
<1>stop-save
File x2108.work written.
<2>save-work
SAVEFILE (FILESPEC): SAVE-WORK file [work.work]>"x2108b.work"
<3>exercise x2108
(100)
! FORALL x EXISTS y.P x IMPLIES P y
<4>indirect
P3 (LINE): Line to be Proven by Contradiction [100]>
P2 (LINE): Line with Contradiction [99]>
H1 (LINE): Line with Assumed Negation [1]>
(1)
1
! ~ FORALL x EXISTS y.P x IMPLIES P y
(99) 1
! FALSEHOOD
PLAN1
Assume negation
PLAN2
We can always use indirect proof.
As you can see, line 1 is negated, so let’s push in that negation.
<5>pushneg
D1 (LINE): Line with Negation [1]>
D2 (LINE): Line after Pushing in Negation one Step [2]>
(2)
1
! EXISTS x.~ EXISTS y.P x IMPLIES P y
Neg: 1
We use the ^P command to show the lines which are now relevant.
<6>^p
(2)
1
(99)
1
! EXISTS x.~ EXISTS y.P x IMPLIES P y
...
! FALSEHOOD
Neg: 1
PLAN2
RULEC is often required when trying to prove a statement
from an existentially quantified line. It is probably the most
complicated rule you will use, so you might wish to study the
description of RULEC in the previous chapter first, as well
the description in the textbook.
<7>rulec
P4 (LINE): Conclusion without Additional Hypothesis [99]>
D1 (LINE): Existentially Quantified Line [2]>
D3 (LINE): Conclusion with Additional Hypothesis [98]>
H2 (LINE): Hypothesis with Chosen Variable [3]>
y (GWFF): Chosen Variable Name [No Default]>"x"
(3)
1,3 ! ~ EXISTS y.P x IMPLIES P y
(98) 1,3 ! FALSEHOOD
Choose: x
PLAN5
The last command created a negated statement, so we can use
PUSHNEG again.
<8>pushneg 3 4
(4)
3,1 ! FORALL y.~.P x IMPLIES P y
Neg: 3
<9>ui
D1 (LINE): Universally Quantified Line [4]>
D2 (LINE): Instantiated Line [5]>
t (GWFF): Substitution Term [No Default]>"x"
(5)
1,3 ! ~.P x IMPLIES P x
31
UI: x 4
ETPS User’s Manual
<10>^p
(4)
3,1 ! FORALL y.~.P x IMPLIES P y
(5)
1,3 ! ~.P x IMPLIES P x
...
(98) 1,3 ! FALSEHOOD
Neg: 3
UI: x 4
PLAN5
Note that line 5 is a contradiction, so we can use it to justify
line 98 by RULEP. Line 4 isn’t necessary for this step.
<1>rulep 98
L (EXISTING-LINELIST): List of Lines [(5 4)]>(5)
<2>squeeze
<3>cleanup
No lines can be deleted.
CLEANUP will remove unnecessary lines and hypotheses from
your finished proof.
<4>pall
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
1
1
3
3
3
3
1
!
!
!
!
!
!
!
!
~ FORALL x EXISTS y.P x IMPLIES P y
EXISTS x.~ EXISTS y.P x IMPLIES P y
~ EXISTS y.P x IMPLIES P y
FORALL y.~.P x IMPLIES P y
~.P x IMPLIES P x
FALSEHOOD
FALSEHOOD
FORALL x EXISTS y.P x IMPLIES P y
Assume negation
Neg: 1
Choose: x
Neg: 3
UI: x 4
RuleP: 5
RuleC: 2 6
Indirect: 7
Have we finished?
<5>done
Score file updated.
Yes. Let’s make a nice copy of this proof. Note that we have
to specify a new file name to keep ETPS from overwriting
the first file we made.
<6>texproof
FILENAME (FILESPEC): Filename [x2108.tex]>"x2108b"
Written file x2108b.tex
If you have open proofwindows, close them now with the
command END-PRFW.
<7>exit
File x2108b.work written.
4.2. Example 2
>etps
etps for issar. Version from Saturday, September 23, 1989 at 5:59:15..
(c) Copyrighted 1988 by Carnegie Mellon University. All rights reserved.
****************************************************************************
WARNING -- Be sure that you when you begin ETPS, your current directory is
one for which you have write access, e.g., your home directory.
****************************************************************************
****************************************************************************
32
Chapter 4: Sample Proofs
WARNING -- You cannot use the Unix ~ convention in specifying file names.
Use the full pathname instead, e.g., instead of entering
"~/foo.work", enter "/afs/andrew/usr11/dn0z/foo.work".
****************************************************************************
****************************************************************************
ANNOUNCING -- ETPS can now be run on the sun3_35 workstation type, as well
as on the Microvax.
The more memory on the machine, the faster ETPS will run. To
check the amount of memory available on a Sun-3, type
"/etc/dmesg | grep avail" in your typescript.
****************************************************************************
[Loading changes ...
...done]
Loading /afs/andrew.cmu.edu/math/etps/etps.ini
Finished loading /afs/andrew.cmu.edu/math/etps/etps.ini
<1>prove
WFF (GWFF0): Prove Wff [No Default]>"exists x forall y P x y implies
forall y exists x P x y"
PREFIX (SYMBOL): Name of the Proof [No Default]>example1
NUM (LINE): Line Number for Theorem [100]>
(100)
! EXISTS x FORALL y P x y IMPLIES FORALL y EXISTS x P x y
PLAN1
If we were trying to prove one of the exercises in the text, we would
have used EXERCISE instead of prove.
Note that EXISTS (for example) was typed in lower case, but is always
printed in upper case.
<2>deduct
P3 (LINE): Line with Implication [100]>
D2 (LINE): Line with Conclusion [99]>
H1 (LINE): Line with Hypothesis [1]>
(1)
1
! EXISTS x FORALL y P x y
(99) 1
! FORALL y EXISTS x P x y
Hyp
PLAN2
DEDUCT is often the right way to start the proof of an implication.
Note that the defaults were just what we wanted anyway, so we selected
them by simply typing <Return>.
<3>ugen
P2 (LINE): Universally Quantified Line [99]>
P1 (LINE): Line with Scope of Universal Quantifier [98]>
(98) 1
! EXISTS x P x y
<4>rulec
P4 (LINE): Conclusion without Additional Hypothesis [98]>
D1 (LINE): Existentially Quantified Line [1]>
D3 (LINE): Conclusion with Additional Hypothesis [97]>
H2 (LINE): Hypothesis with Chosen Variable [2]>
y (GWFF): Chosen Variable Name [No Default]>"x"
(2)
1,2 ! FORALL y P x y
(97) 1,2 ! EXISTS x P x y
PLAN3
Choose: x
PLAN5
We now do a ^P (note that this is not a control-character) to
see what still has to be proven.
<5>^P
(2)
1,2 !
(97)
1,2 !
FORALL y P x y
...
EXISTS x P x y
Choose: x
PLAN5
33
ETPS User’s Manual
<6>ui 2
D2 (LINE): Instantiated Line [3]>
t (GWFF): Substitution Term [No Default]>"y"
(3)
2,1 ! P x y
UI: y 2
We are closing in. You can now see that line 97 follows immediately from
line 3 by existential generalization. Therefore we use the
EGEN command, and display the proof with the
PALL command.
<7>egen
P2 (LINE): Existentially Quantified Line [97]>
P1 (LINE): Line to be Existentially Generalized [96]>3
t (GWFF): Term to be Generalized Upon [No Default]>"x"
<8>pall
(1)
(2)
(3)
(97)
(98)
(99)
(100)
1
1,2
2,1
1,2
1
1
!
!
!
!
!
!
!
EXISTS
FORALL
P x y
EXISTS
EXISTS
FORALL
EXISTS
x FORALL y P x y
y P x y
Hyp
Choose: x
UI: y 2
x P x y
EGen: x 3
x P x y
RuleC: 1 97
y EXISTS x P x y
UGen: y 98
x FORALL y P x y IMPLIES FORALL y EXISTS x P x y
Deduct: 99
This is what our completed proof looks like. Let’s make sure that
we are done and print the proof into a file before exiting ETPS.
<9>done
You completed the proof. Since this is not an assigned exercise,
the score file will not be updated.
<10>texproof
FILENAME (FILESPEC): Filename [example1.tex]>
Written file example1.tex
<10>exit
4.3. Example 3
>etps
etps for issar. Version from Saturday, September 23, 1989 at 5:59:15..
(c) Copyrighted 1988 by Carnegie Mellon University. All rights reserved.
****************************************************************************
WARNING -- Be sure that you when you begin ETPS, your current directory is
one for which you have write access, e.g., your home directory.
****************************************************************************
****************************************************************************
WARNING -- You cannot use the Unix ~ convention in specifying file names.
Use the full pathname instead, e.g., instead of entering
"~/foo.work", enter "/afs/andrew/usr11/dn0z/foo.work".
****************************************************************************
****************************************************************************
ANNOUNCING -- ETPS can now be run on the sun3_35 workstation type, as well
as on the Microvax.
The more memory on the machine, the faster ETPS will run. To
check the amount of memory available on a Sun-3, type
"/etc/dmesg | grep avail" in your typescript.
34
Chapter 4: Sample Proofs
****************************************************************************
[Loading changes ...
...done]
Loading /afs/andrew.cmu.edu/math/etps/etps.ini
Finished loading /afs/andrew.cmu.edu/math/etps/etps.ini
<1>prove
WFF (GWFF0): Prove Wff [No Default]>"forall x [forall y P x y implies Q x x]
implies. forall z [P a z and P b z] implies . Q a a and Q b b"
PREFIX (SYMBOL): Name of the Proof [No Default]>example2
NUM (LINE): Line Number for Theorem [100]>
(100)
!
FORALL x [FORALL y P x y IMPLIES Q x x]
IMPLIES.FORALL z [P a z AND P b z] IMPLIES Q a a AND Q b b
PLAN1
This example does not involve an existential quantifier, but has a more
complicated structure. Since our theorem is an implication, we use the
deduction theorem again right away.
<2>deduct
P3 (LINE): Line with Implication [100]>!
(1)
1
! FORALL x.FORALL y P x y IMPLIES Q x x
(99) 1
! FORALL z [P a z AND P b z] IMPLIES Q a a AND Q b b
Hyp
PLAN2
Note that we used ! to specify that we want to choose the defaults
for the remaining arguments.
It is clear that we need to instantiate x with a and b.
We do this in the next two steps.
<3>ui
D1 (LINE): Universally Quantified Line [1]>!
Some defaults could not be determined.
t (GWFF): Substitution Term [No Default]>"a"
(2)
1
! FORALL y P a y IMPLIES Q a a
UI: a 1
We again used !, but ETPS couldn’t determine all the defaults,
so it prompted us again for the arguments for which it couldn’t figure
the defaults.
<4>ui
D1 (LINE): Universally Quantified Line [2]>1
D2 (LINE): Instantiated Line [3]>
t (GWFF): Substitution Term [No Default]>"b"
(3)
1
! FORALL y P b y IMPLIES Q b b
UI: b 1
The planned line 99 is again an implication, which suggests using
DEDUCT again.
<5>deduct
P3 (LINE): Line with Implication [99]>
D2 (LINE): Line with Conclusion [98]>
H1 (LINE): Line with Hypothesis [4]>
(4)
1,4 ! FORALL z.P a z AND P b z
(98) 1,4 ! Q a a AND Q b b
Hyp
PLAN5
We now use universal instantiation again, this time to distribute the
universal quantifier over a conjunction.
<6>ui
D1 (LINE): Universally Quantified Line [4]>
D2 (LINE): Instantiated Line [5]>
35
ETPS User’s Manual
t (GWFF): Substitution Term [No Default]>"y"
(5)
4,1 ! P a y AND P b y
UI: y 4
Just to make sure ECONJ is the inference rule we want, let’s call the
HELP command.
<7>help econj
*(D1) H
!A AND B
(D2) H
!A
(D3) H
!B
Transformation: (pp D1 ss) ==> (pp D2 D3 ss)
Conj: D1
Conj: D1
Yes, that’s what we need.
<8>econj
D1 (LINE): Line with Conjunction [5]>
D3 (LINE): Line with Right Conjunct [7]>
D2 (LINE): Line with Left Conjunct [6]>
(6)
1,4 ! P a y
(7)
1,4 ! P b y
Conj: 5
Conj: 5
Let’s look at the current planned line and its support lines.
<9>pplan
PLINE (PLINE): Print planned line [98]>
(1)
1
! FORALL x.FORALL y P x y IMPLIES Q x x
(2)
1
! FORALL y P a y IMPLIES Q a a
(3)
1
! FORALL y P b y IMPLIES Q b b
(4)
1,4 ! FORALL z.P a z AND P b z
(6)
1,4 ! P a y
(7)
1,4 ! P b y
...
(98) 1,4 ! Q a a AND Q b b
<10>iconj
P3 (LINE): Line with Conjunction [98]>
P2 (LINE): Line with Right Conjunct [97]>
P1 (LINE): Line with Left Conjunct [52]>
(52) 1,4 ! Q a a
(97) 1,4 ! Q b b
Hyp
UI: a 1
UI: b 1
Hyp
Conj: 5
Conj: 5
PLAN5
PLAN9
PLAN8
<1>mp
D2 (LINE): Line with Implication [6]>2
D3 (LINE): Line with Succedent of Implication [30]>52
P1 (LINE): Line with Antecedent of Implication [29]>
(29) 1,4 ! FORALL y P a y
<2>pplan
PLINE (PLINE): Print planned line [29]>
(1)
1
! FORALL x.FORALL y P x y IMPLIES Q x x
(3)
1
! FORALL y P b y IMPLIES Q b b
(4)
1,4 ! FORALL z.P a z AND P b z
(6)
1,4 ! P a y
(7)
1,4 ! P b y
...
(29) 1,4 ! FORALL y P a y
<3>ugen
P2 (LINE): Universally Quantified Line [29]>
P1 (LINE): Line with Scope of Universal Quantifier [28]>6
<4>pplan
PLINE (PLINE): Print planned line [97]>
36
PLAN11
Hyp
UI: b 1
Hyp
Conj: 5
Conj: 5
PLAN11
Chapter 4: Sample Proofs
(1)
(3)
(4)
(6)
(7)
(29)
(52)
1
1
1,4
1,4
1,4
1,4
1,4
!
!
!
!
!
!
!
(97)
1,4 !
FORALL
FORALL
FORALL
P a y
P b y
FORALL
Q a a
...
Q b b
x.FORALL y P x y IMPLIES Q x x
y P b y IMPLIES Q b b
z.P a z AND P b z
y P a y
Hyp
UI: b 1
Hyp
Conj: 5
Conj: 5
UGen: y 6
MP: 29 2
PLAN8
<5>mp
D2 (LINE): Line with Implication [52]>3
D3 (LINE): Line with Succedent of Implication [75]>97
P1 (LINE): Line with Antecedent of Implication [74]>
(74) 1,4 ! FORALL y P b y
PLAN14
<6>ugen
P2 (LINE): Universally Quantified Line [74]>
P1 (LINE): Line with Scope of Universal Quantifier [73]>7
The proof is complete. Let’s look at the entire proof.
<7>pall
(1)
1
(2)
1
(3)
1
(4)
1,4
(5)
4,1
(6)
1,4
(7)
1,4
(29) 1,4
(52) 1,4
(74) 1,4
(97) 1,4
(98) 1,4
(99) 1
(100)
!
!
!
!
!
!
!
!
!
!
!
!
!
!
FORALL x.FORALL y P x y IMPLIES Q x x
Hyp
FORALL y P a y IMPLIES Q a a
UI: a 1
FORALL y P b y IMPLIES Q b b
UI: b 1
FORALL z.P a z AND P b z
Hyp
P a y AND P b y
UI: y 4
P a y
Conj: 5
P b y
Conj: 5
FORALL y P a y
UGen: y 6
Q a a
MP: 29 2
FORALL y P b y
UGen: y 7
Q b b
MP: 74 3
Q a a AND Q b b
Conj: 52 97
FORALL z [P a z AND P b z] IMPLIES Q a a AND Q b b
Deduct: 98
FORALL x [FORALL y P x y IMPLIES Q x x]
IMPLIES.FORALL z [P a z AND P b z] IMPLIES Q a a AND Q b b
Deduct: 99
We’ll next use SQUEEZE to remove gaps from the proof structure.
We could also have used MODIFY-GAPS 1 1).
<9>squeeze
Let’s see how the proof looks now.
<10>pall
(1)
(2)
(3)
(4)
(5)
(6)
(7)
(8)
(9)
(10)
(11)
(12)
(13)
(14)
1
1
1
1,4
4,1
1,4
1,4
1,4
1,4
1,4
1,4
1,4
1
!
!
!
!
!
!
!
!
!
!
!
!
!
!
FORALL x.FORALL y P x y IMPLIES Q x x
FORALL y P a y IMPLIES Q a a
FORALL y P b y IMPLIES Q b b
FORALL z.P a z AND P b z
P a y AND P b y
P a y
P b y
FORALL y P a y
Q a a
FORALL y P b y
Q b b
Q a a AND Q b b
FORALL z [P a z AND P b z] IMPLIES Q a a AND Q b b
FORALL x [FORALL y P x y IMPLIES Q x x]
37
Hyp
UI: a 1
UI: b 1
Hyp
UI: y 4
Conj: 5
Conj: 5
UGen: y 6
MP: 8 2
UGen: y 7
MP: 10 3
Conj: 9 11
Deduct: 12
ETPS User’s Manual
IMPLIES.FORALL z [P a z AND P b z] IMPLIES Q a a AND Q b b
Deduct: 13
<1>done
You completed the proof. Since this is not an assigned exercise,
the score file will not be updated.
The proof is complete. Let’s print it into a file, so we can print it later
<2>printproof
FILENAME (FILESPEC): Filename [example2.prt]>
Written file example2.prt
<3>exit
38
5. Type Theory in ETPS
5.1. Using ETPS for Type Theory
ETPS can be used for higher-order logic as well as for first-order logic. Wffs of type theory are written
essentially as they are expressed in the logic book. There are a few additional inference rules and the parsing and
printing of wffs is slightly different, while everything else described in the previous chapters is still valid.
5.1.1. Types in Higher-Order Logic
There is a very direct translation from the way types are represented in the logic book and the way types are
represented in ETPS. Since Greek subscripts are not available on most terminals, the Greek letters are transliterated
to uppercase Roman letters. The most commonly used types are
I for ι
A for α
O for ο
B for β
S for σ
C for γ
The same conventions for parentheses are used as in the logic book, i.e., association to the left is assumed. Note,
however, that the outermost pair of parentheses must be preserved in order to distinguish types from identifiers.
Types are entered as strings, such as "(O(OA))"; typically they are substrings of a string representing a wff and
serve to give type information about the symbols in that wff, e.g., "p(O(OA))". If entered separately, the opening
and closing double-quotes must still be provided. Indeed, all of the string input rules apply; for example, carriage
returns may be embedded. For more examples of entering typed wffs, see Section 5.1.3.
ETPS has a powerful type-inference mechanism which makes explicit typing mostly unnecessary within wffs.
Often the type of one variable is enough to uniquely determine the type of every identifier in a wff. Within a wff, all
occurrences of a variable are assumed to have the same type, unless the contrary is specifically indicated. If the type
of a variable remains undetermined after all other type information has been used, ι is assumed. Take care to
specify types if you use ‘‘type variables’’ like α. Also note that type-inference is local, i.e., the type of an identifier
is determined anew for each wff parsed by ETPS.
5.1.2. Abbreviations and Special Symbols
ETPS allows polymorphic abbreviations. These are abbreviations with variable type, which may have multiple
occurrences with different types in the same wff. Since their special symbols cannot be typed on most keyboards,
there is a ‘‘long’’ form of each of them, which has to be used in ETPS. The following is a temporary list of special
symbols, the binary operators ordered according to their binding priority and abbreviations marked with (abb).
Improper symbols
λ
∀
∃
∃1
µ
LAMBDA
FORALL
EXISTS
EXISTS1
EXISTSN
FORALLN
MU-BIND
THAT
The λ-binder
Σ1ο(οα).λxα Aο
∃zσ.NAT z ∧ Aο
∀zσ.NAT z ⊃ Aο
muσ(οσ).λzσ Aο
ι.λzχ Aο
Unary operators with equal binding priority (except NOT which has the least binding priority):
~
NOT
39
ETPS User’s Manual
%
λfαβ λxοβ λzα ∃tβ.x t ∧ z = f t.
POWERSET
λpοαλqοα.q ⊆ p
∩ (abb)
SETINTERSECT
λsο(οα)λxα∀ pοα.s p ⊃ p x
Intersection of a collection of sets
∪ (abb)
SETUNION
λsο(οα)λxα∃pοα.s p ∧ p x
Union of a collection of sets
⊥
FALSEHOOD
T
TRUTH
% (abb)
℘
ο(οα)(οα)
(abb)
Binary operators, strongest binding first:
∩ (abb)
INTERSECT
λpοαλqοαλxα.p x ∧ q x
Intersection of two sets
∪ (abb)
UNION
λpοαλqοαλxα.p x ∨ q x
Union of two sets
⊆ (abb)
SUBSET
λpοαλqοα∀ xα.p x ⊃ q x
=οαα
=
Equality at type α
=S (abb)
SETEQUIV
λpοαλqοα.p ⊆ q ∧. q ⊆ p
Equality between sets.
=S (abb)
EQUIVS
λPοα λRοα ∀xα.P x ≡ R x
Elementwise equality between sets. This is equivalent to
equality between sets, if one assumes extensionality.
<= (abb)
<=
∧
AND
∨
OR
⊃
IMPLIES
≡ (abb)
EQUIV
λxσ λyσ ∀pοσ.p x ∧ ∀zσ [p z ⊃ p.SUCCσσ z] ⊃ p y
Less than or equal to, for natural numbers.
Equality at type o
Other abbreviations:
Conditional
COND
λxχ λyχ λpο THAT qχ.p ∧ x = q ∨ ∼p ∧ y = q
Equipollence
EQP
λpοβλqοα∃sαβ.∀xβ[p x ⊃ q.s x]∧ ∀yα.q y ⊃ ∃1xβ.p x ∧ y = s x
Zero
ZERO
[λpοι.∼∃xιp x]
40
Chapter 5: Type Theory in ETPS
Successor
SUCC
λnο(οι)λpοι∃ xι.p x ∧ n[λtι.t = x ∧ p t]
One
ONE
SUCCσσOσ
Finite
FINITE
λpοι ∃nο(οι).NAT n ∧ n p
µ
MU
λpοσ THAT xσ.NAT x ∧ p x ∧ FORALLN yσ.p y ⊃ x <= y
Natural No.
NAT
λnο(οι) ∀pοσ.p ZEROσ ∧ ∀xσ [p x ⊃ p.SUCCσσ x] ⊃ p n
NC
NC
Recursion
RECURSION
λhσσσ λgσ λnο(οι) THAT mσ ∀wοσσ.w ZEROσ g ∧ ∀xσ ∀yσ [w x y ⊃
w [SUCCσσ x].h x y] ⊃ w n m
Σ1
SIGMA1
[λpοα∃yα.pοα = .= y]
U
UNITSET
λxα λyα.x = y
λuο(οβ) ∃pοβ.u = Eο(οβ)(οβ) p
5.1.3. Some Examples of Higher-Order Wffs
Here are some examples of higher-order wffs. The first line shows how the formula is printed in the logic book,
the second line shows how it could be entered into ETPS as a string, and the third line shows how ETPS would print
it with type symbols (for example with the PWTYPES command). Look at these carefully and make sure you
understand how to type in wffs of higher-order logic.
∃fι(οι)∀Sοι.∃xι[S x] ⊃ S.f S
"EXISTS f FORALL S. EXISTS x S x IMPLIES S . f S"
EXISTS f(I(OI)) FORALL S(OI).EXISTS x(I)[S x] IMPLIES S.f S
∃fοι(ο(οι))∀Sο(οι).∃xοι[S x] ⊃ S.f S
"EXISTS f(OI(O(OI))) FORALL S. EXISTS x S x IMPLIES S.f S"
EXISTS f(OI(O(OI))) FORALL S(O(OI)).EXISTS x(OI)[S x] IMPLIES S.f S
∃fα(οα)∀Sοα.∃xα[S x] ⊃ S.f S
"EXISTS f FORALL S. EXISTS x(A) S x IMPLIES S.f S"
EXISTS f(A(OA)) FORALL S(OA).EXISTS x(A)[S x] IMPLIES S.f S
pο ≡ qο ≡ [λrολsο.[r ⊃ s] ∧.s ⊃ r] p q
"[p EQUIV q] EQUIV . [LAMBDA r LAMBDA s . [r IMPLIES s] AND .s IMPLIES r] p q"
p(O) EQUIV q(O)
EQUIV[LAMBDA r(O) LAMBDA s(O).[r IMPLIES s] AND.s IMPLIES r] p q
∀Aο∃fοι∀Pο(οι).P[λpι A] ≡ P f
"FORALL A(O) EXISTS f FORALL P . P [LAMBDA p A] EQUIV P f"
FORALL A(O) EXISTS f(OI) FORALL P(O(OI)).P[LAMBDA p(I) A] EQUIV P f
∀Aο∃fοο∀Pο(οο).P[λpο A] ≡ P f
41
ETPS User’s Manual
"FORALL A(O) EXISTS f(OO) FORALL P. P[LAMBDA p A] EQUIV P f"
FORALL A(O) EXISTS f(OO) FORALL P(O(OO)).P[LAMBDA p(O) A] EQUIV P f
5.2. Example of a Proof of a Higher-Order Theorem
The following is an annotated transcript of part of a proof in type theory. Basic familiarity with ETPS is assumed.
>etps
etps for issar. Version from Saturday, September 23, 1989 at 5:59:15..
(c) Copyrighted 1988 by Carnegie Mellon University. All rights reserved.
****************************************************************************
WARNING -- Be sure that you when you begin ETPS, your current directory is
one for which you have write access, e.g., your home directory.
****************************************************************************
****************************************************************************
WARNING -- You cannot use the Unix ~ convention in specifying file names.
Use the full pathname instead, e.g., instead of entering
"~/foo.work", enter "/afs/andrew/usr11/dn0z/foo.work".
****************************************************************************
****************************************************************************
ANNOUNCING -- ETPS can now be run on the sun3_35 workstation type, as well
as on the Microvax.
The more memory on the machine, the faster ETPS will run. To
check the amount of memory available on a Sun-3, type
"/etc/dmesg | grep avail" in your typescript.
****************************************************************************
[Loading changes ...
...done]
Loading /afs/andrew.cmu.edu/math/etps/etps.ini
Finished loading /afs/andrew.cmu.edu/math/etps/etps.ini
<1>Exercise X5209
(100)
!
POWERSET [D(OA) INTERSECT E(OA)]
= POWERSET D INTERSECT POWERSET E
PLAN1
<2>ext=
P2 (LINE): Line with Equality [100]>
P1 (LINE): Universally Quantified Equality [99]>
x (GWFF): Universally Quantified Variable [No Default]>"S(OA)"
(99)
! FORALL S(OA). POWERSET [D(OA) INTERSECT E(OA)] S
= [POWERSET D INTERSECT POWERSET E] S
PLAN2
<3>ugen !
(98)
!
POWERSET [D(OA) INTERSECT E(OA)] S(OA)
= [POWERSET D INTERSECT POWERSET E] S
PLAN3
<4>ext=0
P2 (LINE): Line with Equality [98]>
P1 (LINE): Line with Equivalence [97]>
(97)
!
POWERSET [D(OA) INTERSECT E(OA)] S(OA)
EQUIV [POWERSET D INTERSECT POWERSET E] S
PLAN4
<5>implics-equiv
P2 (LINE): Line with Equivalence [97]>
P1 (LINE): Line with Implications in Both Directions [96]>
(96)
!
[
POWERSET [D(OA) INTERSECT E(OA)] S(OA)
IMPLIES [POWERSET D INTERSECT POWERSET E] S]
AND.
[POWERSET D INTERSECT POWERSET E] S
IMPLIES POWERSET [D INTERSECT E] S
PLAN5
42
Chapter 5: Type Theory in ETPS
<6>iconj !
(48)
!
(95)
!
POWERSET [D(OA) INTERSECT E(OA)] S(OA)
IMPLIES [POWERSET D INTERSECT POWERSET E] S
PLAN7
[POWERSET D(OA) INTERSECT POWERSET E(OA)] S(OA)
IMPLIES POWERSET [D INTERSECT E] S
PLAN6
In this example we will prove only line 95. It may be a
a good exercise to try to prove line 48.
<7>subproof
PLINE (PLINE): Line to prove [48]>95
<8>deduct !
(49) 49
(94) 49
!
!
[POWERSET D(OA) INTERSECT POWERSET E(OA)] S(OA)
POWERSET [D(OA) INTERSECT E(OA)] S(OA)
Hyp
PLAN8
Now we eliminate the POWERSET. S is in the powerset
of D ∩ E iff S is a subset of D ∩ E.
<9>idef !
(93) 49
!
S(OA) SUBSET D(OA) INTERSECT E(OA)
PLAN9
Now we eliminate the INTERSECT from the justified line 49.
We therefore have to use the command symmetric to IDEF,
which is EDEF.
<10>edef !
(50) 49
!
<1>^P
(50) 49
!
(93)
49
<2>econj !
(51) 49
(52) 49
POWERSET D(OA) S(OA) AND POWERSET E(OA) S
Defn: 49
POWERSET D(OA) S(OA) AND POWERSET E(OA) S
...
! S(OA) SUBSET D(OA) INTERSECT E(OA)
Defn: 49
!
!
Conj: 50
Conj: 50
POWERSET D(OA) S(OA)
POWERSET E(OA) S(OA)
PLAN9
From here on we go through a sequence of routine elimination of definitions.
<3>edef !
(53) 49
S(OA) SUBSET D(OA)
Defn: 51
<4>edef
D1 (LINE): Line with Definition [53]>52
D2 (LINE): Line with Instantiated Definition [54]>
(54) 49
! S(OA) SUBSET E(OA)
Defn: 52
<5>^P
(53) 49
(54) 49
Defn: 51
Defn: 52
(93)
49
!
!
!
S(OA) SUBSET D(OA)
S(OA) SUBSET E(OA)
...
! S(OA) SUBSET D(OA) INTERSECT E(OA)
PLAN9
We are on the right track! From S ⊆ D and S ⊆ E we should be
able to infer that S ⊆ D ∩ E
<6>edef 53
D2 (LINE): Line with Instantiated Definition [55]>
(55) 49
! FORALL x(A).S(OA) x IMPLIES D(OA) x
<7>edef 54
D2 (LINE): Line with Instantiated Definition [56]>
43
Defn: 53
ETPS User’s Manual
(56)
!
FORALL x(A).S(OA) x IMPLIES E(OA) x
<8>idef !
(92) 49
!
FORALL x(A).S(OA) x IMPLIES [D(OA) INTERSECT E(OA)] x PLAN16
<9>^P
(55) 49
(56) 49
!
!
(92)
49
49
Defn: 54
FORALL x(A).S(OA) x IMPLIES D(OA) x
Defn: 53
FORALL x(A).S(OA) x IMPLIES E(OA) x
Defn: 54
...
! FORALL x(A).S(OA) x IMPLIES [D(OA) INTERSECT E(OA)] x PLAN16
We have to get rid of the universal quantifier, but we have to be careful to give
our variable the right type, namely α.
<10>ui 55
D2 (LINE): Instantiated Line [57]>
t (GWFF): Substitution Term [No Default]>"x(A)"
(57) 49
! S(OA) x(A) IMPLIES D(OA) x
UI: x 55
<1>ui 56
D2 (LINE): Instantiated Line [58]>
Let’s use the editor to extract the variable.
t (GWFF): Substitution Term [No Default]>(ed 56)
<Ed1>a
x(A)
<Ed2>ok
(58) 49
!
S(OA) x(A) IMPLIES E(OA) x
<2>ugen !
(91) 49
!
S(OA) x(A) IMPLIES [D(OA) INTERSECT E(OA)] x
PLAN19
<3>deduct !
(59) 49,59
(90) 49,59
!
!
S(OA) x(A)
[D(OA) INTERSECT E(OA)] x(A)
Hyp
PLAN20
<4>idef !
(89) 49,59
!
D(OA) x(A) AND E(OA) x
PLAN21
<5>^P
(55)
(56)
(57)
(58)
(59)
49
49
49
49
49,59
!
!
!
!
!
(89)
49,59
UI: x 56
FORALL x(A).S(OA) x IMPLIES D(OA) x
FORALL x(A).S(OA) x IMPLIES E(OA) x
S(OA) x(A) IMPLIES D(OA) x
S(OA) x(A) IMPLIES E(OA) x
S(OA) x(A)
...
! D(OA) x(A) AND E(OA) x
Defn:
Defn:
UI: x
UI: x
53
54
55
56
Hyp
PLAN21
We don’t need the universally quantified sponsoring lines any more
in order to prove line 89, so let’s use UNSPONSOR.
<6>unsponsor
PLINE (PLINE):Planned line [89]>
LINELIST (EXISTING-LINELIST): Sponsoring lines [(59 58 56 57 55)]>(55 56)
<7>rulep !
<8>pall
...
(48)
(49)
!
49
!
POWERSET [D(OA) INTERSECT E(OA)] S(OA)
IMPLIES [POWERSET D INTERSECT POWERSET E] S
[POWERSET D(OA) INTERSECT POWERSET E(OA)] S(OA)
44
PLAN7
Hyp
Chapter 5: Type Theory in ETPS
(50)
(51)
(52)
(53)
(54)
(55)
(56)
(57)
(58)
(59)
(89)
(90)
(91)
(92)
49
49
49
49
49
49
49
49
49
49,59
49,59
49,59
49
49
!
!
!
!
!
!
!
!
!
!
!
!
!
!
(93)
(94)
(95)
49
49
!
!
!
(96)
!
(97)
!
(98)
!
(99)
!
(100)
!
POWERSET D(OA) S(OA) AND POWERSET E(OA) S
Defn: 49
POWERSET D(OA) S(OA)
Conj: 50
POWERSET E(OA) S(OA)
Conj: 50
S(OA) SUBSET D(OA)
Defn: 51
S(OA) SUBSET E(OA)
Defn: 52
FORALL x(A).S(OA) x IMPLIES D(OA) x
Defn: 53
FORALL x(A).S(OA) x IMPLIES E(OA) x
Defn: 54
S(OA) x(A) IMPLIES D(OA) x
UI: x 55
S(OA) x(A) IMPLIES E(OA) x
UI: x 56
S(OA) x(A)
Hyp
D(OA) x(A) AND E(OA) x
Rulep: 59 58 57
[D(OA) INTERSECT E(OA)] x(A)
Defn: 89
S(OA) x(A) IMPLIES [D(OA) INTERSECT E(OA)] x
Deduct: 90
FORALL x(A).S(OA) x IMPLIES [D(OA) INTERSECT E(OA)] x
Ugen: x 91
S(OA) SUBSET D(OA) INTERSECT E(OA)
Defn: 92
POWERSET [D(OA) INTERSECT E(OA)] S(OA)
Defn: 93
[POWERSET D(OA) INTERSECT POWERSET E(OA)] S(OA)
IMPLIES POWERSET [D INTERSECT E] S
Deduct: 94
[
POWERSET [D(OA) INTERSECT E(OA)] S(OA)
IMPLIES [POWERSET D INTERSECT POWERSET E] S]
AND.
[POWERSET D INTERSECT POWERSET E] S
IMPLIES POWERSET [D INTERSECT E] S
Conj: 48 95
POWERSET [D(OA) INTERSECT E(OA)] S(OA)
EQUIV [POWERSET D INTERSECT POWERSET E] S
ImpEquiv: 96
POWERSET [D(OA) INTERSECT E(OA)] S(OA)
= [POWERSET D INTERSECT POWERSET E] S
Ext=: 97
FORALL S(OA). POWERSET [D(OA) INTERSECT E(OA)] S
= [POWERSET D INTERSECT POWERSET E] S
Ugen: S 98
POWERSET [D(OA) INTERSECT E(OA)]
= POWERSET D INTERSECT POWERSET E
Ext=: 99
<9>exit
45
ETPS User’s Manual
46
Appendix I
Appendix I
Amenities
.
ETPS incorporates several features of the Unix C-shell (csh) top-level. These features include various control
characters, command sequences, a history mechanism, and aliases.
I.1. Control characters for Unix
If you are running ETPS under Unix (or Linux), you may be able to use the following control characters in
addition to those discussed in Section 1.4.
Ctrl-S
Freeze output.
Ctrl-Q
Proceed with output.
Ctrl-Z
Suspend the current program (ETPS), and return to the monitor.
Ctrl-R
Redisplay the current input line.
I.2. Command Sequences
You may enter a series of commands on the same command line by using the ampersand (&) as a separator. This
is analogous to the C-shell’s use of the semicolon (;). That is, entering
<0> command1 & command2 & ... & commandn
will cause ETPS to sequentially execute command1 through commandn as though you had typed them in one at a
time.
For example, after you have finished a proof, you may want to enter the sequence:
<0> cleanup & squeeze & done & texproof !
I.3. History Substitutions
It is often convenient to be able to refer to commands and arguments that you have already typed. As in the
C-shell, the exclamation point (!) is used to indicate a history substitution, with two exceptions. An exclamation
point that is followed by whitespace will not be interpreted as a history reference, nor will an exclamation point that
is immediately preceded by a a backslash (\). Any input line that contains history substitutions will, before
execution, be echoed on the screen as it would appear without the history references.
In ETPS, each command line is given a unique number; this number is part of the top-level prompts. A certain
number of previous commands are saved by ETPS; the number saved is determined by the flag HISTORY-SIZE.
The previous command is always saved. In addition, each line is parsed into a series of tokens. Unlike the C-shell,
these tokens are not distinguished simply by surrounding whitespace, but rather by their Lisp syntax. All that the
user needs to know is that, in general, each argument entered on a command line will be considered a separate token.
On each input line, the tokens are numbered from left to right, beginning at 0. For example, the input line
<n> rulep 27 (1 2 7 14)
would be parsed into three tokens: rulep, 27 and (1 2 7 14), which would be numbered 0, 1 and 2,
47
ETPS User’s Manual
respectively.
The HISTORY command is used to examine the list of input lines that have been saved by ETPS. It takes two
arguments, the first being the number of lines to show (defaulting to the entire list), and the second being whether to
show them in reverse numerical order (defaulting to no). The number of each input line is also given. The lines are
saved in the history list as they appear after all history substitutions are made.
Previous lines can be referred to using the following input line specifiers:
!n
the command line whose number is n.
!-n
the input line that was entered n lines above the current one.
!!
the previous line.
!str
the most recent command that begins with the string str.
!?str?
the most recent command that has a token containing the substring str.
Here are some examples. Suppose we had the following output from the HISTORY command
<10> history 5 !
6 exercise x2106
7 pstatus
8 ^p
9 pall
10 history 5 !
Then, as input line 11, we could refer to line 7 by !ps or !-4, or even by !?tat?.
Used alone, the above references merely insert every token of the line referred to into the the current input line.
In order to select particular tokens from an input line, a colon (:) follows the input line specifier, along with a
selector for the intended tokens. Here is the syntax for the token selectors, where x and y indicate arbitrary token
selectors.
0
first (command) word
n
n’th argument
^
first argument, i.e. 1
$
last argument
%
word matched by (immediately preceding) ?str? search
x-y
range of words from the x’th through the y’th
-y
abbreviates 0-y
*
abbreviates ^-$, or nothing if only 1 word in input line referred to
x*
abbreviates x-$
x-
like x* but omitting word $
The : separating the event specification from the token selector can be omitted if the token selector begins with a
^, $, *, - or %.
Going back to our example, we can then create the input line
<11> help x2106
by entering help !5:*, or help !ex:$, or help !?2?%.
48
Appendix I
Here is a longer example of the use of history substitutions. We will omit the output of the commands
themselves, showing only the results of history substitutions in italics.
<38> prove "[[A and B] and C] implies [B or C]" foo 100
<39> deduct !!:$ 99 50
deduct 100 99 50
<40> econj !39:$ !
econj 50 !
<41> !e:0 !
econj !
<42> texproof "!?implies?:2_proof1.mss"
texproof "foo_proof1.mss"
One cautionary note: It is unwise to use absolute references to input line numbers (e.g., !25) in your work files,
because when the file is executed again, it is unlikely that a particular line numbered n will be the same as line n
was when the work file was created.
You may wish to know what a command history substitution will look like without executing it. In order to do
that, merely choose a word that is not a command (such as "foobar"), and prefix your history substitution by that
word. ETPS will first echo the substituted line, then just complain that "foobar" is an unknown command.
I.4. Aliases
ETPS maintains a list of aliases which can be created, printed and removed by the ALIAS and UNALIAS
commands. Each input line is separated into distinct commands and the first word of each command is checked to
see if it has an alias. If it does, then the text which is the alias for that command is reread with the history
mechanism available as though that command were the previous input line. The resulting tokens replace the
command and argument list. If no history references appear, then the argument list is not changed.
As an example, if the alias for ded is "deduct", the command ded 100 ! would be interpreted as deduct
100 !. If the alias for pr was "prove \!\!:1 foo 100", then pr x2106 would become prove x2106
foo 100. Note that any occurrences of ! in the alias definition that are meant to be expanded when the alias is
invoked must be escaped with a backslash (\) to keep them from being interpreted as history substitutions when the
alias is defined.
If an alias is found, the token transformation of the input text is performed and the aliasing process begins again
on the new input line. Looping is prevented if the first word of the new text is the same as the old by flagging it to
prevent further aliasing.
The command ALIAS can be used to create or display an alias, or to display all existing aliases. The command
UNALIAS can be used to delete an existing alias. The following example will illustrate:
We define an alias.
<135>alias d "deduct \!\!:1-$ \!"
We show its definition.
<136>alias !
d
deduct !!:1-$ !
<137>exercise x2106
<138>d
49
ETPS User’s Manual
This expands to "deduct !!:1-$ !" but here $ is 0.
TPS error while reading.
!!:1-$: Bad ! arg selector.
Last of range is less than first.
We’ll remove this definition, and try again.
<139>unalias d
The * selector is what we want.
<140>alias d "deduct \!\!:* \!"
<141>d
This expands to "deduct !", which is what we intend.
Suppose now that we have finished the proof.
<155>alias finish "cleanup & squeeze & done & pall & texproof \!\!:*"
T
<156>finish "myproof.mss"
50
Appendix II
Appendix II
More Editor Commands
The most commonly used editor commands were listed in Section 2.12. Here we list the rest of the commands
available in the editor. Note that some of the commands available within the editor are needed for type theory, and
may be ignored by the user who is interested only in first-order logic.
II.1. Labels
<Edn>DELWEAK label
Replace all occurrences of the label in the current edwff by the wff it represents.
<Edn>DW
Replace a top-level occurrence of label by the wff it represents.
<Edn>DW* Replace all labels in a wff by the wffs represented by them.
<Edn>NAME label
Assign a label to the edwff, and replace the edwff with this label.
<Edn>RW label
Makes current edwff the new value of label (which must already exist).
II.2. Basic Abbreviations
<Edn>EXPAND=
Instantiates all equalities.
<Edn>INST gabbr
Instantiate all occurrences of an abbreviation. The occurrences will be lambda-contracted, but not
lambda-normalized.
<Edn>INST1
Instantiate the first abbreviation, left-to-right.
<Edn>INSTALL exceptions
Instantiate all definitions, except the ones specified in the second argument.
II.3. Lambda-Calculus
<Edn>ABNORM
Convert the gwff to alphabetic normal form.
<Edn>ETAB gwff
Eta-expands until original wff is part of a wff of base type.
<Edn>ETAC
Reduces [lambda x.fx] to f at the top.
<Edn>ETAN
Reduces [lambda x.fx] to f from inside out.
<Edn>ETAX
Performs one step of eta expansion of the gwff.
<Edn>LEXP var term occurs
Converts the wff into the application of a function to the term. The function is formed by replacing
given valid occurrences of a term with the variable and binding the result.
<Edn>LNORM
Put a wff into lambda-normal form; equivalent to LNORM-BETA followed by LNORM-ETA.
<Edn>LNORM-BETA
51
ETPS User’s Manual
Put a wff into beta-normal form.
<Edn>LNORM-ETA
Put a wff into eta-normal form (exactly equivalent to ETAN).
<Edn>RED Lambda-contract a top-level reduct. Bound variables may be renamed.
II.4. Quantifier Commands
<Edn>DB
Delete the leftmost binder in a wff.
<Edn>EP
Delete all essentially existential quantifiers in a wff.
<Edn>OP
Delete the leftmost binder in a wff. Delete all essentially existential quantifiers in a wff.
II.5. Embedding Commands
There are a range of embedding commands, which take the current edwff and embed it below a quantifier or
connective. These commands all begin MBED, and then have a suffix denoting the quantifier or connective, and a
further suffix (if appropriate) denoting whether the current wff is to become the left or right side of the new formula.
They are:
<Edn>MBED-AL
Embed the current wff below AND, on the left side.
<Edn>MBED-AR
Embed the current wff below AND, on the right side.
<Edn>MBED-E
Embed the current wff below an EXISTS quantifier.
<Edn>MBED-E1
Embed the current wff below an EXISTS1 quantifier.
<Edn>MBED-F
Embed the current wff below a FORALL quantifier.
<Edn>MBED-IL
Embed the current wff below IMPLIES, on the left side.
<Edn>MBED-IR
Embed the current wff below IMPLIES, on the right side.
<Edn>MBED-L
Embed the current wff below a LAMBDA binder.
<Edn>MBED-OL
Embed the current wff below OR, on the left side.
<Edn>MBED-OR
Embed the current wff below OR, on the right side.
<Edn>MBED-QL
Embed the current wff below EQUIV, on the left side.
<Edn>MBED-QR
Embed the current wff below EQUIV, on the right side.
<Edn>MBED=L
Embed the current wff below =, on the left side.
<Edn>MBED=R
Embed the current wff below =, on the right side.
52
Appendix II
II.6. Changing and Recursive Changing Commands
Many of these commands operate only on the current wff, but have a recursive form that will perform the same
operation on the current wff and all of its subwffs.
<Edn>ASRB
Absorbs unnecessary AND and OR connectives; see the help message for examples. This command also
has a recursive form, ASRB*.
<Edn>ASSL
Applies the left associative law, changing (A * (B * C)) to ( (A * B) * C). This command
also has a recursive form, ASSL*.
<Edn>ASSR
Applies the right associative law, changing ( (A * B) * C) to (A * (B * C)) This command
also has a recursive form, ASSR*.
<Edn>CMRG
Deletes the constants TRUTH and FALSEHOOD from a wff; see the help message for examples. This
command also has a recursive form, CMRG*.
<Edn>CMUT
Applies the commutative laws to a formula; see the help message for examples. This command also
has a recursive form, CMUT*.
<Edn>CNTOP connective-or-quantifier
Changes the outermost connective or quantifier to that specified.
<Edn>DIST-CTR
Applies the laws of distributivity to a wff in the contracting direction; see the help message for
examples. This command also has a recursive form, DIST-CTR*.
<Edn>DIST-EXP
Applies the laws of distributivity to a wff in the expanding direction; see the help message for
examples. This command also has a recursive form, DIST-EXP*.
<Edn>DNEG
Removes a double negation from a wff. This command also has a recursive form, DNEG*.
<Edn>MRG Merges redundant connectives in a wff; see help message for examples. This command also has a
recursive form, MRG*.
<Edn>PMUT
Permutes the two components of an infix operator. This command also has a recursive form, PMUT*.
<Edn>SUBEQ
Reduces an equivalence to a conjunction of implications. This command also has a recursive form,
SUBEQ*.
<Edn>SUBIM
Reduces an implication to a disjunction. This command also has a recursive form, SUBIM*.
II.7. Miscellaneous
<Edn>CNF Find the conjunctive normal form of a wff.
<Edn>HEAD
Finds the head of a gwff.
<Edn>HVARS
Returns all the head variables of a gwff.
<Edn>MIN-SCOPE
Minimises the scope of quantifiers in a gwff.
53
ETPS User’s Manual
II.8. Wellformedness
<Edn>DUPW connective
Duplicates a wff across a connective.
<Edn>EDILL
Finds a minimal ill-formed subformula.
<Edn>ILL Returns a list of messages, each describing the error in a minimal ill-formed subformula.
<Edn>TP
Returns the type of a gwff.
<Edn>WFFP
Tests for a gwff (general well-formed formula).
II.9. Saving and Recording Wffs
Saving wffs into a file is governed by the two flags PRINTEDTFILE and PRINTEDTFLAG, which determine the
name of the file being written and whether or not wffs are currently being written to it, respectively.
<Edn>O
Toggles recording on and off (i.e. inverts the current value of PRINTEDTFLAG).
<Edn>REM string
Writes a comment into the current output file.
<Edn>SAVE label
Saves a gwff by appending it to the file savedwffs.
54
Appendix III
Appendix III
Wff Operations
This is a list of those wffops mentioned in Chapter 3; you can get a complete list of wffops by typing
ENVIRONMENT and then WFFOP.
III.1. Equality between Wffs
(WFFEQ-AB wff1 wff2)
Tests for equality modulo alphabetic change of bound variables.
(WFFEQ-AB-BETA wff1 wff2)
Tests for equality modulo alphabetic change of bound variables and beta-conversion.
(WFFEQ-AB-ETA wff1 wff2)
Tests for equality modulo alphabetic change of bound variables and eta-conversion.
(WFFEQ-AB-LAMBDA wff1 wff2)
Tests for equality modulo alphabetic change of bound variables and both beta- and eta-conversion.
(WFFEQ-DEF wff1 wff2)
Tests for equality modulo definitions, lambda conversion and alphabetic change of bound variables.
III.2. Predicates on Wffs
(FREE-FOR term var inwff)
Tests whether a term is free for a variable in a wff.
(IS-VARIABLE gwff)
Tests whether a wff is a logical variable.
(NON-ATOMIC gwff)
Tests whether a wff is not atomic, that is, negated, quantified or the result of joining two wffs with a
binary connective.
(NOT-FREE-IN gvar inwff)
Tests whether a variable is not free in a wff.
(NOT-FREE-IN-HYPS gvar)
Tests whether a variable is not free in the set of hypotheses of a rule.
(R-PRIME-RESTR term1 wff1 term2 wff2)
Verifies that wff2 follows from wff1 by Rule R’ using equality term1=term2.
(SAME-MODULO-EQUALITY wff1 wff2 term1 term2)
Verifies that wff2 follows from wff1 by Rule R’ (possibly iterated) using the equality term1=term2.
III.3. Substitution
(S term var inwff)
Substitute a term for the free occurrences of variable in a gwff.
III.4. Basic Abbreviations
(CONTAINS-DEFN wff)
Tests whether the argument contains a definition.
(INST-DEF inwff)
Instantiate the first abbreviation, left-to-right.
55
ETPS User’s Manual
III.5. Lambda-Calculus
(LCONTR reduct)
Lambda-contract a top-level reduct.
(LNORM wff)
Put a wff into lambda-normal form (equivalent to LNORM-BETA followed by LNORM-ETA).
(LNORM-BETA wff)
Put a wff into beta-normal form.
(LNORM-ETA wff)
Put a wff into eta-normal form.
III.6. Negation movers
(PUSH-NEGATION gwff)
Pushes negation through the outermost operator or quantifier.
56
Appendix IV
Appendix IV
Theorems and Exercises
IV.1. Book Theorems
Substitution instances of the theorems below can be inserted into a proof by using the ASSERT command.
DESCR
(Axiom of description at all types.)
ι [= Yοα] = Y
EXT (Axiom of extensionality at all types.)
∀xβ [fαβ x = gαβ x] ⊃ f = g
REFL= (Reflexivity of Equality.)
Aα = A
SYM= (Symmetry of Equality.)
Aα = Bα ⊃ B = A
T5302 (Symmetry of Equality.)
xα = yα =.y = x
T5310 (Theorem about descriptions.)
∀zα [pοα z ≡ yα = z] ⊃ ι p = y
T5310A (Theorem about descriptions.)
∀zα [pοα z ≡ z = yα] ⊃ ι p = y
IV.2. First-Order Logic
X2106
X2107
X2108
X2109
X2110
X2111
X2112
X2113
X2114
X2115
X2116
X2117
X2118
X2119
X2120
X2121
X2122
X2123
X2124
X2125
∀x [R x ⊃ P x] ∧ ∀x [∼ Q x ⊃ R x] ⊃ ∀x.P x ∨ Q x
R a b ∧ ∀x ∀y [R x y ⊃ R y x ∧ Q x y] ∧ ∀u ∀v [Q u v ⊃ Q u u] ⊃ Q a
a ∧ Q b b
∀x ∃y.P x ⊃ P y
∃x [p ∧ Q x] ≡ p ∧ ∃x Q x
∃x R x ∧ ∀y [R y ⊃ ∃z Q y z] ∧ ∀x ∀y [Q x y ⊃ Q x x] ⊃ ∃x ∃y.Q x y ∧
R y
∀x [∃y P x y ⊃ ∀y Q x y] ∧ ∀z ∃y P z y ⊃ ∀y ∀x Q x y
∃v ∀x P x v ∧ ∀x [S x ⊃ ∃y Q y x] ∧ ∀x ∀y [P x y ⊃ ∼ Q x y] ⊃ ∃u.∼ S
u
∀y ∃w R y w ∧ ∃z ∀x [P x ⊃ ∼ R z x] ⊃ ∃x.∼ P x
∀x R x b ∧ ∀y [∃z R y z ⊃ R a y] ⊃ ∃u ∀v R u v
∀x [∃y P x y ⊃ ∀z P z z] ∧ ∀u ∃v [P u v ∨ M u ∧ Q.f u v] ∧ ∀w [Q w ⊃
∼ M.g w] ⊃ ∀u ∃v.P [g u] v ∧ P u u
∀x ∃y [P x ⊃ R x [g.h y] ∧ P y] ∧ ∀w [P w ⊃ P [g w] ∧ P.h w] ⊃ ∀x.P
x ⊃ ∃y.R x y ∧ P y
∀u ∀v [R u u ≡ R u v] ∧ ∀w ∀z [R w w ≡ R z w] ⊃.∃x R x x ⊃ ∀y R y y
∀x [p ∧ Q x ∨ ∼ p ∧ R x] ⊃ ∀x Q x ∨ ∀x R x
∃y ∀x.P y ⊃ P x
∀u ∀v ∀w [P u v ∨ P v w] ⊃ ∃x ∀y P x y
∃v ∀y ∃z.P a y [h y] ∨ P v y [f y] ⊃ P v y z
∃x R x x ⊃ ∀y R y y ⊃ ∃u ∀v.R u u ⊃ R v v
∃y [P y ⊃ Q x] ⊃ ∃y.P y ⊃ Q y
∃x [P x ⊃ Q x] ≡ ∀x P x ⊃ ∃x Q x
∃x ∀y [P x ≡ P y] ≡.∃x P x ≡ ∀y P y
57
ETPS User’s Manual
X2126
X2127
X2128
X2129
X2130
X2131
X2132
X2133
X2134
X2135
X2136
X2137
X2138
∀x [P x ≡ ∃y P y] ≡.∀x P x ≡ ∃y P y
∃x ∀y [P y ≡ P x] ⊃ ∀x P x ∨ ∀x.∼ P x
∀x [P x ≡ ∀y P y] ≡.∃x P x ≡ ∀y P y
∃x ∀y [P x ≡ P y] ≡ [∃x Q x ≡ ∀y P y] ≡.∃x ∀y [Q x ≡ Q y] ≡.∃x P x
∀y Q y
∀x P x ⊃ ∼ ∃y Q y ∨ ∃z.P z ⊃ Q z
∀x P x ⊃ ∃y.∀x ∀z Q x y z ⊃ ∼ ∀z.P z ∧ ∼ Q y y z
∀w [∼ R w w] ⊃ ∃x ∃y.∼ R x y ∧.Q y x ⊃ ∀z Q z z
∀x [∃y Q x y ⊃ P x] ∧ ∀v ∃u Q u v ∧ ∀w ∀z [Q w z ⊃ Q z w ∨ Q z z]
∀z P z
∀z ∃x [∀y P x y ∨ Q x z] ⊃ ∀y ∃x.P x y ∨ Q x y
∃x ∀y.P x ∧ Q y ⊃ Q x ∨ P y
∃x ∃y ∀u.P x y z ⊃ P u x x
∃x ∀y.P x ⊃ Q x ∨ P y
∀x ∃y F x y ∧ ∃x ∀e ∃n ∀w [S n w ⊃ D w x e] ∧ ∀e ∃d ∀a ∀b [D a b d
∀y ∀z.F a y ∧ F b z ⊃ D y z e] ⊃ ∃y ∀e ∃m ∀w.S m w ⊃ ∀z.F w z ⊃ D
y e
≡
⊃
⊃
z
IV.3. Higher-Order Logic
X5200
X5201
X5202
X5203
X5204
X5205
X5206
X5207
X5208
X5209
X5210
X5211
X5212
X5304
X5305
X5308
X5309
X5310
X5500
X6004
X6101
X6104
X6105
xοα ∪ yοα = ∪.λvοα.v = x ∨ v = y
xοα ∩ yοα = ∩.λvοα.v = x ∨ v = y
% fαβ [xοβ ∪ yοβ] = % f x ∪ % f y
% fαβ [xοβ ∩ yοβ] ⊆ % f x ∩ % f y
% fαβ [∪ wο(οβ)] = ∪.% [% f] w
% fαβ [∩ wο(οβ)] ⊆ ∩.% [% f] w
% fαβ [xοβ ∪ yοβ] = % f x ∪ % f y
% fαβ [xοβ ∩ yοβ] ⊆ % f x ∩ % f y
∃Sοι ∀xι [[S x ∨ Pοι x] ∧.∼ S x ∨ Qοι x] ≡ ∀yι.P y ∨ Q y
℘
[Dοα ∩ Eοα] = ℘ D ∩ ℘ E
ο(οα)(οα)
[= xα] = λzα ∃yα.y = x ∧ z = y
yοα = ∪.λzοα ∃xα.y x ∧ z = [= x]
λzα ∃xβ [gοβ x ∧ z = fαβ x] = % f g
∼ ∃gοαα ∀fοα ∃jα.g j = f
∀sοα.∼ ∃gοαα ∀fοα.f ⊆ s ⊃ ∃jα.s j ∧ g j = f
∃jβ(οβ) ∀pοβ [∃xβ p x ⊃ p.j p] ⊃.∀xα ∃yβ rοβα x y ≡ ∃fβα ∀x r x.f x
∼∃hι(οι) ∀pοι ∀qοι.h p = h q ⊃ p = q
∀rοβ(οβ) [∀xοβ ∃yβ r x y ⊃ ∃fβ(οβ) ∀x r x.f x] ⊃ ∃jβ(οβ) ∀pοβ.∃zβ p z ⊃ p.j p
∀Pοβ [∃xβ P x ⊃ P.Jβ(οβ) P] ⊃ ∀fαβ ∀gαβ.f [J.λx.∼ f x = g x] = g [J.λx.∼ f
x = g x] ⊃ f = g
Eο(οα)(οβ) [= xβ].= yα
1 = Σ1ο(οι)
∃iο(αα)(αα).∀gαα [i g [λxα x] ∧ i g.λx g.g x] ∧ ∀fαα ∀yα.i [λx y] f ⊃ f y =
y
(This is a lemma for X6106. You may need to ASSERT DESCR or T5310 or T5310A)
∀nο(οι).NAT n ⊃ ∀qοι.n q ⊃ ∃jι(οι) ∀rοι.r ⊆ q ∧ ∃xι r x ⊃ r.j r
58
Appendix IV
X6106
X6201
X8030A
FINITE [λxι T] ⊃ ∃jι(οι) ∀rοι.∃x r x ⊃ r.j r
∃rοαα ∀xα ∀yα ∀zα [∃wα r x w ∧ ∼ r x x ∧.r x y ⊃.r y z ⊃ r x z] ⊃
∃Rο(οα)(οα) ∀Xοα ∀Yοα ∀Zοα.∃Wοα R X W ∧ ∼ R X X ∧.R X Y ⊃.R Y Z ⊃ R X Z
[gοο T ∧ g ⊥] = ∀xο g x
59
60
Index
CMRG*, Editor command 53
CMUT, Editor command 53
CMUT*, Editor command 53
CNF, Editor command 53
CNTOP, Editor command 53
COMPLETION-OPTIONS, Flag 4
COND, 40
CONTAINS-DEFN 55
Control characters 3, 47
Current subproof 10
CW, Editor command 6, 15
%, 40
⊥ 6, 21, 40
T 6, 40
~ 39
= 40
<= 40
0, Editor command 15
?, System Command 4, 9, 14
A, Editor command 15
AB, Editor command 15
AB*, Inference Rule 19, 23
ABE, Inference Rule 19, 23
ABNORM, Editor command 51
ABORT 4
ABSURD, Inference Rule 18, 22
ABU, Inference Rule 19, 23
ADD-HYPS, Inference Rule 18, 20
ADVICE, System Command 1, 9, 13
Alias 7
ALIAS, System Command 9, 49
AND, 40
ANYTHING, Argument Type 5
Argument Types
ANYTHING 5
BOOK-THEOREM 6
BOOLEAN 5
EXERCISE 6
EXISTING-LINE 5
EXISTING-LINELIST 6
FILESPEC 5
GVAR-LIST 7
GVAR 6
GWFF0 6
GWFF 5, 6
GWFFLIST 7
INTEGER+ 5
LINE-RANGE-LIST 6
LINE-RANGE 5
LINE 5
LINELIST 6
OCCLIST 6
PLINE 5
POSINTEGER 5
PRACTICE 6
STRING 5
SYMBOL 5
TEST-PROBLEM 6
TYPESYM 6
YESNO 5
ASRB, Editor command 53
ASRB*, Editor command 53
ASSERT, Inference Rule 18, 20
ASSL, Editor command 53
ASSL*, Editor command 53
ASSR, Editor command 53
ASSR*, Editor command 53
D, Editor command 15
DB, Editor command 52
DEDUCT, Inference Rule 18, 21, 33, 35, 43, 44
DELETE, System Command 12
DELETE*, System Command 12
DELETE-HYPS, Inference Rule 18, 20
DELWEAK, Editor command 51
DEPTH, System Command 12
DISJ-IMP, Inference Rule 18, 21
DIST-CTR, Editor command 53
DIST-CTR*, Editor command 53
DIST-EXP, Editor command 53
DIST-EXP*, Editor command 53
DNEG, Editor command 53
DNEG*, Editor command 53
DONE, System Command 9, 30, 32, 34, 38
DUPW, Editor command 54
DW, Editor command 51
DW*, Editor command 51
ECONJ, Inference Rule 18, 21, 36, 43
ED, 30
ED, System Command 14
EDEF, Inference Rule 19, 25, 43
EDILL, Editor command 54
EDWIN-CURRENT, Flag 15
EDWIN-TOP, Flag 15
EGEN, Inference Rule 19, 23, 29, 34
END-PRFW, System Command 1, 10
ENEG, Inference Rule 19, 22
EP, Editor command 52
EQP, 40
EQUIV, 40
EQUIV-IMPLICS, Inference Rule 18, 21
EQUIV-WFFS, Inference Rule 19, 25
EQUIVS, 40
ETA*, Inference Rule 26
ETAB, Editor command 51
ETAC, Editor command 51
ETAN, Editor command 51, 52
ETAX, Editor command 51
EXECUTE-FILE, System Command 7, 11
EXERCISE, Argument Type 6
EXERCISE, System Command 1, 9, 29, 31, 33, 42
EXISTING-LINE, Argument Type 5
EXISTING-LINELIST, Argument Type 7
EXISTS, 39
EXISTS1, 39
EXISTSN, 39
EXIT, System Command 3, 9, 10, 32, 34, 38
EXPAND=, Editor command 51
EXT=, Inference Rule 19, 24, 42
EXT=0, Inference Rule 19, 24, 42
BEGIN-PRFW, System Command 1, 10
BETA*, Inference Rule 26
BOOK-THEOREM, Argument Type 6
BOOLEAN, Argument Type 5
CASES, Inference Rule 18, 20
CHECK-STRUCTURE, System Command 13
CLEANUP, System Command 9, 32
CMRG, Editor command 53
FALSEHOOD, 6, 40
See also ⊥
FB, Editor command 15
61
LEMMA 18, 20
LET 19, 24
LEXPD*-BETA 26
LEXPD*-ETA 27
LEXPD* 19, 26
MP 18, 22, 36, 37
PULLNEG 19, 22
PUSHNEG 19, 22, 31
RULEC 19, 23, 31
RULEP 18, 19, 30, 32, 44
SAME 18, 20
SUBST-EQUIV 19, 25
SUBST= 19, 24
SUBST=L 19, 24
SUBST=R 19, 25
SUBSTITUTE 19, 24
SYM= 19, 25
UGEN 19, 23, 29, 36, 37, 42, 44
UI 19, 23, 31, 35, 44
INST, Editor command 51
INST-DEF 55
INST1, Editor command 51
INSTALL, Editor command 51
INTEGER+, Argument Type 5
INTERSECT, 40
INTRODUCE-GAP, System Command 13
IS-VARIABLE 55
FI, Editor command 15
FILESPEC, Argument Type 5
FINITE, 41
Flag 7
Flags 14
FORALL, 39
FORALLN, 39
FREE-FOR 55
Gaps 13
GVAR, Argument Type 6
GVAR-LIST, Argument Type 7
GWFF, Argument Type 5, 6
GWFF0, Argument Type 6
GWFFLIST, Argument Type 7
HEAD, Editor command 53
Help
See also ?
HELP, System Command 1, 9, 36
HISTORY, System Command 9, 48
HISTORY-SIZE, Flag 9, 47
HVARS, Editor command 53
HYP, Inference Rule 18, 20
IB, Editor command 15
ICONJ, Inference Rule 18, 21, 36
IDEF, Inference Rule 19, 25, 43, 44
ILL, Editor command 54
IMP-DISJ, Inference Rule 18, 21
IMPLICS-EQUIV, Inference Rule 18, 21, 42
IMPLIES, 40
INDIRECT, Inference Rule 18, 21, 31
INDIRECT1, Inference Rule 18, 22
INDIRECT2, Inference Rule 18, 22
INEG, Inference Rule 19, 22
Inference Rules
AB* 19, 23
ABE 19, 23
ABSURD 18, 22
ABU 19, 23
ADD-HYPS 18, 20
ASSERT 18, 20
BETA* 26
CASES 18, 20
DEDUCT 18, 20, 33, 35, 43, 44
DELETE-HYPS 18, 20
DISJ-IMP 18, 21
ECONJ 18, 21, 36, 43
EDEF 19, 25, 43
EGEN 19, 23, 29, 34
ENEG 18, 22
EQUIV-IMPLICS 18, 21
EQUIV-WFFS 19, 25
ETA* 26
EXT=0 19, 24, 42
EXT= 19, 24, 42
HYP 18, 20
ICONJ 18, 21, 36
IDEF 19, 25, 43, 44
IMP-DISJ 18, 21
IMPLICS-EQUIV 18, 21, 42
INDIRECT1 18, 21
INDIRECT2 18, 22
INDIRECT 18, 21, 31
INEG 19, 22
LAMBDA* 19, 26
LCONTR*-BETA 26
LCONTR*-ETA 26
LCONTR* 19, 26
JAVAWIN, System Command 1, 10
L, Editor command 15
LAMBDA, 39
LAMBDA*, Inference Rule 19, 26
LCONTR 56
LCONTR*, Inference Rule 19, 26
LCONTR*-BETA, Inference Rule 26
LCONTR*-ETA, Inference Rule 26
LEAVE, System Command 14
LEMMA, Inference Rule 18, 20
LET, Inference Rule 19, 24
LEXP, Editor command 51
LEXPD*, Inference Rule 19, 26
LEXPD*-BETA, Inference Rule 27
LEXPD*-ETA, Inference Rule 27
LINE, Argument Type 5
LINE-RANGE, Argument Type 5
LINE-RANGE-LIST, Argument Type 6
LINELIST, Argument Type 6
LIST, System Command 14
LIST-RULES, System Command 9
LNORM 56
LNORM, Editor command 51
LNORM-BETA 56
LNORM-BETA, Editor command 51
LNORM-ETA 56
LNORM-ETA, Editor command 51, 52
MBED-AL, Editor command 52
MBED-AR, Editor command 52
MBED-E, Editor command 52
MBED-E1, Editor command 52
MBED-F, Editor command 52
MBED-IL, Editor command 52
MBED-IR, Editor command 52
MBED-L, Editor command 52
MBED-OL, Editor command 52
MBED-OR, Editor command 52
MBED-QL, Editor command 52
MBED-QR, Editor command 52
MBED=L, Editor command 52
62
See also END-PRFW, EXIT, LEAVE, OK
MBED=R, Editor command 52
MIN-SCOPE, Editor command 53
MODIFY-GAPS, System Command 13, 37
MOVE, System Command 13
MOVE*, System Command 13
MP, Inference Rule 18, 22, 36, 37
MRG, Editor command 53
MRG*, Editor command 53
MU, 41
MU-BIND, 39
R, Editor command 15
R-PRIME-RESTR 55
RECONSIDER, System Command 9
RECURSION, 41
RED, Editor command 52
REM, Editor command 54
REMARK, System Command 9
RENUMBERALL, System Command 13
RESTORE-WORK, System Command 11, 13
RESTOREPROOF, System Command 2, 11
RESUME-SAVE, System Command 2, 11
RESUME-WORK, System Command 2
REVIEW, System Command 14
REW-EQUIV, Editor command 16
RIGHTMARGIN, Flag 14
RP, Editor command 16
RPALL, Editor command 16
RULEC, Inference Rule 19, 23, 31
RULEP, Inference Rule 18, 19, 30, 32, 44
RULEP-DELUXE, Function 19
RULEP-MAINFN, Flag 19
RULEP-SIMPLE, Function 19
RW, Editor command 51
NAME, Editor command 51
NAT, 41
NC, 41
NEG, Editor command 16
NEWS, System Command 9
NNF, Editor command 16
NON-ATOMIC 55
NOT, 39
NOT-FREE-IN 55
NOT-FREE-IN-HYPS 55
O, Editor command 54
OCCLIST, Argument Type 6
OK, Editor command 15
ONE, 41
OP, Editor command 52
OR, 40
S 55
SAME, Inference Rule 18, 20
SAME-MODULO-EQUALITY 55
SAVE, Editor command 54
SAVE-WORK, System Command 2, 3, 7, 11, 31
SAVEPROOF, System Command 2, 11
SCRIBEPROOF, System Command 12
SCRIPT, System Command 3, 11
SETEQUIV, 40
SETFLAG, System Command 14
SETINTERSECT, 40
SETUNION, 40
SHORT-HELP, Flag 9
SHOWNOTYPES, System Command 14
SHOWTYPES, System Command 14
SIGMA1, 41
Sponsor 10
SPONSOR, System Command 11
SQUEEZE, System Command 13, 30, 32, 37
Status 10, 17
STOP-SAVE, System Command 2, 3, 7, 11, 13, 31
STRING, Argument Type 5
SUB, Editor command 16
SUBEQ, Editor command 53
SUBEQ*, Editor command 53
SUBIM, Editor command 53
SUBIM*, Editor command 53
SUBJECTS, System Command 14
SUBPROOF, System Command 11, 43
SUBSET, 40
SUBST, Editor command 16
SUBST-EQUIV, Inference Rule 19, 25
SUBST=, Inference Rule 19, 24
SUBST=L, Inference Rule 19, 25
SUBST=R, Inference Rule 19, 25
SUBSTITUTE, Inference Rule 19, 24
SUBSTYP, Editor command 16
SUCC, 41
SUMMARY, System Command 9
SYM=, Inference Rule 19, 25
SYMBOL, Argument Type 5
P, Editor command 15
PALL, System Command 10, 12, 30, 32, 34, 37
PL, System Command 12
PL*, System Command 12
PLAN, System Command 12
Planned 10
PLINE, Argument Type 5
PLINE, System Command 12
PMUT, Editor command 53
PMUT*, Editor command 53
POP, System Command 4
POSINTEGER, Argument Type 5
POWERSET, 40
PP, Editor command 15
PPLAN, System Command 12, 36
PRACTICE, Argument Type 6
PRINTEDTFILE, Flag 54
PRINTEDTFLAG, Flag 54
PRINTLINEFLAG, Flag 10
PRINTPROOF, System Command 12, 38
PRINTTYPES, Flag 6
PROBLEMS, System Command 1, 5, 6, 9
PROOFLIST, System Command 9
PROOFW-ACTIVE, Flag 10
PROOFW-ACTIVE+NOS, Flag 10
PROOFW-ALL, Flag 10
PROVE, System Command 1, 9, 33, 35
PS, Editor command 15
PSTATUS, System Command 3, 10
PT, Editor command 15
PULL-NEG, Editor command 16
PULLNEG, Inference Rule 19, 22
PUSH, System Command 4
PUSH-NEG, Editor command 16
PUSH-NEGATION 56
PUSHNEG, Inference Rule 19, 23, 31
PW, System Command 12
PWSCOPE, System Command 12
PWTYPES, System Command 13
TEST-PROBLEM, Argument Type 6
TEXPROOF, System Command 12, 30, 32, 34
Quitting
63
THAT, 39
TP, Editor command 54
TRUTH, 6, 40
See also T
TYPESYM, Argument Type 6
UGEN, Inference Rule 19, 23, 29, 36, 37, 42, 44
UI, Inference Rule 19, 24, 31, 35, 44
UNALIAS, System Command 10, 49
UNDO 13
UNDO, Editor command 15
UNION, 40
UNITSET, 41
UNSCRIPT, System Command 11
UNSPONSOR, System Command 11, 44
WFFEQ-AB 55
WFFEQ-AB-BETA 55
WFFEQ-AB-ETA 55
WFFEQ-AB-LAMBDA 55
WFFEQ-DEF 55
WFFP, Editor command 54
XTR, Editor command 15
YESNO, Argument Type 5
ZERO,
40
^, Editor command 15
^P, System Command 10, 12, 31, 32, 33, 43
^PN, System Command 10, 12
64
Table of Contents
1. ETPS User Interface
1
1.1. Introduction
1.2. Saving and Restoring Your Work
1.3. Exiting and Reentering ETPS
1.4. Top-level Interaction
1.5. Using Commands and Defining Wffs
1.6. Flags and Amenities
1.7. Bugs and Error Messages
1
2
3
3
4
7
7
2. System Commands
9
2.1. Communication
2.2. Starting and Finishing
2.3. Starting the Java Interface
2.4. Proofwindows
2.5. The Current Subproof
2.6. Saving Work
2.7. Printing
2.8. Rearranging the Proof
2.9. Proof Assistance
2.10. Higher-Order Logic
2.11. Flags and Review
2.12. ETPS Editor
2.12.1. Top-Levels
2.12.2. Printing
2.12.3. Labels
2.12.4. Moving Commands
2.12.5. Substitution
2.12.6. Negation movers
9
9
10
10
10
11
12
12
13
13
14
14
15
15
15
15
15
16
3. Inference Rules
17
3.1. How to Read Inference Rules
3.2. Quick Reference to Rules
3.3. Special Rules
3.4. Miscellaneous Rules
3.5. Propositional Rules
3.6. Negation Rules
3.7. Quantifier Rules
3.8. Substitution Rules
3.9. Equality Rules
3.10. Definition Rules
3.11. Lambda Conversion Rules
17
18
19
20
20
22
23
24
24
25
26
4. Sample Proofs
29
4.1. Example 1
4.2. Example 2
4.3. Example 3
29
32
34
5. Type Theory in ETPS
39
5.1. Using ETPS for Type Theory
5.1.1. Types in Higher-Order Logic
5.1.2. Abbreviations and Special Symbols
5.1.3. Some Examples of Higher-Order Wffs
5.2. Example of a Proof of a Higher-Order Theorem
i
39
39
39
41
42
Appendix I. Amenities
47
I.1. Control characters for Unix
I.2. Command Sequences
I.3. History Substitutions
I.4. Aliases
47
47
47
49
Appendix II. More Editor Commands
51
II.1. Labels
II.2. Basic Abbreviations
II.3. Lambda-Calculus
II.4. Quantifier Commands
II.5. Embedding Commands
II.6. Changing and Recursive Changing Commands
II.7. Miscellaneous
II.8. Wellformedness
II.9. Saving and Recording Wffs
51
51
51
52
52
53
53
54
54
Appendix III. Wff Operations
55
III.1. Equality between Wffs
III.2. Predicates on Wffs
III.3. Substitution
III.4. Basic Abbreviations
III.5. Lambda-Calculus
III.6. Negation movers
55
55
55
55
56
56
Appendix IV. Theorems and Exercises
57
IV.1. Book Theorems
IV.2. First-Order Logic
IV.3. Higher-Order Logic
57
57
58
Index
61
ii
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement