Google
 

Trailing-Edge - PDP-10 Archives - decuslib10-06 - 43,50442/venn.sim
There are 2 other files named venn.sim in the archive. Click here to see a list.
COMMENT OPTIONS(/-A/-D/-I/-Q);
COMMENT-----------------------------------------------------------------------

VENN Version 1 (c) copyright 1977 by its author, Dr. Walter Maner, Department
of Philosophy, Old Dominion University, Norfolk, VA. 23508. TEL: (804) 489-6517

Use of this program implies an agreement to report all program errors and
modifications directly to the author.  A FILCOM listing of the differences
between the original version and the new version is the preferred vehicle.
Modifications must leave notices of copyright and related warnings intact.
In particular, the run-time program header must not be suppressed or altered.
Copying of this progam for use on another system IS permitted PROVIDED the
author is merely notified that a copy is about to be made, and for whom.
Failure to comply with these requests WILL CONSTITUTE A VIOLATION OF COPYRIGHT.


DOCUMENTATION:  In addition to the internal documentation, users should
consult VENN.DOC.

PEAK CORE REQUIREMENT:     47+12P (30K) without OPTIONS (in other words, as is)
or 42+12P (27K) with OPTIONS (initial "COMMENT " deleted)

------------------------------------------------------------------------------;

BEGIN

   EXTERNAL INTEGER PROCEDURE
   trmop,
   scanint;

   EXTERNAL LONG REAL PROCEDURE
   scanreal;

   EXTERNAL REAL PROCEDURE
   clocktime;

   EXTERNAL TEXT PROCEDURE
   conc,
   rest,
   upcase;

   EXTERNAL PROCEDURE
   sleep;

   EXTERNAL CLASS
   safmin;
   COMMENT-----------------------------------------------------------------
   This subset of the SAFEIO CLASS contains the "request" procedure body.
   ------------------------------------------------------------------------;

   BEGIN
      REF(vennterms) termlist;

      CLASS terms;
      BEGIN
         INTEGER seed;

         TEXT ARRAY
         classterms[1:67];

         TEXT PROCEDURE pickterm(index);
         INTEGER index;
         BEGIN
            IF index = 1 THEN pickterm:- classterms[Randint(1,42,seed)]
            ELSE IF index = 2 THEN pickterm:- classterms[Randint(43,49,seed)]
            ELSE IF index = 3 THEN pickterm:- classterms[Randint(50,57,seed)]
            ELSE pickterm:- classterms[Randint(58,67,seed)];
         END;

         seed:= Entier(clocktime);

         classterms[1]:- Copy("TRUE PHILOSOPHERS");
         classterms[2]:- Copy("CONFIRMED SKEPTICS");
         classterms[3]:- Copy("SUCCESSFUL LOGICIANS");
         classterms[4]:- Copy("SENSUOUS WOMEN");
         classterms[5]:- Copy("SENSUOUS MEN");
         classterms[6]:- Copy("WASHINGTON POLITICIANS");
         classterms[7]:- Copy("DISCO DANCERS");
         classterms[8]:- Copy("RAVING IDIOTS");
         classterms[9]:- Copy("ABSENT-MINDED PROFESSORS");
         classterms[10]:- Copy("GOOD LOVERS");
         classterms[11]:- Copy("TOMATO FONDLERS");
         classterms[12]:- Copy("CANDID PHOTOGRAPHERS");
         classterms[13]:- Copy("PATIO GARDENERS");
         classterms[14]:- Copy("WEE-HOUR SNACKERS");
         classterms[15]:- Copy("BIG SPENDERS");
         classterms[16]:- Copy("MATCHSTICK GAMBLERS");
         classterms[17]:- Copy("SEX OBJECTS");
         classterms[18]:- Copy("MIDNIGHT MARAUDERS");
         classterms[19]:- Copy("MORNING-AFTER BRAGGERS");
         classterms[20]:- Copy("BACKSEAT DRIVERS");
         classterms[21]:- Copy("FREE LOADERS");
         classterms[22]:- Copy("BATHTUB SAILORS");
         classterms[23]:- Copy("MASSAGE ARTISTS");
         classterms[24]:- Copy("COLLEGE GRADUATES");
         classterms[25]:- Copy("SELF-STYLED EXPERTS");
         classterms[26]:- Copy("PARTY POOPERS");
         classterms[27]:- Copy("GARBAGE PICKERS");
         classterms[28]:- Copy("UNSUNG HEROES");
         classterms[29]:- Copy("INCURABLE DREAMERS");
         classterms[30]:- Copy("BATHROOM POETS");
         classterms[31]:- Copy("COMPULSIVE LIARS");
         classterms[32]:- Copy("MEXICAN DENTISTS");
         classterms[33]:- Copy("TOOTH FAIRIES");
         classterms[34]:- Copy("FAST-FOOD JUNKIES");
         classterms[35]:- Copy("DEADLY RIVALS");
         classterms[36]:- Copy("CROP DUSTERS");
         classterms[37]:- Copy("STREET PEDDLERS");
         classterms[38]:- Copy("WILLING PRISONERS");
         classterms[39]:- Copy("STRANGE BEDFELLOWS");
         classterms[40]:- Copy("PEEPHOLE PERVERTS");
         classterms[41]:- Copy("STAND-UP COMICS");
         classterms[42]:- Copy("READY ROMANCERS");
         COMMENT----------------------------------------------------------------------
         The remaining terms, 43-67, establish a universe of discourse for the
         heuristic search mechanism (in CLASS "counterterms") which attempts to generate
         counterexamples to the syllogisms "makesyllogism" produces.  The seven terms
         immediately below, 43-49, are labels for (b)ig, roughly coextensive classes--
         'B' classes for short.
         ---------------------------------------------------------------------------;
         classterms[43]:- Copy("LIVING THINGS");
         classterms[44]:- Copy("CELLULAR ORGANISMS");
         classterms[45]:- Copy("MORTAL THINGS");
         classterms[46]:- Copy("CHROMOSOMAL CREATURES");
         classterms[47]:- Copy("BIOLOGICAL ENTITIES");
         classterms[48]:- Copy("BUNDLES OF PROTOPLASM");
         classterms[49]:- Copy("FORMS OF LIFE");
         COMMENT---------------------------------------------------------------------
         The eight terms immediately below, 50-57, are labels for classes of (m)edium
         extension--'M' classes for short.  Any 'M' class is a proper subset of any 'B'
         class.  (At least, it is in VENN's metaphysics!)
         ----------------------------------------------------------------------------;
         classterms[50]:- Copy("HOMOSAPIENS");
         classterms[51]:- Copy("RATIONAL BEINGS");
         classterms[52]:- Copy("PROMISE MAKERS");
         classterms[53]:- Copy("CONSCIOUS BEINGS");
         classterms[54]:- Copy("HUMAN BEINGS");
         classterms[55]:- Copy("PERSONS");
         classterms[56]:- Copy("POLITICAL ANIMALS");
         classterms[57]:- Copy("FEATHERLESS BIPEDS");
         COMMENT--------------------------------------------------------------------
         The ten terms below label classes which have so (l)ittle extension that
         they are likely to be mutually exclusive--'L' classes for short.  VENN also
         regards each of them as labeling a proper subset of any 'M' class.  This
         characteristic, plus their exclusivity, figure in the success of the heuristic.
         ---------------------------------------------------------------------------;
         classterms[58]:- Copy("WORLD BANK DIRECTORS");
         classterms[59]:- Copy("MULTIBILLIONAIRES");
         classterms[60]:- Copy("NOBEL LAUREATES");
         classterms[61]:- Copy("OLYMPIC GOLD MEDALISTS");
         classterms[62]:- Copy("SOVIET CHESS CHAMPIONS");
         classterms[63]:- Copy("LUNAR EXPLORERS");
         classterms[64]:- Copy("FORMER US PRESIDENTS");
         classterms[65]:- Copy("FIVE-YEAR-OLD BOYS");
         classterms[66]:- Copy("FIVE-YEAR-OLD GIRLS");
         classterms[67]:- Copy("AFRICAN HEADS OF STATE")
      END CLA*S terms;


      terms CLASS vennterms;
      BEGIN
         TEXT ARRAY fallacies[1:8];

         fallacies[1]:- Copy("Negative premises");
         fallacies[2]:- Copy("Undistributed middle");
         fallacies[3]:- Copy("+ Conclusion, - major");
         fallacies[4]:- Copy("+ Conclusion, - minor");
         fallacies[5]:- Copy("- Conclusion, + premises");
         fallacies[6]:- Copy("Illicit major");
         fallacies[7]:- Copy("Illicit minor");
         fallacies[8]:- Copy("Existential fallacy")
      END CLA*S vennterms;

      termlist:- NEW vennterms;
      INSPECT termlist DO
      BEGIN

         CLASS statement;
         BEGIN
            TEXT type, tag, quantifier, subjectterm, copula, predicateterm, all;

            PROCEDURE makestatement;
            BEGIN
               all:- conc(tag,"  ",quantifier," ",subjectterm," ",copula," ",predicateterm,".")
            END;
         END CLA*S statement;

         CLASS syllogism;
         BEGIN
            REF(statement)
            majorpremise, minorpremise, conclusion,
            truemajorpremise, trueminorpremise, falseconclusion;

            TEXT ARRAY
            vennfillers[1:7],
            COMMENT---------------------------------------------------------------------
            Subscript values of "vennfillers" correspond to Venn diagram sectors.  See
            the diagram at PROCEDURE "outblankdiagram."
            ----------------------------------------------------------------------------;
            fallacies[1:8];

            BOOLEAN ARRAY
            fallacyflags[1:8];

            TEXT
            mood,
            figure,
            form,
            latinname,
            majorterm, middleterm, minorterm,
            countermajorterm, countermiddleterm, counterminorterm,
            truemajorpairs, trueminorpairs, falseconpairs;

            BOOLEAN
            reviewing,
            justtesting,
            valid,
            swapforstar,
            aristotelian;


            PROCEDURE initialize;
            COMMENT----------------------------------------------------------------
            The default initialization of all other variables is satisfactory.
            -----------------------------------------------------------------------;
            BEGIN
               INTEGER i;

               FOR i:= 1 STEP 1 UNTIL 8 DO fallacyflags[i]:= TRUE;
               FOR i:= 1 STEP 1 UNTIL 7 DO vennfillers[i]:- Copy("BLANKS")
            END PR*CEDURE initialize;

            PROCEDURE choose;
            BEGIN
               majorterm:- pickterm(1);
               middleterm:- pickterm(1);
               minorterm:- pickterm(1);
               IF (majorterm == middleterm OR middleterm == minorterm OR minorterm == majorterm) THEN choose
            END;

            BOOLEAN PROCEDURE goodformspec;
            BEGIN
               INTEGER i;
               TEXT t;

               goodformspec:= TRUE;
               upcase(form);
               IF form.Length >3 THEN
               BEGIN
                  FOR i:= 1 STEP 1 UNTIL 3 DO
                  BEGIN
                     t:- form.Sub(i,1);
                     IF (t \= "?" AND t \= "A" AND t \= "E" AND t \= "I" AND t \= "O") THEN
                     BEGIN
                        Outtext("Faulty type specification for proposition ");
                        Outint(i,1);
                        Outchar('.');
                        Outimage;
                        goodformspec:= FALSE
                     END
                  END;
                  t:- Copy(form.Sub(form.Length,1));
                  IF (t \= "?" AND t \= "1" AND t \= "2" AND t \= "3" AND t \= "4") THEN
                  BEGIN
                     outline("Figure value (last item) other than 1, 2, 3, 4 or ?.");
                     goodformspec:= FALSE
                  END
               END ELSE
               BEGIN
                  outline("Specification too short...something is missing.");
                  goodformspec:= FALSE
               END;
            END PR*CEDURE goodformspec;

            PROCEDURE makesyllogism;
            BEGIN
               INTEGER i, j;

               FOR i:= 1 STEP 1 UNTIL 3 DO
               BEGIN
                  IF form.Sub(i,1) = "?" THEN
                  BEGIN
                     j:= Randint(1,4,seed);
                     IF j = 1 THEN form.Sub(i,1):= "A"
                     ELSE IF j = 2 THEN form.Sub(i,1):= "E"
                     ELSE IF j = 3 THEN form.Sub(i,1):= "I"
                     ELSE form.Sub(i,1):= "O"
                  END
               END;
               IF form.Sub(form.Length,1) = "?" THEN
               BEGIN
                  j:= Randint(1,4,seed);
                  IF j = 1 THEN form.Sub(form.Length,1):= "1"
                  ELSE IF j = 2 THEN form.Sub(form.Length,1):= "2"
                  ELSE IF j = 3 THEN form.Sub(form.Length,1):= "3"
                  ELSE form.Sub(form.Length,1):= "4"
               END;
               figure:- form.Sub(form.Length,1);

               majorpremise:- NEW statement;
               INSPECT majorpremise DO
               BEGIN
                  type:- form.Sub(1,1);
                  tag:- Copy("Major Premise:");
                  IF figure = "1" OR figure = "3" THEN
                  BEGIN
                     subjectterm:- middleterm;
                     predicateterm:- majorterm;
                     IF type = "A" THEN
                     BEGIN
                        quantifier:- Copy("All");
                        copula:- Copy("are");
                        vennfillers[4]:- vennfillers[3]:- Copy("/");
                        IF aristotelian THEN vennfillers[6]:- vennfillers[7]:- Copy("?");
                        COMMENT----------------------------------------------------------------------
                        Partial set-up for filling in Venn diagram.  The remaining sectors will be
                        assigned filler characters in the INSPECT "minorpremise" block.  Some filler
                        characters set here may be changed later, e.g., in the event of clashes.
                        ----------------------------------------------------------------------------;
                        fallacyflags[1]:= fallacyflags[2]:= fallacyflags[3]:= FALSE;
                        COMMENT---------------------------------------------------------------------
                        Fallacy[1] "Negative Premises," fallacy[2] "Undistributed Middle," and
                        fallacy[3] "+ Conclusion, - Major" have been eliminated as possibilities at
                        this point.  Other possibilities will be eliminated subsequently in the
                        INSPECT "minorpremise" block.
                        ----------------------------------------------------------------------------;
                        truemajorpairs:- Copy(" BM BL ML BB")
                        COMMENT-------------------------------------------------------------------
                        This particular Major Premise tends to be true IF (the major class, i.e., the
                        predicate class, is very (b)ig AND the middle class, i.e., the subject class,
                        is (m)edium-sized) OR (the major class is very (b)ig and the middle class is
                        very (l)ittle) OR (the major class is (m)edium-sized and the middle class is
                        (l)ittle) OR (the major class is (b)ig and the middle class is (b)ig).  These
                        four character pairs represent these four possibilities.  A similar comment
                        could be made about the text stored in "trueminorpairs" and "falseconpairs."
                        In each case, by convention, the middle class (if any) is represented on
                        the right.  Otherwise, the order is minor class followed by major class.  Note
                        too that, since "A" and "O" are contradictories, the same pair values which
                        tend to make "A" true as a premise also work to render the "O" false as a
                        conclusion.  See comment about class "counterterms" for further information.
                        --------------------------------------------------------------------------;
                     END
                     ELSE IF type = "E" THEN
                     BEGIN
                        quantifier:- Copy("No");
                        copula:- Copy("are");
                        vennfillers[6]:- vennfillers[7]:- Copy("/");
                        IF aristotelian THEN vennfillers[3]:- vennfillers[4]:- Copy("?");
                        fallacyflags[2]:= fallacyflags[5]:= fallacyflags[6]:= FALSE;
                        truemajorpairs:- Copy(" LL")
                     END
                     ELSE IF type = "I" THEN
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are");
                        vennfillers[6]:- vennfillers[7]:- Copy("?");
                        fallacyflags[1]:= fallacyflags[3]:= fallacyflags[8]:= FALSE;
                        truemajorpairs:- Copy(" BB MB LB BM MM LM BL ML")
                     END
                     ELSE COMMENT type = "O";
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are not");
                        vennfillers[3]:- vennfillers[4]:- Copy("?");
                        fallacyflags[5]:= fallacyflags[6]:= fallacyflags[8]:= FALSE;
                        truemajorpairs:- Copy(" MB LB LM LL")
                     END
                  END
                  ELSE COMMENT figure = "2" OR figure = "4";
                  BEGIN
                     subjectterm:- majorterm;
                     predicateterm:- middleterm;
                     IF type = "A" THEN
                     BEGIN
                        quantifier:- Copy("All");
                        copula:- Copy("are");
                        vennfillers[2]:- vennfillers[5]:- Copy("/");
                        IF aristotelian THEN vennfillers[6]:- vennfillers[7]:- Copy("?");
                        fallacyflags[1]:= fallacyflags[3]:= fallacyflags[6]:= FALSE;
                        truemajorpairs:- Copy(" MB LB LM BB")
                     END
                     ELSE IF type = "E" THEN
                     BEGIN
                        quantifier:- Copy("No");
                        copula:- Copy("are");
                        vennfillers[6]:- vennfillers[7]:- Copy("/");
                        IF aristotelian THEN vennfillers[2]:- vennfillers[5]:- Copy("?");
                        fallacyflags[2]:= fallacyflags[5]:= fallacyflags[6]:= FALSE;
                        truemajorpairs:- Copy(" LL")
                     END
                     ELSE IF type = "I" THEN
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are");
                        vennfillers[6]:- vennfillers[7]:- Copy("?");
                        fallacyflags[1]:= fallacyflags[3]:= fallacyflags[8]:= FALSE;
                        truemajorpairs:- Copy(" BB BM BL MB MM ML LB LM")
                     END
                     ELSE COMMENT type = "O";
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are not");
                        vennfillers[2]:- vennfillers[5]:- Copy("?");
                        fallacyflags[2]:= fallacyflags[5]:= fallacyflags[8]:= FALSE;
                        truemajorpairs:- Copy(" BM BL ML LL")
                     END
                  END;
                  makestatement
               END INSP*CT majorpremise;

               minorpremise:- NEW statement;
               INSPECT minorpremise DO
               BEGIN
                  type:- form.Sub(2,1);
                  tag:- Copy("Minor Premise:");
                  IF figure = "3" OR figure = "4" THEN
                  BEGIN
                     subjectterm:- middleterm;
                     predicateterm:- minorterm;
                     IF type = "A" THEN
                     BEGIN
                        quantifier:- Copy("All");
                        copula:- Copy("are");
                        swapforstar:= FALSE;
                        IF vennfillers[3] = "?" OR vennfillers[6] = "?" THEN swapforstar:= TRUE;
                        IF vennfillers[6] = "/" THEN vennfillers[6]:- Copy("X")
                        ELSE vennfillers[6]:- Copy("\");
                        IF vennfillers[3] = "/" THEN vennfillers[3]:- Copy("X")
                        ELSE vennfillers[3]:- Copy("\");
                        IF swapforstar THEN FOR i:= 2,4,5,7 DO IF vennfillers[i] = "?" THEN vennfillers[i]:= Copy("*");
                        IF aristotelian THEN
                        BEGIN
                           IF vennfillers[4] = "/" OR vennfillers[7] = "/" THEN
                           BEGIN
                              IF vennfillers[4] \= "/" THEN vennfillers[4]:- Copy("*")
                              ELSE vennfillers[7]:- Copy("*")
                           END
                           ELSE BEGIN
                              IF vennfillers[4] = "BLANKS" THEN vennfillers[4]:- Copy("?");
                              IF vennfillers[7] = "BLANKS" THEN vennfillers[7]:- Copy("?")
                           END
                        END;
                        fallacyflags[1]:= fallacyflags[2]:= fallacyflags[4]:= FALSE;
                        trueminorpairs:- Copy(" BM BL ML BB")
                     END
                     ELSE IF type = "E" THEN
                     BEGIN
                        quantifier:- Copy("No");
                        copula:- Copy("are");
                        swapforstar:= FALSE;
                        IF vennfillers[4] = "?" OR vennfillers[7] = "?" THEN swapforstar:= TRUE;
                        IF vennfillers[4] = "/" THEN vennfillers[4]:- Copy("X")
                        ELSE vennfillers[4]:- Copy("\");
                        IF vennfillers[7] = "/" THEN vennfillers[7]:- Copy("X")
                        ELSE vennfillers[7]:- Copy("\");
                        IF swapforstar THEN FOR i:= 1,2,3,5,6 DO IF vennfillers[i] = "?" THEN vennfillers[i]:= Copy("*");
                        IF aristotelian THEN
                        BEGIN
                           IF vennfillers[3] = "/" OR vennfillers[6] = "/" THEN
                           BEGIN
                              IF vennfillers[3] \= "/" THEN vennfillers[3]:- Copy("*")
                              ELSE vennfillers[6]:- Copy("*")
                           END
                           ELSE BEGIN
                              IF vennfillers[3] = "BLANKS" THEN vennfillers[3]:- Copy("?");
                              IF vennfillers[6] = "BLANKS" THEN vennfillers[6]:- Copy("?")
                           END
                        END;
                        fallacyflags[2]:= fallacyflags[5]:= fallacyflags[7]:= FALSE;
                        trueminorpairs:- Copy(" LL")
                     END
                     ELSE IF type = "I" THEN
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are");
                        IF vennfillers[4] \= "/" AND vennfillers[7] \= "/" THEN vennfillers[4]:- vennfillers[7]:- Copy("?")
                        ELSE BEGIN
                           IF vennfillers[4] \= "/" THEN vennfillers[4]:- Copy("*");
                           IF vennfillers[7] \= "/" THEN vennfillers[7]:- Copy("*")
                        END;
                        fallacyflags[1]:= fallacyflags[4]:= fallacyflags[8]:= FALSE;
                        trueminorpairs:- Copy(" BB MB LB BM MM LM BL ML")
                     END
                     ELSE COMMENT type = "O";
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are not");
                        IF vennfillers[3] \= "/" AND vennfillers[6] \= "/" THEN vennfillers[3]:- vennfillers[6]:- Copy("?")
                        ELSE BEGIN
                           IF vennfillers[3] \= "/" THEN vennfillers[3]:- Copy("*");
                           IF vennfillers[6] \= "/" THEN vennfillers[6]:- Copy("*")
                        END;
                        fallacyflags[5]:= fallacyflags[7]:= fallacyflags[8]:= FALSE;
                        trueminorpairs:- Copy(" MB LB LM LL")
                     END
                  END
                  ELSE COMMENT figure = "1" OR figure = "2";
                  BEGIN
                     subjectterm:- minorterm;
                     predicateterm:- middleterm;
                     IF type = "A" THEN
                     BEGIN
                        quantifier:- Copy("All");
                        copula:- Copy("are");
                        swapforstar:= FALSE;
                        IF vennfillers[1] = "?" OR vennfillers[5] = "?" THEN swapforstar:= TRUE;
                        IF vennfillers[5] = "/" THEN vennfillers[5]:- Copy("X")
                        ELSE vennfillers[5]:- Copy("\");
                        vennfillers[1]:- Copy("\");
                        IF swapforstar THEN FOR i:= 2,3,4,6,7 DO IF vennfillers[i] = "?" THEN vennfillers[i]:= Copy("*");
                        IF aristotelian THEN
                        BEGIN
                           IF vennfillers[4] = "/" OR vennfillers[7] = "/" THEN
                           BEGIN
                              IF vennfillers[4] \= "/" THEN vennfillers[4]:- Copy("*")
                              ELSE vennfillers[7]:- Copy("*")
                           END
                           ELSE BEGIN
                              IF vennfillers[4] = "BLANKS" THEN vennfillers[4]:- Copy("?");
                              IF vennfillers[7] = "BLANKS" THEN vennfillers[7]:- Copy("?")
                           END
                        END;
                        fallacyflags[1]:= fallacyflags[4]:= fallacyflags[7]:= FALSE;
                        trueminorpairs:- Copy(" MB LB LM BB")
                     END
                     ELSE IF type = "E" THEN
                     BEGIN
                        quantifier:- Copy("No");
                        copula:- Copy("are");
                        swapforstar:= FALSE;
                        IF vennfillers[4] = "?" OR vennfillers[7] = "?" THEN swapforstar:= TRUE;
                        IF vennfillers[4] = "/" THEN vennfillers[4]:- Copy("X")
                        ELSE vennfillers[4]:- Copy("\");
                        IF vennfillers[7] = "/" THEN vennfillers[7]:- Copy("X")
                        ELSE vennfillers[7]:- Copy("\");
                        IF swapforstar THEN FOR i:= 1,2,3,5,6 DO IF vennfillers[i] = "?" THEN vennfillers[i]:= Copy("*");
                        IF aristotelian THEN
                        BEGIN
                           IF vennfillers[1] = "/" OR vennfillers[5] = "/" THEN
                           BEGIN
                              IF vennfillers[1] \= "/" THEN vennfillers[1]:- Copy("*")
                              ELSE vennfillers[5]:- Copy("*")
                           END
                           ELSE BEGIN
                              IF vennfillers[1] = "BLANKS" THEN vennfillers[1]:- Copy("?");
                              IF vennfillers[5] = "BLANKS" THEN vennfillers[5]:- Copy("?")
                           END;
                        END;
                        fallacyflags[2]:= fallacyflags[5]:= fallacyflags[7]:= FALSE;
                        trueminorpairs:- Copy(" LL")
                     END
                     ELSE IF type = "I" THEN
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are");
                        IF vennfillers[4] \= "/" AND vennfillers[7] \= "/" THEN vennfillers[4]:- vennfillers[7]:- Copy("?")
                        ELSE BEGIN
                           IF vennfillers[4] \= "/" THEN vennfillers[4]:- Copy("*");
                           IF vennfillers[7] \= "/" THEN vennfillers[7]:- Copy("*")
                        END;
                        fallacyflags[1]:= fallacyflags[4]:= fallacyflags[8]:= FALSE;
                        trueminorpairs:- Copy(" BB BM BL MB MM ML LB LM")
                     END
                     ELSE COMMENT type = "O";
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are not");
                        IF vennfillers[1] \= "/" AND vennfillers[5] \= "/" THEN vennfillers[1]:- vennfillers[5]:- Copy("?")
                        ELSE BEGIN
                           IF vennfillers[1] \= "/" THEN vennfillers[1]:- Copy("*");
                           IF vennfillers[5] \= "/" THEN vennfillers[5]:- Copy("*")
                        END;
                        fallacyflags[2]:= fallacyflags[5]:= fallacyflags[8]:= FALSE;
                        trueminorpairs:- Copy(" BM BL ML LL")
                     END
                  END;
                  makestatement;
               END INSP*CT minorpremise;

               conclusion:- NEW statement;
               INSPECT conclusion DO
               BEGIN
                  type:- form.Sub(3,1);
                  subjectterm:- minorterm;
                  predicateterm:- majorterm;
                  tag:- Copy("Conclusion:   ");
                  IF type = "A" THEN
                  BEGIN
                     quantifier:- Copy("All");
                     copula:- Copy("are");
                     fallacyflags[5]:= fallacyflags[6]:= fallacyflags[8]:= FALSE;
                     falseconpairs:- Copy(" BM BL ML LL")
                  END
                  ELSE
                  IF type = "E" THEN
                  BEGIN
                     quantifier:- Copy("No");
                     copula:- Copy("are");
                     fallacyflags[3]:= fallacyflags[4]:= fallacyflags[8]:= FALSE;
                     falseconpairs:- Copy(" BB BM BL MB MM ML LB LM")
                  END
                  ELSE
                  IF type = "I" THEN
                  BEGIN
                     quantifier:- Copy("Some");
                     copula:- Copy("are");
                     fallacyflags[5]:= fallacyflags[6]:= fallacyflags[7]:= FALSE;
                     IF aristotelian THEN fallacyflags[8]:= FALSE;
                     falseconpairs:- Copy(" LL")
                  END
                  ELSE COMMENT type = "O";
                  BEGIN
                     quantifier:- Copy("Some");
                     copula:- Copy("are not");
                     fallacyflags[3]:= fallacyflags[4]:= fallacyflags[7]:= FALSE;
                     IF aristotelian THEN fallacyflags[8]:= FALSE;
                     falseconpairs:- Copy(" MB LB LM BB")
                  END;
                  makestatement;
               END of INSP*CT conclusion;

               mood:- conc(majorpremise.type,minorpremise.type,conclusion.type);
               form:- conc(mood,"-",figure);
            END PR*CEDURE makesyllogism;

            PROCEDURE makecounterexample;
            COMMENT-------------------------------------------------------------------
            This procedure is, in effect, a subset of "makesyllogism," so it could have
            been extracted from a call on that procedure if enough (confusing) conditional
            branching had been introduced.  It has been coded separately, however, for
            better readability.
            --------------------------------------------------------------------------;
            BEGIN
               truemajorpremise:- NEW statement;
               INSPECT truemajorpremise DO
               BEGIN
                  type:- form.Sub(1,1);
                  tag:- Copy("TRUE Major Premise:");
                  IF figure = "1" OR figure = "3" THEN
                  BEGIN
                     subjectterm:- countermiddleterm;
                     predicateterm:- countermajorterm;
                     IF type = "A" THEN
                     BEGIN
                        quantifier:- Copy("All");
                        copula:- Copy("are")
                     END
                     ELSE IF type = "E" THEN
                     BEGIN
                        quantifier:- Copy("No");
                        copula:- Copy("are")
                     END
                     ELSE IF type = "I" THEN
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are")
                     END
                     ELSE COMMENT type = "O";
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are not")
                     END
                  END
                  ELSE COMMENT figure = "2" OR figure = "4";
                  BEGIN
                     subjectterm:- countermajorterm;
                     predicateterm:- countermiddleterm;
                     IF type = "A" THEN
                     BEGIN
                        quantifier:- Copy("All");
                        copula:- Copy("are")
                     END
                     ELSE IF type = "E" THEN
                     BEGIN
                        quantifier:- Copy("No");
                        copula:- Copy("are")
                     END
                     ELSE IF type = "I" THEN
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are")
                     END
                     ELSE COMMENT type = "O";
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are not")
                     END
                  END;
                  makestatement
               END INSP*CT truemajorpremise;

               trueminorpremise:- NEW statement;
               INSPECT trueminorpremise DO
               BEGIN
                  type:- form.Sub(2,1);
                  tag:- Copy("TRUE Minor Premise:");
                  IF figure = "3" OR figure = "4" THEN
                  BEGIN
                     subjectterm:- countermiddleterm;
                     predicateterm:- counterminorterm;
                     IF type = "A" THEN
                     BEGIN
                        quantifier:- Copy("All");
                        copula:- Copy("are")
                     END
                     ELSE IF type = "E" THEN
                     BEGIN
                        quantifier:- Copy("No");
                        copula:- Copy("are")
                     END
                     ELSE IF type = "I" THEN
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are")
                     END
                     ELSE COMMENT TYPE = "O";
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are not")
                     END
                  END
                  ELSE COMMENT figure = "1" OR figure = "2";
                  BEGIN
                     subjectterm:- counterminorterm;
                     predicateterm:- countermiddleterm;
                     IF type = "A" THEN
                     BEGIN
                        quantifier:- Copy("All");
                        copula:- Copy("are")
                     END
                     ELSE IF type = "E" THEN
                     BEGIN
                        quantifier:- Copy("No");
                        copula:- Copy("are")
                     END
                     ELSE IF type = "I" THEN
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are")
                     END
                     ELSE COMMENT type = "O";
                     BEGIN
                        quantifier:- Copy("Some");
                        copula:- Copy("are not")
                     END
                  END;
                  makestatement
               END INSP*CT trueminorpremise;

               falseconclusion:- NEW statement;
               INSPECT falseconclusion DO
               BEGIN
                  type:- form.Sub(3,1);
                  subjectterm:- counterminorterm;
                  predicateterm:- countermajorterm;
                  tag:- Copy("FALSE Conclusion:  ");
                  IF type = "A" THEN
                  BEGIN
                     quantifier:- Copy("All");
                     copula:- Copy("are")
                  END
                  ELSE
                  IF type = "E" THEN
                  BEGIN
                     quantifier:- Copy("No");
                     copula:- Copy("are")
                  END
                  ELSE
                  IF type = "I" THEN
                  BEGIN
                     quantifier:- Copy("Some");
                     copula:- Copy("are")
                  END
                  ELSE COMMENT type = "O";
                  BEGIN
                     quantifier:- Copy("Some");
                     copula:- Copy("are not")
                  END;
                  makestatement
               END of INSP*CT falseconclusion;
            END PR*CEDURE makecounterexample;

            PROCEDURE validate;
            BEGIN
               IF figure = "1" THEN
               BEGIN
                  IF mood = "AAA" THEN latinname:- Copy("B(a)rb(a)r(a)")
                  ELSE IF mood = "EAE" THEN latinname:- Copy("C(e)l(a)r(e)nt")
                  ELSE IF mood = "AII" THEN latinname:- Copy("D(a)r(i)(i)")
                  ELSE IF mood = "EIO" THEN latinname:- Copy("F(e)r(i)(o)que")
                  ELSE IF aristotelian THEN
                  BEGIN
                     IF mood = "AAI" THEN latinname:- Copy("none given")
                     ELSE IF mood = "EAO" THEN latinname:- Copy("none given")
                  END
               END
               ELSE IF figure = "2" THEN
               BEGIN
                  IF mood = "EAE" THEN latinname:- Copy("C(e)s(a)r(e)")
                  ELSE IF mood = "AEE" THEN latinname:- Copy("C(a)m(e)str(e)s")
                  ELSE IF mood = "EIO" THEN latinname:- Copy("F(e)st(i)n(o)")
                  ELSE IF mood = "AOO" THEN latinname:- Copy("B(a)r(o)c(o)")
                  ELSE IF aristotelian THEN
                  BEGIN
                     IF mood = "AEO" THEN latinname:- Copy("none given")
                     ELSE IF mood = "EAO" THEN latinname:- Copy("none given")
                  END
               END
               ELSE IF figure = "3" THEN
               BEGIN
                  IF mood = "IAI" THEN latinname:- Copy("D(i)s(a)m(i)s")
                  ELSE IF mood = "AII" THEN latinname:- Copy("D(a)t(i)s(i)")
                  ELSE IF mood = "OAO" THEN latinname:- Copy("B(o)c(a)rd(o)")
                  ELSE IF mood = "EIO" THEN latinname:- Copy("F(e)r(i)s(o)n")
                  ELSE IF aristotelian THEN
                  BEGIN
                     IF mood = "AAI" THEN latinname:- Copy("D(a)r(a)pt(i)")
                     ELSE IF mood = "EAO" THEN latinname:- Copy("F(e)l(a)pt(o)n")
                  END;
               END
               ELSE
               IF figure = "4" THEN
               BEGIN
                  IF mood = "AEE" THEN latinname:- Copy("C(a)m(e)n(e)s")
                  ELSE IF mood = "IAI" THEN latinname:- Copy("D(i)m(a)r(i)s")
                  ELSE IF mood = "EIO" THEN latinname:- Copy("Fr(e)s(i)s(o)n")
                  ELSE IF aristotelian THEN
                  BEGIN
                     IF mood = "AEO" THEN
                     BEGIN
                        latinname:- Copy("none given");
                        Outimage;
                        outline("NOTE:  The syllogism you are about to see is the SOLE exception to the VENN");
                        outline("program's parsimonious implementation of the Aristotelian (or existential)");
                        outline("viewpoint.  If you work through the questions, you will discover why.")
                     END
                     ELSE IF mood = "EAO" THEN latinname:- Copy("F(e)s(a)p(o)")
                     ELSE IF mood = "AAI" THEN latinname:- Copy("Br(a)m(a)nt(i)p")
                  END
               END;
               IF latinname =/= NOTEXT THEN valid:= TRUE;
               COMMENT----------------------------------------------------------------------
               Validity could have been determined by stepping across ARRAY "fallacyflags,"
               but then "doublecheck" (below) would be unable to detect internal errors.
               "Validate," among other things, provides an independent check of validity.
               -----------------------------------------------------------------------------;
            END PR*CEDURE validate;


            PROCEDURE doublecheck;
            COMMENT------------------------------------------------------------------
            Used for debugging.  Checks for internal errors and reports any it finds.
            --------------------------------------------------------------------------;
            BEGIN
               INTEGER i, max;
               IF aristotelian THEN max:= 7 ELSE max:= 8;
               IF valid THEN FOR i:= 1 STEP 1 UNTIL max DO
               BEGIN
                  IF fallacyflags[i] THEN
                  BEGIN
                     Outtext("Program error: Fallacy flag(");
                     Outint(i,1);
                     Outtext(") set TRUE for valid ");
                     Outtext(form);
                     Outimage
                  END
               END;
               IF NOT valid THEN
               BEGIN
                  FOR i:= 1 STEP 1 UNTIL max DO
                  IF fallacyflags[i] THEN GOTO out;
                  Outtext("Program error: No fallacy flags set TRUE for invalid ");
                  Outtext(form);
                  Outimage;
                  out:
               END
            END PR*CEDURE doublecheck;

            PROCEDURE outline(t);
            NAME t; TEXT t;

            BEGIN
               Outtext(t);
               Outimage
            END;

            PROCEDURE outsyllogism;
            BEGIN
               Outimage;
               outline(majorpremise.all);
               outline(minorpremise.all);
               outline("-----------------------------------------------------------------");
               outline(conclusion.all);
               Outimage
            END PR*CEDURE outsyllogism;

            PROCEDURE outcounterexample;
            COMMENT------------------------------------------------------------------
            Like "outsyllogism," but coded separately for better readability.
            -------------------------------------------------------------------------;
            BEGIN
               Outimage;
               outline(truemajorpremise.all);
               outline(trueminorpremise.all);
               outline("-----------------------------------------------------------------");
               outline(falseconclusion.all);
               Outimage
            END PR*CEDURE outcounterexample;

            initialize;
            choose
         END CLA*S syllogism;

         syllogism CLASS venndiagram;
         BEGIN
            PROCEDURE outdiagram;
            BEGIN
               INTEGER i, j;

               PROCEDURE outdata;
               BEGIN
                  FOR j:= j STEP 1 UNTIL 8 DO
                  IF fallacyflags[j] THEN
                  BEGIN
                     Outtext("    FALLACY(");
                     Outint(j,1);
                     Outtext("):   ");
                     Outtext(termlist.fallacies[j]);
                     j:= j+1;
                     GOTO exit;
                  END;
                  exit:
               END;

               FOR i:= 1 STEP 1 UNTIL 7 DO IF vennfillers[i] = "BLANKS" THEN vennfillers[i]:- Copy(" ");

               !  LINE ONE;
               j:= 1;
               Outtext("  ------------------");
               Outtext("       MAJOR CLASS:  " );
               Outtext(majorterm);
               Outimage;

               !  LINE TWO;
               Outtext("M !");
               FOR i:= 1 STEP 1 UNTIL 6 DO Outtext(vennfillers[1]);
               Outchar('!');
               Outtext(vennfillers[5]);
               Outtext(vennfillers[5]);
               Outchar('!');
               FOR i:= 1 STEP 1 UNTIL 6 DO Outtext(vennfillers[2]);
               Outchar('!');
               Outtext(" M     MINOR CLASS:  ");
               Outtext(minorterm);
               Outimage;

               !  LINE THREE;
               Outtext("I !");
               FOR i:= 1 STEP 1 UNTIL 6 DO Outtext(vennfillers[1]);
               Outchar('!');
               Outtext(vennfillers[5]);
               Outtext(vennfillers[5]);
               Outchar('!');
               FOR i:= 1 STEP 1 UNTIL 6 DO Outtext(vennfillers[2]);
               Outchar('!');
               Outtext(" A     MIDDLE CLASS: ");
               Outtext(middleterm);
               Outimage;

               !  LINE FOUR;
               Outtext("N !");
               FOR i:= 1 STEP 1 UNTIL 3 DO Outtext(vennfillers[1]);
               Outtext("----------");
               FOR i:= 1 STEP 1 UNTIL 3 DO Outtext(vennfillers[2]);
               Outchar('!');
               Outtext(" J     MOOD-FIGURE:  ");
               Outtext(form);
               Outimage;

               !  LINE FIVE;
               Outtext("O !");
               FOR i:= 1 STEP 1 UNTIL 3 DO Outtext(vennfillers[1]);
               Outchar('!');
               Outtext(vennfillers[4]);
               Outtext(vennfillers[4]);
               Outchar('!');
               Outtext(vennfillers[7]);
               Outtext(vennfillers[7]);
               Outchar('!');
               Outtext(vennfillers[6]);
               Outtext(vennfillers[6]);
               Outchar('!');
               FOR i:= 1 STEP 1 UNTIL 3 DO Outtext(vennfillers[2]);
               Outchar('!');
               Outtext(" O     VIEWPOINT:    ");
               IF aristotelian THEN Outtext("Aristotelian (existential)")
               ELSE Outtext("Boolean (hypothetical)");
               Outimage;

               !  LINE SIX;
               Outtext("R !");
               FOR i:= 1 STEP 1 UNTIL 3 DO Outtext(vennfillers[1]);
               Outchar('!');
               Outtext(vennfillers[4]);
               Outtext(vennfillers[4]);
               Outchar('!');
               Outtext(vennfillers[7]);
               Outtext(vennfillers[7]);
               Outchar('!');
               Outtext(vennfillers[6]);
               Outtext(vennfillers[6]);
               Outchar('!');
               FOR i:= 1 STEP 1 UNTIL 3 DO Outtext(vennfillers[2]);
               Outtext("! R ");
               IF NOT reviewing THEN
               BEGIN
                  IF valid THEN Outtext("    VALID:        Yes")
                  ELSE Outtext("    VALID:        No");
               END;
               Outimage;

               !  LINE SEVEN;
               Outtext("  ------------------   ");
               IF NOT reviewing THEN
               BEGIN
                  IF valid THEN
                  BEGIN
                     Outtext("    LATIN NAME:   ");
                     Outtext(latinname)
                  END ELSE IF j<8 THEN outdata;
               END;
               Outimage;

               !  LINE eight;
               Outtext("      !");
               FOR i:= 1 STEP 1 UNTIL 8 DO Outtext(vennfillers[3]);
               Outtext("!       ");
               IF NOT reviewing AND NOT valid AND j<8 THEN outdata;
               Outimage;

               !  LINE NINE;
               Outtext("      !");
               FOR i:= 1 STEP 1 UNTIL 8 DO Outtext(vennfillers[3]);
               Outtext("!       ");
               IF NOT reviewing AND NOT valid AND j<8 THEN outdata;
               Outimage;

               !  LINE TEN;
               Outtext("      ----------       ");
               IF NOT reviewing AND NOT valid AND j<8 THEN outdata;
               Outimage;
               outline("        MIDDLE             ");

               FOR i:= 1 STEP 1 UNTIL 7 DO IF vennfillers[i] = " " THEN vennfillers[i]:- Copy("BLANKS");
            END PR*CEDURE outdiagram;

            BOOLEAN PROCEDURE outblankdiagram;
            BEGIN
               outline("  ------------------");
               outline("M !1     !5 !2     ! M                    CONVENTIONS");
               outline("I !      !  !      ! A");
               outline("N !   ----------   ! J       '/' = this sector empty by Major Premise");
               outline("O !   !4 !7 !6 !   ! O       '\' = this sector empty by Minor Premise");
               outline("R !   !  !  !  !   ! R       'X' = this sector empty by BOTH the above");
               outline("  ------------------         '?' = this OR adjacent sector MUST have a member");
               outline("      !3       !             '*' = this sector MUST have a member");
               outline("      !        !");
               outline("      ----------             Otherwise, value of sector is 'BLANKS'");
               outline("        MIDDLE               (simply due to lack of information)");
               Outimage;
               outsyllogism
            END PR*CEDURE outblankdiagram;

            BOOLEAN PROCEDURE validityhelp;
            BEGIN
               outline("The syllogism is valid only if you can 'read' the conclusion from the diagram");
               Outtext("just as it is.  That is, ");
               IF conclusion.type = "A" THEN Outtext("both sectors 1 and 4 would have to be shaded out.")
               ELSE IF conclusion.type = "E" THEN Outtext("both sectors 5 and 7 would have to be shaded out.")
               ELSE IF conclusion.type = "I" THEN Outtext("either sector 5 or 7 would have to contain a '*'.")
               ELSE Outtext("either sector 1 or 4 would have to contain a '*'.");
               Outimage
            END PR*CEDURE validityhelp;

         END CLA*S venndiagram;

         INSPECT NEW safmin DO
         BEGIN
            REF(venndiagram) ordinarysyllogism;
            INTEGER i, contacttime;
            BOOLEAN toggle, quit;
            COMMENT--------------------------------------------------------------------
            Note that "toggle" is used for several DIFFERENT purposes.
            ---------------------------------------------------------------------------;
            TEXT response, target;

            BOOLEAN PROCEDURE viewpointhelp;
            BEGIN
               Outimage;
               outline("Under the Aristotelian (or existential) interpretation, the SUBJECT");
               outline("class of each 'A' and 'E' (universal) premise is assumed to have at");
               outline("least one member.  (Some logicians assume that each class mentioned--three");
               outline("in all--must have members, but the stingy VENN program refuses to multiply");
               outline("entities beyond necessity.  Under the Boolean (or hypothetical) viewpoint,");
               outline("even this stingy assumption about the subject class of 'A' and 'E' premises");
               outline("is void.  Of course, it makes no difference which interpretation you select");
               outline("in the case of 'I' and 'O' (particular) premises since 'some' forces us");
               outline("to assume that their subject classes have at least one member.");
               COMMENT----------------------------------------------------------------------
               Parsimony was an important consideration, but this decision was also motivated
               by a desire to keep VENN.SIM and QUICK.SIM (an interactive, generative program
               for teaching immediate inference) consistent.  Eventually parts of QUICK.SIM
               will be used in VENN, e.g., to produce syllogisms with obverted premises.
               Thus it is imperative that "adopting the existential viewpoint" mean ONE
               thing, whether we speak of immeidate inferences or syllogistic inferences.
               In fact, however, most authors MODIFY their stand on the existential viewpoint
               as they pass from immediate inference to syllogistic inference.  Such slippage
               would wreak havoc in a computer algorithm, however!  As a side-effect of this
               decision, we have the problem of deciding what to do with AEO-4.  I prefer to
               consider it invalid, contending that its invalidity shows that the "rules"
               are incomplete.  Nevertheless, AEO-4 IS considered valid by the program at this
               time.  Later verions of VENN will probably treat it as invalid, however, and
               the rules will be modified so that AEO-4 will commit the existential fallacy.
               User comments are invited.
               -----------------------------------------------------------------------------;
               Outimage;
            END;

            BOOLEAN PROCEDURE figurehelp;
            BEGIN
               Outimage;
               outline("The figure of a syllogism is determined by the spatial arrangement of");
               outline("the two occurrences of the MIDDLE term ('X') in the premises:");
               Outimage;
               outline("              -1-                       -2-");
               outline("            X   Major               Major    X");
               outline("          Minor   X                 Minor    X");
               outline("          -----------               ----------");
               Outimage;
               outline("              -3-                       -4-");
               outline("          X    Major                Major   X");
               outline("          X    Minor                  X   Minor");
               outline("          ----------                -----------");
               Outimage
            END;

            IF trmop(8r2012, Sysout, 80) \= 80 THEN
            BEGIN
               COMMENT------------------------------------------------------------
               Simulates "SET TTY WIDTH 80" if necessary and, if it was, reopens
               Sysout with this new parameter.
               ------------------------------------------------------------------;
               Sysout.Close;
               Sysout.Open(Blanks(80));
               outline("TTY WIDTH reset to 80 by program.")
            END;

            Outimage;
            outline("VENN Version 1 (c) copyright 1977 by its author, Dr. Walter Maner, Department");
            outline("of Philosophy, Old Dominion University, Norfolk, VA 23508. TEL: (804) 489-6517");
            Outimage;
            outline("Use of VENN implies an agreement to report all modifications and any program");
            outline("errors directly to the author.");
            Outimage;
            outline("NOTE:  Typing a capital 'H' gets help, if any is available.");
            outline("       Default answers (if any) appear between slash marks,");
            outline("       e.g.,'/yes/'.  If just the RETURN key is pushed, the");
            outline("       program will use the default value indicated.  If not");
            outline("       it will use the value you supply after the final ':'.");
            Outimage;
            margin:= 1;
            helpchar:= 'H';

            request("Need to review the description of this program ('yes' or 'no')? ",
            "yes",boolinput(toggle),
            "Huh?",nohelp);
            IF toggle THEN
            BEGIN
               Outimage;
               outline("This program will generate new  (standard)  syllogisms for you for  as");
               outline("long  as  you want to work at analyzing them.  There are 256  formally");
               outline("distinct  syllogisms and (in this  program) so many novel combinations");
               outline("of terms  for  each of these 256 that the chance that you will get two");
               outline("syllogisms alike in two successive generations approaches zero.  Since");
               outline("most  of  these  256  basic  forms  are  invalid and since the program");
               outline("chooses at random from these  forms (or a subset thereof), you must be");
               outline("skeptical of the arguments produced.  As a rule, the chance of getting");
               outline("a valid syllogism under the Aristotelian interpretation is about 1  in");
               outline("11 while, under the tighter Boolean interpretation, it shrinks to near");
               outline("1 in 17.  (You'll get to choose which interpretation the program is to");
               outline("use.)  When you have correctly answered all the questions posed by the");
               outline("program regarding a syllogism, the program will proceed  to  draw  the");
               outline("Venn diagram for the syllogism and print out a table of relevant data.");
               outline("At this point you can either work through the same syllogism again  or");
               outline("have the program generate a new one (or quit).  Instead of answering a");
               outline("question, you can type 'H' for help.  A program clock will keep  track");
               outline("of  how long it takes you to work through a given series of questions.");
               outline("You'll probably enjoy trying to best your own record.  Of course,  you");
               outline("can skip the questions if you just want to use VENN to check validity.");
               outline("You can even ask VENN to make up counterexamples to his own syllogism!");
               Outimage
            END;

            WHILE NOT quit DO
            BEGIN
               ordinarysyllogism:- NEW venndiagram;
               INSPECT ordinarysyllogism DO
               BEGIN
                  request("Specify syllogism by MOOD and FIGURE (use '?' as a wild card): ","???-?",
                  textinput(form,goodformspec),
                  "Response should resemble 'AEI-2','EOE-4', '??E-?', '???-4', 'EII-?', etc.",
                  help("Each statement's type (A,E,I, O or ?), followed by figure (1,2,3, 4 or ?)."));

                  request("Suggest a label (for the MAJOR class): ",
                  majorterm,textinput(majorterm,majorterm.Length<25),
                  "? Too long...try again",
                  help("Any general category term not beginning with 'H' will work."));
                  IF majorterm.Sub(1,1) \= "h" THEN upcase(majorterm);

                  request("And another label (for the MINOR class): ",
                  minorterm,textinput(minorterm,minorterm.Length<25),
                  "? Too long...try again",
                  help("Any general category term not beginning with 'H' will work."));
                  IF minorterm.Sub(1,1) \= "h" THEN upcase(minorterm);

                  request("And one more (for the MIDDLE class): ",
                  middleterm,textinput(middleterm,middleterm.Length<25),
                  "? Too long...try again",
                  help("Any general category term not beginning with 'H' will work."));
                  IF middleterm.Sub(1,1) \= "h" THEN upcase(middleterm);

                  request("Aristotelian interpretation ('yes' or 'no')? ",
                  "yes",boolinput(aristotelian),
                  "Huh?  Type 'H' for help.",
                  viewpointhelp);

                  makesyllogism;
                  validate;
                  doublecheck;

                  samesyllogism:
                  request("Want to skip the question routine ('yes' or 'no')? ",
                  "no",boolinput(justtesting),
                  "Huh?  Type 'H' for help.",
                  help("If you say 'yes', the program will generate the Venn diagram immediately."));

                  IF NOT justtesting THEN
                  BEGIN
                     contacttime:= Entier(clocktime);
                     Outimage;
                     outline("Here we go...the clock is running.  Good luck!");
                     outsyllogism;

                     request("MOOD of this syllogism:",nodefault,
                     textinput(response,upcase(response)= mood),
                     "No.  Try again or type 'H' for help.",
                     help("A 3-letter word giving the type of each proposition in turn e.g., 'AEI'"));
                     outline("Right!");
                     Outimage;
                     outsyllogism;

                     request("Figure:",nodefault,
                     textinput(response, response = figure),
                     "No.  Try again or type 'H' for help.",
                     figurehelp);
                     outline("Right!");
                     Outimage;
                     outsyllogism;

                     request("Venn diagram, sector 1, will contain (/, \, X, ?, * or BLANKS): ",
                     "BLANKS",textinput(response,response = vennfillers[1]),
                     "Wrong.  Type 'H' for help.",
                     outblankdiagram);
                     outline("Right!");
                     Outimage;
                     outsyllogism;

                     request("Sector 2 will contain (/, \, X, ?, * or BLANKS): ",
                     "BLANKS",textinput(response,response = vennfillers[2]),
                     "Wrong.  Type 'H' for help.",
                     outblankdiagram);
                     outline("Right!");
                     Outimage;
                     outsyllogism;

                     request("Sector 3 will contain (/, \, X, ?, * or BLANKS): ",
                     "BLANKS",textinput(response,response = vennfillers[3]),
                     "Wrong.  Type 'H' for help.",
                     outblankdiagram);
                     outline("Right!");
                     Outimage;
                     outsyllogism;

                     request("Sector 4 will contain (/, \, X, ?, * or BLANKS): ",
                     "BLANKS",textinput(response,response = vennfillers[4]),
                     "Wrong.  Type 'H' for help.",
                     outblankdiagram);
                     outline("Right!");
                     Outimage;
                     outsyllogism;

                     request("Sector 5 will contain (/, \, X, ?, * or BLANKS): ",
                     "BLANKS",textinput(response,response = vennfillers[5]),
                     "Wrong.  Type 'H' for help.",
                     outblankdiagram);
                     outline("Right!");
                     Outimage;
                     outsyllogism;

                     request("Sector 6 will contain (/, \, X, ?, * or BLANKS): ",
                     "BLANKS",textinput(response,response = vennfillers[6]),
                     "Wrong.  Type 'H' for help.",
                     outblankdiagram);
                     outline("Right!");
                     Outimage;
                     outsyllogism;

                     request("Sector 7 will contain (/, \, X, ?, * or BLANKS): ",
                     "BLANKS",textinput(response,response = vennfillers[7]),
                     "Wrong.  Type 'H' for help.",
                     outblankdiagram);
                     outline("Right!");
                     Outimage;

                     outline("Now study the syllogism and the complete Venn diagram carefully");
                     outline("in order to decide whether the syllogism is valid or invalid:");
                     outsyllogism;
                     reviewing:= TRUE;
                     outdiagram;

                     IF valid THEN target:- Copy("YES") ELSE target:- Copy("NO");
                     Outimage;
                     request("Is it valid ('yes' or 'no')? ","no",
                     textinput(response, upcase(response)= target),
                     "Wrong.  Shame on you!  Try again or type 'H' for help.",
                     validityhelp);
                     outline("Right!");
                     Outimage;

                     BEGIN
                        INTEGER i;
                        Outimage;
                        outline("From these same two premises, i.e.,");
                        outline(majorpremise.all);
                        outline(minorpremise.all);
                        Outimage;
                        outline("we can validly deduce the following conclusions:");
                        IF (vennfillers[1] = "\") AND (vennfillers[4] = "\" OR vennfillers[4] = "/" OR vennfillers[4] =
                        "X") THEN
                        BEGIN
                           i:= i + 1;
                           outline(conc("Conclusion:     All ",minorterm," are ",majorterm))
                        END;
                        IF (vennfillers[2] = "/") AND (vennfillers[6] = "/" OR vennfillers[6] = "\" OR vennfillers[6] =
                        "X") THEN
                        BEGIN
                           i:= i + 1;
                           outline(conc("Conclusion:     All ",majorterm," are ",minorterm))
                        END;
                        IF (vennfillers[5] = "\" OR vennfillers[5] = "/" OR vennfillers[5] = "X")
                        AND (vennfillers[7] = "\" OR vennfillers[7] = "/" OR vennfillers[7] = "X") THEN
                        BEGIN
                           i:= i + 2;
                           outline(conc("Conclusion:     No ",minorterm," are ",majorterm,"."));
                           outline(conc("Conclusion:     No ",majorterm," are ",minorterm,"."))
                        END;
                        IF (vennfillers[5] = "*" OR vennfillers[7] = "*") THEN
                        BEGIN
                           i:= i + 2;
                           outline(conc("Conclusion:     Some ",minorterm," are ",majorterm,"."));
                           outline(conc("Conclusion:     Some ",majorterm," are ",minorterm,"."))
                        END;
                        IF (vennfillers[1] = "*" OR vennfillers[4] = "*") THEN
                        BEGIN
                           i:= i + 1;
                           outline(conc("Conclusion:     Some ",minorterm," are not ",majorterm,"."))
                        END;
                        IF (vennfillers[2] = "*" OR vennfillers[6] = "*") THEN
                        BEGIN
                           i:= i + 1;
                           outline(conc("Conclusion:     Some ",majorterm," are not ",minorterm,"."))
                        END;
                        IF i = 0 THEN
                        BEGIN
                           outline("     NONE!");
                           Outimage
                        END
                        ELSE
                        BEGIN
                           Outimage;
                           outline("No other valid deductions are possible.")
                        END;
                        outline("You will have about 45 seconds to verify this for yourself by");
                        outline("referring again to the Venn diagram:");
                        reviewing:= TRUE;
                        Outimage;
                        outdiagram;
                        sleep(45);
                        reviewing:= FALSE
                     END;
                     outsyllogism;


                     IF NOT valid THEN
                     BEGIN
                        outline("Now let's determine which fallacies were committed");
                        outline("by evaluating the following TRUE/FALSE questions...");
                        Outimage;

                        IF fallacyflags[1] THEN target:- Copy("T")
                        ELSE target:- Copy("F");
                        request("(1) Both premises negative ('T' or 'F'): ","F",
                        textinput(response, upcase(response) = target),
                        "No.",
                        nohelp);
                        outline("Right!");
                        Outimage;
                        outsyllogism;

                        IF fallacyflags[2] THEN target:- Copy("T")
                        ELSE target:- Copy("F");
                        request("(2) Neither premise distributes middle term ('T' or 'F'): ","F",
                        textinput(response, upcase(response) = target),
                        "No.  Try again or type 'H' for help.",
                        help("'..distributes..' = '..refers to ALL members of the class named by..'"));
                        outline("Right!");
                        Outimage;
                        outsyllogism;

                        IF fallacyflags[3] THEN target:- Copy("T")
                        ELSE target:- Copy("F");
                        request("(3) Positive conclusion from negative Major Premise ('T' or 'F'): ","F",
                        textinput(response, upcase(response) = target),
                        "No.  Try again or type 'H' for help.",
                        help("'A' and 'I' are positive (affirmative) while 'E' and 'O' are negative."));
                        outline("Right!");
                        Outimage;
                        outsyllogism;

                        IF fallacyflags[4] THEN target:- Copy("T")
                        ELSE target:- Copy("F");
                        request("(4) Positive conclusion from negative Minor Premise ('T' or 'F'): ","F",
                        textinput(response, upcase(response) = target),
                        "No.  Try again or type 'H' for help.",
                        help("'A' and 'I' are positive (affirmative) while 'E' and 'O' are negative."));
                        outline("Right!");
                        Outimage;
                        outsyllogism;

                        IF fallacyflags[5] THEN target:- Copy("T")
                        ELSE target:- Copy("F");
                        request("(5) Negative conclusion from all positive premises ('T' or 'F'): ","F",
                        textinput(response, upcase(response) = target),
                        "No.",
                        nohelp);
                        outline("Right!");
                        Outimage;
                        outsyllogism;

                        IF fallacyflags[6] THEN target:- Copy("T")
                        ELSE target:- Copy("F");
                        request("(6) Conclusion distributes MAJOR term but Major Premise doesn't ('T' or 'F'): ","F",
                        textinput(response, upcase(response) = target),
                        "No.  Try again or type 'H' for help.",
                        help("'..distributes..' = '..refers to ALL members of the class named by..'"));
                        outline("Right!");
                        Outimage;
                        outsyllogism;

                        IF fallacyflags[7] THEN target:- Copy("T")
                        ELSE target:- Copy("F");
                        request("(7) Conclusion distributes MINOR term but Minor Premise doesn't ('T' or 'F'): ","F",
                        textinput(response, upcase(response) = target),
                        "No.  Try again or type 'H' for help.",
                        help("'..distributes..' = '..refers to ALL members of the class named by..'"));
                        outline("Right!");
                        Outimage;

                        IF NOT aristotelian THEN
                        BEGIN
                           outsyllogism;
                           IF fallacyflags[8] THEN target:- Copy("T")
                           ELSE target:- Copy("F");
                           request("(8) Both premises universal, yet conclusion is particular ('T' or 'F'): ","F",
                           textinput(response, upcase(response) = target),
                           "No.",
                           nohelp);
                           outline("Right!");
                           Outimage;
                        END;
                     END;

                     Outtext("You worked through these questions in ");
                     Outint(Entier(clocktime)-contacttime,6);
                     Outtext(" seconds.");
                     Outimage;
                     outline("Now it's time to summarize our findings:")
                  END NOT justtesting;

                  outsyllogism;
                  outdiagram;
                  Outimage;

                  request("Want VENN to try to make up a counterexample ('yes' or 'no')? ",
                  "yes", boolinput(toggle),
                  "Huh?  Type 'H' for help.",
                  help("A syllogism of the same form with true premises and a false conclusion."));

                  IF toggle THEN
                  BEGIN
                     CLASS counterterms;
                     COMMENT---------------------------------------------------------------------
                     This CLASS implements a heuristic search for a set of three terms which, when
                     substituted for the original three terms of a syllogism, will make both its
                     premises true and its conclusion false.  The most promising size combinations
                     of subject and predicate classes for each statement are already known and
                     stored by "makesyllogism" in the variables "truemajorpairs," "trueminorpairs,"
                     "falseconpairs."  (See comment at the first occurrence of "truemajorpairs:-" for
                     further information about the content of these variables.)  This CLASS
                     object simply tries to find a set of three terms which will simultaneously
                     satisfy the size specifications of three pairs, one each from "truemajorpairs,"
                     "trueminorpairs," and "falseconpairs."  If it succeeds, the CLASS detaches and
                     a counterexample is generated with appropriate big, medium and little class terms.
                     (See comments embedded in CLASS "terms" above.)
                     ---------------------------------------------------------------------------;
                     BEGIN
                        INTEGER i, j;

                        BOOLEAN onematch, found;

                        CHARACTER ch, sizeofmajorclass, sizeofmiddleclass, sizeofminorclass;

                        PROCEDURE choose;
                        BEGIN
                           IF sizeofmajorclass = 'B' THEN countermajorterm:- pickterm(2)
                           ELSE IF sizeofmajorclass = 'M' THEN countermajorterm:- pickterm(3)
                           ELSE countermajorterm:- pickterm(4);
                           IF sizeofmiddleclass = 'B' THEN countermiddleterm:- pickterm(2)
                           ELSE IF sizeofmiddleclass = 'M' THEN countermiddleterm:- pickterm(3)
                           ELSE countermiddleterm:- pickterm(4);
                           IF sizeofminorclass = 'B' THEN counterminorterm:- pickterm(2)
                           ELSE IF sizeofminorclass = 'M' THEN counterminorterm:- pickterm(3)
                           ELSE counterminorterm:- pickterm(4);
                           IF (countermajorterm == countermiddleterm OR countermiddleterm == counterminorterm
                           OR countermajorterm == counterminorterm) THEN choose
                        END PR*CEDURE choose;

                        truemajorpairs.Setpos(1);
                        trueminorpairs.Setpos(1);
                        falseconpairs.Setpos(1);

                        IF valid THEN outline("You must be kidding.  It can't be done.")
                        ELSE WHILE falseconpairs.More DO
                        BEGIN
                           j:= j + 1;
                           falseconpairs.Getchar;
                           COMMENT This position is blank so we continue...;
                           sizeofminorclass:= falseconpairs.Getchar;
                           sizeofmajorclass:= falseconpairs.Getchar;
                           WHILE trueminorpairs.More DO
                           BEGIN
                              j:= j + 1;
                              trueminorpairs.Getchar;
                              COMMENT This position is blank so we continue...;
                              IF trueminorpairs.Getchar = sizeofminorclass THEN
                              BEGIN
                                 sizeofmiddleclass:= trueminorpairs.Getchar;
                                 WHILE truemajorpairs.More DO
                                 BEGIN
                                    i:= i + 1;
                                    truemajorpairs.Getchar;
                                    COMMENT This position is blank so we continue...;
                                    ch:= truemajorpairs.Getchar;
                                    IF ch = sizeofmajorclass AND truemajorpairs.Getchar = sizeofmiddleclass
                                    THEN
                                    BEGIN
                                       onematch:= found:= TRUE;
                                       choose;
                                       Detach;
                                       choose;
                                       COMMENT---------------------------------------------------------------------
                                       Before seeking new pair matches, VENN first tries different terms using current
                                       size data.
                                       -----------------------------------------------------------------------------;
                                       Detach;
                                       found:= FALSE
                                    END
                                 END;
                                 truemajorpairs.Setpos(1)
                              END
                              ELSE trueminorpairs.Getchar
                           END;
                           trueminorpairs.Setpos(1);
                        END;
                        IF NOT valid THEN
                        BEGIN
                           IF NOT onematch THEN
                           BEGIN
                              j:= i + j;
                              Outtext("After");
                              Outint(j,3);
                              Outtext(" tries,");
                              Outint(i,3);
                              Outtext(" of which almost succeeded,");
                              outline(" VENN ran out of ideas and gave up.");
                              Outimage
                           END
                           ELSE outline("VENN can't think of another one.  Sorry.")
                        END
                     END CLA*S match;

                     REF(counterterms) heuristic;
                     heuristic:- NEW counterterms;
                     INSPECT heuristic DO
                     WHILE found AND toggle DO
                     BEGIN
                        Outimage;
                        outline("The original syllogism was:");
                        outsyllogism;
                        outline("VENN proposes this as a counterexample:");
                        makecounterexample;
                        outcounterexample;

                        request("Want VENN to try to make up another counterexample ('yes' or 'no')? ",
                        "no", boolinput(toggle),
                        "Huh?", nohelp);

                        IF toggle THEN Resume(heuristic)
                     END
                  END;

                  request("Want to stop ('yes' or 'no')? ","no",
                  boolinput(quit),"Huh?  Type 'H' for help.",
                  help("'No' will end execution of the program."));

                  IF NOT quit THEN
                  BEGIN
                     request("Different syllogism this time ('yes' or 'no')? ","yes",
                     boolinput(toggle),
                     "Huh?  Type 'H' for help.",
                     help("'No' repeats the cycle on the current syllogism."));
                     IF NOT toggle THEN GOTO samesyllogism
                  END
               END INSP*CT ordinary syllogism;
            END "WHILE NOT quit DO" loop;
         END INSP*CT safmin;
      END INSP*CT termlist;
   END
END