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