Docstoc

blobLogic infoPack

Document Sample
blobLogic infoPack Powered By Docstoc
					Introduction
This document is divided into three sections:

1. Using blobLogic
2. blobLogic’s Rules
3. The blobLogic Console

Start by reading Using blobLogic for a quick overview of the blobLogic
interface. The section blobLogic’s Rules gives a detailed account of the rules
set used by the software in checking arguments in propositional and
predicate logics. The section The blobLogic Console is a brief guide to the
main blobLogic console panel and the icons it contains.

If you manage to find a bug, please email me with as much information as
you can remember about what you were doing when the bug appeared. How
long had you been using the software? What input did you supply? Did the
software become unusable? What sort of computer were you using? Which
operating system? Which internet browsing software?

If the software just won’t work on your computer, please let me know which
operating system you are using. (Do check the note for users of Mac OS X
on the blobLogic splash page.)

Thank you for helping to test blobLogic.

Corin Howitt
8th October 2002

corin.howitt@philosophy.ox.ac.uk
DRAFT DOCUMENT


Using blobLogic

Starting a new tree

Start a new tree by clicking the Tree Clear button   . Click the Key Map

button     to display the keyboard mappings for blobLogic’s set of logical

symbols.




                        Figure One: the Key Map window




Each pair of rows show logical symbols on the upper row and their keyboard

equivalents on the lower row. For example, to enter the symbol “ ” type

“£”. (Note that certain key mappings depend on the operating system that
you are using. The Key Map window will show the correct mappings for

your system.) The Key Map window may be moved elsewhere on the screen

by click-and-drag (click on the window then move the mouse while

continuing to hold down the mouse key). Once you’ve learned the key

mappings, hide the Key Map window by clicking         again.

Enter this argument exactly as shown:




Note that each expression in the argument is contained on its own line. Lines

may not contain more than one expression. So, for example, the following is

not allowed in blobLogic:




If you wish to combine expressions on a single line, you should conjoin

them. For example:
Comments

The symbol “;” declares that a comment follows. With certain restrictions

(to be discussed shortly) you may include anything you please as a

comment. These comment lines are all acceptable:




The restrictions on the content of comments arise from their use in declaring

conclusions and their use in declaring theorem source expressions.
Declaring the conclusion line

Conclusions may be declared in three ways: by sequent, by comment with

negation, and by comment without negation. These are arguments with

conclusions declared by sequent:




Notice that an argument may contain only a conclusion line, only premises,

or both premises and a conclusion. Tree proofs are tests for consistency; to

test an argument for validity, the conclusion must be negated. BlobLogic

automatically negates the conclusion if it is declared using a sequent. So an

argument entered as:
will be treated by blobLogic as equivalent to:




In short, don’t negate conclusions that you declare using a sequent,

blobLogic will do it for you.

      Conclusions may also be declared in a comment. The following are

arguments with conclusions declared in a comment:
The first three examples are equivalent to declaring the conclusion using a

sequent. In these cases, blobLogic negates the conclusion expression (if it

exists). If you want to make the negation explicit, you should declare the

conclusion using the comment “               ”. Conclusions declared in this

way will not be negated by blobLogic. These arguments are equivalent:
In the first two examples, blobLogic will negate the conclusion (so the

conclusion is     ); in the third example, blobLogic doesn’t negate the

conclusion (so the conclusion is again      ).

      To make argument entry more efficient, blobLogic only requires that

you enter the first one (for             ) or two (for             )

characters when declaring a conclusion in a comment. So these are all

acceptable conclusion declarations:
A corollary is that you must avoid comments which start “ ”, “ ”, “     ”, or

“   ” unless you wish to declare a conclusion. For example, blobLogic will

complain that you have declared more than one conclusion if you enter:




In this case, the conclusion has been declared twice; once using the sequent,

and once in the comment which starts “     ”.

      Both the expression part of a line and the conclusion part of a line

may include spaces. These arguments are all acceptable (if somewhat

unreadable):
Comments are not compulsory, aside from their role in declaring a

theorem’s source (to be discussed below).



Entering theorems


Theorems are expressions derived from other expressions in the tree by

applying the current logic’s rules of inference. Click on the Rules button

to display the rules of inference for both propositional and predicate logics.

This is what you should see:




                          Figure Two: the Rules window
Click on the text “      ” in the left-hand box. The biconditional rule should

appear on the right-hand side of the box, as shown above. Try it for the other

rules. As with the main blobLogic console and the Key Map window, you

may click-and-drag the Rules window around the screen. Hide the Rules

window by clicking       again.

      Theorems are entered in just the same way as premises and

conclusions with one further requirement: the source of the theorem must be

declared in the theorem’s comment. The source of a theorem is the

expression it was inferred from. Returning to the argument entered above,

your tree should look like this:




                 Figure Three: the tree before theorems are entered
There is one non-atomic expression in this argument, namely, the expression

“      ” at line one. The rule of inference for “         ” requires that we split

the tree. (Click on the rule “       ” in the Rules window if you can’t

remember the rule of inference for material conditional expressions.) Split

the tree by clicking on the lower (blue) blob of block one. Your tree should

now look like this:




                  Figure Four: the tree after adding two new blocks




Notice that each block is numbered; these block numbers are used in

referring to expressions.

      The whole tree may be moved by clicking-and-dragging the first

block’s upper (orange) blob, or the first block’s text. If you click-and-drag
on any other block’s upper blob (or its text) that block, together with all

blocks subordinate to it, will move. You may position the cursor in any

block by clicking with the mouse. Alternatively, you can use the tab key to

jump between blocks. You may also move the cursor within a block using

the arrow keys. As you enter or delete text in a block, all blocks subordinate

to that block will adjust their positions on the screen.

      Delete unwanted blocks by double-clicking on the lower blob of the

superordinate block (that is, the lower blob of the block above those you

wish to delete). For example, if you double-click on block one’s lower blob,

the two blocks just created will be deleted. Note that you cannot delete

blocks that contain text, so you must delete all text before attempting to

delete blocks. Double-clicking on a lower blob will delete all subordinate

blocks.

      Enter this text into blocks two and three:




(block 1)
(block two)




Your tree should now look like this:




               Figure Five: the tree after theorems have been entered


The numbers in the comment line of each theorem specify the location in the

tree of each theorem’s source. In this case, both theorems are derived from

the same source, namely, the expression at block one, line one. Every

theorem in the tree must declare its source in this way. The general form is:
BlobLogic requires that at least one character other than a space separates

the block value from the line value. These expressions are all acceptable

source declarations:




But these expressions are not acceptable source declarations:
If you make a mistake in declaring a theorem’s source, blobLogic will point

it out when you check the proof. The location of any expression in the tree

can be determined by clicking on it to locate the cursor in that expression.

The location of the cursor is displayed in the top left-hand corner of the

console report box.




Ticking used expressions

Source expressions which are used may be ticked, although blobLogic does

not require it. The only restriction is that you must not add more than one

tick to the expression part of a line. These expressions are acceptable:




But these expressions are not allowed:
Closure claims

Complete the tree by adding closure marks at the end of blocks two and

three. Your tree should now look like this:




             Figure Six: the tree after closure claims have been entered




Both paths close so the argument is valid. (Recall that the conclusion

expression is negated by blobLogic when it is declared as a sequent, so the

path ending at block three contains the expression         at block three, line one

which contradicts the (negated) conclusion           at block one, line three.)
         Each closure claim must be made on a separate line and may include

comments. No reference to a source expression is required. No expressions

may follow a closure claim (you’re claiming that the path ends with the

closure). If you violate any of these rules, blobLogic will indicate your

mistake.

         Before checking the syntax of the expressions in the tree, ensure that

the correct logic is selected. The currently selected logic is displayed in the

top right-hand corner of the report box. Click the Change Logic button            to

cycle through the available logics. To check the tree you have just entered,

stop clicking when you reach “Propositional Calculus”. If you check syntax

or a proof when an inappropriate logic is selected, blobLogic will usually

suggest that you switch to a different logic.




Checking syntax

Check the syntax of each expression in the tree by clicking the Check Wff

button      . The result should be a tree that looks like this:
                     Figure Seven: the tree after checking syntax




Lines are coloured green if they pass the syntax checks without errors and

without warnings. Click on each line to view its syntax report. The syntax

check will colour each line as follows:




Colour       Indication

Red          Syntax error of some kind. Click on the line to find out what’s

             wrong

Amber        The expression is a well-formed formula (wff) but there are

             stylistic concerns (for example, too many brackets)
Green         The expression is a wff




Note that the syntax checker does not check the proof, but only the syntax of

each expression in the tree together with the positional correctness of closure

claims.




Brackets, Operators, and Names

You can control, to a certain extent, which symbols are allowed in

blobLogic expressions and how they may be combined. BlobLogic will

remember your preferences between sessions, so you only need to set them

once.

        Click the Relaxed Brackets button    to allow square [ ] and curly { }

brackets in addition to curved ( ) brackets. If you have switched Relaxed

Brackets on, the Relaxed Brackets button will turn red. The following

expressions will be syntactically acceptable only when relaxed brackets are

allowed:
Notice that blobLogic will pay attention only to the function of a bracket

(that is, whether it is an opening or closing bracket), so you may freely mix

curved, square, and curly brackets in expressions (if you have switched

Relaxed Brackets on). In general, blobLogic will expect you to enclose each

sub-expression in brackets; but you need not enclose the whole expression in

brackets (unless you really want to). The following are equally acceptable:




And the expression below is syntactically acceptable (that is, it is a wff), but

will generate a style warning for excessive use of brackets:
((




But this expression will generate an error for insufficient use of brackets:




Click the Relaxed Operators button      to allow a wider range of logical

operators. If you have switched Relaxed Operators on, the Relaxed

Operators button will turn red. The following expressions will be

syntactically acceptable only when relaxed operators are allowed:




Conjunction




Disjunction




Material Conditional




Biconditional
Negation




When constructing trees in a propositional calculus, click on the Relaxed

Names button    to allow lower-case names for propositions. The following

expressions will be syntactically acceptable only when relaxed names are

allowed:




Upper- and lower-case names may be mixed freely. If the logic is

subsequently changed to a Predicate logic, relaxed names are disallowed.
Checking proofs

Check the proof by clicking the Check Proof button            . The tree should

remain green:




                    Figure Eight: the tree after proof-checking




The proof check will colour each line as follows:




Colour      Indication

Red         The line failed the syntax check or failed one of the tests

            applied during the proof check. Click on the line to find out

            what’s wrong
Amber        The expression was correctly derived from its source but

             there are minor errors of some kind. (For example, the

             derivation which resulted in the line did not contribute to the

             closure of the tree and was thereby superfluous.)

Green        The expression was correctly derived from its source

Blue         The expression is an unused non-atomic expression

Black        The proof checker found an error before it managed to check

             this expression




The proof checker starts by running a syntax check. If there are no syntactic

errors in the tree, the proof checker works its way through the proof, until it

finds an error or reaches the end of the tree. The proof checker will usually

colour both a theorem expression and its source red to indicate the

relationship between the expressions. Where an expression is missing at the

end of a path, blobLogic will usually colour the last expression on that path

red (even if the last expression on the path is correct). Read each line’s

comments in the report box to determine why an error occurred.
      The tree can be returned to black, and the comments generated by the

syntax checker and the proof checker cleared, by clicking on the Clear

Colour button     . The Clear Colour button has no effect on the tree itself, it

merely changes the tree’s colouring and deletes each line’s report.

      If you edit the tree after it has been coloured by a checking routine,

blobLogic will delete a line’s colour and report when the line itself is

deleted. If you insert a line in a coloured block, the new line will be coloured

black. To colour the line (and obtain a report on its contents) you must click

either the Check Wff or the Check Proof button.

      Where a tree doesn’t close, blobLogic will generate an error if there

are unused expressions remaining in the tree. In case all expressions have

been used and the tree still doesn’t close, blobLogic will generate counter-

example sets for Propositional arguments. Each set of counter-examples is

included in the report of the last expression on its path.
Saving and Opening Trees

Save your work by clicking the Save button       . This is what will appear:




                          Figure Nine: the Save window




Type “modus ponens (prop)” into the Save file as box then click on the Save

button. The window will disappear as the file is saved. You may include

comments with each file, to be displayed when the file is selected in the

Open window, by entering them in the Comments box when you save the

tree.
      You can check that the file was saved by clicking on the Open button

   to summon the Open window:




                          Figure Ten: the Open window




Notice that your file “modus ponens (prop)” appears at the top of the filelist.

(Obvious if it is your first tree!) Any comments associated with the file are

displayed in the Comments box. You can open your file by clicking the

Open button, or by double-clicking on your file’s name in the filelist.
      If you want to save the current tree under a different name, click the

Save As button     . This is the window that will appear:




                        Figure Eleven: the Save As window




The current tree’s save name is displayed in the Save File As box. Type a

name (and add any comments in the Comments box) then click the Save

button.

      As far as blobLogic is concerned, a tree’s filename may contain up to

25 characters. If you encounter errors when using long filenames, it is likely
that your computer’s operating system can’t cope with filenames that long.

The solution is to use shorter filenames (or buy a better computer). If your

computer does insist on short filenames, use the Comments box to add more

information; a comment is stored in the file itself so is unaffected by the

computer’s filename requirements.

      BlobLogic also allows trees to be downloaded over the web. If you

have an internet connection, click on the Open Web button              . The

following window will appear:




              Figure Twelve: the Open Web window – fetching the filelist
BlobLogic will then attempt to connect to the internet. BlobLogic uses your

computer’s internet settings, so it will connect to whichever internet account

is currently selected when you click Open Web. If there’s a problem in

making the connection, blobLogic will display an error message which sets

out what went wrong.

      Once the connection to the internet is established, blobLogic will

download the list of files available on the server. The Open Web window

will then look like this:




               Figure Thirteen: the Open Web window – selecting a file
Select a file from the filelist using the mouse. Download the file either by

double-clicking on the filename in the filelist or by clicking Open. The

Open Web window will then look like this:




               Figure Fourteen: the Open Web window – fetching a file




When the file has been acquired, the Open Web window will disappear, and

the downloaded tree will be displayed. Note that blobLogic will leave your

internet connection active so you must disconnect manually as required.
Remember to save the downloaded tree on your computer (using either Save

or Save As).


Demo Mode

In addition to tree editing mode, blobLogic includes two further modes:

Demo Mode and Tutorial Mode. Demo mode presents demonstrations of

proofs and derivations which are embedded in the tree file. You may step

through the demo manually or have blobLogic auto-step through the demo at

a rate that you determine. Demo mode only applies to files that have demo

information stored. If you try to play a demo from a file that doesn’t contain

demo information, blobLogic will indicate that there is no demo to be

played. Demos are created and edited using the application version of

blobLogic (as opposed to the version which works inside a web page).

      To view a demo version of the tree you have entered, download the

file “modus ponens (prop)” over the internet as set out above. When the tree

has loaded, click on the Demo Mode button      . If there is demo information

stored, the tree will change, and the Demo Mode button’s dot will turn red to
indicate that you are in demo mode. To return to edit mode, click      again.

Switching to and from demo mode will not affect any information that you

have entered in edit mode, your tree will be restored when you switch back

to edit mode.

      In this case, the demo follows the development of the proof as you

have entered it above. It will often be the case that the demo does not

develop the argument set out in edit mode, but instead develops a related

argument. In fact, the information stored in the tree file which constitutes the

demo is entirely separate from the information which constitutes the tree, so

the demo can, in principle, be entirely unrelated to the tree.

      To step through the tree manually, click the Step button . Each time

you click the Step button, the demo advances by one step. Each step may

comprise the addition of a tree expression, narrative comments, the

application of a rule of inference, the display of the rules box, checking the

proof, and so on. Any step that can be applied in edit mode can be presented

in demo mode. When the end of the demo is reached, clicking the Step

button restarts the demo from the beginning.
         The demo can be auto-stepped by clicking on the Play button .

BlobLogic will automatically step through the demo at regular intervals. The

time between steps is controlled by the Speed slider      . With the slider

handle positioned at its left limit, the demo will advance at a rate of about

one step every eight seconds. With the slider handle positioned at its right

limit, the demo will advance at a rate of about one step every two seconds.

Clicking on the Step button when the demo is auto-stepping advances the

demo by one step (and the demo will continue to auto-step). Click on the

Pause button to pause the demo at its current step. Restart the demo from

the step at which it was paused by clicking the Pause button again. Clicking

the Play button when the demo is playing (or when it is paused) will restart

the demo from the beginning. Stop the demo by clicking the Stop button          .

The Stop button will always return the demo to the beginning.

         Note that you cannot access any of the console functions when in

Demo Mode. (That’s because console functions are under the control of the

demo.) Demo information is saved with the tree information when the tree is

saved.
Tutorial Mode

Tutorial Mode presents a series of interactive tutorials and exercises which

are embedded in the tree file. You may step forwards and backwards through

the tutorials saved with each tree file. Tutorial mode only applies to files that

have tutorial information stored. If you try to switch to tutorial mode when

working with a file that doesn’t contain tutorial information, blobLogic will

indicate that there is no tutorial to be displayed. As with demos, tutorials are

created and edited using the application version of blobLogic (as opposed to

the version which works inside a web page).

      To use some tutorials, download the file “modus ponens (prop)” over

the internet as set out above. When the tree has loaded, click on the Tutorial

Mode button      . If there is tutorial information stored, a tutorial will be

displayed on the screen and the tutorial mode button’s cross will turn red to

indicate that you are in tutorial mode. To return to edit mode, click

again. Switching to and from tutorial mode will not affect any information
that you have entered in edit mode, your tree will be restored when you

switch back to edit mode.

       Step between tutorials using the Next Tutorial button     and Previous

Tutorial button    . Repeatedly clicking either button will cycle through all

tutorials stored with the current tree file.

       There are many kinds of tutorial; we will consider just two below.

The following is an interactive tutorial on quantifier scope:




                           Figure Fifteen: a Scope Tutorial
Click-and-drag the right-hand arrows to indicate the scope of each

quantifier. Click the CHECK button to check your answer. Remember to

click CHECK each time you make a change.

      The following tutorial presents an exercise on categorising arguments:




                    Figure Sixteen: a Multiple Choice Tutorial
blobLogic’s rules

BlobLogic uses the rule set developed from Evert Beth’s method of semantic

tableaux by Richard Jeffrey in his book Formal Logic: Its Scope and Limits,

(New York, New York: McGraw Hill, 1991, 3 rd edition), with one

modification to the rule EI.


Initial rules

The following rules of inference may be applied to any unused expression of

the appropriate form; the resultant theorem must be added at the bottom of

all subordinate open paths.




    Φ

Φ


Φ Ψ                   Φ Ψ

Φ                    Φ    Ψ
Ψ


Φ Ψ                   Φ Ψ
Φ Ψ                 Φ
                    Ψ
Φ   Ψ               Φ    Ψ

 ΦΨ                Φ
                    Ψ


Φ   Ψ                Φ    Ψ

Φ    Φ              Φ     Φ
Ψ    Ψ             Ψ      Ψ



Universal Instantiation (UI)




For all and any names n appearing in the path, write the expression …n… at

the bottom of the path unless the expression …n… already appears on the

path. If no names appear on the path, choose a name n and write the

expression …n… at the bottom of the path. UI may be applied piecemeal,

that is, the expression …n… may be added to one or more subordinate open

paths.
Existential Instantiation (EI)




Write the expression …n… at the bottom of all subordinate open paths. Each
instance of the expression     must contain a name n that is new to its
path.



Identity




Given an expression (1) of the form          and an expression (2) of the form
        or        on an open path, write the expression (2) with constants
substituted throughout at the end of the path, unless the resulting expression
already exists on the path. Note that blobLogic expects the resulting theorem
to refer to the identity (i.e. expression (1)) as its source rather than to
expression (2). Theorems derived from identities may also may also be
added piecemeal to the tree.
Closure

 Φ

Φ




Variables and Constants

Variable names:

Constant names:
The blobLogic Console




File

       New Tree   Clear the current tree.

       Open       Open a tree stored on your computer.

       Open Web   Open a tree stored on a Web server. Requires an
                  Internet connection to work. You must save the
                  tree on your computer if you want to keep it
                  locally.

       Save       Save the current tree to your computer.

       Save As    Save the current tree to your computer under a new
                  name.

       Save Web   Save the current tree to a Web server. Not
                  available in the trial version of blobLogic.
Tree

       Check Wff      Check the syntax of all expressions in the current
                      tree. Expressions with errors are coloured red;
                      expressions with stylistic problems are coloured
                      amber; all other expressions are coloured green. If
                      you see lots of red, make sure that you’ve selected
                      the correct logic. Click on an expression to see
                      blobLogic’s comments.

       Check Proof    Check the tree for derivational correctness.
                      If the tree contains syntax errors, clicking this
                      button will have the same effect as clicking
                      “Check Wff”. Otherwise, blobLogic checks each
                      derivation for correctness. Errors are coloured red;
                      superfluous derivations are coloured amber;
                      unused expressions are coloured blue; unchecked
                      expressions are coloured black; all other
                      expressions are coloured green. Again, click on an
                      expression to see blobLogic’s comments.

       Clear Colour   Return the tree to black and clear all feedback
                      comments from the tree.

       Change Logic   Cycle through available logics: Propositional
                      logic, predicate logic, propositional modal,
                      predicate modal. Only syntax checking is available
                      for modal logics in the trial version of blobLogic.
Preferences

    Key Map           Display or hide a map of the keyboard assignments
                      of the logical symbols.

    Relaxed Brackets Allow or disallow square brackets [] and curly
                     brackets {} in expressions. Note that they can be
                     mixed freely if allowed at all.

    Relaxed Operators Allow or disallow a wider range of symbols for the
                      logical constants. See Using blobLogic for details.

    Relaxed Names     Allow or disallow lower-case names in the
                      propositional calculus.

    Rules             Display or hide the tree rules.



Demo Mode

    Demo Mode         Switch Demo Mode on or off.

    Stop              Stop the currently playing demo.

    Play              Play the current demo.

    Pause             Pause the currently playing demo.

    Step              Advance to the next step in the current demo.

    Speed             Control the speed at which the current demo plays.
Tutorial Mode

    Tutorial Mode      Switch Tutorial Mode on or off.

    Previous Tutorial Step to the previous tutorial.

    Next Tutorial      Step to the next tutorial.

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:9
posted:3/10/2011
language:English
pages:46